1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <linux/module.h>
24#include <linux/kernel.h>
25#include <linux/usb.h>
26#include <linux/i2c.h>
27#include <media/v4l2-common.h>
28#include <media/tuner.h>
29
30#include "cx231xx.h"
31
32
33
34static unsigned int i2c_scan;
35module_param(i2c_scan, int, 0444);
36MODULE_PARM_DESC(i2c_scan, "scan i2c bus at insmod time");
37
38static unsigned int i2c_debug;
39module_param(i2c_debug, int, 0644);
40MODULE_PARM_DESC(i2c_debug, "enable debug messages [i2c]");
41
42#define dprintk1(lvl, fmt, args...) \
43do { \
44 if (i2c_debug >= lvl) { \
45 printk(fmt, ##args); \
46 } \
47} while (0)
48
49#define dprintk2(lvl, fmt, args...) \
50do { \
51 if (i2c_debug >= lvl) { \
52 printk(KERN_DEBUG "%s at %s: " fmt, \
53 dev->name, __func__ , ##args); \
54 } \
55} while (0)
56
57
58
59
60int cx231xx_i2c_send_bytes(struct i2c_adapter *i2c_adap,
61 const struct i2c_msg *msg)
62{
63 struct cx231xx_i2c *bus = i2c_adap->algo_data;
64 struct cx231xx *dev = bus->dev;
65 struct cx231xx_i2c_xfer_data req_data;
66 int status = 0;
67 u16 size = 0;
68 u8 loop = 0;
69 u8 saddr_len = 1;
70 u8 *buf_ptr = NULL;
71 u16 saddr = 0;
72 u8 need_gpio = 0;
73
74 if ((bus->nr == 1) && (msg->addr == 0x61)
75 && (dev->tuner_type == TUNER_XC5000)) {
76
77 size = msg->len;
78
79 if (size == 2) {
80
81
82 return 0;
83 } else if (size == 4) {
84 if (msg->len >= 2)
85 saddr = msg->buf[0] << 8 | msg->buf[1];
86 else if (msg->len == 1)
87 saddr = msg->buf[0];
88
89 switch (saddr) {
90 case 0x0000:
91 need_gpio = 1;
92
93 dev->xc_fw_load_done = 1;
94 break;
95 case 0x000D:
96 case 0x0001:
97 case 0x0002:
98 case 0x0003:
99 need_gpio = 1;
100 break;
101 default:
102 if (dev->xc_fw_load_done)
103 need_gpio = 1;
104 break;
105 }
106
107 if (need_gpio) {
108 dprintk1(1,
109 "GPIO WRITE: addr 0x%x, len %d, saddr 0x%x\n",
110 msg->addr, msg->len, saddr);
111
112 return dev->cx231xx_gpio_i2c_write(dev,
113 msg->addr,
114 msg->buf,
115 msg->len);
116 }
117 }
118
119
120 saddr_len = 1;
121
122
123 size -= saddr_len;
124 buf_ptr = (u8 *) (msg->buf + 1);
125
126 do {
127
128 req_data.dev_addr = msg->addr;
129 req_data.direction = msg->flags;
130 req_data.saddr_len = saddr_len;
131 req_data.saddr_dat = msg->buf[0];
132 req_data.buf_size = size > 16 ? 16 : size;
133 req_data.p_buffer = (u8 *) (buf_ptr + loop * 16);
134
135 bus->i2c_nostop = (size > 16) ? 1 : 0;
136 bus->i2c_reserve = (loop == 0) ? 0 : 1;
137
138
139 status = dev->cx231xx_send_usb_command(bus, &req_data);
140 loop++;
141
142 if (size >= 16)
143 size -= 16;
144 else
145 size = 0;
146
147 } while (size > 0);
148
149 bus->i2c_nostop = 0;
150 bus->i2c_reserve = 0;
151
152 } else {
153
154
155 req_data.dev_addr = msg->addr;
156 req_data.direction = msg->flags;
157 req_data.saddr_len = 0;
158 req_data.saddr_dat = 0;
159 req_data.buf_size = msg->len;
160 req_data.p_buffer = msg->buf;
161
162
163 status = dev->cx231xx_send_usb_command(bus, &req_data);
164 }
165
166 return status < 0 ? status : 0;
167}
168
169
170
171
172
173static int cx231xx_i2c_recv_bytes(struct i2c_adapter *i2c_adap,
174 const struct i2c_msg *msg)
175{
176 struct cx231xx_i2c *bus = i2c_adap->algo_data;
177 struct cx231xx *dev = bus->dev;
178 struct cx231xx_i2c_xfer_data req_data;
179 int status = 0;
180 u16 saddr = 0;
181 u8 need_gpio = 0;
182
183 if ((bus->nr == 1) && (msg->addr == 0x61)
184 && dev->tuner_type == TUNER_XC5000) {
185
186 if (msg->len == 2)
187 saddr = msg->buf[0] << 8 | msg->buf[1];
188 else if (msg->len == 1)
189 saddr = msg->buf[0];
190
191 if (dev->xc_fw_load_done) {
192
193 switch (saddr) {
194 case 0x0009:
195 dprintk1(1,
196 "GPIO R E A D: Special case BUSY check \n");
197
198 msg->buf[0] = 0;
199 if (msg->len == 2)
200 msg->buf[1] = 0;
201 return 0;
202 case 0x0004:
203 need_gpio = 1;
204 break;
205
206 }
207
208 if (need_gpio) {
209
210
211
212 dprintk1(1,
213 "GPIO R E A D: addr 0x%x, len %d, saddr 0x%x\n",
214 msg->addr, msg->len,
215 msg->buf[0] << 8 | msg->buf[1]);
216
217 status =
218 dev->cx231xx_gpio_i2c_write(dev, msg->addr,
219 msg->buf,
220 msg->len);
221 status =
222 dev->cx231xx_gpio_i2c_read(dev, msg->addr,
223 msg->buf,
224 msg->len);
225 return status;
226 }
227 }
228
229
230 req_data.dev_addr = msg->addr;
231 req_data.direction = msg->flags;
232 req_data.saddr_len = msg->len;
233 req_data.saddr_dat = msg->buf[0] << 8 | msg->buf[1];
234 req_data.buf_size = msg->len;
235 req_data.p_buffer = msg->buf;
236
237
238 status = dev->cx231xx_send_usb_command(bus, &req_data);
239
240 } else {
241
242
243 req_data.dev_addr = msg->addr;
244 req_data.direction = msg->flags;
245 req_data.saddr_len = 0;
246 req_data.saddr_dat = 0;
247 req_data.buf_size = msg->len;
248 req_data.p_buffer = msg->buf;
249
250
251 status = dev->cx231xx_send_usb_command(bus, &req_data);
252 }
253
254 return status < 0 ? status : 0;
255}
256
257
258
259
260
261static int cx231xx_i2c_recv_bytes_with_saddr(struct i2c_adapter *i2c_adap,
262 const struct i2c_msg *msg1,
263 const struct i2c_msg *msg2)
264{
265 struct cx231xx_i2c *bus = i2c_adap->algo_data;
266 struct cx231xx *dev = bus->dev;
267 struct cx231xx_i2c_xfer_data req_data;
268 int status = 0;
269 u16 saddr = 0;
270 u8 need_gpio = 0;
271
272 if (msg1->len == 2)
273 saddr = msg1->buf[0] << 8 | msg1->buf[1];
274 else if (msg1->len == 1)
275 saddr = msg1->buf[0];
276
277 if ((bus->nr == 1) && (msg2->addr == 0x61)
278 && dev->tuner_type == TUNER_XC5000) {
279
280 if ((msg2->len < 16)) {
281
282 dprintk1(1,
283 "i2c_read: addr 0x%x, len %d, saddr 0x%x, len %d\n",
284 msg2->addr, msg2->len, saddr, msg1->len);
285
286 switch (saddr) {
287 case 0x0008:
288 need_gpio = 1;
289 break;
290 case 0x0004:
291 need_gpio = 1;
292 break;
293 }
294
295 if (need_gpio) {
296 status =
297 dev->cx231xx_gpio_i2c_write(dev, msg1->addr,
298 msg1->buf,
299 msg1->len);
300 status =
301 dev->cx231xx_gpio_i2c_read(dev, msg2->addr,
302 msg2->buf,
303 msg2->len);
304 return status;
305 }
306 }
307 }
308
309
310 req_data.dev_addr = msg2->addr;
311 req_data.direction = msg2->flags;
312 req_data.saddr_len = msg1->len;
313 req_data.saddr_dat = saddr;
314 req_data.buf_size = msg2->len;
315 req_data.p_buffer = msg2->buf;
316
317
318 status = dev->cx231xx_send_usb_command(bus, &req_data);
319
320 return status < 0 ? status : 0;
321}
322
323
324
325
326
327static int cx231xx_i2c_check_for_device(struct i2c_adapter *i2c_adap,
328 const struct i2c_msg *msg)
329{
330 struct cx231xx_i2c *bus = i2c_adap->algo_data;
331 struct cx231xx *dev = bus->dev;
332 struct cx231xx_i2c_xfer_data req_data;
333 int status = 0;
334
335
336 req_data.dev_addr = msg->addr;
337 req_data.direction = msg->flags;
338 req_data.saddr_len = 0;
339 req_data.saddr_dat = 0;
340 req_data.buf_size = 0;
341 req_data.p_buffer = NULL;
342
343
344 status = dev->cx231xx_send_usb_command(bus, &req_data);
345
346 return status < 0 ? status : 0;
347}
348
349
350
351
352
353static int cx231xx_i2c_xfer(struct i2c_adapter *i2c_adap,
354 struct i2c_msg msgs[], int num)
355{
356 struct cx231xx_i2c *bus = i2c_adap->algo_data;
357 struct cx231xx *dev = bus->dev;
358 int addr, rc, i, byte;
359
360 if (num <= 0)
361 return 0;
362
363 for (i = 0; i < num; i++) {
364
365 addr = msgs[i].addr >> 1;
366
367 dprintk2(2, "%s %s addr=%x len=%d:",
368 (msgs[i].flags & I2C_M_RD) ? "read" : "write",
369 i == num - 1 ? "stop" : "nonstop", addr, msgs[i].len);
370 if (!msgs[i].len) {
371
372 rc = cx231xx_i2c_check_for_device(i2c_adap, &msgs[i]);
373 if (rc < 0) {
374 dprintk2(2, " no device\n");
375 return rc;
376 }
377
378 } else if (msgs[i].flags & I2C_M_RD) {
379
380 rc = cx231xx_i2c_recv_bytes(i2c_adap, &msgs[i]);
381 if (i2c_debug >= 2) {
382 for (byte = 0; byte < msgs[i].len; byte++)
383 printk(" %02x", msgs[i].buf[byte]);
384 }
385 } else if (i + 1 < num && (msgs[i + 1].flags & I2C_M_RD) &&
386 msgs[i].addr == msgs[i + 1].addr
387 && (msgs[i].len <= 2) && (bus->nr < 2)) {
388
389 rc = cx231xx_i2c_recv_bytes_with_saddr(i2c_adap,
390 &msgs[i],
391 &msgs[i + 1]);
392 if (i2c_debug >= 2) {
393 for (byte = 0; byte < msgs[i].len; byte++)
394 printk(" %02x", msgs[i].buf[byte]);
395 }
396 i++;
397 } else {
398
399 if (i2c_debug >= 2) {
400 for (byte = 0; byte < msgs[i].len; byte++)
401 printk(" %02x", msgs[i].buf[byte]);
402 }
403 rc = cx231xx_i2c_send_bytes(i2c_adap, &msgs[i]);
404 }
405 if (rc < 0)
406 goto err;
407 if (i2c_debug >= 2)
408 printk("\n");
409 }
410
411 return num;
412err:
413 dprintk2(2, " ERROR: %i\n", rc);
414 return rc;
415}
416
417
418
419
420
421
422static u32 functionality(struct i2c_adapter *adap)
423{
424 return I2C_FUNC_SMBUS_EMUL | I2C_FUNC_I2C;
425}
426
427static struct i2c_algorithm cx231xx_algo = {
428 .master_xfer = cx231xx_i2c_xfer,
429 .functionality = functionality,
430};
431
432static struct i2c_adapter cx231xx_adap_template = {
433 .owner = THIS_MODULE,
434 .name = "cx231xx",
435 .algo = &cx231xx_algo,
436};
437
438static struct i2c_client cx231xx_client_template = {
439 .name = "cx231xx internal",
440};
441
442
443
444
445
446
447
448static char *i2c_devs[128] = {
449 [0x60 >> 1] = "colibri",
450 [0x88 >> 1] = "hammerhead",
451 [0x8e >> 1] = "CIR",
452 [0x32 >> 1] = "GeminiIII",
453 [0x02 >> 1] = "Aquarius",
454 [0xa0 >> 1] = "eeprom",
455 [0xc0 >> 1] = "tuner/XC3028",
456 [0xc2 >> 1] = "tuner/XC5000",
457};
458
459
460
461
462
463void cx231xx_do_i2c_scan(struct cx231xx *dev, struct i2c_client *c)
464{
465 unsigned char buf;
466 int i, rc;
467
468 cx231xx_info(": Checking for I2C devices ..\n");
469 for (i = 0; i < 128; i++) {
470 c->addr = i;
471 rc = i2c_master_recv(c, &buf, 0);
472 if (rc < 0)
473 continue;
474 cx231xx_info("%s: i2c scan: found device @ 0x%x [%s]\n",
475 dev->name, i << 1,
476 i2c_devs[i] ? i2c_devs[i] : "???");
477 }
478 cx231xx_info(": Completed Checking for I2C devices.\n");
479}
480
481
482
483
484
485int cx231xx_i2c_register(struct cx231xx_i2c *bus)
486{
487 struct cx231xx *dev = bus->dev;
488
489 BUG_ON(!dev->cx231xx_send_usb_command);
490
491 memcpy(&bus->i2c_adap, &cx231xx_adap_template, sizeof(bus->i2c_adap));
492 memcpy(&bus->i2c_algo, &cx231xx_algo, sizeof(bus->i2c_algo));
493 memcpy(&bus->i2c_client, &cx231xx_client_template,
494 sizeof(bus->i2c_client));
495
496 bus->i2c_adap.dev.parent = &dev->udev->dev;
497
498 strlcpy(bus->i2c_adap.name, bus->dev->name, sizeof(bus->i2c_adap.name));
499
500 bus->i2c_algo.data = bus;
501 bus->i2c_adap.algo_data = bus;
502 i2c_set_adapdata(&bus->i2c_adap, &dev->v4l2_dev);
503 i2c_add_adapter(&bus->i2c_adap);
504
505 bus->i2c_client.adapter = &bus->i2c_adap;
506
507 if (0 == bus->i2c_rc) {
508 if (i2c_scan)
509 cx231xx_do_i2c_scan(dev, &bus->i2c_client);
510
511
512 cx231xx_register_i2c_ir(dev);
513 } else
514 cx231xx_warn("%s: i2c bus %d register FAILED\n",
515 dev->name, bus->nr);
516
517 return bus->i2c_rc;
518}
519
520
521
522
523
524int cx231xx_i2c_unregister(struct cx231xx_i2c *bus)
525{
526 i2c_del_adapter(&bus->i2c_adap);
527 return 0;
528}
529