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