1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 1998 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 #include <sys/param.h> 33 #include <sys/systm.h> 34 #include <sys/lock.h> 35 #include <sys/malloc.h> 36 #include <sys/module.h> 37 #include <sys/mutex.h> 38 #include <sys/bus.h> 39 40 #include <dev/iicbus/iiconf.h> 41 #include <dev/iicbus/iicbus.h> 42 #include "iicbus_if.h" 43 44 /* 45 * Translate IIC_Exxxxx status values to vaguely-equivelent errno values. 46 */ 47 int 48 iic2errno(int iic_status) 49 { 50 switch (iic_status) { 51 case IIC_NOERR: return (0); 52 case IIC_EBUSERR: return (EALREADY); 53 case IIC_ENOACK: return (EIO); 54 case IIC_ETIMEOUT: return (ETIMEDOUT); 55 case IIC_EBUSBSY: return (EWOULDBLOCK); 56 case IIC_ESTATUS: return (EPROTO); 57 case IIC_EUNDERFLOW: return (EIO); 58 case IIC_EOVERFLOW: return (EOVERFLOW); 59 case IIC_ENOTSUPP: return (EOPNOTSUPP); 60 case IIC_ENOADDR: return (EADDRNOTAVAIL); 61 case IIC_ERESOURCE: return (ENOMEM); 62 default: return (EIO); 63 } 64 } 65 66 /* 67 * iicbus_intr() 68 */ 69 void 70 iicbus_intr(device_t bus, int event, char *buf) 71 { 72 struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus); 73 74 /* call owner's intr routine */ 75 if (sc->owner) 76 IICBUS_INTR(sc->owner, event, buf); 77 78 return; 79 } 80 81 static int 82 iicbus_poll(struct iicbus_softc *sc, int how) 83 { 84 int error; 85 86 IICBUS_ASSERT_LOCKED(sc); 87 switch (how & IIC_INTRWAIT) { 88 case IIC_WAIT | IIC_INTR: 89 error = mtx_sleep(sc, &sc->lock, IICPRI|PCATCH, "iicreq", 0); 90 break; 91 92 case IIC_WAIT | IIC_NOINTR: 93 error = mtx_sleep(sc, &sc->lock, IICPRI, "iicreq", 0); 94 break; 95 96 default: 97 return (IIC_EBUSBSY); 98 } 99 100 return (error); 101 } 102 103 /* 104 * iicbus_request_bus() 105 * 106 * Allocate the device to perform transfers. 107 * 108 * how : IIC_WAIT or IIC_DONTWAIT 109 */ 110 int 111 iicbus_request_bus(device_t bus, device_t dev, int how) 112 { 113 struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus); 114 int error = 0; 115 116 IICBUS_LOCK(sc); 117 118 for (;;) { 119 if (sc->owner == NULL) 120 break; 121 if ((how & IIC_RECURSIVE) && sc->owner == dev) 122 break; 123 if ((error = iicbus_poll(sc, how)) != 0) 124 break; 125 } 126 127 if (error == 0) { 128 ++sc->owncount; 129 if (sc->owner == NULL) { 130 sc->owner = dev; 131 /* 132 * Mark the device busy while it owns the bus, to 133 * prevent detaching the device, bus, or hardware 134 * controller, until ownership is relinquished. If the 135 * device is doing IO from its probe method before 136 * attaching, it cannot be busied; mark the bus busy. 137 */ 138 if (device_get_state(dev) < DS_ATTACHING) 139 sc->busydev = bus; 140 else 141 sc->busydev = dev; 142 device_busy(sc->busydev); 143 /* 144 * Drop the lock around the call to the bus driver, it 145 * should be allowed to sleep in the IIC_WAIT case. 146 * Drivers might also need to grab locks that would 147 * cause a LOR if our lock is held. 148 */ 149 IICBUS_UNLOCK(sc); 150 /* Ask the underlying layers if the request is ok */ 151 error = IICBUS_CALLBACK(device_get_parent(bus), 152 IIC_REQUEST_BUS, (caddr_t)&how); 153 IICBUS_LOCK(sc); 154 155 if (error != 0) { 156 sc->owner = NULL; 157 sc->owncount = 0; 158 wakeup_one(sc); 159 device_unbusy(sc->busydev); 160 } 161 } 162 } 163 164 IICBUS_UNLOCK(sc); 165 166 return (error); 167 } 168 169 /* 170 * iicbus_release_bus() 171 * 172 * Release the device allocated with iicbus_request_dev() 173 */ 174 int 175 iicbus_release_bus(device_t bus, device_t dev) 176 { 177 struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus); 178 179 IICBUS_LOCK(sc); 180 181 if (sc->owner != dev) { 182 IICBUS_UNLOCK(sc); 183 return (IIC_EBUSBSY); 184 } 185 186 if (--sc->owncount == 0) { 187 /* Drop the lock while informing the low-level driver. */ 188 IICBUS_UNLOCK(sc); 189 IICBUS_CALLBACK(device_get_parent(bus), IIC_RELEASE_BUS, NULL); 190 IICBUS_LOCK(sc); 191 sc->owner = NULL; 192 wakeup_one(sc); 193 device_unbusy(sc->busydev); 194 } 195 IICBUS_UNLOCK(sc); 196 return (0); 197 } 198 199 /* 200 * iicbus_started() 201 * 202 * Test if the iicbus is started by the controller 203 */ 204 int 205 iicbus_started(device_t bus) 206 { 207 struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus); 208 209 return (sc->started); 210 } 211 212 /* 213 * iicbus_start() 214 * 215 * Send start condition to the slave addressed by 'slave' 216 */ 217 int 218 iicbus_start(device_t bus, u_char slave, int timeout) 219 { 220 struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus); 221 int error = 0; 222 223 if (sc->started) 224 return (IIC_ESTATUS); /* protocol error, bus already started */ 225 226 if (!(error = IICBUS_START(device_get_parent(bus), slave, timeout))) 227 sc->started = slave; 228 else 229 sc->started = 0; 230 231 return (error); 232 } 233 234 /* 235 * iicbus_repeated_start() 236 * 237 * Send start condition to the slave addressed by 'slave' 238 */ 239 int 240 iicbus_repeated_start(device_t bus, u_char slave, int timeout) 241 { 242 struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus); 243 int error = 0; 244 245 if (!sc->started) 246 return (IIC_ESTATUS); /* protocol error, bus not started */ 247 248 if (!(error = IICBUS_REPEATED_START(device_get_parent(bus), slave, timeout))) 249 sc->started = slave; 250 else 251 sc->started = 0; 252 253 return (error); 254 } 255 256 /* 257 * iicbus_stop() 258 * 259 * Send stop condition to the bus 260 */ 261 int 262 iicbus_stop(device_t bus) 263 { 264 struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus); 265 int error = 0; 266 267 if (!sc->started) 268 return (IIC_ESTATUS); /* protocol error, bus not started */ 269 270 error = IICBUS_STOP(device_get_parent(bus)); 271 272 /* refuse any further access */ 273 sc->started = 0; 274 275 return (error); 276 } 277 278 /* 279 * iicbus_write() 280 * 281 * Write a block of data to the slave previously started by 282 * iicbus_start() call 283 */ 284 int 285 iicbus_write(device_t bus, const char *buf, int len, int *sent, int timeout) 286 { 287 struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus); 288 289 /* a slave must have been started for writing */ 290 if (sc->started == 0 || (sc->strict != 0 && (sc->started & LSB) != 0)) 291 return (IIC_ESTATUS); 292 293 return (IICBUS_WRITE(device_get_parent(bus), buf, len, sent, timeout)); 294 } 295 296 /* 297 * iicbus_read() 298 * 299 * Read a block of data from the slave previously started by 300 * iicbus_read() call 301 */ 302 int 303 iicbus_read(device_t bus, char *buf, int len, int *read, int last, int delay) 304 { 305 struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus); 306 307 /* a slave must have been started for reading */ 308 if (sc->started == 0 || (sc->strict != 0 && (sc->started & LSB) == 0)) 309 return (IIC_ESTATUS); 310 311 return (IICBUS_READ(device_get_parent(bus), buf, len, read, last, delay)); 312 } 313 314 /* 315 * iicbus_write_byte() 316 * 317 * Write a byte to the slave previously started by iicbus_start() call 318 */ 319 int 320 iicbus_write_byte(device_t bus, char byte, int timeout) 321 { 322 struct iicbus_softc *sc = device_get_softc(bus); 323 char data = byte; 324 int sent; 325 326 /* a slave must have been started for writing */ 327 if (sc->started == 0 || (sc->strict != 0 && (sc->started & LSB) != 0)) 328 return (IIC_ESTATUS); 329 330 return (iicbus_write(bus, &data, 1, &sent, timeout)); 331 } 332 333 /* 334 * iicbus_read_byte() 335 * 336 * Read a byte from the slave previously started by iicbus_start() call 337 */ 338 int 339 iicbus_read_byte(device_t bus, char *byte, int timeout) 340 { 341 struct iicbus_softc *sc = device_get_softc(bus); 342 int read; 343 344 /* a slave must have been started for reading */ 345 if (sc->started == 0 || (sc->strict != 0 && (sc->started & LSB) == 0)) 346 return (IIC_ESTATUS); 347 348 return (iicbus_read(bus, byte, 1, &read, IIC_LAST_READ, timeout)); 349 } 350 351 /* 352 * iicbus_block_write() 353 * 354 * Write a block of data to slave ; start/stop protocol managed 355 */ 356 int 357 iicbus_block_write(device_t bus, u_char slave, char *buf, int len, int *sent) 358 { 359 u_char addr = slave & ~LSB; 360 int error; 361 362 if ((error = iicbus_start(bus, addr, 0))) 363 return (error); 364 365 error = iicbus_write(bus, buf, len, sent, 0); 366 367 iicbus_stop(bus); 368 369 return (error); 370 } 371 372 /* 373 * iicbus_block_read() 374 * 375 * Read a block of data from slave ; start/stop protocol managed 376 */ 377 int 378 iicbus_block_read(device_t bus, u_char slave, char *buf, int len, int *read) 379 { 380 u_char addr = slave | LSB; 381 int error; 382 383 if ((error = iicbus_start(bus, addr, 0))) 384 return (error); 385 386 error = iicbus_read(bus, buf, len, read, IIC_LAST_READ, 0); 387 388 iicbus_stop(bus); 389 390 return (error); 391 } 392 393 /* 394 * iicbus_transfer() 395 * 396 * Do an aribtrary number of transfers on the iicbus. We pass these 397 * raw requests to the bridge driver. If the bridge driver supports 398 * them directly, then it manages all the details. If not, it can use 399 * the helper function iicbus_transfer_gen() which will do the 400 * transfers at a low level. 401 * 402 * Pointers passed in as part of iic_msg must be kernel pointers. 403 * Callers that have user addresses to manage must do so on their own. 404 */ 405 int 406 iicbus_transfer(device_t bus, struct iic_msg *msgs, uint32_t nmsgs) 407 { 408 409 return (IICBUS_TRANSFER(device_get_parent(bus), msgs, nmsgs)); 410 } 411 412 int 413 iicbus_transfer_excl(device_t dev, struct iic_msg *msgs, uint32_t nmsgs, 414 int how) 415 { 416 device_t bus; 417 int error; 418 419 bus = device_get_parent(dev); 420 error = iicbus_request_bus(bus, dev, how); 421 if (error == 0) 422 error = IICBUS_TRANSFER(bus, msgs, nmsgs); 423 iicbus_release_bus(bus, dev); 424 return (error); 425 } 426 427 /* 428 * Generic version of iicbus_transfer that calls the appropriate 429 * routines to accomplish this. See note above about acceptable 430 * buffer addresses. 431 */ 432 int 433 iicbus_transfer_gen(device_t dev, struct iic_msg *msgs, uint32_t nmsgs) 434 { 435 int i, error, lenread, lenwrote, nkid, rpstart, addr; 436 device_t *children, bus; 437 bool started; 438 439 if ((error = device_get_children(dev, &children, &nkid)) != 0) 440 return (IIC_ERESOURCE); 441 if (nkid != 1) { 442 free(children, M_TEMP); 443 return (IIC_ENOTSUPP); 444 } 445 bus = children[0]; 446 rpstart = 0; 447 free(children, M_TEMP); 448 started = false; 449 for (i = 0, error = 0; i < nmsgs && error == 0; i++) { 450 addr = msgs[i].slave; 451 if (msgs[i].flags & IIC_M_RD) 452 addr |= LSB; 453 else 454 addr &= ~LSB; 455 456 if (!(msgs[i].flags & IIC_M_NOSTART)) { 457 if (rpstart) 458 error = iicbus_repeated_start(bus, addr, 0); 459 else 460 error = iicbus_start(bus, addr, 0); 461 if (error != 0) 462 break; 463 started = true; 464 } 465 466 if (msgs[i].flags & IIC_M_RD) 467 error = iicbus_read(bus, msgs[i].buf, msgs[i].len, 468 &lenread, IIC_LAST_READ, 0); 469 else 470 error = iicbus_write(bus, msgs[i].buf, msgs[i].len, 471 &lenwrote, 0); 472 if (error != 0) 473 break; 474 475 if (!(msgs[i].flags & IIC_M_NOSTOP)) { 476 rpstart = 0; 477 iicbus_stop(bus); 478 } else { 479 rpstart = 1; /* Next message gets repeated start */ 480 } 481 } 482 if (error != 0 && started) 483 iicbus_stop(bus); 484 return (error); 485 } 486 487 int 488 iicdev_readfrom(device_t slavedev, uint8_t regaddr, void *buffer, 489 uint16_t buflen, int waithow) 490 { 491 struct iic_msg msgs[2]; 492 uint8_t slaveaddr; 493 494 /* 495 * Two transfers back to back with a repeat-start between them; first we 496 * write the address-within-device, then we read from the device. 497 */ 498 slaveaddr = iicbus_get_addr(slavedev); 499 500 msgs[0].slave = slaveaddr; 501 msgs[0].flags = IIC_M_WR | IIC_M_NOSTOP; 502 msgs[0].len = 1; 503 msgs[0].buf = ®addr; 504 505 msgs[1].slave = slaveaddr; 506 msgs[1].flags = IIC_M_RD; 507 msgs[1].len = buflen; 508 msgs[1].buf = buffer; 509 510 return (iicbus_transfer_excl(slavedev, msgs, nitems(msgs), waithow)); 511 } 512 513 int iicdev_writeto(device_t slavedev, uint8_t regaddr, void *buffer, 514 uint16_t buflen, int waithow) 515 { 516 struct iic_msg msgs[2]; 517 uint8_t slaveaddr; 518 519 /* 520 * Two transfers back to back with no stop or start between them; first 521 * we write the address then we write the data to that address, all in a 522 * single transfer from two scattered buffers. 523 */ 524 slaveaddr = iicbus_get_addr(slavedev); 525 526 msgs[0].slave = slaveaddr; 527 msgs[0].flags = IIC_M_WR | IIC_M_NOSTOP; 528 msgs[0].len = 1; 529 msgs[0].buf = ®addr; 530 531 msgs[1].slave = slaveaddr; 532 msgs[1].flags = IIC_M_WR | IIC_M_NOSTART; 533 msgs[1].len = buflen; 534 msgs[1].buf = buffer; 535 536 return (iicbus_transfer_excl(slavedev, msgs, nitems(msgs), waithow)); 537 } 538