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