Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
it913x.c
Go to the documentation of this file.
1 /*
2  * DVB USB compliant linux driver for ITE IT9135 and IT9137
3  *
4  * Copyright (C) 2011 Malcolm Priestley ([email protected])
5  * IT9135 (C) ITE Tech Inc.
6  * IT9137 (C) ITE Tech Inc.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License Version 2, as
10  * published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20  *
21  *
22  * see Documentation/dvb/README.dvb-usb for more information
23  * see Documentation/dvb/it9137.txt for firmware information
24  *
25  */
26 #define DVB_USB_LOG_PREFIX "it913x"
27 
28 #include <linux/usb.h>
29 #include <linux/usb/input.h>
30 #include <media/rc-core.h>
31 
32 #include "dvb_usb.h"
33 #include "it913x-fe.h"
34 
35 /* debug */
36 static int dvb_usb_it913x_debug;
37 #define it_debug(var, level, args...) \
38  do { if ((var & level)) pr_debug(DVB_USB_LOG_PREFIX": " args); \
39 } while (0)
40 #define deb_info(level, args...) it_debug(dvb_usb_it913x_debug, level, args)
41 #define info(args...) pr_info(DVB_USB_LOG_PREFIX": " args)
42 
43 module_param_named(debug, dvb_usb_it913x_debug, int, 0644);
44 MODULE_PARM_DESC(debug, "set debugging level (1=info (or-able)).");
45 
46 static int dvb_usb_it913x_firmware;
47 module_param_named(firmware, dvb_usb_it913x_firmware, int, 0644);
48 MODULE_PARM_DESC(firmware, "set firmware 0=auto"\
49  "1=IT9137 2=IT9135 V1 3=IT9135 V2");
50 #define FW_IT9137 "dvb-usb-it9137-01.fw"
51 #define FW_IT9135_V1 "dvb-usb-it9135-01.fw"
52 #define FW_IT9135_V2 "dvb-usb-it9135-02.fw"
53 
54 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
55 
56 struct it913x_state {
57  struct ite_config it913x_config;
58  u8 pid_filter_onoff;
59  bool proprietary_ir;
60  int cmd_counter;
61 };
62 
63 static u16 check_sum(u8 *p, u8 len)
64 {
65  u16 sum = 0;
66  u8 i = 1;
67  while (i < len)
68  sum += (i++ & 1) ? (*p++) << 8 : *p++;
69  return ~sum;
70 }
71 
72 static int it913x_io(struct dvb_usb_device *d, u8 mode, u8 pro,
73  u8 cmd, u32 reg, u8 addr, u8 *data, u8 len)
74 {
75  struct it913x_state *st = d->priv;
76  int ret = 0, i, buf_size = 1;
77  u8 *buff;
78  u8 rlen;
79  u16 chk_sum;
80 
81  buff = kzalloc(256, GFP_KERNEL);
82  if (!buff) {
83  info("USB Buffer Failed");
84  return -ENOMEM;
85  }
86 
87  buff[buf_size++] = pro;
88  buff[buf_size++] = cmd;
89  buff[buf_size++] = st->cmd_counter;
90 
91  switch (mode) {
92  case READ_LONG:
93  case WRITE_LONG:
94  buff[buf_size++] = len;
95  buff[buf_size++] = 2;
96  buff[buf_size++] = (reg >> 24);
97  buff[buf_size++] = (reg >> 16) & 0xff;
98  buff[buf_size++] = (reg >> 8) & 0xff;
99  buff[buf_size++] = reg & 0xff;
100  break;
101  case READ_SHORT:
102  buff[buf_size++] = addr;
103  break;
104  case WRITE_SHORT:
105  buff[buf_size++] = len;
106  buff[buf_size++] = addr;
107  buff[buf_size++] = (reg >> 8) & 0xff;
108  buff[buf_size++] = reg & 0xff;
109  break;
110  case READ_DATA:
111  case WRITE_DATA:
112  break;
113  case WRITE_CMD:
114  mode = 7;
115  break;
116  default:
117  kfree(buff);
118  return -EINVAL;
119  }
120 
121  if (mode & 1) {
122  for (i = 0; i < len ; i++)
123  buff[buf_size++] = data[i];
124  }
125  chk_sum = check_sum(&buff[1], buf_size);
126 
127  buff[buf_size++] = chk_sum >> 8;
128  buff[0] = buf_size;
129  buff[buf_size++] = (chk_sum & 0xff);
130 
131  ret = dvb_usbv2_generic_rw(d, buff, buf_size, buff, (mode & 1) ?
132  5 : len + 5);
133  if (ret < 0)
134  goto error;
135 
136  rlen = (mode & 0x1) ? 0x1 : len;
137 
138  if (mode & 1)
139  ret = buff[2];
140  else
141  memcpy(data, &buff[3], rlen);
142 
143  st->cmd_counter++;
144 
145 error: kfree(buff);
146 
147  return ret;
148 }
149 
150 static int it913x_wr_reg(struct dvb_usb_device *d, u8 pro, u32 reg , u8 data)
151 {
152  int ret;
153  u8 b[1];
154  b[0] = data;
155  ret = it913x_io(d, WRITE_LONG, pro,
156  CMD_DEMOD_WRITE, reg, 0, b, sizeof(b));
157 
158  return ret;
159 }
160 
161 static int it913x_read_reg(struct dvb_usb_device *d, u32 reg)
162 {
163  int ret;
164  u8 data[1];
165 
166  ret = it913x_io(d, READ_LONG, DEV_0,
167  CMD_DEMOD_READ, reg, 0, &data[0], sizeof(data));
168 
169  return (ret < 0) ? ret : data[0];
170 }
171 
172 static int it913x_query(struct dvb_usb_device *d, u8 pro)
173 {
174  struct it913x_state *st = d->priv;
175  int ret, i;
176  u8 data[4];
177  u8 ver;
178 
179  for (i = 0; i < 5; i++) {
180  ret = it913x_io(d, READ_LONG, pro, CMD_DEMOD_READ,
181  0x1222, 0, &data[0], 3);
182  ver = data[0];
183  if (ver > 0 && ver < 3)
184  break;
185  msleep(100);
186  }
187 
188  if (ver < 1 || ver > 2) {
189  info("Failed to identify chip version applying 1");
190  st->it913x_config.chip_ver = 0x1;
191  st->it913x_config.chip_type = 0x9135;
192  return 0;
193  }
194 
195  st->it913x_config.chip_ver = ver;
196  st->it913x_config.chip_type = (u16)(data[2] << 8) + data[1];
197 
198  info("Chip Version=%02x Chip Type=%04x", st->it913x_config.chip_ver,
199  st->it913x_config.chip_type);
200 
201  ret = it913x_io(d, READ_SHORT, pro,
202  CMD_QUERYINFO, 0, 0x1, &data[0], 4);
203 
204  st->it913x_config.firmware = (data[0] << 24) | (data[1] << 16) |
205  (data[2] << 8) | data[3];
206 
207  return ret;
208 }
209 
210 static int it913x_pid_filter_ctrl(struct dvb_usb_adapter *adap, int onoff)
211 {
212  struct dvb_usb_device *d = adap_to_d(adap);
213  struct it913x_state *st = adap_to_priv(adap);
214  int ret;
215  u8 pro = (adap->id == 0) ? DEV_0_DMOD : DEV_1_DMOD;
216 
217  mutex_lock(&d->i2c_mutex);
218 
219  deb_info(1, "PID_C (%02x)", onoff);
220 
221  ret = it913x_wr_reg(d, pro, PID_EN, st->pid_filter_onoff);
222 
223  mutex_unlock(&d->i2c_mutex);
224  return ret;
225 }
226 
227 static int it913x_pid_filter(struct dvb_usb_adapter *adap,
228  int index, u16 pid, int onoff)
229 {
230  struct dvb_usb_device *d = adap_to_d(adap);
231  struct it913x_state *st = adap_to_priv(adap);
232  int ret;
233  u8 pro = (adap->id == 0) ? DEV_0_DMOD : DEV_1_DMOD;
234 
235  mutex_lock(&d->i2c_mutex);
236 
237  deb_info(1, "PID_F (%02x)", onoff);
238 
239  ret = it913x_wr_reg(d, pro, PID_LSB, (u8)(pid & 0xff));
240 
241  ret |= it913x_wr_reg(d, pro, PID_MSB, (u8)(pid >> 8));
242 
243  ret |= it913x_wr_reg(d, pro, PID_INX_EN, (u8)onoff);
244 
245  ret |= it913x_wr_reg(d, pro, PID_INX, (u8)(index & 0x1f));
246 
247  if (d->udev->speed == USB_SPEED_HIGH && pid == 0x2000) {
248  ret |= it913x_wr_reg(d , pro, PID_EN, !onoff);
249  st->pid_filter_onoff = !onoff;
250  } else
251  st->pid_filter_onoff =
252  adap->pid_filtering;
253 
254  mutex_unlock(&d->i2c_mutex);
255  return 0;
256 }
257 
258 
259 static int it913x_return_status(struct dvb_usb_device *d)
260 {
261  struct it913x_state *st = d->priv;
262  int ret = it913x_query(d, DEV_0);
263  if (st->it913x_config.firmware > 0)
264  info("Firmware Version %d", st->it913x_config.firmware);
265 
266  return ret;
267 }
268 
269 static int it913x_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
270  int num)
271 {
272  struct dvb_usb_device *d = i2c_get_adapdata(adap);
273  static u8 data[256];
274  int ret;
275  u32 reg;
276  u8 pro;
277 
278  mutex_lock(&d->i2c_mutex);
279 
280  deb_info(2, "num of messages %d address %02x", num, msg[0].addr);
281 
282  pro = (msg[0].addr & 0x2) ? DEV_0_DMOD : 0x0;
283  pro |= (msg[0].addr & 0x20) ? DEV_1 : DEV_0;
284  memcpy(data, msg[0].buf, msg[0].len);
285  reg = (data[0] << 24) + (data[1] << 16) +
286  (data[2] << 8) + data[3];
287  if (num == 2) {
288  ret = it913x_io(d, READ_LONG, pro,
289  CMD_DEMOD_READ, reg, 0, data, msg[1].len);
290  memcpy(msg[1].buf, data, msg[1].len);
291  } else
292  ret = it913x_io(d, WRITE_LONG, pro, CMD_DEMOD_WRITE,
293  reg, 0, &data[4], msg[0].len - 4);
294 
295  mutex_unlock(&d->i2c_mutex);
296 
297  return ret;
298 }
299 
300 static u32 it913x_i2c_func(struct i2c_adapter *adapter)
301 {
302  return I2C_FUNC_I2C;
303 }
304 
305 static struct i2c_algorithm it913x_i2c_algo = {
306  .master_xfer = it913x_i2c_xfer,
307  .functionality = it913x_i2c_func,
308 };
309 
310 /* Callbacks for DVB USB */
311 #define IT913X_POLL 250
312 static int it913x_rc_query(struct dvb_usb_device *d)
313 {
314  u8 ibuf[4];
315  int ret;
316  u32 key;
317  /* Avoid conflict with frontends*/
318  mutex_lock(&d->i2c_mutex);
319 
320  ret = it913x_io(d, READ_LONG, PRO_LINK, CMD_IR_GET,
321  0, 0, &ibuf[0], sizeof(ibuf));
322 
323  if ((ibuf[2] + ibuf[3]) == 0xff) {
324  key = ibuf[2];
325  key += ibuf[0] << 16;
326  key += ibuf[1] << 8;
327  deb_info(1, "NEC Extended Key =%08x", key);
328  if (d->rc_dev != NULL)
329  rc_keydown(d->rc_dev, key, 0);
330  }
331 
332  mutex_unlock(&d->i2c_mutex);
333 
334  return ret;
335 }
336 
337 /* Firmware sets raw */
338 static const char fw_it9135_v1[] = FW_IT9135_V1;
339 static const char fw_it9135_v2[] = FW_IT9135_V2;
340 static const char fw_it9137[] = FW_IT9137;
341 
342 static void ite_get_firmware_name(struct dvb_usb_device *d,
343  const char **name)
344 {
345  struct it913x_state *st = d->priv;
346  int sw;
347  /* auto switch */
348  if (le16_to_cpu(d->udev->descriptor.idVendor) == USB_VID_KWORLD_2)
349  sw = IT9137_FW;
350  else if (st->it913x_config.chip_ver == 1)
351  sw = IT9135_V1_FW;
352  else
353  sw = IT9135_V2_FW;
354 
355  /* force switch */
356  if (dvb_usb_it913x_firmware != IT9135_AUTO)
357  sw = dvb_usb_it913x_firmware;
358 
359  switch (sw) {
360  case IT9135_V1_FW:
361  st->it913x_config.firmware_ver = 1;
362  st->it913x_config.adc_x2 = 1;
363  st->it913x_config.read_slevel = false;
364  *name = fw_it9135_v1;
365  break;
366  case IT9135_V2_FW:
367  st->it913x_config.firmware_ver = 1;
368  st->it913x_config.adc_x2 = 1;
369  st->it913x_config.read_slevel = false;
370  *name = fw_it9135_v2;
371  switch (st->it913x_config.tuner_id_0) {
372  case IT9135_61:
373  case IT9135_62:
374  break;
375  default:
376  info("Unknown tuner ID applying default 0x60");
377  case IT9135_60:
378  st->it913x_config.tuner_id_0 = IT9135_60;
379  }
380  break;
381  case IT9137_FW:
382  default:
383  st->it913x_config.firmware_ver = 0;
384  st->it913x_config.adc_x2 = 0;
385  st->it913x_config.read_slevel = true;
386  *name = fw_it9137;
387  }
388 
389  return;
390 }
391 
392 #define TS_MPEG_PKT_SIZE 188
393 #define EP_LOW 21
394 #define TS_BUFFER_SIZE_PID (EP_LOW*TS_MPEG_PKT_SIZE)
395 #define EP_HIGH 348
396 #define TS_BUFFER_SIZE_MAX (EP_HIGH*TS_MPEG_PKT_SIZE)
397 
398 static int it913x_get_stream_config(struct dvb_frontend *fe, u8 *ts_type,
399  struct usb_data_stream_properties *stream)
400 {
401  struct dvb_usb_adapter *adap = fe_to_adap(fe);
402  if (adap->pid_filtering)
403  stream->u.bulk.buffersize = TS_BUFFER_SIZE_PID;
404  else
405  stream->u.bulk.buffersize = TS_BUFFER_SIZE_MAX;
406 
407  return 0;
408 }
409 
410 static int it913x_select_config(struct dvb_usb_device *d)
411 {
412  struct it913x_state *st = d->priv;
413  int ret, reg;
414 
415  ret = it913x_return_status(d);
416  if (ret < 0)
417  return ret;
418 
419  if (st->it913x_config.chip_ver == 0x02
420  && st->it913x_config.chip_type == 0x9135)
421  reg = it913x_read_reg(d, 0x461d);
422  else
423  reg = it913x_read_reg(d, 0x461b);
424 
425  if (reg < 0)
426  return reg;
427 
428  if (reg == 0) {
429  st->it913x_config.dual_mode = 0;
430  st->it913x_config.tuner_id_0 = IT9135_38;
431  st->proprietary_ir = true;
432  } else {
433  /* TS mode */
434  reg = it913x_read_reg(d, 0x49c5);
435  if (reg < 0)
436  return reg;
437  st->it913x_config.dual_mode = reg;
438 
439  /* IR mode type */
440  reg = it913x_read_reg(d, 0x49ac);
441  if (reg < 0)
442  return reg;
443  if (reg == 5) {
444  info("Remote propriety (raw) mode");
445  st->proprietary_ir = true;
446  } else if (reg == 1) {
447  info("Remote HID mode NOT SUPPORTED");
448  st->proprietary_ir = false;
449  }
450 
451  /* Tuner_id */
452  reg = it913x_read_reg(d, 0x49d0);
453  if (reg < 0)
454  return reg;
455  st->it913x_config.tuner_id_0 = reg;
456  }
457 
458  info("Dual mode=%x Tuner Type=%x", st->it913x_config.dual_mode,
459  st->it913x_config.tuner_id_0);
460 
461  return ret;
462 }
463 
464 static int it913x_streaming_ctrl(struct dvb_frontend *fe, int onoff)
465 {
466  struct dvb_usb_adapter *adap = fe_to_adap(fe);
467  struct dvb_usb_device *d = adap_to_d(adap);
468  struct it913x_state *st = fe_to_priv(fe);
469  int ret = 0;
470  u8 pro = (adap->id == 0) ? DEV_0_DMOD : DEV_1_DMOD;
471 
472  deb_info(1, "STM (%02x)", onoff);
473 
474  if (!onoff) {
475  mutex_lock(&d->i2c_mutex);
476 
477  ret = it913x_wr_reg(d, pro, PID_RST, 0x1);
478 
479  mutex_unlock(&d->i2c_mutex);
480  st->pid_filter_onoff =
481  adap->pid_filtering;
482 
483  }
484 
485  return ret;
486 }
487 
488 static int it913x_identify_state(struct dvb_usb_device *d, const char **name)
489 {
490  struct it913x_state *st = d->priv;
491  int ret;
492  u8 reg;
493 
494  /* Read and select config */
495  ret = it913x_select_config(d);
496  if (ret < 0)
497  return ret;
498 
499  ite_get_firmware_name(d, name);
500 
501  if (st->it913x_config.firmware > 0)
502  return WARM;
503 
504  if (st->it913x_config.dual_mode) {
505  st->it913x_config.tuner_id_1 = it913x_read_reg(d, 0x49e0);
506  ret = it913x_wr_reg(d, DEV_0, GPIOH1_EN, 0x1);
507  ret |= it913x_wr_reg(d, DEV_0, GPIOH1_ON, 0x1);
508  ret |= it913x_wr_reg(d, DEV_0, GPIOH1_O, 0x1);
509  msleep(50);
510  ret |= it913x_wr_reg(d, DEV_0, GPIOH1_O, 0x0);
511  msleep(50);
512  reg = it913x_read_reg(d, GPIOH1_O);
513  if (reg == 0) {
514  ret |= it913x_wr_reg(d, DEV_0, GPIOH1_O, 0x1);
515  ret |= it913x_return_status(d);
516  if (ret != 0)
517  ret = it913x_wr_reg(d, DEV_0,
518  GPIOH1_O, 0x0);
519  }
520  }
521 
522  reg = it913x_read_reg(d, IO_MUX_POWER_CLK);
523 
524  if (st->it913x_config.dual_mode) {
525  ret |= it913x_wr_reg(d, DEV_0, 0x4bfb, CHIP2_I2C_ADDR);
526  if (st->it913x_config.firmware_ver == 1)
527  ret |= it913x_wr_reg(d, DEV_0, 0xcfff, 0x1);
528  else
529  ret |= it913x_wr_reg(d, DEV_0, CLK_O_EN, 0x1);
530  } else {
531  ret |= it913x_wr_reg(d, DEV_0, 0x4bfb, 0x0);
532  if (st->it913x_config.firmware_ver == 1)
533  ret |= it913x_wr_reg(d, DEV_0, 0xcfff, 0x0);
534  else
535  ret |= it913x_wr_reg(d, DEV_0, CLK_O_EN, 0x0);
536  }
537 
538  ret |= it913x_wr_reg(d, DEV_0, I2C_CLK, I2C_CLK_100);
539 
540  return (ret < 0) ? ret : COLD;
541 }
542 
543 static int it913x_download_firmware(struct dvb_usb_device *d,
544  const struct firmware *fw)
545 {
546  struct it913x_state *st = d->priv;
547  int ret = 0, i = 0, pos = 0;
548  u8 packet_size, min_pkt;
549  u8 *fw_data;
550 
551  ret = it913x_wr_reg(d, DEV_0, I2C_CLK, I2C_CLK_100);
552 
553  info("FRM Starting Firmware Download");
554 
555  /* Multi firmware loader */
556  /* This uses scatter write firmware headers */
557  /* The firmware must start with 03 XX 00 */
558  /* and be the extact firmware length */
559 
560  if (st->it913x_config.chip_ver == 2)
561  min_pkt = 0x11;
562  else
563  min_pkt = 0x19;
564 
565  while (i <= fw->size) {
566  if (((fw->data[i] == 0x3) && (fw->data[i + 2] == 0x0))
567  || (i == fw->size)) {
568  packet_size = i - pos;
569  if ((packet_size > min_pkt) || (i == fw->size)) {
570  fw_data = (u8 *)(fw->data + pos);
571  pos += packet_size;
572  if (packet_size > 0) {
573  ret = it913x_io(d, WRITE_DATA,
574  DEV_0, CMD_SCATTER_WRITE, 0,
575  0, fw_data, packet_size);
576  if (ret < 0)
577  break;
578  }
579  udelay(1000);
580  }
581  }
582  i++;
583  }
584 
585  if (ret < 0)
586  info("FRM Firmware Download Failed (%d)" , ret);
587  else
588  info("FRM Firmware Download Completed - Resetting Device");
589 
590  msleep(30);
591 
592  ret = it913x_io(d, WRITE_CMD, DEV_0, CMD_BOOT, 0, 0, NULL, 0);
593  if (ret < 0)
594  info("FRM Device not responding to reboot");
595 
596  ret = it913x_return_status(d);
597  if (st->it913x_config.firmware == 0) {
598  info("FRM Failed to reboot device");
599  return -ENODEV;
600  }
601 
602  msleep(30);
603 
604  ret = it913x_wr_reg(d, DEV_0, I2C_CLK, I2C_CLK_400);
605 
606  msleep(30);
607 
608  /* Tuner function */
609  if (st->it913x_config.dual_mode)
610  ret |= it913x_wr_reg(d, DEV_0_DMOD , 0xec4c, 0xa0);
611  else
612  ret |= it913x_wr_reg(d, DEV_0_DMOD , 0xec4c, 0x68);
613 
614  if ((st->it913x_config.chip_ver == 1) &&
615  (st->it913x_config.chip_type == 0x9135)) {
616  ret |= it913x_wr_reg(d, DEV_0, PADODPU, 0x0);
617  ret |= it913x_wr_reg(d, DEV_0, AGC_O_D, 0x0);
618  if (st->it913x_config.dual_mode) {
619  ret |= it913x_wr_reg(d, DEV_1, PADODPU, 0x0);
620  ret |= it913x_wr_reg(d, DEV_1, AGC_O_D, 0x0);
621  }
622  }
623 
624  return (ret < 0) ? -ENODEV : 0;
625 }
626 
627 static int it913x_name(struct dvb_usb_adapter *adap)
628 {
629  struct dvb_usb_device *d = adap_to_d(adap);
630  const char *desc = d->name;
631  char *fe_name[] = {"_1", "_2", "_3", "_4"};
632  char *name = adap->fe[0]->ops.info.name;
633 
634  strlcpy(name, desc, 128);
635  strlcat(name, fe_name[adap->id], 128);
636 
637  return 0;
638 }
639 
640 static int it913x_frontend_attach(struct dvb_usb_adapter *adap)
641 {
642  struct dvb_usb_device *d = adap_to_d(adap);
643  struct it913x_state *st = d->priv;
644  int ret = 0;
645  u8 adap_addr = I2C_BASE_ADDR + (adap->id << 5);
646  u16 ep_size = adap->stream.buf_size / 4;
647  u8 pkt_size = 0x80;
648 
649  if (d->udev->speed != USB_SPEED_HIGH)
650  pkt_size = 0x10;
651 
652  st->it913x_config.adf = it913x_read_reg(d, IO_MUX_POWER_CLK);
653 
654  adap->fe[0] = dvb_attach(it913x_fe_attach,
655  &d->i2c_adap, adap_addr, &st->it913x_config);
656 
657  if (adap->id == 0 && adap->fe[0]) {
658  it913x_wr_reg(d, DEV_0_DMOD, MP2_SW_RST, 0x1);
659  it913x_wr_reg(d, DEV_0_DMOD, MP2IF2_SW_RST, 0x1);
660  it913x_wr_reg(d, DEV_0, EP0_TX_EN, 0x0f);
661  it913x_wr_reg(d, DEV_0, EP0_TX_NAK, 0x1b);
662  it913x_wr_reg(d, DEV_0, EP0_TX_EN, 0x2f);
663  it913x_wr_reg(d, DEV_0, EP4_TX_LEN_LSB,
664  ep_size & 0xff);
665  it913x_wr_reg(d, DEV_0, EP4_TX_LEN_MSB, ep_size >> 8);
666  ret = it913x_wr_reg(d, DEV_0, EP4_MAX_PKT, pkt_size);
667  } else if (adap->id == 1 && adap->fe[0]) {
668  it913x_wr_reg(d, DEV_0, EP0_TX_EN, 0x6f);
669  it913x_wr_reg(d, DEV_0, EP5_TX_LEN_LSB,
670  ep_size & 0xff);
671  it913x_wr_reg(d, DEV_0, EP5_TX_LEN_MSB, ep_size >> 8);
672  it913x_wr_reg(d, DEV_0, EP5_MAX_PKT, pkt_size);
673  it913x_wr_reg(d, DEV_0_DMOD, MP2IF2_EN, 0x1);
674  it913x_wr_reg(d, DEV_1_DMOD, MP2IF_SERIAL, 0x1);
675  it913x_wr_reg(d, DEV_1, TOP_HOSTB_SER_MODE, 0x1);
676  it913x_wr_reg(d, DEV_0_DMOD, TSIS_ENABLE, 0x1);
677  it913x_wr_reg(d, DEV_0_DMOD, MP2_SW_RST, 0x0);
678  it913x_wr_reg(d, DEV_0_DMOD, MP2IF2_SW_RST, 0x0);
679  it913x_wr_reg(d, DEV_0_DMOD, MP2IF2_HALF_PSB, 0x0);
680  it913x_wr_reg(d, DEV_0_DMOD, MP2IF_STOP_EN, 0x1);
681  it913x_wr_reg(d, DEV_1_DMOD, MPEG_FULL_SPEED, 0x0);
682  ret = it913x_wr_reg(d, DEV_1_DMOD, MP2IF_STOP_EN, 0x0);
683  } else
684  return -ENODEV;
685 
686  ret |= it913x_name(adap);
687 
688  return ret;
689 }
690 
691 /* DVB USB Driver */
692 static int it913x_get_rc_config(struct dvb_usb_device *d, struct dvb_usb_rc *rc)
693 {
694  struct it913x_state *st = d->priv;
695 
696  if (st->proprietary_ir == false) {
697  rc->map_name = NULL;
698  return 0;
699  }
700 
701  rc->allowed_protos = RC_TYPE_NEC;
702  rc->query = it913x_rc_query;
703  rc->interval = 250;
704 
705  return 0;
706 }
707 
708 static int it913x_get_adapter_count(struct dvb_usb_device *d)
709 {
710  struct it913x_state *st = d->priv;
711  if (st->it913x_config.dual_mode)
712  return 2;
713  return 1;
714 }
715 
716 static struct dvb_usb_device_properties it913x_properties = {
717  .driver_name = KBUILD_MODNAME,
718  .owner = THIS_MODULE,
719  .bInterfaceNumber = 0,
720  .generic_bulk_ctrl_endpoint = 0x02,
721  .generic_bulk_ctrl_endpoint_response = 0x81,
722 
723  .adapter_nr = adapter_nr,
724  .size_of_priv = sizeof(struct it913x_state),
725 
726  .identify_state = it913x_identify_state,
727  .i2c_algo = &it913x_i2c_algo,
728 
729  .download_firmware = it913x_download_firmware,
730 
731  .frontend_attach = it913x_frontend_attach,
732  .get_rc_config = it913x_get_rc_config,
733  .get_stream_config = it913x_get_stream_config,
734  .get_adapter_count = it913x_get_adapter_count,
735  .streaming_ctrl = it913x_streaming_ctrl,
736 
737 
738  .adapter = {
739  {
740  .caps = DVB_USB_ADAP_HAS_PID_FILTER|
741  DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
742  .pid_filter_count = 32,
743  .pid_filter = it913x_pid_filter,
744  .pid_filter_ctrl = it913x_pid_filter_ctrl,
745  .stream =
746  DVB_USB_STREAM_BULK(0x84, 10, TS_BUFFER_SIZE_MAX),
747  },
748  {
749  .caps = DVB_USB_ADAP_HAS_PID_FILTER|
750  DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
751  .pid_filter_count = 32,
752  .pid_filter = it913x_pid_filter,
753  .pid_filter_ctrl = it913x_pid_filter_ctrl,
754  .stream =
755  DVB_USB_STREAM_BULK(0x85, 10, TS_BUFFER_SIZE_MAX),
756  }
757  }
758 };
759 
760 static const struct usb_device_id it913x_id_table[] = {
761  { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_UB499_2T_T09,
762  &it913x_properties, "Kworld UB499-2T T09(IT9137)",
763  RC_MAP_IT913X_V1) },
764  { DVB_USB_DEVICE(USB_VID_ITETECH, USB_PID_ITETECH_IT9135,
765  &it913x_properties, "ITE 9135 Generic",
766  RC_MAP_IT913X_V1) },
767  { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_SVEON_STV22_IT9137,
768  &it913x_properties, "Sveon STV22 Dual DVB-T HDTV(IT9137)",
769  RC_MAP_IT913X_V1) },
770  { DVB_USB_DEVICE(USB_VID_ITETECH, USB_PID_ITETECH_IT9135_9005,
771  &it913x_properties, "ITE 9135(9005) Generic",
772  RC_MAP_IT913X_V2) },
773  { DVB_USB_DEVICE(USB_VID_ITETECH, USB_PID_ITETECH_IT9135_9006,
774  &it913x_properties, "ITE 9135(9006) Generic",
775  RC_MAP_IT913X_V1) },
776  {} /* Terminating entry */
777 };
778 
779 MODULE_DEVICE_TABLE(usb, it913x_id_table);
780 
781 static struct usb_driver it913x_driver = {
782  .name = KBUILD_MODNAME,
783  .probe = dvb_usbv2_probe,
784  .disconnect = dvb_usbv2_disconnect,
785  .suspend = dvb_usbv2_suspend,
786  .resume = dvb_usbv2_resume,
787  .id_table = it913x_id_table,
788 };
789 
790 module_usb_driver(it913x_driver);
791 
792 MODULE_AUTHOR("Malcolm Priestley <[email protected]>");
793 MODULE_DESCRIPTION("it913x USB 2 Driver");
794 MODULE_VERSION("1.32");
795 MODULE_LICENSE("GPL");
796 MODULE_FIRMWARE(FW_IT9135_V1);
797 MODULE_FIRMWARE(FW_IT9135_V2);
798 MODULE_FIRMWARE(FW_IT9137);
799 
Generated on Thu Jan 10 2013 13:51:13 for Linux Kernel by   doxygen 1.8.2