GNU Linux-libre 4.9.337-gnu1
[releases.git] / drivers / media / dvb-frontends / dib9000.c
1 /*
2  * Linux-DVB Driver for DiBcom's DiB9000 and demodulator-family.
3  *
4  * Copyright (C) 2005-10 DiBcom (http://www.dibcom.fr/)
5  *
6  * This program is free software; you can redistribute it and/or
7  *      modify it under the terms of the GNU General Public License as
8  *      published by the Free Software Foundation, version 2.
9  */
10 #include <linux/kernel.h>
11 #include <linux/i2c.h>
12 #include <linux/mutex.h>
13
14 #include "dvb_math.h"
15 #include "dvb_frontend.h"
16
17 #include "dib9000.h"
18 #include "dibx000_common.h"
19
20 static int debug;
21 module_param(debug, int, 0644);
22 MODULE_PARM_DESC(debug, "turn on debugging (default: 0)");
23
24 #define dprintk(args...) do { if (debug) { printk(KERN_DEBUG "DiB9000: "); printk(args); printk("\n"); } } while (0)
25 #define MAX_NUMBER_OF_FRONTENDS 6
26
27 struct i2c_device {
28         struct i2c_adapter *i2c_adap;
29         u8 i2c_addr;
30         u8 *i2c_read_buffer;
31         u8 *i2c_write_buffer;
32 };
33
34 struct dib9000_pid_ctrl {
35 #define DIB9000_PID_FILTER_CTRL 0
36 #define DIB9000_PID_FILTER      1
37         u8 cmd;
38         u8 id;
39         u16 pid;
40         u8 onoff;
41 };
42
43 struct dib9000_state {
44         struct i2c_device i2c;
45
46         struct dibx000_i2c_master i2c_master;
47         struct i2c_adapter tuner_adap;
48         struct i2c_adapter component_bus;
49
50         u16 revision;
51         u8 reg_offs;
52
53         enum frontend_tune_state tune_state;
54         u32 status;
55         struct dvb_frontend_parametersContext channel_status;
56
57         u8 fe_id;
58
59 #define DIB9000_GPIO_DEFAULT_DIRECTIONS 0xffff
60         u16 gpio_dir;
61 #define DIB9000_GPIO_DEFAULT_VALUES     0x0000
62         u16 gpio_val;
63 #define DIB9000_GPIO_DEFAULT_PWM_POS    0xffff
64         u16 gpio_pwm_pos;
65
66         union {                 /* common for all chips */
67                 struct {
68                         u8 mobile_mode:1;
69                 } host;
70
71                 struct {
72                         struct dib9000_fe_memory_map {
73                                 u16 addr;
74                                 u16 size;
75                         } fe_mm[18];
76                         u8 memcmd;
77
78                         struct mutex mbx_if_lock;       /* to protect read/write operations */
79                         struct mutex mbx_lock;  /* to protect the whole mailbox handling */
80
81                         struct mutex mem_lock;  /* to protect the memory accesses */
82                         struct mutex mem_mbx_lock;      /* to protect the memory-based mailbox */
83
84 #define MBX_MAX_WORDS (256 - 200 - 2)
85 #define DIB9000_MSG_CACHE_SIZE 2
86                         u16 message_cache[DIB9000_MSG_CACHE_SIZE][MBX_MAX_WORDS];
87                         u8 fw_is_running;
88                 } risc;
89         } platform;
90
91         union {                 /* common for all platforms */
92                 struct {
93                         struct dib9000_config cfg;
94                 } d9;
95         } chip;
96
97         struct dvb_frontend *fe[MAX_NUMBER_OF_FRONTENDS];
98         u16 component_bus_speed;
99
100         /* for the I2C transfer */
101         struct i2c_msg msg[2];
102         u8 i2c_write_buffer[255];
103         u8 i2c_read_buffer[255];
104         struct mutex demod_lock;
105         u8 get_frontend_internal;
106         struct dib9000_pid_ctrl pid_ctrl[10];
107         s8 pid_ctrl_index; /* -1: empty list; -2: do not use the list */
108 };
109
110 static const u32 fe_info[44] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
111         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
112         0, 0, 0, 0, 0, 0, 0, 0
113 };
114
115 enum dib9000_power_mode {
116         DIB9000_POWER_ALL = 0,
117
118         DIB9000_POWER_NO,
119         DIB9000_POWER_INTERF_ANALOG_AGC,
120         DIB9000_POWER_COR4_DINTLV_ICIRM_EQUAL_CFROD,
121         DIB9000_POWER_COR4_CRY_ESRAM_MOUT_NUD,
122         DIB9000_POWER_INTERFACE_ONLY,
123 };
124
125 enum dib9000_out_messages {
126         OUT_MSG_HBM_ACK,
127         OUT_MSG_HOST_BUF_FAIL,
128         OUT_MSG_REQ_VERSION,
129         OUT_MSG_BRIDGE_I2C_W,
130         OUT_MSG_BRIDGE_I2C_R,
131         OUT_MSG_BRIDGE_APB_W,
132         OUT_MSG_BRIDGE_APB_R,
133         OUT_MSG_SCAN_CHANNEL,
134         OUT_MSG_MONIT_DEMOD,
135         OUT_MSG_CONF_GPIO,
136         OUT_MSG_DEBUG_HELP,
137         OUT_MSG_SUBBAND_SEL,
138         OUT_MSG_ENABLE_TIME_SLICE,
139         OUT_MSG_FE_FW_DL,
140         OUT_MSG_FE_CHANNEL_SEARCH,
141         OUT_MSG_FE_CHANNEL_TUNE,
142         OUT_MSG_FE_SLEEP,
143         OUT_MSG_FE_SYNC,
144         OUT_MSG_CTL_MONIT,
145
146         OUT_MSG_CONF_SVC,
147         OUT_MSG_SET_HBM,
148         OUT_MSG_INIT_DEMOD,
149         OUT_MSG_ENABLE_DIVERSITY,
150         OUT_MSG_SET_OUTPUT_MODE,
151         OUT_MSG_SET_PRIORITARY_CHANNEL,
152         OUT_MSG_ACK_FRG,
153         OUT_MSG_INIT_PMU,
154 };
155
156 enum dib9000_in_messages {
157         IN_MSG_DATA,
158         IN_MSG_FRAME_INFO,
159         IN_MSG_CTL_MONIT,
160         IN_MSG_ACK_FREE_ITEM,
161         IN_MSG_DEBUG_BUF,
162         IN_MSG_MPE_MONITOR,
163         IN_MSG_RAWTS_MONITOR,
164         IN_MSG_END_BRIDGE_I2C_RW,
165         IN_MSG_END_BRIDGE_APB_RW,
166         IN_MSG_VERSION,
167         IN_MSG_END_OF_SCAN,
168         IN_MSG_MONIT_DEMOD,
169         IN_MSG_ERROR,
170         IN_MSG_FE_FW_DL_DONE,
171         IN_MSG_EVENT,
172         IN_MSG_ACK_CHANGE_SVC,
173         IN_MSG_HBM_PROF,
174 };
175
176 /* memory_access requests */
177 #define FE_MM_W_CHANNEL                   0
178 #define FE_MM_W_FE_INFO                   1
179 #define FE_MM_RW_SYNC                     2
180
181 #define FE_SYNC_CHANNEL          1
182 #define FE_SYNC_W_GENERIC_MONIT  2
183 #define FE_SYNC_COMPONENT_ACCESS 3
184
185 #define FE_MM_R_CHANNEL_SEARCH_STATE      3
186 #define FE_MM_R_CHANNEL_UNION_CONTEXT     4
187 #define FE_MM_R_FE_INFO                   5
188 #define FE_MM_R_FE_MONITOR                6
189
190 #define FE_MM_W_CHANNEL_HEAD              7
191 #define FE_MM_W_CHANNEL_UNION             8
192 #define FE_MM_W_CHANNEL_CONTEXT           9
193 #define FE_MM_R_CHANNEL_UNION            10
194 #define FE_MM_R_CHANNEL_CONTEXT          11
195 #define FE_MM_R_CHANNEL_TUNE_STATE       12
196
197 #define FE_MM_R_GENERIC_MONITORING_SIZE  13
198 #define FE_MM_W_GENERIC_MONITORING           14
199 #define FE_MM_R_GENERIC_MONITORING           15
200
201 #define FE_MM_W_COMPONENT_ACCESS         16
202 #define FE_MM_RW_COMPONENT_ACCESS_BUFFER 17
203 static int dib9000_risc_apb_access_read(struct dib9000_state *state, u32 address, u16 attribute, const u8 * tx, u32 txlen, u8 * b, u32 len);
204 static int dib9000_risc_apb_access_write(struct dib9000_state *state, u32 address, u16 attribute, const u8 * b, u32 len);
205
206 static u16 to_fw_output_mode(u16 mode)
207 {
208         switch (mode) {
209         case OUTMODE_HIGH_Z:
210                 return 0;
211         case OUTMODE_MPEG2_PAR_GATED_CLK:
212                 return 4;
213         case OUTMODE_MPEG2_PAR_CONT_CLK:
214                 return 8;
215         case OUTMODE_MPEG2_SERIAL:
216                 return 16;
217         case OUTMODE_DIVERSITY:
218                 return 128;
219         case OUTMODE_MPEG2_FIFO:
220                 return 2;
221         case OUTMODE_ANALOG_ADC:
222                 return 1;
223         default:
224                 return 0;
225         }
226 }
227
228 static int dib9000_read16_attr(struct dib9000_state *state, u16 reg, u8 *b, u32 len, u16 attribute)
229 {
230         u32 chunk_size = 126;
231         u32 l;
232         int ret;
233
234         if (state->platform.risc.fw_is_running && (reg < 1024))
235                 return dib9000_risc_apb_access_read(state, reg, attribute, NULL, 0, b, len);
236
237         memset(state->msg, 0, 2 * sizeof(struct i2c_msg));
238         state->msg[0].addr = state->i2c.i2c_addr >> 1;
239         state->msg[0].flags = 0;
240         state->msg[0].buf = state->i2c_write_buffer;
241         state->msg[0].len = 2;
242         state->msg[1].addr = state->i2c.i2c_addr >> 1;
243         state->msg[1].flags = I2C_M_RD;
244         state->msg[1].buf = b;
245         state->msg[1].len = len;
246
247         state->i2c_write_buffer[0] = reg >> 8;
248         state->i2c_write_buffer[1] = reg & 0xff;
249
250         if (attribute & DATA_BUS_ACCESS_MODE_8BIT)
251                 state->i2c_write_buffer[0] |= (1 << 5);
252         if (attribute & DATA_BUS_ACCESS_MODE_NO_ADDRESS_INCREMENT)
253                 state->i2c_write_buffer[0] |= (1 << 4);
254
255         do {
256                 l = len < chunk_size ? len : chunk_size;
257                 state->msg[1].len = l;
258                 state->msg[1].buf = b;
259                 ret = i2c_transfer(state->i2c.i2c_adap, state->msg, 2) != 2 ? -EREMOTEIO : 0;
260                 if (ret != 0) {
261                         dprintk("i2c read error on %d", reg);
262                         return -EREMOTEIO;
263                 }
264
265                 b += l;
266                 len -= l;
267
268                 if (!(attribute & DATA_BUS_ACCESS_MODE_NO_ADDRESS_INCREMENT))
269                         reg += l / 2;
270         } while ((ret == 0) && len);
271
272         return 0;
273 }
274
275 static u16 dib9000_i2c_read16(struct i2c_device *i2c, u16 reg)
276 {
277         struct i2c_msg msg[2] = {
278                 {.addr = i2c->i2c_addr >> 1, .flags = 0,
279                         .buf = i2c->i2c_write_buffer, .len = 2},
280                 {.addr = i2c->i2c_addr >> 1, .flags = I2C_M_RD,
281                         .buf = i2c->i2c_read_buffer, .len = 2},
282         };
283
284         i2c->i2c_write_buffer[0] = reg >> 8;
285         i2c->i2c_write_buffer[1] = reg & 0xff;
286
287         if (i2c_transfer(i2c->i2c_adap, msg, 2) != 2) {
288                 dprintk("read register %x error", reg);
289                 return 0;
290         }
291
292         return (i2c->i2c_read_buffer[0] << 8) | i2c->i2c_read_buffer[1];
293 }
294
295 static inline u16 dib9000_read_word(struct dib9000_state *state, u16 reg)
296 {
297         if (dib9000_read16_attr(state, reg, state->i2c_read_buffer, 2, 0) != 0)
298                 return 0;
299         return (state->i2c_read_buffer[0] << 8) | state->i2c_read_buffer[1];
300 }
301
302 static inline u16 dib9000_read_word_attr(struct dib9000_state *state, u16 reg, u16 attribute)
303 {
304         if (dib9000_read16_attr(state, reg, state->i2c_read_buffer, 2,
305                                 attribute) != 0)
306                 return 0;
307         return (state->i2c_read_buffer[0] << 8) | state->i2c_read_buffer[1];
308 }
309
310 #define dib9000_read16_noinc_attr(state, reg, b, len, attribute) dib9000_read16_attr(state, reg, b, len, (attribute) | DATA_BUS_ACCESS_MODE_NO_ADDRESS_INCREMENT)
311
312 static int dib9000_write16_attr(struct dib9000_state *state, u16 reg, const u8 *buf, u32 len, u16 attribute)
313 {
314         u32 chunk_size = 126;
315         u32 l;
316         int ret;
317
318         if (state->platform.risc.fw_is_running && (reg < 1024)) {
319                 if (dib9000_risc_apb_access_write
320                     (state, reg, DATA_BUS_ACCESS_MODE_16BIT | DATA_BUS_ACCESS_MODE_NO_ADDRESS_INCREMENT | attribute, buf, len) != 0)
321                         return -EINVAL;
322                 return 0;
323         }
324
325         memset(&state->msg[0], 0, sizeof(struct i2c_msg));
326         state->msg[0].addr = state->i2c.i2c_addr >> 1;
327         state->msg[0].flags = 0;
328         state->msg[0].buf = state->i2c_write_buffer;
329         state->msg[0].len = len + 2;
330
331         state->i2c_write_buffer[0] = (reg >> 8) & 0xff;
332         state->i2c_write_buffer[1] = (reg) & 0xff;
333
334         if (attribute & DATA_BUS_ACCESS_MODE_8BIT)
335                 state->i2c_write_buffer[0] |= (1 << 5);
336         if (attribute & DATA_BUS_ACCESS_MODE_NO_ADDRESS_INCREMENT)
337                 state->i2c_write_buffer[0] |= (1 << 4);
338
339         do {
340                 l = len < chunk_size ? len : chunk_size;
341                 state->msg[0].len = l + 2;
342                 memcpy(&state->i2c_write_buffer[2], buf, l);
343
344                 ret = i2c_transfer(state->i2c.i2c_adap, state->msg, 1) != 1 ? -EREMOTEIO : 0;
345
346                 buf += l;
347                 len -= l;
348
349                 if (!(attribute & DATA_BUS_ACCESS_MODE_NO_ADDRESS_INCREMENT))
350                         reg += l / 2;
351         } while ((ret == 0) && len);
352
353         return ret;
354 }
355
356 static int dib9000_i2c_write16(struct i2c_device *i2c, u16 reg, u16 val)
357 {
358         struct i2c_msg msg = {
359                 .addr = i2c->i2c_addr >> 1, .flags = 0,
360                 .buf = i2c->i2c_write_buffer, .len = 4
361         };
362
363         i2c->i2c_write_buffer[0] = (reg >> 8) & 0xff;
364         i2c->i2c_write_buffer[1] = reg & 0xff;
365         i2c->i2c_write_buffer[2] = (val >> 8) & 0xff;
366         i2c->i2c_write_buffer[3] = val & 0xff;
367
368         return i2c_transfer(i2c->i2c_adap, &msg, 1) != 1 ? -EREMOTEIO : 0;
369 }
370
371 static inline int dib9000_write_word(struct dib9000_state *state, u16 reg, u16 val)
372 {
373         u8 b[2] = { val >> 8, val & 0xff };
374         return dib9000_write16_attr(state, reg, b, 2, 0);
375 }
376
377 static inline int dib9000_write_word_attr(struct dib9000_state *state, u16 reg, u16 val, u16 attribute)
378 {
379         u8 b[2] = { val >> 8, val & 0xff };
380         return dib9000_write16_attr(state, reg, b, 2, attribute);
381 }
382
383 #define dib9000_write(state, reg, buf, len) dib9000_write16_attr(state, reg, buf, len, 0)
384 #define dib9000_write16_noinc(state, reg, buf, len) dib9000_write16_attr(state, reg, buf, len, DATA_BUS_ACCESS_MODE_NO_ADDRESS_INCREMENT)
385 #define dib9000_write16_noinc_attr(state, reg, buf, len, attribute) dib9000_write16_attr(state, reg, buf, len, DATA_BUS_ACCESS_MODE_NO_ADDRESS_INCREMENT | (attribute))
386
387 #define dib9000_mbx_send(state, id, data, len) dib9000_mbx_send_attr(state, id, data, len, 0)
388 #define dib9000_mbx_get_message(state, id, msg, len) dib9000_mbx_get_message_attr(state, id, msg, len, 0)
389
390 #define MAC_IRQ      (1 << 1)
391 #define IRQ_POL_MSK  (1 << 4)
392
393 #define dib9000_risc_mem_read_chunks(state, b, len) dib9000_read16_attr(state, 1063, b, len, DATA_BUS_ACCESS_MODE_8BIT | DATA_BUS_ACCESS_MODE_NO_ADDRESS_INCREMENT)
394 #define dib9000_risc_mem_write_chunks(state, buf, len) dib9000_write16_attr(state, 1063, buf, len, DATA_BUS_ACCESS_MODE_8BIT | DATA_BUS_ACCESS_MODE_NO_ADDRESS_INCREMENT)
395
396 static void dib9000_risc_mem_setup_cmd(struct dib9000_state *state, u32 addr, u32 len, u8 reading)
397 {
398         u8 b[14] = { 0 };
399
400 /*      dprintk("%d memcmd: %d %d %d\n", state->fe_id, addr, addr+len, len); */
401 /*      b[0] = 0 << 7; */
402         b[1] = 1;
403
404 /*      b[2] = 0; */
405 /*      b[3] = 0; */
406         b[4] = (u8) (addr >> 8);
407         b[5] = (u8) (addr & 0xff);
408
409 /*      b[10] = 0; */
410 /*      b[11] = 0; */
411         b[12] = (u8) (addr >> 8);
412         b[13] = (u8) (addr & 0xff);
413
414         addr += len;
415 /*      b[6] = 0; */
416 /*      b[7] = 0; */
417         b[8] = (u8) (addr >> 8);
418         b[9] = (u8) (addr & 0xff);
419
420         dib9000_write(state, 1056, b, 14);
421         if (reading)
422                 dib9000_write_word(state, 1056, (1 << 15) | 1);
423         state->platform.risc.memcmd = -1;       /* if it was called directly reset it - to force a future setup-call to set it */
424 }
425
426 static void dib9000_risc_mem_setup(struct dib9000_state *state, u8 cmd)
427 {
428         struct dib9000_fe_memory_map *m = &state->platform.risc.fe_mm[cmd & 0x7f];
429         /* decide whether we need to "refresh" the memory controller */
430         if (state->platform.risc.memcmd == cmd &&       /* same command */
431             !(cmd & 0x80 && m->size < 67))      /* and we do not want to read something with less than 67 bytes looping - working around a bug in the memory controller */
432                 return;
433         dib9000_risc_mem_setup_cmd(state, m->addr, m->size, cmd & 0x80);
434         state->platform.risc.memcmd = cmd;
435 }
436
437 static int dib9000_risc_mem_read(struct dib9000_state *state, u8 cmd, u8 * b, u16 len)
438 {
439         if (!state->platform.risc.fw_is_running)
440                 return -EIO;
441
442         if (mutex_lock_interruptible(&state->platform.risc.mem_lock) < 0) {
443                 dprintk("could not get the lock");
444                 return -EINTR;
445         }
446         dib9000_risc_mem_setup(state, cmd | 0x80);
447         dib9000_risc_mem_read_chunks(state, b, len);
448         mutex_unlock(&state->platform.risc.mem_lock);
449         return 0;
450 }
451
452 static int dib9000_risc_mem_write(struct dib9000_state *state, u8 cmd, const u8 * b)
453 {
454         struct dib9000_fe_memory_map *m = &state->platform.risc.fe_mm[cmd];
455         if (!state->platform.risc.fw_is_running)
456                 return -EIO;
457
458         if (mutex_lock_interruptible(&state->platform.risc.mem_lock) < 0) {
459                 dprintk("could not get the lock");
460                 return -EINTR;
461         }
462         dib9000_risc_mem_setup(state, cmd);
463         dib9000_risc_mem_write_chunks(state, b, m->size);
464         mutex_unlock(&state->platform.risc.mem_lock);
465         return 0;
466 }
467
468 static int dib9000_firmware_download(struct dib9000_state *state, u8 risc_id, u16 key, const u8 * code, u32 len)
469 {
470         u16 offs;
471
472         if (risc_id == 1)
473                 offs = 16;
474         else
475                 offs = 0;
476
477         /* config crtl reg */
478         dib9000_write_word(state, 1024 + offs, 0x000f);
479         dib9000_write_word(state, 1025 + offs, 0);
480         dib9000_write_word(state, 1031 + offs, key);
481
482         dprintk("going to download %dB of microcode", len);
483         if (dib9000_write16_noinc(state, 1026 + offs, (u8 *) code, (u16) len) != 0) {
484                 dprintk("error while downloading microcode for RISC %c", 'A' + risc_id);
485                 return -EIO;
486         }
487
488         dprintk("Microcode for RISC %c loaded", 'A' + risc_id);
489
490         return 0;
491 }
492
493 static int dib9000_mbx_host_init(struct dib9000_state *state, u8 risc_id)
494 {
495         u16 mbox_offs;
496         u16 reset_reg;
497         u16 tries = 1000;
498
499         if (risc_id == 1)
500                 mbox_offs = 16;
501         else
502                 mbox_offs = 0;
503
504         /* Reset mailbox  */
505         dib9000_write_word(state, 1027 + mbox_offs, 0x8000);
506
507         /* Read reset status */
508         do {
509                 reset_reg = dib9000_read_word(state, 1027 + mbox_offs);
510                 msleep(100);
511         } while ((reset_reg & 0x8000) && --tries);
512
513         if (reset_reg & 0x8000) {
514                 dprintk("MBX: init ERROR, no response from RISC %c", 'A' + risc_id);
515                 return -EIO;
516         }
517         dprintk("MBX: initialized");
518         return 0;
519 }
520
521 #define MAX_MAILBOX_TRY 100
522 static int dib9000_mbx_send_attr(struct dib9000_state *state, u8 id, u16 * data, u8 len, u16 attr)
523 {
524         u8 *d, b[2];
525         u16 tmp;
526         u16 size;
527         u32 i;
528         int ret = 0;
529
530         if (!state->platform.risc.fw_is_running)
531                 return -EINVAL;
532
533         if (mutex_lock_interruptible(&state->platform.risc.mbx_if_lock) < 0) {
534                 dprintk("could not get the lock");
535                 return -EINTR;
536         }
537         tmp = MAX_MAILBOX_TRY;
538         do {
539                 size = dib9000_read_word_attr(state, 1043, attr) & 0xff;
540                 if ((size + len + 1) > MBX_MAX_WORDS && --tmp) {
541                         dprintk("MBX: RISC mbx full, retrying");
542                         msleep(100);
543                 } else
544                         break;
545         } while (1);
546
547         /*dprintk( "MBX: size: %d", size); */
548
549         if (tmp == 0) {
550                 ret = -EINVAL;
551                 goto out;
552         }
553 #ifdef DUMP_MSG
554         dprintk("--> %02x %d ", id, len + 1);
555         for (i = 0; i < len; i++)
556                 dprintk("%04x ", data[i]);
557         dprintk("\n");
558 #endif
559
560         /* byte-order conversion - works on big (where it is not necessary) or little endian */
561         d = (u8 *) data;
562         for (i = 0; i < len; i++) {
563                 tmp = data[i];
564                 *d++ = tmp >> 8;
565                 *d++ = tmp & 0xff;
566         }
567
568         /* write msg */
569         b[0] = id;
570         b[1] = len + 1;
571         if (dib9000_write16_noinc_attr(state, 1045, b, 2, attr) != 0 || dib9000_write16_noinc_attr(state, 1045, (u8 *) data, len * 2, attr) != 0) {
572                 ret = -EIO;
573                 goto out;
574         }
575
576         /* update register nb_mes_in_RX */
577         ret = (u8) dib9000_write_word_attr(state, 1043, 1 << 14, attr);
578
579 out:
580         mutex_unlock(&state->platform.risc.mbx_if_lock);
581
582         return ret;
583 }
584
585 static u8 dib9000_mbx_read(struct dib9000_state *state, u16 * data, u8 risc_id, u16 attr)
586 {
587 #ifdef DUMP_MSG
588         u16 *d = data;
589 #endif
590
591         u16 tmp, i;
592         u8 size;
593         u8 mc_base;
594
595         if (!state->platform.risc.fw_is_running)
596                 return 0;
597
598         if (mutex_lock_interruptible(&state->platform.risc.mbx_if_lock) < 0) {
599                 dprintk("could not get the lock");
600                 return 0;
601         }
602         if (risc_id == 1)
603                 mc_base = 16;
604         else
605                 mc_base = 0;
606
607         /* Length and type in the first word */
608         *data = dib9000_read_word_attr(state, 1029 + mc_base, attr);
609
610         size = *data & 0xff;
611         if (size <= MBX_MAX_WORDS) {
612                 data++;
613                 size--;         /* Initial word already read */
614
615                 dib9000_read16_noinc_attr(state, 1029 + mc_base, (u8 *) data, size * 2, attr);
616
617                 /* to word conversion */
618                 for (i = 0; i < size; i++) {
619                         tmp = *data;
620                         *data = (tmp >> 8) | (tmp << 8);
621                         data++;
622                 }
623
624 #ifdef DUMP_MSG
625                 dprintk("<-- ");
626                 for (i = 0; i < size + 1; i++)
627                         dprintk("%04x ", d[i]);
628                 dprintk("\n");
629 #endif
630         } else {
631                 dprintk("MBX: message is too big for message cache (%d), flushing message", size);
632                 size--;         /* Initial word already read */
633                 while (size--)
634                         dib9000_read16_noinc_attr(state, 1029 + mc_base, (u8 *) data, 2, attr);
635         }
636         /* Update register nb_mes_in_TX */
637         dib9000_write_word_attr(state, 1028 + mc_base, 1 << 14, attr);
638
639         mutex_unlock(&state->platform.risc.mbx_if_lock);
640
641         return size + 1;
642 }
643
644 static int dib9000_risc_debug_buf(struct dib9000_state *state, u16 * data, u8 size)
645 {
646         u32 ts = data[1] << 16 | data[0];
647         char *b = (char *)&data[2];
648
649         b[2 * (size - 2) - 1] = '\0';   /* Bullet proof the buffer */
650         if (*b == '~') {
651                 b++;
652                 dprintk("%s", b);
653         } else
654                 dprintk("RISC%d: %d.%04d %s", state->fe_id, ts / 10000, ts % 10000, *b ? b : "<empty>");
655         return 1;
656 }
657
658 static int dib9000_mbx_fetch_to_cache(struct dib9000_state *state, u16 attr)
659 {
660         int i;
661         u8 size;
662         u16 *block;
663         /* find a free slot */
664         for (i = 0; i < DIB9000_MSG_CACHE_SIZE; i++) {
665                 block = state->platform.risc.message_cache[i];
666                 if (*block == 0) {
667                         size = dib9000_mbx_read(state, block, 1, attr);
668
669 /*                      dprintk( "MBX: fetched %04x message to cache", *block); */
670
671                         switch (*block >> 8) {
672                         case IN_MSG_DEBUG_BUF:
673                                 dib9000_risc_debug_buf(state, block + 1, size); /* debug-messages are going to be printed right away */
674                                 *block = 0;     /* free the block */
675                                 break;
676 #if 0
677                         case IN_MSG_DATA:       /* FE-TRACE */
678                                 dib9000_risc_data_process(state, block + 1, size);
679                                 *block = 0;
680                                 break;
681 #endif
682                         default:
683                                 break;
684                         }
685
686                         return 1;
687                 }
688         }
689         dprintk("MBX: no free cache-slot found for new message...");
690         return -1;
691 }
692
693 static u8 dib9000_mbx_count(struct dib9000_state *state, u8 risc_id, u16 attr)
694 {
695         if (risc_id == 0)
696                 return (u8) (dib9000_read_word_attr(state, 1028, attr) >> 10) & 0x1f;   /* 5 bit field */
697         else
698                 return (u8) (dib9000_read_word_attr(state, 1044, attr) >> 8) & 0x7f;    /* 7 bit field */
699 }
700
701 static int dib9000_mbx_process(struct dib9000_state *state, u16 attr)
702 {
703         int ret = 0;
704
705         if (!state->platform.risc.fw_is_running)
706                 return -1;
707
708         if (mutex_lock_interruptible(&state->platform.risc.mbx_lock) < 0) {
709                 dprintk("could not get the lock");
710                 return -1;
711         }
712
713         if (dib9000_mbx_count(state, 1, attr))  /* 1=RiscB */
714                 ret = dib9000_mbx_fetch_to_cache(state, attr);
715
716         dib9000_read_word_attr(state, 1229, attr);      /* Clear the IRQ */
717 /*      if (tmp) */
718 /*              dprintk( "cleared IRQ: %x", tmp); */
719         mutex_unlock(&state->platform.risc.mbx_lock);
720
721         return ret;
722 }
723
724 static int dib9000_mbx_get_message_attr(struct dib9000_state *state, u16 id, u16 * msg, u8 * size, u16 attr)
725 {
726         u8 i;
727         u16 *block;
728         u16 timeout = 30;
729
730         *msg = 0;
731         do {
732                 /* dib9000_mbx_get_from_cache(); */
733                 for (i = 0; i < DIB9000_MSG_CACHE_SIZE; i++) {
734                         block = state->platform.risc.message_cache[i];
735                         if ((*block >> 8) == id) {
736                                 *size = (*block & 0xff) - 1;
737                                 memcpy(msg, block + 1, (*size) * 2);
738                                 *block = 0;     /* free the block */
739                                 i = 0;  /* signal that we found a message */
740                                 break;
741                         }
742                 }
743
744                 if (i == 0)
745                         break;
746
747                 if (dib9000_mbx_process(state, attr) == -1)     /* try to fetch one message - if any */
748                         return -1;
749
750         } while (--timeout);
751
752         if (timeout == 0) {
753                 dprintk("waiting for message %d timed out", id);
754                 return -1;
755         }
756
757         return i == 0;
758 }
759
760 static int dib9000_risc_check_version(struct dib9000_state *state)
761 {
762         u8 r[4];
763         u8 size;
764         u16 fw_version = 0;
765
766         if (dib9000_mbx_send(state, OUT_MSG_REQ_VERSION, &fw_version, 1) != 0)
767                 return -EIO;
768
769         if (dib9000_mbx_get_message(state, IN_MSG_VERSION, (u16 *) r, &size) < 0)
770                 return -EIO;
771
772         fw_version = (r[0] << 8) | r[1];
773         dprintk("RISC: ver: %d.%02d (IC: %d)", fw_version >> 10, fw_version & 0x3ff, (r[2] << 8) | r[3]);
774
775         if ((fw_version >> 10) != 7)
776                 return -EINVAL;
777
778         switch (fw_version & 0x3ff) {
779         case 11:
780         case 12:
781         case 14:
782         case 15:
783         case 16:
784         case 17:
785                 break;
786         default:
787                 dprintk("RISC: invalid firmware version");
788                 return -EINVAL;
789         }
790
791         dprintk("RISC: valid firmware version");
792         return 0;
793 }
794
795 static int dib9000_fw_boot(struct dib9000_state *state, const u8 * codeA, u32 lenA, const u8 * codeB, u32 lenB)
796 {
797         /* Reconfig pool mac ram */
798         dib9000_write_word(state, 1225, 0x02);  /* A: 8k C, 4 k D - B: 32k C 6 k D - IRAM 96k */
799         dib9000_write_word(state, 1226, 0x05);
800
801         /* Toggles IP crypto to Host APB interface. */
802         dib9000_write_word(state, 1542, 1);
803
804         /* Set jump and no jump in the dma box */
805         dib9000_write_word(state, 1074, 0);
806         dib9000_write_word(state, 1075, 0);
807
808         /* Set MAC as APB Master. */
809         dib9000_write_word(state, 1237, 0);
810
811         /* Reset the RISCs */
812         if (codeA != NULL)
813                 dib9000_write_word(state, 1024, 2);
814         else
815                 dib9000_write_word(state, 1024, 15);
816         if (codeB != NULL)
817                 dib9000_write_word(state, 1040, 2);
818
819         if (codeA != NULL)
820                 dib9000_firmware_download(state, 0, 0x1234, codeA, lenA);
821         if (codeB != NULL)
822                 dib9000_firmware_download(state, 1, 0x1234, codeB, lenB);
823
824         /* Run the RISCs */
825         if (codeA != NULL)
826                 dib9000_write_word(state, 1024, 0);
827         if (codeB != NULL)
828                 dib9000_write_word(state, 1040, 0);
829
830         if (codeA != NULL)
831                 if (dib9000_mbx_host_init(state, 0) != 0)
832                         return -EIO;
833         if (codeB != NULL)
834                 if (dib9000_mbx_host_init(state, 1) != 0)
835                         return -EIO;
836
837         msleep(100);
838         state->platform.risc.fw_is_running = 1;
839
840         if (dib9000_risc_check_version(state) != 0)
841                 return -EINVAL;
842
843         state->platform.risc.memcmd = 0xff;
844         return 0;
845 }
846
847 static u16 dib9000_identify(struct i2c_device *client)
848 {
849         u16 value;
850
851         value = dib9000_i2c_read16(client, 896);
852         if (value != 0x01b3) {
853                 dprintk("wrong Vendor ID (0x%x)", value);
854                 return 0;
855         }
856
857         value = dib9000_i2c_read16(client, 897);
858         if (value != 0x4000 && value != 0x4001 && value != 0x4002 && value != 0x4003 && value != 0x4004 && value != 0x4005) {
859                 dprintk("wrong Device ID (0x%x)", value);
860                 return 0;
861         }
862
863         /* protect this driver to be used with 7000PC */
864         if (value == 0x4000 && dib9000_i2c_read16(client, 769) == 0x4000) {
865                 dprintk("this driver does not work with DiB7000PC");
866                 return 0;
867         }
868
869         switch (value) {
870         case 0x4000:
871                 dprintk("found DiB7000MA/PA/MB/PB");
872                 break;
873         case 0x4001:
874                 dprintk("found DiB7000HC");
875                 break;
876         case 0x4002:
877                 dprintk("found DiB7000MC");
878                 break;
879         case 0x4003:
880                 dprintk("found DiB9000A");
881                 break;
882         case 0x4004:
883                 dprintk("found DiB9000H");
884                 break;
885         case 0x4005:
886                 dprintk("found DiB9000M");
887                 break;
888         }
889
890         return value;
891 }
892
893 static void dib9000_set_power_mode(struct dib9000_state *state, enum dib9000_power_mode mode)
894 {
895         /* by default everything is going to be powered off */
896         u16 reg_903 = 0x3fff, reg_904 = 0xffff, reg_905 = 0xffff, reg_906;
897         u8 offset;
898
899         if (state->revision == 0x4003 || state->revision == 0x4004 || state->revision == 0x4005)
900                 offset = 1;
901         else
902                 offset = 0;
903
904         reg_906 = dib9000_read_word(state, 906 + offset) | 0x3; /* keep settings for RISC */
905
906         /* now, depending on the requested mode, we power on */
907         switch (mode) {
908                 /* power up everything in the demod */
909         case DIB9000_POWER_ALL:
910                 reg_903 = 0x0000;
911                 reg_904 = 0x0000;
912                 reg_905 = 0x0000;
913                 reg_906 = 0x0000;
914                 break;
915
916                 /* just leave power on the control-interfaces: GPIO and (I2C or SDIO or SRAM) */
917         case DIB9000_POWER_INTERFACE_ONLY:      /* TODO power up either SDIO or I2C or SRAM */
918                 reg_905 &= ~((1 << 7) | (1 << 6) | (1 << 5) | (1 << 2));
919                 break;
920
921         case DIB9000_POWER_INTERF_ANALOG_AGC:
922                 reg_903 &= ~((1 << 15) | (1 << 14) | (1 << 11) | (1 << 10));
923                 reg_905 &= ~((1 << 7) | (1 << 6) | (1 << 5) | (1 << 4) | (1 << 2));
924                 reg_906 &= ~((1 << 0));
925                 break;
926
927         case DIB9000_POWER_COR4_DINTLV_ICIRM_EQUAL_CFROD:
928                 reg_903 = 0x0000;
929                 reg_904 = 0x801f;
930                 reg_905 = 0x0000;
931                 reg_906 &= ~((1 << 0));
932                 break;
933
934         case DIB9000_POWER_COR4_CRY_ESRAM_MOUT_NUD:
935                 reg_903 = 0x0000;
936                 reg_904 = 0x8000;
937                 reg_905 = 0x010b;
938                 reg_906 &= ~((1 << 0));
939                 break;
940         default:
941         case DIB9000_POWER_NO:
942                 break;
943         }
944
945         /* always power down unused parts */
946         if (!state->platform.host.mobile_mode)
947                 reg_904 |= (1 << 7) | (1 << 6) | (1 << 4) | (1 << 2) | (1 << 1);
948
949         /* P_sdio_select_clk = 0 on MC and after */
950         if (state->revision != 0x4000)
951                 reg_906 <<= 1;
952
953         dib9000_write_word(state, 903 + offset, reg_903);
954         dib9000_write_word(state, 904 + offset, reg_904);
955         dib9000_write_word(state, 905 + offset, reg_905);
956         dib9000_write_word(state, 906 + offset, reg_906);
957 }
958
959 static int dib9000_fw_reset(struct dvb_frontend *fe)
960 {
961         struct dib9000_state *state = fe->demodulator_priv;
962
963         dib9000_write_word(state, 1817, 0x0003);
964
965         dib9000_write_word(state, 1227, 1);
966         dib9000_write_word(state, 1227, 0);
967
968         switch ((state->revision = dib9000_identify(&state->i2c))) {
969         case 0x4003:
970         case 0x4004:
971         case 0x4005:
972                 state->reg_offs = 1;
973                 break;
974         default:
975                 return -EINVAL;
976         }
977
978         /* reset the i2c-master to use the host interface */
979         dibx000_reset_i2c_master(&state->i2c_master);
980
981         dib9000_set_power_mode(state, DIB9000_POWER_ALL);
982
983         /* unforce divstr regardless whether i2c enumeration was done or not */
984         dib9000_write_word(state, 1794, dib9000_read_word(state, 1794) & ~(1 << 1));
985         dib9000_write_word(state, 1796, 0);
986         dib9000_write_word(state, 1805, 0x805);
987
988         /* restart all parts */
989         dib9000_write_word(state, 898, 0xffff);
990         dib9000_write_word(state, 899, 0xffff);
991         dib9000_write_word(state, 900, 0x0001);
992         dib9000_write_word(state, 901, 0xff19);
993         dib9000_write_word(state, 902, 0x003c);
994
995         dib9000_write_word(state, 898, 0);
996         dib9000_write_word(state, 899, 0);
997         dib9000_write_word(state, 900, 0);
998         dib9000_write_word(state, 901, 0);
999         dib9000_write_word(state, 902, 0);
1000
1001         dib9000_write_word(state, 911, state->chip.d9.cfg.if_drives);
1002
1003         dib9000_set_power_mode(state, DIB9000_POWER_INTERFACE_ONLY);
1004
1005         return 0;
1006 }
1007
1008 static int dib9000_risc_apb_access_read(struct dib9000_state *state, u32 address, u16 attribute, const u8 * tx, u32 txlen, u8 * b, u32 len)
1009 {
1010         u16 mb[10];
1011         u8 i, s;
1012
1013         if (address >= 1024 || !state->platform.risc.fw_is_running)
1014                 return -EINVAL;
1015
1016         /* dprintk( "APB access thru rd fw %d %x", address, attribute); */
1017
1018         mb[0] = (u16) address;
1019         mb[1] = len / 2;
1020         dib9000_mbx_send_attr(state, OUT_MSG_BRIDGE_APB_R, mb, 2, attribute);
1021         switch (dib9000_mbx_get_message_attr(state, IN_MSG_END_BRIDGE_APB_RW, mb, &s, attribute)) {
1022         case 1:
1023                 s--;
1024                 for (i = 0; i < s; i++) {
1025                         b[i * 2] = (mb[i + 1] >> 8) & 0xff;
1026                         b[i * 2 + 1] = (mb[i + 1]) & 0xff;
1027                 }
1028                 return 0;
1029         default:
1030                 return -EIO;
1031         }
1032         return -EIO;
1033 }
1034
1035 static int dib9000_risc_apb_access_write(struct dib9000_state *state, u32 address, u16 attribute, const u8 * b, u32 len)
1036 {
1037         u16 mb[10];
1038         u8 s, i;
1039
1040         if (address >= 1024 || !state->platform.risc.fw_is_running)
1041                 return -EINVAL;
1042
1043         if (len > 18)
1044                 return -EINVAL;
1045
1046         /* dprintk( "APB access thru wr fw %d %x", address, attribute); */
1047
1048         mb[0] = (u16)address;
1049         for (i = 0; i + 1 < len; i += 2)
1050                 mb[1 + i / 2] = b[i] << 8 | b[i + 1];
1051         if (len & 1)
1052                 mb[1 + len / 2] = b[len - 1] << 8;
1053
1054         dib9000_mbx_send_attr(state, OUT_MSG_BRIDGE_APB_W, mb, (3 + len) / 2, attribute);
1055         return dib9000_mbx_get_message_attr(state, IN_MSG_END_BRIDGE_APB_RW, mb, &s, attribute) == 1 ? 0 : -EINVAL;
1056 }
1057
1058 static int dib9000_fw_memmbx_sync(struct dib9000_state *state, u8 i)
1059 {
1060         u8 index_loop = 10;
1061
1062         if (!state->platform.risc.fw_is_running)
1063                 return 0;
1064         dib9000_risc_mem_write(state, FE_MM_RW_SYNC, &i);
1065         do {
1066                 dib9000_risc_mem_read(state, FE_MM_RW_SYNC, state->i2c_read_buffer, 1);
1067         } while (state->i2c_read_buffer[0] && index_loop--);
1068
1069         if (index_loop > 0)
1070                 return 0;
1071         return -EIO;
1072 }
1073
1074 static int dib9000_fw_init(struct dib9000_state *state)
1075 {
1076         struct dibGPIOFunction *f;
1077         u16 b[40] = { 0 };
1078         u8 i;
1079         u8 size;
1080
1081         if (dib9000_fw_boot(state, NULL, 0, state->chip.d9.cfg.microcode_B_fe_buffer, state->chip.d9.cfg.microcode_B_fe_size) != 0)
1082                 return -EIO;
1083
1084         /* initialize the firmware */
1085         for (i = 0; i < ARRAY_SIZE(state->chip.d9.cfg.gpio_function); i++) {
1086                 f = &state->chip.d9.cfg.gpio_function[i];
1087                 if (f->mask) {
1088                         switch (f->function) {
1089                         case BOARD_GPIO_FUNCTION_COMPONENT_ON:
1090                                 b[0] = (u16) f->mask;
1091                                 b[1] = (u16) f->direction;
1092                                 b[2] = (u16) f->value;
1093                                 break;
1094                         case BOARD_GPIO_FUNCTION_COMPONENT_OFF:
1095                                 b[3] = (u16) f->mask;
1096                                 b[4] = (u16) f->direction;
1097                                 b[5] = (u16) f->value;
1098                                 break;
1099                         }
1100                 }
1101         }
1102         if (dib9000_mbx_send(state, OUT_MSG_CONF_GPIO, b, 15) != 0)
1103                 return -EIO;
1104
1105         /* subband */
1106         b[0] = state->chip.d9.cfg.subband.size; /* type == 0 -> GPIO - PWM not yet supported */
1107         for (i = 0; i < state->chip.d9.cfg.subband.size; i++) {
1108                 b[1 + i * 4] = state->chip.d9.cfg.subband.subband[i].f_mhz;
1109                 b[2 + i * 4] = (u16) state->chip.d9.cfg.subband.subband[i].gpio.mask;
1110                 b[3 + i * 4] = (u16) state->chip.d9.cfg.subband.subband[i].gpio.direction;
1111                 b[4 + i * 4] = (u16) state->chip.d9.cfg.subband.subband[i].gpio.value;
1112         }
1113         b[1 + i * 4] = 0;       /* fe_id */
1114         if (dib9000_mbx_send(state, OUT_MSG_SUBBAND_SEL, b, 2 + 4 * i) != 0)
1115                 return -EIO;
1116
1117         /* 0 - id, 1 - no_of_frontends */
1118         b[0] = (0 << 8) | 1;
1119         /* 0 = i2c-address demod, 0 = tuner */
1120         b[1] = (0 << 8) | (0);
1121         b[2] = (u16) (((state->chip.d9.cfg.xtal_clock_khz * 1000) >> 16) & 0xffff);
1122         b[3] = (u16) (((state->chip.d9.cfg.xtal_clock_khz * 1000)) & 0xffff);
1123         b[4] = (u16) ((state->chip.d9.cfg.vcxo_timer >> 16) & 0xffff);
1124         b[5] = (u16) ((state->chip.d9.cfg.vcxo_timer) & 0xffff);
1125         b[6] = (u16) ((state->chip.d9.cfg.timing_frequency >> 16) & 0xffff);
1126         b[7] = (u16) ((state->chip.d9.cfg.timing_frequency) & 0xffff);
1127         b[29] = state->chip.d9.cfg.if_drives;
1128         if (dib9000_mbx_send(state, OUT_MSG_INIT_DEMOD, b, ARRAY_SIZE(b)) != 0)
1129                 return -EIO;
1130
1131         if (dib9000_mbx_send(state, OUT_MSG_FE_FW_DL, NULL, 0) != 0)
1132                 return -EIO;
1133
1134         if (dib9000_mbx_get_message(state, IN_MSG_FE_FW_DL_DONE, b, &size) < 0)
1135                 return -EIO;
1136
1137         if (size > ARRAY_SIZE(b)) {
1138                 dprintk("error : firmware returned %dbytes needed but the used buffer has only %dbytes\n Firmware init ABORTED", size,
1139                         (int)ARRAY_SIZE(b));
1140                 return -EINVAL;
1141         }
1142
1143         for (i = 0; i < size; i += 2) {
1144                 state->platform.risc.fe_mm[i / 2].addr = b[i + 0];
1145                 state->platform.risc.fe_mm[i / 2].size = b[i + 1];
1146         }
1147
1148         return 0;
1149 }
1150
1151 static void dib9000_fw_set_channel_head(struct dib9000_state *state)
1152 {
1153         u8 b[9];
1154         u32 freq = state->fe[0]->dtv_property_cache.frequency / 1000;
1155         if (state->fe_id % 2)
1156                 freq += 101;
1157
1158         b[0] = (u8) ((freq >> 0) & 0xff);
1159         b[1] = (u8) ((freq >> 8) & 0xff);
1160         b[2] = (u8) ((freq >> 16) & 0xff);
1161         b[3] = (u8) ((freq >> 24) & 0xff);
1162         b[4] = (u8) ((state->fe[0]->dtv_property_cache.bandwidth_hz / 1000 >> 0) & 0xff);
1163         b[5] = (u8) ((state->fe[0]->dtv_property_cache.bandwidth_hz / 1000 >> 8) & 0xff);
1164         b[6] = (u8) ((state->fe[0]->dtv_property_cache.bandwidth_hz / 1000 >> 16) & 0xff);
1165         b[7] = (u8) ((state->fe[0]->dtv_property_cache.bandwidth_hz / 1000 >> 24) & 0xff);
1166         b[8] = 0x80;            /* do not wait for CELL ID when doing autosearch */
1167         if (state->fe[0]->dtv_property_cache.delivery_system == SYS_DVBT)
1168                 b[8] |= 1;
1169         dib9000_risc_mem_write(state, FE_MM_W_CHANNEL_HEAD, b);
1170 }
1171
1172 static int dib9000_fw_get_channel(struct dvb_frontend *fe)
1173 {
1174         struct dib9000_state *state = fe->demodulator_priv;
1175         struct dibDVBTChannel {
1176                 s8 spectrum_inversion;
1177
1178                 s8 nfft;
1179                 s8 guard;
1180                 s8 constellation;
1181
1182                 s8 hrch;
1183                 s8 alpha;
1184                 s8 code_rate_hp;
1185                 s8 code_rate_lp;
1186                 s8 select_hp;
1187
1188                 s8 intlv_native;
1189         };
1190         struct dibDVBTChannel *ch;
1191         int ret = 0;
1192
1193         if (mutex_lock_interruptible(&state->platform.risc.mem_mbx_lock) < 0) {
1194                 dprintk("could not get the lock");
1195                 return -EINTR;
1196         }
1197         if (dib9000_fw_memmbx_sync(state, FE_SYNC_CHANNEL) < 0) {
1198                 ret = -EIO;
1199                 goto error;
1200         }
1201
1202         dib9000_risc_mem_read(state, FE_MM_R_CHANNEL_UNION,
1203                         state->i2c_read_buffer, sizeof(struct dibDVBTChannel));
1204         ch = (struct dibDVBTChannel *)state->i2c_read_buffer;
1205
1206
1207         switch (ch->spectrum_inversion & 0x7) {
1208         case 1:
1209                 state->fe[0]->dtv_property_cache.inversion = INVERSION_ON;
1210                 break;
1211         case 0:
1212                 state->fe[0]->dtv_property_cache.inversion = INVERSION_OFF;
1213                 break;
1214         default:
1215         case -1:
1216                 state->fe[0]->dtv_property_cache.inversion = INVERSION_AUTO;
1217                 break;
1218         }
1219         switch (ch->nfft) {
1220         case 0:
1221                 state->fe[0]->dtv_property_cache.transmission_mode = TRANSMISSION_MODE_2K;
1222                 break;
1223         case 2:
1224                 state->fe[0]->dtv_property_cache.transmission_mode = TRANSMISSION_MODE_4K;
1225                 break;
1226         case 1:
1227                 state->fe[0]->dtv_property_cache.transmission_mode = TRANSMISSION_MODE_8K;
1228                 break;
1229         default:
1230         case -1:
1231                 state->fe[0]->dtv_property_cache.transmission_mode = TRANSMISSION_MODE_AUTO;
1232                 break;
1233         }
1234         switch (ch->guard) {
1235         case 0:
1236                 state->fe[0]->dtv_property_cache.guard_interval = GUARD_INTERVAL_1_32;
1237                 break;
1238         case 1:
1239                 state->fe[0]->dtv_property_cache.guard_interval = GUARD_INTERVAL_1_16;
1240                 break;
1241         case 2:
1242                 state->fe[0]->dtv_property_cache.guard_interval = GUARD_INTERVAL_1_8;
1243                 break;
1244         case 3:
1245                 state->fe[0]->dtv_property_cache.guard_interval = GUARD_INTERVAL_1_4;
1246                 break;
1247         default:
1248         case -1:
1249                 state->fe[0]->dtv_property_cache.guard_interval = GUARD_INTERVAL_AUTO;
1250                 break;
1251         }
1252         switch (ch->constellation) {
1253         case 2:
1254                 state->fe[0]->dtv_property_cache.modulation = QAM_64;
1255                 break;
1256         case 1:
1257                 state->fe[0]->dtv_property_cache.modulation = QAM_16;
1258                 break;
1259         case 0:
1260                 state->fe[0]->dtv_property_cache.modulation = QPSK;
1261                 break;
1262         default:
1263         case -1:
1264                 state->fe[0]->dtv_property_cache.modulation = QAM_AUTO;
1265                 break;
1266         }
1267         switch (ch->hrch) {
1268         case 0:
1269                 state->fe[0]->dtv_property_cache.hierarchy = HIERARCHY_NONE;
1270                 break;
1271         case 1:
1272                 state->fe[0]->dtv_property_cache.hierarchy = HIERARCHY_1;
1273                 break;
1274         default:
1275         case -1:
1276                 state->fe[0]->dtv_property_cache.hierarchy = HIERARCHY_AUTO;
1277                 break;
1278         }
1279         switch (ch->code_rate_hp) {
1280         case 1:
1281                 state->fe[0]->dtv_property_cache.code_rate_HP = FEC_1_2;
1282                 break;
1283         case 2:
1284                 state->fe[0]->dtv_property_cache.code_rate_HP = FEC_2_3;
1285                 break;
1286         case 3:
1287                 state->fe[0]->dtv_property_cache.code_rate_HP = FEC_3_4;
1288                 break;
1289         case 5:
1290                 state->fe[0]->dtv_property_cache.code_rate_HP = FEC_5_6;
1291                 break;
1292         case 7:
1293                 state->fe[0]->dtv_property_cache.code_rate_HP = FEC_7_8;
1294                 break;
1295         default:
1296         case -1:
1297                 state->fe[0]->dtv_property_cache.code_rate_HP = FEC_AUTO;
1298                 break;
1299         }
1300         switch (ch->code_rate_lp) {
1301         case 1:
1302                 state->fe[0]->dtv_property_cache.code_rate_LP = FEC_1_2;
1303                 break;
1304         case 2:
1305                 state->fe[0]->dtv_property_cache.code_rate_LP = FEC_2_3;
1306                 break;
1307         case 3:
1308                 state->fe[0]->dtv_property_cache.code_rate_LP = FEC_3_4;
1309                 break;
1310         case 5:
1311                 state->fe[0]->dtv_property_cache.code_rate_LP = FEC_5_6;
1312                 break;
1313         case 7:
1314                 state->fe[0]->dtv_property_cache.code_rate_LP = FEC_7_8;
1315                 break;
1316         default:
1317         case -1:
1318                 state->fe[0]->dtv_property_cache.code_rate_LP = FEC_AUTO;
1319                 break;
1320         }
1321
1322 error:
1323         mutex_unlock(&state->platform.risc.mem_mbx_lock);
1324         return ret;
1325 }
1326
1327 static int dib9000_fw_set_channel_union(struct dvb_frontend *fe)
1328 {
1329         struct dib9000_state *state = fe->demodulator_priv;
1330         struct dibDVBTChannel {
1331                 s8 spectrum_inversion;
1332
1333                 s8 nfft;
1334                 s8 guard;
1335                 s8 constellation;
1336
1337                 s8 hrch;
1338                 s8 alpha;
1339                 s8 code_rate_hp;
1340                 s8 code_rate_lp;
1341                 s8 select_hp;
1342
1343                 s8 intlv_native;
1344         };
1345         struct dibDVBTChannel ch;
1346
1347         switch (state->fe[0]->dtv_property_cache.inversion) {
1348         case INVERSION_ON:
1349                 ch.spectrum_inversion = 1;
1350                 break;
1351         case INVERSION_OFF:
1352                 ch.spectrum_inversion = 0;
1353                 break;
1354         default:
1355         case INVERSION_AUTO:
1356                 ch.spectrum_inversion = -1;
1357                 break;
1358         }
1359         switch (state->fe[0]->dtv_property_cache.transmission_mode) {
1360         case TRANSMISSION_MODE_2K:
1361                 ch.nfft = 0;
1362                 break;
1363         case TRANSMISSION_MODE_4K:
1364                 ch.nfft = 2;
1365                 break;
1366         case TRANSMISSION_MODE_8K:
1367                 ch.nfft = 1;
1368                 break;
1369         default:
1370         case TRANSMISSION_MODE_AUTO:
1371                 ch.nfft = 1;
1372                 break;
1373         }
1374         switch (state->fe[0]->dtv_property_cache.guard_interval) {
1375         case GUARD_INTERVAL_1_32:
1376                 ch.guard = 0;
1377                 break;
1378         case GUARD_INTERVAL_1_16:
1379                 ch.guard = 1;
1380                 break;
1381         case GUARD_INTERVAL_1_8:
1382                 ch.guard = 2;
1383                 break;
1384         case GUARD_INTERVAL_1_4:
1385                 ch.guard = 3;
1386                 break;
1387         default:
1388         case GUARD_INTERVAL_AUTO:
1389                 ch.guard = -1;
1390                 break;
1391         }
1392         switch (state->fe[0]->dtv_property_cache.modulation) {
1393         case QAM_64:
1394                 ch.constellation = 2;
1395                 break;
1396         case QAM_16:
1397                 ch.constellation = 1;
1398                 break;
1399         case QPSK:
1400                 ch.constellation = 0;
1401                 break;
1402         default:
1403         case QAM_AUTO:
1404                 ch.constellation = -1;
1405                 break;
1406         }
1407         switch (state->fe[0]->dtv_property_cache.hierarchy) {
1408         case HIERARCHY_NONE:
1409                 ch.hrch = 0;
1410                 break;
1411         case HIERARCHY_1:
1412         case HIERARCHY_2:
1413         case HIERARCHY_4:
1414                 ch.hrch = 1;
1415                 break;
1416         default:
1417         case HIERARCHY_AUTO:
1418                 ch.hrch = -1;
1419                 break;
1420         }
1421         ch.alpha = 1;
1422         switch (state->fe[0]->dtv_property_cache.code_rate_HP) {
1423         case FEC_1_2:
1424                 ch.code_rate_hp = 1;
1425                 break;
1426         case FEC_2_3:
1427                 ch.code_rate_hp = 2;
1428                 break;
1429         case FEC_3_4:
1430                 ch.code_rate_hp = 3;
1431                 break;
1432         case FEC_5_6:
1433                 ch.code_rate_hp = 5;
1434                 break;
1435         case FEC_7_8:
1436                 ch.code_rate_hp = 7;
1437                 break;
1438         default:
1439         case FEC_AUTO:
1440                 ch.code_rate_hp = -1;
1441                 break;
1442         }
1443         switch (state->fe[0]->dtv_property_cache.code_rate_LP) {
1444         case FEC_1_2:
1445                 ch.code_rate_lp = 1;
1446                 break;
1447         case FEC_2_3:
1448                 ch.code_rate_lp = 2;
1449                 break;
1450         case FEC_3_4:
1451                 ch.code_rate_lp = 3;
1452                 break;
1453         case FEC_5_6:
1454                 ch.code_rate_lp = 5;
1455                 break;
1456         case FEC_7_8:
1457                 ch.code_rate_lp = 7;
1458                 break;
1459         default:
1460         case FEC_AUTO:
1461                 ch.code_rate_lp = -1;
1462                 break;
1463         }
1464         ch.select_hp = 1;
1465         ch.intlv_native = 1;
1466
1467         dib9000_risc_mem_write(state, FE_MM_W_CHANNEL_UNION, (u8 *) &ch);
1468
1469         return 0;
1470 }
1471
1472 static int dib9000_fw_tune(struct dvb_frontend *fe)
1473 {
1474         struct dib9000_state *state = fe->demodulator_priv;
1475         int ret = 10, search = state->channel_status.status == CHANNEL_STATUS_PARAMETERS_UNKNOWN;
1476         s8 i;
1477
1478         switch (state->tune_state) {
1479         case CT_DEMOD_START:
1480                 dib9000_fw_set_channel_head(state);
1481
1482                 /* write the channel context - a channel is initialized to 0, so it is OK */
1483                 dib9000_risc_mem_write(state, FE_MM_W_CHANNEL_CONTEXT, (u8 *) fe_info);
1484                 dib9000_risc_mem_write(state, FE_MM_W_FE_INFO, (u8 *) fe_info);
1485
1486                 if (search)
1487                         dib9000_mbx_send(state, OUT_MSG_FE_CHANNEL_SEARCH, NULL, 0);
1488                 else {
1489                         dib9000_fw_set_channel_union(fe);
1490                         dib9000_mbx_send(state, OUT_MSG_FE_CHANNEL_TUNE, NULL, 0);
1491                 }
1492                 state->tune_state = CT_DEMOD_STEP_1;
1493                 break;
1494         case CT_DEMOD_STEP_1:
1495                 if (search)
1496                         dib9000_risc_mem_read(state, FE_MM_R_CHANNEL_SEARCH_STATE, state->i2c_read_buffer, 1);
1497                 else
1498                         dib9000_risc_mem_read(state, FE_MM_R_CHANNEL_TUNE_STATE, state->i2c_read_buffer, 1);
1499                 i = (s8)state->i2c_read_buffer[0];
1500                 switch (i) {    /* something happened */
1501                 case 0:
1502                         break;
1503                 case -2:        /* tps locks are "slower" than MPEG locks -> even in autosearch data is OK here */
1504                         if (search)
1505                                 state->status = FE_STATUS_DEMOD_SUCCESS;
1506                         else {
1507                                 state->tune_state = CT_DEMOD_STOP;
1508                                 state->status = FE_STATUS_LOCKED;
1509                         }
1510                         break;
1511                 default:
1512                         state->status = FE_STATUS_TUNE_FAILED;
1513                         state->tune_state = CT_DEMOD_STOP;
1514                         break;
1515                 }
1516                 break;
1517         default:
1518                 ret = FE_CALLBACK_TIME_NEVER;
1519                 break;
1520         }
1521
1522         return ret;
1523 }
1524
1525 static int dib9000_fw_set_diversity_in(struct dvb_frontend *fe, int onoff)
1526 {
1527         struct dib9000_state *state = fe->demodulator_priv;
1528         u16 mode = (u16) onoff;
1529         return dib9000_mbx_send(state, OUT_MSG_ENABLE_DIVERSITY, &mode, 1);
1530 }
1531
1532 static int dib9000_fw_set_output_mode(struct dvb_frontend *fe, int mode)
1533 {
1534         struct dib9000_state *state = fe->demodulator_priv;
1535         u16 outreg, smo_mode;
1536
1537         dprintk("setting output mode for demod %p to %d", fe, mode);
1538
1539         switch (mode) {
1540         case OUTMODE_MPEG2_PAR_GATED_CLK:
1541                 outreg = (1 << 10);     /* 0x0400 */
1542                 break;
1543         case OUTMODE_MPEG2_PAR_CONT_CLK:
1544                 outreg = (1 << 10) | (1 << 6);  /* 0x0440 */
1545                 break;
1546         case OUTMODE_MPEG2_SERIAL:
1547                 outreg = (1 << 10) | (2 << 6) | (0 << 1);       /* 0x0482 */
1548                 break;
1549         case OUTMODE_DIVERSITY:
1550                 outreg = (1 << 10) | (4 << 6);  /* 0x0500 */
1551                 break;
1552         case OUTMODE_MPEG2_FIFO:
1553                 outreg = (1 << 10) | (5 << 6);
1554                 break;
1555         case OUTMODE_HIGH_Z:
1556                 outreg = 0;
1557                 break;
1558         default:
1559                 dprintk("Unhandled output_mode passed to be set for demod %p", &state->fe[0]);
1560                 return -EINVAL;
1561         }
1562
1563         dib9000_write_word(state, 1795, outreg);
1564
1565         switch (mode) {
1566         case OUTMODE_MPEG2_PAR_GATED_CLK:
1567         case OUTMODE_MPEG2_PAR_CONT_CLK:
1568         case OUTMODE_MPEG2_SERIAL:
1569         case OUTMODE_MPEG2_FIFO:
1570                 smo_mode = (dib9000_read_word(state, 295) & 0x0010) | (1 << 1);
1571                 if (state->chip.d9.cfg.output_mpeg2_in_188_bytes)
1572                         smo_mode |= (1 << 5);
1573                 dib9000_write_word(state, 295, smo_mode);
1574                 break;
1575         }
1576
1577         outreg = to_fw_output_mode(mode);
1578         return dib9000_mbx_send(state, OUT_MSG_SET_OUTPUT_MODE, &outreg, 1);
1579 }
1580
1581 static int dib9000_tuner_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg msg[], int num)
1582 {
1583         struct dib9000_state *state = i2c_get_adapdata(i2c_adap);
1584         u16 i, len, t, index_msg;
1585
1586         for (index_msg = 0; index_msg < num; index_msg++) {
1587                 if (msg[index_msg].flags & I2C_M_RD) {  /* read */
1588                         len = msg[index_msg].len;
1589                         if (len > 16)
1590                                 len = 16;
1591
1592                         if (dib9000_read_word(state, 790) != 0)
1593                                 dprintk("TunerITF: read busy");
1594
1595                         dib9000_write_word(state, 784, (u16) (msg[index_msg].addr));
1596                         dib9000_write_word(state, 787, (len / 2) - 1);
1597                         dib9000_write_word(state, 786, 1);      /* start read */
1598
1599                         i = 1000;
1600                         while (dib9000_read_word(state, 790) != (len / 2) && i)
1601                                 i--;
1602
1603                         if (i == 0)
1604                                 dprintk("TunerITF: read failed");
1605
1606                         for (i = 0; i < len; i += 2) {
1607                                 t = dib9000_read_word(state, 785);
1608                                 msg[index_msg].buf[i] = (t >> 8) & 0xff;
1609                                 msg[index_msg].buf[i + 1] = (t) & 0xff;
1610                         }
1611                         if (dib9000_read_word(state, 790) != 0)
1612                                 dprintk("TunerITF: read more data than expected");
1613                 } else {
1614                         i = 1000;
1615                         while (dib9000_read_word(state, 789) && i)
1616                                 i--;
1617                         if (i == 0)
1618                                 dprintk("TunerITF: write busy");
1619
1620                         len = msg[index_msg].len;
1621                         if (len > 16)
1622                                 len = 16;
1623
1624                         for (i = 0; i < len; i += 2)
1625                                 dib9000_write_word(state, 785, (msg[index_msg].buf[i] << 8) | msg[index_msg].buf[i + 1]);
1626                         dib9000_write_word(state, 784, (u16) msg[index_msg].addr);
1627                         dib9000_write_word(state, 787, (len / 2) - 1);
1628                         dib9000_write_word(state, 786, 0);      /* start write */
1629
1630                         i = 1000;
1631                         while (dib9000_read_word(state, 791) > 0 && i)
1632                                 i--;
1633                         if (i == 0)
1634                                 dprintk("TunerITF: write failed");
1635                 }
1636         }
1637         return num;
1638 }
1639
1640 int dib9000_fw_set_component_bus_speed(struct dvb_frontend *fe, u16 speed)
1641 {
1642         struct dib9000_state *state = fe->demodulator_priv;
1643
1644         state->component_bus_speed = speed;
1645         return 0;
1646 }
1647 EXPORT_SYMBOL(dib9000_fw_set_component_bus_speed);
1648
1649 static int dib9000_fw_component_bus_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg msg[], int num)
1650 {
1651         struct dib9000_state *state = i2c_get_adapdata(i2c_adap);
1652         u8 type = 0;            /* I2C */
1653         u8 port = DIBX000_I2C_INTERFACE_GPIO_3_4;
1654         u16 scl = state->component_bus_speed;   /* SCL frequency */
1655         struct dib9000_fe_memory_map *m = &state->platform.risc.fe_mm[FE_MM_RW_COMPONENT_ACCESS_BUFFER];
1656         u8 p[13] = { 0 };
1657
1658         p[0] = type;
1659         p[1] = port;
1660         p[2] = msg[0].addr << 1;
1661
1662         p[3] = (u8) scl & 0xff; /* scl */
1663         p[4] = (u8) (scl >> 8);
1664
1665         p[7] = 0;
1666         p[8] = 0;
1667
1668         p[9] = (u8) (msg[0].len);
1669         p[10] = (u8) (msg[0].len >> 8);
1670         if ((num > 1) && (msg[1].flags & I2C_M_RD)) {
1671                 p[11] = (u8) (msg[1].len);
1672                 p[12] = (u8) (msg[1].len >> 8);
1673         } else {
1674                 p[11] = 0;
1675                 p[12] = 0;
1676         }
1677
1678         if (mutex_lock_interruptible(&state->platform.risc.mem_mbx_lock) < 0) {
1679                 dprintk("could not get the lock");
1680                 return 0;
1681         }
1682
1683         dib9000_risc_mem_write(state, FE_MM_W_COMPONENT_ACCESS, p);
1684
1685         {                       /* write-part */
1686                 dib9000_risc_mem_setup_cmd(state, m->addr, msg[0].len, 0);
1687                 dib9000_risc_mem_write_chunks(state, msg[0].buf, msg[0].len);
1688         }
1689
1690         /* do the transaction */
1691         if (dib9000_fw_memmbx_sync(state, FE_SYNC_COMPONENT_ACCESS) < 0) {
1692                 mutex_unlock(&state->platform.risc.mem_mbx_lock);
1693                 return 0;
1694         }
1695
1696         /* read back any possible result */
1697         if ((num > 1) && (msg[1].flags & I2C_M_RD))
1698                 dib9000_risc_mem_read(state, FE_MM_RW_COMPONENT_ACCESS_BUFFER, msg[1].buf, msg[1].len);
1699
1700         mutex_unlock(&state->platform.risc.mem_mbx_lock);
1701
1702         return num;
1703 }
1704
1705 static u32 dib9000_i2c_func(struct i2c_adapter *adapter)
1706 {
1707         return I2C_FUNC_I2C;
1708 }
1709
1710 static struct i2c_algorithm dib9000_tuner_algo = {
1711         .master_xfer = dib9000_tuner_xfer,
1712         .functionality = dib9000_i2c_func,
1713 };
1714
1715 static struct i2c_algorithm dib9000_component_bus_algo = {
1716         .master_xfer = dib9000_fw_component_bus_xfer,
1717         .functionality = dib9000_i2c_func,
1718 };
1719
1720 struct i2c_adapter *dib9000_get_tuner_interface(struct dvb_frontend *fe)
1721 {
1722         struct dib9000_state *st = fe->demodulator_priv;
1723         return &st->tuner_adap;
1724 }
1725 EXPORT_SYMBOL(dib9000_get_tuner_interface);
1726
1727 struct i2c_adapter *dib9000_get_component_bus_interface(struct dvb_frontend *fe)
1728 {
1729         struct dib9000_state *st = fe->demodulator_priv;
1730         return &st->component_bus;
1731 }
1732 EXPORT_SYMBOL(dib9000_get_component_bus_interface);
1733
1734 struct i2c_adapter *dib9000_get_i2c_master(struct dvb_frontend *fe, enum dibx000_i2c_interface intf, int gating)
1735 {
1736         struct dib9000_state *st = fe->demodulator_priv;
1737         return dibx000_get_i2c_adapter(&st->i2c_master, intf, gating);
1738 }
1739 EXPORT_SYMBOL(dib9000_get_i2c_master);
1740
1741 int dib9000_set_i2c_adapter(struct dvb_frontend *fe, struct i2c_adapter *i2c)
1742 {
1743         struct dib9000_state *st = fe->demodulator_priv;
1744
1745         st->i2c.i2c_adap = i2c;
1746         return 0;
1747 }
1748 EXPORT_SYMBOL(dib9000_set_i2c_adapter);
1749
1750 static int dib9000_cfg_gpio(struct dib9000_state *st, u8 num, u8 dir, u8 val)
1751 {
1752         st->gpio_dir = dib9000_read_word(st, 773);
1753         st->gpio_dir &= ~(1 << num);    /* reset the direction bit */
1754         st->gpio_dir |= (dir & 0x1) << num;     /* set the new direction */
1755         dib9000_write_word(st, 773, st->gpio_dir);
1756
1757         st->gpio_val = dib9000_read_word(st, 774);
1758         st->gpio_val &= ~(1 << num);    /* reset the direction bit */
1759         st->gpio_val |= (val & 0x01) << num;    /* set the new value */
1760         dib9000_write_word(st, 774, st->gpio_val);
1761
1762         dprintk("gpio dir: %04x: gpio val: %04x", st->gpio_dir, st->gpio_val);
1763
1764         return 0;
1765 }
1766
1767 int dib9000_set_gpio(struct dvb_frontend *fe, u8 num, u8 dir, u8 val)
1768 {
1769         struct dib9000_state *state = fe->demodulator_priv;
1770         return dib9000_cfg_gpio(state, num, dir, val);
1771 }
1772 EXPORT_SYMBOL(dib9000_set_gpio);
1773
1774 int dib9000_fw_pid_filter_ctrl(struct dvb_frontend *fe, u8 onoff)
1775 {
1776         struct dib9000_state *state = fe->demodulator_priv;
1777         u16 val;
1778         int ret;
1779
1780         if ((state->pid_ctrl_index != -2) && (state->pid_ctrl_index < 9)) {
1781                 /* postpone the pid filtering cmd */
1782                 dprintk("pid filter cmd postpone");
1783                 state->pid_ctrl_index++;
1784                 state->pid_ctrl[state->pid_ctrl_index].cmd = DIB9000_PID_FILTER_CTRL;
1785                 state->pid_ctrl[state->pid_ctrl_index].onoff = onoff;
1786                 return 0;
1787         }
1788
1789         if (mutex_lock_interruptible(&state->demod_lock) < 0) {
1790                 dprintk("could not get the lock");
1791                 return -EINTR;
1792         }
1793
1794         val = dib9000_read_word(state, 294 + 1) & 0xffef;
1795         val |= (onoff & 0x1) << 4;
1796
1797         dprintk("PID filter enabled %d", onoff);
1798         ret = dib9000_write_word(state, 294 + 1, val);
1799         mutex_unlock(&state->demod_lock);
1800         return ret;
1801
1802 }
1803 EXPORT_SYMBOL(dib9000_fw_pid_filter_ctrl);
1804
1805 int dib9000_fw_pid_filter(struct dvb_frontend *fe, u8 id, u16 pid, u8 onoff)
1806 {
1807         struct dib9000_state *state = fe->demodulator_priv;
1808         int ret;
1809
1810         if (state->pid_ctrl_index != -2) {
1811                 /* postpone the pid filtering cmd */
1812                 dprintk("pid filter postpone");
1813                 if (state->pid_ctrl_index < 9) {
1814                         state->pid_ctrl_index++;
1815                         state->pid_ctrl[state->pid_ctrl_index].cmd = DIB9000_PID_FILTER;
1816                         state->pid_ctrl[state->pid_ctrl_index].id = id;
1817                         state->pid_ctrl[state->pid_ctrl_index].pid = pid;
1818                         state->pid_ctrl[state->pid_ctrl_index].onoff = onoff;
1819                 } else
1820                         dprintk("can not add any more pid ctrl cmd");
1821                 return 0;
1822         }
1823
1824         if (mutex_lock_interruptible(&state->demod_lock) < 0) {
1825                 dprintk("could not get the lock");
1826                 return -EINTR;
1827         }
1828         dprintk("Index %x, PID %d, OnOff %d", id, pid, onoff);
1829         ret = dib9000_write_word(state, 300 + 1 + id,
1830                         onoff ? (1 << 13) | pid : 0);
1831         mutex_unlock(&state->demod_lock);
1832         return ret;
1833 }
1834 EXPORT_SYMBOL(dib9000_fw_pid_filter);
1835
1836 int dib9000_firmware_post_pll_init(struct dvb_frontend *fe)
1837 {
1838         struct dib9000_state *state = fe->demodulator_priv;
1839         return dib9000_fw_init(state);
1840 }
1841 EXPORT_SYMBOL(dib9000_firmware_post_pll_init);
1842
1843 static void dib9000_release(struct dvb_frontend *demod)
1844 {
1845         struct dib9000_state *st = demod->demodulator_priv;
1846         u8 index_frontend;
1847
1848         for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (st->fe[index_frontend] != NULL); index_frontend++)
1849                 dvb_frontend_detach(st->fe[index_frontend]);
1850
1851         dibx000_exit_i2c_master(&st->i2c_master);
1852
1853         i2c_del_adapter(&st->tuner_adap);
1854         i2c_del_adapter(&st->component_bus);
1855         kfree(st->fe[0]);
1856         kfree(st);
1857 }
1858
1859 static int dib9000_wakeup(struct dvb_frontend *fe)
1860 {
1861         return 0;
1862 }
1863
1864 static int dib9000_sleep(struct dvb_frontend *fe)
1865 {
1866         struct dib9000_state *state = fe->demodulator_priv;
1867         u8 index_frontend;
1868         int ret = 0;
1869
1870         if (mutex_lock_interruptible(&state->demod_lock) < 0) {
1871                 dprintk("could not get the lock");
1872                 return -EINTR;
1873         }
1874         for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
1875                 ret = state->fe[index_frontend]->ops.sleep(state->fe[index_frontend]);
1876                 if (ret < 0)
1877                         goto error;
1878         }
1879         ret = dib9000_mbx_send(state, OUT_MSG_FE_SLEEP, NULL, 0);
1880
1881 error:
1882         mutex_unlock(&state->demod_lock);
1883         return ret;
1884 }
1885
1886 static int dib9000_fe_get_tune_settings(struct dvb_frontend *fe, struct dvb_frontend_tune_settings *tune)
1887 {
1888         tune->min_delay_ms = 1000;
1889         return 0;
1890 }
1891
1892 static int dib9000_get_frontend(struct dvb_frontend *fe,
1893                                 struct dtv_frontend_properties *c)
1894 {
1895         struct dib9000_state *state = fe->demodulator_priv;
1896         u8 index_frontend, sub_index_frontend;
1897         enum fe_status stat;
1898         int ret = 0;
1899
1900         if (state->get_frontend_internal == 0) {
1901                 if (mutex_lock_interruptible(&state->demod_lock) < 0) {
1902                         dprintk("could not get the lock");
1903                         return -EINTR;
1904                 }
1905         }
1906
1907         for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
1908                 state->fe[index_frontend]->ops.read_status(state->fe[index_frontend], &stat);
1909                 if (stat & FE_HAS_SYNC) {
1910                         dprintk("TPS lock on the slave%i", index_frontend);
1911
1912                         /* synchronize the cache with the other frontends */
1913                         state->fe[index_frontend]->ops.get_frontend(state->fe[index_frontend], c);
1914                         for (sub_index_frontend = 0; (sub_index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[sub_index_frontend] != NULL);
1915                              sub_index_frontend++) {
1916                                 if (sub_index_frontend != index_frontend) {
1917                                         state->fe[sub_index_frontend]->dtv_property_cache.modulation =
1918                                             state->fe[index_frontend]->dtv_property_cache.modulation;
1919                                         state->fe[sub_index_frontend]->dtv_property_cache.inversion =
1920                                             state->fe[index_frontend]->dtv_property_cache.inversion;
1921                                         state->fe[sub_index_frontend]->dtv_property_cache.transmission_mode =
1922                                             state->fe[index_frontend]->dtv_property_cache.transmission_mode;
1923                                         state->fe[sub_index_frontend]->dtv_property_cache.guard_interval =
1924                                             state->fe[index_frontend]->dtv_property_cache.guard_interval;
1925                                         state->fe[sub_index_frontend]->dtv_property_cache.hierarchy =
1926                                             state->fe[index_frontend]->dtv_property_cache.hierarchy;
1927                                         state->fe[sub_index_frontend]->dtv_property_cache.code_rate_HP =
1928                                             state->fe[index_frontend]->dtv_property_cache.code_rate_HP;
1929                                         state->fe[sub_index_frontend]->dtv_property_cache.code_rate_LP =
1930                                             state->fe[index_frontend]->dtv_property_cache.code_rate_LP;
1931                                         state->fe[sub_index_frontend]->dtv_property_cache.rolloff =
1932                                             state->fe[index_frontend]->dtv_property_cache.rolloff;
1933                                 }
1934                         }
1935                         ret = 0;
1936                         goto return_value;
1937                 }
1938         }
1939
1940         /* get the channel from master chip */
1941         ret = dib9000_fw_get_channel(fe);
1942         if (ret != 0)
1943                 goto return_value;
1944
1945         /* synchronize the cache with the other frontends */
1946         for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
1947                 state->fe[index_frontend]->dtv_property_cache.inversion = c->inversion;
1948                 state->fe[index_frontend]->dtv_property_cache.transmission_mode = c->transmission_mode;
1949                 state->fe[index_frontend]->dtv_property_cache.guard_interval = c->guard_interval;
1950                 state->fe[index_frontend]->dtv_property_cache.modulation = c->modulation;
1951                 state->fe[index_frontend]->dtv_property_cache.hierarchy = c->hierarchy;
1952                 state->fe[index_frontend]->dtv_property_cache.code_rate_HP = c->code_rate_HP;
1953                 state->fe[index_frontend]->dtv_property_cache.code_rate_LP = c->code_rate_LP;
1954                 state->fe[index_frontend]->dtv_property_cache.rolloff = c->rolloff;
1955         }
1956         ret = 0;
1957
1958 return_value:
1959         if (state->get_frontend_internal == 0)
1960                 mutex_unlock(&state->demod_lock);
1961         return ret;
1962 }
1963
1964 static int dib9000_set_tune_state(struct dvb_frontend *fe, enum frontend_tune_state tune_state)
1965 {
1966         struct dib9000_state *state = fe->demodulator_priv;
1967         state->tune_state = tune_state;
1968         if (tune_state == CT_DEMOD_START)
1969                 state->status = FE_STATUS_TUNE_PENDING;
1970
1971         return 0;
1972 }
1973
1974 static u32 dib9000_get_status(struct dvb_frontend *fe)
1975 {
1976         struct dib9000_state *state = fe->demodulator_priv;
1977         return state->status;
1978 }
1979
1980 static int dib9000_set_channel_status(struct dvb_frontend *fe, struct dvb_frontend_parametersContext *channel_status)
1981 {
1982         struct dib9000_state *state = fe->demodulator_priv;
1983
1984         memcpy(&state->channel_status, channel_status, sizeof(struct dvb_frontend_parametersContext));
1985         return 0;
1986 }
1987
1988 static int dib9000_set_frontend(struct dvb_frontend *fe)
1989 {
1990         struct dib9000_state *state = fe->demodulator_priv;
1991         int sleep_time, sleep_time_slave;
1992         u32 frontend_status;
1993         u8 nbr_pending, exit_condition, index_frontend, index_frontend_success;
1994         struct dvb_frontend_parametersContext channel_status;
1995
1996         /* check that the correct parameters are set */
1997         if (state->fe[0]->dtv_property_cache.frequency == 0) {
1998                 dprintk("dib9000: must specify frequency ");
1999                 return 0;
2000         }
2001
2002         if (state->fe[0]->dtv_property_cache.bandwidth_hz == 0) {
2003                 dprintk("dib9000: must specify bandwidth ");
2004                 return 0;
2005         }
2006
2007         state->pid_ctrl_index = -1; /* postpone the pid filtering cmd */
2008         if (mutex_lock_interruptible(&state->demod_lock) < 0) {
2009                 dprintk("could not get the lock");
2010                 return 0;
2011         }
2012
2013         fe->dtv_property_cache.delivery_system = SYS_DVBT;
2014
2015         /* set the master status */
2016         if (state->fe[0]->dtv_property_cache.transmission_mode == TRANSMISSION_MODE_AUTO ||
2017             state->fe[0]->dtv_property_cache.guard_interval == GUARD_INTERVAL_AUTO ||
2018             state->fe[0]->dtv_property_cache.modulation == QAM_AUTO ||
2019             state->fe[0]->dtv_property_cache.code_rate_HP == FEC_AUTO) {
2020                 /* no channel specified, autosearch the channel */
2021                 state->channel_status.status = CHANNEL_STATUS_PARAMETERS_UNKNOWN;
2022         } else
2023                 state->channel_status.status = CHANNEL_STATUS_PARAMETERS_SET;
2024
2025         /* set mode and status for the different frontends */
2026         for (index_frontend = 0; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
2027                 dib9000_fw_set_diversity_in(state->fe[index_frontend], 1);
2028
2029                 /* synchronization of the cache */
2030                 memcpy(&state->fe[index_frontend]->dtv_property_cache, &fe->dtv_property_cache, sizeof(struct dtv_frontend_properties));
2031
2032                 state->fe[index_frontend]->dtv_property_cache.delivery_system = SYS_DVBT;
2033                 dib9000_fw_set_output_mode(state->fe[index_frontend], OUTMODE_HIGH_Z);
2034
2035                 dib9000_set_channel_status(state->fe[index_frontend], &state->channel_status);
2036                 dib9000_set_tune_state(state->fe[index_frontend], CT_DEMOD_START);
2037         }
2038
2039         /* actual tune */
2040         exit_condition = 0;     /* 0: tune pending; 1: tune failed; 2:tune success */
2041         index_frontend_success = 0;
2042         do {
2043                 sleep_time = dib9000_fw_tune(state->fe[0]);
2044                 for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
2045                         sleep_time_slave = dib9000_fw_tune(state->fe[index_frontend]);
2046                         if (sleep_time == FE_CALLBACK_TIME_NEVER)
2047                                 sleep_time = sleep_time_slave;
2048                         else if ((sleep_time_slave != FE_CALLBACK_TIME_NEVER) && (sleep_time_slave > sleep_time))
2049                                 sleep_time = sleep_time_slave;
2050                 }
2051                 if (sleep_time != FE_CALLBACK_TIME_NEVER)
2052                         msleep(sleep_time / 10);
2053                 else
2054                         break;
2055
2056                 nbr_pending = 0;
2057                 exit_condition = 0;
2058                 index_frontend_success = 0;
2059                 for (index_frontend = 0; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
2060                         frontend_status = -dib9000_get_status(state->fe[index_frontend]);
2061                         if (frontend_status > -FE_STATUS_TUNE_PENDING) {
2062                                 exit_condition = 2;     /* tune success */
2063                                 index_frontend_success = index_frontend;
2064                                 break;
2065                         }
2066                         if (frontend_status == -FE_STATUS_TUNE_PENDING)
2067                                 nbr_pending++;  /* some frontends are still tuning */
2068                 }
2069                 if ((exit_condition != 2) && (nbr_pending == 0))
2070                         exit_condition = 1;     /* if all tune are done and no success, exit: tune failed */
2071
2072         } while (exit_condition == 0);
2073
2074         /* check the tune result */
2075         if (exit_condition == 1) {      /* tune failed */
2076                 dprintk("tune failed");
2077                 mutex_unlock(&state->demod_lock);
2078                 /* tune failed; put all the pid filtering cmd to junk */
2079                 state->pid_ctrl_index = -1;
2080                 return 0;
2081         }
2082
2083         dprintk("tune success on frontend%i", index_frontend_success);
2084
2085         /* synchronize all the channel cache */
2086         state->get_frontend_internal = 1;
2087         dib9000_get_frontend(state->fe[0], &state->fe[0]->dtv_property_cache);
2088         state->get_frontend_internal = 0;
2089
2090         /* retune the other frontends with the found channel */
2091         channel_status.status = CHANNEL_STATUS_PARAMETERS_SET;
2092         for (index_frontend = 0; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
2093                 /* only retune the frontends which was not tuned success */
2094                 if (index_frontend != index_frontend_success) {
2095                         dib9000_set_channel_status(state->fe[index_frontend], &channel_status);
2096                         dib9000_set_tune_state(state->fe[index_frontend], CT_DEMOD_START);
2097                 }
2098         }
2099         do {
2100                 sleep_time = FE_CALLBACK_TIME_NEVER;
2101                 for (index_frontend = 0; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
2102                         if (index_frontend != index_frontend_success) {
2103                                 sleep_time_slave = dib9000_fw_tune(state->fe[index_frontend]);
2104                                 if (sleep_time == FE_CALLBACK_TIME_NEVER)
2105                                         sleep_time = sleep_time_slave;
2106                                 else if ((sleep_time_slave != FE_CALLBACK_TIME_NEVER) && (sleep_time_slave > sleep_time))
2107                                         sleep_time = sleep_time_slave;
2108                         }
2109                 }
2110                 if (sleep_time != FE_CALLBACK_TIME_NEVER)
2111                         msleep(sleep_time / 10);
2112                 else
2113                         break;
2114
2115                 nbr_pending = 0;
2116                 for (index_frontend = 0; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
2117                         if (index_frontend != index_frontend_success) {
2118                                 frontend_status = -dib9000_get_status(state->fe[index_frontend]);
2119                                 if ((index_frontend != index_frontend_success) && (frontend_status == -FE_STATUS_TUNE_PENDING))
2120                                         nbr_pending++;  /* some frontends are still tuning */
2121                         }
2122                 }
2123         } while (nbr_pending != 0);
2124
2125         /* set the output mode */
2126         dib9000_fw_set_output_mode(state->fe[0], state->chip.d9.cfg.output_mode);
2127         for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++)
2128                 dib9000_fw_set_output_mode(state->fe[index_frontend], OUTMODE_DIVERSITY);
2129
2130         /* turn off the diversity for the last frontend */
2131         dib9000_fw_set_diversity_in(state->fe[index_frontend - 1], 0);
2132
2133         mutex_unlock(&state->demod_lock);
2134         if (state->pid_ctrl_index >= 0) {
2135                 u8 index_pid_filter_cmd;
2136                 u8 pid_ctrl_index = state->pid_ctrl_index;
2137
2138                 state->pid_ctrl_index = -2;
2139                 for (index_pid_filter_cmd = 0;
2140                                 index_pid_filter_cmd <= pid_ctrl_index;
2141                                 index_pid_filter_cmd++) {
2142                         if (state->pid_ctrl[index_pid_filter_cmd].cmd == DIB9000_PID_FILTER_CTRL)
2143                                 dib9000_fw_pid_filter_ctrl(state->fe[0],
2144                                                 state->pid_ctrl[index_pid_filter_cmd].onoff);
2145                         else if (state->pid_ctrl[index_pid_filter_cmd].cmd == DIB9000_PID_FILTER)
2146                                 dib9000_fw_pid_filter(state->fe[0],
2147                                                 state->pid_ctrl[index_pid_filter_cmd].id,
2148                                                 state->pid_ctrl[index_pid_filter_cmd].pid,
2149                                                 state->pid_ctrl[index_pid_filter_cmd].onoff);
2150                 }
2151         }
2152         /* do not postpone any more the pid filtering */
2153         state->pid_ctrl_index = -2;
2154
2155         return 0;
2156 }
2157
2158 static u16 dib9000_read_lock(struct dvb_frontend *fe)
2159 {
2160         struct dib9000_state *state = fe->demodulator_priv;
2161
2162         return dib9000_read_word(state, 535);
2163 }
2164
2165 static int dib9000_read_status(struct dvb_frontend *fe, enum fe_status *stat)
2166 {
2167         struct dib9000_state *state = fe->demodulator_priv;
2168         u8 index_frontend;
2169         u16 lock = 0, lock_slave = 0;
2170
2171         if (mutex_lock_interruptible(&state->demod_lock) < 0) {
2172                 dprintk("could not get the lock");
2173                 return -EINTR;
2174         }
2175         for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++)
2176                 lock_slave |= dib9000_read_lock(state->fe[index_frontend]);
2177
2178         lock = dib9000_read_word(state, 535);
2179
2180         *stat = 0;
2181
2182         if ((lock & 0x8000) || (lock_slave & 0x8000))
2183                 *stat |= FE_HAS_SIGNAL;
2184         if ((lock & 0x3000) || (lock_slave & 0x3000))
2185                 *stat |= FE_HAS_CARRIER;
2186         if ((lock & 0x0100) || (lock_slave & 0x0100))
2187                 *stat |= FE_HAS_VITERBI;
2188         if (((lock & 0x0038) == 0x38) || ((lock_slave & 0x0038) == 0x38))
2189                 *stat |= FE_HAS_SYNC;
2190         if ((lock & 0x0008) || (lock_slave & 0x0008))
2191                 *stat |= FE_HAS_LOCK;
2192
2193         mutex_unlock(&state->demod_lock);
2194
2195         return 0;
2196 }
2197
2198 static int dib9000_read_ber(struct dvb_frontend *fe, u32 * ber)
2199 {
2200         struct dib9000_state *state = fe->demodulator_priv;
2201         u16 *c;
2202         int ret = 0;
2203
2204         if (mutex_lock_interruptible(&state->demod_lock) < 0) {
2205                 dprintk("could not get the lock");
2206                 return -EINTR;
2207         }
2208         if (mutex_lock_interruptible(&state->platform.risc.mem_mbx_lock) < 0) {
2209                 dprintk("could not get the lock");
2210                 ret = -EINTR;
2211                 goto error;
2212         }
2213         if (dib9000_fw_memmbx_sync(state, FE_SYNC_CHANNEL) < 0) {
2214                 mutex_unlock(&state->platform.risc.mem_mbx_lock);
2215                 ret = -EIO;
2216                 goto error;
2217         }
2218         dib9000_risc_mem_read(state, FE_MM_R_FE_MONITOR,
2219                         state->i2c_read_buffer, 16 * 2);
2220         mutex_unlock(&state->platform.risc.mem_mbx_lock);
2221
2222         c = (u16 *)state->i2c_read_buffer;
2223
2224         *ber = c[10] << 16 | c[11];
2225
2226 error:
2227         mutex_unlock(&state->demod_lock);
2228         return ret;
2229 }
2230
2231 static int dib9000_read_signal_strength(struct dvb_frontend *fe, u16 * strength)
2232 {
2233         struct dib9000_state *state = fe->demodulator_priv;
2234         u8 index_frontend;
2235         u16 *c = (u16 *)state->i2c_read_buffer;
2236         u16 val;
2237         int ret = 0;
2238
2239         if (mutex_lock_interruptible(&state->demod_lock) < 0) {
2240                 dprintk("could not get the lock");
2241                 return -EINTR;
2242         }
2243         *strength = 0;
2244         for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
2245                 state->fe[index_frontend]->ops.read_signal_strength(state->fe[index_frontend], &val);
2246                 if (val > 65535 - *strength)
2247                         *strength = 65535;
2248                 else
2249                         *strength += val;
2250         }
2251
2252         if (mutex_lock_interruptible(&state->platform.risc.mem_mbx_lock) < 0) {
2253                 dprintk("could not get the lock");
2254                 ret = -EINTR;
2255                 goto error;
2256         }
2257         if (dib9000_fw_memmbx_sync(state, FE_SYNC_CHANNEL) < 0) {
2258                 mutex_unlock(&state->platform.risc.mem_mbx_lock);
2259                 ret = -EIO;
2260                 goto error;
2261         }
2262         dib9000_risc_mem_read(state, FE_MM_R_FE_MONITOR, (u8 *) c, 16 * 2);
2263         mutex_unlock(&state->platform.risc.mem_mbx_lock);
2264
2265         val = 65535 - c[4];
2266         if (val > 65535 - *strength)
2267                 *strength = 65535;
2268         else
2269                 *strength += val;
2270
2271 error:
2272         mutex_unlock(&state->demod_lock);
2273         return ret;
2274 }
2275
2276 static u32 dib9000_get_snr(struct dvb_frontend *fe)
2277 {
2278         struct dib9000_state *state = fe->demodulator_priv;
2279         u16 *c = (u16 *)state->i2c_read_buffer;
2280         u32 n, s, exp;
2281         u16 val;
2282
2283         if (mutex_lock_interruptible(&state->platform.risc.mem_mbx_lock) < 0) {
2284                 dprintk("could not get the lock");
2285                 return 0;
2286         }
2287         if (dib9000_fw_memmbx_sync(state, FE_SYNC_CHANNEL) < 0) {
2288                 mutex_unlock(&state->platform.risc.mem_mbx_lock);
2289                 return 0;
2290         }
2291         dib9000_risc_mem_read(state, FE_MM_R_FE_MONITOR, (u8 *) c, 16 * 2);
2292         mutex_unlock(&state->platform.risc.mem_mbx_lock);
2293
2294         val = c[7];
2295         n = (val >> 4) & 0xff;
2296         exp = ((val & 0xf) << 2);
2297         val = c[8];
2298         exp += ((val >> 14) & 0x3);
2299         if ((exp & 0x20) != 0)
2300                 exp -= 0x40;
2301         n <<= exp + 16;
2302
2303         s = (val >> 6) & 0xFF;
2304         exp = (val & 0x3F);
2305         if ((exp & 0x20) != 0)
2306                 exp -= 0x40;
2307         s <<= exp + 16;
2308
2309         if (n > 0) {
2310                 u32 t = (s / n) << 16;
2311                 return t + ((s << 16) - n * t) / n;
2312         }
2313         return 0xffffffff;
2314 }
2315
2316 static int dib9000_read_snr(struct dvb_frontend *fe, u16 * snr)
2317 {
2318         struct dib9000_state *state = fe->demodulator_priv;
2319         u8 index_frontend;
2320         u32 snr_master;
2321
2322         if (mutex_lock_interruptible(&state->demod_lock) < 0) {
2323                 dprintk("could not get the lock");
2324                 return -EINTR;
2325         }
2326         snr_master = dib9000_get_snr(fe);
2327         for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++)
2328                 snr_master += dib9000_get_snr(state->fe[index_frontend]);
2329
2330         if ((snr_master >> 16) != 0) {
2331                 snr_master = 10 * intlog10(snr_master >> 16);
2332                 *snr = snr_master / ((1 << 24) / 10);
2333         } else
2334                 *snr = 0;
2335
2336         mutex_unlock(&state->demod_lock);
2337
2338         return 0;
2339 }
2340
2341 static int dib9000_read_unc_blocks(struct dvb_frontend *fe, u32 * unc)
2342 {
2343         struct dib9000_state *state = fe->demodulator_priv;
2344         u16 *c = (u16 *)state->i2c_read_buffer;
2345         int ret = 0;
2346
2347         if (mutex_lock_interruptible(&state->demod_lock) < 0) {
2348                 dprintk("could not get the lock");
2349                 return -EINTR;
2350         }
2351         if (mutex_lock_interruptible(&state->platform.risc.mem_mbx_lock) < 0) {
2352                 dprintk("could not get the lock");
2353                 ret = -EINTR;
2354                 goto error;
2355         }
2356         if (dib9000_fw_memmbx_sync(state, FE_SYNC_CHANNEL) < 0) {
2357                 mutex_unlock(&state->platform.risc.mem_mbx_lock);
2358                 ret = -EIO;
2359                 goto error;
2360         }
2361         dib9000_risc_mem_read(state, FE_MM_R_FE_MONITOR, (u8 *) c, 16 * 2);
2362         mutex_unlock(&state->platform.risc.mem_mbx_lock);
2363
2364         *unc = c[12];
2365
2366 error:
2367         mutex_unlock(&state->demod_lock);
2368         return ret;
2369 }
2370
2371 int dib9000_i2c_enumeration(struct i2c_adapter *i2c, int no_of_demods, u8 default_addr, u8 first_addr)
2372 {
2373         int k = 0, ret = 0;
2374         u8 new_addr = 0;
2375         struct i2c_device client = {.i2c_adap = i2c };
2376
2377         client.i2c_write_buffer = kzalloc(4 * sizeof(u8), GFP_KERNEL);
2378         if (!client.i2c_write_buffer) {
2379                 dprintk("%s: not enough memory", __func__);
2380                 return -ENOMEM;
2381         }
2382         client.i2c_read_buffer = kzalloc(4 * sizeof(u8), GFP_KERNEL);
2383         if (!client.i2c_read_buffer) {
2384                 dprintk("%s: not enough memory", __func__);
2385                 ret = -ENOMEM;
2386                 goto error_memory;
2387         }
2388
2389         client.i2c_addr = default_addr + 16;
2390         dib9000_i2c_write16(&client, 1796, 0x0);
2391
2392         for (k = no_of_demods - 1; k >= 0; k--) {
2393                 /* designated i2c address */
2394                 new_addr = first_addr + (k << 1);
2395                 client.i2c_addr = default_addr;
2396
2397                 dib9000_i2c_write16(&client, 1817, 3);
2398                 dib9000_i2c_write16(&client, 1796, 0);
2399                 dib9000_i2c_write16(&client, 1227, 1);
2400                 dib9000_i2c_write16(&client, 1227, 0);
2401
2402                 client.i2c_addr = new_addr;
2403                 dib9000_i2c_write16(&client, 1817, 3);
2404                 dib9000_i2c_write16(&client, 1796, 0);
2405                 dib9000_i2c_write16(&client, 1227, 1);
2406                 dib9000_i2c_write16(&client, 1227, 0);
2407
2408                 if (dib9000_identify(&client) == 0) {
2409                         client.i2c_addr = default_addr;
2410                         if (dib9000_identify(&client) == 0) {
2411                                 dprintk("DiB9000 #%d: not identified", k);
2412                                 ret = -EIO;
2413                                 goto error;
2414                         }
2415                 }
2416
2417                 dib9000_i2c_write16(&client, 1795, (1 << 10) | (4 << 6));
2418                 dib9000_i2c_write16(&client, 1794, (new_addr << 2) | 2);
2419
2420                 dprintk("IC %d initialized (to i2c_address 0x%x)", k, new_addr);
2421         }
2422
2423         for (k = 0; k < no_of_demods; k++) {
2424                 new_addr = first_addr | (k << 1);
2425                 client.i2c_addr = new_addr;
2426
2427                 dib9000_i2c_write16(&client, 1794, (new_addr << 2));
2428                 dib9000_i2c_write16(&client, 1795, 0);
2429         }
2430
2431 error:
2432         kfree(client.i2c_read_buffer);
2433 error_memory:
2434         kfree(client.i2c_write_buffer);
2435
2436         return ret;
2437 }
2438 EXPORT_SYMBOL(dib9000_i2c_enumeration);
2439
2440 int dib9000_set_slave_frontend(struct dvb_frontend *fe, struct dvb_frontend *fe_slave)
2441 {
2442         struct dib9000_state *state = fe->demodulator_priv;
2443         u8 index_frontend = 1;
2444
2445         while ((index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL))
2446                 index_frontend++;
2447         if (index_frontend < MAX_NUMBER_OF_FRONTENDS) {
2448                 dprintk("set slave fe %p to index %i", fe_slave, index_frontend);
2449                 state->fe[index_frontend] = fe_slave;
2450                 return 0;
2451         }
2452
2453         dprintk("too many slave frontend");
2454         return -ENOMEM;
2455 }
2456 EXPORT_SYMBOL(dib9000_set_slave_frontend);
2457
2458 int dib9000_remove_slave_frontend(struct dvb_frontend *fe)
2459 {
2460         struct dib9000_state *state = fe->demodulator_priv;
2461         u8 index_frontend = 1;
2462
2463         while ((index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL))
2464                 index_frontend++;
2465         if (index_frontend != 1) {
2466                 dprintk("remove slave fe %p (index %i)", state->fe[index_frontend - 1], index_frontend - 1);
2467                 state->fe[index_frontend] = NULL;
2468                 return 0;
2469         }
2470
2471         dprintk("no frontend to be removed");
2472         return -ENODEV;
2473 }
2474 EXPORT_SYMBOL(dib9000_remove_slave_frontend);
2475
2476 struct dvb_frontend *dib9000_get_slave_frontend(struct dvb_frontend *fe, int slave_index)
2477 {
2478         struct dib9000_state *state = fe->demodulator_priv;
2479
2480         if (slave_index >= MAX_NUMBER_OF_FRONTENDS)
2481                 return NULL;
2482         return state->fe[slave_index];
2483 }
2484 EXPORT_SYMBOL(dib9000_get_slave_frontend);
2485
2486 static struct dvb_frontend_ops dib9000_ops;
2487 struct dvb_frontend *dib9000_attach(struct i2c_adapter *i2c_adap, u8 i2c_addr, const struct dib9000_config *cfg)
2488 {
2489         struct dvb_frontend *fe;
2490         struct dib9000_state *st;
2491         st = kzalloc(sizeof(struct dib9000_state), GFP_KERNEL);
2492         if (st == NULL)
2493                 return NULL;
2494         fe = kzalloc(sizeof(struct dvb_frontend), GFP_KERNEL);
2495         if (fe == NULL) {
2496                 kfree(st);
2497                 return NULL;
2498         }
2499
2500         memcpy(&st->chip.d9.cfg, cfg, sizeof(struct dib9000_config));
2501         st->i2c.i2c_adap = i2c_adap;
2502         st->i2c.i2c_addr = i2c_addr;
2503         st->i2c.i2c_write_buffer = st->i2c_write_buffer;
2504         st->i2c.i2c_read_buffer = st->i2c_read_buffer;
2505
2506         st->gpio_dir = DIB9000_GPIO_DEFAULT_DIRECTIONS;
2507         st->gpio_val = DIB9000_GPIO_DEFAULT_VALUES;
2508         st->gpio_pwm_pos = DIB9000_GPIO_DEFAULT_PWM_POS;
2509
2510         mutex_init(&st->platform.risc.mbx_if_lock);
2511         mutex_init(&st->platform.risc.mbx_lock);
2512         mutex_init(&st->platform.risc.mem_lock);
2513         mutex_init(&st->platform.risc.mem_mbx_lock);
2514         mutex_init(&st->demod_lock);
2515         st->get_frontend_internal = 0;
2516
2517         st->pid_ctrl_index = -2;
2518
2519         st->fe[0] = fe;
2520         fe->demodulator_priv = st;
2521         memcpy(&st->fe[0]->ops, &dib9000_ops, sizeof(struct dvb_frontend_ops));
2522
2523         /* Ensure the output mode remains at the previous default if it's
2524          * not specifically set by the caller.
2525          */
2526         if ((st->chip.d9.cfg.output_mode != OUTMODE_MPEG2_SERIAL) && (st->chip.d9.cfg.output_mode != OUTMODE_MPEG2_PAR_GATED_CLK))
2527                 st->chip.d9.cfg.output_mode = OUTMODE_MPEG2_FIFO;
2528
2529         if (dib9000_identify(&st->i2c) == 0)
2530                 goto error;
2531
2532         dibx000_init_i2c_master(&st->i2c_master, DIB7000MC, st->i2c.i2c_adap, st->i2c.i2c_addr);
2533
2534         st->tuner_adap.dev.parent = i2c_adap->dev.parent;
2535         strncpy(st->tuner_adap.name, "DIB9000_FW TUNER ACCESS", sizeof(st->tuner_adap.name));
2536         st->tuner_adap.algo = &dib9000_tuner_algo;
2537         st->tuner_adap.algo_data = NULL;
2538         i2c_set_adapdata(&st->tuner_adap, st);
2539         if (i2c_add_adapter(&st->tuner_adap) < 0)
2540                 goto error;
2541
2542         st->component_bus.dev.parent = i2c_adap->dev.parent;
2543         strncpy(st->component_bus.name, "DIB9000_FW COMPONENT BUS ACCESS", sizeof(st->component_bus.name));
2544         st->component_bus.algo = &dib9000_component_bus_algo;
2545         st->component_bus.algo_data = NULL;
2546         st->component_bus_speed = 340;
2547         i2c_set_adapdata(&st->component_bus, st);
2548         if (i2c_add_adapter(&st->component_bus) < 0)
2549                 goto component_bus_add_error;
2550
2551         dib9000_fw_reset(fe);
2552
2553         return fe;
2554
2555 component_bus_add_error:
2556         i2c_del_adapter(&st->tuner_adap);
2557 error:
2558         kfree(st);
2559         return NULL;
2560 }
2561 EXPORT_SYMBOL(dib9000_attach);
2562
2563 static struct dvb_frontend_ops dib9000_ops = {
2564         .delsys = { SYS_DVBT },
2565         .info = {
2566                  .name = "DiBcom 9000",
2567                  .frequency_min = 44250000,
2568                  .frequency_max = 867250000,
2569                  .frequency_stepsize = 62500,
2570                  .caps = FE_CAN_INVERSION_AUTO |
2571                  FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
2572                  FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
2573                  FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
2574                  FE_CAN_TRANSMISSION_MODE_AUTO | FE_CAN_GUARD_INTERVAL_AUTO | FE_CAN_RECOVER | FE_CAN_HIERARCHY_AUTO,
2575                  },
2576
2577         .release = dib9000_release,
2578
2579         .init = dib9000_wakeup,
2580         .sleep = dib9000_sleep,
2581
2582         .set_frontend = dib9000_set_frontend,
2583         .get_tune_settings = dib9000_fe_get_tune_settings,
2584         .get_frontend = dib9000_get_frontend,
2585
2586         .read_status = dib9000_read_status,
2587         .read_ber = dib9000_read_ber,
2588         .read_signal_strength = dib9000_read_signal_strength,
2589         .read_snr = dib9000_read_snr,
2590         .read_ucblocks = dib9000_read_unc_blocks,
2591 };
2592
2593 MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@posteo.de>");
2594 MODULE_AUTHOR("Olivier Grenie <olivier.grenie@parrot.com>");
2595 MODULE_DESCRIPTION("Driver for the DiBcom 9000 COFDM demodulator");
2596 MODULE_LICENSE("GPL");