1 /*- 2 * Copyright (c) 1998 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 27 #include <sys/cdefs.h> 28 __FBSDID("$FreeBSD$"); 29 30 #include <sys/param.h> 31 #include <sys/systm.h> 32 #include <sys/lock.h> 33 #include <sys/malloc.h> 34 #include <sys/module.h> 35 #include <sys/mutex.h> 36 #include <sys/bus.h> 37 38 #include <dev/iicbus/iiconf.h> 39 #include <dev/iicbus/iicbus.h> 40 #include "iicbus_if.h" 41 42 /* 43 * iicbus_intr() 44 */ 45 void 46 iicbus_intr(device_t bus, int event, char *buf) 47 { 48 struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus); 49 50 /* call owner's intr routine */ 51 if (sc->owner) 52 IICBUS_INTR(sc->owner, event, buf); 53 54 return; 55 } 56 57 static int 58 iicbus_poll(struct iicbus_softc *sc, int how) 59 { 60 int error; 61 62 IICBUS_ASSERT_LOCKED(sc); 63 switch (how) { 64 case IIC_WAIT | IIC_INTR: 65 error = mtx_sleep(sc, &sc->lock, IICPRI|PCATCH, "iicreq", 0); 66 break; 67 68 case IIC_WAIT | IIC_NOINTR: 69 error = mtx_sleep(sc, &sc->lock, IICPRI, "iicreq", 0); 70 break; 71 72 default: 73 return (EWOULDBLOCK); 74 } 75 76 return (error); 77 } 78 79 /* 80 * iicbus_request_bus() 81 * 82 * Allocate the device to perform transfers. 83 * 84 * how : IIC_WAIT or IIC_DONTWAIT 85 */ 86 int 87 iicbus_request_bus(device_t bus, device_t dev, int how) 88 { 89 struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus); 90 int error = 0; 91 92 IICBUS_LOCK(sc); 93 94 while ((error == 0) && (sc->owner != NULL)) 95 error = iicbus_poll(sc, how); 96 97 if (error == 0) { 98 sc->owner = dev; 99 /* 100 * Drop the lock around the call to the bus driver. 101 * This call should be allowed to sleep in the IIC_WAIT case. 102 * Drivers might also need to grab locks that would cause LOR 103 * if our lock is held. 104 */ 105 IICBUS_UNLOCK(sc); 106 /* Ask the underlying layers if the request is ok */ 107 error = IICBUS_CALLBACK(device_get_parent(bus), 108 IIC_REQUEST_BUS, (caddr_t)&how); 109 IICBUS_LOCK(sc); 110 111 if (error != 0) { 112 sc->owner = NULL; 113 wakeup_one(sc); 114 } 115 } 116 117 118 IICBUS_UNLOCK(sc); 119 120 return (error); 121 } 122 123 /* 124 * iicbus_release_bus() 125 * 126 * Release the device allocated with iicbus_request_dev() 127 */ 128 int 129 iicbus_release_bus(device_t bus, device_t dev) 130 { 131 struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus); 132 int error; 133 134 IICBUS_LOCK(sc); 135 136 if (sc->owner != dev) { 137 IICBUS_UNLOCK(sc); 138 return (EACCES); 139 } 140 141 /* 142 * Drop the lock around the call to the bus driver. 143 * This call should be allowed to sleep in the IIC_WAIT case. 144 * Drivers might also need to grab locks that would cause LOR 145 * if our lock is held. 146 */ 147 IICBUS_UNLOCK(sc); 148 /* Ask the underlying layers if the release is ok */ 149 error = IICBUS_CALLBACK(device_get_parent(bus), IIC_RELEASE_BUS, NULL); 150 151 if (error == 0) { 152 IICBUS_LOCK(sc); 153 sc->owner = NULL; 154 155 /* wakeup a waiting thread */ 156 wakeup_one(sc); 157 IICBUS_UNLOCK(sc); 158 } 159 160 return (error); 161 } 162 163 /* 164 * iicbus_started() 165 * 166 * Test if the iicbus is started by the controller 167 */ 168 int 169 iicbus_started(device_t bus) 170 { 171 struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus); 172 173 return (sc->started); 174 } 175 176 /* 177 * iicbus_start() 178 * 179 * Send start condition to the slave addressed by 'slave' 180 */ 181 int 182 iicbus_start(device_t bus, u_char slave, int timeout) 183 { 184 struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus); 185 int error = 0; 186 187 if (sc->started) 188 return (EINVAL); /* bus already started */ 189 190 if (!(error = IICBUS_START(device_get_parent(bus), slave, timeout))) 191 sc->started = slave; 192 else 193 sc->started = 0; 194 195 return (error); 196 } 197 198 /* 199 * iicbus_repeated_start() 200 * 201 * Send start condition to the slave addressed by 'slave' 202 */ 203 int 204 iicbus_repeated_start(device_t bus, u_char slave, int timeout) 205 { 206 struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus); 207 int error = 0; 208 209 if (!sc->started) 210 return (EINVAL); /* bus should have been already started */ 211 212 if (!(error = IICBUS_REPEATED_START(device_get_parent(bus), slave, timeout))) 213 sc->started = slave; 214 else 215 sc->started = 0; 216 217 return (error); 218 } 219 220 /* 221 * iicbus_stop() 222 * 223 * Send stop condition to the bus 224 */ 225 int 226 iicbus_stop(device_t bus) 227 { 228 struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus); 229 int error = 0; 230 231 if (!sc->started) 232 return (EINVAL); /* bus not started */ 233 234 error = IICBUS_STOP(device_get_parent(bus)); 235 236 /* refuse any further access */ 237 sc->started = 0; 238 239 return (error); 240 } 241 242 /* 243 * iicbus_write() 244 * 245 * Write a block of data to the slave previously started by 246 * iicbus_start() call 247 */ 248 int 249 iicbus_write(device_t bus, const char *buf, int len, int *sent, int timeout) 250 { 251 struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus); 252 253 /* a slave must have been started for writing */ 254 if (sc->started == 0 || (sc->strict != 0 && (sc->started & LSB) != 0)) 255 return (EINVAL); 256 257 return (IICBUS_WRITE(device_get_parent(bus), buf, len, sent, timeout)); 258 } 259 260 /* 261 * iicbus_read() 262 * 263 * Read a block of data from the slave previously started by 264 * iicbus_read() call 265 */ 266 int 267 iicbus_read(device_t bus, char *buf, int len, int *read, int last, int delay) 268 { 269 struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus); 270 271 /* a slave must have been started for reading */ 272 if (sc->started == 0 || (sc->strict != 0 && (sc->started & LSB) == 0)) 273 return (EINVAL); 274 275 return (IICBUS_READ(device_get_parent(bus), buf, len, read, last, delay)); 276 } 277 278 /* 279 * iicbus_write_byte() 280 * 281 * Write a byte to the slave previously started by iicbus_start() call 282 */ 283 int 284 iicbus_write_byte(device_t bus, char byte, int timeout) 285 { 286 char data = byte; 287 int sent; 288 289 return (iicbus_write(bus, &data, 1, &sent, timeout)); 290 } 291 292 /* 293 * iicbus_read_byte() 294 * 295 * Read a byte from the slave previously started by iicbus_start() call 296 */ 297 int 298 iicbus_read_byte(device_t bus, char *byte, int timeout) 299 { 300 int read; 301 302 return (iicbus_read(bus, byte, 1, &read, IIC_LAST_READ, timeout)); 303 } 304 305 /* 306 * iicbus_block_write() 307 * 308 * Write a block of data to slave ; start/stop protocol managed 309 */ 310 int 311 iicbus_block_write(device_t bus, u_char slave, char *buf, int len, int *sent) 312 { 313 u_char addr = slave & ~LSB; 314 int error; 315 316 if ((error = iicbus_start(bus, addr, 0))) 317 return (error); 318 319 error = iicbus_write(bus, buf, len, sent, 0); 320 321 iicbus_stop(bus); 322 323 return (error); 324 } 325 326 /* 327 * iicbus_block_read() 328 * 329 * Read a block of data from slave ; start/stop protocol managed 330 */ 331 int 332 iicbus_block_read(device_t bus, u_char slave, char *buf, int len, int *read) 333 { 334 u_char addr = slave | LSB; 335 int error; 336 337 if ((error = iicbus_start(bus, addr, 0))) 338 return (error); 339 340 error = iicbus_read(bus, buf, len, read, IIC_LAST_READ, 0); 341 342 iicbus_stop(bus); 343 344 return (error); 345 } 346 347 /* 348 * iicbus_transfer() 349 * 350 * Do an aribtrary number of transfers on the iicbus. We pass these 351 * raw requests to the bridge driver. If the bridge driver supports 352 * them directly, then it manages all the details. If not, it can use 353 * the helper function iicbus_transfer_gen() which will do the 354 * transfers at a low level. 355 * 356 * Pointers passed in as part of iic_msg must be kernel pointers. 357 * Callers that have user addresses to manage must do so on their own. 358 */ 359 int 360 iicbus_transfer(device_t bus, struct iic_msg *msgs, uint32_t nmsgs) 361 { 362 return (IICBUS_TRANSFER(device_get_parent(bus), msgs, nmsgs)); 363 } 364 365 /* 366 * Generic version of iicbus_transfer that calls the appropriate 367 * routines to accomplish this. See note above about acceptable 368 * buffer addresses. 369 */ 370 int 371 iicbus_transfer_gen(device_t dev, struct iic_msg *msgs, uint32_t nmsgs) 372 { 373 int i, error, lenread, lenwrote, nkid, rpstart, addr; 374 device_t *children, bus; 375 bool nostop; 376 377 if ((error = device_get_children(dev, &children, &nkid)) != 0) 378 return (error); 379 if (nkid != 1) { 380 free(children, M_TEMP); 381 return (EIO); 382 } 383 bus = children[0]; 384 rpstart = 0; 385 free(children, M_TEMP); 386 nostop = iicbus_get_nostop(dev); 387 for (i = 0, error = 0; i < nmsgs && error == 0; i++) { 388 addr = msgs[i].slave; 389 if (msgs[i].flags & IIC_M_RD) 390 addr |= LSB; 391 else 392 addr &= ~LSB; 393 394 if (!(msgs[i].flags & IIC_M_NOSTART)) { 395 if (rpstart) 396 error = iicbus_repeated_start(bus, addr, 0); 397 else 398 error = iicbus_start(bus, addr, 0); 399 } 400 401 if (error) 402 break; 403 404 if (msgs[i].flags & IIC_M_RD) 405 error = iicbus_read(bus, msgs[i].buf, msgs[i].len, 406 &lenread, IIC_LAST_READ, 0); 407 else 408 error = iicbus_write(bus, msgs[i].buf, msgs[i].len, 409 &lenwrote, 0); 410 411 if ((msgs[i].flags & IIC_M_NOSTOP) != 0 || 412 (nostop && i + 1 < nmsgs)) { 413 rpstart = 1; /* Next message gets repeated start */ 414 } else { 415 rpstart = 0; 416 iicbus_stop(bus); 417 } 418 } 419 return (error); 420 } 421