projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[PATCH] i2c: Drop i2c_driver.{owner,name}, 4 of 11
[deliverable/linux.git] / drivers / media / video / tveeprom.c
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/moduleparam.h>
34 #include <linux/errno.h>
35 #include <linux/kernel.h>
36 #include <linux/init.h>
37 #include <linux/types.h>
38 #include <linux/videodev.h>
39 #include <linux/i2c.h>
40
41 #include <media/tuner.h>
42 #include <media/tveeprom.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 = 0;
50 module_param(debug, int, 0644);
51 MODULE_PARM_DESC(debug, "Debug level (0-1)");
52
53 #define STRM(array,i) (i < sizeof(array)/sizeof(char*) ? array[i] : "unknown")
54
55 #define tveeprom_info(fmt, arg...) do {\
56 printk(KERN_INFO "tveeprom %d-%04x: " fmt, \
57 c->adapter->nr, c->addr , ##arg); } while (0)
58 #define tveeprom_warn(fmt, arg...) do {\
59 printk(KERN_WARNING "tveeprom %d-%04x: " fmt, \
60 c->adapter->nr, c->addr , ##arg); } while (0)
61 #define tveeprom_dbg(fmt, arg...) do {\
62 if (debug) \
63 printk(KERN_INFO "tveeprom %d-%04x: " fmt, \
64 c->adapter->nr, c->addr , ##arg); } while (0)
65
66
67 /* ----------------------------------------------------------------------- */
68 /* some hauppauge specific stuff */
69
70 static struct HAUPPAUGE_TUNER_FMT
71 {
72 int id;
73 char *name;
74 }
75 hauppauge_tuner_fmt[] =
76 {
77 { 0x00000000, " unknown1" },
78 { 0x00000000, " unknown2" },
79 { 0x00000007, " PAL(B/G)" },
80 { 0x00001000, " NTSC(M)" },
81 { 0x00000010, " PAL(I)" },
82 { 0x00400000, " SECAM(L/L')" },
83 { 0x00000e00, " PAL(D/K)" },
84 { 0x03000000, " 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_ABSENT, "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_ABSENT, "Philips FQ1216LME MK3"},
188 { TUNER_ABSENT, "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_ABSENT, "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_ABSENT, "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_ABSENT, "TCL M2523_5N_E"},
223 { TUNER_ABSENT, "TCL M2523_3DB_E"},
224 { TUNER_ABSENT, "Philips 8275A"},
225 { TUNER_ABSENT, "Microtune MT2060"},
226 { TUNER_ABSENT, "Philips FM1236 MK5"},
227 { TUNER_ABSENT, "Philips FM1216ME MK5"},
228 { TUNER_ABSENT, "TCL M2523_3DI_E"},
229 { TUNER_ABSENT, "Samsung THPD5222FG30A"},
230 /* 120-129 */
231 { TUNER_ABSENT, "Xceive XC3028"},
232 { TUNER_ABSENT, "Philips FQ1216LME MK5"},
233 };
234
235 static struct HAUPPAUGE_AUDIOIC
236 {
237 enum audiochip id;
238 char *name;
239 }
240 audioIC[] =
241 {
242 /* 0-4 */
243 {AUDIO_CHIP_NONE, "None"},
244 {AUDIO_CHIP_TEA6300, "TEA6300"},
245 {AUDIO_CHIP_TEA6300, "TEA6320"},
246 {AUDIO_CHIP_TDA985X, "TDA9850"},
247 {AUDIO_CHIP_MSP34XX, "MSP3400C"},
248 /* 5-9 */
249 {AUDIO_CHIP_MSP34XX, "MSP3410D"},
250 {AUDIO_CHIP_MSP34XX, "MSP3415"},
251 {AUDIO_CHIP_MSP34XX, "MSP3430"},
252 {AUDIO_CHIP_UNKNOWN, "MSP3438"},
253 {AUDIO_CHIP_UNKNOWN, "CS5331"},
254 /* 10-14 */
255 {AUDIO_CHIP_MSP34XX, "MSP3435"},
256 {AUDIO_CHIP_MSP34XX, "MSP3440"},
257 {AUDIO_CHIP_MSP34XX, "MSP3445"},
258 {AUDIO_CHIP_UNKNOWN, "MSP3411"},
259 {AUDIO_CHIP_UNKNOWN, "MSP3416"},
260 /* 15-19 */
261 {AUDIO_CHIP_MSP34XX, "MSP3425"},
262 {AUDIO_CHIP_UNKNOWN, "MSP3451"},
263 {AUDIO_CHIP_UNKNOWN, "MSP3418"},
264 {AUDIO_CHIP_UNKNOWN, "Type 0x12"},
265 {AUDIO_CHIP_UNKNOWN, "OKI7716"},
266 /* 20-24 */
267 {AUDIO_CHIP_UNKNOWN, "MSP4410"},
268 {AUDIO_CHIP_UNKNOWN, "MSP4420"},
269 {AUDIO_CHIP_UNKNOWN, "MSP4440"},
270 {AUDIO_CHIP_UNKNOWN, "MSP4450"},
271 {AUDIO_CHIP_UNKNOWN, "MSP4408"},
272 /* 25-29 */
273 {AUDIO_CHIP_UNKNOWN, "MSP4418"},
274 {AUDIO_CHIP_UNKNOWN, "MSP4428"},
275 {AUDIO_CHIP_UNKNOWN, "MSP4448"},
276 {AUDIO_CHIP_UNKNOWN, "MSP4458"},
277 {AUDIO_CHIP_UNKNOWN, "Type 0x1d"},
278 /* 30-34 */
279 {AUDIO_CHIP_INTERNAL, "CX880"},
280 {AUDIO_CHIP_INTERNAL, "CX881"},
281 {AUDIO_CHIP_INTERNAL, "CX883"},
282 {AUDIO_CHIP_INTERNAL, "CX882"},
283 {AUDIO_CHIP_INTERNAL, "CX25840"},
284 /* 35-38 */
285 {AUDIO_CHIP_INTERNAL, "CX25841"},
286 {AUDIO_CHIP_INTERNAL, "CX25842"},
287 {AUDIO_CHIP_INTERNAL, "CX25843"},
288 {AUDIO_CHIP_INTERNAL, "CX23418"},
289 };
290
291 /* This list is supplied by Hauppauge. Thanks! */
292 static const char *decoderIC[] = {
293 /* 0-4 */
294 "None", "BT815", "BT817", "BT819", "BT815A",
295 /* 5-9 */
296 "BT817A", "BT819A", "BT827", "BT829", "BT848",
297 /* 10-14 */
298 "BT848A", "BT849A", "BT829A", "BT827A", "BT878",
299 /* 15-19 */
300 "BT879", "BT880", "VPX3226E", "SAA7114", "SAA7115",
301 /* 20-24 */
302 "CX880", "CX881", "CX883", "SAA7111", "SAA7113",
303 /* 25-29 */
304 "CX882", "TVP5150A", "CX25840", "CX25841", "CX25842",
305 /* 30-31 */
306 "CX25843", "CX23418",
307 };
308
309 static int hasRadioTuner(int tunerType)
310 {
311 switch (tunerType) {
312 case 18: //PNPEnv_TUNER_FR1236_MK2:
313 case 23: //PNPEnv_TUNER_FM1236:
314 case 38: //PNPEnv_TUNER_FMR1236:
315 case 16: //PNPEnv_TUNER_FR1216_MK2:
316 case 19: //PNPEnv_TUNER_FR1246_MK2:
317 case 21: //PNPEnv_TUNER_FM1216:
318 case 24: //PNPEnv_TUNER_FM1246:
319 case 17: //PNPEnv_TUNER_FR1216MF_MK2:
320 case 22: //PNPEnv_TUNER_FM1216MF:
321 case 20: //PNPEnv_TUNER_FR1256_MK2:
322 case 25: //PNPEnv_TUNER_FM1256:
323 case 33: //PNPEnv_TUNER_4039FR5:
324 case 42: //PNPEnv_TUNER_4009FR5:
325 case 52: //PNPEnv_TUNER_4049FM5:
326 case 54: //PNPEnv_TUNER_4049FM5_AltI2C:
327 case 44: //PNPEnv_TUNER_4009FN5:
328 case 31: //PNPEnv_TUNER_TCPB9085P:
329 case 30: //PNPEnv_TUNER_TCPN9085D:
330 case 46: //PNPEnv_TUNER_TP18NSR01F:
331 case 47: //PNPEnv_TUNER_TP18PSB01D:
332 case 49: //PNPEnv_TUNER_TAPC_I001D:
333 case 60: //PNPEnv_TUNER_TAPE_S001D_MK3:
334 case 57: //PNPEnv_TUNER_FM1216ME_MK3:
335 case 59: //PNPEnv_TUNER_FM1216MP_MK3:
336 case 58: //PNPEnv_TUNER_FM1236_MK3:
337 case 68: //PNPEnv_TUNER_TAPE_H001F_MK3:
338 case 61: //PNPEnv_TUNER_TAPE_M001D_MK3:
339 case 78: //PNPEnv_TUNER_TDA8275C1_8290_FM:
340 case 89: //PNPEnv_TUNER_TCL_MFPE05_2:
341 case 92: //PNPEnv_TUNER_PHILIPS_FQ1236A_MK4:
342 case 105:
343 return 1;
344 }
345 return 0;
346 }
347
348 void tveeprom_hauppauge_analog(struct i2c_client *c, struct tveeprom *tvee,
349 unsigned char *eeprom_data)
350 {
351 /* ----------------------------------------------
352 ** The hauppauge eeprom format is tagged
353 **
354 ** if packet[0] == 0x84, then packet[0..1] == length
355 ** else length = packet[0] & 3f;
356 ** if packet[0] & f8 == f8, then EOD and packet[1] == checksum
357 **
358 ** In our (ivtv) case we're interested in the following:
359 ** tuner type: tag [00].05 or [0a].01 (index into hauppauge_tuner)
360 ** tuner fmts: tag [00].04 or [0a].00 (bitmask index into hauppauge_tuner_fmt)
361 ** radio: tag [00].{last} or [0e].00 (bitmask. bit2=FM)
362 ** audio proc: tag [02].01 or [05].00 (mask with 0x7f)
363 ** decoder proc: tag [09].01)
364
365 ** Fun info:
366 ** model: tag [00].07-08 or [06].00-01
367 ** revision: tag [00].09-0b or [06].04-06
368 ** serial#: tag [01].05-07 or [04].04-06
369
370 ** # of inputs/outputs ???
371 */
372
373 int i, j, len, done, beenhere, tag,start;
374
375 int tuner1 = 0, t_format1 = 0, audioic=-1;
376 char *t_name1 = NULL;
377 const char *t_fmt_name1[8] = { " none", "", "", "", "", "", "", "" };
378
379 int tuner2 = 0, t_format2 = 0;
380 char *t_name2 = NULL;
381 const char *t_fmt_name2[8] = { " none", "", "", "", "", "", "", "" };
382
383 memset(tvee, 0, sizeof(*tvee));
384 done = len = beenhere = 0;
385
386 /* Hack for processing eeprom for em28xx and cx 2388x*/
387 if ((eeprom_data[0] == 0x1a) && (eeprom_data[1] == 0xeb) &&
388 (eeprom_data[2] == 0x67) && (eeprom_data[3] == 0x95))
389 start=0xa0; /* Generic em28xx offset */
390 else if (((eeprom_data[0] & 0xf0) == 0x10) &&
391 (eeprom_data[1] == 0x00) &&
392 (eeprom_data[2] == 0x00) &&
393 (eeprom_data[8] == 0x84))
394 start=8; /* Generic cx2388x offset */
395 else
396 start=0;
397
398 for (i = start; !done && i < 256; i += len) {
399 if (eeprom_data[i] == 0x84) {
400 len = eeprom_data[i + 1] + (eeprom_data[i + 2] << 8);
401 i += 3;
402 } else if ((eeprom_data[i] & 0xf0) == 0x70) {
403 if (eeprom_data[i] & 0x08) {
404 /* verify checksum! */
405 done = 1;
406 break;
407 }
408 len = eeprom_data[i] & 0x07;
409 ++i;
410 } else {
411 tveeprom_warn("Encountered bad packet header [%02x]. "
412 "Corrupt or not a Hauppauge eeprom.\n", eeprom_data[i]);
413 return;
414 }
415
416 if (debug) {
417 tveeprom_info("Tag [%02x] + %d bytes:", eeprom_data[i], len - 1);
418 for(j = 1; j < len; j++) {
419 printk(" %02x", eeprom_data[i + j]);
420 }
421 printk("\n");
422 }
423
424 /* process by tag */
425 tag = eeprom_data[i];
426 switch (tag) {
427 case 0x00:
428 /* tag: 'Comprehensive' */
429 tuner1 = eeprom_data[i+6];
430 t_format1 = eeprom_data[i+5];
431 tvee->has_radio = eeprom_data[i+len-1];
432 /* old style tag, don't know how to detect
433 IR presence, mark as unknown. */
434 tvee->has_ir = 2;
435 tvee->model =
436 eeprom_data[i+8] +
437 (eeprom_data[i+9] << 8);
438 tvee->revision = eeprom_data[i+10] +
439 (eeprom_data[i+11] << 8) +
440 (eeprom_data[i+12] << 16);
441 break;
442
443 case 0x01:
444 /* tag: 'SerialID' */
445 tvee->serial_number =
446 eeprom_data[i+6] +
447 (eeprom_data[i+7] << 8) +
448 (eeprom_data[i+8] << 16);
449 break;
450
451 case 0x02:
452 /* tag 'AudioInfo'
453 Note mask with 0x7F, high bit used on some older models
454 to indicate 4052 mux was removed in favor of using MSP
455 inputs directly. */
456 audioic = eeprom_data[i+2] & 0x7f;
457 if (audioic < sizeof(audioIC)/sizeof(*audioIC))
458 tvee->audio_processor = audioIC[audioic].id;
459 else
460 tvee->audio_processor = AUDIO_CHIP_UNKNOWN;
461 break;
462
463 /* case 0x03: tag 'EEInfo' */
464
465 case 0x04:
466 /* tag 'SerialID2' */
467 tvee->serial_number =
468 eeprom_data[i+5] +
469 (eeprom_data[i+6] << 8) +
470 (eeprom_data[i+7] << 16);
471
472 if ( (eeprom_data[i + 8] && 0xf0) &&
473 (tvee->serial_number < 0xffffff) ) {
474 tvee->MAC_address[0] = 0x00;
475 tvee->MAC_address[1] = 0x0D;
476 tvee->MAC_address[2] = 0xFE;
477 tvee->MAC_address[3] = eeprom_data[i + 7];
478 tvee->MAC_address[4] = eeprom_data[i + 6];
479 tvee->MAC_address[5] = eeprom_data[i + 5];
480 tvee->has_MAC_address = 1;
481 }
482 break;
483
484 case 0x05:
485 /* tag 'Audio2'
486 Note mask with 0x7F, high bit used on some older models
487 to indicate 4052 mux was removed in favor of using MSP
488 inputs directly. */
489 audioic = eeprom_data[i+1] & 0x7f;
490 if (audioic < sizeof(audioIC)/sizeof(*audioIC))
491 tvee->audio_processor = audioIC[audioic].id;
492 else
493 tvee->audio_processor = AUDIO_CHIP_UNKNOWN;
494
495 break;
496
497 case 0x06:
498 /* tag 'ModelRev' */
499 tvee->model =
500 eeprom_data[i + 1] +
501 (eeprom_data[i + 2] << 8) +
502 (eeprom_data[i + 3] << 16) +
503 (eeprom_data[i + 4] << 24);
504 tvee->revision =
505 eeprom_data[i +5 ] +
506 (eeprom_data[i + 6] << 8) +
507 (eeprom_data[i + 7] << 16);
508 break;
509
510 case 0x07:
511 /* tag 'Details': according to Hauppauge not interesting
512 on any PCI-era or later boards. */
513 break;
514
515 /* there is no tag 0x08 defined */
516
517 case 0x09:
518 /* tag 'Video' */
519 tvee->decoder_processor = eeprom_data[i + 1];
520 break;
521
522 case 0x0a:
523 /* tag 'Tuner' */
524 if (beenhere == 0) {
525 tuner1 = eeprom_data[i+2];
526 t_format1 = eeprom_data[i+1];
527 beenhere = 1;
528 } else {
529 /* a second (radio) tuner may be present */
530 tuner2 = eeprom_data[i+2];
531 t_format2 = eeprom_data[i+1];
532 if (t_format2 == 0) { /* not a TV tuner? */
533 tvee->has_radio = 1; /* must be radio */
534 }
535 }
536 break;
537
538 case 0x0b:
539 /* tag 'Inputs': according to Hauppauge this is specific
540 to each driver family, so no good assumptions can be
541 made. */
542 break;
543
544 /* case 0x0c: tag 'Balun' */
545 /* case 0x0d: tag 'Teletext' */
546
547 case 0x0e:
548 /* tag: 'Radio' */
549 tvee->has_radio = eeprom_data[i+1];
550 break;
551
552 case 0x0f:
553 /* tag 'IRInfo' */
554 tvee->has_ir = eeprom_data[i+1];
555 break;
556
557 /* case 0x10: tag 'VBIInfo' */
558 /* case 0x11: tag 'QCInfo' */
559 /* case 0x12: tag 'InfoBits' */
560
561 default:
562 tveeprom_dbg("Not sure what to do with tag [%02x]\n", tag);
563 /* dump the rest of the packet? */
564 }
565 }
566
567 if (!done) {
568 tveeprom_warn("Ran out of data!\n");
569 return;
570 }
571
572 if (tvee->revision != 0) {
573 tvee->rev_str[0] = 32 + ((tvee->revision >> 18) & 0x3f);
574 tvee->rev_str[1] = 32 + ((tvee->revision >> 12) & 0x3f);
575 tvee->rev_str[2] = 32 + ((tvee->revision >> 6) & 0x3f);
576 tvee->rev_str[3] = 32 + ( tvee->revision & 0x3f);
577 tvee->rev_str[4] = 0;
578 }
579
580 if (hasRadioTuner(tuner1) && !tvee->has_radio) {
581 tveeprom_info("The eeprom says no radio is present, but the tuner type\n");
582 tveeprom_info("indicates otherwise. I will assume that radio is present.\n");
583 tvee->has_radio = 1;
584 }
585
586 if (tuner1 < sizeof(hauppauge_tuner)/sizeof(struct HAUPPAUGE_TUNER)) {
587 tvee->tuner_type = hauppauge_tuner[tuner1].id;
588 t_name1 = hauppauge_tuner[tuner1].name;
589 } else {
590 t_name1 = "unknown";
591 }
592
593 if (tuner2 < sizeof(hauppauge_tuner)/sizeof(struct HAUPPAUGE_TUNER)) {
594 tvee->tuner2_type = hauppauge_tuner[tuner2].id;
595 t_name2 = hauppauge_tuner[tuner2].name;
596 } else {
597 t_name2 = "unknown";
598 }
599
600 tvee->tuner_hauppauge_model = tuner1;
601 tvee->tuner2_hauppauge_model = tuner2;
602 tvee->tuner_formats = 0;
603 tvee->tuner2_formats = 0;
604 for (i = j = 0; i < 8; i++) {
605 if (t_format1 & (1 << i)) {
606 tvee->tuner_formats |= hauppauge_tuner_fmt[i].id;
607 t_fmt_name1[j++] = hauppauge_tuner_fmt[i].name;
608 }
609 if (t_format2 & (1 << i)) {
610 tvee->tuner2_formats |= hauppauge_tuner_fmt[i].id;
611 t_fmt_name2[j++] = hauppauge_tuner_fmt[i].name;
612 }
613 }
614
615 tveeprom_info("Hauppauge model %d, rev %s, serial# %d\n",
616 tvee->model, tvee->rev_str, tvee->serial_number);
617 if (tvee->has_MAC_address == 1) {
618 tveeprom_info("MAC address is %02X-%02X-%02X-%02X-%02X-%02X\n",
619 tvee->MAC_address[0], tvee->MAC_address[1],
620 tvee->MAC_address[2], tvee->MAC_address[3],
621 tvee->MAC_address[4], tvee->MAC_address[5]);
622 }
623 tveeprom_info("tuner model is %s (idx %d, type %d)\n",
624 t_name1, tuner1, tvee->tuner_type);
625 tveeprom_info("TV standards%s%s%s%s%s%s%s%s (eeprom 0x%02x)\n",
626 t_fmt_name1[0], t_fmt_name1[1], t_fmt_name1[2], t_fmt_name1[3],
627 t_fmt_name1[4], t_fmt_name1[5], t_fmt_name1[6], t_fmt_name1[7],
628 t_format1);
629 if (tuner2) {
630 tveeprom_info("second tuner model is %s (idx %d, type %d)\n",
631 t_name2, tuner2, tvee->tuner2_type);
632 }
633 if (t_format2) {
634 tveeprom_info("TV standards%s%s%s%s%s%s%s%s (eeprom 0x%02x)\n",
635 t_fmt_name2[0], t_fmt_name2[1], t_fmt_name2[2], t_fmt_name2[3],
636 t_fmt_name2[4], t_fmt_name2[5], t_fmt_name2[6], t_fmt_name2[7],
637 t_format2);
638 }
639 if (audioic<0) {
640 tveeprom_info("audio processor is unknown (no idx)\n");
641 tvee->audio_processor=AUDIO_CHIP_UNKNOWN;
642 } else {
643 if (audioic < sizeof(audioIC)/sizeof(*audioIC))
644 tveeprom_info("audio processor is %s (idx %d)\n",
645 audioIC[audioic].name,audioic);
646 else
647 tveeprom_info("audio processor is unknown (idx %d)\n",
648 audioic);
649 }
650 if (tvee->decoder_processor) {
651 tveeprom_info("decoder processor is %s (idx %d)\n",
652 STRM(decoderIC, tvee->decoder_processor),
653 tvee->decoder_processor);
654 }
655 if (tvee->has_ir == 2)
656 tveeprom_info("has %sradio\n",
657 tvee->has_radio ? "" : "no ");
658 else
659 tveeprom_info("has %sradio, has %sIR remote\n",
660 tvee->has_radio ? "" : "no ",
661 tvee->has_ir ? "" : "no ");
662 }
663 EXPORT_SYMBOL(tveeprom_hauppauge_analog);
664
665 /* ----------------------------------------------------------------------- */
666 /* generic helper functions */
667
668 int tveeprom_read(struct i2c_client *c, unsigned char *eedata, int len)
669 {
670 unsigned char buf;
671 int err;
672
673 buf = 0;
674 if (1 != (err = i2c_master_send(c, &buf, 1))) {
675 tveeprom_info("Huh, no eeprom present (err=%d)?\n", err);
676 return -1;
677 }
678 if (len != (err = i2c_master_recv(c, eedata, len))) {
679 tveeprom_warn("i2c eeprom read error (err=%d)\n", err);
680 return -1;
681 }
682 if (debug) {
683 int i;
684
685 tveeprom_info("full 256-byte eeprom dump:\n");
686 for (i = 0; i < len; i++) {
687 if (0 == (i % 16))
688 tveeprom_info("%02x:", i);
689 printk(" %02x", eedata[i]);
690 if (15 == (i % 16))
691 printk("\n");
692 }
693 }
694 return 0;
695 }
696 EXPORT_SYMBOL(tveeprom_read);
697
698 /* ----------------------------------------------------------------------- */
699 /* needed for ivtv.sf.net at the moment. Should go away in the long */
700 /* run, just call the exported tveeprom_* directly, there is no point in */
701 /* using the indirect way via i2c_driver->command() */
702
703 static unsigned short normal_i2c[] = {
704 0xa0 >> 1,
705 I2C_CLIENT_END,
706 };
707
708 I2C_CLIENT_INSMOD;
709
710 static struct i2c_driver i2c_driver_tveeprom;
711
712 static int
713 tveeprom_command(struct i2c_client *client,
714 unsigned int cmd,
715 void *arg)
716 {
717 struct tveeprom eeprom;
718 u32 *eeprom_props = arg;
719 u8 *buf;
720
721 switch (cmd) {
722 case 0:
723 buf = kmalloc(256,GFP_KERNEL);
724 memset(buf,0,256);
725 tveeprom_read(client,buf,256);
726 tveeprom_hauppauge_analog(client, &eeprom,buf);
727 kfree(buf);
728 eeprom_props[0] = eeprom.tuner_type;
729 eeprom_props[1] = eeprom.tuner_formats;
730 eeprom_props[2] = eeprom.model;
731 eeprom_props[3] = eeprom.revision;
732 eeprom_props[4] = eeprom.has_radio;
733 break;
734 default:
735 return -EINVAL;
736 }
737 return 0;
738 }
739
740 static int
741 tveeprom_detect_client(struct i2c_adapter *adapter,
742 int address,
743 int kind)
744 {
745 struct i2c_client *client;
746
747 client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
748 if (NULL == client)
749 return -ENOMEM;
750 memset(client, 0, sizeof(struct i2c_client));
751 client->addr = address;
752 client->adapter = adapter;
753 client->driver = &i2c_driver_tveeprom;
754 snprintf(client->name, sizeof(client->name), "tveeprom");
755 i2c_attach_client(client);
756
757 return 0;
758 }
759
760 static int
761 tveeprom_attach_adapter (struct i2c_adapter *adapter)
762 {
763 if (adapter->id != I2C_HW_B_BT848)
764 return 0;
765 return i2c_probe(adapter, &addr_data, tveeprom_detect_client);
766 }
767
768 static int
769 tveeprom_detach_client (struct i2c_client *client)
770 {
771 int err;
772
773 err = i2c_detach_client(client);
774 if (err < 0)
775 return err;
776 kfree(client);
777 return 0;
778 }
779
780 static struct i2c_driver i2c_driver_tveeprom = {
781 .owner = THIS_MODULE,
782 .name = "tveeprom",
783 .id = I2C_DRIVERID_TVEEPROM,
784 .attach_adapter = tveeprom_attach_adapter,
785 .detach_client = tveeprom_detach_client,
786 .command = tveeprom_command,
787 };
788
789 static int __init tveeprom_init(void)
790 {
791 return i2c_add_driver(&i2c_driver_tveeprom);
792 }
793
794 static void __exit tveeprom_exit(void)
795 {
796 i2c_del_driver(&i2c_driver_tveeprom);
797 }
798
799 module_init(tveeprom_init);
800 module_exit(tveeprom_exit);
801
802 /*
803 * Local variables:
804 * c-basic-offset: 8
805 * End:
806 */
Linux kernel - Deliverables
This page took 0.052656 seconds and 5 git commands to generate.