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 break; 75 } 76 77 return (error); 78 } 79 80 /* 81 * iicbus_request_bus() 82 * 83 * Allocate the device to perform transfers. 84 * 85 * how : IIC_WAIT or IIC_DONTWAIT 86 */ 87 int 88 iicbus_request_bus(device_t bus, device_t dev, int how) 89 { 90 struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus); 91 int error = 0; 92 93 /* first, ask the underlying layers if the request is ok */ 94 IICBUS_LOCK(sc); 95 do { 96 error = IICBUS_CALLBACK(device_get_parent(bus), 97 IIC_REQUEST_BUS, (caddr_t)&how); 98 if (error) 99 error = iicbus_poll(sc, how); 100 } while (error == EWOULDBLOCK); 101 102 while (!error) { 103 if (sc->owner && sc->owner != dev) { 104 105 error = iicbus_poll(sc, how); 106 } else { 107 sc->owner = dev; 108 109 IICBUS_UNLOCK(sc); 110 return (0); 111 } 112 113 /* free any allocated resource */ 114 if (error) 115 IICBUS_CALLBACK(device_get_parent(bus), IIC_RELEASE_BUS, 116 (caddr_t)&how); 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 /* first, ask the underlying layers if the release is ok */ 135 error = IICBUS_CALLBACK(device_get_parent(bus), IIC_RELEASE_BUS, NULL); 136 137 if (error) 138 return (error); 139 140 IICBUS_LOCK(sc); 141 142 if (sc->owner != dev) { 143 IICBUS_UNLOCK(sc); 144 return (EACCES); 145 } 146 147 sc->owner = NULL; 148 149 /* wakeup waiting processes */ 150 wakeup(sc); 151 IICBUS_UNLOCK(sc); 152 153 return (0); 154 } 155 156 /* 157 * iicbus_started() 158 * 159 * Test if the iicbus is started by the controller 160 */ 161 int 162 iicbus_started(device_t bus) 163 { 164 struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus); 165 166 return (sc->started); 167 } 168 169 /* 170 * iicbus_start() 171 * 172 * Send start condition to the slave addressed by 'slave' 173 */ 174 int 175 iicbus_start(device_t bus, u_char slave, int timeout) 176 { 177 struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus); 178 int error = 0; 179 180 if (sc->started) 181 return (EINVAL); /* bus already started */ 182 183 if (!(error = IICBUS_START(device_get_parent(bus), slave, timeout))) 184 sc->started = slave; 185 else 186 sc->started = 0; 187 188 return (error); 189 } 190 191 /* 192 * iicbus_repeated_start() 193 * 194 * Send start condition to the slave addressed by 'slave' 195 */ 196 int 197 iicbus_repeated_start(device_t bus, u_char slave, int timeout) 198 { 199 struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus); 200 int error = 0; 201 202 if (!sc->started) 203 return (EINVAL); /* bus should have been already started */ 204 205 if (!(error = IICBUS_REPEATED_START(device_get_parent(bus), slave, timeout))) 206 sc->started = slave; 207 else 208 sc->started = 0; 209 210 return (error); 211 } 212 213 /* 214 * iicbus_stop() 215 * 216 * Send stop condition to the bus 217 */ 218 int 219 iicbus_stop(device_t bus) 220 { 221 struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus); 222 int error = 0; 223 224 if (!sc->started) 225 return (EINVAL); /* bus not started */ 226 227 error = IICBUS_STOP(device_get_parent(bus)); 228 229 /* refuse any further access */ 230 sc->started = 0; 231 232 return (error); 233 } 234 235 /* 236 * iicbus_write() 237 * 238 * Write a block of data to the slave previously started by 239 * iicbus_start() call 240 */ 241 int 242 iicbus_write(device_t bus, const char *buf, int len, int *sent, int timeout) 243 { 244 struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus); 245 246 /* a slave must have been started with the appropriate address */ 247 if (!sc->started || (sc->started & LSB)) 248 return (EINVAL); 249 250 return (IICBUS_WRITE(device_get_parent(bus), buf, len, sent, timeout)); 251 } 252 253 /* 254 * iicbus_read() 255 * 256 * Read a block of data from the slave previously started by 257 * iicbus_read() call 258 */ 259 int 260 iicbus_read(device_t bus, char *buf, int len, int *read, int last, int delay) 261 { 262 struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus); 263 264 /* a slave must have been started with the appropriate address */ 265 if (!sc->started || !(sc->started & LSB)) 266 return (EINVAL); 267 268 return (IICBUS_READ(device_get_parent(bus), buf, len, read, last, delay)); 269 } 270 271 /* 272 * iicbus_write_byte() 273 * 274 * Write a byte to the slave previously started by iicbus_start() call 275 */ 276 int 277 iicbus_write_byte(device_t bus, char byte, int timeout) 278 { 279 char data = byte; 280 int sent; 281 282 return (iicbus_write(bus, &data, 1, &sent, timeout)); 283 } 284 285 /* 286 * iicbus_read_byte() 287 * 288 * Read a byte from the slave previously started by iicbus_start() call 289 */ 290 int 291 iicbus_read_byte(device_t bus, char *byte, int timeout) 292 { 293 int read; 294 295 return (iicbus_read(bus, byte, 1, &read, IIC_LAST_READ, timeout)); 296 } 297 298 /* 299 * iicbus_block_write() 300 * 301 * Write a block of data to slave ; start/stop protocol managed 302 */ 303 int 304 iicbus_block_write(device_t bus, u_char slave, char *buf, int len, int *sent) 305 { 306 u_char addr = slave & ~LSB; 307 int error; 308 309 if ((error = iicbus_start(bus, addr, 0))) 310 return (error); 311 312 error = iicbus_write(bus, buf, len, sent, 0); 313 314 iicbus_stop(bus); 315 316 return (error); 317 } 318 319 /* 320 * iicbus_block_read() 321 * 322 * Read a block of data from slave ; start/stop protocol managed 323 */ 324 int 325 iicbus_block_read(device_t bus, u_char slave, char *buf, int len, int *read) 326 { 327 u_char addr = slave | LSB; 328 int error; 329 330 if ((error = iicbus_start(bus, addr, 0))) 331 return (error); 332 333 error = iicbus_read(bus, buf, len, read, IIC_LAST_READ, 0); 334 335 iicbus_stop(bus); 336 337 return (error); 338 } 339 340 /* 341 * iicbus_transfer() 342 * 343 * Do an aribtrary number of transfers on the iicbus. We pass these 344 * raw requests to the bridge driver. If the bridge driver supports 345 * them directly, then it manages all the details. If not, it can use 346 * the helper function iicbus_transfer_gen() which will do the 347 * transfers at a low level. 348 * 349 * Pointers passed in as part of iic_msg must be kernel pointers. 350 * Callers that have user addresses to manage must do so on their own. 351 */ 352 int 353 iicbus_transfer(device_t bus, struct iic_msg *msgs, uint32_t nmsgs) 354 { 355 return (IICBUS_TRANSFER(device_get_parent(bus), msgs, nmsgs)); 356 } 357 358 /* 359 * Generic version of iicbus_transfer that calls the appropriate 360 * routines to accomplish this. See note above about acceptable 361 * buffer addresses. 362 */ 363 int 364 iicbus_transfer_gen(device_t dev, struct iic_msg *msgs, uint32_t nmsgs) 365 { 366 int i, error, lenread, lenwrote, nkid; 367 device_t *children, bus; 368 369 device_get_children(dev, &children, &nkid); 370 if (nkid != 1) 371 return (EIO); 372 bus = children[0]; 373 free(children, M_TEMP); 374 for (i = 0, error = 0; i < nmsgs && error == 0; i++) { 375 if (msgs[i].flags & IIC_M_RD) 376 error = iicbus_block_read(bus, msgs[i].slave, 377 msgs[i].buf, msgs[i].len, &lenread); 378 else 379 error = iicbus_block_write(bus, msgs[i].slave, 380 msgs[i].buf, msgs[i].len, &lenwrote); 381 } 382 return (error); 383 } 384