]> err.no Git - linux-2.6/blob - drivers/media/video/cx18/cx18-i2c.c
Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6
[linux-2.6] / drivers / media / video / cx18 / cx18-i2c.c
1 /*
2  *  cx18 I2C functions
3  *
4  *  Derived from ivtv-i2c.c
5  *
6  *  Copyright (C) 2007  Hans Verkuil <hverkuil@xs4all.nl>
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., 59 Temple Place, Suite 330, Boston, MA
21  *  02111-1307  USA
22  */
23
24 #include "cx18-driver.h"
25 #include "cx18-cards.h"
26 #include "cx18-gpio.h"
27 #include "cx18-av-core.h"
28 #include "cx18-i2c.h"
29
30 #include <media/ir-kbd-i2c.h>
31
32 #define CX18_REG_I2C_1_WR   0xf15000
33 #define CX18_REG_I2C_1_RD   0xf15008
34 #define CX18_REG_I2C_2_WR   0xf25100
35 #define CX18_REG_I2C_2_RD   0xf25108
36
37 #define SETSCL_BIT      0x0001
38 #define SETSDL_BIT      0x0002
39 #define GETSCL_BIT      0x0004
40 #define GETSDL_BIT      0x0008
41
42 #define CX18_CS5345_I2C_ADDR            0x4c
43
44 /* This array should match the CX18_HW_ defines */
45 static const u8 hw_driverids[] = {
46         I2C_DRIVERID_TUNER,
47         I2C_DRIVERID_TVEEPROM,
48         I2C_DRIVERID_CS5345,
49         0,              /* CX18_HW_GPIO dummy driver ID */
50         0               /* CX18_HW_CX23418 dummy driver ID */
51 };
52
53 /* This array should match the CX18_HW_ defines */
54 static const u8 hw_addrs[] = {
55         0,
56         0,
57         CX18_CS5345_I2C_ADDR,
58         0,              /* CX18_HW_GPIO dummy driver ID */
59         0,              /* CX18_HW_CX23418 dummy driver ID */
60 };
61
62 /* This array should match the CX18_HW_ defines */
63 /* This might well become a card-specific array */
64 static const u8 hw_bus[] = {
65         0,
66         0,
67         0,
68         0,              /* CX18_HW_GPIO dummy driver ID */
69         0,              /* CX18_HW_CX23418 dummy driver ID */
70 };
71
72 /* This array should match the CX18_HW_ defines */
73 static const char * const hw_devicenames[] = {
74         "tuner",
75         "tveeprom",
76         "cs5345",
77         "gpio",
78         "cx23418",
79 };
80
81 int cx18_i2c_register(struct cx18 *cx, unsigned idx)
82 {
83         struct i2c_board_info info;
84         struct i2c_client *c;
85         u8 id, bus;
86         int i;
87
88         CX18_DEBUG_I2C("i2c client register\n");
89         if (idx >= ARRAY_SIZE(hw_driverids) || hw_driverids[idx] == 0)
90                 return -1;
91         id = hw_driverids[idx];
92         bus = hw_bus[idx];
93         memset(&info, 0, sizeof(info));
94         strlcpy(info.type, hw_devicenames[idx], sizeof(info.type));
95         info.addr = hw_addrs[idx];
96         for (i = 0; i < I2C_CLIENTS_MAX; i++)
97                 if (cx->i2c_clients[i] == NULL)
98                         break;
99
100         if (i == I2C_CLIENTS_MAX) {
101                 CX18_ERR("insufficient room for new I2C client!\n");
102                 return -ENOMEM;
103         }
104
105         if (id != I2C_DRIVERID_TUNER) {
106                 c = i2c_new_device(&cx->i2c_adap[bus], &info);
107                 if (c->driver == NULL)
108                         i2c_unregister_device(c);
109                 else
110                         cx->i2c_clients[i] = c;
111                 return cx->i2c_clients[i] ? 0 : -ENODEV;
112         }
113
114         /* special tuner handling */
115         c = i2c_new_probed_device(&cx->i2c_adap[1], &info, cx->card_i2c->radio);
116         if (c && c->driver == NULL)
117                 i2c_unregister_device(c);
118         else if (c)
119                 cx->i2c_clients[i++] = c;
120         c = i2c_new_probed_device(&cx->i2c_adap[1], &info, cx->card_i2c->demod);
121         if (c && c->driver == NULL)
122                 i2c_unregister_device(c);
123         else if (c)
124                 cx->i2c_clients[i++] = c;
125         c = i2c_new_probed_device(&cx->i2c_adap[1], &info, cx->card_i2c->tv);
126         if (c && c->driver == NULL)
127                 i2c_unregister_device(c);
128         else if (c)
129                 cx->i2c_clients[i++] = c;
130         return 0;
131 }
132
133 static int attach_inform(struct i2c_client *client)
134 {
135         return 0;
136 }
137
138 static int detach_inform(struct i2c_client *client)
139 {
140         int i;
141         struct cx18 *cx = (struct cx18 *)i2c_get_adapdata(client->adapter);
142
143         CX18_DEBUG_I2C("i2c client detach\n");
144         for (i = 0; i < I2C_CLIENTS_MAX; i++) {
145                 if (cx->i2c_clients[i] == client) {
146                         cx->i2c_clients[i] = NULL;
147                         break;
148                 }
149         }
150         CX18_DEBUG_I2C("i2c detach [client=%s,%s]\n",
151                    client->name, (i < I2C_CLIENTS_MAX) ? "ok" : "failed");
152
153         return 0;
154 }
155
156 static void cx18_setscl(void *data, int state)
157 {
158         struct cx18 *cx = ((struct cx18_i2c_algo_callback_data *)data)->cx;
159         int bus_index = ((struct cx18_i2c_algo_callback_data *)data)->bus_index;
160         u32 addr = bus_index ? CX18_REG_I2C_2_WR : CX18_REG_I2C_1_WR;
161         u32 r = read_reg(addr);
162
163         if (state)
164                 write_reg_sync(r | SETSCL_BIT, addr);
165         else
166                 write_reg_sync(r & ~SETSCL_BIT, addr);
167 }
168
169 static void cx18_setsda(void *data, int state)
170 {
171         struct cx18 *cx = ((struct cx18_i2c_algo_callback_data *)data)->cx;
172         int bus_index = ((struct cx18_i2c_algo_callback_data *)data)->bus_index;
173         u32 addr = bus_index ? CX18_REG_I2C_2_WR : CX18_REG_I2C_1_WR;
174         u32 r = read_reg(addr);
175
176         if (state)
177                 write_reg_sync(r | SETSDL_BIT, addr);
178         else
179                 write_reg_sync(r & ~SETSDL_BIT, addr);
180 }
181
182 static int cx18_getscl(void *data)
183 {
184         struct cx18 *cx = ((struct cx18_i2c_algo_callback_data *)data)->cx;
185         int bus_index = ((struct cx18_i2c_algo_callback_data *)data)->bus_index;
186         u32 addr = bus_index ? CX18_REG_I2C_2_RD : CX18_REG_I2C_1_RD;
187
188         return read_reg(addr) & GETSCL_BIT;
189 }
190
191 static int cx18_getsda(void *data)
192 {
193         struct cx18 *cx = ((struct cx18_i2c_algo_callback_data *)data)->cx;
194         int bus_index = ((struct cx18_i2c_algo_callback_data *)data)->bus_index;
195         u32 addr = bus_index ? CX18_REG_I2C_2_RD : CX18_REG_I2C_1_RD;
196
197         return read_reg(addr) & GETSDL_BIT;
198 }
199
200 /* template for i2c-bit-algo */
201 static struct i2c_adapter cx18_i2c_adap_template = {
202         .name = "cx18 i2c driver",
203         .id = I2C_HW_B_CX2341X,
204         .algo = NULL,                   /* set by i2c-algo-bit */
205         .algo_data = NULL,              /* filled from template */
206         .client_register = attach_inform,
207         .client_unregister = detach_inform,
208         .owner = THIS_MODULE,
209 };
210
211 #define CX18_SCL_PERIOD (10) /* usecs. 10 usec is period for a 100 KHz clock */
212 #define CX18_ALGO_BIT_TIMEOUT (2) /* seconds */
213
214 static struct i2c_algo_bit_data cx18_i2c_algo_template = {
215         .setsda         = cx18_setsda,
216         .setscl         = cx18_setscl,
217         .getsda         = cx18_getsda,
218         .getscl         = cx18_getscl,
219         .udelay         = CX18_SCL_PERIOD/2,       /* 1/2 clock period in usec*/
220         .timeout        = CX18_ALGO_BIT_TIMEOUT*HZ /* jiffies */
221 };
222
223 static struct i2c_client cx18_i2c_client_template = {
224         .name = "cx18 internal",
225 };
226
227 int cx18_call_i2c_client(struct cx18 *cx, int addr, unsigned cmd, void *arg)
228 {
229         struct i2c_client *client;
230         int retval;
231         int i;
232
233         CX18_DEBUG_I2C("call_i2c_client addr=%02x\n", addr);
234         for (i = 0; i < I2C_CLIENTS_MAX; i++) {
235                 client = cx->i2c_clients[i];
236                 if (client == NULL || client->driver == NULL ||
237                                 client->driver->command == NULL)
238                         continue;
239                 if (addr == client->addr) {
240                         retval = client->driver->command(client, cmd, arg);
241                         return retval;
242                 }
243         }
244         if (cmd != VIDIOC_G_CHIP_IDENT)
245                 CX18_ERR("i2c addr 0x%02x not found for cmd 0x%x!\n",
246                                addr, cmd);
247         return -ENODEV;
248 }
249
250 /* Find the i2c device based on the driver ID and return
251    its i2c address or -ENODEV if no matching device was found. */
252 static int cx18_i2c_id_addr(struct cx18 *cx, u32 id)
253 {
254         struct i2c_client *client;
255         int retval = -ENODEV;
256         int i;
257
258         for (i = 0; i < I2C_CLIENTS_MAX; i++) {
259                 client = cx->i2c_clients[i];
260                 if (client == NULL || client->driver == NULL)
261                         continue;
262                 if (id == client->driver->id) {
263                         retval = client->addr;
264                         break;
265                 }
266         }
267         return retval;
268 }
269
270 /* Find the i2c device name matching the DRIVERID */
271 static const char *cx18_i2c_id_name(u32 id)
272 {
273         int i;
274
275         for (i = 0; i < ARRAY_SIZE(hw_driverids); i++)
276                 if (hw_driverids[i] == id)
277                         return hw_devicenames[i];
278         return "unknown device";
279 }
280
281 /* Find the i2c device name matching the CX18_HW_ flag */
282 static const char *cx18_i2c_hw_name(u32 hw)
283 {
284         int i;
285
286         for (i = 0; i < ARRAY_SIZE(hw_driverids); i++)
287                 if (1 << i == hw)
288                         return hw_devicenames[i];
289         return "unknown device";
290 }
291
292 /* Find the i2c device matching the CX18_HW_ flag and return
293    its i2c address or -ENODEV if no matching device was found. */
294 int cx18_i2c_hw_addr(struct cx18 *cx, u32 hw)
295 {
296         int i;
297
298         for (i = 0; i < ARRAY_SIZE(hw_driverids); i++)
299                 if (1 << i == hw)
300                         return cx18_i2c_id_addr(cx, hw_driverids[i]);
301         return -ENODEV;
302 }
303
304 /* Calls i2c device based on CX18_HW_ flag. If hw == 0, then do nothing.
305    If hw == CX18_HW_GPIO then call the gpio handler. */
306 int cx18_i2c_hw(struct cx18 *cx, u32 hw, unsigned int cmd, void *arg)
307 {
308         int addr;
309
310         if (hw == 0)
311                 return 0;
312
313         if (hw == CX18_HW_GPIO)
314                 return cx18_gpio(cx, cmd, arg);
315
316         if (hw == CX18_HW_CX23418)
317                 return cx18_av_cmd(cx, cmd, arg);
318
319         addr = cx18_i2c_hw_addr(cx, hw);
320         if (addr < 0) {
321                 CX18_ERR("i2c hardware 0x%08x (%s) not found for cmd 0x%x!\n",
322                                hw, cx18_i2c_hw_name(hw), cmd);
323                 return addr;
324         }
325         return cx18_call_i2c_client(cx, addr, cmd, arg);
326 }
327
328 /* Calls i2c device based on I2C driver ID. */
329 int cx18_i2c_id(struct cx18 *cx, u32 id, unsigned int cmd, void *arg)
330 {
331         int addr;
332
333         addr = cx18_i2c_id_addr(cx, id);
334         if (addr < 0) {
335                 if (cmd != VIDIOC_G_CHIP_IDENT)
336                         CX18_ERR("i2c ID 0x%08x (%s) not found for cmd 0x%x!\n",
337                                 id, cx18_i2c_id_name(id), cmd);
338                 return addr;
339         }
340         return cx18_call_i2c_client(cx, addr, cmd, arg);
341 }
342
343 /* broadcast cmd for all I2C clients and for the gpio subsystem */
344 void cx18_call_i2c_clients(struct cx18 *cx, unsigned int cmd, void *arg)
345 {
346         if (cx->i2c_adap[0].algo == NULL || cx->i2c_adap[1].algo == NULL) {
347                 CX18_ERR("adapter is not set\n");
348                 return;
349         }
350         cx18_av_cmd(cx, cmd, arg);
351         i2c_clients_command(&cx->i2c_adap[0], cmd, arg);
352         i2c_clients_command(&cx->i2c_adap[1], cmd, arg);
353         if (cx->hw_flags & CX18_HW_GPIO)
354                 cx18_gpio(cx, cmd, arg);
355 }
356
357 /* init + register i2c algo-bit adapter */
358 int init_cx18_i2c(struct cx18 *cx)
359 {
360         int i;
361         CX18_DEBUG_I2C("i2c init\n");
362
363         /* Sanity checks for the I2C hardware arrays. They must be the
364          * same size and GPIO/CX23418 must be the last entries.
365          */
366         if (ARRAY_SIZE(hw_driverids) != ARRAY_SIZE(hw_addrs) ||
367             ARRAY_SIZE(hw_devicenames) != ARRAY_SIZE(hw_addrs) ||
368             CX18_HW_GPIO != (1 << (ARRAY_SIZE(hw_addrs) - 2)) ||
369             CX18_HW_CX23418 != (1 << (ARRAY_SIZE(hw_addrs) - 1)) ||
370             hw_driverids[ARRAY_SIZE(hw_addrs) - 1]) {
371                 CX18_ERR("Mismatched I2C hardware arrays\n");
372                 return -ENODEV;
373         }
374
375         for (i = 0; i < 2; i++) {
376                 memcpy(&cx->i2c_adap[i], &cx18_i2c_adap_template,
377                         sizeof(struct i2c_adapter));
378                 memcpy(&cx->i2c_algo[i], &cx18_i2c_algo_template,
379                         sizeof(struct i2c_algo_bit_data));
380                 cx->i2c_algo_cb_data[i].cx = cx;
381                 cx->i2c_algo_cb_data[i].bus_index = i;
382                 cx->i2c_algo[i].data = &cx->i2c_algo_cb_data[i];
383                 cx->i2c_adap[i].algo_data = &cx->i2c_algo[i];
384
385                 sprintf(cx->i2c_adap[i].name + strlen(cx->i2c_adap[i].name),
386                                 " #%d-%d", cx->num, i);
387                 i2c_set_adapdata(&cx->i2c_adap[i], cx);
388
389                 memcpy(&cx->i2c_client[i], &cx18_i2c_client_template,
390                         sizeof(struct i2c_client));
391                 sprintf(cx->i2c_client[i].name +
392                                 strlen(cx->i2c_client[i].name), "%d", i);
393                 cx->i2c_client[i].adapter = &cx->i2c_adap[i];
394                 cx->i2c_adap[i].dev.parent = &cx->dev->dev;
395         }
396
397         if (read_reg(CX18_REG_I2C_2_WR) != 0x0003c02f) {
398                 /* Reset/Unreset I2C hardware block */
399                 write_reg(0x10000000, 0xc71004); /* Clock select 220MHz */
400                 write_reg_sync(0x10001000, 0xc71024); /* Clock Enable */
401         }
402         /* courtesy of Steven Toth <stoth@hauppauge.com> */
403         write_reg_sync(0x00c00000, 0xc7001c);
404         mdelay(10);
405         write_reg_sync(0x00c000c0, 0xc7001c);
406         mdelay(10);
407         write_reg_sync(0x00c00000, 0xc7001c);
408         mdelay(10);
409
410         write_reg_sync(0x00c00000, 0xc730c8); /* Set to edge-triggered intrs. */
411         write_reg_sync(0x00c00000, 0xc730c4); /* Clear any stale intrs */
412
413         /* Hw I2C1 Clock Freq ~100kHz */
414         write_reg_sync(0x00021c0f & ~4, CX18_REG_I2C_1_WR);
415         cx18_setscl(&cx->i2c_algo_cb_data[0], 1);
416         cx18_setsda(&cx->i2c_algo_cb_data[0], 1);
417
418         /* Hw I2C2 Clock Freq ~100kHz */
419         write_reg_sync(0x00021c0f & ~4, CX18_REG_I2C_2_WR);
420         cx18_setscl(&cx->i2c_algo_cb_data[1], 1);
421         cx18_setsda(&cx->i2c_algo_cb_data[1], 1);
422
423         cx18_reset_i2c_slaves_gpio(cx);
424
425         return i2c_bit_add_bus(&cx->i2c_adap[0]) ||
426                 i2c_bit_add_bus(&cx->i2c_adap[1]);
427 }
428
429 void exit_cx18_i2c(struct cx18 *cx)
430 {
431         int i;
432         CX18_DEBUG_I2C("i2c exit\n");
433         write_reg(read_reg(CX18_REG_I2C_1_WR) | 4, CX18_REG_I2C_1_WR);
434         write_reg(read_reg(CX18_REG_I2C_2_WR) | 4, CX18_REG_I2C_2_WR);
435
436         for (i = 0; i < 2; i++) {
437                 i2c_del_adapter(&cx->i2c_adap[i]);
438         }
439 }
440
441 /*
442    Hauppauge HVR1600 should have:
443    32 cx24227
444    98 unknown
445    a0 eeprom
446    c2 tuner
447    e? zilog ir
448    */