sys/dev/bktr/bktr_i2c.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 1998, 2001 Nicolas Souchu
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 /*
  33  * I2C support for the bti2c chipset.
  34  *
  35  * From brooktree848.c <fsmp@freefall.org>
  36  */
  37
  38 #include "opt_bktr.h"
  39
  40 #include <sys/param.h>
  41 #include <sys/kernel.h>
  42 #include <sys/malloc.h>
  43 #include <sys/systm.h>
  44 #include <sys/module.h>
  45 #include <sys/bus.h>
  46 #include <sys/uio.h>
  47
  48 #if __FreeBSD_version < 500014
  49 #include <sys/select.h>
  50 #else
  51 #include <sys/selinfo.h>
  52 #endif
  53
  54 #if (__FreeBSD_version < 500000)
  55 #include <pci/pcivar.h>
  56 #include <pci/pcireg.h>
  57 #else
  58 #include <dev/pci/pcivar.h>
  59 #include <dev/pci/pcireg.h>
  60 #endif
  61
  62 #include <machine/bus.h>
  63 #include <sys/bus.h>
  64
  65 #include <dev/bktr/ioctl_meteor.h>
  66 #include <dev/bktr/ioctl_bt848.h>       /* extensions to ioctl_meteor.h */
  67 #include <dev/bktr/bktr_reg.h>
  68 #include <dev/bktr/bktr_i2c.h>
  69
  70 #include <dev/smbus/smbconf.h>
  71 #include <dev/iicbus/iiconf.h>
  72
  73 /* Compilation is void if BKTR_USE_FREEBSD_SMBUS is not
  74  * defined. This allows bktr owners to have smbus active for there
  75  * motherboard and still use their bktr without smbus.
  76  */
  77 #if defined(BKTR_USE_FREEBSD_SMBUS)
  78
  79 #define BTI2C_DEBUG(x)  if (bti2c_debug) (x)
  80 static int bti2c_debug = 0;
  81
  82 /*
  83  * Call this to pass the address of the bktr device to the
  84  * bti2c_i2c layer and initialize all the I2C bus architecture
  85  */
  86 int bt848_i2c_attach(device_t dev)
  87 {
  88         struct bktr_softc *bktr_sc = (struct bktr_softc *)device_get_softc(dev);
  89         struct bktr_i2c_softc *sc = &bktr_sc->i2c_sc;
  90
  91         sc->smbus = device_add_child(dev, "smbus", -1);
  92         sc->iicbb = device_add_child(dev, "iicbb", -1);
  93
  94         if (!sc->iicbb || !sc->smbus)
  95                 return ENXIO;
  96
  97         bus_generic_attach(dev);
  98
  99         return (0);
 100 };
 101
 102 int bt848_i2c_detach(device_t dev)
 103 {
 104         struct bktr_softc *bktr_sc = (struct bktr_softc *)device_get_softc(dev);
 105         struct bktr_i2c_softc *sc = &bktr_sc->i2c_sc;
 106         int error = 0;
 107
 108         if ((error = bus_generic_detach(dev)))
 109                 goto error;
 110
 111         if (sc->iicbb && (error = device_delete_child(dev, sc->iicbb)))
 112                 goto error;
 113
 114         if (sc->smbus && (error = device_delete_child(dev, sc->smbus)))
 115                 goto error;
 116
 117 error:
 118         return (error);
 119 }
 120
 121 int bti2c_smb_callback(device_t dev, int index, void *data)
 122 {
 123         struct bktr_softc *bktr_sc = (struct bktr_softc *)device_get_softc(dev);
 124         struct bktr_i2c_softc *sc = &bktr_sc->i2c_sc;
 125         int error = 0;
 126
 127         /* test each time if we already have/haven't the iicbus
 128          * to avoid deadlocks
 129          */
 130         switch (index) {
 131         case SMB_REQUEST_BUS:
 132                 /* XXX test & set */
 133                 mtx_lock(&Giant);
 134                 if (!sc->bus_owned) {
 135                         sc->bus_owned = 1;
 136                 } else
 137                         error = EWOULDBLOCK;
 138                 mtx_unlock(&Giant);
 139                 break;
 140
 141         case SMB_RELEASE_BUS:
 142                 /* XXX test & set */
 143                 mtx_lock(&Giant);
 144                 if (sc->bus_owned) {
 145                         sc->bus_owned = 0;
 146                 } else
 147                         error = EINVAL;
 148                 mtx_unlock(&Giant);
 149                 break;
 150
 151         default:
 152                 error = EINVAL;
 153         }
 154
 155         return (error);
 156 }
 157
 158 int bti2c_iic_callback(device_t dev, int index, caddr_t *data)
 159 {
 160         struct bktr_softc *bktr_sc = (struct bktr_softc *)device_get_softc(dev);
 161         struct bktr_i2c_softc *sc = &bktr_sc->i2c_sc;
 162         int error = 0;
 163
 164         /* test each time if we already have/haven't the smbus
 165          * to avoid deadlocks
 166          */
 167         switch (index) {
 168         case IIC_REQUEST_BUS:
 169                 /* XXX test & set */
 170                 mtx_lock(&Giant);
 171                 if (!sc->bus_owned) {
 172                         sc->bus_owned = 1;
 173                 } else
 174                         error = EWOULDBLOCK;
 175                 mtx_unlock(&Giant);
 176                 break;
 177
 178         case IIC_RELEASE_BUS:
 179                 /* XXX test & set */
 180                 mtx_lock(&Giant);
 181                 if (sc->bus_owned) {
 182                         sc->bus_owned = 0;
 183                 } else
 184                         error = EINVAL;
 185                 mtx_unlock(&Giant);
 186                 break;
 187
 188         default:
 189                 error = EINVAL;
 190         }
 191
 192         return (error);
 193 }
 194
 195 int bti2c_iic_reset(device_t dev, u_char speed, u_char addr, u_char * oldaddr)
 196 {
 197         mtx_lock(&Giant);
 198         if (oldaddr)
 199                 *oldaddr = 0;                   /* XXX */
 200         mtx_unlock(&Giant);
 201
 202         return (IIC_ENOADDR);
 203 }
 204
 205 void bti2c_iic_setsda(device_t dev, int val)
 206 {
 207         struct bktr_softc *sc  = (struct bktr_softc *)device_get_softc(dev);
 208         int clock;
 209
 210         mtx_lock(&Giant);
 211         clock = INL(sc, BKTR_I2C_DATA_CTL) & 0x2;
 212
 213         if (val)
 214                 OUTL(sc, BKTR_I2C_DATA_CTL, clock | 1);
 215         else
 216                 OUTL(sc, BKTR_I2C_DATA_CTL, clock);
 217         mtx_unlock(&Giant);
 218
 219         return;
 220 }
 221
 222 void bti2c_iic_setscl(device_t dev, int val)
 223 {
 224         struct bktr_softc *sc  = (struct bktr_softc *)device_get_softc(dev);
 225         int data;
 226
 227         mtx_lock(&Giant);
 228         data = INL(sc, BKTR_I2C_DATA_CTL) & 0x1;
 229
 230         if (val)
 231                 OUTL(sc, BKTR_I2C_DATA_CTL, 0x2 | data);
 232         else
 233                 OUTL(sc, BKTR_I2C_DATA_CTL, data);
 234         mtx_unlock(&Giant);
 235
 236         return;
 237 }
 238
 239 int
 240 bti2c_iic_getsda(device_t dev)
 241 {
 242         struct bktr_softc *sc  = (struct bktr_softc *)device_get_softc(dev);
 243         int retval;
 244
 245         mtx_lock(&Giant);
 246         retval = INL(sc,BKTR_I2C_DATA_CTL) & 0x1;
 247         mtx_unlock(&Giant);
 248         return (retval);
 249 }
 250
 251 int
 252 bti2c_iic_getscl(device_t dev)
 253 {
 254         return (0);
 255 }
 256
 257 static int
 258 bti2c_write(struct bktr_softc *sc, u_long data)
 259 {
 260         u_long          x;
 261
 262         mtx_lock(&Giant);
 263
 264         /* clear status bits */
 265         OUTL(sc, BKTR_INT_STAT, (BT848_INT_RACK | BT848_INT_I2CDONE));
 266
 267         BTI2C_DEBUG(printf("w%lx", data));
 268
 269         /* write the address and data */
 270         OUTL(sc, BKTR_I2C_DATA_CTL, data);
 271
 272         /* wait for completion */
 273         for ( x = 0x7fffffff; x; --x ) {        /* safety valve */
 274                 if ( INL(sc, BKTR_INT_STAT) & BT848_INT_I2CDONE )
 275                         break;
 276         }
 277
 278         /* check for ACK */
 279         if ( !x || !( INL(sc, BKTR_INT_STAT) & BT848_INT_RACK) ) {
 280                 BTI2C_DEBUG(printf("%c%c", (!x)?'+':'-',
 281                         (!( INL(sc, BKTR_INT_STAT) & BT848_INT_RACK))?'+':'-'));
 282                 mtx_unlock(&Giant);
 283                 return (SMB_ENOACK);
 284         }
 285         BTI2C_DEBUG(printf("+"));
 286         mtx_unlock(&Giant);
 287
 288         /* return OK */
 289         return( 0 );
 290 }
 291
 292 int
 293 bti2c_smb_writeb(device_t dev, u_char slave, char cmd, char byte)
 294 {
 295         struct bktr_softc *sc  = (struct bktr_softc *)device_get_softc(dev);
 296         u_long data;
 297
 298         data = ((slave & 0xff) << 24) | ((byte & 0xff) << 16) | (u_char)cmd;
 299
 300         return (bti2c_write(sc, data));
 301 }
 302
 303 /*
 304  * byte1 becomes low byte of word
 305  * byte2 becomes high byte of word
 306  */
 307 int
 308 bti2c_smb_writew(device_t dev, u_char slave, char cmd, short word)
 309 {
 310         struct bktr_softc *sc  = (struct bktr_softc *)device_get_softc(dev);
 311         u_long data;
 312         char low, high;
 313
 314         low = (char)(word & 0xff);
 315         high = (char)((word & 0xff00) >> 8);
 316
 317         data = ((slave & 0xff) << 24) | ((low & 0xff) << 16) |
 318                 ((high & 0xff) << 8) | BT848_DATA_CTL_I2CW3B | (u_char)cmd;
 319
 320         return (bti2c_write(sc, data));
 321 }
 322
 323 /*
 324  * The Bt878 and Bt879 differed on the treatment of i2c commands
 325  */
 326 int
 327 bti2c_smb_readb(device_t dev, u_char slave, char cmd, char *byte)
 328 {
 329         struct bktr_softc *sc  = (struct bktr_softc *)device_get_softc(dev);
 330         u_long          x;
 331
 332         mtx_lock(&Giant);
 333         /* clear status bits */
 334         OUTL(sc,BKTR_INT_STAT, (BT848_INT_RACK | BT848_INT_I2CDONE));
 335
 336         OUTL(sc,BKTR_I2C_DATA_CTL, ((slave & 0xff) << 24) | (u_char)cmd);
 337
 338         BTI2C_DEBUG(printf("r%lx/", (u_long)(((slave & 0xff) << 24) | (u_char)cmd)));
 339
 340         /* wait for completion */
 341         for ( x = 0x7fffffff; x; --x ) {        /* safety valve */
 342                 if ( INL(sc,BKTR_INT_STAT) & BT848_INT_I2CDONE )
 343                         break;
 344         }
 345
 346         /* check for ACK */
 347         if ( !x || !(INL(sc,BKTR_INT_STAT) & BT848_INT_RACK) ) {
 348                 BTI2C_DEBUG(printf("r%c%c", (!x)?'+':'-',
 349                         (!( INL(sc,BKTR_INT_STAT) & BT848_INT_RACK))?'+':'-'));
 350                 mtx_unlock(&Giant);
 351                 return (SMB_ENOACK);
 352         }
 353
 354         *byte = (char)((INL(sc,BKTR_I2C_DATA_CTL) >> 8) & 0xff);
 355         BTI2C_DEBUG(printf("r%x+", *byte));
 356         mtx_unlock(&Giant);
 357
 358         return (0);
 359 }
 360
 361 DRIVER_MODULE(iicbb, bktr, iicbb_driver, iicbb_devclass, 0, 0);
 362 DRIVER_MODULE(smbus, bktr, smbus_driver, smbus_devclass, 0, 0);
 363
 364 #endif /* defined(BKTR_USE_FREEBSD_SMBUS) */