1 /* 2 * i2c-algo-pcf.c i2c driver algorithms for PCF8584 adapters 3 * 4 * Copyright (C) 1995-1997 Simon G. Vogl 5 * 1998-2000 Hans Berglund 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 20 * MA 02110-1301 USA. 21 * 22 * With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and 23 * Frodo Looijaard <frodol@dds.nl>, and also from Martin Bailey 24 * <mbailey@littlefeet-inc.com> 25 * 26 * Partially rewriten by Oleg I. Vdovikin <vdovikin@jscc.ru> to handle multiple 27 * messages, proper stop/repstart signaling during receive, added detect code 28 */ 29 30 #include <linux/kernel.h> 31 #include <linux/module.h> 32 #include <linux/delay.h> 33 #include <linux/errno.h> 34 #include <linux/i2c.h> 35 #include <linux/i2c-algo-pcf.h> 36 #include "i2c-algo-pcf.h" 37 38 39 #define DEB2(x) if (i2c_debug >= 2) x 40 #define DEB3(x) if (i2c_debug >= 3) x /* print several statistical values */ 41 #define DEBPROTO(x) if (i2c_debug >= 9) x; 42 /* debug the protocol by showing transferred bits */ 43 #define DEF_TIMEOUT 16 44 45 /* 46 * module parameters: 47 */ 48 static int i2c_debug; 49 50 /* setting states on the bus with the right timing: */ 51 52 #define set_pcf(adap, ctl, val) adap->setpcf(adap->data, ctl, val) 53 #define get_pcf(adap, ctl) adap->getpcf(adap->data, ctl) 54 #define get_own(adap) adap->getown(adap->data) 55 #define get_clock(adap) adap->getclock(adap->data) 56 #define i2c_outb(adap, val) adap->setpcf(adap->data, 0, val) 57 #define i2c_inb(adap) adap->getpcf(adap->data, 0) 58 59 /* other auxiliary functions */ 60 61 static void i2c_start(struct i2c_algo_pcf_data *adap) 62 { 63 DEBPROTO(printk(KERN_DEBUG "S ")); 64 set_pcf(adap, 1, I2C_PCF_START); 65 } 66 67 static void i2c_repstart(struct i2c_algo_pcf_data *adap) 68 { 69 DEBPROTO(printk(" Sr ")); 70 set_pcf(adap, 1, I2C_PCF_REPSTART); 71 } 72 73 static void i2c_stop(struct i2c_algo_pcf_data *adap) 74 { 75 DEBPROTO(printk("P\n")); 76 set_pcf(adap, 1, I2C_PCF_STOP); 77 } 78 79 static void handle_lab(struct i2c_algo_pcf_data *adap, const int *status) 80 { 81 DEB2(printk(KERN_INFO 82 "i2c-algo-pcf.o: lost arbitration (CSR 0x%02x)\n", 83 *status)); 84 /* 85 * Cleanup from LAB -- reset and enable ESO. 86 * This resets the PCF8584; since we've lost the bus, no 87 * further attempts should be made by callers to clean up 88 * (no i2c_stop() etc.) 89 */ 90 set_pcf(adap, 1, I2C_PCF_PIN); 91 set_pcf(adap, 1, I2C_PCF_ESO); 92 /* 93 * We pause for a time period sufficient for any running 94 * I2C transaction to complete -- the arbitration logic won't 95 * work properly until the next START is seen. 96 * It is assumed the bus driver or client has set a proper value. 97 * 98 * REVISIT: should probably use msleep instead of mdelay if we 99 * know we can sleep. 100 */ 101 if (adap->lab_mdelay) 102 mdelay(adap->lab_mdelay); 103 104 DEB2(printk(KERN_INFO 105 "i2c-algo-pcf.o: reset LAB condition (CSR 0x%02x)\n", 106 get_pcf(adap, 1))); 107 } 108 109 static int wait_for_bb(struct i2c_algo_pcf_data *adap) 110 { 111 112 int timeout = DEF_TIMEOUT; 113 int status; 114 115 status = get_pcf(adap, 1); 116 117 while (!(status & I2C_PCF_BB) && --timeout) { 118 udelay(100); /* wait for 100 us */ 119 status = get_pcf(adap, 1); 120 } 121 122 if (timeout == 0) { 123 printk(KERN_ERR "Timeout waiting for Bus Busy\n"); 124 return -ETIMEDOUT; 125 } 126 127 return 0; 128 } 129 130 static int wait_for_pin(struct i2c_algo_pcf_data *adap, int *status) 131 { 132 133 int timeout = DEF_TIMEOUT; 134 135 *status = get_pcf(adap, 1); 136 137 while ((*status & I2C_PCF_PIN) && --timeout) { 138 adap->waitforpin(adap->data); 139 *status = get_pcf(adap, 1); 140 } 141 if (*status & I2C_PCF_LAB) { 142 handle_lab(adap, status); 143 return -EINTR; 144 } 145 146 if (timeout == 0) 147 return -ETIMEDOUT; 148 149 return 0; 150 } 151 152 /* 153 * This should perform the 'PCF8584 initialization sequence' as described 154 * in the Philips IC12 data book (1995, Aug 29). 155 * There should be a 30 clock cycle wait after reset, I assume this 156 * has been fulfilled. 157 * There should be a delay at the end equal to the longest I2C message 158 * to synchronize the BB-bit (in multimaster systems). How long is 159 * this? I assume 1 second is always long enough. 160 * 161 * vdovikin: added detect code for PCF8584 162 */ 163 static int pcf_init_8584 (struct i2c_algo_pcf_data *adap) 164 { 165 unsigned char temp; 166 167 DEB3(printk(KERN_DEBUG "i2c-algo-pcf.o: PCF state 0x%02x\n", 168 get_pcf(adap, 1))); 169 170 /* S1=0x80: S0 selected, serial interface off */ 171 set_pcf(adap, 1, I2C_PCF_PIN); 172 /* 173 * check to see S1 now used as R/W ctrl - 174 * PCF8584 does that when ESO is zero 175 */ 176 if (((temp = get_pcf(adap, 1)) & 0x7f) != (0)) { 177 DEB2(printk(KERN_ERR "i2c-algo-pcf.o: PCF detection failed -- can't select S0 (0x%02x).\n", temp)); 178 return -ENXIO; /* definitely not PCF8584 */ 179 } 180 181 /* load own address in S0, effective address is (own << 1) */ 182 i2c_outb(adap, get_own(adap)); 183 /* check it's really written */ 184 if ((temp = i2c_inb(adap)) != get_own(adap)) { 185 DEB2(printk(KERN_ERR "i2c-algo-pcf.o: PCF detection failed -- can't set S0 (0x%02x).\n", temp)); 186 return -ENXIO; 187 } 188 189 /* S1=0xA0, next byte in S2 */ 190 set_pcf(adap, 1, I2C_PCF_PIN | I2C_PCF_ES1); 191 /* check to see S2 now selected */ 192 if (((temp = get_pcf(adap, 1)) & 0x7f) != I2C_PCF_ES1) { 193 DEB2(printk(KERN_ERR "i2c-algo-pcf.o: PCF detection failed -- can't select S2 (0x%02x).\n", temp)); 194 return -ENXIO; 195 } 196 197 /* load clock register S2 */ 198 i2c_outb(adap, get_clock(adap)); 199 /* check it's really written, the only 5 lowest bits does matter */ 200 if (((temp = i2c_inb(adap)) & 0x1f) != get_clock(adap)) { 201 DEB2(printk(KERN_ERR "i2c-algo-pcf.o: PCF detection failed -- can't set S2 (0x%02x).\n", temp)); 202 return -ENXIO; 203 } 204 205 /* Enable serial interface, idle, S0 selected */ 206 set_pcf(adap, 1, I2C_PCF_IDLE); 207 208 /* check to see PCF is really idled and we can access status register */ 209 if ((temp = get_pcf(adap, 1)) != (I2C_PCF_PIN | I2C_PCF_BB)) { 210 DEB2(printk(KERN_ERR "i2c-algo-pcf.o: PCF detection failed -- can't select S1` (0x%02x).\n", temp)); 211 return -ENXIO; 212 } 213 214 printk(KERN_DEBUG "i2c-algo-pcf.o: detected and initialized PCF8584.\n"); 215 216 return 0; 217 } 218 219 static int pcf_sendbytes(struct i2c_adapter *i2c_adap, const char *buf, 220 int count, int last) 221 { 222 struct i2c_algo_pcf_data *adap = i2c_adap->algo_data; 223 int wrcount, status, timeout; 224 225 for (wrcount=0; wrcount<count; ++wrcount) { 226 DEB2(dev_dbg(&i2c_adap->dev, "i2c_write: writing %2.2X\n", 227 buf[wrcount] & 0xff)); 228 i2c_outb(adap, buf[wrcount]); 229 timeout = wait_for_pin(adap, &status); 230 if (timeout) { 231 if (timeout == -EINTR) 232 return -EINTR; /* arbitration lost */ 233 234 i2c_stop(adap); 235 dev_err(&i2c_adap->dev, "i2c_write: error - timeout.\n"); 236 return -EREMOTEIO; /* got a better one ?? */ 237 } 238 if (status & I2C_PCF_LRB) { 239 i2c_stop(adap); 240 dev_err(&i2c_adap->dev, "i2c_write: error - no ack.\n"); 241 return -EREMOTEIO; /* got a better one ?? */ 242 } 243 } 244 if (last) 245 i2c_stop(adap); 246 else 247 i2c_repstart(adap); 248 249 return wrcount; 250 } 251 252 static int pcf_readbytes(struct i2c_adapter *i2c_adap, char *buf, 253 int count, int last) 254 { 255 int i, status; 256 struct i2c_algo_pcf_data *adap = i2c_adap->algo_data; 257 int wfp; 258 259 /* increment number of bytes to read by one -- read dummy byte */ 260 for (i = 0; i <= count; i++) { 261 262 if ((wfp = wait_for_pin(adap, &status))) { 263 if (wfp == -EINTR) 264 return -EINTR; /* arbitration lost */ 265 266 i2c_stop(adap); 267 dev_err(&i2c_adap->dev, "pcf_readbytes timed out.\n"); 268 return -1; 269 } 270 271 if ((status & I2C_PCF_LRB) && (i != count)) { 272 i2c_stop(adap); 273 dev_err(&i2c_adap->dev, "i2c_read: i2c_inb, No ack.\n"); 274 return -1; 275 } 276 277 if (i == count - 1) { 278 set_pcf(adap, 1, I2C_PCF_ESO); 279 } else if (i == count) { 280 if (last) 281 i2c_stop(adap); 282 else 283 i2c_repstart(adap); 284 } 285 286 if (i) 287 buf[i - 1] = i2c_inb(adap); 288 else 289 i2c_inb(adap); /* dummy read */ 290 } 291 292 return i - 1; 293 } 294 295 296 static int pcf_doAddress(struct i2c_algo_pcf_data *adap, 297 struct i2c_msg *msg) 298 { 299 unsigned short flags = msg->flags; 300 unsigned char addr; 301 302 addr = msg->addr << 1; 303 if (flags & I2C_M_RD) 304 addr |= 1; 305 if (flags & I2C_M_REV_DIR_ADDR) 306 addr ^= 1; 307 i2c_outb(adap, addr); 308 309 return 0; 310 } 311 312 static int pcf_xfer(struct i2c_adapter *i2c_adap, 313 struct i2c_msg *msgs, 314 int num) 315 { 316 struct i2c_algo_pcf_data *adap = i2c_adap->algo_data; 317 struct i2c_msg *pmsg; 318 int i; 319 int ret=0, timeout, status; 320 321 if (adap->xfer_begin) 322 adap->xfer_begin(adap->data); 323 324 /* Check for bus busy */ 325 timeout = wait_for_bb(adap); 326 if (timeout) { 327 DEB2(printk(KERN_ERR "i2c-algo-pcf.o: " 328 "Timeout waiting for BB in pcf_xfer\n");) 329 i = -EIO; 330 goto out; 331 } 332 333 for (i = 0;ret >= 0 && i < num; i++) { 334 pmsg = &msgs[i]; 335 336 DEB2(printk(KERN_DEBUG "i2c-algo-pcf.o: Doing %s %d bytes to 0x%02x - %d of %d messages\n", 337 pmsg->flags & I2C_M_RD ? "read" : "write", 338 pmsg->len, pmsg->addr, i + 1, num);) 339 340 ret = pcf_doAddress(adap, pmsg); 341 342 /* Send START */ 343 if (i == 0) 344 i2c_start(adap); 345 346 /* Wait for PIN (pending interrupt NOT) */ 347 timeout = wait_for_pin(adap, &status); 348 if (timeout) { 349 if (timeout == -EINTR) { 350 /* arbitration lost */ 351 i = -EINTR; 352 goto out; 353 } 354 i2c_stop(adap); 355 DEB2(printk(KERN_ERR "i2c-algo-pcf.o: Timeout waiting " 356 "for PIN(1) in pcf_xfer\n");) 357 i = -EREMOTEIO; 358 goto out; 359 } 360 361 /* Check LRB (last rcvd bit - slave ack) */ 362 if (status & I2C_PCF_LRB) { 363 i2c_stop(adap); 364 DEB2(printk(KERN_ERR "i2c-algo-pcf.o: No LRB(1) in pcf_xfer\n");) 365 i = -EREMOTEIO; 366 goto out; 367 } 368 369 DEB3(printk(KERN_DEBUG "i2c-algo-pcf.o: Msg %d, addr=0x%x, flags=0x%x, len=%d\n", 370 i, msgs[i].addr, msgs[i].flags, msgs[i].len);) 371 372 if (pmsg->flags & I2C_M_RD) { 373 ret = pcf_readbytes(i2c_adap, pmsg->buf, pmsg->len, 374 (i + 1 == num)); 375 376 if (ret != pmsg->len) { 377 DEB2(printk(KERN_DEBUG "i2c-algo-pcf.o: fail: " 378 "only read %d bytes.\n",ret)); 379 } else { 380 DEB2(printk(KERN_DEBUG "i2c-algo-pcf.o: read %d bytes.\n",ret)); 381 } 382 } else { 383 ret = pcf_sendbytes(i2c_adap, pmsg->buf, pmsg->len, 384 (i + 1 == num)); 385 386 if (ret != pmsg->len) { 387 DEB2(printk(KERN_DEBUG "i2c-algo-pcf.o: fail: " 388 "only wrote %d bytes.\n",ret)); 389 } else { 390 DEB2(printk(KERN_DEBUG "i2c-algo-pcf.o: wrote %d bytes.\n",ret)); 391 } 392 } 393 } 394 395 out: 396 if (adap->xfer_end) 397 adap->xfer_end(adap->data); 398 return i; 399 } 400 401 static u32 pcf_func(struct i2c_adapter *adap) 402 { 403 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL | 404 I2C_FUNC_PROTOCOL_MANGLING; 405 } 406 407 /* exported algorithm data: */ 408 static const struct i2c_algorithm pcf_algo = { 409 .master_xfer = pcf_xfer, 410 .functionality = pcf_func, 411 }; 412 413 /* 414 * registering functions to load algorithms at runtime 415 */ 416 int i2c_pcf_add_bus(struct i2c_adapter *adap) 417 { 418 struct i2c_algo_pcf_data *pcf_adap = adap->algo_data; 419 int rval; 420 421 DEB2(dev_dbg(&adap->dev, "hw routines registered.\n")); 422 423 /* register new adapter to i2c module... */ 424 adap->algo = &pcf_algo; 425 426 if ((rval = pcf_init_8584(pcf_adap))) 427 return rval; 428 429 rval = i2c_add_adapter(adap); 430 431 return rval; 432 } 433 EXPORT_SYMBOL(i2c_pcf_add_bus); 434 435 MODULE_AUTHOR("Hans Berglund <hb@spacetec.no>"); 436 MODULE_DESCRIPTION("I2C-Bus PCF8584 algorithm"); 437 MODULE_LICENSE("GPL"); 438 439 module_param(i2c_debug, int, S_IRUGO | S_IWUSR); 440 MODULE_PARM_DESC(i2c_debug, 441 "debug level - 0 off; 1 normal; 2,3 more verbose; 9 pcf-protocol"); 442