1 /* 2 * i2c-algo-pca.c i2c driver algorithms for PCA9564 adapters 3 * Copyright (C) 2004 Arcom Control Systems 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License as published by 7 * the Free Software Foundation; either version 2 of the License, or 8 * (at your option) any later version. 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program; if not, write to the Free Software 17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 18 */ 19 20 #include <linux/kernel.h> 21 #include <linux/module.h> 22 #include <linux/moduleparam.h> 23 #include <linux/delay.h> 24 #include <linux/slab.h> 25 #include <linux/init.h> 26 #include <linux/errno.h> 27 #include <linux/i2c.h> 28 #include <linux/i2c-algo-pca.h> 29 #include "i2c-algo-pca.h" 30 31 #define DRIVER "i2c-algo-pca" 32 33 #define DEB1(fmt, args...) do { if (i2c_debug>=1) printk(fmt, ## args); } while(0) 34 #define DEB2(fmt, args...) do { if (i2c_debug>=2) printk(fmt, ## args); } while(0) 35 #define DEB3(fmt, args...) do { if (i2c_debug>=3) printk(fmt, ## args); } while(0) 36 37 static int i2c_debug; 38 39 #define pca_outw(adap, reg, val) adap->write_byte(adap, reg, val) 40 #define pca_inw(adap, reg) adap->read_byte(adap, reg) 41 42 #define pca_status(adap) pca_inw(adap, I2C_PCA_STA) 43 #define pca_clock(adap) adap->get_clock(adap) 44 #define pca_own(adap) adap->get_own(adap) 45 #define pca_set_con(adap, val) pca_outw(adap, I2C_PCA_CON, val) 46 #define pca_get_con(adap) pca_inw(adap, I2C_PCA_CON) 47 #define pca_wait(adap) adap->wait_for_interrupt(adap) 48 49 /* 50 * Generate a start condition on the i2c bus. 51 * 52 * returns after the start condition has occurred 53 */ 54 static void pca_start(struct i2c_algo_pca_data *adap) 55 { 56 int sta = pca_get_con(adap); 57 DEB2("=== START\n"); 58 sta |= I2C_PCA_CON_STA; 59 sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_SI); 60 pca_set_con(adap, sta); 61 pca_wait(adap); 62 } 63 64 /* 65 * Generate a repeated start condition on the i2c bus 66 * 67 * return after the repeated start condition has occurred 68 */ 69 static void pca_repeated_start(struct i2c_algo_pca_data *adap) 70 { 71 int sta = pca_get_con(adap); 72 DEB2("=== REPEATED START\n"); 73 sta |= I2C_PCA_CON_STA; 74 sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_SI); 75 pca_set_con(adap, sta); 76 pca_wait(adap); 77 } 78 79 /* 80 * Generate a stop condition on the i2c bus 81 * 82 * returns after the stop condition has been generated 83 * 84 * STOPs do not generate an interrupt or set the SI flag, since the 85 * part returns the idle state (0xf8). Hence we don't need to 86 * pca_wait here. 87 */ 88 static void pca_stop(struct i2c_algo_pca_data *adap) 89 { 90 int sta = pca_get_con(adap); 91 DEB2("=== STOP\n"); 92 sta |= I2C_PCA_CON_STO; 93 sta &= ~(I2C_PCA_CON_STA|I2C_PCA_CON_SI); 94 pca_set_con(adap, sta); 95 } 96 97 /* 98 * Send the slave address and R/W bit 99 * 100 * returns after the address has been sent 101 */ 102 static void pca_address(struct i2c_algo_pca_data *adap, 103 struct i2c_msg *msg) 104 { 105 int sta = pca_get_con(adap); 106 int addr; 107 108 addr = ( (0x7f & msg->addr) << 1 ); 109 if (msg->flags & I2C_M_RD ) 110 addr |= 1; 111 DEB2("=== SLAVE ADDRESS %#04x+%c=%#04x\n", 112 msg->addr, msg->flags & I2C_M_RD ? 'R' : 'W', addr); 113 114 pca_outw(adap, I2C_PCA_DAT, addr); 115 116 sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_STA|I2C_PCA_CON_SI); 117 pca_set_con(adap, sta); 118 119 pca_wait(adap); 120 } 121 122 /* 123 * Transmit a byte. 124 * 125 * Returns after the byte has been transmitted 126 */ 127 static void pca_tx_byte(struct i2c_algo_pca_data *adap, 128 __u8 b) 129 { 130 int sta = pca_get_con(adap); 131 DEB2("=== WRITE %#04x\n", b); 132 pca_outw(adap, I2C_PCA_DAT, b); 133 134 sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_STA|I2C_PCA_CON_SI); 135 pca_set_con(adap, sta); 136 137 pca_wait(adap); 138 } 139 140 /* 141 * Receive a byte 142 * 143 * returns immediately. 144 */ 145 static void pca_rx_byte(struct i2c_algo_pca_data *adap, 146 __u8 *b, int ack) 147 { 148 *b = pca_inw(adap, I2C_PCA_DAT); 149 DEB2("=== READ %#04x %s\n", *b, ack ? "ACK" : "NACK"); 150 } 151 152 /* 153 * Setup ACK or NACK for next received byte and wait for it to arrive. 154 * 155 * Returns after next byte has arrived. 156 */ 157 static void pca_rx_ack(struct i2c_algo_pca_data *adap, 158 int ack) 159 { 160 int sta = pca_get_con(adap); 161 162 sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_STA|I2C_PCA_CON_SI|I2C_PCA_CON_AA); 163 164 if ( ack ) 165 sta |= I2C_PCA_CON_AA; 166 167 pca_set_con(adap, sta); 168 pca_wait(adap); 169 } 170 171 /* 172 * Reset the i2c bus / SIO 173 */ 174 static void pca_reset(struct i2c_algo_pca_data *adap) 175 { 176 /* apparently only an external reset will do it. not a lot can be done */ 177 printk(KERN_ERR DRIVER ": Haven't figured out how to do a reset yet\n"); 178 } 179 180 static int pca_xfer(struct i2c_adapter *i2c_adap, 181 struct i2c_msg *msgs, 182 int num) 183 { 184 struct i2c_algo_pca_data *adap = i2c_adap->algo_data; 185 struct i2c_msg *msg = NULL; 186 int curmsg; 187 int numbytes = 0; 188 int state; 189 int ret; 190 int timeout = 100; 191 192 while ((state = pca_status(adap)) != 0xf8 && timeout--) { 193 msleep(10); 194 } 195 if (state != 0xf8) { 196 dev_dbg(&i2c_adap->dev, "bus is not idle. status is %#04x\n", state); 197 return -EIO; 198 } 199 200 DEB1("{{{ XFER %d messages\n", num); 201 202 if (i2c_debug>=2) { 203 for (curmsg = 0; curmsg < num; curmsg++) { 204 int addr, i; 205 msg = &msgs[curmsg]; 206 207 addr = (0x7f & msg->addr) ; 208 209 if (msg->flags & I2C_M_RD ) 210 printk(KERN_INFO " [%02d] RD %d bytes from %#02x [%#02x, ...]\n", 211 curmsg, msg->len, addr, (addr<<1) | 1); 212 else { 213 printk(KERN_INFO " [%02d] WR %d bytes to %#02x [%#02x%s", 214 curmsg, msg->len, addr, addr<<1, 215 msg->len == 0 ? "" : ", "); 216 for(i=0; i < msg->len; i++) 217 printk("%#04x%s", msg->buf[i], i == msg->len - 1 ? "" : ", "); 218 printk("]\n"); 219 } 220 } 221 } 222 223 curmsg = 0; 224 ret = -EREMOTEIO; 225 while (curmsg < num) { 226 state = pca_status(adap); 227 228 DEB3("STATE is 0x%02x\n", state); 229 msg = &msgs[curmsg]; 230 231 switch (state) { 232 case 0xf8: /* On reset or stop the bus is idle */ 233 pca_start(adap); 234 break; 235 236 case 0x08: /* A START condition has been transmitted */ 237 case 0x10: /* A repeated start condition has been transmitted */ 238 pca_address(adap, msg); 239 break; 240 241 case 0x18: /* SLA+W has been transmitted; ACK has been received */ 242 case 0x28: /* Data byte in I2CDAT has been transmitted; ACK has been received */ 243 if (numbytes < msg->len) { 244 pca_tx_byte(adap, msg->buf[numbytes]); 245 numbytes++; 246 break; 247 } 248 curmsg++; numbytes = 0; 249 if (curmsg == num) 250 pca_stop(adap); 251 else 252 pca_repeated_start(adap); 253 break; 254 255 case 0x20: /* SLA+W has been transmitted; NOT ACK has been received */ 256 DEB2("NOT ACK received after SLA+W\n"); 257 pca_stop(adap); 258 goto out; 259 260 case 0x40: /* SLA+R has been transmitted; ACK has been received */ 261 pca_rx_ack(adap, msg->len > 1); 262 break; 263 264 case 0x50: /* Data bytes has been received; ACK has been returned */ 265 if (numbytes < msg->len) { 266 pca_rx_byte(adap, &msg->buf[numbytes], 1); 267 numbytes++; 268 pca_rx_ack(adap, numbytes < msg->len - 1); 269 break; 270 } 271 curmsg++; numbytes = 0; 272 if (curmsg == num) 273 pca_stop(adap); 274 else 275 pca_repeated_start(adap); 276 break; 277 278 case 0x48: /* SLA+R has been transmitted; NOT ACK has been received */ 279 DEB2("NOT ACK received after SLA+R\n"); 280 pca_stop(adap); 281 goto out; 282 283 case 0x30: /* Data byte in I2CDAT has been transmitted; NOT ACK has been received */ 284 DEB2("NOT ACK received after data byte\n"); 285 goto out; 286 287 case 0x38: /* Arbitration lost during SLA+W, SLA+R or data bytes */ 288 DEB2("Arbitration lost\n"); 289 goto out; 290 291 case 0x58: /* Data byte has been received; NOT ACK has been returned */ 292 if ( numbytes == msg->len - 1 ) { 293 pca_rx_byte(adap, &msg->buf[numbytes], 0); 294 curmsg++; numbytes = 0; 295 if (curmsg == num) 296 pca_stop(adap); 297 else 298 pca_repeated_start(adap); 299 } else { 300 DEB2("NOT ACK sent after data byte received. " 301 "Not final byte. numbytes %d. len %d\n", 302 numbytes, msg->len); 303 pca_stop(adap); 304 goto out; 305 } 306 break; 307 case 0x70: /* Bus error - SDA stuck low */ 308 DEB2("BUS ERROR - SDA Stuck low\n"); 309 pca_reset(adap); 310 goto out; 311 case 0x90: /* Bus error - SCL stuck low */ 312 DEB2("BUS ERROR - SCL Stuck low\n"); 313 pca_reset(adap); 314 goto out; 315 case 0x00: /* Bus error during master or slave mode due to illegal START or STOP condition */ 316 DEB2("BUS ERROR - Illegal START or STOP\n"); 317 pca_reset(adap); 318 goto out; 319 default: 320 printk(KERN_ERR DRIVER ": unhandled SIO state 0x%02x\n", state); 321 break; 322 } 323 324 } 325 326 ret = curmsg; 327 out: 328 DEB1(KERN_CRIT "}}} transfered %d/%d messages. " 329 "status is %#04x. control is %#04x\n", 330 curmsg, num, pca_status(adap), 331 pca_get_con(adap)); 332 return ret; 333 } 334 335 static u32 pca_func(struct i2c_adapter *adap) 336 { 337 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL; 338 } 339 340 static int pca_init(struct i2c_algo_pca_data *adap) 341 { 342 static int freqs[] = {330,288,217,146,88,59,44,36}; 343 int own, clock; 344 345 own = pca_own(adap); 346 clock = pca_clock(adap); 347 DEB1(KERN_INFO DRIVER ": own address is %#04x\n", own); 348 DEB1(KERN_INFO DRIVER ": clock freqeuncy is %dkHz\n", freqs[clock]); 349 350 pca_outw(adap, I2C_PCA_ADR, own << 1); 351 352 pca_set_con(adap, I2C_PCA_CON_ENSIO | clock); 353 udelay(500); /* 500 µs for oscilator to stabilise */ 354 355 return 0; 356 } 357 358 static const struct i2c_algorithm pca_algo = { 359 .master_xfer = pca_xfer, 360 .functionality = pca_func, 361 }; 362 363 /* 364 * registering functions to load algorithms at runtime 365 */ 366 int i2c_pca_add_bus(struct i2c_adapter *adap) 367 { 368 struct i2c_algo_pca_data *pca_adap = adap->algo_data; 369 int rval; 370 371 /* register new adapter to i2c module... */ 372 adap->algo = &pca_algo; 373 374 adap->timeout = 100; /* default values, should */ 375 adap->retries = 3; /* be replaced by defines */ 376 377 if ((rval = pca_init(pca_adap))) 378 return rval; 379 380 rval = i2c_add_adapter(adap); 381 382 return rval; 383 } 384 EXPORT_SYMBOL(i2c_pca_add_bus); 385 386 MODULE_AUTHOR("Ian Campbell <icampbell@arcom.com>"); 387 MODULE_DESCRIPTION("I2C-Bus PCA9564 algorithm"); 388 MODULE_LICENSE("GPL"); 389 390 module_param(i2c_debug, int, 0); 391