sys/dev/video/cxm/cxm_i2c.c

   1 /*
   2  * Copyright (c) 2003, 2004, 2005
   3  *      John Wehle <john@feith.com>.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by John Wehle.
  16  * 4. The name of the author may not be used to endorse or promote products
  17  *    derived from this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  20  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  21  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  22  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
  23  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  24  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  25  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  27  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  28  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 /*
  33  * I2c routines for the Conexant MPEG-2 Codec driver.
  34  */
  35
  36 #include <sys/param.h>
  37 #include <sys/systm.h>
  38 #include <sys/malloc.h>
  39 #include <sys/conf.h>
  40 #include <sys/uio.h>
  41 #include <sys/kernel.h>
  42 #include <sys/module.h>
  43 #include <sys/poll.h>
  44 #include <sys/select.h>
  45 #include <sys/resource.h>
  46 #include <sys/bus.h>
  47 #include <sys/rman.h>
  48
  49 #include <machine/clock.h>
  50
  51 #include <bus/pci/pcireg.h>
  52 #include <bus/pci/pcivar.h>
  53
  54 #include <dev/video/cxm/cxm.h>
  55
  56 #include <bus/iicbus/iiconf.h>
  57
  58 #include "iicbb_if.h"
  59
  60
  61 static int      cxm_iic_probe(device_t dev);
  62 static int      cxm_iic_attach(device_t dev);
  63 static int      cxm_iic_detach(device_t dev);
  64 static void     cxm_iic_child_detached(device_t dev, device_t child);
  65
  66 static int      cxm_iic_callback(device_t, int, caddr_t *);
  67 static int      cxm_iic_reset(device_t, u_char, u_char, u_char *);
  68 #if 0
  69 static int      cxm_iic_getscl(device_t);
  70 #endif
  71 static int      cxm_iic_getsda(device_t);
  72 static void     cxm_iic_setscl(device_t, int);
  73 static void     cxm_iic_setsda(device_t, int);
  74 static void     cxm_iic_setlines(device_t, int, int);
  75
  76 static device_method_t cxm_iic_methods[] = {
  77         /* Device interface */
  78         DEVMETHOD(device_probe,         cxm_iic_probe),
  79         DEVMETHOD(device_attach,        cxm_iic_attach),
  80         DEVMETHOD(device_detach,        cxm_iic_detach),
  81
  82         /* bus interface */
  83         DEVMETHOD(bus_child_detached,   cxm_iic_child_detached),
  84         DEVMETHOD(bus_print_child,      bus_generic_print_child),
  85         DEVMETHOD(bus_driver_added,     bus_generic_driver_added),
  86
  87         /* iicbb interface */
  88         DEVMETHOD(iicbb_callback,       cxm_iic_callback),
  89         DEVMETHOD(iicbb_reset,          cxm_iic_reset),
  90         DEVMETHOD(iicbb_getdataline,    cxm_iic_getsda),
  91         DEVMETHOD(iicbb_setlines,       cxm_iic_setlines),
  92
  93         { 0, 0 }
  94 };
  95
  96 static driver_t cxm_iic_driver = {
  97         "cxm_iic",
  98         cxm_iic_methods,
  99         sizeof(struct cxm_iic_softc),
 100 };
 101
 102 static devclass_t cxm_iic_devclass;
 103
 104 MODULE_VERSION(cxm_iic, 1);
 105 DRIVER_MODULE(cxm_iic, cxm, cxm_iic_driver, cxm_iic_devclass, 0, 0);
 106
 107
 108 /*
 109  * the boot time probe routine.
 110  *
 111  * The cxm_iic device is only probed after it has
 112  * been established that the cxm device is present
 113  * which means that the cxm_iic device * must *
 114  * be present since it's built into the cxm hardware.
 115  */
 116 static int
 117 cxm_iic_probe(device_t dev)
 118 {
 119         device_set_desc(dev, "Conexant iTVC15 / iTVC16 I2C controller");
 120
 121         return 0;
 122 }
 123
 124
 125 /*
 126  * the attach routine.
 127  */
 128 static int
 129 cxm_iic_attach(device_t dev)
 130 {
 131         device_t *kids;
 132         device_t iicbus;
 133         int error;
 134         int numkids;
 135         int i;
 136         int unit;
 137         bus_space_handle_t *bhandlep;
 138         bus_space_tag_t *btagp;
 139         struct cxm_iic_softc *sc;
 140         device_t child;
 141
 142         /* Get the device data */
 143         sc = device_get_softc(dev);
 144         unit = device_get_unit(dev);
 145
 146         /* retrieve the cxm btag and bhandle */
 147         if (BUS_READ_IVAR(device_get_parent(dev), dev,
 148                           CXM_IVAR_BTAG, (uintptr_t *)&btagp)
 149             || BUS_READ_IVAR(device_get_parent(dev), dev,
 150                              CXM_IVAR_BHANDLE, (uintptr_t *)&bhandlep)) {
 151                 device_printf(dev,
 152                               "could not retrieve bus space information\n");
 153                 return ENXIO;
 154         }
 155
 156         sc->btag = *btagp;
 157         sc->bhandle = *bhandlep;
 158
 159         /* add bit-banging generic code onto cxm_iic interface */
 160         sc->iicbb = device_add_child(dev, "iicbb", -1);
 161
 162         if (!sc->iicbb) {
 163                 device_printf(dev, "could not add iicbb\n");
 164                 return ENXIO;
 165         }
 166
 167         /* probed and attached the bit-banging code */
 168         error = device_probe_and_attach(sc->iicbb);
 169
 170         if (error) {
 171                 device_printf(dev, "could not attach iicbb\n");
 172                 goto fail;
 173         }
 174
 175         /* locate iicbus which was attached by the bit-banging code */
 176         iicbus = NULL;
 177         device_get_children(sc->iicbb, &kids, &numkids);
 178         for (i = 0; i < numkids; i++)
 179                 if (strcmp(device_get_name(kids[i]), "iicbus") == 0) {
 180                         iicbus = kids[i];
 181                         break;
 182                 }
 183         kfree(kids, M_TEMP);
 184
 185         if (!iicbus) {
 186                 device_printf(dev, "could not find iicbus\n");
 187                 error = ENXIO;
 188                 goto fail;
 189         }
 190
 191         if (BUS_WRITE_IVAR(device_get_parent(dev), dev,
 192                            CXM_IVAR_IICBUS, (uintptr_t)&iicbus)) {
 193                 device_printf(dev, "could not store iicbus information\n");
 194                 error = ENXIO;
 195                 goto fail;
 196         }
 197
 198         return 0;
 199
 200 fail:
 201         /*
 202          * Detach the children before recursively deleting
 203          * in case a child has a pointer to a grandchild
 204          * which is used by the child's detach routine.
 205          *
 206          * Remember the child before detaching so we can
 207          * delete it (bus_generic_detach indirectly zeroes
 208          * sc->child_dev).
 209          */
 210         child = sc->iicbb;
 211         bus_generic_detach(dev);
 212         if (child)
 213                 device_delete_child(dev, child);
 214
 215         return error;
 216 }
 217
 218
 219 /*
 220  * the detach routine.
 221  */
 222 static int
 223 cxm_iic_detach(device_t dev)
 224 {
 225         struct cxm_iic_softc *sc;
 226         device_t child;
 227
 228         /* Get the device data */
 229         sc = device_get_softc(dev);
 230
 231         BUS_WRITE_IVAR(device_get_parent(dev), dev, CXM_IVAR_IICBUS, 0);
 232
 233         /*
 234          * Detach the children before recursively deleting
 235          * in case a child has a pointer to a grandchild
 236          * which is used by the child's detach routine.
 237          *
 238          * Remember the child before detaching so we can
 239          * delete it (bus_generic_detach indirectly zeroes
 240          * sc->child_dev).
 241          */
 242         child = sc->iicbb;
 243         bus_generic_detach(dev);
 244         if (child)
 245                 device_delete_child(dev, child);
 246
 247         return 0;
 248 }
 249
 250
 251 /*
 252  * the child detached routine.
 253  */
 254 static void
 255 cxm_iic_child_detached(device_t dev, device_t child)
 256 {
 257         struct cxm_iic_softc *sc;
 258
 259         /* Get the device data */
 260         sc = device_get_softc(dev);
 261
 262         if (child == sc->iicbb)
 263                 sc->iicbb = NULL;
 264 }
 265
 266
 267 static int
 268 cxm_iic_callback(device_t dev, int index, caddr_t *data)
 269 {
 270         return 0;
 271 }
 272
 273
 274 static int
 275 cxm_iic_reset(device_t dev, u_char speed, u_char addr, u_char * oldaddr)
 276 {
 277         struct cxm_iic_softc *sc;
 278
 279         /* Get the device data */
 280         sc = (struct cxm_iic_softc *)device_get_softc(dev);
 281
 282         /* Set scl to 1 */
 283         CSR_WRITE_4(sc, CXM_REG_I2C_SETSCL, ~(int)1);
 284
 285         /* Set sda to 1 */
 286         CSR_WRITE_4(sc, CXM_REG_I2C_SETSDA, ~(int)1);
 287
 288         /*
 289          * PCI writes may be buffered so force the
 290          * write to complete by reading the last
 291          * location written.
 292          */
 293
 294         CSR_READ_4(sc, CXM_REG_I2C_SETSDA);
 295
 296         /* Wait for 10 usec */
 297         DELAY(10);
 298
 299         return IIC_ENOADDR;
 300 }
 301
 302
 303 #if 0
 304 static int
 305 cxm_iic_getscl(device_t dev)
 306 {
 307         struct cxm_iic_softc *sc;
 308
 309         /* Get the device data */
 310         sc = (struct cxm_iic_softc *)device_get_softc(dev);
 311
 312         /* Get sda */
 313         return CSR_READ_1(sc, CXM_REG_I2C_GETSCL);
 314 }
 315 #endif
 316
 317
 318 static int
 319 cxm_iic_getsda(device_t dev)
 320 {
 321         struct cxm_iic_softc *sc;
 322
 323         /* Get the device data */
 324         sc = (struct cxm_iic_softc *)device_get_softc(dev);
 325
 326         /* Get sda */
 327         return CSR_READ_1(sc, CXM_REG_I2C_GETSDA);
 328 }
 329
 330
 331 static void
 332 cxm_iic_setscl(device_t dev, int val)
 333 {
 334         struct cxm_iic_softc *sc;
 335
 336         /* Get the device data */
 337         sc = (struct cxm_iic_softc *)device_get_softc(dev);
 338
 339         /* Set scl to the requested value */
 340         CSR_WRITE_4(sc, CXM_REG_I2C_SETSCL, ~(int)(val ? 1 : 0));
 341
 342         /*
 343          * PCI writes may be buffered so force the
 344          * write to complete by reading the last
 345          * location written.
 346          */
 347
 348         CSR_READ_4(sc, CXM_REG_I2C_SETSCL);
 349 }
 350
 351
 352 static void
 353 cxm_iic_setsda(device_t dev, int val)
 354 {
 355         struct cxm_iic_softc *sc;
 356
 357         /* Get the device data */
 358         sc = (struct cxm_iic_softc *)device_get_softc(dev);
 359
 360         /* Set sda to the requested value */
 361         CSR_WRITE_4(sc, CXM_REG_I2C_SETSDA, ~(int)(val ? 1 : 0));
 362
 363         /*
 364          * PCI writes may be buffered so force the
 365          * write to complete by reading the last
 366          * location written.
 367          */
 368
 369         CSR_READ_4(sc, CXM_REG_I2C_SETSDA);
 370 }
 371
 372
 373 static void
 374 cxm_iic_setlines(device_t dev, int ctrl, int data)
 375 {
 376
 377         cxm_iic_setscl(dev, ctrl);
 378         cxm_iic_setsda(dev, data);
 379
 380         /* Wait for 10 usec */
 381         DELAY(10);
 382 }