1 /*- 2 * Copyright (c) 1998 Nicolas Souchu, Marc Bouget 3 * Copyright (c) 2004 Joerg Wunsch 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 */ 27 28 #include <sys/cdefs.h> 29 __FBSDID("$FreeBSD$"); 30 31 #include <sys/param.h> 32 #include <sys/systm.h> 33 #include <sys/kernel.h> 34 #include <sys/module.h> 35 #include <sys/bus.h> 36 37 #include <machine/bus.h> 38 #include <machine/resource.h> 39 40 #include <sys/rman.h> 41 42 #include <dev/iicbus/iiconf.h> 43 #include <dev/pcf/pcfvar.h> 44 #include "iicbus_if.h" 45 46 /* Not so official debugging option. */ 47 /* #define PCFDEBUG */ 48 49 static int pcf_wait_byte(struct pcf_softc *pcf); 50 static int pcf_noack(struct pcf_softc *pcf, int timeout); 51 52 /* 53 * Polling mode for master operations wait for a new 54 * byte incomming or outgoing 55 */ 56 int 57 pcf_wait_byte(struct pcf_softc *sc) 58 { 59 int counter = TIMEOUT; 60 61 while (counter--) { 62 63 if ((pcf_get_S1(sc) & PIN) == 0) 64 return (0); 65 } 66 67 #ifdef PCFDEBUG 68 printf("pcf: timeout!\n"); 69 #endif 70 71 return (IIC_ETIMEOUT); 72 } 73 74 int 75 pcf_stop(device_t dev) 76 { 77 struct pcf_softc *sc = DEVTOSOFTC(dev); 78 79 #ifdef PCFDEBUG 80 device_printf(dev, " >> stop\n"); 81 #endif 82 /* 83 * Send STOP condition iff the START condition was previously sent. 84 * STOP is sent only once even if an iicbus_stop() is called after 85 * an iicbus_read()... see pcf_read(): the PCF needs to send the stop 86 * before the last char is read. 87 */ 88 if (sc->pcf_started) { 89 /* set stop condition and enable IT */ 90 pcf_set_S1(sc, PIN|ESO|ENI|STO|ACK); 91 92 sc->pcf_started = 0; 93 } 94 95 return (0); 96 } 97 98 99 int 100 pcf_noack(struct pcf_softc *sc, int timeout) 101 { 102 int noack; 103 int k = timeout/10; 104 105 do { 106 noack = pcf_get_S1(sc) & LRB; 107 if (!noack) 108 break; 109 DELAY(10); /* XXX wait 10 us */ 110 } while (k--); 111 112 return (noack); 113 } 114 115 int 116 pcf_repeated_start(device_t dev, u_char slave, int timeout) 117 { 118 struct pcf_softc *sc = DEVTOSOFTC(dev); 119 int error = 0; 120 121 #ifdef PCFDEBUG 122 device_printf(dev, " >> repeated start for slave %#x\n", 123 (unsigned)slave); 124 #endif 125 /* repeated start */ 126 pcf_set_S1(sc, ESO|STA|STO|ACK); 127 128 /* set slave address to PCF. Last bit (LSB) must be set correctly 129 * according to transfer direction */ 130 pcf_set_S0(sc, slave); 131 132 /* wait for address sent, polling */ 133 if ((error = pcf_wait_byte(sc))) 134 goto error; 135 136 /* check for ack */ 137 if (pcf_noack(sc, timeout)) { 138 error = IIC_ENOACK; 139 #ifdef PCFDEBUG 140 printf("pcf: no ack on repeated_start!\n"); 141 #endif 142 goto error; 143 } 144 145 return (0); 146 147 error: 148 pcf_stop(dev); 149 return (error); 150 } 151 152 int 153 pcf_start(device_t dev, u_char slave, int timeout) 154 { 155 struct pcf_softc *sc = DEVTOSOFTC(dev); 156 int error = 0; 157 158 #ifdef PCFDEBUG 159 device_printf(dev, " >> start for slave %#x\n", (unsigned)slave); 160 #endif 161 if ((pcf_get_S1(sc) & nBB) == 0) { 162 #ifdef PCFDEBUG 163 printf("pcf: busy!\n"); 164 #endif 165 return (IIC_EBUSBSY); 166 } 167 168 /* set slave address to PCF. Last bit (LSB) must be set correctly 169 * according to transfer direction */ 170 pcf_set_S0(sc, slave); 171 172 /* START only */ 173 pcf_set_S1(sc, PIN|ESO|STA|ACK); 174 175 sc->pcf_started = 1; 176 177 /* wait for address sent, polling */ 178 if ((error = pcf_wait_byte(sc))) 179 goto error; 180 181 /* check for ACK */ 182 if (pcf_noack(sc, timeout)) { 183 error = IIC_ENOACK; 184 #ifdef PCFDEBUG 185 printf("pcf: no ack on start!\n"); 186 #endif 187 goto error; 188 } 189 190 return (0); 191 192 error: 193 pcf_stop(dev); 194 return (error); 195 } 196 197 void 198 pcf_intr(void *arg) 199 { 200 struct pcf_softc *sc = arg; 201 char data, status, addr; 202 char error = 0; 203 204 status = pcf_get_S1(sc); 205 206 if (status & PIN) { 207 printf("pcf: spurious interrupt, status=0x%x\n", 208 status & 0xff); 209 210 goto error; 211 } 212 213 if (status & LAB) 214 printf("pcf: bus arbitration lost!\n"); 215 216 if (status & BER) { 217 error = IIC_EBUSERR; 218 iicbus_intr(sc->iicbus, INTR_ERROR, &error); 219 220 goto error; 221 } 222 223 do { 224 status = pcf_get_S1(sc); 225 226 switch(sc->pcf_slave_mode) { 227 228 case SLAVE_TRANSMITTER: 229 if (status & LRB) { 230 /* ack interrupt line */ 231 dummy_write(sc); 232 233 /* no ack, don't send anymore */ 234 sc->pcf_slave_mode = SLAVE_RECEIVER; 235 236 iicbus_intr(sc->iicbus, INTR_NOACK, NULL); 237 break; 238 } 239 240 /* get data from upper code */ 241 iicbus_intr(sc->iicbus, INTR_TRANSMIT, &data); 242 243 pcf_set_S0(sc, data); 244 break; 245 246 case SLAVE_RECEIVER: 247 if (status & AAS) { 248 addr = pcf_get_S0(sc); 249 250 if (status & AD0) 251 iicbus_intr(sc->iicbus, INTR_GENERAL, &addr); 252 else 253 iicbus_intr(sc->iicbus, INTR_START, &addr); 254 255 if (addr & LSB) { 256 sc->pcf_slave_mode = SLAVE_TRANSMITTER; 257 258 /* get the first char from upper code */ 259 iicbus_intr(sc->iicbus, INTR_TRANSMIT, &data); 260 261 /* send first data byte */ 262 pcf_set_S0(sc, data); 263 } 264 265 break; 266 } 267 268 /* stop condition received? */ 269 if (status & STS) { 270 /* ack interrupt line */ 271 dummy_read(sc); 272 273 /* emulate intr stop condition */ 274 iicbus_intr(sc->iicbus, INTR_STOP, NULL); 275 276 } else { 277 /* get data, ack interrupt line */ 278 data = pcf_get_S0(sc); 279 280 /* deliver the character */ 281 iicbus_intr(sc->iicbus, INTR_RECEIVE, &data); 282 } 283 break; 284 285 default: 286 panic("%s: unknown slave mode (%d)!", __func__, 287 sc->pcf_slave_mode); 288 } 289 290 } while ((pcf_get_S1(sc) & PIN) == 0); 291 292 return; 293 294 error: 295 /* unknown event on bus...reset PCF */ 296 pcf_set_S1(sc, PIN|ESO|ENI|ACK); 297 298 sc->pcf_slave_mode = SLAVE_RECEIVER; 299 300 return; 301 } 302 303 int 304 pcf_rst_card(device_t dev, u_char speed, u_char addr, u_char *oldaddr) 305 { 306 struct pcf_softc *sc = DEVTOSOFTC(dev); 307 308 if (oldaddr) 309 *oldaddr = sc->pcf_addr; 310 311 /* retrieve own address from bus level */ 312 if (!addr) 313 sc->pcf_addr = PCF_DEFAULT_ADDR; 314 else 315 sc->pcf_addr = addr; 316 317 pcf_set_S1(sc, PIN); /* initialize S1 */ 318 319 /* own address S'O<>0 */ 320 pcf_set_S0(sc, sc->pcf_addr >> 1); 321 322 /* select clock register */ 323 pcf_set_S1(sc, PIN|ES1); 324 325 /* select bus speed : 18=90kb, 19=45kb, 1A=11kb, 1B=1.5kb */ 326 switch (speed) { 327 case IIC_SLOW: 328 pcf_set_S0(sc, 0x1b); /* XXX Sun uses 0x1f */ 329 break; 330 331 case IIC_FAST: 332 pcf_set_S0(sc, 0x19); /* XXX Sun: 0x1d */ 333 break; 334 335 case IIC_UNKNOWN: 336 case IIC_FASTEST: 337 default: 338 pcf_set_S0(sc, 0x18); /* XXX Sun: 0x1c */ 339 break; 340 } 341 342 /* set bus on, ack=yes, INT=yes */ 343 pcf_set_S1(sc, PIN|ESO|ENI|ACK); 344 345 sc->pcf_slave_mode = SLAVE_RECEIVER; 346 347 return (0); 348 } 349 350 int 351 pcf_write(device_t dev, char *buf, int len, int *sent, int timeout /* us */) 352 { 353 struct pcf_softc *sc = DEVTOSOFTC(dev); 354 int bytes, error = 0; 355 356 #ifdef PCFDEBUG 357 device_printf(dev, " >> writing %d bytes: %#x%s\n", len, 358 (unsigned)buf[0], len > 1? "...": ""); 359 #endif 360 361 bytes = 0; 362 while (len) { 363 364 pcf_set_S0(sc, *buf++); 365 366 /* wait for the byte to be send */ 367 if ((error = pcf_wait_byte(sc))) 368 goto error; 369 370 /* check if ack received */ 371 if (pcf_noack(sc, timeout)) { 372 error = IIC_ENOACK; 373 goto error; 374 } 375 376 len --; 377 bytes ++; 378 } 379 380 error: 381 *sent = bytes; 382 383 #ifdef PCFDEBUG 384 device_printf(dev, " >> %d bytes written (%d)\n", bytes, error); 385 #endif 386 387 return (error); 388 } 389 390 int 391 pcf_read(device_t dev, char *buf, int len, int *read, int last, 392 int delay /* us */) 393 { 394 struct pcf_softc *sc = DEVTOSOFTC(dev); 395 int bytes, error = 0; 396 #ifdef PCFDEBUG 397 char *obuf = buf; 398 399 device_printf(dev, " << reading %d bytes\n", len); 400 #endif 401 402 /* trig the bus to get the first data byte in S0 */ 403 if (len) { 404 if (len == 1 && last) 405 /* just one byte to read */ 406 pcf_set_S1(sc, ESO); /* no ack */ 407 408 dummy_read(sc); 409 } 410 411 bytes = 0; 412 while (len) { 413 414 /* XXX delay needed here */ 415 416 /* wait for trigged byte */ 417 if ((error = pcf_wait_byte(sc))) { 418 pcf_stop(dev); 419 goto error; 420 } 421 422 if (len == 1 && last) 423 /* ok, last data byte already in S0, no I2C activity 424 * on next pcf_get_S0() */ 425 pcf_stop(dev); 426 427 else if (len == 2 && last) 428 /* next trigged byte with no ack */ 429 pcf_set_S1(sc, ESO); 430 431 /* receive byte, trig next byte */ 432 *buf++ = pcf_get_S0(sc); 433 434 len --; 435 bytes ++; 436 }; 437 438 error: 439 *read = bytes; 440 441 #ifdef PCFDEBUG 442 device_printf(dev, " << %d bytes read (%d): %#x%s\n", bytes, error, 443 (unsigned)obuf[0], bytes > 1? "...": ""); 444 #endif 445 446 return (error); 447 } 448