1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | I2C functions |
4 | Copyright (C) 2003-2004 Kevin Thayer <nufan_wfk at yahoo.com> |
5 | Copyright (C) 2005-2007 Hans Verkuil <hverkuil@xs4all.nl> |
6 | |
7 | */ |
8 | |
9 | /* |
10 | This file includes an i2c implementation that was reverse engineered |
11 | from the Hauppauge windows driver. Older ivtv versions used i2c-algo-bit, |
12 | which whilst fine under most circumstances, had trouble with the Zilog |
13 | CPU on the PVR-150 which handles IR functions (occasional inability to |
14 | communicate with the chip until it was reset) and also with the i2c |
15 | bus being completely unreachable when multiple PVR cards were present. |
16 | |
17 | The implementation is very similar to i2c-algo-bit, but there are enough |
18 | subtle differences that the two are hard to merge. The general strategy |
19 | employed by i2c-algo-bit is to use udelay() to implement the timing |
20 | when putting out bits on the scl/sda lines. The general strategy taken |
21 | here is to poll the lines for state changes (see ivtv_waitscl and |
22 | ivtv_waitsda). In addition there are small delays at various locations |
23 | which poll the SCL line 5 times (ivtv_scldelay). I would guess that |
24 | since this is memory mapped I/O that the length of those delays is tied |
25 | to the PCI bus clock. There is some extra code to do with recovery |
26 | and retries. Since it is not known what causes the actual i2c problems |
27 | in the first place, the only goal if one was to attempt to use |
28 | i2c-algo-bit would be to try to make it follow the same code path. |
29 | This would be a lot of work, and I'm also not convinced that it would |
30 | provide a generic benefit to i2c-algo-bit. Therefore consider this |
31 | an engineering solution -- not pretty, but it works. |
32 | |
33 | Some more general comments about what we are doing: |
34 | |
35 | The i2c bus is a 2 wire serial bus, with clock (SCL) and data (SDA) |
36 | lines. To communicate on the bus (as a master, we don't act as a slave), |
37 | we first initiate a start condition (ivtv_start). We then write the |
38 | address of the device that we want to communicate with, along with a flag |
39 | that indicates whether this is a read or a write. The slave then issues |
40 | an ACK signal (ivtv_ack), which tells us that it is ready for reading / |
41 | writing. We then proceed with reading or writing (ivtv_read/ivtv_write), |
42 | and finally issue a stop condition (ivtv_stop) to make the bus available |
43 | to other masters. |
44 | |
45 | There is an additional form of transaction where a write may be |
46 | immediately followed by a read. In this case, there is no intervening |
47 | stop condition. (Only the msp3400 chip uses this method of data transfer). |
48 | */ |
49 | |
50 | #include "ivtv-driver.h" |
51 | #include "ivtv-cards.h" |
52 | #include "ivtv-gpio.h" |
53 | #include "ivtv-i2c.h" |
54 | #include <media/drv-intf/cx25840.h> |
55 | |
56 | /* i2c implementation for cx23415/6 chip, ivtv project. |
57 | * Author: Kevin Thayer (nufan_wfk at yahoo.com) |
58 | */ |
59 | /* i2c stuff */ |
60 | #define IVTV_REG_I2C_SETSCL_OFFSET 0x7000 |
61 | #define IVTV_REG_I2C_SETSDA_OFFSET 0x7004 |
62 | #define IVTV_REG_I2C_GETSCL_OFFSET 0x7008 |
63 | #define IVTV_REG_I2C_GETSDA_OFFSET 0x700c |
64 | |
65 | #define IVTV_CS53L32A_I2C_ADDR 0x11 |
66 | #define IVTV_M52790_I2C_ADDR 0x48 |
67 | #define IVTV_CX25840_I2C_ADDR 0x44 |
68 | #define IVTV_SAA7115_I2C_ADDR 0x21 |
69 | #define IVTV_SAA7127_I2C_ADDR 0x44 |
70 | #define IVTV_SAA717x_I2C_ADDR 0x21 |
71 | #define IVTV_MSP3400_I2C_ADDR 0x40 |
72 | #define IVTV_HAUPPAUGE_I2C_ADDR 0x50 |
73 | #define IVTV_WM8739_I2C_ADDR 0x1a |
74 | #define IVTV_WM8775_I2C_ADDR 0x1b |
75 | #define IVTV_TEA5767_I2C_ADDR 0x60 |
76 | #define IVTV_UPD64031A_I2C_ADDR 0x12 |
77 | #define IVTV_UPD64083_I2C_ADDR 0x5c |
78 | #define IVTV_VP27SMPX_I2C_ADDR 0x5b |
79 | #define IVTV_M52790_I2C_ADDR 0x48 |
80 | #define IVTV_AVERMEDIA_IR_RX_I2C_ADDR 0x40 |
81 | #define IVTV_HAUP_EXT_IR_RX_I2C_ADDR 0x1a |
82 | #define IVTV_HAUP_INT_IR_RX_I2C_ADDR 0x18 |
83 | #define IVTV_Z8F0811_IR_TX_I2C_ADDR 0x70 |
84 | #define IVTV_Z8F0811_IR_RX_I2C_ADDR 0x71 |
85 | #define IVTV_ADAPTEC_IR_ADDR 0x6b |
86 | |
87 | /* This array should match the IVTV_HW_ defines */ |
88 | static const u8 hw_addrs[IVTV_HW_MAX_BITS] = { |
89 | IVTV_CX25840_I2C_ADDR, |
90 | IVTV_SAA7115_I2C_ADDR, |
91 | IVTV_SAA7127_I2C_ADDR, |
92 | IVTV_MSP3400_I2C_ADDR, |
93 | 0, |
94 | IVTV_WM8775_I2C_ADDR, |
95 | IVTV_CS53L32A_I2C_ADDR, |
96 | 0, |
97 | IVTV_SAA7115_I2C_ADDR, |
98 | IVTV_UPD64031A_I2C_ADDR, |
99 | IVTV_UPD64083_I2C_ADDR, |
100 | IVTV_SAA717x_I2C_ADDR, |
101 | IVTV_WM8739_I2C_ADDR, |
102 | IVTV_VP27SMPX_I2C_ADDR, |
103 | IVTV_M52790_I2C_ADDR, |
104 | 0, /* IVTV_HW_GPIO dummy driver ID */ |
105 | IVTV_AVERMEDIA_IR_RX_I2C_ADDR, /* IVTV_HW_I2C_IR_RX_AVER */ |
106 | IVTV_HAUP_EXT_IR_RX_I2C_ADDR, /* IVTV_HW_I2C_IR_RX_HAUP_EXT */ |
107 | IVTV_HAUP_INT_IR_RX_I2C_ADDR, /* IVTV_HW_I2C_IR_RX_HAUP_INT */ |
108 | IVTV_Z8F0811_IR_RX_I2C_ADDR, /* IVTV_HW_Z8F0811_IR_HAUP */ |
109 | IVTV_ADAPTEC_IR_ADDR, /* IVTV_HW_I2C_IR_RX_ADAPTEC */ |
110 | }; |
111 | |
112 | /* This array should match the IVTV_HW_ defines */ |
113 | static const char * const hw_devicenames[IVTV_HW_MAX_BITS] = { |
114 | "cx25840" , |
115 | "saa7115" , |
116 | "saa7127_auto" , /* saa7127 or saa7129 */ |
117 | "msp3400" , |
118 | "tuner" , |
119 | "wm8775" , |
120 | "cs53l32a" , |
121 | "tveeprom" , |
122 | "saa7114" , |
123 | "upd64031a" , |
124 | "upd64083" , |
125 | "saa717x" , |
126 | "wm8739" , |
127 | "vp27smpx" , |
128 | "m52790" , |
129 | "gpio" , |
130 | "ir_video" , /* IVTV_HW_I2C_IR_RX_AVER */ |
131 | "ir_video" , /* IVTV_HW_I2C_IR_RX_HAUP_EXT */ |
132 | "ir_video" , /* IVTV_HW_I2C_IR_RX_HAUP_INT */ |
133 | "ir_z8f0811_haup" , /* IVTV_HW_Z8F0811_IR_HAUP */ |
134 | "ir_video" , /* IVTV_HW_I2C_IR_RX_ADAPTEC */ |
135 | }; |
136 | |
137 | static int get_key_adaptec(struct IR_i2c *ir, enum rc_proto *protocol, |
138 | u32 *scancode, u8 *toggle) |
139 | { |
140 | unsigned char keybuf[4]; |
141 | |
142 | keybuf[0] = 0x00; |
143 | i2c_master_send(client: ir->c, buf: keybuf, count: 1); |
144 | /* poll IR chip */ |
145 | if (i2c_master_recv(client: ir->c, buf: keybuf, count: sizeof(keybuf)) != sizeof(keybuf)) { |
146 | return 0; |
147 | } |
148 | |
149 | /* key pressed ? */ |
150 | if (keybuf[2] == 0xff) |
151 | return 0; |
152 | |
153 | /* remove repeat bit */ |
154 | keybuf[2] &= 0x7f; |
155 | keybuf[3] |= 0x80; |
156 | |
157 | *protocol = RC_PROTO_UNKNOWN; |
158 | *scancode = keybuf[3] | keybuf[2] << 8 | keybuf[1] << 16 |keybuf[0] << 24; |
159 | *toggle = 0; |
160 | return 1; |
161 | } |
162 | |
163 | static int ivtv_i2c_new_ir(struct ivtv *itv, u32 hw, const char *type, u8 addr) |
164 | { |
165 | struct i2c_board_info info; |
166 | struct i2c_adapter *adap = &itv->i2c_adap; |
167 | struct IR_i2c_init_data *init_data = &itv->ir_i2c_init_data; |
168 | unsigned short addr_list[2] = { addr, I2C_CLIENT_END }; |
169 | |
170 | /* Only allow one IR receiver to be registered per board */ |
171 | if (itv->hw_flags & IVTV_HW_IR_ANY) |
172 | return -1; |
173 | |
174 | /* Our default information for ir-kbd-i2c.c to use */ |
175 | switch (hw) { |
176 | case IVTV_HW_I2C_IR_RX_AVER: |
177 | init_data->ir_codes = RC_MAP_AVERMEDIA_CARDBUS; |
178 | init_data->internal_get_key_func = |
179 | IR_KBD_GET_KEY_AVERMEDIA_CARDBUS; |
180 | init_data->type = RC_PROTO_BIT_OTHER; |
181 | init_data->name = "AVerMedia AVerTV card" ; |
182 | break; |
183 | case IVTV_HW_I2C_IR_RX_HAUP_EXT: |
184 | case IVTV_HW_I2C_IR_RX_HAUP_INT: |
185 | init_data->ir_codes = RC_MAP_HAUPPAUGE; |
186 | init_data->internal_get_key_func = IR_KBD_GET_KEY_HAUP; |
187 | init_data->type = RC_PROTO_BIT_RC5; |
188 | init_data->name = itv->card_name; |
189 | break; |
190 | case IVTV_HW_Z8F0811_IR_HAUP: |
191 | /* Default to grey remote */ |
192 | init_data->ir_codes = RC_MAP_HAUPPAUGE; |
193 | init_data->internal_get_key_func = IR_KBD_GET_KEY_HAUP_XVR; |
194 | init_data->type = RC_PROTO_BIT_RC5 | RC_PROTO_BIT_RC6_MCE | |
195 | RC_PROTO_BIT_RC6_6A_32; |
196 | init_data->name = itv->card_name; |
197 | break; |
198 | case IVTV_HW_I2C_IR_RX_ADAPTEC: |
199 | init_data->get_key = get_key_adaptec; |
200 | init_data->name = itv->card_name; |
201 | /* FIXME: The protocol and RC_MAP needs to be corrected */ |
202 | init_data->ir_codes = RC_MAP_EMPTY; |
203 | init_data->type = RC_PROTO_BIT_UNKNOWN; |
204 | break; |
205 | } |
206 | |
207 | memset(&info, 0, sizeof(struct i2c_board_info)); |
208 | info.platform_data = init_data; |
209 | strscpy(info.type, type, I2C_NAME_SIZE); |
210 | |
211 | return IS_ERR(ptr: i2c_new_scanned_device(adap, info: &info, addr_list, NULL)) ? |
212 | -1 : 0; |
213 | } |
214 | |
215 | /* Instantiate the IR receiver device using probing -- undesirable */ |
216 | void ivtv_i2c_new_ir_legacy(struct ivtv *itv) |
217 | { |
218 | struct i2c_board_info info; |
219 | /* |
220 | * The external IR receiver is at i2c address 0x34. |
221 | * The internal IR receiver is at i2c address 0x30. |
222 | * |
223 | * In theory, both can be fitted, and Hauppauge suggests an external |
224 | * overrides an internal. That's why we probe 0x1a (~0x34) first. CB |
225 | * |
226 | * Some of these addresses we probe may collide with other i2c address |
227 | * allocations, so this function must be called after all other i2c |
228 | * devices we care about are registered. |
229 | */ |
230 | static const unsigned short addr_list[] = { |
231 | 0x1a, /* Hauppauge IR external - collides with WM8739 */ |
232 | 0x18, /* Hauppauge IR internal */ |
233 | I2C_CLIENT_END |
234 | }; |
235 | |
236 | memset(&info, 0, sizeof(struct i2c_board_info)); |
237 | strscpy(info.type, "ir_video" , I2C_NAME_SIZE); |
238 | i2c_new_scanned_device(adap: &itv->i2c_adap, info: &info, addr_list, NULL); |
239 | } |
240 | |
241 | int ivtv_i2c_register(struct ivtv *itv, unsigned idx) |
242 | { |
243 | struct i2c_adapter *adap = &itv->i2c_adap; |
244 | struct v4l2_subdev *sd; |
245 | const char *type; |
246 | u32 hw; |
247 | |
248 | if (idx >= IVTV_HW_MAX_BITS) |
249 | return -ENODEV; |
250 | |
251 | type = hw_devicenames[idx]; |
252 | hw = 1 << idx; |
253 | |
254 | if (hw == IVTV_HW_TUNER) { |
255 | /* special tuner handling */ |
256 | sd = v4l2_i2c_new_subdev(v4l2_dev: &itv->v4l2_dev, adapter: adap, client_type: type, addr: 0, |
257 | probe_addrs: itv->card_i2c->radio); |
258 | if (sd) |
259 | sd->grp_id = 1 << idx; |
260 | sd = v4l2_i2c_new_subdev(v4l2_dev: &itv->v4l2_dev, adapter: adap, client_type: type, addr: 0, |
261 | probe_addrs: itv->card_i2c->demod); |
262 | if (sd) |
263 | sd->grp_id = 1 << idx; |
264 | sd = v4l2_i2c_new_subdev(v4l2_dev: &itv->v4l2_dev, adapter: adap, client_type: type, addr: 0, |
265 | probe_addrs: itv->card_i2c->tv); |
266 | if (sd) |
267 | sd->grp_id = 1 << idx; |
268 | return sd ? 0 : -1; |
269 | } |
270 | |
271 | if (hw & IVTV_HW_IR_ANY) |
272 | return ivtv_i2c_new_ir(itv, hw, type, addr: hw_addrs[idx]); |
273 | |
274 | /* Is it not an I2C device or one we do not wish to register? */ |
275 | if (!hw_addrs[idx]) |
276 | return -1; |
277 | |
278 | /* It's an I2C device other than an analog tuner or IR chip */ |
279 | if (hw == IVTV_HW_UPD64031A || hw == IVTV_HW_UPD6408X) { |
280 | sd = v4l2_i2c_new_subdev(v4l2_dev: &itv->v4l2_dev, |
281 | adapter: adap, client_type: type, addr: 0, I2C_ADDRS(hw_addrs[idx])); |
282 | } else if (hw == IVTV_HW_CX25840) { |
283 | struct cx25840_platform_data pdata; |
284 | struct i2c_board_info cx25840_info = { |
285 | .type = "cx25840" , |
286 | .addr = hw_addrs[idx], |
287 | .platform_data = &pdata, |
288 | }; |
289 | |
290 | memset(&pdata, 0, sizeof(pdata)); |
291 | pdata.pvr150_workaround = itv->pvr150_workaround; |
292 | sd = v4l2_i2c_new_subdev_board(v4l2_dev: &itv->v4l2_dev, adapter: adap, |
293 | info: &cx25840_info, NULL); |
294 | } else { |
295 | sd = v4l2_i2c_new_subdev(v4l2_dev: &itv->v4l2_dev, |
296 | adapter: adap, client_type: type, addr: hw_addrs[idx], NULL); |
297 | } |
298 | if (sd) |
299 | sd->grp_id = 1 << idx; |
300 | return sd ? 0 : -1; |
301 | } |
302 | |
303 | struct v4l2_subdev *ivtv_find_hw(struct ivtv *itv, u32 hw) |
304 | { |
305 | struct v4l2_subdev *result = NULL; |
306 | struct v4l2_subdev *sd; |
307 | |
308 | spin_lock(lock: &itv->v4l2_dev.lock); |
309 | v4l2_device_for_each_subdev(sd, &itv->v4l2_dev) { |
310 | if (sd->grp_id == hw) { |
311 | result = sd; |
312 | break; |
313 | } |
314 | } |
315 | spin_unlock(lock: &itv->v4l2_dev.lock); |
316 | return result; |
317 | } |
318 | |
319 | /* Set the serial clock line to the desired state */ |
320 | static void ivtv_setscl(struct ivtv *itv, int state) |
321 | { |
322 | /* write them out */ |
323 | /* write bits are inverted */ |
324 | write_reg(~state, IVTV_REG_I2C_SETSCL_OFFSET); |
325 | } |
326 | |
327 | /* Set the serial data line to the desired state */ |
328 | static void ivtv_setsda(struct ivtv *itv, int state) |
329 | { |
330 | /* write them out */ |
331 | /* write bits are inverted */ |
332 | write_reg(~state & 1, IVTV_REG_I2C_SETSDA_OFFSET); |
333 | } |
334 | |
335 | /* Read the serial clock line */ |
336 | static int ivtv_getscl(struct ivtv *itv) |
337 | { |
338 | return read_reg(IVTV_REG_I2C_GETSCL_OFFSET) & 1; |
339 | } |
340 | |
341 | /* Read the serial data line */ |
342 | static int ivtv_getsda(struct ivtv *itv) |
343 | { |
344 | return read_reg(IVTV_REG_I2C_GETSDA_OFFSET) & 1; |
345 | } |
346 | |
347 | /* Implement a short delay by polling the serial clock line */ |
348 | static void ivtv_scldelay(struct ivtv *itv) |
349 | { |
350 | int i; |
351 | |
352 | for (i = 0; i < 5; ++i) |
353 | ivtv_getscl(itv); |
354 | } |
355 | |
356 | /* Wait for the serial clock line to become set to a specific value */ |
357 | static int ivtv_waitscl(struct ivtv *itv, int val) |
358 | { |
359 | int i; |
360 | |
361 | ivtv_scldelay(itv); |
362 | for (i = 0; i < 1000; ++i) { |
363 | if (ivtv_getscl(itv) == val) |
364 | return 1; |
365 | } |
366 | return 0; |
367 | } |
368 | |
369 | /* Wait for the serial data line to become set to a specific value */ |
370 | static int ivtv_waitsda(struct ivtv *itv, int val) |
371 | { |
372 | int i; |
373 | |
374 | ivtv_scldelay(itv); |
375 | for (i = 0; i < 1000; ++i) { |
376 | if (ivtv_getsda(itv) == val) |
377 | return 1; |
378 | } |
379 | return 0; |
380 | } |
381 | |
382 | /* Wait for the slave to issue an ACK */ |
383 | static int ivtv_ack(struct ivtv *itv) |
384 | { |
385 | int ret = 0; |
386 | |
387 | if (ivtv_getscl(itv) == 1) { |
388 | IVTV_DEBUG_HI_I2C("SCL was high starting an ack\n" ); |
389 | ivtv_setscl(itv, state: 0); |
390 | if (!ivtv_waitscl(itv, val: 0)) { |
391 | IVTV_DEBUG_I2C("Could not set SCL low starting an ack\n" ); |
392 | return -EREMOTEIO; |
393 | } |
394 | } |
395 | ivtv_setsda(itv, state: 1); |
396 | ivtv_scldelay(itv); |
397 | ivtv_setscl(itv, state: 1); |
398 | if (!ivtv_waitsda(itv, val: 0)) { |
399 | IVTV_DEBUG_I2C("Slave did not ack\n" ); |
400 | ret = -EREMOTEIO; |
401 | } |
402 | ivtv_setscl(itv, state: 0); |
403 | if (!ivtv_waitscl(itv, val: 0)) { |
404 | IVTV_DEBUG_I2C("Failed to set SCL low after ACK\n" ); |
405 | ret = -EREMOTEIO; |
406 | } |
407 | return ret; |
408 | } |
409 | |
410 | /* Write a single byte to the i2c bus and wait for the slave to ACK */ |
411 | static int ivtv_sendbyte(struct ivtv *itv, unsigned char byte) |
412 | { |
413 | int i, bit; |
414 | |
415 | IVTV_DEBUG_HI_I2C("write %x\n" ,byte); |
416 | for (i = 0; i < 8; ++i, byte<<=1) { |
417 | ivtv_setscl(itv, state: 0); |
418 | if (!ivtv_waitscl(itv, val: 0)) { |
419 | IVTV_DEBUG_I2C("Error setting SCL low\n" ); |
420 | return -EREMOTEIO; |
421 | } |
422 | bit = (byte>>7)&1; |
423 | ivtv_setsda(itv, state: bit); |
424 | if (!ivtv_waitsda(itv, val: bit)) { |
425 | IVTV_DEBUG_I2C("Error setting SDA\n" ); |
426 | return -EREMOTEIO; |
427 | } |
428 | ivtv_setscl(itv, state: 1); |
429 | if (!ivtv_waitscl(itv, val: 1)) { |
430 | IVTV_DEBUG_I2C("Slave not ready for bit\n" ); |
431 | return -EREMOTEIO; |
432 | } |
433 | } |
434 | ivtv_setscl(itv, state: 0); |
435 | if (!ivtv_waitscl(itv, val: 0)) { |
436 | IVTV_DEBUG_I2C("Error setting SCL low\n" ); |
437 | return -EREMOTEIO; |
438 | } |
439 | return ivtv_ack(itv); |
440 | } |
441 | |
442 | /* Read a byte from the i2c bus and send a NACK if applicable (i.e. for the |
443 | final byte) */ |
444 | static int ivtv_readbyte(struct ivtv *itv, unsigned char *byte, int nack) |
445 | { |
446 | int i; |
447 | |
448 | *byte = 0; |
449 | |
450 | ivtv_setsda(itv, state: 1); |
451 | ivtv_scldelay(itv); |
452 | for (i = 0; i < 8; ++i) { |
453 | ivtv_setscl(itv, state: 0); |
454 | ivtv_scldelay(itv); |
455 | ivtv_setscl(itv, state: 1); |
456 | if (!ivtv_waitscl(itv, val: 1)) { |
457 | IVTV_DEBUG_I2C("Error setting SCL high\n" ); |
458 | return -EREMOTEIO; |
459 | } |
460 | *byte = ((*byte)<<1)|ivtv_getsda(itv); |
461 | } |
462 | ivtv_setscl(itv, state: 0); |
463 | ivtv_scldelay(itv); |
464 | ivtv_setsda(itv, state: nack); |
465 | ivtv_scldelay(itv); |
466 | ivtv_setscl(itv, state: 1); |
467 | ivtv_scldelay(itv); |
468 | ivtv_setscl(itv, state: 0); |
469 | ivtv_scldelay(itv); |
470 | IVTV_DEBUG_HI_I2C("read %x\n" ,*byte); |
471 | return 0; |
472 | } |
473 | |
474 | /* Issue a start condition on the i2c bus to alert slaves to prepare for |
475 | an address write */ |
476 | static int ivtv_start(struct ivtv *itv) |
477 | { |
478 | int sda; |
479 | |
480 | sda = ivtv_getsda(itv); |
481 | if (sda != 1) { |
482 | IVTV_DEBUG_HI_I2C("SDA was low at start\n" ); |
483 | ivtv_setsda(itv, state: 1); |
484 | if (!ivtv_waitsda(itv, val: 1)) { |
485 | IVTV_DEBUG_I2C("SDA stuck low\n" ); |
486 | return -EREMOTEIO; |
487 | } |
488 | } |
489 | if (ivtv_getscl(itv) != 1) { |
490 | ivtv_setscl(itv, state: 1); |
491 | if (!ivtv_waitscl(itv, val: 1)) { |
492 | IVTV_DEBUG_I2C("SCL stuck low at start\n" ); |
493 | return -EREMOTEIO; |
494 | } |
495 | } |
496 | ivtv_setsda(itv, state: 0); |
497 | ivtv_scldelay(itv); |
498 | return 0; |
499 | } |
500 | |
501 | /* Issue a stop condition on the i2c bus to release it */ |
502 | static int ivtv_stop(struct ivtv *itv) |
503 | { |
504 | int i; |
505 | |
506 | if (ivtv_getscl(itv) != 0) { |
507 | IVTV_DEBUG_HI_I2C("SCL not low when stopping\n" ); |
508 | ivtv_setscl(itv, state: 0); |
509 | if (!ivtv_waitscl(itv, val: 0)) { |
510 | IVTV_DEBUG_I2C("SCL could not be set low\n" ); |
511 | } |
512 | } |
513 | ivtv_setsda(itv, state: 0); |
514 | ivtv_scldelay(itv); |
515 | ivtv_setscl(itv, state: 1); |
516 | if (!ivtv_waitscl(itv, val: 1)) { |
517 | IVTV_DEBUG_I2C("SCL could not be set high\n" ); |
518 | return -EREMOTEIO; |
519 | } |
520 | ivtv_scldelay(itv); |
521 | ivtv_setsda(itv, state: 1); |
522 | if (!ivtv_waitsda(itv, val: 1)) { |
523 | IVTV_DEBUG_I2C("resetting I2C\n" ); |
524 | for (i = 0; i < 16; ++i) { |
525 | ivtv_setscl(itv, state: 0); |
526 | ivtv_scldelay(itv); |
527 | ivtv_setscl(itv, state: 1); |
528 | ivtv_scldelay(itv); |
529 | ivtv_setsda(itv, state: 1); |
530 | } |
531 | ivtv_waitsda(itv, val: 1); |
532 | return -EREMOTEIO; |
533 | } |
534 | return 0; |
535 | } |
536 | |
537 | /* Write a message to the given i2c slave. do_stop may be 0 to prevent |
538 | issuing the i2c stop condition (when following with a read) */ |
539 | static int ivtv_write(struct ivtv *itv, unsigned char addr, unsigned char *data, u32 len, int do_stop) |
540 | { |
541 | int retry, ret = -EREMOTEIO; |
542 | u32 i; |
543 | |
544 | for (retry = 0; ret != 0 && retry < 8; ++retry) { |
545 | ret = ivtv_start(itv); |
546 | |
547 | if (ret == 0) { |
548 | ret = ivtv_sendbyte(itv, byte: addr<<1); |
549 | for (i = 0; ret == 0 && i < len; ++i) |
550 | ret = ivtv_sendbyte(itv, byte: data[i]); |
551 | } |
552 | if (ret != 0 || do_stop) { |
553 | ivtv_stop(itv); |
554 | } |
555 | } |
556 | if (ret) |
557 | IVTV_DEBUG_I2C("i2c write to %x failed\n" , addr); |
558 | return ret; |
559 | } |
560 | |
561 | /* Read data from the given i2c slave. A stop condition is always issued. */ |
562 | static int ivtv_read(struct ivtv *itv, unsigned char addr, unsigned char *data, u32 len) |
563 | { |
564 | int retry, ret = -EREMOTEIO; |
565 | u32 i; |
566 | |
567 | for (retry = 0; ret != 0 && retry < 8; ++retry) { |
568 | ret = ivtv_start(itv); |
569 | if (ret == 0) |
570 | ret = ivtv_sendbyte(itv, byte: (addr << 1) | 1); |
571 | for (i = 0; ret == 0 && i < len; ++i) { |
572 | ret = ivtv_readbyte(itv, byte: &data[i], nack: i == len - 1); |
573 | } |
574 | ivtv_stop(itv); |
575 | } |
576 | if (ret) |
577 | IVTV_DEBUG_I2C("i2c read from %x failed\n" , addr); |
578 | return ret; |
579 | } |
580 | |
581 | /* Kernel i2c transfer implementation. Takes a number of messages to be read |
582 | or written. If a read follows a write, this will occur without an |
583 | intervening stop condition */ |
584 | static int ivtv_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg *msgs, int num) |
585 | { |
586 | struct v4l2_device *v4l2_dev = i2c_get_adapdata(adap: i2c_adap); |
587 | struct ivtv *itv = to_ivtv(v4l2_dev); |
588 | int retval; |
589 | int i; |
590 | |
591 | mutex_lock(&itv->i2c_bus_lock); |
592 | for (i = retval = 0; retval == 0 && i < num; i++) { |
593 | if (msgs[i].flags & I2C_M_RD) |
594 | retval = ivtv_read(itv, addr: msgs[i].addr, data: msgs[i].buf, len: msgs[i].len); |
595 | else { |
596 | /* if followed by a read, don't stop */ |
597 | int stop = !(i + 1 < num && msgs[i + 1].flags == I2C_M_RD); |
598 | |
599 | retval = ivtv_write(itv, addr: msgs[i].addr, data: msgs[i].buf, len: msgs[i].len, do_stop: stop); |
600 | } |
601 | } |
602 | mutex_unlock(lock: &itv->i2c_bus_lock); |
603 | return retval ? retval : num; |
604 | } |
605 | |
606 | /* Kernel i2c capabilities */ |
607 | static u32 ivtv_functionality(struct i2c_adapter *adap) |
608 | { |
609 | return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL; |
610 | } |
611 | |
612 | static const struct i2c_algorithm ivtv_algo = { |
613 | .master_xfer = ivtv_xfer, |
614 | .functionality = ivtv_functionality, |
615 | }; |
616 | |
617 | /* template for our-bit banger */ |
618 | static const struct i2c_adapter ivtv_i2c_adap_hw_template = { |
619 | .name = "ivtv i2c driver" , |
620 | .algo = &ivtv_algo, |
621 | .algo_data = NULL, /* filled from template */ |
622 | .owner = THIS_MODULE, |
623 | }; |
624 | |
625 | static void ivtv_setscl_old(void *data, int state) |
626 | { |
627 | struct ivtv *itv = (struct ivtv *)data; |
628 | |
629 | if (state) |
630 | itv->i2c_state |= 0x01; |
631 | else |
632 | itv->i2c_state &= ~0x01; |
633 | |
634 | /* write them out */ |
635 | /* write bits are inverted */ |
636 | write_reg(~itv->i2c_state, IVTV_REG_I2C_SETSCL_OFFSET); |
637 | } |
638 | |
639 | static void ivtv_setsda_old(void *data, int state) |
640 | { |
641 | struct ivtv *itv = (struct ivtv *)data; |
642 | |
643 | if (state) |
644 | itv->i2c_state |= 0x01; |
645 | else |
646 | itv->i2c_state &= ~0x01; |
647 | |
648 | /* write them out */ |
649 | /* write bits are inverted */ |
650 | write_reg(~itv->i2c_state, IVTV_REG_I2C_SETSDA_OFFSET); |
651 | } |
652 | |
653 | static int ivtv_getscl_old(void *data) |
654 | { |
655 | struct ivtv *itv = (struct ivtv *)data; |
656 | |
657 | return read_reg(IVTV_REG_I2C_GETSCL_OFFSET) & 1; |
658 | } |
659 | |
660 | static int ivtv_getsda_old(void *data) |
661 | { |
662 | struct ivtv *itv = (struct ivtv *)data; |
663 | |
664 | return read_reg(IVTV_REG_I2C_GETSDA_OFFSET) & 1; |
665 | } |
666 | |
667 | /* template for i2c-bit-algo */ |
668 | static const struct i2c_adapter ivtv_i2c_adap_template = { |
669 | .name = "ivtv i2c driver" , |
670 | .algo = NULL, /* set by i2c-algo-bit */ |
671 | .algo_data = NULL, /* filled from template */ |
672 | .owner = THIS_MODULE, |
673 | }; |
674 | |
675 | #define IVTV_ALGO_BIT_TIMEOUT (2) /* seconds */ |
676 | |
677 | static const struct i2c_algo_bit_data ivtv_i2c_algo_template = { |
678 | .setsda = ivtv_setsda_old, |
679 | .setscl = ivtv_setscl_old, |
680 | .getsda = ivtv_getsda_old, |
681 | .getscl = ivtv_getscl_old, |
682 | .udelay = IVTV_DEFAULT_I2C_CLOCK_PERIOD / 2, /* microseconds */ |
683 | .timeout = IVTV_ALGO_BIT_TIMEOUT * HZ, /* jiffies */ |
684 | }; |
685 | |
686 | static const struct i2c_client ivtv_i2c_client_template = { |
687 | .name = "ivtv internal" , |
688 | }; |
689 | |
690 | /* init + register i2c adapter */ |
691 | int init_ivtv_i2c(struct ivtv *itv) |
692 | { |
693 | int retval; |
694 | |
695 | IVTV_DEBUG_I2C("i2c init\n" ); |
696 | |
697 | /* Sanity checks for the I2C hardware arrays. They must be the |
698 | * same size. |
699 | */ |
700 | if (ARRAY_SIZE(hw_devicenames) != ARRAY_SIZE(hw_addrs)) { |
701 | IVTV_ERR("Mismatched I2C hardware arrays\n" ); |
702 | return -ENODEV; |
703 | } |
704 | if (itv->options.newi2c > 0) { |
705 | itv->i2c_adap = ivtv_i2c_adap_hw_template; |
706 | } else { |
707 | itv->i2c_adap = ivtv_i2c_adap_template; |
708 | itv->i2c_algo = ivtv_i2c_algo_template; |
709 | } |
710 | itv->i2c_algo.udelay = itv->options.i2c_clock_period / 2; |
711 | itv->i2c_algo.data = itv; |
712 | itv->i2c_adap.algo_data = &itv->i2c_algo; |
713 | |
714 | sprintf(buf: itv->i2c_adap.name + strlen(itv->i2c_adap.name), fmt: " #%d" , |
715 | itv->instance); |
716 | i2c_set_adapdata(adap: &itv->i2c_adap, data: &itv->v4l2_dev); |
717 | |
718 | itv->i2c_client = ivtv_i2c_client_template; |
719 | itv->i2c_client.adapter = &itv->i2c_adap; |
720 | itv->i2c_adap.dev.parent = &itv->pdev->dev; |
721 | |
722 | IVTV_DEBUG_I2C("setting scl and sda to 1\n" ); |
723 | ivtv_setscl(itv, state: 1); |
724 | ivtv_setsda(itv, state: 1); |
725 | |
726 | if (itv->options.newi2c > 0) |
727 | retval = i2c_add_adapter(adap: &itv->i2c_adap); |
728 | else |
729 | retval = i2c_bit_add_bus(&itv->i2c_adap); |
730 | |
731 | return retval; |
732 | } |
733 | |
734 | void exit_ivtv_i2c(struct ivtv *itv) |
735 | { |
736 | IVTV_DEBUG_I2C("i2c exit\n" ); |
737 | |
738 | i2c_del_adapter(adap: &itv->i2c_adap); |
739 | } |
740 | |