1 /* 2 * 3 * device driver for philips saa7134 based TV cards 4 * i2c interface support 5 * 6 * (c) 2001,02 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs] 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 21 */ 22 23 #include "saa7134.h" 24 #include "saa7134-reg.h" 25 26 #include <linux/init.h> 27 #include <linux/list.h> 28 #include <linux/module.h> 29 #include <linux/kernel.h> 30 #include <linux/delay.h> 31 32 #include <media/v4l2-common.h> 33 34 /* ----------------------------------------------------------- */ 35 36 static unsigned int i2c_debug; 37 module_param(i2c_debug, int, 0644); 38 MODULE_PARM_DESC(i2c_debug,"enable debug messages [i2c]"); 39 40 static unsigned int i2c_scan; 41 module_param(i2c_scan, int, 0444); 42 MODULE_PARM_DESC(i2c_scan,"scan i2c bus at insmod time"); 43 44 #define i2c_dbg(level, fmt, arg...) do { \ 45 if (i2c_debug == level) \ 46 printk(KERN_DEBUG pr_fmt("i2c: " fmt), ## arg); \ 47 } while (0) 48 49 #define i2c_cont(level, fmt, arg...) do { \ 50 if (i2c_debug == level) \ 51 pr_cont(fmt, ## arg); \ 52 } while (0) 53 54 #define I2C_WAIT_DELAY 32 55 #define I2C_WAIT_RETRY 16 56 57 /* ----------------------------------------------------------- */ 58 59 static char *str_i2c_status[] = { 60 "IDLE", "DONE_STOP", "BUSY", "TO_SCL", "TO_ARB", "DONE_WRITE", 61 "DONE_READ", "DONE_WRITE_TO", "DONE_READ_TO", "NO_DEVICE", 62 "NO_ACKN", "BUS_ERR", "ARB_LOST", "SEQ_ERR", "ST_ERR", "SW_ERR" 63 }; 64 65 enum i2c_status { 66 IDLE = 0, // no I2C command pending 67 DONE_STOP = 1, // I2C command done and STOP executed 68 BUSY = 2, // executing I2C command 69 TO_SCL = 3, // executing I2C command, time out on clock stretching 70 TO_ARB = 4, // time out on arbitration trial, still trying 71 DONE_WRITE = 5, // I2C command done and awaiting next write command 72 DONE_READ = 6, // I2C command done and awaiting next read command 73 DONE_WRITE_TO = 7, // see 5, and time out on status echo 74 DONE_READ_TO = 8, // see 6, and time out on status echo 75 NO_DEVICE = 9, // no acknowledge on device slave address 76 NO_ACKN = 10, // no acknowledge after data byte transfer 77 BUS_ERR = 11, // bus error 78 ARB_LOST = 12, // arbitration lost during transfer 79 SEQ_ERR = 13, // erroneous programming sequence 80 ST_ERR = 14, // wrong status echoing 81 SW_ERR = 15 // software error 82 }; 83 84 static char *str_i2c_attr[] = { 85 "NOP", "STOP", "CONTINUE", "START" 86 }; 87 88 enum i2c_attr { 89 NOP = 0, // no operation on I2C bus 90 STOP = 1, // stop condition, no associated byte transfer 91 CONTINUE = 2, // continue with byte transfer 92 START = 3 // start condition with byte transfer 93 }; 94 95 static inline enum i2c_status i2c_get_status(struct saa7134_dev *dev) 96 { 97 enum i2c_status status; 98 99 status = saa_readb(SAA7134_I2C_ATTR_STATUS) & 0x0f; 100 i2c_dbg(2, "i2c stat <= %s\n", str_i2c_status[status]); 101 return status; 102 } 103 104 static inline void i2c_set_status(struct saa7134_dev *dev, 105 enum i2c_status status) 106 { 107 i2c_dbg(2, "i2c stat => %s\n", str_i2c_status[status]); 108 saa_andorb(SAA7134_I2C_ATTR_STATUS,0x0f,status); 109 } 110 111 static inline void i2c_set_attr(struct saa7134_dev *dev, enum i2c_attr attr) 112 { 113 i2c_dbg(2, "i2c attr => %s\n", str_i2c_attr[attr]); 114 saa_andorb(SAA7134_I2C_ATTR_STATUS,0xc0,attr << 6); 115 } 116 117 static inline int i2c_is_error(enum i2c_status status) 118 { 119 switch (status) { 120 case NO_DEVICE: 121 case NO_ACKN: 122 case BUS_ERR: 123 case ARB_LOST: 124 case SEQ_ERR: 125 case ST_ERR: 126 return true; 127 default: 128 return false; 129 } 130 } 131 132 static inline int i2c_is_idle(enum i2c_status status) 133 { 134 switch (status) { 135 case IDLE: 136 case DONE_STOP: 137 return true; 138 default: 139 return false; 140 } 141 } 142 143 static inline int i2c_is_busy(enum i2c_status status) 144 { 145 switch (status) { 146 case BUSY: 147 case TO_SCL: 148 case TO_ARB: 149 return true; 150 default: 151 return false; 152 } 153 } 154 155 static int i2c_is_busy_wait(struct saa7134_dev *dev) 156 { 157 enum i2c_status status; 158 int count; 159 160 for (count = 0; count < I2C_WAIT_RETRY; count++) { 161 status = i2c_get_status(dev); 162 if (!i2c_is_busy(status)) 163 break; 164 saa_wait(I2C_WAIT_DELAY); 165 } 166 if (I2C_WAIT_RETRY == count) 167 return false; 168 return true; 169 } 170 171 static int i2c_reset(struct saa7134_dev *dev) 172 { 173 enum i2c_status status; 174 int count; 175 176 i2c_dbg(2, "i2c reset\n"); 177 status = i2c_get_status(dev); 178 if (!i2c_is_error(status)) 179 return true; 180 i2c_set_status(dev,status); 181 182 for (count = 0; count < I2C_WAIT_RETRY; count++) { 183 status = i2c_get_status(dev); 184 if (!i2c_is_error(status)) 185 break; 186 udelay(I2C_WAIT_DELAY); 187 } 188 if (I2C_WAIT_RETRY == count) 189 return false; 190 191 if (!i2c_is_idle(status)) 192 return false; 193 194 i2c_set_attr(dev,NOP); 195 return true; 196 } 197 198 static inline int i2c_send_byte(struct saa7134_dev *dev, 199 enum i2c_attr attr, 200 unsigned char data) 201 { 202 enum i2c_status status; 203 __u32 dword; 204 205 /* have to write both attr + data in one 32bit word */ 206 dword = saa_readl(SAA7134_I2C_ATTR_STATUS >> 2); 207 dword &= 0x0f; 208 dword |= (attr << 6); 209 dword |= ((__u32)data << 8); 210 dword |= 0x00 << 16; /* 100 kHz */ 211 // dword |= 0x40 << 16; /* 400 kHz */ 212 dword |= 0xf0 << 24; 213 saa_writel(SAA7134_I2C_ATTR_STATUS >> 2, dword); 214 i2c_dbg(2, "i2c data => 0x%x\n", data); 215 216 if (!i2c_is_busy_wait(dev)) 217 return -EIO; 218 status = i2c_get_status(dev); 219 if (i2c_is_error(status)) 220 return -EIO; 221 return 0; 222 } 223 224 static inline int i2c_recv_byte(struct saa7134_dev *dev) 225 { 226 enum i2c_status status; 227 unsigned char data; 228 229 i2c_set_attr(dev,CONTINUE); 230 if (!i2c_is_busy_wait(dev)) 231 return -EIO; 232 status = i2c_get_status(dev); 233 if (i2c_is_error(status)) 234 return -EIO; 235 data = saa_readb(SAA7134_I2C_DATA); 236 i2c_dbg(2, "i2c data <= 0x%x\n", data); 237 return data; 238 } 239 240 static int saa7134_i2c_xfer(struct i2c_adapter *i2c_adap, 241 struct i2c_msg *msgs, int num) 242 { 243 struct saa7134_dev *dev = i2c_adap->algo_data; 244 enum i2c_status status; 245 unsigned char data; 246 int addr,rc,i,byte; 247 248 status = i2c_get_status(dev); 249 if (!i2c_is_idle(status)) 250 if (!i2c_reset(dev)) 251 return -EIO; 252 253 i2c_dbg(2, "start xfer\n"); 254 i2c_dbg(1, "i2c xfer:"); 255 for (i = 0; i < num; i++) { 256 if (!(msgs[i].flags & I2C_M_NOSTART) || 0 == i) { 257 /* send address */ 258 i2c_dbg(2, "send address\n"); 259 addr = msgs[i].addr << 1; 260 if (msgs[i].flags & I2C_M_RD) 261 addr |= 1; 262 if (i > 0 && msgs[i].flags & 263 I2C_M_RD && msgs[i].addr != 0x40 && 264 msgs[i].addr != 0x41 && 265 msgs[i].addr != 0x19) { 266 /* workaround for a saa7134 i2c bug 267 * needed to talk to the mt352 demux 268 * thanks to pinnacle for the hint */ 269 int quirk = 0xfe; 270 i2c_cont(1, " [%02x quirk]", quirk); 271 i2c_send_byte(dev,START,quirk); 272 i2c_recv_byte(dev); 273 } 274 i2c_cont(1, " < %02x", addr); 275 rc = i2c_send_byte(dev,START,addr); 276 if (rc < 0) 277 goto err; 278 } 279 if (msgs[i].flags & I2C_M_RD) { 280 /* read bytes */ 281 i2c_dbg(2, "read bytes\n"); 282 for (byte = 0; byte < msgs[i].len; byte++) { 283 i2c_cont(1, " ="); 284 rc = i2c_recv_byte(dev); 285 if (rc < 0) 286 goto err; 287 i2c_cont(1, "%02x", rc); 288 msgs[i].buf[byte] = rc; 289 } 290 /* discard mysterious extra byte when reading 291 from Samsung S5H1411. i2c bus gets error 292 if we do not. */ 293 if (0x19 == msgs[i].addr) { 294 i2c_cont(1, " ?"); 295 rc = i2c_recv_byte(dev); 296 if (rc < 0) 297 goto err; 298 i2c_cont(1, "%02x", rc); 299 } 300 } else { 301 /* write bytes */ 302 i2c_dbg(2, "write bytes\n"); 303 for (byte = 0; byte < msgs[i].len; byte++) { 304 data = msgs[i].buf[byte]; 305 i2c_cont(1, " %02x", data); 306 rc = i2c_send_byte(dev,CONTINUE,data); 307 if (rc < 0) 308 goto err; 309 } 310 } 311 } 312 i2c_dbg(2, "xfer done\n"); 313 i2c_cont(1, " >"); 314 i2c_set_attr(dev,STOP); 315 rc = -EIO; 316 if (!i2c_is_busy_wait(dev)) 317 goto err; 318 status = i2c_get_status(dev); 319 if (i2c_is_error(status)) 320 goto err; 321 /* ensure that the bus is idle for at least one bit slot */ 322 msleep(1); 323 324 i2c_cont(1, "\n"); 325 return num; 326 err: 327 if (1 == i2c_debug) { 328 status = i2c_get_status(dev); 329 i2c_cont(1, " ERROR: %s\n", str_i2c_status[status]); 330 } 331 return rc; 332 } 333 334 /* ----------------------------------------------------------- */ 335 336 static u32 functionality(struct i2c_adapter *adap) 337 { 338 return I2C_FUNC_SMBUS_EMUL; 339 } 340 341 static struct i2c_algorithm saa7134_algo = { 342 .master_xfer = saa7134_i2c_xfer, 343 .functionality = functionality, 344 }; 345 346 static struct i2c_adapter saa7134_adap_template = { 347 .owner = THIS_MODULE, 348 .name = "saa7134", 349 .algo = &saa7134_algo, 350 }; 351 352 static struct i2c_client saa7134_client_template = { 353 .name = "saa7134 internal", 354 }; 355 356 /* ----------------------------------------------------------- */ 357 358 static int 359 saa7134_i2c_eeprom(struct saa7134_dev *dev, unsigned char *eedata, int len) 360 { 361 unsigned char buf; 362 int i,err; 363 364 dev->i2c_client.addr = 0xa0 >> 1; 365 buf = 0; 366 if (1 != (err = i2c_master_send(&dev->i2c_client,&buf,1))) { 367 pr_info("%s: Huh, no eeprom present (err=%d)?\n", 368 dev->name,err); 369 return -1; 370 } 371 if (len != (err = i2c_master_recv(&dev->i2c_client,eedata,len))) { 372 pr_warn("%s: i2c eeprom read error (err=%d)\n", 373 dev->name,err); 374 return -1; 375 } 376 377 for (i = 0; i < len; i += 16) { 378 int size = (len - i) > 16 ? 16 : len - i; 379 380 pr_info("i2c eeprom %02x: %*ph\n", i, size, &eedata[i]); 381 } 382 383 return 0; 384 } 385 386 static char *i2c_devs[128] = { 387 [ 0x20 ] = "mpeg encoder (saa6752hs)", 388 [ 0xa0 >> 1 ] = "eeprom", 389 [ 0xc0 >> 1 ] = "tuner (analog)", 390 [ 0x86 >> 1 ] = "tda9887", 391 [ 0x5a >> 1 ] = "remote control", 392 }; 393 394 static void do_i2c_scan(struct i2c_client *c) 395 { 396 unsigned char buf; 397 int i,rc; 398 399 for (i = 0; i < ARRAY_SIZE(i2c_devs); i++) { 400 c->addr = i; 401 rc = i2c_master_recv(c,&buf,0); 402 if (rc < 0) 403 continue; 404 pr_info("i2c scan: found device @ 0x%x [%s]\n", 405 i << 1, i2c_devs[i] ? i2c_devs[i] : "???"); 406 } 407 } 408 409 int saa7134_i2c_register(struct saa7134_dev *dev) 410 { 411 dev->i2c_adap = saa7134_adap_template; 412 dev->i2c_adap.dev.parent = &dev->pci->dev; 413 strcpy(dev->i2c_adap.name,dev->name); 414 dev->i2c_adap.algo_data = dev; 415 i2c_set_adapdata(&dev->i2c_adap, &dev->v4l2_dev); 416 i2c_add_adapter(&dev->i2c_adap); 417 418 dev->i2c_client = saa7134_client_template; 419 dev->i2c_client.adapter = &dev->i2c_adap; 420 421 saa7134_i2c_eeprom(dev,dev->eedata,sizeof(dev->eedata)); 422 if (i2c_scan) 423 do_i2c_scan(&dev->i2c_client); 424 425 /* Instantiate the IR receiver device, if present */ 426 saa7134_probe_i2c_ir(dev); 427 return 0; 428 } 429 430 int saa7134_i2c_unregister(struct saa7134_dev *dev) 431 { 432 i2c_del_adapter(&dev->i2c_adap); 433 return 0; 434 } 435