Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | * |
| 3 | * i2c tv tuner chip device driver |
| 4 | * controls all those simple 4-control-bytes style tuners. |
| 5 | */ |
| 6 | #include <linux/delay.h> |
| 7 | #include <linux/i2c.h> |
| 8 | #include <linux/videodev.h> |
| 9 | #include <media/tuner.h> |
Hans Verkuil | ba8fc39 | 2006-06-25 15:34:39 -0300 | [diff] [blame] | 10 | #include <media/v4l2-common.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 11 | |
Mauro Carvalho Chehab | 5c07db0 | 2006-01-09 15:25:11 -0200 | [diff] [blame] | 12 | static int offset = 0; |
Mauro Carvalho Chehab | 4d98816 | 2006-08-12 21:59:19 -0300 | [diff] [blame] | 13 | module_param(offset, int, 0664); |
Mauro Carvalho Chehab | 5c07db0 | 2006-01-09 15:25:11 -0200 | [diff] [blame] | 14 | MODULE_PARM_DESC(offset,"Allows to specify an offset for tuner"); |
| 15 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 16 | /* ---------------------------------------------------------------------- */ |
| 17 | |
| 18 | /* tv standard selection for Temic 4046 FM5 |
| 19 | this value takes the low bits of control byte 2 |
| 20 | from datasheet Rev.01, Feb.00 |
| 21 | standard BG I L L2 D |
| 22 | picture IF 38.9 38.9 38.9 33.95 38.9 |
| 23 | sound 1 33.4 32.9 32.4 40.45 32.4 |
| 24 | sound 2 33.16 |
| 25 | NICAM 33.05 32.348 33.05 33.05 |
| 26 | */ |
| 27 | #define TEMIC_SET_PAL_I 0x05 |
| 28 | #define TEMIC_SET_PAL_DK 0x09 |
| 29 | #define TEMIC_SET_PAL_L 0x0a // SECAM ? |
| 30 | #define TEMIC_SET_PAL_L2 0x0b // change IF ! |
| 31 | #define TEMIC_SET_PAL_BG 0x0c |
| 32 | |
| 33 | /* tv tuner system standard selection for Philips FQ1216ME |
| 34 | this value takes the low bits of control byte 2 |
| 35 | from datasheet "1999 Nov 16" (supersedes "1999 Mar 23") |
| 36 | standard BG DK I L L` |
| 37 | picture carrier 38.90 38.90 38.90 38.90 33.95 |
| 38 | colour 34.47 34.47 34.47 34.47 38.38 |
| 39 | sound 1 33.40 32.40 32.90 32.40 40.45 |
| 40 | sound 2 33.16 - - - - |
| 41 | NICAM 33.05 33.05 32.35 33.05 39.80 |
| 42 | */ |
| 43 | #define PHILIPS_SET_PAL_I 0x01 /* Bit 2 always zero !*/ |
| 44 | #define PHILIPS_SET_PAL_BGDK 0x09 |
| 45 | #define PHILIPS_SET_PAL_L2 0x0a |
| 46 | #define PHILIPS_SET_PAL_L 0x0b |
| 47 | |
| 48 | /* system switching for Philips FI1216MF MK2 |
| 49 | from datasheet "1996 Jul 09", |
| 50 | standard BG L L' |
| 51 | picture carrier 38.90 38.90 33.95 |
| 52 | colour 34.47 34.37 38.38 |
| 53 | sound 1 33.40 32.40 40.45 |
| 54 | sound 2 33.16 - - |
| 55 | NICAM 33.05 33.05 39.80 |
| 56 | */ |
| 57 | #define PHILIPS_MF_SET_BG 0x01 /* Bit 2 must be zero, Bit 3 is system output */ |
| 58 | #define PHILIPS_MF_SET_PAL_L 0x03 // France |
| 59 | #define PHILIPS_MF_SET_PAL_L2 0x02 // L' |
| 60 | |
Mauro Carvalho Chehab | f7ce3cc | 2005-07-12 13:58:55 -0700 | [diff] [blame] | 61 | /* Control byte */ |
| 62 | |
| 63 | #define TUNER_RATIO_MASK 0x06 /* Bit cb1:cb2 */ |
| 64 | #define TUNER_RATIO_SELECT_50 0x00 |
| 65 | #define TUNER_RATIO_SELECT_32 0x02 |
| 66 | #define TUNER_RATIO_SELECT_166 0x04 |
| 67 | #define TUNER_RATIO_SELECT_62 0x06 |
| 68 | |
| 69 | #define TUNER_CHARGE_PUMP 0x40 /* Bit cb6 */ |
| 70 | |
| 71 | /* Status byte */ |
| 72 | |
| 73 | #define TUNER_POR 0x80 |
| 74 | #define TUNER_FL 0x40 |
| 75 | #define TUNER_MODE 0x38 |
| 76 | #define TUNER_AFC 0x07 |
| 77 | #define TUNER_SIGNAL 0x07 |
| 78 | #define TUNER_STEREO 0x10 |
| 79 | |
| 80 | #define TUNER_PLL_LOCKED 0x40 |
| 81 | #define TUNER_STEREO_MK3 0x04 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 82 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 83 | /* ---------------------------------------------------------------------- */ |
| 84 | |
| 85 | static int tuner_getstatus(struct i2c_client *c) |
| 86 | { |
| 87 | unsigned char byte; |
| 88 | |
| 89 | if (1 != i2c_master_recv(c,&byte,1)) |
| 90 | return 0; |
Mauro Carvalho Chehab | 56fc08c | 2005-06-23 22:05:07 -0700 | [diff] [blame] | 91 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 92 | return byte; |
| 93 | } |
| 94 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 95 | static int tuner_signal(struct i2c_client *c) |
| 96 | { |
Mauro Carvalho Chehab | 56fc08c | 2005-06-23 22:05:07 -0700 | [diff] [blame] | 97 | return (tuner_getstatus(c) & TUNER_SIGNAL) << 13; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 98 | } |
| 99 | |
| 100 | static int tuner_stereo(struct i2c_client *c) |
| 101 | { |
Mauro Carvalho Chehab | 56fc08c | 2005-06-23 22:05:07 -0700 | [diff] [blame] | 102 | int stereo, status; |
| 103 | struct tuner *t = i2c_get_clientdata(c); |
| 104 | |
| 105 | status = tuner_getstatus (c); |
| 106 | |
| 107 | switch (t->type) { |
Mauro Carvalho Chehab | 4ac9791 | 2005-11-08 21:37:43 -0800 | [diff] [blame] | 108 | case TUNER_PHILIPS_FM1216ME_MK3: |
Trent Piepho | 657de3c | 2006-06-20 00:30:57 -0300 | [diff] [blame] | 109 | case TUNER_PHILIPS_FM1236_MK3: |
Mauro Carvalho Chehab | 56fc08c | 2005-06-23 22:05:07 -0700 | [diff] [blame] | 110 | case TUNER_PHILIPS_FM1256_IH3: |
| 111 | stereo = ((status & TUNER_SIGNAL) == TUNER_STEREO_MK3); |
| 112 | break; |
| 113 | default: |
| 114 | stereo = status & TUNER_STEREO; |
| 115 | } |
| 116 | |
| 117 | return stereo; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 118 | } |
| 119 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 120 | |
| 121 | /* ---------------------------------------------------------------------- */ |
| 122 | |
| 123 | static void default_set_tv_freq(struct i2c_client *c, unsigned int freq) |
| 124 | { |
| 125 | struct tuner *t = i2c_get_clientdata(c); |
Michael Krufky | 3fc46d3 | 2006-01-23 17:11:11 -0200 | [diff] [blame] | 126 | u8 config, cb, tuneraddr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 127 | u16 div; |
| 128 | struct tunertype *tun; |
Hans Verkuil | 27487d4 | 2006-01-15 15:04:52 -0200 | [diff] [blame] | 129 | u8 buffer[4]; |
Michael Krufky | 7b0ac9c | 2006-01-13 14:10:25 -0200 | [diff] [blame] | 130 | int rc, IFPCoff, i, j; |
Michael Krufky | 476d63d | 2006-02-07 06:25:34 -0200 | [diff] [blame] | 131 | enum param_type desired_type; |
Hans Verkuil | ba8fc39 | 2006-06-25 15:34:39 -0300 | [diff] [blame] | 132 | struct tuner_params *params; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 133 | |
| 134 | tun = &tuners[t->type]; |
Michael Krufky | 7b0ac9c | 2006-01-13 14:10:25 -0200 | [diff] [blame] | 135 | |
Michael Krufky | 5f59418 | 2006-02-07 06:25:33 -0200 | [diff] [blame] | 136 | /* IFPCoff = Video Intermediate Frequency - Vif: |
| 137 | 940 =16*58.75 NTSC/J (Japan) |
| 138 | 732 =16*45.75 M/N STD |
| 139 | 704 =16*44 ATSC (at DVB code) |
| 140 | 632 =16*39.50 I U.K. |
| 141 | 622.4=16*38.90 B/G D/K I, L STD |
| 142 | 592 =16*37.00 D China |
| 143 | 590 =16.36.875 B Australia |
| 144 | 543.2=16*33.95 L' STD |
| 145 | 171.2=16*10.70 FM Radio (at set_radio_freq) |
| 146 | */ |
| 147 | |
| 148 | if (t->std == V4L2_STD_NTSC_M_JP) { |
Michael Krufky | 476d63d | 2006-02-07 06:25:34 -0200 | [diff] [blame] | 149 | IFPCoff = 940; |
| 150 | desired_type = TUNER_PARAM_TYPE_NTSC; |
Michael Krufky | 5f59418 | 2006-02-07 06:25:33 -0200 | [diff] [blame] | 151 | } else if ((t->std & V4L2_STD_MN) && |
| 152 | !(t->std & ~V4L2_STD_MN)) { |
Michael Krufky | 476d63d | 2006-02-07 06:25:34 -0200 | [diff] [blame] | 153 | IFPCoff = 732; |
| 154 | desired_type = TUNER_PARAM_TYPE_NTSC; |
Michael Krufky | 5f59418 | 2006-02-07 06:25:33 -0200 | [diff] [blame] | 155 | } else if (t->std == V4L2_STD_SECAM_LC) { |
Michael Krufky | 476d63d | 2006-02-07 06:25:34 -0200 | [diff] [blame] | 156 | IFPCoff = 543; |
| 157 | desired_type = TUNER_PARAM_TYPE_SECAM; |
Michael Krufky | 5f59418 | 2006-02-07 06:25:33 -0200 | [diff] [blame] | 158 | } else { |
Michael Krufky | 476d63d | 2006-02-07 06:25:34 -0200 | [diff] [blame] | 159 | IFPCoff = 623; |
| 160 | desired_type = TUNER_PARAM_TYPE_PAL; |
Michael Krufky | 5f59418 | 2006-02-07 06:25:33 -0200 | [diff] [blame] | 161 | } |
| 162 | |
Michael Krufky | 476d63d | 2006-02-07 06:25:34 -0200 | [diff] [blame] | 163 | for (j = 0; j < tun->count-1; j++) { |
| 164 | if (desired_type != tun->params[j].type) |
| 165 | continue; |
| 166 | break; |
| 167 | } |
Michael Krufky | 8f1a58d | 2006-02-07 06:25:39 -0200 | [diff] [blame] | 168 | /* use default tuner_params if desired_type not available */ |
Michael Krufky | 15207b2 | 2006-02-07 06:25:40 -0200 | [diff] [blame] | 169 | if (desired_type != tun->params[j].type) { |
| 170 | tuner_dbg("IFPCoff = %d: tuner_params undefined for tuner %d\n", |
| 171 | IFPCoff,t->type); |
Michael Krufky | 8f1a58d | 2006-02-07 06:25:39 -0200 | [diff] [blame] | 172 | j = 0; |
Michael Krufky | 15207b2 | 2006-02-07 06:25:40 -0200 | [diff] [blame] | 173 | } |
Hans Verkuil | ba8fc39 | 2006-06-25 15:34:39 -0300 | [diff] [blame] | 174 | params = &tun->params[j]; |
Michael Krufky | 8f1a58d | 2006-02-07 06:25:39 -0200 | [diff] [blame] | 175 | |
Hans Verkuil | ba8fc39 | 2006-06-25 15:34:39 -0300 | [diff] [blame] | 176 | for (i = 0; i < params->count; i++) { |
| 177 | if (freq > params->ranges[i].limit) |
Michael Krufky | 90200d2 | 2006-01-09 15:25:38 -0200 | [diff] [blame] | 178 | continue; |
| 179 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 180 | } |
Hans Verkuil | ba8fc39 | 2006-06-25 15:34:39 -0300 | [diff] [blame] | 181 | if (i == params->count) { |
Hans Verkuil | 27487d4 | 2006-01-15 15:04:52 -0200 | [diff] [blame] | 182 | tuner_dbg("TV frequency out of range (%d > %d)", |
Hans Verkuil | ba8fc39 | 2006-06-25 15:34:39 -0300 | [diff] [blame] | 183 | freq, params->ranges[i - 1].limit); |
| 184 | freq = params->ranges[--i].limit; |
Hans Verkuil | 27487d4 | 2006-01-15 15:04:52 -0200 | [diff] [blame] | 185 | } |
Hans Verkuil | ba8fc39 | 2006-06-25 15:34:39 -0300 | [diff] [blame] | 186 | config = params->ranges[i].config; |
| 187 | cb = params->ranges[i].cb; |
Michael Krufky | 5f59418 | 2006-02-07 06:25:33 -0200 | [diff] [blame] | 188 | /* i == 0 -> VHF_LO |
| 189 | * i == 1 -> VHF_HI |
| 190 | * i == 2 -> UHF */ |
Michael Krufky | bd0d0f5 | 2006-02-07 06:25:35 -0200 | [diff] [blame] | 191 | tuner_dbg("tv: param %d, range %d\n",j,i); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 192 | |
Michael Krufky | 5f59418 | 2006-02-07 06:25:33 -0200 | [diff] [blame] | 193 | div=freq + IFPCoff + offset; |
| 194 | |
| 195 | tuner_dbg("Freq= %d.%02d MHz, V_IF=%d.%02d MHz, Offset=%d.%02d MHz, div=%0d\n", |
| 196 | freq / 16, freq % 16 * 100 / 16, |
| 197 | IFPCoff / 16, IFPCoff % 16 * 100 / 16, |
| 198 | offset / 16, offset % 16 * 100 / 16, |
| 199 | div); |
| 200 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 201 | /* tv norm specific stuff for multi-norm tuners */ |
| 202 | switch (t->type) { |
| 203 | case TUNER_PHILIPS_SECAM: // FI1216MF |
| 204 | /* 0x01 -> ??? no change ??? */ |
| 205 | /* 0x02 -> PAL BDGHI / SECAM L */ |
| 206 | /* 0x04 -> ??? PAL others / SECAM others ??? */ |
Michael Krufky | ab66b22 | 2006-01-23 17:11:11 -0200 | [diff] [blame] | 207 | cb &= ~0x02; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 208 | if (t->std & V4L2_STD_SECAM) |
Michael Krufky | ab66b22 | 2006-01-23 17:11:11 -0200 | [diff] [blame] | 209 | cb |= 0x02; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 210 | break; |
| 211 | |
| 212 | case TUNER_TEMIC_4046FM5: |
Michael Krufky | ab66b22 | 2006-01-23 17:11:11 -0200 | [diff] [blame] | 213 | cb &= ~0x0f; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 214 | |
| 215 | if (t->std & V4L2_STD_PAL_BG) { |
Michael Krufky | ab66b22 | 2006-01-23 17:11:11 -0200 | [diff] [blame] | 216 | cb |= TEMIC_SET_PAL_BG; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 217 | |
| 218 | } else if (t->std & V4L2_STD_PAL_I) { |
Michael Krufky | ab66b22 | 2006-01-23 17:11:11 -0200 | [diff] [blame] | 219 | cb |= TEMIC_SET_PAL_I; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 220 | |
| 221 | } else if (t->std & V4L2_STD_PAL_DK) { |
Michael Krufky | ab66b22 | 2006-01-23 17:11:11 -0200 | [diff] [blame] | 222 | cb |= TEMIC_SET_PAL_DK; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 223 | |
| 224 | } else if (t->std & V4L2_STD_SECAM_L) { |
Michael Krufky | ab66b22 | 2006-01-23 17:11:11 -0200 | [diff] [blame] | 225 | cb |= TEMIC_SET_PAL_L; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 226 | |
| 227 | } |
| 228 | break; |
| 229 | |
| 230 | case TUNER_PHILIPS_FQ1216ME: |
Michael Krufky | ab66b22 | 2006-01-23 17:11:11 -0200 | [diff] [blame] | 231 | cb &= ~0x0f; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 232 | |
| 233 | if (t->std & (V4L2_STD_PAL_BG|V4L2_STD_PAL_DK)) { |
Michael Krufky | ab66b22 | 2006-01-23 17:11:11 -0200 | [diff] [blame] | 234 | cb |= PHILIPS_SET_PAL_BGDK; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 235 | |
| 236 | } else if (t->std & V4L2_STD_PAL_I) { |
Michael Krufky | ab66b22 | 2006-01-23 17:11:11 -0200 | [diff] [blame] | 237 | cb |= PHILIPS_SET_PAL_I; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 238 | |
| 239 | } else if (t->std & V4L2_STD_SECAM_L) { |
Michael Krufky | ab66b22 | 2006-01-23 17:11:11 -0200 | [diff] [blame] | 240 | cb |= PHILIPS_SET_PAL_L; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 241 | |
| 242 | } |
| 243 | break; |
| 244 | |
| 245 | case TUNER_PHILIPS_ATSC: |
| 246 | /* 0x00 -> ATSC antenna input 1 */ |
| 247 | /* 0x01 -> ATSC antenna input 2 */ |
| 248 | /* 0x02 -> NTSC antenna input 1 */ |
| 249 | /* 0x03 -> NTSC antenna input 2 */ |
Michael Krufky | ab66b22 | 2006-01-23 17:11:11 -0200 | [diff] [blame] | 250 | cb &= ~0x03; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 251 | if (!(t->std & V4L2_STD_ATSC)) |
Michael Krufky | ab66b22 | 2006-01-23 17:11:11 -0200 | [diff] [blame] | 252 | cb |= 2; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 253 | /* FIXME: input */ |
| 254 | break; |
| 255 | |
| 256 | case TUNER_MICROTUNE_4042FI5: |
| 257 | /* Set the charge pump for fast tuning */ |
Michael Krufky | 3fc46d3 | 2006-01-23 17:11:11 -0200 | [diff] [blame] | 258 | config |= TUNER_CHARGE_PUMP; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 259 | break; |
Kirk Lapray | e976f937 | 2005-11-08 21:37:04 -0800 | [diff] [blame] | 260 | |
| 261 | case TUNER_PHILIPS_TUV1236D: |
| 262 | /* 0x40 -> ATSC antenna input 1 */ |
| 263 | /* 0x48 -> ATSC antenna input 2 */ |
| 264 | /* 0x00 -> NTSC antenna input 1 */ |
| 265 | /* 0x08 -> NTSC antenna input 2 */ |
Kirk Lapray | fde6d31 | 2005-11-08 21:38:18 -0800 | [diff] [blame] | 266 | buffer[0] = 0x14; |
| 267 | buffer[1] = 0x00; |
| 268 | buffer[2] = 0x17; |
| 269 | buffer[3] = 0x00; |
Michael Krufky | ab66b22 | 2006-01-23 17:11:11 -0200 | [diff] [blame] | 270 | cb &= ~0x40; |
Kirk Lapray | fde6d31 | 2005-11-08 21:38:18 -0800 | [diff] [blame] | 271 | if (t->std & V4L2_STD_ATSC) { |
Michael Krufky | ab66b22 | 2006-01-23 17:11:11 -0200 | [diff] [blame] | 272 | cb |= 0x40; |
Kirk Lapray | fde6d31 | 2005-11-08 21:38:18 -0800 | [diff] [blame] | 273 | buffer[1] = 0x04; |
| 274 | } |
| 275 | /* set to the correct mode (analog or digital) */ |
Kirk Lapray | fde6d31 | 2005-11-08 21:38:18 -0800 | [diff] [blame] | 276 | tuneraddr = c->addr; |
| 277 | c->addr = 0x0a; |
| 278 | if (2 != (rc = i2c_master_send(c,&buffer[0],2))) |
| 279 | tuner_warn("i2c i/o error: rc == %d (should be 2)\n",rc); |
| 280 | if (2 != (rc = i2c_master_send(c,&buffer[2],2))) |
| 281 | tuner_warn("i2c i/o error: rc == %d (should be 2)\n",rc); |
| 282 | c->addr = tuneraddr; |
Kirk Lapray | e976f937 | 2005-11-08 21:37:04 -0800 | [diff] [blame] | 283 | /* FIXME: input */ |
| 284 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 285 | } |
| 286 | |
Hans Verkuil | ba8fc39 | 2006-06-25 15:34:39 -0300 | [diff] [blame] | 287 | if (params->cb_first_if_lower_freq && div < t->last_div) { |
Michael Krufky | 3fc46d3 | 2006-01-23 17:11:11 -0200 | [diff] [blame] | 288 | buffer[0] = config; |
Michael Krufky | ab66b22 | 2006-01-23 17:11:11 -0200 | [diff] [blame] | 289 | buffer[1] = cb; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 290 | buffer[2] = (div>>8) & 0x7f; |
| 291 | buffer[3] = div & 0xff; |
| 292 | } else { |
| 293 | buffer[0] = (div>>8) & 0x7f; |
| 294 | buffer[1] = div & 0xff; |
Michael Krufky | 3fc46d3 | 2006-01-23 17:11:11 -0200 | [diff] [blame] | 295 | buffer[2] = config; |
Michael Krufky | ab66b22 | 2006-01-23 17:11:11 -0200 | [diff] [blame] | 296 | buffer[3] = cb; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 297 | } |
Hans Verkuil | 27487d4 | 2006-01-15 15:04:52 -0200 | [diff] [blame] | 298 | t->last_div = div; |
Hans Verkuil | ba8fc39 | 2006-06-25 15:34:39 -0300 | [diff] [blame] | 299 | if (params->has_tda9887) { |
| 300 | int config = 0; |
| 301 | int is_secam_l = (t->std & (V4L2_STD_SECAM_L | V4L2_STD_SECAM_LC)) && |
| 302 | !(t->std & ~(V4L2_STD_SECAM_L | V4L2_STD_SECAM_LC)); |
| 303 | |
| 304 | if (t->std == V4L2_STD_SECAM_LC) { |
| 305 | if (params->port1_active ^ params->port1_invert_for_secam_lc) |
| 306 | config |= TDA9887_PORT1_ACTIVE; |
| 307 | if (params->port2_active ^ params->port2_invert_for_secam_lc) |
| 308 | config |= TDA9887_PORT2_ACTIVE; |
| 309 | } |
| 310 | else { |
| 311 | if (params->port1_active) |
| 312 | config |= TDA9887_PORT1_ACTIVE; |
| 313 | if (params->port2_active) |
| 314 | config |= TDA9887_PORT2_ACTIVE; |
| 315 | } |
| 316 | if (params->intercarrier_mode) |
| 317 | config |= TDA9887_INTERCARRIER; |
| 318 | if (is_secam_l) { |
| 319 | if (i == 0 && params->default_top_secam_low) |
| 320 | config |= TDA9887_TOP(params->default_top_secam_low); |
| 321 | else if (i == 1 && params->default_top_secam_mid) |
| 322 | config |= TDA9887_TOP(params->default_top_secam_mid); |
| 323 | else if (params->default_top_secam_high) |
| 324 | config |= TDA9887_TOP(params->default_top_secam_high); |
| 325 | } |
| 326 | else { |
| 327 | if (i == 0 && params->default_top_low) |
| 328 | config |= TDA9887_TOP(params->default_top_low); |
| 329 | else if (i == 1 && params->default_top_mid) |
| 330 | config |= TDA9887_TOP(params->default_top_mid); |
| 331 | else if (params->default_top_high) |
| 332 | config |= TDA9887_TOP(params->default_top_high); |
| 333 | } |
Trent Piepho | d7304de | 2006-08-24 22:43:45 -0300 | [diff] [blame] | 334 | if (params->default_pll_gating_18) |
| 335 | config |= TDA9887_GATING_18; |
Hans Verkuil | ba8fc39 | 2006-06-25 15:34:39 -0300 | [diff] [blame] | 336 | i2c_clients_command(c->adapter, TDA9887_SET_CONFIG, &config); |
| 337 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 338 | tuner_dbg("tv 0x%02x 0x%02x 0x%02x 0x%02x\n", |
| 339 | buffer[0],buffer[1],buffer[2],buffer[3]); |
| 340 | |
Mauro Carvalho Chehab | 4ac9791 | 2005-11-08 21:37:43 -0800 | [diff] [blame] | 341 | if (4 != (rc = i2c_master_send(c,buffer,4))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 342 | tuner_warn("i2c i/o error: rc == %d (should be 4)\n",rc); |
| 343 | |
Michael Krufky | d9cd2d9 | 2006-07-17 17:15:26 -0300 | [diff] [blame] | 344 | switch (t->type) { |
| 345 | case TUNER_LG_TDVS_H06XF: |
| 346 | /* Set the Auxiliary Byte. */ |
| 347 | buffer[0] = buffer[2]; |
| 348 | buffer[0] &= ~0x20; |
| 349 | buffer[0] |= 0x18; |
| 350 | buffer[1] = 0x20; |
| 351 | tuner_dbg("tv 0x%02x 0x%02x\n",buffer[0],buffer[1]); |
| 352 | |
| 353 | if (2 != (rc = i2c_master_send(c,buffer,2))) |
| 354 | tuner_warn("i2c i/o error: rc == %d (should be 2)\n",rc); |
| 355 | break; |
| 356 | case TUNER_MICROTUNE_4042FI5: |
| 357 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 358 | // FIXME - this may also work for other tuners |
| 359 | unsigned long timeout = jiffies + msecs_to_jiffies(1); |
| 360 | u8 status_byte = 0; |
| 361 | |
| 362 | /* Wait until the PLL locks */ |
| 363 | for (;;) { |
| 364 | if (time_after(jiffies,timeout)) |
| 365 | return; |
| 366 | if (1 != (rc = i2c_master_recv(c,&status_byte,1))) { |
| 367 | tuner_warn("i2c i/o read error: rc == %d (should be 1)\n",rc); |
| 368 | break; |
| 369 | } |
Mauro Carvalho Chehab | f7ce3cc | 2005-07-12 13:58:55 -0700 | [diff] [blame] | 370 | if (status_byte & TUNER_PLL_LOCKED) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 371 | break; |
| 372 | udelay(10); |
| 373 | } |
| 374 | |
| 375 | /* Set the charge pump for optimized phase noise figure */ |
Michael Krufky | 3fc46d3 | 2006-01-23 17:11:11 -0200 | [diff] [blame] | 376 | config &= ~TUNER_CHARGE_PUMP; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 377 | buffer[0] = (div>>8) & 0x7f; |
| 378 | buffer[1] = div & 0xff; |
Michael Krufky | 3fc46d3 | 2006-01-23 17:11:11 -0200 | [diff] [blame] | 379 | buffer[2] = config; |
Michael Krufky | ab66b22 | 2006-01-23 17:11:11 -0200 | [diff] [blame] | 380 | buffer[3] = cb; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 381 | tuner_dbg("tv 0x%02x 0x%02x 0x%02x 0x%02x\n", |
Michael Krufky | d9cd2d9 | 2006-07-17 17:15:26 -0300 | [diff] [blame] | 382 | buffer[0],buffer[1],buffer[2],buffer[3]); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 383 | |
| 384 | if (4 != (rc = i2c_master_send(c,buffer,4))) |
| 385 | tuner_warn("i2c i/o error: rc == %d (should be 4)\n",rc); |
Michael Krufky | d9cd2d9 | 2006-07-17 17:15:26 -0300 | [diff] [blame] | 386 | break; |
| 387 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 388 | } |
| 389 | } |
| 390 | |
| 391 | static void default_set_radio_freq(struct i2c_client *c, unsigned int freq) |
| 392 | { |
| 393 | struct tunertype *tun; |
| 394 | struct tuner *t = i2c_get_clientdata(c); |
Hans Verkuil | 27487d4 | 2006-01-15 15:04:52 -0200 | [diff] [blame] | 395 | u8 buffer[4]; |
| 396 | u16 div; |
Michael Krufky | 7b0ac9c | 2006-01-13 14:10:25 -0200 | [diff] [blame] | 397 | int rc, j; |
Michael Krufky | 476d63d | 2006-02-07 06:25:34 -0200 | [diff] [blame] | 398 | enum param_type desired_type = TUNER_PARAM_TYPE_RADIO; |
Hans Verkuil | ba8fc39 | 2006-06-25 15:34:39 -0300 | [diff] [blame] | 399 | struct tuner_params *params; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 400 | |
Mauro Carvalho Chehab | f7ce3cc | 2005-07-12 13:58:55 -0700 | [diff] [blame] | 401 | tun = &tuners[t->type]; |
Michael Krufky | 476d63d | 2006-02-07 06:25:34 -0200 | [diff] [blame] | 402 | |
| 403 | for (j = 0; j < tun->count-1; j++) { |
| 404 | if (desired_type != tun->params[j].type) |
| 405 | continue; |
| 406 | break; |
| 407 | } |
Michael Krufky | 8f1a58d | 2006-02-07 06:25:39 -0200 | [diff] [blame] | 408 | /* use default tuner_params if desired_type not available */ |
| 409 | if (desired_type != tun->params[j].type) |
| 410 | j = 0; |
Michael Krufky | 7b0ac9c | 2006-01-13 14:10:25 -0200 | [diff] [blame] | 411 | |
Mauro Carvalho Chehab | f7ce3cc | 2005-07-12 13:58:55 -0700 | [diff] [blame] | 412 | div = (20 * freq / 16000) + (int)(20*10.7); /* IF 10.7 MHz */ |
Hans Verkuil | ba8fc39 | 2006-06-25 15:34:39 -0300 | [diff] [blame] | 413 | params = &tun->params[j]; |
| 414 | buffer[2] = (params->ranges[0].config & ~TUNER_RATIO_MASK) | TUNER_RATIO_SELECT_50; /* 50 kHz step */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 415 | |
| 416 | switch (t->type) { |
Mauro Carvalho Chehab | 56fc08c | 2005-06-23 22:05:07 -0700 | [diff] [blame] | 417 | case TUNER_TENA_9533_DI: |
Mauro Carvalho Chehab | 391cd72 | 2005-06-23 22:02:43 -0700 | [diff] [blame] | 418 | case TUNER_YMEC_TVF_5533MF: |
Mauro Carvalho Chehab | f7ce3cc | 2005-07-12 13:58:55 -0700 | [diff] [blame] | 419 | tuner_dbg ("This tuner doesn't have FM. Most cards has a TEA5767 for FM\n"); |
| 420 | return; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 421 | case TUNER_PHILIPS_FM1216ME_MK3: |
| 422 | case TUNER_PHILIPS_FM1236_MK3: |
Mauro Carvalho Chehab | 586b0ca | 2005-06-28 20:45:21 -0700 | [diff] [blame] | 423 | case TUNER_PHILIPS_FMD1216ME_MK3: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 424 | buffer[3] = 0x19; |
| 425 | break; |
Mauro Carvalho Chehab | efcf55c | 2006-03-09 11:17:43 -0300 | [diff] [blame] | 426 | case TUNER_TNF_5335MF: |
| 427 | buffer[3] = 0x11; |
| 428 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 429 | case TUNER_PHILIPS_FM1256_IH3: |
Mauro Carvalho Chehab | f7ce3cc | 2005-07-12 13:58:55 -0700 | [diff] [blame] | 430 | div = (20 * freq) / 16000 + (int)(33.3 * 20); /* IF 33.3 MHz */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 431 | buffer[3] = 0x19; |
| 432 | break; |
| 433 | case TUNER_LG_PAL_FM: |
| 434 | buffer[3] = 0xa5; |
| 435 | break; |
Mauro Carvalho Chehab | 33ac6b5 | 2005-09-09 13:03:56 -0700 | [diff] [blame] | 436 | case TUNER_MICROTUNE_4049FM5: |
| 437 | div = (20 * freq) / 16000 + (int)(33.3 * 20); /* IF 33.3 MHz */ |
| 438 | buffer[3] = 0xa4; |
| 439 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 440 | default: |
| 441 | buffer[3] = 0xa4; |
| 442 | break; |
| 443 | } |
Hans Verkuil | ba8fc39 | 2006-06-25 15:34:39 -0300 | [diff] [blame] | 444 | if (params->cb_first_if_lower_freq && div < t->last_div) { |
Hans Verkuil | 27487d4 | 2006-01-15 15:04:52 -0200 | [diff] [blame] | 445 | buffer[0] = buffer[2]; |
| 446 | buffer[1] = buffer[3]; |
| 447 | buffer[2] = (div>>8) & 0x7f; |
| 448 | buffer[3] = div & 0xff; |
| 449 | } else { |
| 450 | buffer[0] = (div>>8) & 0x7f; |
| 451 | buffer[1] = div & 0xff; |
| 452 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 453 | |
| 454 | tuner_dbg("radio 0x%02x 0x%02x 0x%02x 0x%02x\n", |
| 455 | buffer[0],buffer[1],buffer[2],buffer[3]); |
Hans Verkuil | 27487d4 | 2006-01-15 15:04:52 -0200 | [diff] [blame] | 456 | t->last_div = div; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 457 | |
Hans Verkuil | ba8fc39 | 2006-06-25 15:34:39 -0300 | [diff] [blame] | 458 | if (params->has_tda9887) { |
| 459 | int config = 0; |
| 460 | if (params->port1_active && !params->port1_fm_high_sensitivity) |
| 461 | config |= TDA9887_PORT1_ACTIVE; |
| 462 | if (params->port2_active && !params->port2_fm_high_sensitivity) |
| 463 | config |= TDA9887_PORT2_ACTIVE; |
| 464 | if (params->intercarrier_mode) |
| 465 | config |= TDA9887_INTERCARRIER; |
| 466 | /* if (params->port1_set_for_fm_mono) |
| 467 | config &= ~TDA9887_PORT1_ACTIVE;*/ |
| 468 | i2c_clients_command(c->adapter, TDA9887_SET_CONFIG, &config); |
| 469 | } |
Mauro Carvalho Chehab | 4ac9791 | 2005-11-08 21:37:43 -0800 | [diff] [blame] | 470 | if (4 != (rc = i2c_master_send(c,buffer,4))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 471 | tuner_warn("i2c i/o error: rc == %d (should be 4)\n",rc); |
| 472 | } |
| 473 | |
| 474 | int default_tuner_init(struct i2c_client *c) |
| 475 | { |
| 476 | struct tuner *t = i2c_get_clientdata(c); |
| 477 | |
| 478 | tuner_info("type set to %d (%s)\n", |
| 479 | t->type, tuners[t->type].name); |
| 480 | strlcpy(c->name, tuners[t->type].name, sizeof(c->name)); |
| 481 | |
Hans Verkuil | 27487d4 | 2006-01-15 15:04:52 -0200 | [diff] [blame] | 482 | t->set_tv_freq = default_set_tv_freq; |
| 483 | t->set_radio_freq = default_set_radio_freq; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 484 | t->has_signal = tuner_signal; |
Hans Verkuil | 27487d4 | 2006-01-15 15:04:52 -0200 | [diff] [blame] | 485 | t->is_stereo = tuner_stereo; |
Mauro Carvalho Chehab | 793cf9e | 2005-09-09 13:03:37 -0700 | [diff] [blame] | 486 | t->standby = NULL; |
Mauro Carvalho Chehab | 586b0ca | 2005-06-28 20:45:21 -0700 | [diff] [blame] | 487 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 488 | return 0; |
| 489 | } |
| 490 | |
| 491 | /* |
| 492 | * Overrides for Emacs so that we follow Linus's tabbing style. |
| 493 | * --------------------------------------------------------------------------- |
| 494 | * Local variables: |
| 495 | * c-basic-offset: 8 |
| 496 | * End: |
| 497 | */ |