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