]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - drivers/media/video/usbvision/usbvision-i2c.c
V4L/DVB (9116): USB: remove info() macro from usb media drivers
[mirror_ubuntu-bionic-kernel.git] / drivers / media / video / usbvision / usbvision-i2c.c
CommitLineData
f2242ee5 1/*
1ff16c20 2 * usbvision_i2c.c
781aa1d1
MCC
3 * i2c algorithm for USB-I2C Bridges
4 *
1ff16c20 5 * Copyright (c) 1999-2007 Joerg Heckenbach <joerg@heckenbach-aw.de>
781aa1d1
MCC
6 * Dwaine Garden <dwainegarden@rogers.com>
7 *
8 * This module is part of usbvision driver project.
9 * Updates to driver completed by Dwaine P. Garden
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 */
25
26
27#include <linux/kernel.h>
28#include <linux/module.h>
29#include <linux/delay.h>
30#include <linux/slab.h>
31#include <linux/version.h>
a1ed551c 32#include <linux/utsname.h>
781aa1d1
MCC
33#include <linux/init.h>
34#include <asm/uaccess.h>
35#include <linux/ioport.h>
36#include <linux/errno.h>
781aa1d1
MCC
37#include <linux/usb.h>
38#include <linux/i2c.h>
483dfdb6 39#include "usbvision.h"
781aa1d1 40
483dfdb6 41#define DBG_I2C 1<<0
781aa1d1 42
ff699e6b 43static int i2c_debug;
483dfdb6
TM
44
45module_param (i2c_debug, int, 0644); // debug_i2c_usb mode of the device driver
46MODULE_PARM_DESC(i2c_debug, "enable debug messages [i2c]");
781aa1d1 47
df18c319
TM
48#define PDEBUG(level, fmt, args...) { \
49 if (i2c_debug & (level)) \
a482f327
GKH
50 printk(KERN_INFO KBUILD_MODNAME ":[%s:%d] " fmt, \
51 __func__, __LINE__ , ## args); \
df18c319 52 }
781aa1d1 53
1ff16c20 54static int usbvision_i2c_write(struct usb_usbvision *usbvision, unsigned char addr, char *buf,
2a7e9a26 55 short len);
1ff16c20 56static int usbvision_i2c_read(struct usb_usbvision *usbvision, unsigned char addr, char *buf,
2a7e9a26
MCC
57 short len);
58
781aa1d1
MCC
59static inline int try_write_address(struct i2c_adapter *i2c_adap,
60 unsigned char addr, int retries)
61{
1ff16c20 62 struct usb_usbvision *usbvision;
781aa1d1
MCC
63 int i, ret = -1;
64 char buf[4];
65
bf8b20e1 66 usbvision = (struct usb_usbvision *)i2c_get_adapdata(i2c_adap);
781aa1d1
MCC
67 buf[0] = 0x00;
68 for (i = 0; i <= retries; i++) {
1ff16c20 69 ret = (usbvision_i2c_write(usbvision, addr, buf, 1));
781aa1d1
MCC
70 if (ret == 1)
71 break; /* success! */
c6268461 72 udelay(5);
781aa1d1
MCC
73 if (i == retries) /* no success */
74 break;
c6268461 75 udelay(10);
781aa1d1 76 }
483dfdb6 77 if (i) {
1ff16c20
TM
78 PDEBUG(DBG_I2C,"Needed %d retries for address %#2x", i, addr);
79 PDEBUG(DBG_I2C,"Maybe there's no device at this address");
781aa1d1
MCC
80 }
81 return ret;
82}
83
84static inline int try_read_address(struct i2c_adapter *i2c_adap,
85 unsigned char addr, int retries)
86{
1ff16c20 87 struct usb_usbvision *usbvision;
781aa1d1
MCC
88 int i, ret = -1;
89 char buf[4];
90
bf8b20e1 91 usbvision = (struct usb_usbvision *)i2c_get_adapdata(i2c_adap);
781aa1d1 92 for (i = 0; i <= retries; i++) {
1ff16c20 93 ret = (usbvision_i2c_read(usbvision, addr, buf, 1));
781aa1d1
MCC
94 if (ret == 1)
95 break; /* success! */
c6268461 96 udelay(5);
781aa1d1
MCC
97 if (i == retries) /* no success */
98 break;
c6268461 99 udelay(10);
781aa1d1 100 }
483dfdb6 101 if (i) {
1ff16c20
TM
102 PDEBUG(DBG_I2C,"Needed %d retries for address %#2x", i, addr);
103 PDEBUG(DBG_I2C,"Maybe there's no device at this address");
781aa1d1
MCC
104 }
105 return ret;
106}
107
108static inline int usb_find_address(struct i2c_adapter *i2c_adap,
109 struct i2c_msg *msg, int retries,
110 unsigned char *add)
111{
112 unsigned short flags = msg->flags;
f2242ee5 113
781aa1d1
MCC
114 unsigned char addr;
115 int ret;
116 if ((flags & I2C_M_TEN)) {
117 /* a ten bit address */
118 addr = 0xf0 | ((msg->addr >> 7) & 0x03);
119 /* try extended address code... */
120 ret = try_write_address(i2c_adap, addr, retries);
121 if (ret != 1) {
122 err("died at extended address code, while writing");
123 return -EREMOTEIO;
124 }
125 add[0] = addr;
126 if (flags & I2C_M_RD) {
127 /* okay, now switch into reading mode */
128 addr |= 0x01;
129 ret = try_read_address(i2c_adap, addr, retries);
130 if (ret != 1) {
131 err("died at extended address code, while reading");
132 return -EREMOTEIO;
133 }
134 }
135
136 } else { /* normal 7bit address */
137 addr = (msg->addr << 1);
138 if (flags & I2C_M_RD)
139 addr |= 1;
781aa1d1
MCC
140
141 add[0] = addr;
142 if (flags & I2C_M_RD)
143 ret = try_read_address(i2c_adap, addr, retries);
144 else
145 ret = try_write_address(i2c_adap, addr, retries);
146
147 if (ret != 1) {
148 return -EREMOTEIO;
149 }
150 }
151 return 0;
152}
153
154static int
1ff16c20 155usbvision_i2c_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg msgs[], int num)
781aa1d1
MCC
156{
157 struct i2c_msg *pmsg;
1ff16c20 158 struct usb_usbvision *usbvision;
781aa1d1
MCC
159 int i, ret;
160 unsigned char addr;
161
bf8b20e1
TM
162 usbvision = (struct usb_usbvision *)i2c_get_adapdata(i2c_adap);
163
781aa1d1
MCC
164 for (i = 0; i < num; i++) {
165 pmsg = &msgs[i];
166 ret = usb_find_address(i2c_adap, pmsg, i2c_adap->retries, &addr);
167 if (ret != 0) {
1ff16c20 168 PDEBUG(DBG_I2C,"got NAK from device, message #%d", i);
781aa1d1
MCC
169 return (ret < 0) ? ret : -EREMOTEIO;
170 }
171
172 if (pmsg->flags & I2C_M_RD) {
173 /* read bytes into buffer */
1ff16c20 174 ret = (usbvision_i2c_read(usbvision, addr, pmsg->buf, pmsg->len));
781aa1d1
MCC
175 if (ret < pmsg->len) {
176 return (ret < 0) ? ret : -EREMOTEIO;
177 }
178 } else {
179 /* write bytes from buffer */
1ff16c20 180 ret = (usbvision_i2c_write(usbvision, addr, pmsg->buf, pmsg->len));
781aa1d1
MCC
181 if (ret < pmsg->len) {
182 return (ret < 0) ? ret : -EREMOTEIO;
183 }
184 }
185 }
186 return num;
187}
188
1ff16c20 189static u32 functionality(struct i2c_adapter *adap)
781aa1d1 190{
39f46ade 191 return I2C_FUNC_SMBUS_EMUL | I2C_FUNC_10BIT_ADDR;
781aa1d1
MCC
192}
193
781aa1d1
MCC
194/* -----exported algorithm data: ------------------------------------- */
195
1ff16c20
TM
196static struct i2c_algorithm usbvision_algo = {
197 .master_xfer = usbvision_i2c_xfer,
781aa1d1 198 .smbus_xfer = NULL,
1ff16c20 199 .functionality = functionality,
781aa1d1
MCC
200};
201
202
bf8b20e1
TM
203/*
204 * registering functions to load algorithms at runtime
205 */
206static int usbvision_i2c_usb_add_bus(struct i2c_adapter *adap)
207{
208 PDEBUG(DBG_I2C, "I2C debugging is enabled [i2c]");
209 PDEBUG(DBG_I2C, "ALGO debugging is enabled [i2c]");
210
211 /* register new adapter to i2c module... */
212
213 adap->algo = &usbvision_algo;
214
215 adap->timeout = 100; /* default values, should */
216 adap->retries = 3; /* be replaced by defines */
217
218 i2c_add_adapter(adap);
219
220 PDEBUG(DBG_I2C,"i2c bus for %s registered", adap->name);
221
222 return 0;
223}
224
483dfdb6
TM
225/* ----------------------------------------------------------------------- */
226/* usbvision specific I2C functions */
227/* ----------------------------------------------------------------------- */
228static struct i2c_adapter i2c_adap_template;
483dfdb6
TM
229static struct i2c_client i2c_client_template;
230
1ff16c20 231int usbvision_i2c_register(struct usb_usbvision *usbvision)
483dfdb6 232{
bf8b20e1
TM
233 memcpy(&usbvision->i2c_adap, &i2c_adap_template,
234 sizeof(struct i2c_adapter));
235 memcpy(&usbvision->i2c_client, &i2c_client_template,
236 sizeof(struct i2c_client));
483dfdb6 237
1ff16c20
TM
238 sprintf(usbvision->i2c_adap.name + strlen(usbvision->i2c_adap.name),
239 " #%d", usbvision->vdev->minor & 0x1f);
bf8b20e1
TM
240 PDEBUG(DBG_I2C,"Adaptername: %s", usbvision->i2c_adap.name);
241 usbvision->i2c_adap.dev.parent = &usbvision->dev->dev;
242
243 i2c_set_adapdata(&usbvision->i2c_adap, usbvision);
244 i2c_set_clientdata(&usbvision->i2c_client, usbvision);
1ff16c20 245
483dfdb6
TM
246 usbvision->i2c_client.adapter = &usbvision->i2c_adap;
247
248 if (usbvision_write_reg(usbvision, USBVISION_SER_MODE, USBVISION_IIC_LRNACK) < 0) {
bf8b20e1 249 printk(KERN_ERR "usbvision_register: can't write reg\n");
483dfdb6
TM
250 return -EBUSY;
251 }
252
253#ifdef CONFIG_MODULES
254 /* Request the load of the i2c modules we need */
255 switch (usbvision_device_data[usbvision->DevModel].Codec) {
256 case CODEC_SAA7113:
257 request_module("saa7115");
258 break;
259 case CODEC_SAA7111:
260 request_module("saa7115");
261 break;
262 }
263 if (usbvision_device_data[usbvision->DevModel].Tuner == 1) {
264 request_module("tuner");
781aa1d1 265 }
781aa1d1
MCC
266#endif
267
bf8b20e1 268 return usbvision_i2c_usb_add_bus(&usbvision->i2c_adap);
1ff16c20
TM
269}
270
271int usbvision_i2c_unregister(struct usb_usbvision *usbvision)
272{
273
274 i2c_del_adapter(&(usbvision->i2c_adap));
275
276 PDEBUG(DBG_I2C,"i2c bus for %s unregistered", usbvision->i2c_adap.name);
277
278 return 0;
483dfdb6
TM
279}
280
281void call_i2c_clients(struct usb_usbvision *usbvision, unsigned int cmd,
282 void *arg)
283{
483dfdb6
TM
284 i2c_clients_command(&usbvision->i2c_adap, cmd, arg);
285}
286
287static int attach_inform(struct i2c_client *client)
288{
289 struct usb_usbvision *usbvision;
290
bf8b20e1
TM
291 usbvision = (struct usb_usbvision *)i2c_get_adapdata(client->adapter);
292
483dfdb6 293 switch (client->addr << 1) {
3153bd91
TP
294 case 0x42 << 1:
295 case 0x43 << 1:
296 case 0x4a << 1:
297 case 0x4b << 1:
6284feaf 298 PDEBUG(DBG_I2C,"attach_inform: tda9887 detected.");
483dfdb6 299 break;
483dfdb6
TM
300 case 0x42:
301 PDEBUG(DBG_I2C,"attach_inform: saa7114 detected.");
302 break;
303 case 0x4a:
304 PDEBUG(DBG_I2C,"attach_inform: saa7113 detected.");
305 break;
38284ba3
TM
306 case 0x48:
307 PDEBUG(DBG_I2C,"attach_inform: saa7111 detected.");
308 break;
483dfdb6
TM
309 case 0xa0:
310 PDEBUG(DBG_I2C,"attach_inform: eeprom detected.");
311 break;
312
313 default:
314 {
315 struct tuner_setup tun_setup;
316
317 PDEBUG(DBG_I2C,"attach inform: detected I2C address %x", client->addr << 1);
318 usbvision->tuner_addr = client->addr;
319
320 if ((usbvision->have_tuner) && (usbvision->tuner_type != -1)) {
321 tun_setup.mode_mask = T_ANALOG_TV | T_RADIO;
322 tun_setup.type = usbvision->tuner_type;
323 tun_setup.addr = usbvision->tuner_addr;
324 call_i2c_clients(usbvision, TUNER_SET_TYPE_ADDR, &tun_setup);
325 }
326 }
327 break;
328 }
781aa1d1
MCC
329 return 0;
330}
331
483dfdb6
TM
332static int detach_inform(struct i2c_client *client)
333{
334 struct usb_usbvision *usbvision;
335
bf8b20e1 336 usbvision = (struct usb_usbvision *)i2c_get_adapdata(client->adapter);
483dfdb6 337
a1ed551c 338 PDEBUG(DBG_I2C,"usbvision[%d] detaches %s", usbvision->nr, client->name);
483dfdb6
TM
339 return 0;
340}
341
342static int
343usbvision_i2c_read_max4(struct usb_usbvision *usbvision, unsigned char addr,
344 char *buf, short len)
345{
346 int rc, retries;
347
348 for (retries = 5;;) {
349 rc = usbvision_write_reg(usbvision, USBVISION_SER_ADRS, addr);
350 if (rc < 0)
351 return rc;
352
353 /* Initiate byte read cycle */
354 /* USBVISION_SER_CONT <- d0-d2 n. of bytes to r/w */
355 /* d3 0=Wr 1=Rd */
356 rc = usbvision_write_reg(usbvision, USBVISION_SER_CONT,
357 (len & 0x07) | 0x18);
358 if (rc < 0)
359 return rc;
360
361 /* Test for Busy and ACK */
362 do {
363 /* USBVISION_SER_CONT -> d4 == 0 busy */
364 rc = usbvision_read_reg(usbvision, USBVISION_SER_CONT);
365 } while (rc > 0 && ((rc & 0x10) != 0)); /* Retry while busy */
366 if (rc < 0)
367 return rc;
368
369 /* USBVISION_SER_CONT -> d5 == 1 Not ack */
370 if ((rc & 0x20) == 0) /* Ack? */
371 break;
372
373 /* I2C abort */
374 rc = usbvision_write_reg(usbvision, USBVISION_SER_CONT, 0x00);
375 if (rc < 0)
376 return rc;
377
378 if (--retries < 0)
379 return -1;
380 }
381
382 switch (len) {
383 case 4:
384 buf[3] = usbvision_read_reg(usbvision, USBVISION_SER_DAT4);
385 case 3:
386 buf[2] = usbvision_read_reg(usbvision, USBVISION_SER_DAT3);
387 case 2:
388 buf[1] = usbvision_read_reg(usbvision, USBVISION_SER_DAT2);
389 case 1:
390 buf[0] = usbvision_read_reg(usbvision, USBVISION_SER_DAT1);
391 break;
392 default:
393 printk(KERN_ERR
394 "usbvision_i2c_read_max4: buffer length > 4\n");
395 }
396
397 if (i2c_debug & DBG_I2C) {
398 int idx;
399 for (idx = 0; idx < len; idx++) {
400 PDEBUG(DBG_I2C,"read %x from address %x", (unsigned char)buf[idx], addr);
401 }
402 }
403 return len;
404}
405
406
407static int usbvision_i2c_write_max4(struct usb_usbvision *usbvision,
408 unsigned char addr, const char *buf,
409 short len)
410{
411 int rc, retries;
412 int i;
413 unsigned char value[6];
414 unsigned char ser_cont;
415
416 ser_cont = (len & 0x07) | 0x10;
417
418 value[0] = addr;
419 value[1] = ser_cont;
420 for (i = 0; i < len; i++)
421 value[i + 2] = buf[i];
422
423 for (retries = 5;;) {
424 rc = usb_control_msg(usbvision->dev,
425 usb_sndctrlpipe(usbvision->dev, 1),
426 USBVISION_OP_CODE,
427 USB_DIR_OUT | USB_TYPE_VENDOR |
428 USB_RECIP_ENDPOINT, 0,
429 (__u16) USBVISION_SER_ADRS, value,
430 len + 2, HZ);
431
432 if (rc < 0)
433 return rc;
434
435 rc = usbvision_write_reg(usbvision, USBVISION_SER_CONT,
436 (len & 0x07) | 0x10);
437 if (rc < 0)
438 return rc;
439
440 /* Test for Busy and ACK */
441 do {
442 rc = usbvision_read_reg(usbvision, USBVISION_SER_CONT);
443 } while (rc > 0 && ((rc & 0x10) != 0)); /* Retry while busy */
444 if (rc < 0)
445 return rc;
446
447 if ((rc & 0x20) == 0) /* Ack? */
448 break;
449
450 /* I2C abort */
451 usbvision_write_reg(usbvision, USBVISION_SER_CONT, 0x00);
452
453 if (--retries < 0)
454 return -1;
455
456 }
457
458 if (i2c_debug & DBG_I2C) {
459 int idx;
460 for (idx = 0; idx < len; idx++) {
461 PDEBUG(DBG_I2C,"wrote %x at address %x", (unsigned char)buf[idx], addr);
462 }
463 }
464 return len;
465}
466
1ff16c20 467static int usbvision_i2c_write(struct usb_usbvision *usbvision, unsigned char addr, char *buf,
483dfdb6
TM
468 short len)
469{
470 char *bufPtr = buf;
471 int retval;
472 int wrcount = 0;
473 int count;
474 int maxLen = 4;
483dfdb6
TM
475
476 while (len > 0) {
477 count = (len > maxLen) ? maxLen : len;
478 retval = usbvision_i2c_write_max4(usbvision, addr, bufPtr, count);
479 if (retval > 0) {
480 len -= count;
481 bufPtr += count;
482 wrcount += count;
483 } else
484 return (retval < 0) ? retval : -EFAULT;
485 }
486 return wrcount;
487}
488
1ff16c20 489static int usbvision_i2c_read(struct usb_usbvision *usbvision, unsigned char addr, char *buf,
483dfdb6
TM
490 short len)
491{
492 char temp[4];
493 int retval, i;
494 int rdcount = 0;
495 int count;
483dfdb6
TM
496
497 while (len > 0) {
498 count = (len > 3) ? 4 : len;
499 retval = usbvision_i2c_read_max4(usbvision, addr, temp, count);
500 if (retval > 0) {
501 for (i = 0; i < len; i++)
502 buf[rdcount + i] = temp[i];
503 len -= count;
504 rdcount += count;
505 } else
506 return (retval < 0) ? retval : -EFAULT;
507 }
508 return rdcount;
509}
510
483dfdb6
TM
511static struct i2c_adapter i2c_adap_template = {
512 .owner = THIS_MODULE,
513 .name = "usbvision",
514 .id = I2C_HW_B_BT848, /* FIXME */
483dfdb6
TM
515 .client_register = attach_inform,
516 .client_unregister = detach_inform,
483dfdb6 517 .class = I2C_CLASS_TV_ANALOG,
483dfdb6
TM
518};
519
520static struct i2c_client i2c_client_template = {
521 .name = "usbvision internal",
522};
523
483dfdb6
TM
524/*
525 * Overrides for Emacs so that we follow Linus's tabbing style.
526 * ---------------------------------------------------------------------------
527 * Local variables:
528 * c-basic-offset: 8
529 * End:
530 */