treewide: Replace GPLv2 boilerplate/reference with SPDX - rule 157
[sfrench/cifs-2.6.git] / drivers / media / usb / dvb-usb-v2 / mxl111sf-i2c.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *  mxl111sf-i2c.c - driver for the MaxLinear MXL111SF
4  *
5  *  Copyright (C) 2010-2014 Michael Krufky <mkrufky@linuxtv.org>
6  */
7
8 #include "mxl111sf-i2c.h"
9 #include "mxl111sf.h"
10
11 /* SW-I2C ----------------------------------------------------------------- */
12
13 #define SW_I2C_ADDR             0x1a
14 #define SW_I2C_EN               0x02
15 #define SW_SCL_OUT              0x04
16 #define SW_SDA_OUT              0x08
17 #define SW_SDA_IN               0x04
18
19 #define SW_I2C_BUSY_ADDR        0x2f
20 #define SW_I2C_BUSY             0x02
21
22 static int mxl111sf_i2c_bitbang_sendbyte(struct mxl111sf_state *state,
23                                          u8 byte)
24 {
25         int i, ret;
26         u8 data = 0;
27
28         mxl_i2c("(0x%02x)", byte);
29
30         ret = mxl111sf_read_reg(state, SW_I2C_BUSY_ADDR, &data);
31         if (mxl_fail(ret))
32                 goto fail;
33
34         for (i = 0; i < 8; i++) {
35
36                 data = (byte & (0x80 >> i)) ? SW_SDA_OUT : 0;
37
38                 ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
39                                          0x10 | SW_I2C_EN | data);
40                 if (mxl_fail(ret))
41                         goto fail;
42
43                 ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
44                                          0x10 | SW_I2C_EN | data | SW_SCL_OUT);
45                 if (mxl_fail(ret))
46                         goto fail;
47
48                 ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
49                                          0x10 | SW_I2C_EN | data);
50                 if (mxl_fail(ret))
51                         goto fail;
52         }
53
54         /* last bit was 0 so we need to release SDA */
55         if (!(byte & 1)) {
56                 ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
57                                          0x10 | SW_I2C_EN | SW_SDA_OUT);
58                 if (mxl_fail(ret))
59                         goto fail;
60         }
61
62         /* CLK high for ACK readback */
63         ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
64                                  0x10 | SW_I2C_EN | SW_SCL_OUT | SW_SDA_OUT);
65         if (mxl_fail(ret))
66                 goto fail;
67
68         ret = mxl111sf_read_reg(state, SW_I2C_BUSY_ADDR, &data);
69         if (mxl_fail(ret))
70                 goto fail;
71
72         /* drop the CLK after getting ACK, SDA will go high right away */
73         ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
74                                  0x10 | SW_I2C_EN | SW_SDA_OUT);
75         if (mxl_fail(ret))
76                 goto fail;
77
78         if (data & SW_SDA_IN)
79                 ret = -EIO;
80 fail:
81         return ret;
82 }
83
84 static int mxl111sf_i2c_bitbang_recvbyte(struct mxl111sf_state *state,
85                                          u8 *pbyte)
86 {
87         int i, ret;
88         u8 byte = 0;
89         u8 data = 0;
90
91         mxl_i2c("()");
92
93         *pbyte = 0;
94
95         ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
96                                  0x10 | SW_I2C_EN | SW_SDA_OUT);
97         if (mxl_fail(ret))
98                 goto fail;
99
100         for (i = 0; i < 8; i++) {
101                 ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
102                                          0x10 | SW_I2C_EN |
103                                          SW_SCL_OUT | SW_SDA_OUT);
104                 if (mxl_fail(ret))
105                         goto fail;
106
107                 ret = mxl111sf_read_reg(state, SW_I2C_BUSY_ADDR, &data);
108                 if (mxl_fail(ret))
109                         goto fail;
110
111                 if (data & SW_SDA_IN)
112                         byte |= (0x80 >> i);
113
114                 ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
115                                          0x10 | SW_I2C_EN | SW_SDA_OUT);
116                 if (mxl_fail(ret))
117                         goto fail;
118         }
119         *pbyte = byte;
120 fail:
121         return ret;
122 }
123
124 static int mxl111sf_i2c_start(struct mxl111sf_state *state)
125 {
126         int ret;
127
128         mxl_i2c("()");
129
130         ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
131                                  0x10 | SW_I2C_EN | SW_SCL_OUT | SW_SDA_OUT);
132         if (mxl_fail(ret))
133                 goto fail;
134
135         ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
136                                  0x10 | SW_I2C_EN | SW_SCL_OUT);
137         if (mxl_fail(ret))
138                 goto fail;
139
140         ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
141                                  0x10 | SW_I2C_EN); /* start */
142         mxl_fail(ret);
143 fail:
144         return ret;
145 }
146
147 static int mxl111sf_i2c_stop(struct mxl111sf_state *state)
148 {
149         int ret;
150
151         mxl_i2c("()");
152
153         ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
154                                  0x10 | SW_I2C_EN); /* stop */
155         if (mxl_fail(ret))
156                 goto fail;
157
158         ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
159                                  0x10 | SW_I2C_EN | SW_SCL_OUT);
160         if (mxl_fail(ret))
161                 goto fail;
162
163         ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
164                                  0x10 | SW_I2C_EN | SW_SCL_OUT | SW_SDA_OUT);
165         if (mxl_fail(ret))
166                 goto fail;
167
168         ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
169                                  0x10 | SW_SCL_OUT | SW_SDA_OUT);
170         mxl_fail(ret);
171 fail:
172         return ret;
173 }
174
175 static int mxl111sf_i2c_ack(struct mxl111sf_state *state)
176 {
177         int ret;
178         u8 b = 0;
179
180         mxl_i2c("()");
181
182         ret = mxl111sf_read_reg(state, SW_I2C_BUSY_ADDR, &b);
183         if (mxl_fail(ret))
184                 goto fail;
185
186         ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
187                                  0x10 | SW_I2C_EN);
188         if (mxl_fail(ret))
189                 goto fail;
190
191         /* pull SDA low */
192         ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
193                                  0x10 | SW_I2C_EN | SW_SCL_OUT);
194         if (mxl_fail(ret))
195                 goto fail;
196
197         ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
198                                  0x10 | SW_I2C_EN | SW_SDA_OUT);
199         mxl_fail(ret);
200 fail:
201         return ret;
202 }
203
204 static int mxl111sf_i2c_nack(struct mxl111sf_state *state)
205 {
206         int ret;
207
208         mxl_i2c("()");
209
210         /* SDA high to signal last byte read from slave */
211         ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
212                                  0x10 | SW_I2C_EN | SW_SCL_OUT | SW_SDA_OUT);
213         if (mxl_fail(ret))
214                 goto fail;
215
216         ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
217                                  0x10 | SW_I2C_EN | SW_SDA_OUT);
218         mxl_fail(ret);
219 fail:
220         return ret;
221 }
222
223 /* ------------------------------------------------------------------------ */
224
225 static int mxl111sf_i2c_sw_xfer_msg(struct mxl111sf_state *state,
226                                     struct i2c_msg *msg)
227 {
228         int i, ret;
229
230         mxl_i2c("()");
231
232         if (msg->flags & I2C_M_RD) {
233
234                 ret = mxl111sf_i2c_start(state);
235                 if (mxl_fail(ret))
236                         goto fail;
237
238                 ret = mxl111sf_i2c_bitbang_sendbyte(state,
239                                                     (msg->addr << 1) | 0x01);
240                 if (mxl_fail(ret)) {
241                         mxl111sf_i2c_stop(state);
242                         goto fail;
243                 }
244
245                 for (i = 0; i < msg->len; i++) {
246                         ret = mxl111sf_i2c_bitbang_recvbyte(state,
247                                                             &msg->buf[i]);
248                         if (mxl_fail(ret)) {
249                                 mxl111sf_i2c_stop(state);
250                                 goto fail;
251                         }
252
253                         if (i < msg->len - 1)
254                                 mxl111sf_i2c_ack(state);
255                 }
256
257                 mxl111sf_i2c_nack(state);
258
259                 ret = mxl111sf_i2c_stop(state);
260                 if (mxl_fail(ret))
261                         goto fail;
262
263         } else {
264
265                 ret = mxl111sf_i2c_start(state);
266                 if (mxl_fail(ret))
267                         goto fail;
268
269                 ret = mxl111sf_i2c_bitbang_sendbyte(state,
270                                                     (msg->addr << 1) & 0xfe);
271                 if (mxl_fail(ret)) {
272                         mxl111sf_i2c_stop(state);
273                         goto fail;
274                 }
275
276                 for (i = 0; i < msg->len; i++) {
277                         ret = mxl111sf_i2c_bitbang_sendbyte(state,
278                                                             msg->buf[i]);
279                         if (mxl_fail(ret)) {
280                                 mxl111sf_i2c_stop(state);
281                                 goto fail;
282                         }
283                 }
284
285                 /* FIXME: we only want to do this on the last transaction */
286                 mxl111sf_i2c_stop(state);
287         }
288 fail:
289         return ret;
290 }
291
292 /* HW-I2C ----------------------------------------------------------------- */
293
294 #define USB_WRITE_I2C_CMD     0x99
295 #define USB_READ_I2C_CMD      0xdd
296 #define USB_END_I2C_CMD       0xfe
297
298 #define USB_WRITE_I2C_CMD_LEN   26
299 #define USB_READ_I2C_CMD_LEN    24
300
301 #define I2C_MUX_REG           0x30
302 #define I2C_CONTROL_REG       0x00
303 #define I2C_SLAVE_ADDR_REG    0x08
304 #define I2C_DATA_REG          0x0c
305 #define I2C_INT_STATUS_REG    0x10
306
307 static int mxl111sf_i2c_send_data(struct mxl111sf_state *state,
308                                   u8 index, u8 *wdata)
309 {
310         int ret = mxl111sf_ctrl_msg(state, wdata[0],
311                                     &wdata[1], 25, NULL, 0);
312         mxl_fail(ret);
313
314         return ret;
315 }
316
317 static int mxl111sf_i2c_get_data(struct mxl111sf_state *state,
318                                  u8 index, u8 *wdata, u8 *rdata)
319 {
320         int ret = mxl111sf_ctrl_msg(state, wdata[0],
321                                     &wdata[1], 25, rdata, 24);
322         mxl_fail(ret);
323
324         return ret;
325 }
326
327 static u8 mxl111sf_i2c_check_status(struct mxl111sf_state *state)
328 {
329         u8 status = 0;
330         u8 buf[26];
331
332         mxl_i2c_adv("()");
333
334         buf[0] = USB_READ_I2C_CMD;
335         buf[1] = 0x00;
336
337         buf[2] = I2C_INT_STATUS_REG;
338         buf[3] = 0x00;
339         buf[4] = 0x00;
340
341         buf[5] = USB_END_I2C_CMD;
342
343         mxl111sf_i2c_get_data(state, 0, buf, buf);
344
345         if (buf[1] & 0x04)
346                 status = 1;
347
348         return status;
349 }
350
351 static u8 mxl111sf_i2c_check_fifo(struct mxl111sf_state *state)
352 {
353         u8 status = 0;
354         u8 buf[26];
355
356         mxl_i2c("()");
357
358         buf[0] = USB_READ_I2C_CMD;
359         buf[1] = 0x00;
360
361         buf[2] = I2C_MUX_REG;
362         buf[3] = 0x00;
363         buf[4] = 0x00;
364
365         buf[5] = I2C_INT_STATUS_REG;
366         buf[6] = 0x00;
367         buf[7] = 0x00;
368         buf[8] = USB_END_I2C_CMD;
369
370         mxl111sf_i2c_get_data(state, 0, buf, buf);
371
372         if (0x08 == (buf[1] & 0x08))
373                 status = 1;
374
375         if ((buf[5] & 0x02) == 0x02)
376                 mxl_i2c("(buf[5] & 0x02) == 0x02"); /* FIXME */
377
378         return status;
379 }
380
381 static int mxl111sf_i2c_readagain(struct mxl111sf_state *state,
382                                   u8 count, u8 *rbuf)
383 {
384         u8 i2c_w_data[26];
385         u8 i2c_r_data[24];
386         u8 i = 0;
387         u8 fifo_status = 0;
388         int status = 0;
389
390         mxl_i2c("read %d bytes", count);
391
392         while ((fifo_status == 0) && (i++ < 5))
393                 fifo_status = mxl111sf_i2c_check_fifo(state);
394
395         i2c_w_data[0] = 0xDD;
396         i2c_w_data[1] = 0x00;
397
398         for (i = 2; i < 26; i++)
399                 i2c_w_data[i] = 0xFE;
400
401         for (i = 0; i < count; i++) {
402                 i2c_w_data[2+(i*3)] = 0x0C;
403                 i2c_w_data[3+(i*3)] = 0x00;
404                 i2c_w_data[4+(i*3)] = 0x00;
405         }
406
407         mxl111sf_i2c_get_data(state, 0, i2c_w_data, i2c_r_data);
408
409         /* Check for I2C NACK status */
410         if (mxl111sf_i2c_check_status(state) == 1) {
411                 mxl_i2c("error!");
412         } else {
413                 for (i = 0; i < count; i++) {
414                         rbuf[i] = i2c_r_data[(i*3)+1];
415                         mxl_i2c("%02x\t %02x",
416                                 i2c_r_data[(i*3)+1],
417                                 i2c_r_data[(i*3)+2]);
418                 }
419
420                 status = 1;
421         }
422
423         return status;
424 }
425
426 #define HWI2C400 1
427 static int mxl111sf_i2c_hw_xfer_msg(struct mxl111sf_state *state,
428                                     struct i2c_msg *msg)
429 {
430         int i, k, ret = 0;
431         u16 index = 0;
432         u8 buf[26];
433         u8 i2c_r_data[24];
434         u16 block_len;
435         u16 left_over_len;
436         u8 rd_status[8];
437         u8 ret_status;
438         u8 readbuff[26];
439
440         mxl_i2c("addr: 0x%02x, read buff len: %d, write buff len: %d",
441                 msg->addr, (msg->flags & I2C_M_RD) ? msg->len : 0,
442                 (!(msg->flags & I2C_M_RD)) ? msg->len : 0);
443
444         for (index = 0; index < 26; index++)
445                 buf[index] = USB_END_I2C_CMD;
446
447         /* command to indicate data payload is destined for I2C interface */
448         buf[0] = USB_WRITE_I2C_CMD;
449         buf[1] = 0x00;
450
451         /* enable I2C interface */
452         buf[2] = I2C_MUX_REG;
453         buf[3] = 0x80;
454         buf[4] = 0x00;
455
456         /* enable I2C interface */
457         buf[5] = I2C_MUX_REG;
458         buf[6] = 0x81;
459         buf[7] = 0x00;
460
461         /* set Timeout register on I2C interface */
462         buf[8] = 0x14;
463         buf[9] = 0xff;
464         buf[10] = 0x00;
465 #if 0
466         /* enable Interrupts on I2C interface */
467         buf[8] = 0x24;
468         buf[9] = 0xF7;
469         buf[10] = 0x00;
470 #endif
471         buf[11] = 0x24;
472         buf[12] = 0xF7;
473         buf[13] = 0x00;
474
475         ret = mxl111sf_i2c_send_data(state, 0, buf);
476
477         /* write data on I2C bus */
478         if (!(msg->flags & I2C_M_RD) && (msg->len > 0)) {
479                 mxl_i2c("%d\t%02x", msg->len, msg->buf[0]);
480
481                 /* control register on I2C interface to initialize I2C bus */
482                 buf[2] = I2C_CONTROL_REG;
483                 buf[3] = 0x5E;
484                 buf[4] = (HWI2C400) ? 0x03 : 0x0D;
485
486                 /* I2C Slave device Address */
487                 buf[5] = I2C_SLAVE_ADDR_REG;
488                 buf[6] = (msg->addr);
489                 buf[7] = 0x00;
490                 buf[8] = USB_END_I2C_CMD;
491                 ret = mxl111sf_i2c_send_data(state, 0, buf);
492
493                 /* check for slave device status */
494                 if (mxl111sf_i2c_check_status(state) == 1) {
495                         mxl_i2c("NACK writing slave address %02x",
496                                 msg->addr);
497                         /* if NACK, stop I2C bus and exit */
498                         buf[2] = I2C_CONTROL_REG;
499                         buf[3] = 0x4E;
500                         buf[4] = (HWI2C400) ? 0x03 : 0x0D;
501                         ret = -EIO;
502                         goto exit;
503                 }
504
505                 /* I2C interface can do I2C operations in block of 8 bytes of
506                    I2C data. calculation to figure out number of blocks of i2c
507                    data required to program */
508                 block_len = (msg->len / 8);
509                 left_over_len = (msg->len % 8);
510
511                 mxl_i2c("block_len %d, left_over_len %d",
512                         block_len, left_over_len);
513
514                 for (index = 0; index < block_len; index++) {
515                         for (i = 0; i < 8; i++) {
516                                 /* write data on I2C interface */
517                                 buf[2+(i*3)] = I2C_DATA_REG;
518                                 buf[3+(i*3)] = msg->buf[(index*8)+i];
519                                 buf[4+(i*3)] = 0x00;
520                         }
521
522                         ret = mxl111sf_i2c_send_data(state, 0, buf);
523
524                         /* check for I2C NACK status */
525                         if (mxl111sf_i2c_check_status(state) == 1) {
526                                 mxl_i2c("NACK writing slave address %02x",
527                                         msg->addr);
528
529                                 /* if NACK, stop I2C bus and exit */
530                                 buf[2] = I2C_CONTROL_REG;
531                                 buf[3] = 0x4E;
532                                 buf[4] = (HWI2C400) ? 0x03 : 0x0D;
533                                 ret = -EIO;
534                                 goto exit;
535                         }
536
537                 }
538
539                 if (left_over_len) {
540                         for (k = 0; k < 26; k++)
541                                 buf[k] = USB_END_I2C_CMD;
542
543                         buf[0] = 0x99;
544                         buf[1] = 0x00;
545
546                         for (i = 0; i < left_over_len; i++) {
547                                 buf[2+(i*3)] = I2C_DATA_REG;
548                                 buf[3+(i*3)] = msg->buf[(index*8)+i];
549                                 mxl_i2c("index = %d %d data %d",
550                                         index, i, msg->buf[(index*8)+i]);
551                                 buf[4+(i*3)] = 0x00;
552                         }
553                         ret = mxl111sf_i2c_send_data(state, 0, buf);
554
555                         /* check for I2C NACK status */
556                         if (mxl111sf_i2c_check_status(state) == 1) {
557                                 mxl_i2c("NACK writing slave address %02x",
558                                         msg->addr);
559
560                                 /* if NACK, stop I2C bus and exit */
561                                 buf[2] = I2C_CONTROL_REG;
562                                 buf[3] = 0x4E;
563                                 buf[4] = (HWI2C400) ? 0x03 : 0x0D;
564                                 ret = -EIO;
565                                 goto exit;
566                         }
567
568                 }
569
570                 /* issue I2C STOP after write */
571                 buf[2] = I2C_CONTROL_REG;
572                 buf[3] = 0x4E;
573                 buf[4] = (HWI2C400) ? 0x03 : 0x0D;
574
575         }
576
577         /* read data from I2C bus */
578         if ((msg->flags & I2C_M_RD) && (msg->len > 0)) {
579                 mxl_i2c("read buf len %d", msg->len);
580
581                 /* command to indicate data payload is
582                    destined for I2C interface */
583                 buf[2] = I2C_CONTROL_REG;
584                 buf[3] = 0xDF;
585                 buf[4] = (HWI2C400) ? 0x03 : 0x0D;
586
587                 /* I2C xfer length */
588                 buf[5] = 0x14;
589                 buf[6] = (msg->len & 0xFF);
590                 buf[7] = 0;
591
592                 /* I2C slave device Address */
593                 buf[8] = I2C_SLAVE_ADDR_REG;
594                 buf[9] = msg->addr;
595                 buf[10] = 0x00;
596                 buf[11] = USB_END_I2C_CMD;
597                 ret = mxl111sf_i2c_send_data(state, 0, buf);
598
599                 /* check for I2C NACK status */
600                 if (mxl111sf_i2c_check_status(state) == 1) {
601                         mxl_i2c("NACK reading slave address %02x",
602                                 msg->addr);
603
604                         /* if NACK, stop I2C bus and exit */
605                         buf[2] = I2C_CONTROL_REG;
606                         buf[3] = 0xC7;
607                         buf[4] = (HWI2C400) ? 0x03 : 0x0D;
608                         ret = -EIO;
609                         goto exit;
610                 }
611
612                 /* I2C interface can do I2C operations in block of 8 bytes of
613                    I2C data. calculation to figure out number of blocks of
614                    i2c data required to program */
615                 block_len = ((msg->len) / 8);
616                 left_over_len = ((msg->len) % 8);
617                 index = 0;
618
619                 mxl_i2c("block_len %d, left_over_len %d",
620                         block_len, left_over_len);
621
622                 /* command to read data from I2C interface */
623                 buf[0] = USB_READ_I2C_CMD;
624                 buf[1] = 0x00;
625
626                 for (index = 0; index < block_len; index++) {
627                         /* setup I2C read request packet on I2C interface */
628                         for (i = 0; i < 8; i++) {
629                                 buf[2+(i*3)] = I2C_DATA_REG;
630                                 buf[3+(i*3)] = 0x00;
631                                 buf[4+(i*3)] = 0x00;
632                         }
633
634                         ret = mxl111sf_i2c_get_data(state, 0, buf, i2c_r_data);
635
636                         /* check for I2C NACK status */
637                         if (mxl111sf_i2c_check_status(state) == 1) {
638                                 mxl_i2c("NACK reading slave address %02x",
639                                         msg->addr);
640
641                                 /* if NACK, stop I2C bus and exit */
642                                 buf[2] = I2C_CONTROL_REG;
643                                 buf[3] = 0xC7;
644                                 buf[4] = (HWI2C400) ? 0x03 : 0x0D;
645                                 ret = -EIO;
646                                 goto exit;
647                         }
648
649                         /* copy data from i2c data payload to read buffer */
650                         for (i = 0; i < 8; i++) {
651                                 rd_status[i] = i2c_r_data[(i*3)+2];
652
653                                 if (rd_status[i] == 0x04) {
654                                         if (i < 7) {
655                                                 mxl_i2c("i2c fifo empty! @ %d",
656                                                         i);
657                                                 msg->buf[(index*8)+i] =
658                                                         i2c_r_data[(i*3)+1];
659                                                 /* read again */
660                                                 ret_status =
661                                                         mxl111sf_i2c_readagain(
662                                                                 state, 8-(i+1),
663                                                                 readbuff);
664                                                 if (ret_status == 1) {
665                                                         for (k = 0;
666                                                              k < 8-(i+1);
667                                                              k++) {
668
669                                         msg->buf[(index*8)+(k+i+1)] =
670                                                 readbuff[k];
671                                         mxl_i2c("read data: %02x\t %02x",
672                                                 msg->buf[(index*8)+(k+i)],
673                                                 (index*8)+(k+i));
674                                         mxl_i2c("read data: %02x\t %02x",
675                                                 msg->buf[(index*8)+(k+i+1)],
676                                                 readbuff[k]);
677
678                                                         }
679                                                         goto stop_copy;
680                                                 } else {
681                                                         mxl_i2c("readagain ERROR!");
682                                                 }
683                                         } else {
684                                                 msg->buf[(index*8)+i] =
685                                                         i2c_r_data[(i*3)+1];
686                                         }
687                                 } else {
688                                         msg->buf[(index*8)+i] =
689                                                 i2c_r_data[(i*3)+1];
690                                 }
691                         }
692 stop_copy:
693                         ;
694
695                 }
696
697                 if (left_over_len) {
698                         for (k = 0; k < 26; k++)
699                                 buf[k] = USB_END_I2C_CMD;
700
701                         buf[0] = 0xDD;
702                         buf[1] = 0x00;
703
704                         for (i = 0; i < left_over_len; i++) {
705                                 buf[2+(i*3)] = I2C_DATA_REG;
706                                 buf[3+(i*3)] = 0x00;
707                                 buf[4+(i*3)] = 0x00;
708                         }
709                         ret = mxl111sf_i2c_get_data(state, 0, buf,
710                                                     i2c_r_data);
711
712                         /* check for I2C NACK status */
713                         if (mxl111sf_i2c_check_status(state) == 1) {
714                                 mxl_i2c("NACK reading slave address %02x",
715                                         msg->addr);
716
717                                 /* if NACK, stop I2C bus and exit */
718                                 buf[2] = I2C_CONTROL_REG;
719                                 buf[3] = 0xC7;
720                                 buf[4] = (HWI2C400) ? 0x03 : 0x0D;
721                                 ret = -EIO;
722                                 goto exit;
723                         }
724
725                         for (i = 0; i < left_over_len; i++) {
726                                 msg->buf[(block_len*8)+i] =
727                                         i2c_r_data[(i*3)+1];
728                                 mxl_i2c("read data: %02x\t %02x",
729                                         i2c_r_data[(i*3)+1],
730                                         i2c_r_data[(i*3)+2]);
731                         }
732                 }
733
734                 /* indicate I2C interface to issue NACK
735                    after next I2C read op */
736                 buf[0] = USB_WRITE_I2C_CMD;
737                 buf[1] = 0x00;
738
739                 /* control register */
740                 buf[2] = I2C_CONTROL_REG;
741                 buf[3] = 0x17;
742                 buf[4] = (HWI2C400) ? 0x03 : 0x0D;
743
744                 buf[5] = USB_END_I2C_CMD;
745                 ret = mxl111sf_i2c_send_data(state, 0, buf);
746
747                 /* control register */
748                 buf[2] = I2C_CONTROL_REG;
749                 buf[3] = 0xC7;
750                 buf[4] = (HWI2C400) ? 0x03 : 0x0D;
751
752         }
753 exit:
754         /* STOP and disable I2C MUX */
755         buf[0] = USB_WRITE_I2C_CMD;
756         buf[1] = 0x00;
757
758         /* de-initilize I2C BUS */
759         buf[5] = USB_END_I2C_CMD;
760         mxl111sf_i2c_send_data(state, 0, buf);
761
762         /* Control Register */
763         buf[2] = I2C_CONTROL_REG;
764         buf[3] = 0xDF;
765         buf[4] = 0x03;
766
767         /* disable I2C interface */
768         buf[5] = I2C_MUX_REG;
769         buf[6] = 0x00;
770         buf[7] = 0x00;
771
772         /* de-initilize I2C BUS */
773         buf[8] = USB_END_I2C_CMD;
774         mxl111sf_i2c_send_data(state, 0, buf);
775
776         /* disable I2C interface */
777         buf[2] = I2C_MUX_REG;
778         buf[3] = 0x81;
779         buf[4] = 0x00;
780
781         /* disable I2C interface */
782         buf[5] = I2C_MUX_REG;
783         buf[6] = 0x00;
784         buf[7] = 0x00;
785
786         /* disable I2C interface */
787         buf[8] = I2C_MUX_REG;
788         buf[9] = 0x00;
789         buf[10] = 0x00;
790
791         buf[11] = USB_END_I2C_CMD;
792         mxl111sf_i2c_send_data(state, 0, buf);
793
794         return ret;
795 }
796
797 /* ------------------------------------------------------------------------ */
798
799 int mxl111sf_i2c_xfer(struct i2c_adapter *adap,
800                       struct i2c_msg msg[], int num)
801 {
802         struct dvb_usb_device *d = i2c_get_adapdata(adap);
803         struct mxl111sf_state *state = d->priv;
804         int hwi2c = (state->chip_rev > MXL111SF_V6);
805         int i, ret;
806
807         if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
808                 return -EAGAIN;
809
810         for (i = 0; i < num; i++) {
811                 ret = (hwi2c) ?
812                         mxl111sf_i2c_hw_xfer_msg(state, &msg[i]) :
813                         mxl111sf_i2c_sw_xfer_msg(state, &msg[i]);
814                 if (mxl_fail(ret)) {
815                         mxl_debug_adv("failed with error %d on i2c transaction %d of %d, %sing %d bytes to/from 0x%02x",
816                                       ret, i+1, num,
817                                       (msg[i].flags & I2C_M_RD) ?
818                                       "read" : "writ",
819                                       msg[i].len, msg[i].addr);
820
821                         break;
822                 }
823         }
824
825         mutex_unlock(&d->i2c_mutex);
826
827         return i == num ? num : -EREMOTEIO;
828 }