1 /*- 2 * Copyright (c) 2001 Tsubai Masanari. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 1. Redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer. 9 * 2. Redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution. 12 * 3. The name of the author may not be used to endorse or promote products 13 * derived from this software without specific prior written permission. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 24 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 * 26 * $FreeBSD$ 27 * NetBSD: ki2c.c,v 1.11 2007/12/06 17:00:33 ad Exp 28 * Id: ki2c.c,v 1.7 2002/10/05 09:56:05 tsubai Exp 29 */ 30 31 /* 32 * Support routines for the Keywest I2C controller. 33 */ 34 35 #include <sys/param.h> 36 #include <sys/systm.h> 37 #include <sys/kernel.h> 38 #include <sys/module.h> 39 #include <sys/bus.h> 40 #include <sys/lock.h> 41 #include <sys/mutex.h> 42 #include <machine/resource.h> 43 #include <machine/bus.h> 44 #include <sys/rman.h> 45 46 #include <dev/iicbus/iicbus.h> 47 #include <dev/iicbus/iiconf.h> 48 #include <dev/ofw/ofw_bus.h> 49 #include "iicbus_if.h" 50 51 /* Keywest I2C Register offsets */ 52 #define MODE 0 53 #define CONTROL 1 54 #define STATUS 2 55 #define ISR 3 56 #define IER 4 57 #define ADDR 5 58 #define SUBADDR 6 59 #define DATA 7 60 61 /* MODE */ 62 #define I2C_SPEED 0x03 /* Speed mask */ 63 #define I2C_100kHz 0x00 64 #define I2C_50kHz 0x01 65 #define I2C_25kHz 0x02 66 #define I2C_MODE 0x0c /* Mode mask */ 67 #define I2C_DUMBMODE 0x00 /* Dumb mode */ 68 #define I2C_STDMODE 0x04 /* Standard mode */ 69 #define I2C_STDSUBMODE 0x08 /* Standard mode + sub address */ 70 #define I2C_COMBMODE 0x0c /* Combined mode */ 71 #define I2C_PORT 0xf0 /* Port mask */ 72 73 /* CONTROL */ 74 #define I2C_CT_AAK 0x01 /* Send AAK */ 75 #define I2C_CT_ADDR 0x02 /* Send address(es) */ 76 #define I2C_CT_STOP 0x04 /* Send STOP */ 77 #define I2C_CT_START 0x08 /* Send START */ 78 79 /* STATUS */ 80 #define I2C_ST_BUSY 0x01 /* Busy */ 81 #define I2C_ST_LASTAAK 0x02 /* Last AAK */ 82 #define I2C_ST_LASTRW 0x04 /* Last R/W */ 83 #define I2C_ST_SDA 0x08 /* SDA */ 84 #define I2C_ST_SCL 0x10 /* SCL */ 85 86 /* ISR/IER */ 87 #define I2C_INT_DATA 0x01 /* Data byte sent/received */ 88 #define I2C_INT_ADDR 0x02 /* Address sent */ 89 #define I2C_INT_STOP 0x04 /* STOP condition sent */ 90 #define I2C_INT_START 0x08 /* START condition sent */ 91 92 /* I2C flags */ 93 #define I2C_BUSY 0x01 94 #define I2C_READING 0x02 95 #define I2C_ERROR 0x04 96 #define I2C_SELECTED 0x08 97 98 struct kiic_softc { 99 device_t sc_dev; 100 phandle_t sc_node; 101 struct mtx sc_mutex; 102 struct resource *sc_reg; 103 int sc_irqrid; 104 struct resource *sc_irq; 105 void *sc_ih; 106 u_int sc_regstep; 107 u_int sc_flags; 108 u_char *sc_data; 109 int sc_resid; 110 device_t sc_iicbus; 111 }; 112 113 static int kiic_probe(device_t dev); 114 static int kiic_attach(device_t dev); 115 static void kiic_writereg(struct kiic_softc *sc, u_int, u_int); 116 static u_int kiic_readreg(struct kiic_softc *, u_int); 117 static void kiic_setmode(struct kiic_softc *, u_int); 118 static void kiic_setspeed(struct kiic_softc *, u_int); 119 static void kiic_intr(void *xsc); 120 static int kiic_transfer(device_t dev, struct iic_msg *msgs, 121 uint32_t nmsgs); 122 static phandle_t kiic_get_node(device_t bus, device_t dev); 123 124 static device_method_t kiic_methods[] = { 125 /* device interface */ 126 DEVMETHOD(device_probe, kiic_probe), 127 DEVMETHOD(device_attach, kiic_attach), 128 129 /* iicbus interface */ 130 DEVMETHOD(iicbus_callback, iicbus_null_callback), 131 DEVMETHOD(iicbus_transfer, kiic_transfer), 132 133 /* ofw_bus interface */ 134 DEVMETHOD(ofw_bus_get_node, kiic_get_node), 135 136 { 0, 0 } 137 }; 138 139 static driver_t kiic_driver = { 140 "iichb", 141 kiic_methods, 142 sizeof(struct kiic_softc) 143 }; 144 static devclass_t kiic_devclass; 145 146 DRIVER_MODULE(kiic, macio, kiic_driver, kiic_devclass, 0, 0); 147 148 static int 149 kiic_probe(device_t self) 150 { 151 const char *name; 152 153 name = ofw_bus_get_name(self); 154 if (name && strcmp(name, "i2c") == 0) { 155 device_set_desc(self, "Keywest I2C controller"); 156 return (0); 157 } 158 159 return (ENXIO); 160 } 161 162 static int 163 kiic_attach(device_t self) 164 { 165 struct kiic_softc *sc = device_get_softc(self); 166 int rid, rate; 167 phandle_t node; 168 char name[64]; 169 170 bzero(sc, sizeof(*sc)); 171 sc->sc_dev = self; 172 173 node = ofw_bus_get_node(self); 174 if (node == 0 || node == -1) { 175 return (EINVAL); 176 } 177 178 rid = 0; 179 sc->sc_reg = bus_alloc_resource_any(self, SYS_RES_MEMORY, 180 &rid, RF_ACTIVE); 181 if (sc->sc_reg == NULL) { 182 return (ENOMEM); 183 } 184 185 if (OF_getprop(node, "AAPL,i2c-rate", &rate, 4) != 4) { 186 device_printf(self, "cannot get i2c-rate\n"); 187 return (ENXIO); 188 } 189 if (OF_getprop(node, "AAPL,address-step", &sc->sc_regstep, 4) != 4) { 190 device_printf(self, "unable to find i2c address step\n"); 191 return (ENXIO); 192 } 193 194 /* 195 * Some Keywest I2C devices have their children attached directly 196 * underneath them. Some have a single 'iicbus' child with the 197 * devices underneath that. Sort this out, and make sure that the 198 * OFW I2C layer has the correct node. 199 */ 200 201 sc->sc_node = OF_child(node); 202 if (OF_getprop(sc->sc_node,"name",name,sizeof(name)) > 0) { 203 if (strcmp(name,"i2c-bus") != 0) 204 sc->sc_node = node; 205 } 206 207 mtx_init(&sc->sc_mutex, "kiic", NULL, MTX_DEF); 208 209 sc->sc_irq = bus_alloc_resource_any(self, SYS_RES_IRQ, &sc->sc_irqrid, 210 RF_ACTIVE); 211 bus_setup_intr(self, sc->sc_irq, INTR_TYPE_MISC | INTR_MPSAFE, NULL, 212 kiic_intr, sc, &sc->sc_ih); 213 214 kiic_writereg(sc, STATUS, 0); 215 kiic_writereg(sc, ISR, 0); 216 kiic_writereg(sc, IER, 0); 217 218 kiic_setmode(sc, I2C_STDMODE); 219 kiic_setspeed(sc, I2C_100kHz); /* XXX rate */ 220 221 kiic_writereg(sc, IER, I2C_INT_DATA | I2C_INT_ADDR | I2C_INT_STOP); 222 223 /* Add the IIC bus layer */ 224 sc->sc_iicbus = device_add_child(self, "iicbus", -1); 225 226 return (bus_generic_attach(self)); 227 } 228 229 static void 230 kiic_writereg(struct kiic_softc *sc, u_int reg, u_int val) 231 { 232 bus_write_1(sc->sc_reg, sc->sc_regstep * reg, val); 233 DELAY(10); /* register access delay */ 234 } 235 236 static u_int 237 kiic_readreg(struct kiic_softc *sc, u_int reg) 238 { 239 return bus_read_1(sc->sc_reg, sc->sc_regstep * reg); 240 } 241 242 static void 243 kiic_setmode(struct kiic_softc *sc, u_int mode) 244 { 245 u_int x; 246 247 KASSERT((mode & ~I2C_MODE) == 0, ("bad mode")); 248 x = kiic_readreg(sc, MODE); 249 x &= ~I2C_MODE; 250 x |= mode; 251 kiic_writereg(sc, MODE, x); 252 } 253 254 static void 255 kiic_setspeed(struct kiic_softc *sc, u_int speed) 256 { 257 u_int x; 258 259 KASSERT((speed & ~I2C_SPEED) == 0, ("bad speed")); 260 x = kiic_readreg(sc, MODE); 261 x &= ~I2C_SPEED; 262 x |= speed; 263 kiic_writereg(sc, MODE, x); 264 } 265 266 static void 267 kiic_intr(void *xsc) 268 { 269 struct kiic_softc *sc = xsc; 270 u_int isr; 271 uint32_t x; 272 273 mtx_lock(&sc->sc_mutex); 274 isr = kiic_readreg(sc, ISR); 275 276 if (isr & I2C_INT_ADDR) { 277 sc->sc_flags |= I2C_SELECTED; 278 279 if (sc->sc_flags & I2C_READING) { 280 if (sc->sc_resid > 1) { 281 x = kiic_readreg(sc, CONTROL); 282 x |= I2C_CT_AAK; 283 kiic_writereg(sc, CONTROL, x); 284 } 285 } else { 286 kiic_writereg(sc, DATA, *sc->sc_data++); 287 sc->sc_resid--; 288 } 289 } 290 291 if (isr & I2C_INT_DATA) { 292 if (sc->sc_flags & I2C_READING) { 293 if (sc->sc_resid > 0) { 294 *sc->sc_data++ = kiic_readreg(sc, DATA); 295 sc->sc_resid--; 296 } 297 298 } else { 299 if (sc->sc_resid == 0) { 300 x = kiic_readreg(sc, CONTROL); 301 x |= I2C_CT_STOP; 302 kiic_writereg(sc, CONTROL, x); 303 } else { 304 kiic_writereg(sc, DATA, *sc->sc_data++); 305 sc->sc_resid--; 306 } 307 } 308 } 309 310 if (isr & I2C_INT_STOP) { 311 kiic_writereg(sc, CONTROL, 0); 312 sc->sc_flags &= ~I2C_SELECTED; 313 wakeup(sc->sc_dev); 314 } 315 316 kiic_writereg(sc, ISR, isr); 317 mtx_unlock(&sc->sc_mutex); 318 } 319 320 static int 321 kiic_transfer(device_t dev, struct iic_msg *msgs, uint32_t nmsgs) 322 { 323 struct kiic_softc *sc; 324 int i, x, timo, err; 325 uint8_t addr; 326 327 sc = device_get_softc(dev); 328 timo = 100; 329 330 mtx_lock(&sc->sc_mutex); 331 332 if (sc->sc_flags & I2C_BUSY) 333 mtx_sleep(dev, &sc->sc_mutex, 0, "kiic", timo); 334 335 if (sc->sc_flags & I2C_BUSY) { 336 mtx_unlock(&sc->sc_mutex); 337 return (ETIMEDOUT); 338 } 339 340 sc->sc_flags = I2C_BUSY; 341 342 for (i = 0; i < nmsgs; i++) { 343 sc->sc_data = msgs[i].buf; 344 sc->sc_resid = msgs[i].len; 345 sc->sc_flags = I2C_BUSY; 346 addr = msgs[i].slave; 347 timo = 1000 + sc->sc_resid * 200; 348 timo += 100000; 349 350 if (msgs[i].flags & IIC_M_RD) { 351 sc->sc_flags |= I2C_READING; 352 addr |= 1; 353 } 354 355 kiic_writereg(sc, ADDR, addr); 356 kiic_writereg(sc, SUBADDR, 0x04); 357 358 x = kiic_readreg(sc, CONTROL) | I2C_CT_ADDR; 359 kiic_writereg(sc, CONTROL, x); 360 361 err = mtx_sleep(dev, &sc->sc_mutex, 0, "kiic", timo); 362 363 msgs[i].len -= sc->sc_resid; 364 365 if ((sc->sc_flags & I2C_ERROR) || err == EWOULDBLOCK) { 366 device_printf(sc->sc_dev, "I2C error\n"); 367 sc->sc_flags = 0; 368 mtx_unlock(&sc->sc_mutex); 369 return (-1); 370 } 371 } 372 373 sc->sc_flags = 0; 374 375 mtx_unlock(&sc->sc_mutex); 376 377 return (0); 378 } 379 380 static phandle_t 381 kiic_get_node(device_t bus, device_t dev) 382 { 383 struct kiic_softc *sc; 384 385 sc = device_get_softc(bus); 386 /* We only have one child, the I2C bus, which needs our own node. */ 387 388 return sc->sc_node; 389 } 390 391