Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
dibusb-common.c
Go to the documentation of this file.
1 /* Common methods for dibusb-based-receivers.
2  *
3  * Copyright (C) 2004-5 Patrick Boettcher ([email protected])
4  *
5  * This program is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License as published by the Free
7  * Software Foundation, version 2.
8  *
9  * see Documentation/dvb/README.dvb-usb for more information
10  */
11 #include "dibusb.h"
12 
13 static int debug;
14 module_param(debug, int, 0644);
15 MODULE_PARM_DESC(debug, "set debugging level (1=info (|-able))." DVB_USB_DEBUG_STATUS);
16 MODULE_LICENSE("GPL");
17 
18 #define deb_info(args...) dprintk(debug,0x01,args)
19 
20 /* common stuff used by the different dibusb modules */
22 {
23  if (adap->priv != NULL) {
24  struct dibusb_state *st = adap->priv;
25  if (st->ops.fifo_ctrl != NULL)
26  if (st->ops.fifo_ctrl(adap->fe_adap[0].fe, onoff)) {
27  err("error while controlling the fifo of the demod.");
28  return -ENODEV;
29  }
30  }
31  return 0;
32 }
34 
35 int dibusb_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid, int onoff)
36 {
37  if (adap->priv != NULL) {
38  struct dibusb_state *st = adap->priv;
39  if (st->ops.pid_ctrl != NULL)
40  st->ops.pid_ctrl(adap->fe_adap[0].fe,
41  index, pid, onoff);
42  }
43  return 0;
44 }
46 
48 {
49  if (adap->priv != NULL) {
50  struct dibusb_state *st = adap->priv;
51  if (st->ops.pid_parse != NULL)
52  if (st->ops.pid_parse(adap->fe_adap[0].fe, onoff) < 0)
53  err("could not handle pid_parser");
54  }
55  return 0;
56 }
58 
60 {
61  u8 b[3];
62  int ret;
63  b[0] = DIBUSB_REQ_SET_IOCTL;
66  ret = dvb_usb_generic_write(d,b,3);
67  msleep(10);
68  return ret;
69 }
71 
73 {
74  u8 b[3] = { 0 };
75  int ret;
76 
77  if ((ret = dibusb_streaming_ctrl(adap,onoff)) < 0)
78  return ret;
79 
80  if (onoff) {
82  b[1] = 0x00;
83  if ((ret = dvb_usb_generic_write(adap->dev,b,2)) < 0)
84  return ret;
85  }
86 
87  b[0] = DIBUSB_REQ_SET_IOCTL;
89  return dvb_usb_generic_write(adap->dev,b,3);
90 }
92 
94 {
95  if (onoff) {
97  return dvb_usb_generic_write(d,b,3);
98  } else
99  return 0;
100 }
102 
103 static int dibusb_i2c_msg(struct dvb_usb_device *d, u8 addr,
104  u8 *wbuf, u16 wlen, u8 *rbuf, u16 rlen)
105 {
106  u8 sndbuf[wlen+4]; /* lead(1) devaddr,direction(1) addr(2) data(wlen) (len(2) (when reading)) */
107  /* write only ? */
108  int wo = (rbuf == NULL || rlen == 0),
109  len = 2 + wlen + (wo ? 0 : 2);
110 
111  sndbuf[0] = wo ? DIBUSB_REQ_I2C_WRITE : DIBUSB_REQ_I2C_READ;
112  sndbuf[1] = (addr << 1) | (wo ? 0 : 1);
113 
114  memcpy(&sndbuf[2],wbuf,wlen);
115 
116  if (!wo) {
117  sndbuf[wlen+2] = (rlen >> 8) & 0xff;
118  sndbuf[wlen+3] = rlen & 0xff;
119  }
120 
121  return dvb_usb_generic_rw(d,sndbuf,len,rbuf,rlen,0);
122 }
123 
124 /*
125  * I2C master xfer function
126  */
127 static int dibusb_i2c_xfer(struct i2c_adapter *adap,struct i2c_msg msg[],int num)
128 {
129  struct dvb_usb_device *d = i2c_get_adapdata(adap);
130  int i;
131 
132  if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
133  return -EAGAIN;
134 
135  for (i = 0; i < num; i++) {
136  /* write/read request */
137  if (i+1 < num && (msg[i].flags & I2C_M_RD) == 0
138  && (msg[i+1].flags & I2C_M_RD)) {
139  if (dibusb_i2c_msg(d, msg[i].addr, msg[i].buf,msg[i].len,
140  msg[i+1].buf,msg[i+1].len) < 0)
141  break;
142  i++;
143  } else if ((msg[i].flags & I2C_M_RD) == 0) {
144  if (dibusb_i2c_msg(d, msg[i].addr, msg[i].buf,msg[i].len,NULL,0) < 0)
145  break;
146  } else if (msg[i].addr != 0x50) {
147  /* 0x50 is the address of the eeprom - we need to protect it
148  * from dibusb's bad i2c implementation: reads without
149  * writing the offset before are forbidden */
150  if (dibusb_i2c_msg(d, msg[i].addr, NULL, 0, msg[i].buf, msg[i].len) < 0)
151  break;
152  }
153  }
154 
155  mutex_unlock(&d->i2c_mutex);
156  return i;
157 }
158 
159 static u32 dibusb_i2c_func(struct i2c_adapter *adapter)
160 {
161  return I2C_FUNC_I2C;
162 }
163 
165  .master_xfer = dibusb_i2c_xfer,
166  .functionality = dibusb_i2c_func,
167 };
168 EXPORT_SYMBOL(dibusb_i2c_algo);
169 
171 {
172  u8 wbuf[1] = { offs };
173  return dibusb_i2c_msg(d, 0x50, wbuf, 1, val, 1);
174 }
176 
177 /* 3000MC/P stuff */
178 // Config Adjacent channels Perf -cal22
179 static struct dibx000_agc_config dib3000p_mt2060_agc_config = {
180  .band_caps = BAND_VHF | BAND_UHF,
181  .setup = (1 << 8) | (5 << 5) | (1 << 4) | (1 << 3) | (0 << 2) | (2 << 0),
182 
183  .agc1_max = 48497,
184  .agc1_min = 23593,
185  .agc2_max = 46531,
186  .agc2_min = 24904,
187 
188  .agc1_pt1 = 0x65,
189  .agc1_pt2 = 0x69,
190 
191  .agc1_slope1 = 0x51,
192  .agc1_slope2 = 0x27,
193 
194  .agc2_pt1 = 0,
195  .agc2_pt2 = 0x33,
196 
197  .agc2_slope1 = 0x35,
198  .agc2_slope2 = 0x37,
199 };
200 
201 static struct dib3000mc_config stk3000p_dib3000p_config = {
202  &dib3000p_mt2060_agc_config,
203 
204  .max_time = 0x196,
205  .ln_adc_level = 0x1cc7,
206 
207  .output_mpeg2_in_188_bytes = 1,
208 
209  .agc_command1 = 1,
210  .agc_command2 = 1,
211 };
212 
213 static struct dibx000_agc_config dib3000p_panasonic_agc_config = {
214  .band_caps = BAND_VHF | BAND_UHF,
215  .setup = (1 << 8) | (5 << 5) | (1 << 4) | (1 << 3) | (0 << 2) | (2 << 0),
216 
217  .agc1_max = 56361,
218  .agc1_min = 22282,
219  .agc2_max = 47841,
220  .agc2_min = 36045,
221 
222  .agc1_pt1 = 0x3b,
223  .agc1_pt2 = 0x6b,
224 
225  .agc1_slope1 = 0x55,
226  .agc1_slope2 = 0x1d,
227 
228  .agc2_pt1 = 0,
229  .agc2_pt2 = 0x0a,
230 
231  .agc2_slope1 = 0x95,
232  .agc2_slope2 = 0x1e,
233 };
234 
235 #if defined(CONFIG_DVB_DIB3000MC) || \
236  (defined(CONFIG_DVB_DIB3000MC_MODULE) && defined(MODULE))
237 
238 static struct dib3000mc_config mod3000p_dib3000p_config = {
239  &dib3000p_panasonic_agc_config,
240 
241  .max_time = 0x51,
242  .ln_adc_level = 0x1cc7,
243 
244  .output_mpeg2_in_188_bytes = 1,
245 
246  .agc_command1 = 1,
247  .agc_command2 = 1,
248 };
249 
251 {
252  if (adap->dev->udev->descriptor.idVendor == USB_VID_LITEON &&
253  adap->dev->udev->descriptor.idProduct ==
255  msleep(1000);
256  }
257 
258  adap->fe_adap[0].fe = dvb_attach(dib3000mc_attach,
259  &adap->dev->i2c_adap,
261  &mod3000p_dib3000p_config);
262  if ((adap->fe_adap[0].fe) == NULL)
263  adap->fe_adap[0].fe = dvb_attach(dib3000mc_attach,
264  &adap->dev->i2c_adap,
266  &mod3000p_dib3000p_config);
267  if ((adap->fe_adap[0].fe) != NULL) {
268  if (adap->priv != NULL) {
269  struct dibusb_state *st = adap->priv;
270  st->ops.pid_parse = dib3000mc_pid_parse;
271  st->ops.pid_ctrl = dib3000mc_pid_control;
272  }
273  return 0;
274  }
275  return -ENODEV;
276 }
278 
279 static struct mt2060_config stk3000p_mt2060_config = {
280  0x60
281 };
282 
284 {
285  struct dibusb_state *st = adap->priv;
286  u8 a,b;
287  u16 if1 = 1220;
288  struct i2c_adapter *tun_i2c;
289 
290  // First IF calibration for Liteon Sticks
291  if (adap->dev->udev->descriptor.idVendor == USB_VID_LITEON &&
292  adap->dev->udev->descriptor.idProduct == USB_PID_LITEON_DVB_T_WARM) {
293 
294  dibusb_read_eeprom_byte(adap->dev,0x7E,&a);
295  dibusb_read_eeprom_byte(adap->dev,0x7F,&b);
296 
297  if (a == 0x00)
298  if1 += b;
299  else if (a == 0x80)
300  if1 -= b;
301  else
302  warn("LITE-ON DVB-T: Strange IF1 calibration :%2X %2X\n", a, b);
303 
304  } else if (adap->dev->udev->descriptor.idVendor == USB_VID_DIBCOM &&
305  adap->dev->udev->descriptor.idProduct == USB_PID_DIBCOM_MOD3001_WARM) {
306  u8 desc;
307  dibusb_read_eeprom_byte(adap->dev, 7, &desc);
308  if (desc == 2) {
309  a = 127;
310  do {
311  dibusb_read_eeprom_byte(adap->dev, a, &desc);
312  a--;
313  } while (a > 7 && (desc == 0xff || desc == 0x00));
314  if (desc & 0x80)
315  if1 -= (0xff - desc);
316  else
317  if1 += desc;
318  }
319  }
320 
321  tun_i2c = dib3000mc_get_tuner_i2c_master(adap->fe_adap[0].fe, 1);
322  if (dvb_attach(mt2060_attach, adap->fe_adap[0].fe, tun_i2c, &stk3000p_mt2060_config, if1) == NULL) {
323  /* not found - use panasonic pll parameters */
324  if (dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x60, tun_i2c, DVB_PLL_ENV57H1XD5) == NULL)
325  return -ENOMEM;
326  } else {
327  st->mt2060_present = 1;
328  /* set the correct parameters for the dib3000p */
329  dib3000mc_set_config(adap->fe_adap[0].fe, &stk3000p_dib3000p_config);
330  }
331  return 0;
332 }
334 #endif
335 
336 /*
337  * common remote control stuff
338  */
340  /* Key codes for the little Artec T1/Twinhan/HAMA/ remote. */
341  { 0x0016, KEY_POWER },
342  { 0x0010, KEY_MUTE },
343  { 0x0003, KEY_1 },
344  { 0x0001, KEY_2 },
345  { 0x0006, KEY_3 },
346  { 0x0009, KEY_4 },
347  { 0x001d, KEY_5 },
348  { 0x001f, KEY_6 },
349  { 0x000d, KEY_7 },
350  { 0x0019, KEY_8 },
351  { 0x001b, KEY_9 },
352  { 0x0015, KEY_0 },
353  { 0x0005, KEY_CHANNELUP },
354  { 0x0002, KEY_CHANNELDOWN },
355  { 0x001e, KEY_VOLUMEUP },
356  { 0x000a, KEY_VOLUMEDOWN },
357  { 0x0011, KEY_RECORD },
358  { 0x0017, KEY_FAVORITES }, /* Heart symbol - Channel list. */
359  { 0x0014, KEY_PLAY },
360  { 0x001a, KEY_STOP },
361  { 0x0040, KEY_REWIND },
362  { 0x0012, KEY_FASTFORWARD },
363  { 0x000e, KEY_PREVIOUS }, /* Recall - Previous channel. */
364  { 0x004c, KEY_PAUSE },
365  { 0x004d, KEY_SCREEN }, /* Full screen mode. */
366  { 0x0054, KEY_AUDIO }, /* MTS - Switch to secondary audio. */
367  /* additional keys TwinHan VisionPlus, the Artec seemingly not have */
368  { 0x000c, KEY_CANCEL }, /* Cancel */
369  { 0x001c, KEY_EPG }, /* EPG */
370  { 0x0000, KEY_TAB }, /* Tab */
371  { 0x0048, KEY_INFO }, /* Preview */
372  { 0x0004, KEY_LIST }, /* RecordList */
373  { 0x000f, KEY_TEXT }, /* Teletext */
374  /* Key codes for the KWorld/ADSTech/JetWay remote. */
375  { 0x8612, KEY_POWER },
376  { 0x860f, KEY_SELECT }, /* source */
377  { 0x860c, KEY_UNKNOWN }, /* scan */
378  { 0x860b, KEY_EPG },
379  { 0x8610, KEY_MUTE },
380  { 0x8601, KEY_1 },
381  { 0x8602, KEY_2 },
382  { 0x8603, KEY_3 },
383  { 0x8604, KEY_4 },
384  { 0x8605, KEY_5 },
385  { 0x8606, KEY_6 },
386  { 0x8607, KEY_7 },
387  { 0x8608, KEY_8 },
388  { 0x8609, KEY_9 },
389  { 0x860a, KEY_0 },
390  { 0x8618, KEY_ZOOM },
391  { 0x861c, KEY_UNKNOWN }, /* preview */
392  { 0x8613, KEY_UNKNOWN }, /* snap */
393  { 0x8600, KEY_UNDO },
394  { 0x861d, KEY_RECORD },
395  { 0x860d, KEY_STOP },
396  { 0x860e, KEY_PAUSE },
397  { 0x8616, KEY_PLAY },
398  { 0x8611, KEY_BACK },
399  { 0x8619, KEY_FORWARD },
400  { 0x8614, KEY_UNKNOWN }, /* pip */
401  { 0x8615, KEY_ESC },
402  { 0x861a, KEY_UP },
403  { 0x861e, KEY_DOWN },
404  { 0x861f, KEY_LEFT },
405  { 0x861b, KEY_RIGHT },
406 
407  /* Key codes for the DiBcom MOD3000 remote. */
408  { 0x8000, KEY_MUTE },
409  { 0x8001, KEY_TEXT },
410  { 0x8002, KEY_HOME },
411  { 0x8003, KEY_POWER },
412 
413  { 0x8004, KEY_RED },
414  { 0x8005, KEY_GREEN },
415  { 0x8006, KEY_YELLOW },
416  { 0x8007, KEY_BLUE },
417 
418  { 0x8008, KEY_DVD },
419  { 0x8009, KEY_AUDIO },
420  { 0x800a, KEY_IMAGES }, /* Pictures */
421  { 0x800b, KEY_VIDEO },
422 
423  { 0x800c, KEY_BACK },
424  { 0x800d, KEY_UP },
425  { 0x800e, KEY_RADIO },
426  { 0x800f, KEY_EPG },
427 
428  { 0x8010, KEY_LEFT },
429  { 0x8011, KEY_OK },
430  { 0x8012, KEY_RIGHT },
431  { 0x8013, KEY_UNKNOWN }, /* SAP */
432 
433  { 0x8014, KEY_TV },
434  { 0x8015, KEY_DOWN },
435  { 0x8016, KEY_MENU }, /* DVD Menu */
436  { 0x8017, KEY_LAST },
437 
438  { 0x8018, KEY_RECORD },
439  { 0x8019, KEY_STOP },
440  { 0x801a, KEY_PAUSE },
441  { 0x801b, KEY_PLAY },
442 
443  { 0x801c, KEY_PREVIOUS },
444  { 0x801d, KEY_REWIND },
445  { 0x801e, KEY_FASTFORWARD },
446  { 0x801f, KEY_NEXT},
447 
448  { 0x8040, KEY_1 },
449  { 0x8041, KEY_2 },
450  { 0x8042, KEY_3 },
451  { 0x8043, KEY_CHANNELUP },
452 
453  { 0x8044, KEY_4 },
454  { 0x8045, KEY_5 },
455  { 0x8046, KEY_6 },
456  { 0x8047, KEY_CHANNELDOWN },
457 
458  { 0x8048, KEY_7 },
459  { 0x8049, KEY_8 },
460  { 0x804a, KEY_9 },
461  { 0x804b, KEY_VOLUMEUP },
462 
463  { 0x804c, KEY_CLEAR },
464  { 0x804d, KEY_0 },
465  { 0x804e, KEY_ENTER },
466  { 0x804f, KEY_VOLUMEDOWN },
467 };
468 EXPORT_SYMBOL(rc_map_dibusb_table);
469 
471 {
473  dvb_usb_generic_rw(d,&cmd,1,key,5,0);
474  dvb_usb_nec_rc_key_to_event(d,key,event,state);
475  if (key[0] != 0)
476  deb_info("key: %*ph\n", 5, key);
477  return 0;
478 }