1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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
36static unsigned int i2c_debug;
37module_param(i2c_debug, int, 0644);
38MODULE_PARM_DESC(i2c_debug,"enable debug messages [i2c]");
39
40static unsigned int i2c_scan;
41module_param(i2c_scan, int, 0444);
42MODULE_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
59static 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
65enum i2c_status {
66 IDLE = 0,
67 DONE_STOP = 1,
68 BUSY = 2,
69 TO_SCL = 3,
70 TO_ARB = 4,
71 DONE_WRITE = 5,
72 DONE_READ = 6,
73 DONE_WRITE_TO = 7,
74 DONE_READ_TO = 8,
75 NO_DEVICE = 9,
76 NO_ACKN = 10,
77 BUS_ERR = 11,
78 ARB_LOST = 12,
79 SEQ_ERR = 13,
80 ST_ERR = 14,
81 SW_ERR = 15
82};
83
84static char *str_i2c_attr[] = {
85 "NOP", "STOP", "CONTINUE", "START"
86};
87
88enum i2c_attr {
89 NOP = 0,
90 STOP = 1,
91 CONTINUE = 2,
92 START = 3
93};
94
95static 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
104static 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
111static 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
117static 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
132static 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
143static 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
155static 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
171static 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
198static 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
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;
211
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
224static 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
240static 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
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
267
268
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
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
291
292
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
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
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
336static u32 functionality(struct i2c_adapter *adap)
337{
338 return I2C_FUNC_SMBUS_EMUL;
339}
340
341static const struct i2c_algorithm saa7134_algo = {
342 .master_xfer = saa7134_i2c_xfer,
343 .functionality = functionality,
344};
345
346static struct i2c_adapter saa7134_adap_template = {
347 .owner = THIS_MODULE,
348 .name = "saa7134",
349 .algo = &saa7134_algo,
350};
351
352static struct i2c_client saa7134_client_template = {
353 .name = "saa7134 internal",
354};
355
356
357
358static int
359saa7134_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
386static 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
394static 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
409int 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
426 saa7134_probe_i2c_ir(dev);
427 return 0;
428}
429
430int saa7134_i2c_unregister(struct saa7134_dev *dev)
431{
432 i2c_del_adapter(&dev->i2c_adap);
433 return 0;
434}
435
