Thomas Gleixner | c942fdd | 2019-05-27 08:55:06 +0200 | [diff] [blame^] | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | /* |
Wolfram Sang | 3d43829 | 2008-04-22 22:16:46 +0200 | [diff] [blame] | 3 | * i2c-algo-pca.c i2c driver algorithms for PCA9564 adapters |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 4 | * Copyright (C) 2004 Arcom Control Systems |
Wolfram Sang | c01b083 | 2008-04-22 22:16:46 +0200 | [diff] [blame] | 5 | * Copyright (C) 2008 Pengutronix |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 6 | */ |
| 7 | |
| 8 | #include <linux/kernel.h> |
| 9 | #include <linux/module.h> |
| 10 | #include <linux/moduleparam.h> |
| 11 | #include <linux/delay.h> |
Wolfram Sang | 8e99ada | 2009-03-28 21:34:45 +0100 | [diff] [blame] | 12 | #include <linux/jiffies.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 13 | #include <linux/errno.h> |
| 14 | #include <linux/i2c.h> |
| 15 | #include <linux/i2c-algo-pca.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 16 | |
Frank Seidel | bac3e7c | 2009-03-28 21:34:44 +0100 | [diff] [blame] | 17 | #define DEB1(fmt, args...) do { if (i2c_debug >= 1) \ |
| 18 | printk(KERN_DEBUG fmt, ## args); } while (0) |
| 19 | #define DEB2(fmt, args...) do { if (i2c_debug >= 2) \ |
| 20 | printk(KERN_DEBUG fmt, ## args); } while (0) |
| 21 | #define DEB3(fmt, args...) do { if (i2c_debug >= 3) \ |
| 22 | printk(KERN_DEBUG fmt, ## args); } while (0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 23 | |
Jean Delvare | 6050709 | 2005-09-25 16:23:07 +0200 | [diff] [blame] | 24 | static int i2c_debug; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 25 | |
Wolfram Sang | c01b083 | 2008-04-22 22:16:46 +0200 | [diff] [blame] | 26 | #define pca_outw(adap, reg, val) adap->write_byte(adap->data, reg, val) |
| 27 | #define pca_inw(adap, reg) adap->read_byte(adap->data, reg) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 28 | |
| 29 | #define pca_status(adap) pca_inw(adap, I2C_PCA_STA) |
Wolfram Sang | c01b083 | 2008-04-22 22:16:46 +0200 | [diff] [blame] | 30 | #define pca_clock(adap) adap->i2c_clock |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 31 | #define pca_set_con(adap, val) pca_outw(adap, I2C_PCA_CON, val) |
| 32 | #define pca_get_con(adap) pca_inw(adap, I2C_PCA_CON) |
Wolfram Sang | c01b083 | 2008-04-22 22:16:46 +0200 | [diff] [blame] | 33 | #define pca_wait(adap) adap->wait_for_completion(adap->data) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 34 | |
Thomas Kavanagh | a76e7c6 | 2012-09-20 20:20:46 -0700 | [diff] [blame] | 35 | static void pca_reset(struct i2c_algo_pca_data *adap) |
Marco Aurelio da Costa | eff9ec9 | 2009-03-28 21:34:44 +0100 | [diff] [blame] | 36 | { |
Thomas Kavanagh | a76e7c6 | 2012-09-20 20:20:46 -0700 | [diff] [blame] | 37 | if (adap->chip == I2C_PCA_CHIP_9665) { |
| 38 | /* Ignore the reset function from the module, |
| 39 | * we can use the parallel bus reset. |
| 40 | */ |
| 41 | pca_outw(adap, I2C_PCA_INDPTR, I2C_PCA_IPRESET); |
| 42 | pca_outw(adap, I2C_PCA_IND, 0xA5); |
| 43 | pca_outw(adap, I2C_PCA_IND, 0x5A); |
| 44 | } else { |
| 45 | adap->reset_chip(adap->data); |
| 46 | } |
Marco Aurelio da Costa | eff9ec9 | 2009-03-28 21:34:44 +0100 | [diff] [blame] | 47 | } |
| 48 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 49 | /* |
| 50 | * Generate a start condition on the i2c bus. |
| 51 | * |
Steven Cole | 44bbe87 | 2005-05-03 18:21:25 -0600 | [diff] [blame] | 52 | * returns after the start condition has occurred |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 53 | */ |
Wolfram Sang | 2378bc0 | 2009-03-28 21:34:45 +0100 | [diff] [blame] | 54 | static int pca_start(struct i2c_algo_pca_data *adap) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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); |
Wolfram Sang | 2378bc0 | 2009-03-28 21:34:45 +0100 | [diff] [blame] | 61 | return pca_wait(adap); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 62 | } |
| 63 | |
| 64 | /* |
Tobias Klauser | 46b615f | 2005-05-19 22:27:23 +0200 | [diff] [blame] | 65 | * Generate a repeated start condition on the i2c bus |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 66 | * |
Steven Cole | 44bbe87 | 2005-05-03 18:21:25 -0600 | [diff] [blame] | 67 | * return after the repeated start condition has occurred |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 68 | */ |
Wolfram Sang | 2378bc0 | 2009-03-28 21:34:45 +0100 | [diff] [blame] | 69 | static int pca_repeated_start(struct i2c_algo_pca_data *adap) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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); |
Wolfram Sang | 2378bc0 | 2009-03-28 21:34:45 +0100 | [diff] [blame] | 76 | return pca_wait(adap); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 |
Tobias Klauser | 46b615f | 2005-05-19 22:27:23 +0200 | [diff] [blame] | 85 | * part returns the idle state (0xf8). Hence we don't need to |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | */ |
Wolfram Sang | 2378bc0 | 2009-03-28 21:34:45 +0100 | [diff] [blame] | 102 | static int pca_address(struct i2c_algo_pca_data *adap, |
Farid Hammane | 2086ca4 | 2010-05-21 18:41:00 +0200 | [diff] [blame] | 103 | struct i2c_msg *msg) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 104 | { |
| 105 | int sta = pca_get_con(adap); |
Peter Rosin | ac6d529 | 2018-05-16 09:16:46 +0200 | [diff] [blame] | 106 | int addr = i2c_8bit_addr_from_msg(msg); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 107 | |
Wolfram Sang | 3d43829 | 2008-04-22 22:16:46 +0200 | [diff] [blame] | 108 | DEB2("=== SLAVE ADDRESS %#04x+%c=%#04x\n", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 109 | msg->addr, msg->flags & I2C_M_RD ? 'R' : 'W', addr); |
Wolfram Sang | 3d43829 | 2008-04-22 22:16:46 +0200 | [diff] [blame] | 110 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Wolfram Sang | 2378bc0 | 2009-03-28 21:34:45 +0100 | [diff] [blame] | 116 | return pca_wait(adap); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 117 | } |
| 118 | |
| 119 | /* |
| 120 | * Transmit a byte. |
| 121 | * |
| 122 | * Returns after the byte has been transmitted |
| 123 | */ |
Wolfram Sang | 2378bc0 | 2009-03-28 21:34:45 +0100 | [diff] [blame] | 124 | static int pca_tx_byte(struct i2c_algo_pca_data *adap, |
Farid Hammane | 2086ca4 | 2010-05-21 18:41:00 +0200 | [diff] [blame] | 125 | __u8 b) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Wolfram Sang | 2378bc0 | 2009-03-28 21:34:45 +0100 | [diff] [blame] | 134 | return pca_wait(adap); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 135 | } |
| 136 | |
| 137 | /* |
| 138 | * Receive a byte |
| 139 | * |
| 140 | * returns immediately. |
| 141 | */ |
Wolfram Sang | 3d43829 | 2008-04-22 22:16:46 +0200 | [diff] [blame] | 142 | static void pca_rx_byte(struct i2c_algo_pca_data *adap, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Wolfram Sang | 3d43829 | 2008-04-22 22:16:46 +0200 | [diff] [blame] | 149 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 150 | * Setup ACK or NACK for next received byte and wait for it to arrive. |
| 151 | * |
| 152 | * Returns after next byte has arrived. |
| 153 | */ |
Wolfram Sang | 2378bc0 | 2009-03-28 21:34:45 +0100 | [diff] [blame] | 154 | static int pca_rx_ack(struct i2c_algo_pca_data *adap, |
Farid Hammane | 2086ca4 | 2010-05-21 18:41:00 +0200 | [diff] [blame] | 155 | int ack) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Farid Hammane | 2086ca4 | 2010-05-21 18:41:00 +0200 | [diff] [blame] | 161 | if (ack) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 162 | sta |= I2C_PCA_CON_AA; |
| 163 | |
| 164 | pca_set_con(adap, sta); |
Wolfram Sang | 2378bc0 | 2009-03-28 21:34:45 +0100 | [diff] [blame] | 165 | return pca_wait(adap); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 166 | } |
| 167 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 168 | static int pca_xfer(struct i2c_adapter *i2c_adap, |
Farid Hammane | 2086ca4 | 2010-05-21 18:41:00 +0200 | [diff] [blame] | 169 | struct i2c_msg *msgs, |
| 170 | int num) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 171 | { |
Farid Hammane | 2086ca4 | 2010-05-21 18:41:00 +0200 | [diff] [blame] | 172 | struct i2c_algo_pca_data *adap = i2c_adap->algo_data; |
| 173 | struct i2c_msg *msg = NULL; |
| 174 | int curmsg; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 175 | int numbytes = 0; |
| 176 | int state; |
| 177 | int ret; |
Wolfram Sang | 2378bc0 | 2009-03-28 21:34:45 +0100 | [diff] [blame] | 178 | int completed = 1; |
Wolfram Sang | 8e99ada | 2009-03-28 21:34:45 +0100 | [diff] [blame] | 179 | unsigned long timeout = jiffies + i2c_adap->timeout; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 180 | |
Jean Delvare | c454dee | 2009-04-13 17:02:13 +0200 | [diff] [blame] | 181 | while ((state = pca_status(adap)) != 0xf8) { |
Wolfram Sang | 8e99ada | 2009-03-28 21:34:45 +0100 | [diff] [blame] | 182 | if (time_before(jiffies, timeout)) { |
| 183 | msleep(10); |
| 184 | } else { |
| 185 | dev_dbg(&i2c_adap->dev, "bus is not idle. status is " |
| 186 | "%#04x\n", state); |
Jean Delvare | 4403988 | 2011-10-30 13:47:25 +0100 | [diff] [blame] | 187 | return -EBUSY; |
Wolfram Sang | 8e99ada | 2009-03-28 21:34:45 +0100 | [diff] [blame] | 188 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 189 | } |
| 190 | |
| 191 | DEB1("{{{ XFER %d messages\n", num); |
| 192 | |
Farid Hammane | 2086ca4 | 2010-05-21 18:41:00 +0200 | [diff] [blame] | 193 | if (i2c_debug >= 2) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 194 | for (curmsg = 0; curmsg < num; curmsg++) { |
| 195 | int addr, i; |
| 196 | msg = &msgs[curmsg]; |
Wolfram Sang | 3d43829 | 2008-04-22 22:16:46 +0200 | [diff] [blame] | 197 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 198 | addr = (0x7f & msg->addr) ; |
Wolfram Sang | 3d43829 | 2008-04-22 22:16:46 +0200 | [diff] [blame] | 199 | |
Farid Hammane | 2086ca4 | 2010-05-21 18:41:00 +0200 | [diff] [blame] | 200 | if (msg->flags & I2C_M_RD) |
Wolfram Sang | 3d43829 | 2008-04-22 22:16:46 +0200 | [diff] [blame] | 201 | printk(KERN_INFO " [%02d] RD %d bytes from %#02x [%#02x, ...]\n", |
Farid Hammane | 2086ca4 | 2010-05-21 18:41:00 +0200 | [diff] [blame] | 202 | curmsg, msg->len, addr, (addr << 1) | 1); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 203 | else { |
Wolfram Sang | 3d43829 | 2008-04-22 22:16:46 +0200 | [diff] [blame] | 204 | printk(KERN_INFO " [%02d] WR %d bytes to %#02x [%#02x%s", |
Farid Hammane | 2086ca4 | 2010-05-21 18:41:00 +0200 | [diff] [blame] | 205 | curmsg, msg->len, addr, addr << 1, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 206 | msg->len == 0 ? "" : ", "); |
Farid Hammane | 2086ca4 | 2010-05-21 18:41:00 +0200 | [diff] [blame] | 207 | for (i = 0; i < msg->len; i++) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 208 | printk("%#04x%s", msg->buf[i], i == msg->len - 1 ? "" : ", "); |
| 209 | printk("]\n"); |
| 210 | } |
| 211 | } |
| 212 | } |
| 213 | |
| 214 | curmsg = 0; |
Jean Delvare | 4403988 | 2011-10-30 13:47:25 +0100 | [diff] [blame] | 215 | ret = -EIO; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 216 | while (curmsg < num) { |
| 217 | state = pca_status(adap); |
| 218 | |
| 219 | DEB3("STATE is 0x%02x\n", state); |
| 220 | msg = &msgs[curmsg]; |
| 221 | |
| 222 | switch (state) { |
| 223 | case 0xf8: /* On reset or stop the bus is idle */ |
Wolfram Sang | 2378bc0 | 2009-03-28 21:34:45 +0100 | [diff] [blame] | 224 | completed = pca_start(adap); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 225 | break; |
| 226 | |
| 227 | case 0x08: /* A START condition has been transmitted */ |
| 228 | case 0x10: /* A repeated start condition has been transmitted */ |
Wolfram Sang | 2378bc0 | 2009-03-28 21:34:45 +0100 | [diff] [blame] | 229 | completed = pca_address(adap, msg); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 230 | break; |
Wolfram Sang | 3d43829 | 2008-04-22 22:16:46 +0200 | [diff] [blame] | 231 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 232 | case 0x18: /* SLA+W has been transmitted; ACK has been received */ |
| 233 | case 0x28: /* Data byte in I2CDAT has been transmitted; ACK has been received */ |
| 234 | if (numbytes < msg->len) { |
Wolfram Sang | 2378bc0 | 2009-03-28 21:34:45 +0100 | [diff] [blame] | 235 | completed = pca_tx_byte(adap, |
| 236 | msg->buf[numbytes]); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 237 | numbytes++; |
| 238 | break; |
| 239 | } |
| 240 | curmsg++; numbytes = 0; |
| 241 | if (curmsg == num) |
| 242 | pca_stop(adap); |
| 243 | else |
Wolfram Sang | 2378bc0 | 2009-03-28 21:34:45 +0100 | [diff] [blame] | 244 | completed = pca_repeated_start(adap); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 245 | break; |
| 246 | |
| 247 | case 0x20: /* SLA+W has been transmitted; NOT ACK has been received */ |
| 248 | DEB2("NOT ACK received after SLA+W\n"); |
| 249 | pca_stop(adap); |
Jean Delvare | 4403988 | 2011-10-30 13:47:25 +0100 | [diff] [blame] | 250 | ret = -ENXIO; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 251 | goto out; |
| 252 | |
| 253 | case 0x40: /* SLA+R has been transmitted; ACK has been received */ |
Wolfram Sang | 2378bc0 | 2009-03-28 21:34:45 +0100 | [diff] [blame] | 254 | completed = pca_rx_ack(adap, msg->len > 1); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 255 | break; |
| 256 | |
| 257 | case 0x50: /* Data bytes has been received; ACK has been returned */ |
| 258 | if (numbytes < msg->len) { |
| 259 | pca_rx_byte(adap, &msg->buf[numbytes], 1); |
| 260 | numbytes++; |
Wolfram Sang | 2378bc0 | 2009-03-28 21:34:45 +0100 | [diff] [blame] | 261 | completed = pca_rx_ack(adap, |
| 262 | numbytes < msg->len - 1); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 263 | break; |
| 264 | } |
| 265 | curmsg++; numbytes = 0; |
| 266 | if (curmsg == num) |
| 267 | pca_stop(adap); |
| 268 | else |
Wolfram Sang | 2378bc0 | 2009-03-28 21:34:45 +0100 | [diff] [blame] | 269 | completed = pca_repeated_start(adap); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 270 | break; |
| 271 | |
| 272 | case 0x48: /* SLA+R has been transmitted; NOT ACK has been received */ |
| 273 | DEB2("NOT ACK received after SLA+R\n"); |
| 274 | pca_stop(adap); |
Jean Delvare | 4403988 | 2011-10-30 13:47:25 +0100 | [diff] [blame] | 275 | ret = -ENXIO; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 276 | goto out; |
| 277 | |
| 278 | case 0x30: /* Data byte in I2CDAT has been transmitted; NOT ACK has been received */ |
| 279 | DEB2("NOT ACK received after data byte\n"); |
Enrik Berkhan | 2196d1c | 2009-05-05 08:39:25 +0200 | [diff] [blame] | 280 | pca_stop(adap); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 281 | goto out; |
| 282 | |
| 283 | case 0x38: /* Arbitration lost during SLA+W, SLA+R or data bytes */ |
| 284 | DEB2("Arbitration lost\n"); |
Enrik Berkhan | 2196d1c | 2009-05-05 08:39:25 +0200 | [diff] [blame] | 285 | /* |
| 286 | * The PCA9564 data sheet (2006-09-01) says "A |
| 287 | * START condition will be transmitted when the |
| 288 | * bus becomes free (STOP or SCL and SDA high)" |
| 289 | * when the STA bit is set (p. 11). |
| 290 | * |
| 291 | * In case this won't work, try pca_reset() |
| 292 | * instead. |
| 293 | */ |
| 294 | pca_start(adap); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 295 | goto out; |
Wolfram Sang | 3d43829 | 2008-04-22 22:16:46 +0200 | [diff] [blame] | 296 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 297 | case 0x58: /* Data byte has been received; NOT ACK has been returned */ |
Farid Hammane | 2086ca4 | 2010-05-21 18:41:00 +0200 | [diff] [blame] | 298 | if (numbytes == msg->len - 1) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 299 | pca_rx_byte(adap, &msg->buf[numbytes], 0); |
| 300 | curmsg++; numbytes = 0; |
| 301 | if (curmsg == num) |
| 302 | pca_stop(adap); |
| 303 | else |
Wolfram Sang | 2378bc0 | 2009-03-28 21:34:45 +0100 | [diff] [blame] | 304 | completed = pca_repeated_start(adap); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 305 | } else { |
| 306 | DEB2("NOT ACK sent after data byte received. " |
| 307 | "Not final byte. numbytes %d. len %d\n", |
| 308 | numbytes, msg->len); |
| 309 | pca_stop(adap); |
| 310 | goto out; |
| 311 | } |
| 312 | break; |
| 313 | case 0x70: /* Bus error - SDA stuck low */ |
| 314 | DEB2("BUS ERROR - SDA Stuck low\n"); |
| 315 | pca_reset(adap); |
| 316 | goto out; |
| 317 | case 0x90: /* Bus error - SCL stuck low */ |
| 318 | DEB2("BUS ERROR - SCL Stuck low\n"); |
| 319 | pca_reset(adap); |
| 320 | goto out; |
| 321 | case 0x00: /* Bus error during master or slave mode due to illegal START or STOP condition */ |
| 322 | DEB2("BUS ERROR - Illegal START or STOP\n"); |
| 323 | pca_reset(adap); |
| 324 | goto out; |
| 325 | default: |
Wolfram Sang | c01b083 | 2008-04-22 22:16:46 +0200 | [diff] [blame] | 326 | dev_err(&i2c_adap->dev, "unhandled SIO state 0x%02x\n", state); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 327 | break; |
| 328 | } |
Wolfram Sang | 3d43829 | 2008-04-22 22:16:46 +0200 | [diff] [blame] | 329 | |
Wolfram Sang | 2378bc0 | 2009-03-28 21:34:45 +0100 | [diff] [blame] | 330 | if (!completed) |
| 331 | goto out; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 332 | } |
| 333 | |
| 334 | ret = curmsg; |
| 335 | out: |
Lucas De Marchi | 25985ed | 2011-03-30 22:57:33 -0300 | [diff] [blame] | 336 | DEB1("}}} transferred %d/%d messages. " |
Wolfram Sang | 3d43829 | 2008-04-22 22:16:46 +0200 | [diff] [blame] | 337 | "status is %#04x. control is %#04x\n", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 338 | curmsg, num, pca_status(adap), |
| 339 | pca_get_con(adap)); |
| 340 | return ret; |
| 341 | } |
| 342 | |
| 343 | static u32 pca_func(struct i2c_adapter *adap) |
| 344 | { |
Farid Hammane | 2086ca4 | 2010-05-21 18:41:00 +0200 | [diff] [blame] | 345 | return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 346 | } |
| 347 | |
Jean Delvare | 9e11a9f | 2006-09-03 22:38:52 +0200 | [diff] [blame] | 348 | static const struct i2c_algorithm pca_algo = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 349 | .master_xfer = pca_xfer, |
| 350 | .functionality = pca_func, |
| 351 | }; |
| 352 | |
Marco Aurelio da Costa | eff9ec9 | 2009-03-28 21:34:44 +0100 | [diff] [blame] | 353 | static unsigned int pca_probe_chip(struct i2c_adapter *adap) |
| 354 | { |
| 355 | struct i2c_algo_pca_data *pca_data = adap->algo_data; |
| 356 | /* The trick here is to check if there is an indirect register |
| 357 | * available. If there is one, we will read the value we first |
| 358 | * wrote on I2C_PCA_IADR. Otherwise, we will read the last value |
| 359 | * we wrote on I2C_PCA_ADR |
| 360 | */ |
| 361 | pca_outw(pca_data, I2C_PCA_INDPTR, I2C_PCA_IADR); |
| 362 | pca_outw(pca_data, I2C_PCA_IND, 0xAA); |
| 363 | pca_outw(pca_data, I2C_PCA_INDPTR, I2C_PCA_ITO); |
| 364 | pca_outw(pca_data, I2C_PCA_IND, 0x00); |
| 365 | pca_outw(pca_data, I2C_PCA_INDPTR, I2C_PCA_IADR); |
| 366 | if (pca_inw(pca_data, I2C_PCA_IND) == 0xAA) { |
| 367 | printk(KERN_INFO "%s: PCA9665 detected.\n", adap->name); |
Thomas Kavanagh | a76e7c6 | 2012-09-20 20:20:46 -0700 | [diff] [blame] | 368 | pca_data->chip = I2C_PCA_CHIP_9665; |
Marco Aurelio da Costa | eff9ec9 | 2009-03-28 21:34:44 +0100 | [diff] [blame] | 369 | } else { |
| 370 | printk(KERN_INFO "%s: PCA9564 detected.\n", adap->name); |
Thomas Kavanagh | a76e7c6 | 2012-09-20 20:20:46 -0700 | [diff] [blame] | 371 | pca_data->chip = I2C_PCA_CHIP_9564; |
Marco Aurelio da Costa | eff9ec9 | 2009-03-28 21:34:44 +0100 | [diff] [blame] | 372 | } |
Thomas Kavanagh | a76e7c6 | 2012-09-20 20:20:46 -0700 | [diff] [blame] | 373 | return pca_data->chip; |
Marco Aurelio da Costa | eff9ec9 | 2009-03-28 21:34:44 +0100 | [diff] [blame] | 374 | } |
| 375 | |
Wolfram Sang | c01b083 | 2008-04-22 22:16:46 +0200 | [diff] [blame] | 376 | static int pca_init(struct i2c_adapter *adap) |
| 377 | { |
Wolfram Sang | c01b083 | 2008-04-22 22:16:46 +0200 | [diff] [blame] | 378 | struct i2c_algo_pca_data *pca_data = adap->algo_data; |
| 379 | |
Wolfram Sang | c01b083 | 2008-04-22 22:16:46 +0200 | [diff] [blame] | 380 | adap->algo = &pca_algo; |
| 381 | |
Marco Aurelio da Costa | eff9ec9 | 2009-03-28 21:34:44 +0100 | [diff] [blame] | 382 | if (pca_probe_chip(adap) == I2C_PCA_CHIP_9564) { |
| 383 | static int freqs[] = {330, 288, 217, 146, 88, 59, 44, 36}; |
| 384 | int clock; |
Wolfram Sang | c01b083 | 2008-04-22 22:16:46 +0200 | [diff] [blame] | 385 | |
Marco Aurelio da Costa | eff9ec9 | 2009-03-28 21:34:44 +0100 | [diff] [blame] | 386 | if (pca_data->i2c_clock > 7) { |
| 387 | switch (pca_data->i2c_clock) { |
| 388 | case 330000: |
| 389 | pca_data->i2c_clock = I2C_PCA_CON_330kHz; |
| 390 | break; |
| 391 | case 288000: |
| 392 | pca_data->i2c_clock = I2C_PCA_CON_288kHz; |
| 393 | break; |
| 394 | case 217000: |
| 395 | pca_data->i2c_clock = I2C_PCA_CON_217kHz; |
| 396 | break; |
| 397 | case 146000: |
| 398 | pca_data->i2c_clock = I2C_PCA_CON_146kHz; |
| 399 | break; |
| 400 | case 88000: |
| 401 | pca_data->i2c_clock = I2C_PCA_CON_88kHz; |
| 402 | break; |
| 403 | case 59000: |
| 404 | pca_data->i2c_clock = I2C_PCA_CON_59kHz; |
| 405 | break; |
| 406 | case 44000: |
| 407 | pca_data->i2c_clock = I2C_PCA_CON_44kHz; |
| 408 | break; |
| 409 | case 36000: |
| 410 | pca_data->i2c_clock = I2C_PCA_CON_36kHz; |
| 411 | break; |
| 412 | default: |
| 413 | printk(KERN_WARNING |
| 414 | "%s: Invalid I2C clock speed selected." |
| 415 | " Using default 59kHz.\n", adap->name); |
| 416 | pca_data->i2c_clock = I2C_PCA_CON_59kHz; |
| 417 | } |
| 418 | } else { |
| 419 | printk(KERN_WARNING "%s: " |
| 420 | "Choosing the clock frequency based on " |
| 421 | "index is deprecated." |
| 422 | " Use the nominal frequency.\n", adap->name); |
| 423 | } |
Wolfram Sang | c01b083 | 2008-04-22 22:16:46 +0200 | [diff] [blame] | 424 | |
Marco Aurelio da Costa | eff9ec9 | 2009-03-28 21:34:44 +0100 | [diff] [blame] | 425 | pca_reset(pca_data); |
| 426 | |
| 427 | clock = pca_clock(pca_data); |
| 428 | printk(KERN_INFO "%s: Clock frequency is %dkHz\n", |
| 429 | adap->name, freqs[clock]); |
| 430 | |
| 431 | pca_set_con(pca_data, I2C_PCA_CON_ENSIO | clock); |
| 432 | } else { |
| 433 | int clock; |
| 434 | int mode; |
| 435 | int tlow, thi; |
| 436 | /* Values can be found on PCA9665 datasheet section 7.3.2.6 */ |
| 437 | int min_tlow, min_thi; |
| 438 | /* These values are the maximum raise and fall values allowed |
| 439 | * by the I2C operation mode (Standard, Fast or Fast+) |
| 440 | * They are used (added) below to calculate the clock dividers |
| 441 | * of PCA9665. Note that they are slightly different of the |
| 442 | * real maximum, to allow the change on mode exactly on the |
| 443 | * maximum clock rate for each mode |
| 444 | */ |
| 445 | int raise_fall_time; |
| 446 | |
Marco Aurelio da Costa | eff9ec9 | 2009-03-28 21:34:44 +0100 | [diff] [blame] | 447 | if (pca_data->i2c_clock > 1265800) { |
| 448 | printk(KERN_WARNING "%s: I2C clock speed too high." |
| 449 | " Using 1265.8kHz.\n", adap->name); |
| 450 | pca_data->i2c_clock = 1265800; |
| 451 | } |
| 452 | |
| 453 | if (pca_data->i2c_clock < 60300) { |
| 454 | printk(KERN_WARNING "%s: I2C clock speed too low." |
| 455 | " Using 60.3kHz.\n", adap->name); |
| 456 | pca_data->i2c_clock = 60300; |
| 457 | } |
| 458 | |
| 459 | /* To avoid integer overflow, use clock/100 for calculations */ |
| 460 | clock = pca_clock(pca_data) / 100; |
| 461 | |
Thomas Kavanagh | 5f71a3e | 2012-09-13 08:16:55 -0700 | [diff] [blame] | 462 | if (pca_data->i2c_clock > 1000000) { |
Marco Aurelio da Costa | eff9ec9 | 2009-03-28 21:34:44 +0100 | [diff] [blame] | 463 | mode = I2C_PCA_MODE_TURBO; |
| 464 | min_tlow = 14; |
| 465 | min_thi = 5; |
| 466 | raise_fall_time = 22; /* Raise 11e-8s, Fall 11e-8s */ |
Thomas Kavanagh | 5f71a3e | 2012-09-13 08:16:55 -0700 | [diff] [blame] | 467 | } else if (pca_data->i2c_clock > 400000) { |
Marco Aurelio da Costa | eff9ec9 | 2009-03-28 21:34:44 +0100 | [diff] [blame] | 468 | mode = I2C_PCA_MODE_FASTP; |
| 469 | min_tlow = 17; |
| 470 | min_thi = 9; |
| 471 | raise_fall_time = 22; /* Raise 11e-8s, Fall 11e-8s */ |
Thomas Kavanagh | 5f71a3e | 2012-09-13 08:16:55 -0700 | [diff] [blame] | 472 | } else if (pca_data->i2c_clock > 100000) { |
Marco Aurelio da Costa | eff9ec9 | 2009-03-28 21:34:44 +0100 | [diff] [blame] | 473 | mode = I2C_PCA_MODE_FAST; |
| 474 | min_tlow = 44; |
| 475 | min_thi = 20; |
| 476 | raise_fall_time = 58; /* Raise 29e-8s, Fall 29e-8s */ |
| 477 | } else { |
| 478 | mode = I2C_PCA_MODE_STD; |
| 479 | min_tlow = 157; |
| 480 | min_thi = 134; |
| 481 | raise_fall_time = 127; /* Raise 29e-8s, Fall 98e-8s */ |
| 482 | } |
| 483 | |
| 484 | /* The minimum clock that respects the thi/tlow = 134/157 is |
| 485 | * 64800 Hz. Below that, we have to fix the tlow to 255 and |
| 486 | * calculate the thi factor. |
| 487 | */ |
| 488 | if (clock < 648) { |
| 489 | tlow = 255; |
| 490 | thi = 1000000 - clock * raise_fall_time; |
| 491 | thi /= (I2C_PCA_OSC_PER * clock) - tlow; |
| 492 | } else { |
| 493 | tlow = (1000000 - clock * raise_fall_time) * min_tlow; |
| 494 | tlow /= I2C_PCA_OSC_PER * clock * (min_thi + min_tlow); |
| 495 | thi = tlow * min_thi / min_tlow; |
| 496 | } |
| 497 | |
| 498 | pca_reset(pca_data); |
| 499 | |
| 500 | printk(KERN_INFO |
| 501 | "%s: Clock frequency is %dHz\n", adap->name, clock * 100); |
| 502 | |
| 503 | pca_outw(pca_data, I2C_PCA_INDPTR, I2C_PCA_IMODE); |
| 504 | pca_outw(pca_data, I2C_PCA_IND, mode); |
| 505 | pca_outw(pca_data, I2C_PCA_INDPTR, I2C_PCA_ISCLL); |
| 506 | pca_outw(pca_data, I2C_PCA_IND, tlow); |
| 507 | pca_outw(pca_data, I2C_PCA_INDPTR, I2C_PCA_ISCLH); |
| 508 | pca_outw(pca_data, I2C_PCA_IND, thi); |
| 509 | |
| 510 | pca_set_con(pca_data, I2C_PCA_CON_ENSIO); |
| 511 | } |
Shailendra Verma | 0e6dd6a | 2015-05-18 22:37:54 +0530 | [diff] [blame] | 512 | udelay(500); /* 500 us for oscillator to stabilise */ |
Wolfram Sang | c01b083 | 2008-04-22 22:16:46 +0200 | [diff] [blame] | 513 | |
| 514 | return 0; |
| 515 | } |
| 516 | |
Wolfram Sang | 3d43829 | 2008-04-22 22:16:46 +0200 | [diff] [blame] | 517 | /* |
| 518 | * registering functions to load algorithms at runtime |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 519 | */ |
| 520 | int i2c_pca_add_bus(struct i2c_adapter *adap) |
| 521 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 522 | int rval; |
| 523 | |
Wolfram Sang | c01b083 | 2008-04-22 22:16:46 +0200 | [diff] [blame] | 524 | rval = pca_init(adap); |
| 525 | if (rval) |
Mark M. Hoffman | b39ad0c | 2006-07-01 17:16:06 +0200 | [diff] [blame] | 526 | return rval; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 527 | |
Wolfram Sang | c01b083 | 2008-04-22 22:16:46 +0200 | [diff] [blame] | 528 | return i2c_add_adapter(adap); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 529 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 530 | EXPORT_SYMBOL(i2c_pca_add_bus); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 531 | |
Wolfram Sang | c01b083 | 2008-04-22 22:16:46 +0200 | [diff] [blame] | 532 | int i2c_pca_add_numbered_bus(struct i2c_adapter *adap) |
| 533 | { |
| 534 | int rval; |
| 535 | |
| 536 | rval = pca_init(adap); |
| 537 | if (rval) |
| 538 | return rval; |
| 539 | |
| 540 | return i2c_add_numbered_adapter(adap); |
| 541 | } |
| 542 | EXPORT_SYMBOL(i2c_pca_add_numbered_bus); |
| 543 | |
| 544 | MODULE_AUTHOR("Ian Campbell <icampbell@arcom.com>, " |
| 545 | "Wolfram Sang <w.sang@pengutronix.de>"); |
Marco Aurelio da Costa | eff9ec9 | 2009-03-28 21:34:44 +0100 | [diff] [blame] | 546 | MODULE_DESCRIPTION("I2C-Bus PCA9564/PCA9665 algorithm"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 547 | MODULE_LICENSE("GPL"); |
| 548 | |
| 549 | module_param(i2c_debug, int, 0); |