1 /*- 2 * Copyright (c) 1998, 2001 Nicolas Souchu 3 * 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 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 * 26 * $FreeBSD$ 27 * 28 */ 29 #include <sys/param.h> 30 #include <sys/bus.h> 31 #include <sys/conf.h> 32 #include <sys/fcntl.h> 33 #include <sys/lock.h> 34 #include <sys/kernel.h> 35 #include <sys/malloc.h> 36 #include <sys/module.h> 37 #include <sys/sx.h> 38 #include <sys/systm.h> 39 #include <sys/uio.h> 40 41 #include <dev/iicbus/iiconf.h> 42 #include <dev/iicbus/iicbus.h> 43 #include <dev/iicbus/iic.h> 44 45 #include "iicbus_if.h" 46 47 #define BUFSIZE 1024 48 49 struct iic_softc { 50 51 device_t sc_dev; 52 u_char sc_addr; /* 7 bit address on iicbus */ 53 int sc_count; /* >0 if device opened */ 54 55 char sc_buffer[BUFSIZE]; /* output buffer */ 56 char sc_inbuf[BUFSIZE]; /* input buffer */ 57 58 struct cdev *sc_devnode; 59 struct sx sc_lock; 60 }; 61 62 #define IIC_LOCK(sc) sx_xlock(&(sc)->sc_lock) 63 #define IIC_UNLOCK(sc) sx_xunlock(&(sc)->sc_lock) 64 65 static int iic_probe(device_t); 66 static int iic_attach(device_t); 67 static int iic_detach(device_t); 68 static void iic_identify(driver_t *driver, device_t parent); 69 70 static devclass_t iic_devclass; 71 72 static device_method_t iic_methods[] = { 73 /* device interface */ 74 DEVMETHOD(device_identify, iic_identify), 75 DEVMETHOD(device_probe, iic_probe), 76 DEVMETHOD(device_attach, iic_attach), 77 DEVMETHOD(device_detach, iic_detach), 78 79 /* iicbus interface */ 80 DEVMETHOD(iicbus_intr, iicbus_generic_intr), 81 82 { 0, 0 } 83 }; 84 85 static driver_t iic_driver = { 86 "iic", 87 iic_methods, 88 sizeof(struct iic_softc), 89 }; 90 91 static d_open_t iicopen; 92 static d_close_t iicclose; 93 static d_write_t iicwrite; 94 static d_read_t iicread; 95 static d_ioctl_t iicioctl; 96 97 static struct cdevsw iic_cdevsw = { 98 .d_version = D_VERSION, 99 .d_flags = D_TRACKCLOSE, 100 .d_open = iicopen, 101 .d_close = iicclose, 102 .d_read = iicread, 103 .d_write = iicwrite, 104 .d_ioctl = iicioctl, 105 .d_name = "iic", 106 }; 107 108 static void 109 iic_identify(driver_t *driver, device_t parent) 110 { 111 112 if (device_find_child(parent, "iic", -1) == NULL) 113 BUS_ADD_CHILD(parent, 0, "iic", -1); 114 } 115 116 static int 117 iic_probe(device_t dev) 118 { 119 if (iicbus_get_addr(dev) > 0) 120 return (ENXIO); 121 122 device_set_desc(dev, "I2C generic I/O"); 123 124 return (0); 125 } 126 127 static int 128 iic_attach(device_t dev) 129 { 130 struct iic_softc *sc = (struct iic_softc *)device_get_softc(dev); 131 132 sc->sc_dev = dev; 133 sx_init(&sc->sc_lock, "iic"); 134 sc->sc_devnode = make_dev(&iic_cdevsw, device_get_unit(dev), 135 UID_ROOT, GID_WHEEL, 136 0600, "iic%d", device_get_unit(dev)); 137 if (sc->sc_devnode == NULL) { 138 device_printf(dev, "failed to create character device\n"); 139 sx_destroy(&sc->sc_lock); 140 return (ENXIO); 141 } 142 sc->sc_devnode->si_drv1 = sc; 143 144 return (0); 145 } 146 147 static int 148 iic_detach(device_t dev) 149 { 150 struct iic_softc *sc = (struct iic_softc *)device_get_softc(dev); 151 152 if (sc->sc_devnode) 153 destroy_dev(sc->sc_devnode); 154 sx_destroy(&sc->sc_lock); 155 156 return (0); 157 } 158 159 static int 160 iicopen(struct cdev *dev, int flags, int fmt, struct thread *td) 161 { 162 struct iic_softc *sc = dev->si_drv1; 163 164 IIC_LOCK(sc); 165 if (sc->sc_count > 0) { 166 IIC_UNLOCK(sc); 167 return (EBUSY); 168 } 169 170 sc->sc_count++; 171 IIC_UNLOCK(sc); 172 173 return (0); 174 } 175 176 static int 177 iicclose(struct cdev *dev, int flags, int fmt, struct thread *td) 178 { 179 struct iic_softc *sc = dev->si_drv1; 180 181 IIC_LOCK(sc); 182 if (!sc->sc_count) { 183 /* XXX: I don't think this can happen. */ 184 IIC_UNLOCK(sc); 185 return (EINVAL); 186 } 187 188 sc->sc_count--; 189 190 if (sc->sc_count < 0) 191 panic("%s: iic_count < 0!", __func__); 192 IIC_UNLOCK(sc); 193 194 return (0); 195 } 196 197 static int 198 iicwrite(struct cdev *dev, struct uio * uio, int ioflag) 199 { 200 struct iic_softc *sc = dev->si_drv1; 201 device_t iicdev = sc->sc_dev; 202 int sent, error, count; 203 204 IIC_LOCK(sc); 205 if (!sc->sc_addr) { 206 IIC_UNLOCK(sc); 207 return (EINVAL); 208 } 209 210 if (sc->sc_count == 0) { 211 /* XXX: I don't think this can happen. */ 212 IIC_UNLOCK(sc); 213 return (EINVAL); 214 } 215 216 error = iicbus_request_bus(device_get_parent(iicdev), iicdev, 217 IIC_DONTWAIT); 218 if (error) { 219 IIC_UNLOCK(sc); 220 return (error); 221 } 222 223 count = min(uio->uio_resid, BUFSIZE); 224 uiomove(sc->sc_buffer, count, uio); 225 226 error = iicbus_block_write(device_get_parent(iicdev), sc->sc_addr, 227 sc->sc_buffer, count, &sent); 228 229 iicbus_release_bus(device_get_parent(iicdev), iicdev); 230 IIC_UNLOCK(sc); 231 232 return (error); 233 } 234 235 static int 236 iicread(struct cdev *dev, struct uio * uio, int ioflag) 237 { 238 struct iic_softc *sc = dev->si_drv1; 239 device_t iicdev = sc->sc_dev; 240 int len, error = 0; 241 int bufsize; 242 243 IIC_LOCK(sc); 244 if (!sc->sc_addr) { 245 IIC_UNLOCK(sc); 246 return (EINVAL); 247 } 248 249 if (sc->sc_count == 0) { 250 /* XXX: I don't think this can happen. */ 251 IIC_UNLOCK(sc); 252 return (EINVAL); 253 } 254 255 error = iicbus_request_bus(device_get_parent(iicdev), iicdev, 256 IIC_DONTWAIT); 257 if (error) { 258 IIC_UNLOCK(sc); 259 return (error); 260 } 261 262 /* max amount of data to read */ 263 len = min(uio->uio_resid, BUFSIZE); 264 265 error = iicbus_block_read(device_get_parent(iicdev), sc->sc_addr, 266 sc->sc_inbuf, len, &bufsize); 267 if (error) { 268 IIC_UNLOCK(sc); 269 return (error); 270 } 271 272 if (bufsize > uio->uio_resid) 273 panic("%s: too much data read!", __func__); 274 275 iicbus_release_bus(device_get_parent(iicdev), iicdev); 276 277 error = uiomove(sc->sc_inbuf, bufsize, uio); 278 IIC_UNLOCK(sc); 279 return (error); 280 } 281 282 static int 283 iicioctl(struct cdev *dev, u_long cmd, caddr_t data, int flags, struct thread *td) 284 { 285 struct iic_softc *sc = dev->si_drv1; 286 device_t iicdev = sc->sc_dev; 287 device_t parent = device_get_parent(iicdev); 288 struct iiccmd *s = (struct iiccmd *)data; 289 struct iic_rdwr_data *d = (struct iic_rdwr_data *)data; 290 struct iic_msg *m; 291 int error, count, i; 292 char *buf = NULL; 293 void **usrbufs = NULL; 294 295 if ((error = iicbus_request_bus(parent, iicdev, 296 (flags & O_NONBLOCK) ? IIC_DONTWAIT : (IIC_WAIT | IIC_INTR)))) 297 return (error); 298 299 switch (cmd) { 300 case I2CSTART: 301 IIC_LOCK(sc); 302 error = iicbus_start(parent, s->slave, 0); 303 304 /* 305 * Implicitly set the chip addr to the slave addr passed as 306 * parameter. Consequently, start/stop shall be called before 307 * the read or the write of a block. 308 */ 309 if (!error) 310 sc->sc_addr = s->slave; 311 IIC_UNLOCK(sc); 312 313 break; 314 315 case I2CSTOP: 316 error = iicbus_stop(parent); 317 break; 318 319 case I2CRSTCARD: 320 error = iicbus_reset(parent, IIC_UNKNOWN, 0, NULL); 321 break; 322 323 case I2CWRITE: 324 if (s->count <= 0) { 325 error = EINVAL; 326 break; 327 } 328 buf = malloc((unsigned long)s->count, M_TEMP, M_WAITOK); 329 error = copyin(s->buf, buf, s->count); 330 if (error) 331 break; 332 error = iicbus_write(parent, buf, s->count, &count, 10); 333 break; 334 335 case I2CREAD: 336 if (s->count <= 0) { 337 error = EINVAL; 338 break; 339 } 340 buf = malloc((unsigned long)s->count, M_TEMP, M_WAITOK); 341 error = iicbus_read(parent, buf, s->count, &count, s->last, 10); 342 if (error) 343 break; 344 error = copyout(buf, s->buf, s->count); 345 break; 346 347 case I2CRDWR: 348 buf = malloc(sizeof(*d->msgs) * d->nmsgs, M_TEMP, M_WAITOK); 349 usrbufs = malloc(sizeof(void *) * d->nmsgs, M_TEMP, M_ZERO | M_WAITOK); 350 error = copyin(d->msgs, buf, sizeof(*d->msgs) * d->nmsgs); 351 if (error) 352 break; 353 /* Alloc kernel buffers for userland data, copyin write data */ 354 for (i = 0; i < d->nmsgs; i++) { 355 m = &((struct iic_msg *)buf)[i]; 356 usrbufs[i] = m->buf; 357 m->buf = malloc(m->len, M_TEMP, M_WAITOK); 358 if (!(m->flags & IIC_M_RD)) 359 copyin(usrbufs[i], m->buf, m->len); 360 } 361 error = iicbus_transfer(iicdev, (struct iic_msg *)buf, d->nmsgs); 362 /* Copyout all read segments, free up kernel buffers */ 363 for (i = 0; i < d->nmsgs; i++) { 364 m = &((struct iic_msg *)buf)[i]; 365 if (m->flags & IIC_M_RD) 366 copyout(m->buf, usrbufs[i], m->len); 367 free(m->buf, M_TEMP); 368 } 369 free(usrbufs, M_TEMP); 370 break; 371 372 case I2CRPTSTART: 373 error = iicbus_repeated_start(parent, s->slave, 0); 374 break; 375 376 default: 377 error = ENOTTY; 378 } 379 380 iicbus_release_bus(parent, iicdev); 381 382 if (buf != NULL) 383 free(buf, M_TEMP); 384 return (error); 385 } 386 387 DRIVER_MODULE(iic, iicbus, iic_driver, iic_devclass, 0, 0); 388 MODULE_DEPEND(iic, iicbus, IICBUS_MINVER, IICBUS_PREFVER, IICBUS_MAXVER); 389 MODULE_VERSION(iic, 1); 390