2 * Driver for the Auvitek AU0828 USB bridge
4 * Copyright (c) 2008 Steven Toth <stoth@hauppauge.com>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 #include <linux/module.h>
23 #include <linux/moduleparam.h>
24 #include <linux/init.h>
25 #include <linux/delay.h>
30 #include <media/v4l2-common.h>
32 unsigned int i2c_debug
= 0;
33 module_param(i2c_debug
, int, 0444);
34 MODULE_PARM_DESC(i2c_debug
, "enable debug messages [i2c]");
36 unsigned int i2c_scan
= 0;
37 module_param(i2c_scan
, int, 0444);
38 MODULE_PARM_DESC(i2c_scan
, "scan i2c bus at insmod time");
40 #define I2C_WAIT_DELAY 512
41 #define I2C_WAIT_RETRY 64
43 static inline int i2c_slave_did_write_ack(struct i2c_adapter
*i2c_adap
)
45 struct au0828_dev
*dev
= i2c_adap
->algo_data
;
46 return au0828_read(dev
, REG_201
) & 0x08 ? 0 : 1;
49 static inline int i2c_slave_did_read_ack(struct i2c_adapter
*i2c_adap
)
51 struct au0828_dev
*dev
= i2c_adap
->algo_data
;
52 return au0828_read(dev
, REG_201
) & 0x02 ? 0 : 1;
55 static int i2c_wait_read_ack(struct i2c_adapter
*i2c_adap
)
59 for (count
= 0; count
< I2C_WAIT_RETRY
; count
++) {
60 if (!i2c_slave_did_read_ack(i2c_adap
))
62 udelay(I2C_WAIT_DELAY
);
65 if (I2C_WAIT_RETRY
== count
)
71 static inline int i2c_is_read_busy(struct i2c_adapter
*i2c_adap
)
73 struct au0828_dev
*dev
= i2c_adap
->algo_data
;
74 return au0828_read(dev
, REG_201
) & 0x01 ? 0 : 1;
77 static int i2c_wait_read_done(struct i2c_adapter
*i2c_adap
)
81 for (count
= 0; count
< I2C_WAIT_RETRY
; count
++) {
82 if (!i2c_is_read_busy(i2c_adap
))
84 udelay(I2C_WAIT_DELAY
);
87 if (I2C_WAIT_RETRY
== count
)
93 static inline int i2c_is_write_done(struct i2c_adapter
*i2c_adap
)
95 struct au0828_dev
*dev
= i2c_adap
->algo_data
;
96 return au0828_read(dev
, REG_201
) & 0x04 ? 1 : 0;
99 static int i2c_wait_write_done(struct i2c_adapter
*i2c_adap
)
103 for (count
= 0; count
< I2C_WAIT_RETRY
; count
++) {
104 if (i2c_is_write_done(i2c_adap
))
106 udelay(I2C_WAIT_DELAY
);
109 if (I2C_WAIT_RETRY
== count
)
115 static inline int i2c_is_busy(struct i2c_adapter
*i2c_adap
)
117 struct au0828_dev
*dev
= i2c_adap
->algo_data
;
118 return au0828_read(dev
, REG_201
) & 0x10 ? 1 : 0;
121 static int i2c_wait_done(struct i2c_adapter
*i2c_adap
)
125 for (count
= 0; count
< I2C_WAIT_RETRY
; count
++) {
126 if (!i2c_is_busy(i2c_adap
))
128 udelay(I2C_WAIT_DELAY
);
131 if (I2C_WAIT_RETRY
== count
)
137 /* FIXME: Implement join handling correctly */
138 static int i2c_sendbytes(struct i2c_adapter
*i2c_adap
,
139 const struct i2c_msg
*msg
, int joined_rlen
)
142 struct au0828_dev
*dev
= i2c_adap
->algo_data
;
144 dprintk(4, "%s()\n", __FUNCTION__
);
146 au0828_write(dev
, REG_2FF
, 0x01);
147 au0828_write(dev
, REG_202
, 0x07);
149 /* Hardware needs 8 bit addresses */
150 au0828_write(dev
, REG_203
, msg
->addr
<< 1);
152 dprintk(4, "SEND: %02x\n", msg
->addr
);
154 for (i
=0; i
< msg
->len
;) {
156 dprintk(4, " %02x\n", msg
->buf
[i
]);
158 au0828_write(dev
, REG_205
, msg
->buf
[i
]);
163 if ((strobe
>= 4) || (i
>= msg
->len
)) {
165 /* Strobe the byte into the bus */
167 au0828_write(dev
, REG_200
, 0x41);
169 au0828_write(dev
, REG_200
, 0x01);
171 /* Reset strobe trigger */
174 if (!i2c_wait_write_done(i2c_adap
))
180 if (!i2c_wait_done(i2c_adap
))
188 /* FIXME: Implement join handling correctly */
189 static int i2c_readbytes(struct i2c_adapter
*i2c_adap
,
190 const struct i2c_msg
*msg
, int joined
)
192 struct au0828_dev
*dev
= i2c_adap
->algo_data
;
195 dprintk(4, "%s()\n", __FUNCTION__
);
197 au0828_write(dev
, REG_2FF
, 0x01);
198 au0828_write(dev
, REG_202
, 0x07);
200 /* Hardware needs 8 bit addresses */
201 au0828_write(dev
, REG_203
, msg
->addr
<< 1);
203 dprintk(4, " RECV:\n");
205 /* Deal with i2c_scan */
207 au0828_write(dev
, REG_200
, 0x20);
208 if (i2c_wait_read_ack(i2c_adap
))
213 for (i
=0; i
< msg
->len
;) {
218 au0828_write(dev
, REG_200
, 0x60);
220 au0828_write(dev
, REG_200
, 0x20);
222 if (!i2c_wait_read_done(i2c_adap
))
225 msg
->buf
[i
-1] = au0828_read(dev
, REG_209
) & 0xff;
227 dprintk(4, " %02x\n", msg
->buf
[i
-1]);
229 if (!i2c_wait_done(i2c_adap
))
237 static int i2c_xfer(struct i2c_adapter
*i2c_adap
,
238 struct i2c_msg
*msgs
, int num
)
242 dprintk(4, "%s(num = %d)\n", __FUNCTION__
, num
);
244 for (i
= 0 ; i
< num
; i
++) {
245 dprintk(4, "%s(num = %d) addr = 0x%02x len = 0x%x\n",
246 __FUNCTION__
, num
, msgs
[i
].addr
, msgs
[i
].len
);
247 if (msgs
[i
].flags
& I2C_M_RD
) {
249 retval
= i2c_readbytes(i2c_adap
, &msgs
[i
], 0);
250 } else if (i
+ 1 < num
&& (msgs
[i
+ 1].flags
& I2C_M_RD
) &&
251 msgs
[i
].addr
== msgs
[i
+ 1].addr
) {
252 /* write then read from same address */
253 retval
= i2c_sendbytes(i2c_adap
, &msgs
[i
],
258 retval
= i2c_readbytes(i2c_adap
, &msgs
[i
], 1);
261 retval
= i2c_sendbytes(i2c_adap
, &msgs
[i
], 0);
272 static int attach_inform(struct i2c_client
*client
)
274 dprintk(1, "%s i2c attach [addr=0x%x,client=%s]\n",
275 client
->driver
->driver
.name
, client
->addr
, client
->name
);
277 if (!client
->driver
->command
)
283 static int detach_inform(struct i2c_client
*client
)
285 dprintk(1, "i2c detach [client=%s]\n", client
->name
);
290 void au0828_call_i2c_clients(struct au0828_dev
*dev
,
291 unsigned int cmd
, void *arg
)
293 if (dev
->i2c_rc
!= 0)
296 i2c_clients_command(&dev
->i2c_adap
, cmd
, arg
);
299 static u32
au0828_functionality(struct i2c_adapter
*adap
)
301 return I2C_FUNC_SMBUS_EMUL
| I2C_FUNC_I2C
;
304 static struct i2c_algorithm au0828_i2c_algo_template
= {
305 .master_xfer
= i2c_xfer
,
306 .functionality
= au0828_functionality
,
309 /* ----------------------------------------------------------------------- */
311 static struct i2c_adapter au0828_i2c_adap_template
= {
313 .owner
= THIS_MODULE
,
314 .id
= I2C_HW_B_AU0828
,
315 .algo
= &au0828_i2c_algo_template
,
316 .class = I2C_CLASS_TV_ANALOG
,
317 .client_register
= attach_inform
,
318 .client_unregister
= detach_inform
,
321 static struct i2c_client au0828_i2c_client_template
= {
322 .name
= "au0828 internal",
325 static char *i2c_devs
[128] = {
326 [ 0x8e >> 1 ] = "au8522",
327 [ 0xa0 >> 1 ] = "eeprom",
328 [ 0xc2 >> 1 ] = "tuner/xc5000",
331 static void do_i2c_scan(char *name
, struct i2c_client
*c
)
336 for (i
= 0; i
< 128; i
++) {
338 rc
= i2c_master_recv(c
, &buf
, 0);
341 printk("%s: i2c scan: found device @ 0x%x [%s]\n",
342 name
, i
<< 1, i2c_devs
[i
] ? i2c_devs
[i
] : "???");
346 /* init + register i2c algo-bit adapter */
347 int au0828_i2c_register(struct au0828_dev
*dev
)
349 dprintk(1, "%s()\n", __FUNCTION__
);
351 memcpy(&dev
->i2c_adap
, &au0828_i2c_adap_template
,
352 sizeof(dev
->i2c_adap
));
353 memcpy(&dev
->i2c_algo
, &au0828_i2c_algo_template
,
354 sizeof(dev
->i2c_algo
));
355 memcpy(&dev
->i2c_client
, &au0828_i2c_client_template
,
356 sizeof(dev
->i2c_client
));
358 dev
->i2c_adap
.dev
.parent
= &dev
->usbdev
->dev
;
360 strlcpy(dev
->i2c_adap
.name
, DRIVER_NAME
,
361 sizeof(dev
->i2c_adap
.name
));
363 dev
->i2c_algo
.data
= dev
;
364 dev
->i2c_adap
.algo_data
= dev
;
365 i2c_set_adapdata(&dev
->i2c_adap
, dev
);
366 i2c_add_adapter(&dev
->i2c_adap
);
368 dev
->i2c_client
.adapter
= &dev
->i2c_adap
;
370 if (0 == dev
->i2c_rc
) {
371 printk("%s: i2c bus registered\n", DRIVER_NAME
);
373 do_i2c_scan(DRIVER_NAME
, &dev
->i2c_client
);
375 printk("%s: i2c bus register FAILED\n", DRIVER_NAME
);
380 int au0828_i2c_unregister(struct au0828_dev
*dev
)
382 i2c_del_adapter(&dev
->i2c_adap
);