?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6
[wrt350n-kernel.git] / drivers / media / video / tveeprom.c
blobfde05a28cafe905f4c76c12582f2be823f3d80d1
1 /*
2 * tveeprom - eeprom decoder for tvcard configuration eeproms
3 *
4 * Data and decoding routines shamelessly borrowed from bttv-cards.c
5 * eeprom access routine shamelessly borrowed from bttv-if.c
6 * which are:
7
8 Copyright (C) 1996,97,98 Ralph Metzler (rjkm@thp.uni-koeln.de)
9 & Marcus Metzler (mocm@thp.uni-koeln.de)
10 (c) 1999-2001 Gerd Knorr <kraxel@goldbach.in-berlin.de>
11
12 * Adjustments to fit a more general model and all bugs:
13
14 Copyright (C) 2003 John Klar <linpvr at projectplasma.com>
15
16 * This program is free software; you can redistribute it and/or modify
17 * it under the terms of the GNU General Public License as published by
18 * the Free Software Foundation; either version 2 of the License, or
19 * (at your option) any later version.
20 *
21 * This program is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 * GNU General Public License for more details.
25 *
26 * You should have received a copy of the GNU General Public License
27 * along with this program; if not, write to the Free Software
28 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
29 */
30
31
32 #include <linux/module.h>
33 #include <linux/errno.h>
34 #include <linux/kernel.h>
35 #include <linux/init.h>
36 #include <linux/types.h>
37 #include <linux/videodev.h>
38 #include <linux/i2c.h>
39
40 #include <media/tuner.h>
41 #include <media/tveeprom.h>
42 #include <media/v4l2-common.h>
43 #include <media/audiochip.h>
44
45 MODULE_DESCRIPTION("i2c Hauppauge eeprom decoder driver");
46 MODULE_AUTHOR("John Klar");
47 MODULE_LICENSE("GPL");
48
49 static int debug;
50 module_param(debug, int, 0644);
51 MODULE_PARM_DESC(debug, "Debug level (0-1)");
52
53 #define STRM(array, i) \
54 (i < sizeof(array) / sizeof(char *) ? array[i] : "unknown")
55
56 #define tveeprom_info(fmt, arg...) \
57 v4l_printk(KERN_INFO, "tveeprom", c->adapter, c->addr, fmt , ## arg)
58 #define tveeprom_warn(fmt, arg...) \
59 v4l_printk(KERN_WARNING, "tveeprom", c->adapter, c->addr, fmt , ## arg)
60 #define tveeprom_dbg(fmt, arg...) do { \
61 if (debug) \
62 v4l_printk(KERN_DEBUG, "tveeprom", \
63 c->adapter, c->addr, fmt , ## arg); \
64 } while (0)
65
66 /*
67 * The Hauppauge eeprom uses an 8bit field to determine which
68 * tuner formats the tuner supports.
69 */
70 static struct HAUPPAUGE_TUNER_FMT
71 {
72 int id;
73 char *name;
74 }
75 hauppauge_tuner_fmt[] =
76 {
77 { V4L2_STD_UNKNOWN, " UNKNOWN" },
78 { V4L2_STD_UNKNOWN, " FM" },
79 { V4L2_STD_B|V4L2_STD_GH, " PAL(B/G)" },
80 { V4L2_STD_MN, " NTSC(M)" },
81 { V4L2_STD_PAL_I, " PAL(I)" },
82 { V4L2_STD_SECAM_L|V4L2_STD_SECAM_LC, " SECAM(L/L')" },
83 { V4L2_STD_DK, " PAL(D/D1/K)" },
84 { V4L2_STD_ATSC, " ATSC/DVB Digital" },
85 };
86
87 /* This is the full list of possible tuners. Many thanks to Hauppauge for
88 supplying this information. Note that many tuners where only used for
89 testing and never made it to the outside world. So you will only see
90 a subset in actual produced cards. */
91 static struct HAUPPAUGE_TUNER
92 {
93 int id;
94 char *name;
95 }
96 hauppauge_tuner[] =
97 {
98 /* 0-9 */
99 { TUNER_ABSENT, "None" },
100 { TUNER_ABSENT, "External" },
101 { TUNER_ABSENT, "Unspecified" },
102 { TUNER_PHILIPS_PAL, "Philips FI1216" },
103 { TUNER_PHILIPS_SECAM, "Philips FI1216MF" },
104 { TUNER_PHILIPS_NTSC, "Philips FI1236" },
105 { TUNER_PHILIPS_PAL_I, "Philips FI1246" },
106 { TUNER_PHILIPS_PAL_DK, "Philips FI1256" },
107 { TUNER_PHILIPS_PAL, "Philips FI1216 MK2" },
108 { TUNER_PHILIPS_SECAM, "Philips FI1216MF MK2" },
109 /* 10-19 */
110 { TUNER_PHILIPS_NTSC, "Philips FI1236 MK2" },
111 { TUNER_PHILIPS_PAL_I, "Philips FI1246 MK2" },
112 { TUNER_PHILIPS_PAL_DK, "Philips FI1256 MK2" },
113 { TUNER_TEMIC_NTSC, "Temic 4032FY5" },
114 { TUNER_TEMIC_PAL, "Temic 4002FH5" },
115 { TUNER_TEMIC_PAL_I, "Temic 4062FY5" },
116 { TUNER_PHILIPS_PAL, "Philips FR1216 MK2" },
117 { TUNER_PHILIPS_SECAM, "Philips FR1216MF MK2" },
118 { TUNER_PHILIPS_NTSC, "Philips FR1236 MK2" },
119 { TUNER_PHILIPS_PAL_I, "Philips FR1246 MK2" },
120 /* 20-29 */
121 { TUNER_PHILIPS_PAL_DK, "Philips FR1256 MK2" },
122 { TUNER_PHILIPS_PAL, "Philips FM1216" },
123 { TUNER_PHILIPS_SECAM, "Philips FM1216MF" },
124 { TUNER_PHILIPS_NTSC, "Philips FM1236" },
125 { TUNER_PHILIPS_PAL_I, "Philips FM1246" },
126 { TUNER_PHILIPS_PAL_DK, "Philips FM1256" },
127 { TUNER_TEMIC_4036FY5_NTSC, "Temic 4036FY5" },
128 { TUNER_ABSENT, "Samsung TCPN9082D" },
129 { TUNER_ABSENT, "Samsung TCPM9092P" },
130 { TUNER_TEMIC_4006FH5_PAL, "Temic 4006FH5" },
131 /* 30-39 */
132 { TUNER_ABSENT, "Samsung TCPN9085D" },
133 { TUNER_ABSENT, "Samsung TCPB9085P" },
134 { TUNER_ABSENT, "Samsung TCPL9091P" },
135 { TUNER_TEMIC_4039FR5_NTSC, "Temic 4039FR5" },
136 { TUNER_PHILIPS_FQ1216ME, "Philips FQ1216 ME" },
137 { TUNER_TEMIC_4066FY5_PAL_I, "Temic 4066FY5" },
138 { TUNER_PHILIPS_NTSC, "Philips TD1536" },
139 { TUNER_PHILIPS_NTSC, "Philips TD1536D" },
140 { TUNER_PHILIPS_NTSC, "Philips FMR1236" }, /* mono radio */
141 { TUNER_ABSENT, "Philips FI1256MP" },
142 /* 40-49 */
143 { TUNER_ABSENT, "Samsung TCPQ9091P" },
144 { TUNER_TEMIC_4006FN5_MULTI_PAL, "Temic 4006FN5" },
145 { TUNER_TEMIC_4009FR5_PAL, "Temic 4009FR5" },
146 { TUNER_TEMIC_4046FM5, "Temic 4046FM5" },
147 { TUNER_TEMIC_4009FN5_MULTI_PAL_FM, "Temic 4009FN5" },
148 { TUNER_ABSENT, "Philips TD1536D FH 44"},
149 { TUNER_LG_NTSC_FM, "LG TP18NSR01F"},
150 { TUNER_LG_PAL_FM, "LG TP18PSB01D"},
151 { TUNER_LG_PAL, "LG TP18PSB11D"},
152 { TUNER_LG_PAL_I_FM, "LG TAPC-I001D"},
153 /* 50-59 */
154 { TUNER_LG_PAL_I, "LG TAPC-I701D"},
155 { TUNER_ABSENT, "Temic 4042FI5"},
156 { TUNER_MICROTUNE_4049FM5, "Microtune 4049 FM5"},
157 { TUNER_ABSENT, "LG TPI8NSR11F"},
158 { TUNER_ABSENT, "Microtune 4049 FM5 Alt I2C"},
159 { TUNER_PHILIPS_FM1216ME_MK3, "Philips FQ1216ME MK3"},
160 { TUNER_ABSENT, "Philips FI1236 MK3"},
161 { TUNER_PHILIPS_FM1216ME_MK3, "Philips FM1216 ME MK3"},
162 { TUNER_PHILIPS_FM1236_MK3, "Philips FM1236 MK3"},
163 { TUNER_ABSENT, "Philips FM1216MP MK3"},
164 /* 60-69 */
165 { TUNER_PHILIPS_FM1216ME_MK3, "LG S001D MK3"},
166 { TUNER_ABSENT, "LG M001D MK3"},
167 { TUNER_PHILIPS_FM1216ME_MK3, "LG S701D MK3"},
168 { TUNER_ABSENT, "LG M701D MK3"},
169 { TUNER_ABSENT, "Temic 4146FM5"},
170 { TUNER_ABSENT, "Temic 4136FY5"},
171 { TUNER_ABSENT, "Temic 4106FH5"},
172 { TUNER_ABSENT, "Philips FQ1216LMP MK3"},
173 { TUNER_LG_NTSC_TAPE, "LG TAPE H001F MK3"},
174 { TUNER_LG_NTSC_TAPE, "LG TAPE H701F MK3"},
175 /* 70-79 */
176 { TUNER_ABSENT, "LG TALN H200T"},
177 { TUNER_ABSENT, "LG TALN H250T"},
178 { TUNER_ABSENT, "LG TALN M200T"},
179 { TUNER_ABSENT, "LG TALN Z200T"},
180 { TUNER_ABSENT, "LG TALN S200T"},
181 { TUNER_ABSENT, "Thompson DTT7595"},
182 { TUNER_ABSENT, "Thompson DTT7592"},
183 { TUNER_ABSENT, "Silicon TDA8275C1 8290"},
184 { TUNER_ABSENT, "Silicon TDA8275C1 8290 FM"},
185 { TUNER_ABSENT, "Thompson DTT757"},
186 /* 80-89 */
187 { TUNER_PHILIPS_FM1216ME_MK3, "Philips FQ1216LME MK3"},
188 { TUNER_LG_PAL_NEW_TAPC, "LG TAPC G701D"},
189 { TUNER_LG_NTSC_NEW_TAPC, "LG TAPC H791F"},
190 { TUNER_LG_PAL_NEW_TAPC, "TCL 2002MB 3"},
191 { TUNER_LG_PAL_NEW_TAPC, "TCL 2002MI 3"},
192 { TUNER_TCL_2002N, "TCL 2002N 6A"},
193 { TUNER_PHILIPS_FM1236_MK3, "Philips FQ1236 MK3"},
194 { TUNER_SAMSUNG_TCPN_2121P30A, "Samsung TCPN 2121P30A"},
195 { TUNER_ABSENT, "Samsung TCPE 4121P30A"},
196 { TUNER_PHILIPS_FM1216ME_MK3, "TCL MFPE05 2"},
197 /* 90-99 */
198 { TUNER_ABSENT, "LG TALN H202T"},
199 { TUNER_PHILIPS_FQ1216AME_MK4, "Philips FQ1216AME MK4"},
200 { TUNER_PHILIPS_FQ1236A_MK4, "Philips FQ1236A MK4"},
201 { TUNER_ABSENT, "Philips FQ1286A MK4"},
202 { TUNER_ABSENT, "Philips FQ1216ME MK5"},
203 { TUNER_ABSENT, "Philips FQ1236 MK5"},
204 { TUNER_SAMSUNG_TCPG_6121P30A, "Samsung TCPG 6121P30A"},
205 { TUNER_TCL_2002MB, "TCL 2002MB_3H"},
206 { TUNER_ABSENT, "TCL 2002MI_3H"},
207 { TUNER_TCL_2002N, "TCL 2002N 5H"},
208 /* 100-109 */
209 { TUNER_PHILIPS_FMD1216ME_MK3, "Philips FMD1216ME"},
210 { TUNER_TEA5767, "Philips TEA5768HL FM Radio"},
211 { TUNER_ABSENT, "Panasonic ENV57H12D5"},
212 { TUNER_PHILIPS_FM1236_MK3, "TCL MFNM05-4"},
213 { TUNER_ABSENT, "TCL MNM05-4"},
214 { TUNER_PHILIPS_FM1216ME_MK3, "TCL MPE05-2"},
215 { TUNER_ABSENT, "TCL MQNM05-4"},
216 { TUNER_ABSENT, "LG TAPC-W701D"},
217 { TUNER_ABSENT, "TCL 9886P-WM"},
218 { TUNER_ABSENT, "TCL 1676NM-WM"},
219 /* 110-119 */
220 { TUNER_ABSENT, "Thompson DTT75105"},
221 { TUNER_ABSENT, "Conexant_CX24109"},
222 { TUNER_TCL_2002N, "TCL M2523_5N_E"},
223 { TUNER_TCL_2002MB, "TCL M2523_3DB_E"},
224 { TUNER_ABSENT, "Philips 8275A"},
225 { TUNER_ABSENT, "Microtune MT2060"},
226 { TUNER_PHILIPS_FM1236_MK3, "Philips FM1236 MK5"},
227 { TUNER_PHILIPS_FM1216ME_MK3, "Philips FM1216ME MK5"},
228 { TUNER_ABSENT, "TCL M2523_3DI_E"},
229 { TUNER_ABSENT, "Samsung THPD5222FG30A"},
230 /* 120-129 */
231 { TUNER_XC2028, "Xceive XC3028"},
232 { TUNER_ABSENT, "Philips FQ1216LME MK5"},
233 { TUNER_ABSENT, "Philips FQD1216LME"},
234 { TUNER_ABSENT, "Conexant CX24118A"},
235 { TUNER_ABSENT, "TCL DMF11WIP"},
236 { TUNER_ABSENT, "TCL MFNM05_4H_E"},
237 { TUNER_ABSENT, "TCL MNM05_4H_E"},
238 { TUNER_ABSENT, "TCL MPE05_2H_E"},
239 { TUNER_ABSENT, "TCL MQNM05_4_U"},
240 { TUNER_ABSENT, "TCL M2523_5NH_E"},
241 /* 130-139 */
242 { TUNER_ABSENT, "TCL M2523_3DBH_E"},
243 { TUNER_ABSENT, "TCL M2523_3DIH_E"},
244 { TUNER_ABSENT, "TCL MFPE05_2_U"},
245 <<<<<<< HEAD:drivers/media/video/tveeprom.c
246 { TUNER_ABSENT, "Philips FMD1216MEX"},
247 =======
248 { TUNER_PHILIPS_FMD1216ME_MK3, "Philips FMD1216MEX"},
249 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/media/video/tveeprom.c
250 { TUNER_ABSENT, "Philips FRH2036B"},
251 { TUNER_ABSENT, "Panasonic ENGF75_01GF"},
252 { TUNER_ABSENT, "MaxLinear MXL5005"},
253 { TUNER_ABSENT, "MaxLinear MXL5003"},
254 { TUNER_ABSENT, "Xceive XC2028"},
255 { TUNER_ABSENT, "Microtune MT2131"},
256 /* 140-149 */
257 { TUNER_ABSENT, "Philips 8275A_8295"},
258 { TUNER_ABSENT, "TCL MF02GIP_5N_E"},
259 { TUNER_ABSENT, "TCL MF02GIP_3DB_E"},
260 { TUNER_ABSENT, "TCL MF02GIP_3DI_E"},
261 { TUNER_ABSENT, "Microtune MT2266"},
262 { TUNER_ABSENT, "TCL MF10WPP_4N_E"},
263 { TUNER_ABSENT, "LG TAPQ_H702F"},
264 { TUNER_ABSENT, "TCL M09WPP_4N_E"},
265 { TUNER_ABSENT, "MaxLinear MXL5005_v2"},
266 { TUNER_PHILIPS_TDA8290, "Philips 18271_8295"},
267 /* 150-159 */
268 { TUNER_ABSENT, "Xceive XC5000"},
269 };
270
271 static struct HAUPPAUGE_AUDIOIC
272 {
273 enum audiochip id;
274 char *name;
275 }
276 audioIC[] =
277 {
278 /* 0-4 */
279 {AUDIO_CHIP_NONE, "None"},
280 {AUDIO_CHIP_TEA6300, "TEA6300"},
281 {AUDIO_CHIP_TEA6300, "TEA6320"},
282 {AUDIO_CHIP_TDA985X, "TDA9850"},
283 {AUDIO_CHIP_MSP34XX, "MSP3400C"},
284 /* 5-9 */
285 {AUDIO_CHIP_MSP34XX, "MSP3410D"},
286 {AUDIO_CHIP_MSP34XX, "MSP3415"},
287 {AUDIO_CHIP_MSP34XX, "MSP3430"},
288 {AUDIO_CHIP_MSP34XX, "MSP3438"},
289 {AUDIO_CHIP_UNKNOWN, "CS5331"},
290 /* 10-14 */
291 {AUDIO_CHIP_MSP34XX, "MSP3435"},
292 {AUDIO_CHIP_MSP34XX, "MSP3440"},
293 {AUDIO_CHIP_MSP34XX, "MSP3445"},
294 {AUDIO_CHIP_MSP34XX, "MSP3411"},
295 {AUDIO_CHIP_MSP34XX, "MSP3416"},
296 /* 15-19 */
297 {AUDIO_CHIP_MSP34XX, "MSP3425"},
298 {AUDIO_CHIP_MSP34XX, "MSP3451"},
299 {AUDIO_CHIP_MSP34XX, "MSP3418"},
300 {AUDIO_CHIP_UNKNOWN, "Type 0x12"},
301 {AUDIO_CHIP_UNKNOWN, "OKI7716"},
302 /* 20-24 */
303 {AUDIO_CHIP_MSP34XX, "MSP4410"},
304 {AUDIO_CHIP_MSP34XX, "MSP4420"},
305 {AUDIO_CHIP_MSP34XX, "MSP4440"},
306 {AUDIO_CHIP_MSP34XX, "MSP4450"},
307 {AUDIO_CHIP_MSP34XX, "MSP4408"},
308 /* 25-29 */
309 {AUDIO_CHIP_MSP34XX, "MSP4418"},
310 {AUDIO_CHIP_MSP34XX, "MSP4428"},
311 {AUDIO_CHIP_MSP34XX, "MSP4448"},
312 {AUDIO_CHIP_MSP34XX, "MSP4458"},
313 {AUDIO_CHIP_MSP34XX, "Type 0x1d"},
314 /* 30-34 */
315 {AUDIO_CHIP_INTERNAL, "CX880"},
316 {AUDIO_CHIP_INTERNAL, "CX881"},
317 {AUDIO_CHIP_INTERNAL, "CX883"},
318 {AUDIO_CHIP_INTERNAL, "CX882"},
319 {AUDIO_CHIP_INTERNAL, "CX25840"},
320 /* 35-39 */
321 {AUDIO_CHIP_INTERNAL, "CX25841"},
322 {AUDIO_CHIP_INTERNAL, "CX25842"},
323 {AUDIO_CHIP_INTERNAL, "CX25843"},
324 {AUDIO_CHIP_INTERNAL, "CX23418"},
325 {AUDIO_CHIP_INTERNAL, "CX23885"},
326 /* 40-42 */
327 {AUDIO_CHIP_INTERNAL, "CX23888"},
328 {AUDIO_CHIP_INTERNAL, "SAA7131"},
329 {AUDIO_CHIP_INTERNAL, "CX23887"},
330 };
331
332 /* This list is supplied by Hauppauge. Thanks! */
333 static const char *decoderIC[] = {
334 /* 0-4 */
335 "None", "BT815", "BT817", "BT819", "BT815A",
336 /* 5-9 */
337 "BT817A", "BT819A", "BT827", "BT829", "BT848",
338 /* 10-14 */
339 "BT848A", "BT849A", "BT829A", "BT827A", "BT878",
340 /* 15-19 */
341 "BT879", "BT880", "VPX3226E", "SAA7114", "SAA7115",
342 /* 20-24 */
343 "CX880", "CX881", "CX883", "SAA7111", "SAA7113",
344 /* 25-29 */
345 "CX882", "TVP5150A", "CX25840", "CX25841", "CX25842",
346 /* 30-34 */
347 "CX25843", "CX23418", "NEC61153", "CX23885", "CX23888",
348 /* 35-37 */
349 "SAA7131", "CX25837", "CX23887"
350 };
351
352 static int hasRadioTuner(int tunerType)
353 {
354 switch (tunerType) {
355 case 18: /* PNPEnv_TUNER_FR1236_MK2 */
356 case 23: /* PNPEnv_TUNER_FM1236 */
357 case 38: /* PNPEnv_TUNER_FMR1236 */
358 case 16: /* PNPEnv_TUNER_FR1216_MK2 */
359 case 19: /* PNPEnv_TUNER_FR1246_MK2 */
360 case 21: /* PNPEnv_TUNER_FM1216 */
361 case 24: /* PNPEnv_TUNER_FM1246 */
362 case 17: /* PNPEnv_TUNER_FR1216MF_MK2 */
363 case 22: /* PNPEnv_TUNER_FM1216MF */
364 case 20: /* PNPEnv_TUNER_FR1256_MK2 */
365 case 25: /* PNPEnv_TUNER_FM1256 */
366 case 33: /* PNPEnv_TUNER_4039FR5 */
367 case 42: /* PNPEnv_TUNER_4009FR5 */
368 case 52: /* PNPEnv_TUNER_4049FM5 */
369 case 54: /* PNPEnv_TUNER_4049FM5_AltI2C */
370 case 44: /* PNPEnv_TUNER_4009FN5 */
371 case 31: /* PNPEnv_TUNER_TCPB9085P */
372 case 30: /* PNPEnv_TUNER_TCPN9085D */
373 case 46: /* PNPEnv_TUNER_TP18NSR01F */
374 case 47: /* PNPEnv_TUNER_TP18PSB01D */
375 case 49: /* PNPEnv_TUNER_TAPC_I001D */
376 case 60: /* PNPEnv_TUNER_TAPE_S001D_MK3 */
377 case 57: /* PNPEnv_TUNER_FM1216ME_MK3 */
378 case 59: /* PNPEnv_TUNER_FM1216MP_MK3 */
379 case 58: /* PNPEnv_TUNER_FM1236_MK3 */
380 case 68: /* PNPEnv_TUNER_TAPE_H001F_MK3 */
381 case 61: /* PNPEnv_TUNER_TAPE_M001D_MK3 */
382 case 78: /* PNPEnv_TUNER_TDA8275C1_8290_FM */
383 case 89: /* PNPEnv_TUNER_TCL_MFPE05_2 */
384 case 92: /* PNPEnv_TUNER_PHILIPS_FQ1236A_MK4 */
385 case 105:
386 return 1;
387 }
388 return 0;
389 }
390
391 void tveeprom_hauppauge_analog(struct i2c_client *c, struct tveeprom *tvee,
392 unsigned char *eeprom_data)
393 {
394 /* ----------------------------------------------
395 ** The hauppauge eeprom format is tagged
396 **
397 ** if packet[0] == 0x84, then packet[0..1] == length
398 ** else length = packet[0] & 3f;
399 ** if packet[0] & f8 == f8, then EOD and packet[1] == checksum
400 **
401 ** In our (ivtv) case we're interested in the following:
402 ** tuner type: tag [00].05 or [0a].01 (index into hauppauge_tuner)
403 ** tuner fmts: tag [00].04 or [0a].00 (bitmask index into
404 ** hauppauge_tuner_fmt)
405 ** radio: tag [00].{last} or [0e].00 (bitmask. bit2=FM)
406 ** audio proc: tag [02].01 or [05].00 (mask with 0x7f)
407 ** decoder proc: tag [09].01)
408
409 ** Fun info:
410 ** model: tag [00].07-08 or [06].00-01
411 ** revision: tag [00].09-0b or [06].04-06
412 ** serial#: tag [01].05-07 or [04].04-06
413
414 ** # of inputs/outputs ???
415 */
416
417 int i, j, len, done, beenhere, tag, start;
418
419 int tuner1 = 0, t_format1 = 0, audioic = -1;
420 char *t_name1 = NULL;
421 const char *t_fmt_name1[8] = { " none", "", "", "", "", "", "", "" };
422
423 int tuner2 = 0, t_format2 = 0;
424 char *t_name2 = NULL;
425 const char *t_fmt_name2[8] = { " none", "", "", "", "", "", "", "" };
426
427 memset(tvee, 0, sizeof(*tvee));
428 done = len = beenhere = 0;
429
430 /* Different eeprom start offsets for em28xx, cx2388x and cx23418 */
431 if (eeprom_data[0] == 0x1a &&
432 eeprom_data[1] == 0xeb &&
433 eeprom_data[2] == 0x67 &&
434 eeprom_data[3] == 0x95)
435 start = 0xa0; /* Generic em28xx offset */
436 else if ((eeprom_data[0] & 0xe1) == 0x01 &&
437 eeprom_data[1] == 0x00 &&
438 eeprom_data[2] == 0x00 &&
439 eeprom_data[8] == 0x84)
440 start = 8; /* Generic cx2388x offset */
441 else if (eeprom_data[1] == 0x70 &&
442 eeprom_data[2] == 0x00 &&
443 eeprom_data[4] == 0x74 &&
444 eeprom_data[8] == 0x84)
445 start = 8; /* Generic cx23418 offset (models 74xxx) */
446 else
447 start = 0;
448
449 for (i = start; !done && i < 256; i += len) {
450 if (eeprom_data[i] == 0x84) {
451 len = eeprom_data[i + 1] + (eeprom_data[i + 2] << 8);
452 i += 3;
453 } else if ((eeprom_data[i] & 0xf0) == 0x70) {
454 if (eeprom_data[i] & 0x08) {
455 /* verify checksum! */
456 done = 1;
457 break;
458 }
459 len = eeprom_data[i] & 0x07;
460 ++i;
461 } else {
462 tveeprom_warn("Encountered bad packet header [%02x]. "
463 "Corrupt or not a Hauppauge eeprom.\n",
464 eeprom_data[i]);
465 return;
466 }
467
468 if (debug) {
469 tveeprom_info("Tag [%02x] + %d bytes:",
470 eeprom_data[i], len - 1);
471 for (j = 1; j < len; j++)
472 printk(KERN_CONT " %02x", eeprom_data[i + j]);
473 printk(KERN_CONT "\n");
474 }
475
476 /* process by tag */
477 tag = eeprom_data[i];
478 switch (tag) {
479 case 0x00:
480 /* tag: 'Comprehensive' */
481 tuner1 = eeprom_data[i+6];
482 t_format1 = eeprom_data[i+5];
483 tvee->has_radio = eeprom_data[i+len-1];
484 /* old style tag, don't know how to detect
485 IR presence, mark as unknown. */
486 tvee->has_ir = -1;
487 tvee->model =
488 eeprom_data[i+8] +
489 (eeprom_data[i+9] << 8);
490 tvee->revision = eeprom_data[i+10] +
491 (eeprom_data[i+11] << 8) +
492 (eeprom_data[i+12] << 16);
493 break;
494
495 case 0x01:
496 /* tag: 'SerialID' */
497 tvee->serial_number =
498 eeprom_data[i+6] +
499 (eeprom_data[i+7] << 8) +
500 (eeprom_data[i+8] << 16);
501 break;
502
503 case 0x02:
504 /* tag 'AudioInfo'
505 Note mask with 0x7F, high bit used on some older models
506 to indicate 4052 mux was removed in favor of using MSP
507 inputs directly. */
508 audioic = eeprom_data[i+2] & 0x7f;
509 if (audioic < ARRAY_SIZE(audioIC))
510 tvee->audio_processor = audioIC[audioic].id;
511 else
512 tvee->audio_processor = AUDIO_CHIP_UNKNOWN;
513 break;
514
515 /* case 0x03: tag 'EEInfo' */
516
517 case 0x04:
518 /* tag 'SerialID2' */
519 tvee->serial_number =
520 eeprom_data[i+5] +
521 (eeprom_data[i+6] << 8) +
522 (eeprom_data[i+7] << 16);
523
524 if ((eeprom_data[i + 8] & 0xf0) &&
525 (tvee->serial_number < 0xffffff)) {
526 tvee->MAC_address[0] = 0x00;
527 tvee->MAC_address[1] = 0x0D;
528 tvee->MAC_address[2] = 0xFE;
529 tvee->MAC_address[3] = eeprom_data[i + 7];
530 tvee->MAC_address[4] = eeprom_data[i + 6];
531 tvee->MAC_address[5] = eeprom_data[i + 5];
532 tvee->has_MAC_address = 1;
533 }
534 break;
535
536 case 0x05:
537 /* tag 'Audio2'
538 Note mask with 0x7F, high bit used on some older models
539 to indicate 4052 mux was removed in favor of using MSP
540 inputs directly. */
541 audioic = eeprom_data[i+1] & 0x7f;
542 if (audioic < ARRAY_SIZE(audioIC))
543 tvee->audio_processor = audioIC[audioic].id;
544 else
545 tvee->audio_processor = AUDIO_CHIP_UNKNOWN;
546
547 break;
548
549 case 0x06:
550 /* tag 'ModelRev' */
551 tvee->model =
552 eeprom_data[i + 1] +
553 (eeprom_data[i + 2] << 8) +
554 (eeprom_data[i + 3] << 16) +
555 (eeprom_data[i + 4] << 24);
556 tvee->revision =
557 eeprom_data[i + 5] +
558 (eeprom_data[i + 6] << 8) +
559 (eeprom_data[i + 7] << 16);
560 break;
561
562 case 0x07:
563 /* tag 'Details': according to Hauppauge not interesting
564 on any PCI-era or later boards. */
565 break;
566
567 /* there is no tag 0x08 defined */
568
569 case 0x09:
570 /* tag 'Video' */
571 tvee->decoder_processor = eeprom_data[i + 1];
572 break;
573
574 case 0x0a:
575 /* tag 'Tuner' */
576 if (beenhere == 0) {
577 tuner1 = eeprom_data[i + 2];
578 t_format1 = eeprom_data[i + 1];
579 beenhere = 1;
580 } else {
581 /* a second (radio) tuner may be present */
582 tuner2 = eeprom_data[i + 2];
583 t_format2 = eeprom_data[i + 1];
584 /* not a TV tuner? */
585 if (t_format2 == 0)
586 tvee->has_radio = 1; /* must be radio */
587 }
588 break;
589
590 case 0x0b:
591 /* tag 'Inputs': according to Hauppauge this is specific
592 to each driver family, so no good assumptions can be
593 made. */
594 break;
595
596 /* case 0x0c: tag 'Balun' */
597 /* case 0x0d: tag 'Teletext' */
598
599 case 0x0e:
600 /* tag: 'Radio' */
601 tvee->has_radio = eeprom_data[i+1];
602 break;
603
604 case 0x0f:
605 /* tag 'IRInfo' */
606 tvee->has_ir = eeprom_data[i+1];
607 break;
608
609 /* case 0x10: tag 'VBIInfo' */
610 /* case 0x11: tag 'QCInfo' */
611 /* case 0x12: tag 'InfoBits' */
612
613 default:
614 tveeprom_dbg("Not sure what to do with tag [%02x]\n",
615 tag);
616 /* dump the rest of the packet? */
617 }
618 }
619
620 if (!done) {
621 tveeprom_warn("Ran out of data!\n");
622 return;
623 }
624
625 if (tvee->revision != 0) {
626 tvee->rev_str[0] = 32 + ((tvee->revision >> 18) & 0x3f);
627 tvee->rev_str[1] = 32 + ((tvee->revision >> 12) & 0x3f);
628 tvee->rev_str[2] = 32 + ((tvee->revision >> 6) & 0x3f);
629 tvee->rev_str[3] = 32 + (tvee->revision & 0x3f);
630 tvee->rev_str[4] = 0;
631 }
632
633 if (hasRadioTuner(tuner1) && !tvee->has_radio) {
634 tveeprom_info("The eeprom says no radio is present, but the tuner type\n");
635 tveeprom_info("indicates otherwise. I will assume that radio is present.\n");
636 tvee->has_radio = 1;
637 }
638
639 if (tuner1 < sizeof(hauppauge_tuner)/sizeof(struct HAUPPAUGE_TUNER)) {
640 tvee->tuner_type = hauppauge_tuner[tuner1].id;
641 t_name1 = hauppauge_tuner[tuner1].name;
642 } else {
643 t_name1 = "unknown";
644 }
645
646 if (tuner2 < sizeof(hauppauge_tuner)/sizeof(struct HAUPPAUGE_TUNER)) {
647 tvee->tuner2_type = hauppauge_tuner[tuner2].id;
648 t_name2 = hauppauge_tuner[tuner2].name;
649 } else {
650 t_name2 = "unknown";
651 }
652
653 tvee->tuner_hauppauge_model = tuner1;
654 tvee->tuner2_hauppauge_model = tuner2;
655 tvee->tuner_formats = 0;
656 tvee->tuner2_formats = 0;
657 for (i = j = 0; i < 8; i++) {
658 if (t_format1 & (1 << i)) {
659 tvee->tuner_formats |= hauppauge_tuner_fmt[i].id;
660 t_fmt_name1[j++] = hauppauge_tuner_fmt[i].name;
661 }
662 }
663 for (i = j = 0; i < 8; i++) {
664 if (t_format2 & (1 << i)) {
665 tvee->tuner2_formats |= hauppauge_tuner_fmt[i].id;
666 t_fmt_name2[j++] = hauppauge_tuner_fmt[i].name;
667 }
668 }
669
670 tveeprom_info("Hauppauge model %d, rev %s, serial# %d\n",
671 tvee->model, tvee->rev_str, tvee->serial_number);
672 if (tvee->has_MAC_address == 1)
673 tveeprom_info("MAC address is %02X-%02X-%02X-%02X-%02X-%02X\n",
674 tvee->MAC_address[0], tvee->MAC_address[1],
675 tvee->MAC_address[2], tvee->MAC_address[3],
676 tvee->MAC_address[4], tvee->MAC_address[5]);
677 tveeprom_info("tuner model is %s (idx %d, type %d)\n",
678 t_name1, tuner1, tvee->tuner_type);
679 tveeprom_info("TV standards%s%s%s%s%s%s%s%s (eeprom 0x%02x)\n",
680 t_fmt_name1[0], t_fmt_name1[1], t_fmt_name1[2],
681 t_fmt_name1[3], t_fmt_name1[4], t_fmt_name1[5],
682 t_fmt_name1[6], t_fmt_name1[7], t_format1);
683 if (tuner2)
684 tveeprom_info("second tuner model is %s (idx %d, type %d)\n",
685 t_name2, tuner2, tvee->tuner2_type);
686 if (t_format2)
687 tveeprom_info("TV standards%s%s%s%s%s%s%s%s (eeprom 0x%02x)\n",
688 t_fmt_name2[0], t_fmt_name2[1], t_fmt_name2[2],
689 t_fmt_name2[3], t_fmt_name2[4], t_fmt_name2[5],
690 t_fmt_name2[6], t_fmt_name2[7], t_format2);
691 if (audioic < 0) {
692 tveeprom_info("audio processor is unknown (no idx)\n");
693 tvee->audio_processor = AUDIO_CHIP_UNKNOWN;
694 } else {
695 if (audioic < ARRAY_SIZE(audioIC))
696 tveeprom_info("audio processor is %s (idx %d)\n",
697 audioIC[audioic].name, audioic);
698 else
699 tveeprom_info("audio processor is unknown (idx %d)\n",
700 audioic);
701 }
702 if (tvee->decoder_processor)
703 tveeprom_info("decoder processor is %s (idx %d)\n",
704 STRM(decoderIC, tvee->decoder_processor),
705 tvee->decoder_processor);
706 if (tvee->has_ir == -1)
707 tveeprom_info("has %sradio\n",
708 tvee->has_radio ? "" : "no ");
709 else
710 tveeprom_info("has %sradio, has %sIR receiver, has %sIR transmitter\n",
711 tvee->has_radio ? "" : "no ",
712 (tvee->has_ir & 1) ? "" : "no ",
713 (tvee->has_ir & 2) ? "" : "no ");
714 }
715 EXPORT_SYMBOL(tveeprom_hauppauge_analog);
716
717 /* ----------------------------------------------------------------------- */
718 /* generic helper functions */
719
720 int tveeprom_read(struct i2c_client *c, unsigned char *eedata, int len)
721 {
722 unsigned char buf;
723 int err;
724
725 buf = 0;
726 err = i2c_master_send(c, &buf, 1);
727 if (err != 1) {
728 tveeprom_info("Huh, no eeprom present (err=%d)?\n", err);
729 return -1;
730 }
731 err = i2c_master_recv(c, eedata, len);
732 if (err != len) {
733 tveeprom_warn("i2c eeprom read error (err=%d)\n", err);
734 return -1;
735 }
736 if (debug) {
737 int i;
738
739 tveeprom_info("full 256-byte eeprom dump:\n");
740 for (i = 0; i < len; i++) {
741 if (0 == (i % 16))
742 tveeprom_info("%02x:", i);
743 printk(KERN_CONT " %02x", eedata[i]);
744 if (15 == (i % 16))
745 printk(KERN_CONT "\n");
746 }
747 }
748 return 0;
749 }
750 EXPORT_SYMBOL(tveeprom_read);
751
752 /* ----------------------------------------------------------------------- */
753 /* needed for ivtv.sf.net at the moment. Should go away in the long */
754 /* run, just call the exported tveeprom_* directly, there is no point in */
755 /* using the indirect way via i2c_driver->command() */
756
757 static unsigned short normal_i2c[] = {
758 0xa0 >> 1,
759 I2C_CLIENT_END,
760 };
761
762 I2C_CLIENT_INSMOD;
763
764 static struct i2c_driver i2c_driver_tveeprom;
765
766 static int
767 tveeprom_command(struct i2c_client *client,
768 unsigned int cmd,
769 void *arg)
770 {
771 struct tveeprom eeprom;
772 u32 *eeprom_props = arg;
773 u8 *buf;
774
775 switch (cmd) {
776 case 0:
777 buf = kzalloc(256, GFP_KERNEL);
778 tveeprom_read(client, buf, 256);
779 tveeprom_hauppauge_analog(client, &eeprom, buf);
780 kfree(buf);
781 eeprom_props[0] = eeprom.tuner_type;
782 eeprom_props[1] = eeprom.tuner_formats;
783 eeprom_props[2] = eeprom.model;
784 eeprom_props[3] = eeprom.revision;
785 eeprom_props[4] = eeprom.has_radio;
786 break;
787 default:
788 return -EINVAL;
789 }
790 return 0;
791 }
792
793 static int
794 tveeprom_detect_client(struct i2c_adapter *adapter,
795 int address,
796 int kind)
797 {
798 struct i2c_client *client;
799
800 client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
801 if (NULL == client)
802 return -ENOMEM;
803 client->addr = address;
804 client->adapter = adapter;
805 client->driver = &i2c_driver_tveeprom;
806 snprintf(client->name, sizeof(client->name), "tveeprom");
807 i2c_attach_client(client);
808
809 return 0;
810 }
811
812 static int
813 tveeprom_attach_adapter(struct i2c_adapter *adapter)
814 {
815 if (adapter->class & I2C_CLASS_TV_ANALOG)
816 return i2c_probe(adapter, &addr_data, tveeprom_detect_client);
817 return 0;
818 }
819
820 static int
821 tveeprom_detach_client(struct i2c_client *client)
822 {
823 int err;
824
825 err = i2c_detach_client(client);
826 if (err < 0)
827 return err;
828 kfree(client);
829 return 0;
830 }
831
832 static struct i2c_driver i2c_driver_tveeprom = {
833 .driver = {
834 .name = "tveeprom",
835 },
836 .id = I2C_DRIVERID_TVEEPROM,
837 .attach_adapter = tveeprom_attach_adapter,
838 .detach_client = tveeprom_detach_client,
839 .command = tveeprom_command,
840 };
841
842 static int __init tveeprom_init(void)
843 {
844 return i2c_add_driver(&i2c_driver_tveeprom);
845 }
846
847 static void __exit tveeprom_exit(void)
848 {
849 i2c_del_driver(&i2c_driver_tveeprom);
850 }
851
852 module_init(tveeprom_init);
853 module_exit(tveeprom_exit);
854
855 /*
856 * Local variables:
857 * c-basic-offset: 8
858 * End:
859 */
WRT350N Kernel Patches