1 /* 2 * 3 * 4 * Copyright (C) 2005 Mike Isely <isely@pobox.com> 5 * Copyright (C) 2004 Aurelien Alleaume <slts@free.fr> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 */ 17 18 #include <linux/slab.h> 19 #include "pvrusb2-eeprom.h" 20 #include "pvrusb2-hdw-internal.h" 21 #include "pvrusb2-debug.h" 22 23 #define trace_eeprom(...) pvr2_trace(PVR2_TRACE_EEPROM,__VA_ARGS__) 24 25 26 27 /* 28 29 Read and analyze data in the eeprom. Use tveeprom to figure out 30 the packet structure, since this is another Hauppauge device and 31 internally it has a family resemblance to ivtv-type devices 32 33 */ 34 35 #include <media/tveeprom.h> 36 37 /* We seem to only be interested in the last 128 bytes of the EEPROM */ 38 #define EEPROM_SIZE 128 39 40 /* Grab EEPROM contents, needed for direct method. */ 41 static u8 *pvr2_eeprom_fetch(struct pvr2_hdw *hdw) 42 { 43 struct i2c_msg msg[2]; 44 u8 *eeprom; 45 u8 iadd[2]; 46 u8 addr; 47 u16 eepromSize; 48 unsigned int offs; 49 int ret; 50 int mode16 = 0; 51 unsigned pcnt,tcnt; 52 eeprom = kmalloc(EEPROM_SIZE,GFP_KERNEL); 53 if (!eeprom) { 54 pvr2_trace(PVR2_TRACE_ERROR_LEGS, 55 "Failed to allocate memory required to read eeprom"); 56 return NULL; 57 } 58 59 trace_eeprom("Value for eeprom addr from controller was 0x%x", 60 hdw->eeprom_addr); 61 addr = hdw->eeprom_addr; 62 /* Seems that if the high bit is set, then the *real* eeprom 63 address is shifted right now bit position (noticed this in 64 newer PVR USB2 hardware) */ 65 if (addr & 0x80) addr >>= 1; 66 67 /* FX2 documentation states that a 16bit-addressed eeprom is 68 expected if the I2C address is an odd number (yeah, this is 69 strange but it's what they do) */ 70 mode16 = (addr & 1); 71 eepromSize = (mode16 ? 4096 : 256); 72 trace_eeprom("Examining %d byte eeprom at location 0x%x using %d bit addressing", 73 eepromSize, addr, 74 mode16 ? 16 : 8); 75 76 msg[0].addr = addr; 77 msg[0].flags = 0; 78 msg[0].len = mode16 ? 2 : 1; 79 msg[0].buf = iadd; 80 msg[1].addr = addr; 81 msg[1].flags = I2C_M_RD; 82 83 /* We have to do the actual eeprom data fetch ourselves, because 84 (1) we're only fetching part of the eeprom, and (2) if we were 85 getting the whole thing our I2C driver can't grab it in one 86 pass - which is what tveeprom is otherwise going to attempt */ 87 memset(eeprom,0,EEPROM_SIZE); 88 for (tcnt = 0; tcnt < EEPROM_SIZE; tcnt += pcnt) { 89 pcnt = 16; 90 if (pcnt + tcnt > EEPROM_SIZE) pcnt = EEPROM_SIZE-tcnt; 91 offs = tcnt + (eepromSize - EEPROM_SIZE); 92 if (mode16) { 93 iadd[0] = offs >> 8; 94 iadd[1] = offs; 95 } else { 96 iadd[0] = offs; 97 } 98 msg[1].len = pcnt; 99 msg[1].buf = eeprom+tcnt; 100 if ((ret = i2c_transfer(&hdw->i2c_adap, 101 msg,ARRAY_SIZE(msg))) != 2) { 102 pvr2_trace(PVR2_TRACE_ERROR_LEGS, 103 "eeprom fetch set offs err=%d",ret); 104 kfree(eeprom); 105 return NULL; 106 } 107 } 108 return eeprom; 109 } 110 111 112 /* Directly call eeprom analysis function within tveeprom. */ 113 int pvr2_eeprom_analyze(struct pvr2_hdw *hdw) 114 { 115 u8 *eeprom; 116 struct tveeprom tvdata; 117 118 memset(&tvdata,0,sizeof(tvdata)); 119 120 eeprom = pvr2_eeprom_fetch(hdw); 121 if (!eeprom) return -EINVAL; 122 123 { 124 struct i2c_client fake_client; 125 /* Newer version expects a useless client interface */ 126 fake_client.addr = hdw->eeprom_addr; 127 fake_client.adapter = &hdw->i2c_adap; 128 tveeprom_hauppauge_analog(&fake_client,&tvdata,eeprom); 129 } 130 131 trace_eeprom("eeprom assumed v4l tveeprom module"); 132 trace_eeprom("eeprom direct call results:"); 133 trace_eeprom("has_radio=%d",tvdata.has_radio); 134 trace_eeprom("tuner_type=%d",tvdata.tuner_type); 135 trace_eeprom("tuner_formats=0x%x",tvdata.tuner_formats); 136 trace_eeprom("audio_processor=%d",tvdata.audio_processor); 137 trace_eeprom("model=%d",tvdata.model); 138 trace_eeprom("revision=%d",tvdata.revision); 139 trace_eeprom("serial_number=%d",tvdata.serial_number); 140 trace_eeprom("rev_str=%s",tvdata.rev_str); 141 hdw->tuner_type = tvdata.tuner_type; 142 hdw->tuner_updated = !0; 143 hdw->serial_number = tvdata.serial_number; 144 hdw->std_mask_eeprom = tvdata.tuner_formats; 145 146 kfree(eeprom); 147 148 return 0; 149 } 150