Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 1 | /* |
| 2 | * Programming the mspx4xx sound processor family |
| 3 | * |
| 4 | * (c) 1997-2001 Gerd Knorr <kraxel@bytesex.org> |
| 5 | * |
| 6 | * what works and what doesn't: |
| 7 | * |
| 8 | * AM-Mono |
| 9 | * Support for Hauppauge cards added (decoding handled by tuner) added by |
| 10 | * Frederic Crozat <fcrozat@mail.dotcom.fr> |
| 11 | * |
| 12 | * FM-Mono |
| 13 | * should work. The stereo modes are backward compatible to FM-mono, |
| 14 | * therefore FM-Mono should be allways available. |
| 15 | * |
| 16 | * FM-Stereo (B/G, used in germany) |
| 17 | * should work, with autodetect |
| 18 | * |
| 19 | * FM-Stereo (satellite) |
| 20 | * should work, no autodetect (i.e. default is mono, but you can |
| 21 | * switch to stereo -- untested) |
| 22 | * |
| 23 | * NICAM (B/G, L , used in UK, Scandinavia, Spain and France) |
| 24 | * should work, with autodetect. Support for NICAM was added by |
| 25 | * Pekka Pietikainen <pp@netppl.fi> |
| 26 | * |
| 27 | * TODO: |
| 28 | * - better SAT support |
| 29 | * |
| 30 | * 980623 Thomas Sailer (sailer@ife.ee.ethz.ch) |
| 31 | * using soundcore instead of OSS |
| 32 | * |
| 33 | * This program is free software; you can redistribute it and/or |
| 34 | * modify it under the terms of the GNU General Public License |
| 35 | * as published by the Free Software Foundation; either version 2 |
| 36 | * of the License, or (at your option) any later version. |
| 37 | * |
| 38 | * This program is distributed in the hope that it will be useful, |
| 39 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 40 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 41 | * GNU General Public License for more details. |
| 42 | * |
| 43 | * You should have received a copy of the GNU General Public License |
| 44 | * along with this program; if not, write to the Free Software |
Hans Verkuil | d52c738 | 2007-12-12 08:25:18 -0300 | [diff] [blame] | 45 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
| 46 | * 02110-1301, USA. |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 47 | */ |
| 48 | |
| 49 | |
| 50 | #include <linux/kernel.h> |
| 51 | #include <linux/module.h> |
| 52 | #include <linux/slab.h> |
| 53 | #include <linux/i2c.h> |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 54 | #include <linux/kthread.h> |
Nigel Cunningham | 7dfb710 | 2006-12-06 20:34:23 -0800 | [diff] [blame] | 55 | #include <linux/freezer.h> |
Mauro Carvalho Chehab | 2c26976 | 2009-03-30 08:18:10 -0300 | [diff] [blame] | 56 | #include <linux/videodev2.h> |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 57 | #include <media/v4l2-device.h> |
| 58 | #include <media/v4l2-ioctl.h> |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 59 | #include <media/msp3400.h> |
| 60 | #include <media/tvaudio.h> |
Hans Verkuil | 49965a8 | 2006-03-19 08:45:38 -0300 | [diff] [blame] | 61 | #include "msp3400-driver.h" |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 62 | |
| 63 | /* ---------------------------------------------------------------------- */ |
| 64 | |
| 65 | MODULE_DESCRIPTION("device driver for msp34xx TV sound processor"); |
| 66 | MODULE_AUTHOR("Gerd Knorr"); |
| 67 | MODULE_LICENSE("GPL"); |
| 68 | |
| 69 | /* module parameters */ |
| 70 | static int opmode = OPMODE_AUTO; |
Mauro Carvalho Chehab | a5ed425 | 2006-01-13 14:10:19 -0200 | [diff] [blame] | 71 | int msp_debug; /* msp_debug output */ |
Lucas De Marchi | 25985ed | 2011-03-30 22:57:33 -0300 | [diff] [blame] | 72 | int msp_once; /* no continuous stereo monitoring */ |
Mauro Carvalho Chehab | a5ed425 | 2006-01-13 14:10:19 -0200 | [diff] [blame] | 73 | int msp_amsound; /* hard-wire AM sound at 6.5 Hz (france), |
| 74 | the autoscan seems work well only with FM... */ |
Hans Verkuil | d52c738 | 2007-12-12 08:25:18 -0300 | [diff] [blame] | 75 | int msp_standard = 1; /* Override auto detect of audio msp_standard, |
| 76 | if needed. */ |
Mauro Carvalho Chehab | a5ed425 | 2006-01-13 14:10:19 -0200 | [diff] [blame] | 77 | int msp_dolby; |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 78 | |
Mauro Carvalho Chehab | f167cb4e | 2006-01-11 19:41:49 -0200 | [diff] [blame] | 79 | int msp_stereo_thresh = 0x190; /* a2 threshold for stereo/bilingual |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 80 | (msp34xxg only) 0x00a0-0x03c0 */ |
| 81 | |
| 82 | /* read-only */ |
| 83 | module_param(opmode, int, 0444); |
| 84 | |
| 85 | /* read-write */ |
Hans Verkuil | d52c738 | 2007-12-12 08:25:18 -0300 | [diff] [blame] | 86 | module_param_named(once, msp_once, bool, 0644); |
| 87 | module_param_named(debug, msp_debug, int, 0644); |
| 88 | module_param_named(stereo_threshold, msp_stereo_thresh, int, 0644); |
| 89 | module_param_named(standard, msp_standard, int, 0644); |
| 90 | module_param_named(amsound, msp_amsound, bool, 0644); |
| 91 | module_param_named(dolby, msp_dolby, bool, 0644); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 92 | |
| 93 | MODULE_PARM_DESC(opmode, "Forces a MSP3400 opmode. 0=Manual, 1=Autodetect, 2=Autodetect and autoselect"); |
| 94 | MODULE_PARM_DESC(once, "No continuous stereo monitoring"); |
| 95 | MODULE_PARM_DESC(debug, "Enable debug messages [0-3]"); |
| 96 | MODULE_PARM_DESC(stereo_threshold, "Sets signal threshold to activate stereo"); |
| 97 | MODULE_PARM_DESC(standard, "Specify audio standard: 32 = NTSC, 64 = radio, Default: Autodetect"); |
| 98 | MODULE_PARM_DESC(amsound, "Hardwire AM sound at 6.5Hz (France), FM can autoscan"); |
Justin P. Mattock | 70f23fd | 2011-05-10 10:16:21 +0200 | [diff] [blame] | 99 | MODULE_PARM_DESC(dolby, "Activates Dolby processing"); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 100 | |
| 101 | /* ---------------------------------------------------------------------- */ |
| 102 | |
| 103 | /* control subaddress */ |
| 104 | #define I2C_MSP_CONTROL 0x00 |
| 105 | /* demodulator unit subaddress */ |
| 106 | #define I2C_MSP_DEM 0x10 |
| 107 | /* DSP unit subaddress */ |
| 108 | #define I2C_MSP_DSP 0x12 |
| 109 | |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 110 | |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 111 | /* ----------------------------------------------------------------------- */ |
| 112 | /* functions for talking to the MSP3400C Sound processor */ |
| 113 | |
| 114 | int msp_reset(struct i2c_client *client) |
| 115 | { |
| 116 | /* reset and read revision code */ |
| 117 | static u8 reset_off[3] = { I2C_MSP_CONTROL, 0x80, 0x00 }; |
| 118 | static u8 reset_on[3] = { I2C_MSP_CONTROL, 0x00, 0x00 }; |
| 119 | static u8 write[3] = { I2C_MSP_DSP + 1, 0x00, 0x1e }; |
| 120 | u8 read[2]; |
| 121 | struct i2c_msg reset[2] = { |
| 122 | { client->addr, I2C_M_IGNORE_NAK, 3, reset_off }, |
| 123 | { client->addr, I2C_M_IGNORE_NAK, 3, reset_on }, |
| 124 | }; |
| 125 | struct i2c_msg test[2] = { |
| 126 | { client->addr, 0, 3, write }, |
| 127 | { client->addr, I2C_M_RD, 2, read }, |
| 128 | }; |
| 129 | |
Mauro Carvalho Chehab | f167cb4e | 2006-01-11 19:41:49 -0200 | [diff] [blame] | 130 | v4l_dbg(3, msp_debug, client, "msp_reset\n"); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 131 | if (i2c_transfer(client->adapter, &reset[0], 1) != 1 || |
| 132 | i2c_transfer(client->adapter, &reset[1], 1) != 1 || |
| 133 | i2c_transfer(client->adapter, test, 2) != 2) { |
Hans Verkuil | 7e8b09e | 2006-01-09 15:32:40 -0200 | [diff] [blame] | 134 | v4l_err(client, "chip reset failed\n"); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 135 | return -1; |
| 136 | } |
| 137 | return 0; |
| 138 | } |
| 139 | |
| 140 | static int msp_read(struct i2c_client *client, int dev, int addr) |
| 141 | { |
| 142 | int err, retval; |
| 143 | u8 write[3]; |
| 144 | u8 read[2]; |
| 145 | struct i2c_msg msgs[2] = { |
| 146 | { client->addr, 0, 3, write }, |
| 147 | { client->addr, I2C_M_RD, 2, read } |
| 148 | }; |
| 149 | |
| 150 | write[0] = dev + 1; |
| 151 | write[1] = addr >> 8; |
| 152 | write[2] = addr & 0xff; |
| 153 | |
| 154 | for (err = 0; err < 3; err++) { |
| 155 | if (i2c_transfer(client->adapter, msgs, 2) == 2) |
| 156 | break; |
Hans Verkuil | 7e8b09e | 2006-01-09 15:32:40 -0200 | [diff] [blame] | 157 | v4l_warn(client, "I/O error #%d (read 0x%02x/0x%02x)\n", err, |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 158 | dev, addr); |
Robert P. J. Day | f3a43d3 | 2007-07-16 10:46:42 -0300 | [diff] [blame] | 159 | schedule_timeout_interruptible(msecs_to_jiffies(10)); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 160 | } |
| 161 | if (err == 3) { |
Hans Verkuil | d52c738 | 2007-12-12 08:25:18 -0300 | [diff] [blame] | 162 | v4l_warn(client, "resetting chip, sound will go off.\n"); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 163 | msp_reset(client); |
| 164 | return -1; |
| 165 | } |
| 166 | retval = read[0] << 8 | read[1]; |
Hans Verkuil | d52c738 | 2007-12-12 08:25:18 -0300 | [diff] [blame] | 167 | v4l_dbg(3, msp_debug, client, "msp_read(0x%x, 0x%x): 0x%x\n", |
| 168 | dev, addr, retval); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 169 | return retval; |
| 170 | } |
| 171 | |
| 172 | int msp_read_dem(struct i2c_client *client, int addr) |
| 173 | { |
| 174 | return msp_read(client, I2C_MSP_DEM, addr); |
| 175 | } |
| 176 | |
| 177 | int msp_read_dsp(struct i2c_client *client, int addr) |
| 178 | { |
| 179 | return msp_read(client, I2C_MSP_DSP, addr); |
| 180 | } |
| 181 | |
| 182 | static int msp_write(struct i2c_client *client, int dev, int addr, int val) |
| 183 | { |
| 184 | int err; |
| 185 | u8 buffer[5]; |
| 186 | |
| 187 | buffer[0] = dev; |
| 188 | buffer[1] = addr >> 8; |
| 189 | buffer[2] = addr & 0xff; |
| 190 | buffer[3] = val >> 8; |
| 191 | buffer[4] = val & 0xff; |
| 192 | |
Hans Verkuil | d52c738 | 2007-12-12 08:25:18 -0300 | [diff] [blame] | 193 | v4l_dbg(3, msp_debug, client, "msp_write(0x%x, 0x%x, 0x%x)\n", |
| 194 | dev, addr, val); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 195 | for (err = 0; err < 3; err++) { |
| 196 | if (i2c_master_send(client, buffer, 5) == 5) |
| 197 | break; |
Hans Verkuil | 7e8b09e | 2006-01-09 15:32:40 -0200 | [diff] [blame] | 198 | v4l_warn(client, "I/O error #%d (write 0x%02x/0x%02x)\n", err, |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 199 | dev, addr); |
Robert P. J. Day | f3a43d3 | 2007-07-16 10:46:42 -0300 | [diff] [blame] | 200 | schedule_timeout_interruptible(msecs_to_jiffies(10)); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 201 | } |
| 202 | if (err == 3) { |
Hans Verkuil | d52c738 | 2007-12-12 08:25:18 -0300 | [diff] [blame] | 203 | v4l_warn(client, "resetting chip, sound will go off.\n"); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 204 | msp_reset(client); |
| 205 | return -1; |
| 206 | } |
| 207 | return 0; |
| 208 | } |
| 209 | |
| 210 | int msp_write_dem(struct i2c_client *client, int addr, int val) |
| 211 | { |
| 212 | return msp_write(client, I2C_MSP_DEM, addr, val); |
| 213 | } |
| 214 | |
| 215 | int msp_write_dsp(struct i2c_client *client, int addr, int val) |
| 216 | { |
| 217 | return msp_write(client, I2C_MSP_DSP, addr, val); |
| 218 | } |
| 219 | |
| 220 | /* ----------------------------------------------------------------------- * |
| 221 | * bits 9 8 5 - SCART DSP input Select: |
| 222 | * 0 0 0 - SCART 1 to DSP input (reset position) |
| 223 | * 0 1 0 - MONO to DSP input |
| 224 | * 1 0 0 - SCART 2 to DSP input |
| 225 | * 1 1 1 - Mute DSP input |
| 226 | * |
| 227 | * bits 11 10 6 - SCART 1 Output Select: |
| 228 | * 0 0 0 - undefined (reset position) |
| 229 | * 0 1 0 - SCART 2 Input to SCART 1 Output (for devices with 2 SCARTS) |
| 230 | * 1 0 0 - MONO input to SCART 1 Output |
| 231 | * 1 1 0 - SCART 1 DA to SCART 1 Output |
| 232 | * 0 0 1 - SCART 2 DA to SCART 1 Output |
| 233 | * 0 1 1 - SCART 1 Input to SCART 1 Output |
| 234 | * 1 1 1 - Mute SCART 1 Output |
| 235 | * |
| 236 | * bits 13 12 7 - SCART 2 Output Select (for devices with 2 Output SCART): |
| 237 | * 0 0 0 - SCART 1 DA to SCART 2 Output (reset position) |
| 238 | * 0 1 0 - SCART 1 Input to SCART 2 Output |
| 239 | * 1 0 0 - MONO input to SCART 2 Output |
| 240 | * 0 0 1 - SCART 2 DA to SCART 2 Output |
| 241 | * 0 1 1 - SCART 2 Input to SCART 2 Output |
| 242 | * 1 1 0 - Mute SCART 2 Output |
| 243 | * |
| 244 | * Bits 4 to 0 should be zero. |
| 245 | * ----------------------------------------------------------------------- */ |
| 246 | |
| 247 | static int scarts[3][9] = { |
Michael Krufky | b930e1d | 2007-08-27 18:16:54 -0300 | [diff] [blame] | 248 | /* MASK IN1 IN2 IN3 IN4 IN1_DA IN2_DA MONO MUTE */ |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 249 | /* SCART DSP Input select */ |
Michael Krufky | b930e1d | 2007-08-27 18:16:54 -0300 | [diff] [blame] | 250 | { 0x0320, 0x0000, 0x0200, 0x0300, 0x0020, -1, -1, 0x0100, 0x0320 }, |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 251 | /* SCART1 Output select */ |
Michael Krufky | b930e1d | 2007-08-27 18:16:54 -0300 | [diff] [blame] | 252 | { 0x0c40, 0x0440, 0x0400, 0x0000, 0x0840, 0x0c00, 0x0040, 0x0800, 0x0c40 }, |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 253 | /* SCART2 Output select */ |
Michael Krufky | b930e1d | 2007-08-27 18:16:54 -0300 | [diff] [blame] | 254 | { 0x3080, 0x1000, 0x1080, 0x2080, 0x3080, 0x0000, 0x0080, 0x2000, 0x3000 }, |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 255 | }; |
| 256 | |
| 257 | static char *scart_names[] = { |
Michael Krufky | b930e1d | 2007-08-27 18:16:54 -0300 | [diff] [blame] | 258 | "in1", "in2", "in3", "in4", "in1 da", "in2 da", "mono", "mute" |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 259 | }; |
| 260 | |
| 261 | void msp_set_scart(struct i2c_client *client, int in, int out) |
| 262 | { |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 263 | struct msp_state *state = to_state(i2c_get_clientdata(client)); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 264 | |
Hans Verkuil | 4277257 | 2006-03-19 06:48:51 -0300 | [diff] [blame] | 265 | state->in_scart = in; |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 266 | |
Hans Verkuil | 4277257 | 2006-03-19 06:48:51 -0300 | [diff] [blame] | 267 | if (in >= 0 && in <= 7 && out >= 0 && out <= 2) { |
| 268 | if (-1 == scarts[out][in + 1]) |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 269 | return; |
| 270 | |
Hans Verkuil | 4277257 | 2006-03-19 06:48:51 -0300 | [diff] [blame] | 271 | state->acb &= ~scarts[out][0]; |
| 272 | state->acb |= scarts[out][in + 1]; |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 273 | } else |
| 274 | state->acb = 0xf60; /* Mute Input and SCART 1 Output */ |
| 275 | |
Mauro Carvalho Chehab | f167cb4e | 2006-01-11 19:41:49 -0200 | [diff] [blame] | 276 | v4l_dbg(1, msp_debug, client, "scart switch: %s => %d (ACB=0x%04x)\n", |
Hans Verkuil | d52c738 | 2007-12-12 08:25:18 -0300 | [diff] [blame] | 277 | scart_names[in], out, state->acb); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 278 | msp_write_dsp(client, 0x13, state->acb); |
| 279 | |
| 280 | /* Sets I2S speed 0 = 1.024 Mbps, 1 = 2.048 Mbps */ |
Hans Verkuil | dc555aa | 2006-03-28 18:32:52 -0300 | [diff] [blame] | 281 | if (state->has_i2s_conf) |
| 282 | msp_write_dem(client, 0x40, state->i2s_mode); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 283 | } |
| 284 | |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 285 | /* ------------------------------------------------------------------------ */ |
| 286 | |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 287 | static void msp_wake_thread(struct i2c_client *client) |
| 288 | { |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 289 | struct msp_state *state = to_state(i2c_get_clientdata(client)); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 290 | |
| 291 | if (NULL == state->kthread) |
| 292 | return; |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 293 | state->watch_stereo = 0; |
| 294 | state->restart = 1; |
| 295 | wake_up_interruptible(&state->wq); |
| 296 | } |
| 297 | |
| 298 | int msp_sleep(struct msp_state *state, int timeout) |
| 299 | { |
| 300 | DECLARE_WAITQUEUE(wait, current); |
| 301 | |
| 302 | add_wait_queue(&state->wq, &wait); |
| 303 | if (!kthread_should_stop()) { |
| 304 | if (timeout < 0) { |
| 305 | set_current_state(TASK_INTERRUPTIBLE); |
| 306 | schedule(); |
| 307 | } else { |
| 308 | schedule_timeout_interruptible |
| 309 | (msecs_to_jiffies(timeout)); |
| 310 | } |
| 311 | } |
| 312 | |
| 313 | remove_wait_queue(&state->wq, &wait); |
| 314 | try_to_freeze(); |
| 315 | return state->restart; |
| 316 | } |
| 317 | |
| 318 | /* ------------------------------------------------------------------------ */ |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 319 | |
Hans Verkuil | ebc3bba | 2010-05-24 10:01:58 -0300 | [diff] [blame] | 320 | static int msp_s_ctrl(struct v4l2_ctrl *ctrl) |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 321 | { |
Hans Verkuil | ebc3bba | 2010-05-24 10:01:58 -0300 | [diff] [blame] | 322 | struct msp_state *state = ctrl_to_state(ctrl); |
| 323 | struct i2c_client *client = v4l2_get_subdevdata(&state->sd); |
| 324 | int val = ctrl->val; |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 325 | |
| 326 | switch (ctrl->id) { |
Hans Verkuil | ebc3bba | 2010-05-24 10:01:58 -0300 | [diff] [blame] | 327 | case V4L2_CID_AUDIO_VOLUME: { |
| 328 | /* audio volume cluster */ |
| 329 | int reallymuted = state->muted->val | state->scan_in_progress; |
Hans Verkuil | d312a46 | 2006-01-09 18:21:36 -0200 | [diff] [blame] | 330 | |
Hans Verkuil | ebc3bba | 2010-05-24 10:01:58 -0300 | [diff] [blame] | 331 | if (!reallymuted) |
| 332 | val = (val * 0x7f / 65535) << 8; |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 333 | |
Hans Verkuil | ebc3bba | 2010-05-24 10:01:58 -0300 | [diff] [blame] | 334 | v4l_dbg(1, msp_debug, client, "mute=%s scanning=%s volume=%d\n", |
| 335 | state->muted->val ? "on" : "off", |
| 336 | state->scan_in_progress ? "yes" : "no", |
| 337 | state->volume->val); |
| 338 | |
| 339 | msp_write_dsp(client, 0x0000, val); |
| 340 | msp_write_dsp(client, 0x0007, reallymuted ? 0x1 : (val | 0x1)); |
| 341 | if (state->has_scart2_out_volume) |
| 342 | msp_write_dsp(client, 0x0040, reallymuted ? 0x1 : (val | 0x1)); |
| 343 | if (state->has_headphones) |
| 344 | msp_write_dsp(client, 0x0006, val); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 345 | break; |
Hans Verkuil | ebc3bba | 2010-05-24 10:01:58 -0300 | [diff] [blame] | 346 | } |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 347 | |
| 348 | case V4L2_CID_AUDIO_BASS: |
Hans Verkuil | ebc3bba | 2010-05-24 10:01:58 -0300 | [diff] [blame] | 349 | val = ((val - 32768) * 0x60 / 65535) << 8; |
| 350 | msp_write_dsp(client, 0x0002, val); |
| 351 | if (state->has_headphones) |
| 352 | msp_write_dsp(client, 0x0031, val); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 353 | break; |
| 354 | |
| 355 | case V4L2_CID_AUDIO_TREBLE: |
Hans Verkuil | ebc3bba | 2010-05-24 10:01:58 -0300 | [diff] [blame] | 356 | val = ((val - 32768) * 0x60 / 65535) << 8; |
| 357 | msp_write_dsp(client, 0x0003, val); |
| 358 | if (state->has_headphones) |
| 359 | msp_write_dsp(client, 0x0032, val); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 360 | break; |
| 361 | |
Hans Verkuil | d312a46 | 2006-01-09 18:21:36 -0200 | [diff] [blame] | 362 | case V4L2_CID_AUDIO_LOUDNESS: |
Hans Verkuil | ebc3bba | 2010-05-24 10:01:58 -0300 | [diff] [blame] | 363 | val = val ? ((5 * 4) << 8) : 0; |
| 364 | msp_write_dsp(client, 0x0004, val); |
| 365 | if (state->has_headphones) |
| 366 | msp_write_dsp(client, 0x0033, val); |
| 367 | break; |
| 368 | |
| 369 | case V4L2_CID_AUDIO_BALANCE: |
| 370 | val = (u8)((val / 256) - 128); |
| 371 | msp_write_dsp(client, 0x0001, val << 8); |
| 372 | if (state->has_headphones) |
| 373 | msp_write_dsp(client, 0x0030, val << 8); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 374 | break; |
| 375 | |
| 376 | default: |
| 377 | return -EINVAL; |
| 378 | } |
| 379 | return 0; |
| 380 | } |
| 381 | |
Hans Verkuil | ebc3bba | 2010-05-24 10:01:58 -0300 | [diff] [blame] | 382 | void msp_update_volume(struct msp_state *state) |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 383 | { |
Hans Verkuil | 0310871 | 2010-10-17 07:24:20 -0300 | [diff] [blame] | 384 | /* Force an update of the volume/mute cluster */ |
| 385 | v4l2_ctrl_lock(state->volume); |
| 386 | state->volume->val = state->volume->cur.val; |
| 387 | state->muted->val = state->muted->cur.val; |
| 388 | msp_s_ctrl(state->volume); |
| 389 | v4l2_ctrl_unlock(state->volume); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 390 | } |
| 391 | |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 392 | /* --- v4l2 ioctls --- */ |
| 393 | static int msp_s_radio(struct v4l2_subdev *sd) |
| 394 | { |
| 395 | struct msp_state *state = to_state(sd); |
| 396 | struct i2c_client *client = v4l2_get_subdevdata(sd); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 397 | |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 398 | if (state->radio) |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 399 | return 0; |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 400 | state->radio = 1; |
| 401 | v4l_dbg(1, msp_debug, client, "switching to radio mode\n"); |
| 402 | state->watch_stereo = 0; |
| 403 | switch (state->opmode) { |
| 404 | case OPMODE_MANUAL: |
| 405 | /* set msp3400 to FM radio mode */ |
| 406 | msp3400c_set_mode(client, MSP_MODE_FM_RADIO); |
| 407 | msp3400c_set_carrier(client, MSP_CARRIER(10.7), |
| 408 | MSP_CARRIER(10.7)); |
Hans Verkuil | ebc3bba | 2010-05-24 10:01:58 -0300 | [diff] [blame] | 409 | msp_update_volume(state); |
Hans Verkuil | 2474ed4 | 2006-03-19 12:35:57 -0300 | [diff] [blame] | 410 | break; |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 411 | case OPMODE_AUTODETECT: |
| 412 | case OPMODE_AUTOSELECT: |
| 413 | /* the thread will do for us */ |
Hans Verkuil | 2eb606d | 2006-04-02 08:21:02 -0300 | [diff] [blame] | 414 | msp_wake_thread(client); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 415 | break; |
| 416 | } |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 417 | return 0; |
| 418 | } |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 419 | |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 420 | static int msp_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *freq) |
| 421 | { |
| 422 | struct i2c_client *client = v4l2_get_subdevdata(sd); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 423 | |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 424 | /* new channel -- kick audio carrier scan */ |
| 425 | msp_wake_thread(client); |
| 426 | return 0; |
| 427 | } |
| 428 | |
| 429 | static int msp_s_std(struct v4l2_subdev *sd, v4l2_std_id id) |
| 430 | { |
| 431 | struct msp_state *state = to_state(sd); |
| 432 | struct i2c_client *client = v4l2_get_subdevdata(sd); |
| 433 | int update = state->radio || state->v4l2_std != id; |
| 434 | |
| 435 | state->v4l2_std = id; |
| 436 | state->radio = 0; |
| 437 | if (update) |
| 438 | msp_wake_thread(client); |
| 439 | return 0; |
| 440 | } |
| 441 | |
Hans Verkuil | 5325b42 | 2009-04-02 11:26:22 -0300 | [diff] [blame] | 442 | static int msp_s_routing(struct v4l2_subdev *sd, |
| 443 | u32 input, u32 output, u32 config) |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 444 | { |
| 445 | struct msp_state *state = to_state(sd); |
| 446 | struct i2c_client *client = v4l2_get_subdevdata(sd); |
Hans Verkuil | 5325b42 | 2009-04-02 11:26:22 -0300 | [diff] [blame] | 447 | int tuner = (input >> 3) & 1; |
| 448 | int sc_in = input & 0x7; |
| 449 | int sc1_out = output & 0xf; |
| 450 | int sc2_out = (output >> 4) & 0xf; |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 451 | u16 val, reg; |
| 452 | int i; |
| 453 | int extern_input = 1; |
| 454 | |
Hans Verkuil | 5325b42 | 2009-04-02 11:26:22 -0300 | [diff] [blame] | 455 | if (state->route_in == input && state->route_out == output) |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 456 | return 0; |
Hans Verkuil | 5325b42 | 2009-04-02 11:26:22 -0300 | [diff] [blame] | 457 | state->route_in = input; |
| 458 | state->route_out = output; |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 459 | /* check if the tuner input is used */ |
| 460 | for (i = 0; i < 5; i++) { |
Hans Verkuil | 5325b42 | 2009-04-02 11:26:22 -0300 | [diff] [blame] | 461 | if (((input >> (4 + i * 4)) & 0xf) == 0) |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 462 | extern_input = 0; |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 463 | } |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 464 | state->mode = extern_input ? MSP_MODE_EXTERN : MSP_MODE_AM_DETECT; |
| 465 | state->rxsubchans = V4L2_TUNER_SUB_STEREO; |
| 466 | msp_set_scart(client, sc_in, 0); |
| 467 | msp_set_scart(client, sc1_out, 1); |
| 468 | msp_set_scart(client, sc2_out, 2); |
| 469 | msp_set_audmode(client); |
| 470 | reg = (state->opmode == OPMODE_AUTOSELECT) ? 0x30 : 0xbb; |
| 471 | val = msp_read_dem(client, reg); |
| 472 | msp_write_dem(client, reg, (val & ~0x100) | (tuner << 8)); |
| 473 | /* wake thread when a new input is chosen */ |
| 474 | msp_wake_thread(client); |
| 475 | return 0; |
| 476 | } |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 477 | |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 478 | static int msp_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt) |
| 479 | { |
| 480 | struct msp_state *state = to_state(sd); |
| 481 | struct i2c_client *client = v4l2_get_subdevdata(sd); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 482 | |
Hans Verkuil | ddc6ff3 | 2011-06-26 06:16:03 -0300 | [diff] [blame] | 483 | if (vt->type != V4L2_TUNER_ANALOG_TV) |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 484 | return 0; |
Hans Verkuil | ddc6ff3 | 2011-06-26 06:16:03 -0300 | [diff] [blame] | 485 | if (!state->radio) { |
| 486 | if (state->opmode == OPMODE_AUTOSELECT) |
| 487 | msp_detect_stereo(client); |
| 488 | vt->rxsubchans = state->rxsubchans; |
| 489 | } |
| 490 | vt->audmode = state->audmode; |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 491 | vt->capability |= V4L2_TUNER_CAP_STEREO | |
| 492 | V4L2_TUNER_CAP_LANG1 | V4L2_TUNER_CAP_LANG2; |
| 493 | return 0; |
| 494 | } |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 495 | |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 496 | static int msp_s_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt) |
| 497 | { |
| 498 | struct msp_state *state = to_state(sd); |
| 499 | struct i2c_client *client = v4l2_get_subdevdata(sd); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 500 | |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 501 | if (state->radio) /* TODO: add mono/stereo support for radio */ |
| 502 | return 0; |
| 503 | if (state->audmode == vt->audmode) |
| 504 | return 0; |
| 505 | state->audmode = vt->audmode; |
| 506 | /* only set audmode */ |
| 507 | msp_set_audmode(client); |
| 508 | return 0; |
| 509 | } |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 510 | |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 511 | static int msp_s_i2s_clock_freq(struct v4l2_subdev *sd, u32 freq) |
| 512 | { |
| 513 | struct msp_state *state = to_state(sd); |
| 514 | struct i2c_client *client = v4l2_get_subdevdata(sd); |
| 515 | |
| 516 | v4l_dbg(1, msp_debug, client, "Setting I2S speed to %d\n", freq); |
| 517 | |
| 518 | switch (freq) { |
Hans Verkuil | d52c738 | 2007-12-12 08:25:18 -0300 | [diff] [blame] | 519 | case 1024000: |
| 520 | state->i2s_mode = 0; |
| 521 | break; |
| 522 | case 2048000: |
| 523 | state->i2s_mode = 1; |
| 524 | break; |
| 525 | default: |
| 526 | return -EINVAL; |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 527 | } |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 528 | return 0; |
| 529 | } |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 530 | |
Hans Verkuil | aecde8b5 | 2008-12-30 07:14:19 -0300 | [diff] [blame] | 531 | static int msp_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip) |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 532 | { |
| 533 | struct msp_state *state = to_state(sd); |
| 534 | struct i2c_client *client = v4l2_get_subdevdata(sd); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 535 | |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 536 | return v4l2_chip_ident_i2c_client(client, chip, state->ident, |
| 537 | (state->rev1 << 16) | state->rev2); |
| 538 | } |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 539 | |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 540 | static int msp_log_status(struct v4l2_subdev *sd) |
| 541 | { |
| 542 | struct msp_state *state = to_state(sd); |
| 543 | struct i2c_client *client = v4l2_get_subdevdata(sd); |
| 544 | const char *p; |
Hans Verkuil | ebc3bba | 2010-05-24 10:01:58 -0300 | [diff] [blame] | 545 | char prefix[V4L2_SUBDEV_NAME_SIZE + 20]; |
Hans Verkuil | 5af0c8f | 2006-01-09 18:21:37 -0200 | [diff] [blame] | 546 | |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 547 | if (state->opmode == OPMODE_AUTOSELECT) |
| 548 | msp_detect_stereo(client); |
| 549 | v4l_info(client, "%s rev1 = 0x%04x rev2 = 0x%04x\n", |
| 550 | client->name, state->rev1, state->rev2); |
Hans Verkuil | ebc3bba | 2010-05-24 10:01:58 -0300 | [diff] [blame] | 551 | snprintf(prefix, sizeof(prefix), "%s: Audio: ", sd->name); |
| 552 | v4l2_ctrl_handler_log_status(&state->hdl, prefix); |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 553 | switch (state->mode) { |
Hans Verkuil | 5af0c8f | 2006-01-09 18:21:37 -0200 | [diff] [blame] | 554 | case MSP_MODE_AM_DETECT: p = "AM (for carrier detect)"; break; |
| 555 | case MSP_MODE_FM_RADIO: p = "FM Radio"; break; |
Lucas De Marchi | 25985ed | 2011-03-30 22:57:33 -0300 | [diff] [blame] | 556 | case MSP_MODE_FM_TERRA: p = "Terrestrial FM-mono/stereo"; break; |
Hans Verkuil | 5af0c8f | 2006-01-09 18:21:37 -0200 | [diff] [blame] | 557 | case MSP_MODE_FM_SAT: p = "Satellite FM-mono"; break; |
| 558 | case MSP_MODE_FM_NICAM1: p = "NICAM/FM (B/G, D/K)"; break; |
| 559 | case MSP_MODE_FM_NICAM2: p = "NICAM/FM (I)"; break; |
| 560 | case MSP_MODE_AM_NICAM: p = "NICAM/AM (L)"; break; |
| 561 | case MSP_MODE_BTSC: p = "BTSC"; break; |
| 562 | case MSP_MODE_EXTERN: p = "External input"; break; |
| 563 | default: p = "unknown"; break; |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 564 | } |
| 565 | if (state->mode == MSP_MODE_EXTERN) { |
| 566 | v4l_info(client, "Mode: %s\n", p); |
| 567 | } else if (state->opmode == OPMODE_MANUAL) { |
| 568 | v4l_info(client, "Mode: %s (%s%s)\n", p, |
Hans Verkuil | 5af0c8f | 2006-01-09 18:21:37 -0200 | [diff] [blame] | 569 | (state->rxsubchans & V4L2_TUNER_SUB_STEREO) ? "stereo" : "mono", |
| 570 | (state->rxsubchans & V4L2_TUNER_SUB_LANG2) ? ", dual" : ""); |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 571 | } else { |
| 572 | if (state->opmode == OPMODE_AUTODETECT) |
| 573 | v4l_info(client, "Mode: %s\n", p); |
| 574 | v4l_info(client, "Standard: %s (%s%s)\n", |
Hans Verkuil | 5af0c8f | 2006-01-09 18:21:37 -0200 | [diff] [blame] | 575 | msp_standard_std_name(state->std), |
| 576 | (state->rxsubchans & V4L2_TUNER_SUB_STEREO) ? "stereo" : "mono", |
| 577 | (state->rxsubchans & V4L2_TUNER_SUB_LANG2) ? ", dual" : ""); |
Hans Verkuil | 5af0c8f | 2006-01-09 18:21:37 -0200 | [diff] [blame] | 578 | } |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 579 | v4l_info(client, "Audmode: 0x%04x\n", state->audmode); |
| 580 | v4l_info(client, "Routing: 0x%08x (input) 0x%08x (output)\n", |
Hans Verkuil | 5325b42 | 2009-04-02 11:26:22 -0300 | [diff] [blame] | 581 | state->route_in, state->route_out); |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 582 | v4l_info(client, "ACB: 0x%04x\n", state->acb); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 583 | return 0; |
| 584 | } |
| 585 | |
Jean Delvare | 21b48a7 | 2007-03-12 19:20:15 -0300 | [diff] [blame] | 586 | static int msp_suspend(struct i2c_client *client, pm_message_t state) |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 587 | { |
Mauro Carvalho Chehab | f167cb4e | 2006-01-11 19:41:49 -0200 | [diff] [blame] | 588 | v4l_dbg(1, msp_debug, client, "suspend\n"); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 589 | msp_reset(client); |
| 590 | return 0; |
| 591 | } |
| 592 | |
Jean Delvare | 21b48a7 | 2007-03-12 19:20:15 -0300 | [diff] [blame] | 593 | static int msp_resume(struct i2c_client *client) |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 594 | { |
Mauro Carvalho Chehab | f167cb4e | 2006-01-11 19:41:49 -0200 | [diff] [blame] | 595 | v4l_dbg(1, msp_debug, client, "resume\n"); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 596 | msp_wake_thread(client); |
| 597 | return 0; |
| 598 | } |
| 599 | |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 600 | /* ----------------------------------------------------------------------- */ |
| 601 | |
Hans Verkuil | ebc3bba | 2010-05-24 10:01:58 -0300 | [diff] [blame] | 602 | static const struct v4l2_ctrl_ops msp_ctrl_ops = { |
| 603 | .s_ctrl = msp_s_ctrl, |
| 604 | }; |
| 605 | |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 606 | static const struct v4l2_subdev_core_ops msp_core_ops = { |
| 607 | .log_status = msp_log_status, |
| 608 | .g_chip_ident = msp_g_chip_ident, |
Hans Verkuil | ebc3bba | 2010-05-24 10:01:58 -0300 | [diff] [blame] | 609 | .g_ext_ctrls = v4l2_subdev_g_ext_ctrls, |
| 610 | .try_ext_ctrls = v4l2_subdev_try_ext_ctrls, |
| 611 | .s_ext_ctrls = v4l2_subdev_s_ext_ctrls, |
| 612 | .g_ctrl = v4l2_subdev_g_ctrl, |
| 613 | .s_ctrl = v4l2_subdev_s_ctrl, |
| 614 | .queryctrl = v4l2_subdev_queryctrl, |
| 615 | .querymenu = v4l2_subdev_querymenu, |
Hans Verkuil | f41737e | 2009-04-01 03:52:39 -0300 | [diff] [blame] | 616 | .s_std = msp_s_std, |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 617 | }; |
| 618 | |
| 619 | static const struct v4l2_subdev_tuner_ops msp_tuner_ops = { |
| 620 | .s_frequency = msp_s_frequency, |
| 621 | .g_tuner = msp_g_tuner, |
| 622 | .s_tuner = msp_s_tuner, |
| 623 | .s_radio = msp_s_radio, |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 624 | }; |
| 625 | |
| 626 | static const struct v4l2_subdev_audio_ops msp_audio_ops = { |
| 627 | .s_routing = msp_s_routing, |
| 628 | .s_i2s_clock_freq = msp_s_i2s_clock_freq, |
| 629 | }; |
| 630 | |
| 631 | static const struct v4l2_subdev_ops msp_ops = { |
| 632 | .core = &msp_core_ops, |
| 633 | .tuner = &msp_tuner_ops, |
| 634 | .audio = &msp_audio_ops, |
| 635 | }; |
| 636 | |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 637 | /* ----------------------------------------------------------------------- */ |
| 638 | |
Jean Delvare | d2653e9 | 2008-04-29 23:11:39 +0200 | [diff] [blame] | 639 | static int msp_probe(struct i2c_client *client, const struct i2c_device_id *id) |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 640 | { |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 641 | struct msp_state *state; |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 642 | struct v4l2_subdev *sd; |
Hans Verkuil | ebc3bba | 2010-05-24 10:01:58 -0300 | [diff] [blame] | 643 | struct v4l2_ctrl_handler *hdl; |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 644 | int (*thread_func)(void *data) = NULL; |
Hans Verkuil | 7560d7a | 2006-01-09 18:21:32 -0200 | [diff] [blame] | 645 | int msp_hard; |
| 646 | int msp_family; |
| 647 | int msp_revision; |
| 648 | int msp_product, msp_prod_hi, msp_prod_lo; |
| 649 | int msp_rom; |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 650 | |
Jean Delvare | af29486 | 2008-05-18 20:49:40 +0200 | [diff] [blame] | 651 | if (!id) |
| 652 | strlcpy(client->name, "msp3400", sizeof(client->name)); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 653 | |
| 654 | if (msp_reset(client) == -1) { |
Mauro Carvalho Chehab | f167cb4e | 2006-01-11 19:41:49 -0200 | [diff] [blame] | 655 | v4l_dbg(1, msp_debug, client, "msp3400 not found\n"); |
Hans Verkuil | 188f345 | 2007-09-16 10:47:15 -0300 | [diff] [blame] | 656 | return -ENODEV; |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 657 | } |
| 658 | |
Mariusz Kozlowski | b2a6576 | 2007-07-31 16:35:32 -0300 | [diff] [blame] | 659 | state = kzalloc(sizeof(*state), GFP_KERNEL); |
Hans Verkuil | d52c738 | 2007-12-12 08:25:18 -0300 | [diff] [blame] | 660 | if (!state) |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 661 | return -ENOMEM; |
Mariusz Kozlowski | b2a6576 | 2007-07-31 16:35:32 -0300 | [diff] [blame] | 662 | |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 663 | sd = &state->sd; |
| 664 | v4l2_i2c_subdev_init(sd, client, &msp_ops); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 665 | |
Hans Verkuil | 5af0c8f | 2006-01-09 18:21:37 -0200 | [diff] [blame] | 666 | state->v4l2_std = V4L2_STD_NTSC; |
Hans Verkuil | 0020d3e | 2006-03-30 19:50:34 -0300 | [diff] [blame] | 667 | state->audmode = V4L2_TUNER_MODE_STEREO; |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 668 | state->input = -1; |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 669 | state->i2s_mode = 0; |
| 670 | init_waitqueue_head(&state->wq); |
Hans Verkuil | 2474ed4 | 2006-03-19 12:35:57 -0300 | [diff] [blame] | 671 | /* These are the reset input/output positions */ |
Hans Verkuil | 5325b42 | 2009-04-02 11:26:22 -0300 | [diff] [blame] | 672 | state->route_in = MSP_INPUT_DEFAULT; |
| 673 | state->route_out = MSP_OUTPUT_DEFAULT; |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 674 | |
| 675 | state->rev1 = msp_read_dsp(client, 0x1e); |
| 676 | if (state->rev1 != -1) |
| 677 | state->rev2 = msp_read_dsp(client, 0x1f); |
Hans Verkuil | d52c738 | 2007-12-12 08:25:18 -0300 | [diff] [blame] | 678 | v4l_dbg(1, msp_debug, client, "rev1=0x%04x, rev2=0x%04x\n", |
| 679 | state->rev1, state->rev2); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 680 | if (state->rev1 == -1 || (state->rev1 == 0 && state->rev2 == 0)) { |
Hans Verkuil | d52c738 | 2007-12-12 08:25:18 -0300 | [diff] [blame] | 681 | v4l_dbg(1, msp_debug, client, |
| 682 | "not an msp3400 (cannot read chip version)\n"); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 683 | kfree(state); |
Hans Verkuil | 188f345 | 2007-09-16 10:47:15 -0300 | [diff] [blame] | 684 | return -ENODEV; |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 685 | } |
| 686 | |
Hans Verkuil | 7560d7a | 2006-01-09 18:21:32 -0200 | [diff] [blame] | 687 | msp_family = ((state->rev1 >> 4) & 0x0f) + 3; |
| 688 | msp_product = (state->rev2 >> 8) & 0xff; |
| 689 | msp_prod_hi = msp_product / 10; |
| 690 | msp_prod_lo = msp_product % 10; |
| 691 | msp_revision = (state->rev1 & 0x0f) + '@'; |
| 692 | msp_hard = ((state->rev1 >> 8) & 0xff) + '@'; |
| 693 | msp_rom = state->rev2 & 0x1f; |
Hans Verkuil | 74cab31 | 2007-04-27 12:31:26 -0300 | [diff] [blame] | 694 | /* Rev B=2, C=3, D=4, G=7 */ |
Hans Verkuil | d52c738 | 2007-12-12 08:25:18 -0300 | [diff] [blame] | 695 | state->ident = msp_family * 10000 + 4000 + msp_product * 10 + |
| 696 | msp_revision - '@'; |
Hans Verkuil | 7560d7a | 2006-01-09 18:21:32 -0200 | [diff] [blame] | 697 | |
| 698 | /* Has NICAM support: all mspx41x and mspx45x products have NICAM */ |
Hans Verkuil | d52c738 | 2007-12-12 08:25:18 -0300 | [diff] [blame] | 699 | state->has_nicam = |
| 700 | msp_prod_hi == 1 || msp_prod_hi == 5; |
Hans Verkuil | 7560d7a | 2006-01-09 18:21:32 -0200 | [diff] [blame] | 701 | /* Has radio support: was added with revision G */ |
Hans Verkuil | d52c738 | 2007-12-12 08:25:18 -0300 | [diff] [blame] | 702 | state->has_radio = |
| 703 | msp_revision >= 'G'; |
Hans Verkuil | 7560d7a | 2006-01-09 18:21:32 -0200 | [diff] [blame] | 704 | /* Has headphones output: not for stripped down products */ |
Hans Verkuil | d52c738 | 2007-12-12 08:25:18 -0300 | [diff] [blame] | 705 | state->has_headphones = |
| 706 | msp_prod_lo < 5; |
Hans Verkuil | 0020d3e | 2006-03-30 19:50:34 -0300 | [diff] [blame] | 707 | /* Has scart2 input: not in stripped down products of the '3' family */ |
Hans Verkuil | d52c738 | 2007-12-12 08:25:18 -0300 | [diff] [blame] | 708 | state->has_scart2 = |
| 709 | msp_family >= 4 || msp_prod_lo < 7; |
Hans Verkuil | 0020d3e | 2006-03-30 19:50:34 -0300 | [diff] [blame] | 710 | /* Has scart3 input: not in stripped down products of the '3' family */ |
Hans Verkuil | d52c738 | 2007-12-12 08:25:18 -0300 | [diff] [blame] | 711 | state->has_scart3 = |
| 712 | msp_family >= 4 || msp_prod_lo < 5; |
Hans Verkuil | 7560d7a | 2006-01-09 18:21:32 -0200 | [diff] [blame] | 713 | /* Has scart4 input: not in pre D revisions, not in stripped D revs */ |
Hans Verkuil | d52c738 | 2007-12-12 08:25:18 -0300 | [diff] [blame] | 714 | state->has_scart4 = |
| 715 | msp_family >= 4 || (msp_revision >= 'D' && msp_prod_lo < 5); |
| 716 | /* Has scart2 output: not in stripped down products of |
| 717 | * the '3' family */ |
| 718 | state->has_scart2_out = |
| 719 | msp_family >= 4 || msp_prod_lo < 5; |
Hans Verkuil | d312a46 | 2006-01-09 18:21:36 -0200 | [diff] [blame] | 720 | /* Has scart2 a volume control? Not in pre-D revisions. */ |
Hans Verkuil | d52c738 | 2007-12-12 08:25:18 -0300 | [diff] [blame] | 721 | state->has_scart2_out_volume = |
| 722 | msp_revision > 'C' && state->has_scart2_out; |
Hans Verkuil | 5af0c8f | 2006-01-09 18:21:37 -0200 | [diff] [blame] | 723 | /* Has a configurable i2s out? */ |
Hans Verkuil | d52c738 | 2007-12-12 08:25:18 -0300 | [diff] [blame] | 724 | state->has_i2s_conf = |
| 725 | msp_revision >= 'G' && msp_prod_lo < 7; |
| 726 | /* Has subwoofer output: not in pre-D revs and not in stripped down |
| 727 | * products */ |
| 728 | state->has_subwoofer = |
| 729 | msp_revision >= 'D' && msp_prod_lo < 5; |
| 730 | /* Has soundprocessing (bass/treble/balance/loudness/equalizer): |
| 731 | * not in stripped down products */ |
| 732 | state->has_sound_processing = |
| 733 | msp_prod_lo < 7; |
Hans Verkuil | 7560d7a | 2006-01-09 18:21:32 -0200 | [diff] [blame] | 734 | /* Has Virtual Dolby Surround: only in msp34x1 */ |
Hans Verkuil | d52c738 | 2007-12-12 08:25:18 -0300 | [diff] [blame] | 735 | state->has_virtual_dolby_surround = |
| 736 | msp_revision == 'G' && msp_prod_lo == 1; |
Hans Verkuil | 7560d7a | 2006-01-09 18:21:32 -0200 | [diff] [blame] | 737 | /* Has Virtual Dolby Surround & Dolby Pro Logic: only in msp34x2 */ |
Hans Verkuil | d52c738 | 2007-12-12 08:25:18 -0300 | [diff] [blame] | 738 | state->has_dolby_pro_logic = |
| 739 | msp_revision == 'G' && msp_prod_lo == 2; |
| 740 | /* The msp343xG supports BTSC only and cannot do Automatic Standard |
| 741 | * Detection. */ |
| 742 | state->force_btsc = |
| 743 | msp_family == 3 && msp_revision == 'G' && msp_prod_hi == 3; |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 744 | |
| 745 | state->opmode = opmode; |
| 746 | if (state->opmode == OPMODE_AUTO) { |
| 747 | /* MSP revision G and up have both autodetect and autoselect */ |
Hans Verkuil | 7560d7a | 2006-01-09 18:21:32 -0200 | [diff] [blame] | 748 | if (msp_revision >= 'G') |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 749 | state->opmode = OPMODE_AUTOSELECT; |
| 750 | /* MSP revision D and up have autodetect */ |
Hans Verkuil | 7560d7a | 2006-01-09 18:21:32 -0200 | [diff] [blame] | 751 | else if (msp_revision >= 'D') |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 752 | state->opmode = OPMODE_AUTODETECT; |
| 753 | else |
| 754 | state->opmode = OPMODE_MANUAL; |
| 755 | } |
| 756 | |
Hans Verkuil | ebc3bba | 2010-05-24 10:01:58 -0300 | [diff] [blame] | 757 | hdl = &state->hdl; |
| 758 | v4l2_ctrl_handler_init(hdl, 6); |
| 759 | if (state->has_sound_processing) { |
| 760 | v4l2_ctrl_new_std(hdl, &msp_ctrl_ops, |
| 761 | V4L2_CID_AUDIO_BASS, 0, 65535, 65535 / 100, 32768); |
| 762 | v4l2_ctrl_new_std(hdl, &msp_ctrl_ops, |
| 763 | V4L2_CID_AUDIO_TREBLE, 0, 65535, 65535 / 100, 32768); |
| 764 | v4l2_ctrl_new_std(hdl, &msp_ctrl_ops, |
| 765 | V4L2_CID_AUDIO_LOUDNESS, 0, 1, 1, 0); |
| 766 | } |
| 767 | state->volume = v4l2_ctrl_new_std(hdl, &msp_ctrl_ops, |
| 768 | V4L2_CID_AUDIO_VOLUME, 0, 65535, 65535 / 100, 58880); |
| 769 | v4l2_ctrl_new_std(hdl, &msp_ctrl_ops, |
| 770 | V4L2_CID_AUDIO_BALANCE, 0, 65535, 65535 / 100, 32768); |
| 771 | state->muted = v4l2_ctrl_new_std(hdl, &msp_ctrl_ops, |
| 772 | V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0); |
| 773 | sd->ctrl_handler = hdl; |
| 774 | if (hdl->error) { |
| 775 | int err = hdl->error; |
| 776 | |
| 777 | v4l2_ctrl_handler_free(hdl); |
| 778 | kfree(state); |
| 779 | return err; |
| 780 | } |
| 781 | |
| 782 | v4l2_ctrl_cluster(2, &state->volume); |
| 783 | v4l2_ctrl_handler_setup(hdl); |
| 784 | |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 785 | /* hello world :-) */ |
Jean Delvare | af29486 | 2008-05-18 20:49:40 +0200 | [diff] [blame] | 786 | v4l_info(client, "MSP%d4%02d%c-%c%d found @ 0x%x (%s)\n", |
| 787 | msp_family, msp_product, |
| 788 | msp_revision, msp_hard, msp_rom, |
Hans Verkuil | d52c738 | 2007-12-12 08:25:18 -0300 | [diff] [blame] | 789 | client->addr << 1, client->adapter->name); |
Hans Verkuil | 7e8b09e | 2006-01-09 15:32:40 -0200 | [diff] [blame] | 790 | v4l_info(client, "%s ", client->name); |
Hans Verkuil | 7560d7a | 2006-01-09 18:21:32 -0200 | [diff] [blame] | 791 | if (state->has_nicam && state->has_radio) |
Hans Verkuil | d52c738 | 2007-12-12 08:25:18 -0300 | [diff] [blame] | 792 | printk(KERN_CONT "supports nicam and radio, "); |
Hans Verkuil | 7560d7a | 2006-01-09 18:21:32 -0200 | [diff] [blame] | 793 | else if (state->has_nicam) |
Hans Verkuil | d52c738 | 2007-12-12 08:25:18 -0300 | [diff] [blame] | 794 | printk(KERN_CONT "supports nicam, "); |
Hans Verkuil | 7560d7a | 2006-01-09 18:21:32 -0200 | [diff] [blame] | 795 | else if (state->has_radio) |
Hans Verkuil | d52c738 | 2007-12-12 08:25:18 -0300 | [diff] [blame] | 796 | printk(KERN_CONT "supports radio, "); |
| 797 | printk(KERN_CONT "mode is "); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 798 | |
| 799 | /* version-specific initialization */ |
| 800 | switch (state->opmode) { |
| 801 | case OPMODE_MANUAL: |
Hans Verkuil | d52c738 | 2007-12-12 08:25:18 -0300 | [diff] [blame] | 802 | printk(KERN_CONT "manual"); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 803 | thread_func = msp3400c_thread; |
| 804 | break; |
| 805 | case OPMODE_AUTODETECT: |
Hans Verkuil | d52c738 | 2007-12-12 08:25:18 -0300 | [diff] [blame] | 806 | printk(KERN_CONT "autodetect"); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 807 | thread_func = msp3410d_thread; |
| 808 | break; |
| 809 | case OPMODE_AUTOSELECT: |
Hans Verkuil | d52c738 | 2007-12-12 08:25:18 -0300 | [diff] [blame] | 810 | printk(KERN_CONT "autodetect and autoselect"); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 811 | thread_func = msp34xxg_thread; |
| 812 | break; |
| 813 | } |
Hans Verkuil | d52c738 | 2007-12-12 08:25:18 -0300 | [diff] [blame] | 814 | printk(KERN_CONT "\n"); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 815 | |
| 816 | /* startup control thread if needed */ |
| 817 | if (thread_func) { |
| 818 | state->kthread = kthread_run(thread_func, client, "msp34xx"); |
| 819 | |
Akinobu Mita | 25821400 | 2006-12-20 10:07:30 -0300 | [diff] [blame] | 820 | if (IS_ERR(state->kthread)) |
Hans Verkuil | 7e8b09e | 2006-01-09 15:32:40 -0200 | [diff] [blame] | 821 | v4l_warn(client, "kernel_thread() failed\n"); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 822 | msp_wake_thread(client); |
| 823 | } |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 824 | return 0; |
| 825 | } |
| 826 | |
Hans Verkuil | 79518da | 2007-09-13 11:28:59 -0300 | [diff] [blame] | 827 | static int msp_remove(struct i2c_client *client) |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 828 | { |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 829 | struct msp_state *state = to_state(i2c_get_clientdata(client)); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 830 | |
Hans Verkuil | 76efd62 | 2008-11-24 18:16:46 -0300 | [diff] [blame] | 831 | v4l2_device_unregister_subdev(&state->sd); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 832 | /* shutdown control thread */ |
| 833 | if (state->kthread) { |
| 834 | state->restart = 1; |
| 835 | kthread_stop(state->kthread); |
| 836 | } |
| 837 | msp_reset(client); |
| 838 | |
Hans Verkuil | ebc3bba | 2010-05-24 10:01:58 -0300 | [diff] [blame] | 839 | v4l2_ctrl_handler_free(&state->hdl); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 840 | kfree(state); |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 841 | return 0; |
| 842 | } |
| 843 | |
| 844 | /* ----------------------------------------------------------------------- */ |
| 845 | |
Jean Delvare | af29486 | 2008-05-18 20:49:40 +0200 | [diff] [blame] | 846 | static const struct i2c_device_id msp_id[] = { |
| 847 | { "msp3400", 0 }, |
| 848 | { } |
| 849 | }; |
| 850 | MODULE_DEVICE_TABLE(i2c, msp_id); |
| 851 | |
Hans Verkuil | 61a489c | 2010-09-15 15:22:34 -0300 | [diff] [blame] | 852 | static struct i2c_driver msp_driver = { |
| 853 | .driver = { |
| 854 | .owner = THIS_MODULE, |
| 855 | .name = "msp3400", |
| 856 | }, |
| 857 | .probe = msp_probe, |
| 858 | .remove = msp_remove, |
| 859 | .suspend = msp_suspend, |
| 860 | .resume = msp_resume, |
| 861 | .id_table = msp_id, |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 862 | }; |
| 863 | |
Hans Verkuil | 61a489c | 2010-09-15 15:22:34 -0300 | [diff] [blame] | 864 | static __init int init_msp(void) |
| 865 | { |
| 866 | return i2c_add_driver(&msp_driver); |
| 867 | } |
| 868 | |
| 869 | static __exit void exit_msp(void) |
| 870 | { |
| 871 | i2c_del_driver(&msp_driver); |
| 872 | } |
| 873 | |
| 874 | module_init(init_msp); |
| 875 | module_exit(exit_msp); |
| 876 | |
Hans Verkuil | 53b0a1c | 2006-01-09 15:32:39 -0200 | [diff] [blame] | 877 | /* |
| 878 | * Overrides for Emacs so that we follow Linus's tabbing style. |
| 879 | * --------------------------------------------------------------------------- |
| 880 | * Local variables: |
| 881 | * c-basic-offset: 8 |
| 882 | * End: |
| 883 | */ |