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