开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
msp3400.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：42k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

msp3400.c：源码内容
  1. /*
  2.  * programming the msp34* 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.  *
  28.  * TODO:
  29.  *   - better SAT support
  30.  *
  31.  *
  32.  * 980623  Thomas Sailer (sailer@ife.ee.ethz.ch)
  33.  *         using soundcore instead of OSS
  34.  *
  35.  */
  37. #include <linux/config.h>
  38. #include <linux/module.h>
  39. #include <linux/kernel.h>
  40. #include <linux/sched.h>
  41. #include <linux/string.h>
  42. #include <linux/timer.h>
  43. #include <linux/delay.h>
  44. #include <linux/errno.h>
  45. #include <linux/slab.h>
  46. #include <linux/i2c.h>
  47. #include <linux/videodev.h>
  48. #include <asm/semaphore.h>
  49. #include <linux/init.h>
  51. #ifdef CONFIG_SMP
  52. #include <asm/pgtable.h>
  53. #include <linux/smp_lock.h>
  54. #endif
  55. /* kernel_thread */
  56. #define __KERNEL_SYSCALLS__
  57. #include <linux/unistd.h>
  59. #include "audiochip.h"
  60. #include "msp3400.h"
  62. /* Addresses to scan */
  63. static unsigned short normal_i2c[] = {I2C_CLIENT_END};
  64. static unsigned short normal_i2c_range[] = {0x40,0x40,I2C_CLIENT_END};
  65. static unsigned short probe[2]        = { I2C_CLIENT_END, I2C_CLIENT_END };
  66. static unsigned short probe_range[2]  = { I2C_CLIENT_END, I2C_CLIENT_END };
  67. static unsigned short ignore[2]       = { I2C_CLIENT_END, I2C_CLIENT_END };
  68. static unsigned short ignore_range[2] = { I2C_CLIENT_END, I2C_CLIENT_END };
  69. static unsigned short force[2]        = { I2C_CLIENT_END, I2C_CLIENT_END };
  70. static struct i2c_client_address_data addr_data = {
  71. normal_i2c, normal_i2c_range, 
  72. probe, probe_range, 
  73. ignore, ignore_range, 
  74. force
  75. };
  77. /* insmod parameters */
  78. static int debug   = 0;    /* debug output */
  79. static int once    = 0;    /* no continous stereo monitoring */
  80. static int amsound = 0;    /* hard-wire AM sound at 6.5 Hz (france),
  81.       the autoscan seems work well only with FM... */
  82. static int simple  = -1;   /* use short programming (>= msp3410 only) */
  83. static int dolby   = 0;
  85. #define DFP_COUNT 0x41
  86. static const int bl_dfp[] = {
  87. 0x00, 0x01, 0x02, 0x03,  0x06, 0x08, 0x09, 0x0a,
  88. 0x0b, 0x0d, 0x0e, 0x10
  89. };
  91. struct msp3400c {
  92. int simple;
  93. int nicam;
  94. int mode;
  95. int norm;
  96. int stereo;
  97. int nicam_on;
  98. int acb;
  99. int main, second; /* sound carrier */
  100. int input;
  102. int muted;
  103. int left, right; /* volume */
  104. int bass, treble;
  106. /* shadow register set */
  107. int dfp_regs[DFP_COUNT];
  109. /* thread */
  110. struct task_struct  *thread;
  111. wait_queue_head_t    wq;
  113. struct semaphore    *notify;
  114. int                  active,restart,rmmod;
  116. int                  watch_stereo;
  117. struct timer_list    wake_stereo;
  118. };
  120. #define MSP3400_MAX 4
  121. static struct i2c_client *msps[MSP3400_MAX];
  123. #define VIDEO_MODE_RADIO 16      /* norm magic for radio mode */
  125. /* ---------------------------------------------------------------------- */
  127. #define dprintk     if (debug) printk
  129. MODULE_PARM(once,"i");
  130. MODULE_PARM(debug,"i");
  131. MODULE_PARM(simple,"i");
  132. MODULE_PARM(amsound,"i");
  133. MODULE_PARM(dolby,"i");
  135. MODULE_DESCRIPTION("device driver for msp34xx TV sound processor");
  136. MODULE_AUTHOR("Gerd Knorr");
  137. MODULE_LICENSE("GPL");
  139. /* ---------------------------------------------------------------------- */
  141. #define I2C_MSP3400C       0x80
  142. #define I2C_MSP3400C_DEM   0x10
  143. #define I2C_MSP3400C_DFP   0x12
  145. /* ----------------------------------------------------------------------- */
  146. /* functions for talking to the MSP3400C Sound processor                   */
  148. static int msp3400c_reset(struct i2c_client *client)
  149. {
  150.         static char reset_off[3] = { 0x00, 0x80, 0x00 };
  151.         static char reset_on[3]  = { 0x00, 0x00, 0x00 };
  153.         i2c_master_send(client,reset_off,3);  /* XXX ignore errors here */
  154.         if (3 != i2c_master_send(client,reset_on, 3)) {
  155. printk(KERN_ERR "msp3400: chip reset failed, penguin on i2c bus?n");
  156.                 return -1;
  157. }
  158.         return 0;
  159. }
  161. static int
  162. msp3400c_read(struct i2c_client *client, int dev, int addr)
  163. {
  164. int err;
  166.         unsigned char write[3];
  167.         unsigned char read[2];
  168.         struct i2c_msg msgs[2] = {
  169.                 { client->addr, 0,        3, write },
  170.                 { client->addr, I2C_M_RD, 2, read  }
  171.         };
  172.         write[0] = dev+1;
  173.         write[1] = addr >> 8;
  174.         write[2] = addr & 0xff;
  176. for (err = 0; err < 3;) {
  177. if (2 == i2c_transfer(client->adapter,msgs,2))
  178. break;
  179. err++;
  180. printk(KERN_WARNING "msp34xx: I/O error #%d (read 0x%02x/0x%02x)n",
  181.        err, dev, addr);
  182. current->state = TASK_INTERRUPTIBLE;
  183. schedule_timeout(HZ/10);
  184. }
  185. if (3 == err) {
  186. printk(KERN_WARNING "msp34xx: giving up, reseting chip. Sound will go off, sorry folks :-|n");
  187. msp3400c_reset(client);
  188. return -1;
  189. }
  190.         return read[0] << 8 | read[1];
  191. }
  193. static int
  194. msp3400c_write(struct i2c_client *client, int dev, int addr, int val)
  195. {
  196. int err;
  197.         unsigned char buffer[5];
  199.         buffer[0] = dev;
  200.         buffer[1] = addr >> 8;
  201.         buffer[2] = addr &  0xff;
  202.         buffer[3] = val  >> 8;
  203.         buffer[4] = val  &  0xff;
  205. for (err = 0; err < 3;) {
  206. if (5 == i2c_master_send(client, buffer, 5))
  207. break;
  208. err++;
  209. printk(KERN_WARNING "msp34xx: I/O error #%d (write 0x%02x/0x%02x)n",
  210.        err, dev, addr);
  211. current->state = TASK_INTERRUPTIBLE;
  212. schedule_timeout(HZ/10);
  213. }
  214. if (3 == err) {
  215. printk(KERN_WARNING "msp34xx: giving up, reseting chip. Sound will go off, sorry folks :-|n");
  216. msp3400c_reset(client);
  217. return -1;
  218. }
  219. return 0;
  220. }
  222. /* ------------------------------------------------------------------------ */
  224. /* This macro is allowed for *constants* only, gcc must calculate it
  225.    at compile time.  Remember -- no floats in kernel mode */
  226. #define MSP_CARRIER(freq) ((int)((float)(freq/18.432)*(1<<24)))
  228. #define MSP_MODE_AM_DETECT   0
  229. #define MSP_MODE_FM_RADIO    2
  230. #define MSP_MODE_FM_TERRA    3
  231. #define MSP_MODE_FM_SAT      4
  232. #define MSP_MODE_FM_NICAM1   5
  233. #define MSP_MODE_FM_NICAM2   6
  234. #define MSP_MODE_AM_NICAM    7
  235. #define MSP_MODE_BTSC        8
  236. #define MSP_MODE_EXTERN      9
  238. static struct MSP_INIT_DATA_DEM {
  239. int fir1[6];
  240. int fir2[6];
  241. int cdo1;
  242. int cdo2;
  243. int ad_cv;
  244. int mode_reg;
  245. int dfp_src;
  246. int dfp_matrix;
  247. } msp_init_data[] = {
  248. /* AM (for carrier detect / msp3400) */
  249. { { 75, 19, 36, 35, 39, 40 }, { 75, 19, 36, 35, 39, 40 },
  250.   MSP_CARRIER(5.5), MSP_CARRIER(5.5),
  251.   0x00d0, 0x0500,   0x0020, 0x3000},
  253. /* AM (for carrier detect / msp3410) */
  254. { { -1, -1, -8, 2, 59, 126 }, { -1, -1, -8, 2, 59, 126 },
  255.   MSP_CARRIER(5.5), MSP_CARRIER(5.5),
  256.   0x00d0, 0x0100,   0x0020, 0x3000},
  258. /* FM Radio */
  259. { { -8, -8, 4, 6, 78, 107 }, { -8, -8, 4, 6, 78, 107 },
  260.   MSP_CARRIER(10.7), MSP_CARRIER(10.7),
  261.   0x00d0, 0x0480, 0x0020, 0x3000 },
  263. /* Terrestial FM-mono + FM-stereo */
  264. { {  3, 18, 27, 48, 66, 72 }, {  3, 18, 27, 48, 66, 72 },
  265.   MSP_CARRIER(5.5), MSP_CARRIER(5.5),
  266.   0x00d0, 0x0480,   0x0030, 0x3000},
  268. /* Sat FM-mono */
  269. { {  1,  9, 14, 24, 33, 37 }, {  3, 18, 27, 48, 66, 72 },
  270.   MSP_CARRIER(6.5), MSP_CARRIER(6.5),
  271.   0x00c6, 0x0480,   0x0000, 0x3000},
  273. /* NICAM/FM --  B/G (5.5/5.85), D/K (6.5/5.85) */
  274. { { -2, -8, -10, 10, 50, 86 }, {  3, 18, 27, 48, 66, 72 },
  275.   MSP_CARRIER(5.5), MSP_CARRIER(5.5),
  276.   0x00d0, 0x0040,   0x0120, 0x3000},
  278. /* NICAM/FM -- I (6.0/6.552) */
  279. { {  2, 4, -6, -4, 40, 94 }, {  3, 18, 27, 48, 66, 72 },
  280.   MSP_CARRIER(6.0), MSP_CARRIER(6.0),
  281.   0x00d0, 0x0040,   0x0120, 0x3000},
  283. /* NICAM/AM -- L (6.5/5.85) */
  284. { {  -2, -8, -10, 10, 50, 86 }, {  -4, -12, -9, 23, 79, 126 },
  285.   MSP_CARRIER(6.5), MSP_CARRIER(6.5),
  286.   0x00c6, 0x0140,   0x0120, 0x7c03},
  287. };
  289. struct CARRIER_DETECT {
  290. int   cdo;
  291. char *name;
  292. };
  294. static struct CARRIER_DETECT carrier_detect_main[] = {
  295. /* main carrier */
  296. { MSP_CARRIER(4.5),        "4.5   NTSC"                   }, 
  297. { MSP_CARRIER(5.5),        "5.5   PAL B/G"                }, 
  298. { MSP_CARRIER(6.0),        "6.0   PAL I"                  },
  299. { MSP_CARRIER(6.5),        "6.5   PAL D/K + SAT + SECAM"  }
  300. };
  302. static struct CARRIER_DETECT carrier_detect_55[] = {
  303. /* PAL B/G */
  304. { MSP_CARRIER(5.7421875),  "5.742 PAL B/G FM-stereo"     }, 
  305. { MSP_CARRIER(5.85),       "5.85  PAL B/G NICAM"         }
  306. };
  308. static struct CARRIER_DETECT carrier_detect_65[] = {
  309. /* PAL SAT / SECAM */
  310. { MSP_CARRIER(5.85),       "5.85  PAL D/K + SECAM NICAM" },
  311. { MSP_CARRIER(6.2578125),  "6.25  PAL D/K1 FM-stereo" },
  312. { MSP_CARRIER(6.7421875),  "6.74  PAL D/K2 FM-stereo" },
  313. { MSP_CARRIER(7.02),       "7.02  PAL SAT FM-stereo s/b" },
  314. { MSP_CARRIER(7.20),       "7.20  PAL SAT FM-stereo s"   },
  315. { MSP_CARRIER(7.38),       "7.38  PAL SAT FM-stereo b"   },
  316. };
  318. #define CARRIER_COUNT(x) (sizeof(x)/sizeof(struct CARRIER_DETECT))
  320. /* ----------------------------------------------------------------------- */
  322. #define SCART_MASK    0
  323. #define SCART_IN1     1
  324. #define SCART_IN2     2
  325. #define SCART_IN1_DA  3
  326. #define SCART_IN2_DA  4
  327. #define SCART_IN3     5
  328. #define SCART_IN4     6
  329. #define SCART_MONO    7
  330. #define SCART_MUTE    8
  332. static int scarts[3][9] = {
  333.   /* MASK    IN1     IN2     IN1_DA  IN2_DA  IN3     IN4     MONO    MUTE   */
  334.   {  0x0320, 0x0000, 0x0200, -1,     -1,     0x0300, 0x0020, 0x0100, 0x0320 },
  335.   {  0x0c40, 0x0440, 0x0400, 0x0c00, 0x0040, 0x0000, 0x0840, 0x0800, 0x0c40 },
  336.   {  0x3080, 0x1000, 0x1080, 0x0000, 0x0080, 0x2080, 0x3080, 0x2000, 0x3000 },
  337. };
  339. static char *scart_names[] = {
  340.   "mask", "in1", "in2", "in1 da", "in2 da", "in3", "in4", "mono", "mute"
  341. };
  343. static void
  344. msp3400c_set_scart(struct i2c_client *client, int in, int out)
  345. {
  346. struct msp3400c *msp = client->data;
  348. if (-1 == scarts[out][in])
  349. return;
  351. dprintk("msp34xx: scart switch: %s => %dn",scart_names[in],out);
  352. msp->acb &= ~scarts[out][SCART_MASK];
  353. msp->acb |=  scarts[out][in];
  354. msp3400c_write(client,I2C_MSP3400C_DFP, 0x0013, msp->acb);
  355. }
  357. /* ------------------------------------------------------------------------ */
  359. static void msp3400c_setcarrier(struct i2c_client *client, int cdo1, int cdo2)
  360. {
  361. msp3400c_write(client,I2C_MSP3400C_DEM, 0x0093, cdo1 & 0xfff);
  362. msp3400c_write(client,I2C_MSP3400C_DEM, 0x009b, cdo1 >> 12);
  363. msp3400c_write(client,I2C_MSP3400C_DEM, 0x00a3, cdo2 & 0xfff);
  364. msp3400c_write(client,I2C_MSP3400C_DEM, 0x00ab, cdo2 >> 12);
  365. msp3400c_write(client,I2C_MSP3400C_DEM, 0x0056, 0); /*LOAD_REG_1/2*/
  366. }
  368. static void msp3400c_setvolume(struct i2c_client *client,
  369.        int muted, int left, int right)
  370. {
  371. int vol = 0,val = 0,balance = 0;
  373. if (!muted) {
  374. vol     = (left > right) ? left : right;
  375. val     = (vol * 0x73 / 65535) << 8;
  376. }
  377. if (vol > 0) {
  378. balance = ((right-left) * 127) / vol;
  379. }
  381. dprintk("msp34xx: setvolume: mute=%s %d:%d  v=0x%02x b=0x%02xn",
  382. muted ? "on" : "off", left, right, val>>8, balance);
  383. msp3400c_write(client,I2C_MSP3400C_DFP, 0x0000, val); /* loudspeaker */
  384. msp3400c_write(client,I2C_MSP3400C_DFP, 0x0006, val); /* headphones  */
  385. /* scart - on/off only */
  386. msp3400c_write(client,I2C_MSP3400C_DFP, 0x0007, val ? 0x4000 : 0);
  387. msp3400c_write(client,I2C_MSP3400C_DFP, 0x0001, balance << 8);
  388. }
  390. static void msp3400c_setbass(struct i2c_client *client, int bass)
  391. {
  392. int val = ((bass-32768) * 0x60 / 65535) << 8;
  394. dprintk("msp34xx: setbass: %d 0x%02xn",bass, val>>8);
  395. msp3400c_write(client,I2C_MSP3400C_DFP, 0x0002, val); /* loudspeaker */
  396. }
  398. static void msp3400c_settreble(struct i2c_client *client, int treble)
  399. {
  400. int val = ((treble-32768) * 0x60 / 65535) << 8;
  402. dprintk("msp34xx: settreble: %d 0x%02xn",treble, val>>8);
  403. msp3400c_write(client,I2C_MSP3400C_DFP, 0x0003, val); /* loudspeaker */
  404. }
  406. static void msp3400c_setmode(struct i2c_client *client, int type)
  407. {
  408. struct msp3400c *msp = client->data;
  409. int i;
  411. dprintk("msp3400: setmode: %dn",type);
  412. msp->mode   = type;
  413. msp->stereo = VIDEO_SOUND_MONO;
  415. msp3400c_write(client,I2C_MSP3400C_DEM, 0x00bb,          /* ad_cv */
  416.        msp_init_data[type].ad_cv);
  417.     
  418. for (i = 5; i >= 0; i--)                                   /* fir 1 */
  419. msp3400c_write(client,I2C_MSP3400C_DEM, 0x0001,
  420.        msp_init_data[type].fir1[i]);
  421.     
  422. msp3400c_write(client,I2C_MSP3400C_DEM, 0x0005, 0x0004); /* fir 2 */
  423. msp3400c_write(client,I2C_MSP3400C_DEM, 0x0005, 0x0040);
  424. msp3400c_write(client,I2C_MSP3400C_DEM, 0x0005, 0x0000);
  425. for (i = 5; i >= 0; i--)
  426. msp3400c_write(client,I2C_MSP3400C_DEM, 0x0005,
  427.        msp_init_data[type].fir2[i]);
  428.     
  429. msp3400c_write(client,I2C_MSP3400C_DEM, 0x0083,     /* MODE_REG */
  430.        msp_init_data[type].mode_reg);
  431.     
  432. msp3400c_setcarrier(client, msp_init_data[type].cdo1,
  433.     msp_init_data[type].cdo2);
  434.     
  435. msp3400c_write(client,I2C_MSP3400C_DEM, 0x0056, 0); /*LOAD_REG_1/2*/
  437. if (dolby) {
  438. msp3400c_write(client,I2C_MSP3400C_DFP, 0x0008,
  439.        0x0520); /* I2S1 */
  440. msp3400c_write(client,I2C_MSP3400C_DFP, 0x0009,
  441.        0x0620); /* I2S2 */
  442. msp3400c_write(client,I2C_MSP3400C_DFP, 0x000b,
  443.        msp_init_data[type].dfp_src);
  444. } else {
  445. msp3400c_write(client,I2C_MSP3400C_DFP, 0x0008,
  446.        msp_init_data[type].dfp_src);
  447. msp3400c_write(client,I2C_MSP3400C_DFP, 0x0009,
  448.        msp_init_data[type].dfp_src);
  449. msp3400c_write(client,I2C_MSP3400C_DFP, 0x000b,
  450.        msp_init_data[type].dfp_src);
  451. }
  452. msp3400c_write(client,I2C_MSP3400C_DFP, 0x000a,
  453.        msp_init_data[type].dfp_src);
  454. msp3400c_write(client,I2C_MSP3400C_DFP, 0x000e,
  455.        msp_init_data[type].dfp_matrix);
  457. if (msp->nicam) {
  458. /* nicam prescale */
  459. msp3400c_write(client,I2C_MSP3400C_DFP, 0x0010, 0x5a00); /* was: 0x3000 */
  460. }
  461. }
  463. /* turn on/off nicam + stereo */
  464. static void msp3400c_setstereo(struct i2c_client *client, int mode)
  465. {
  466. static char *strmode[] = { "0", "mono", "stereo", "3",
  467.    "lang1", "5", "6", "7", "lang2" };
  468. struct msp3400c *msp = client->data;
  469. int nicam=0; /* channel source: FM/AM or nicam */
  470. int src=0;
  472. /* switch demodulator */
  473. switch (msp->mode) {
  474. case MSP_MODE_FM_TERRA:
  475. dprintk("msp3400: FM setstereo: %sn",strmode[mode]);
  476. msp3400c_setcarrier(client,msp->second,msp->main);
  477. switch (mode) {
  478. case VIDEO_SOUND_STEREO:
  479. msp3400c_write(client,I2C_MSP3400C_DFP, 0x000e, 0x3001);
  480. break;
  481. case VIDEO_SOUND_MONO:
  482. case VIDEO_SOUND_LANG1:
  483. case VIDEO_SOUND_LANG2:
  484. msp3400c_write(client,I2C_MSP3400C_DFP, 0x000e, 0x3000);
  485. break;
  486. }
  487. break;
  488. case MSP_MODE_FM_SAT:
  489. dprintk("msp3400: SAT setstereo: %sn",strmode[mode]);
  490. switch (mode) {
  491. case VIDEO_SOUND_MONO:
  492. msp3400c_setcarrier(client, MSP_CARRIER(6.5), MSP_CARRIER(6.5));
  493. break;
  494. case VIDEO_SOUND_STEREO:
  495. msp3400c_setcarrier(client, MSP_CARRIER(7.2), MSP_CARRIER(7.02));
  496. break;
  497. case VIDEO_SOUND_LANG1:
  498. msp3400c_setcarrier(client, MSP_CARRIER(7.38), MSP_CARRIER(7.02));
  499. break;
  500. case VIDEO_SOUND_LANG2:
  501. msp3400c_setcarrier(client, MSP_CARRIER(7.38), MSP_CARRIER(7.02));
  502. break;
  503. }
  504. break;
  505. case MSP_MODE_FM_NICAM1:
  506. case MSP_MODE_FM_NICAM2:
  507. case MSP_MODE_AM_NICAM:
  508. dprintk("msp3400: NICAM setstereo: %sn",strmode[mode]);
  509. msp3400c_setcarrier(client,msp->second,msp->main);
  510. if (msp->nicam_on)
  511. nicam=0x0100;
  512. break;
  513. case MSP_MODE_BTSC:
  514. dprintk("msp3400: BTSC setstereo: %sn",strmode[mode]);
  515. nicam=0x0300;
  516. break;
  517. case MSP_MODE_EXTERN:
  518. dprintk("msp3400: extern setstereo: %sn",strmode[mode]);
  519. nicam = 0x0200;
  520. break;
  521. case MSP_MODE_FM_RADIO:
  522. dprintk("msp3400: FM-Radio setstereo: %sn",strmode[mode]);
  523. break;
  524. default:
  525. dprintk("msp3400: mono setstereon");
  526. return;
  527. }
  529. /* switch audio */
  530. switch (mode) {
  531. case VIDEO_SOUND_STEREO:
  532. src = 0x0020 | nicam;
  533. #if 0 
  534. /* spatial effect */
  535. msp3400c_write(client,I2C_MSP3400C_DFP, 0x0005,0x4000);
  536. #endif
  537. break;
  538. case VIDEO_SOUND_MONO:
  539. if (msp->mode == MSP_MODE_AM_NICAM) {
  540. dprintk("msp3400: switching to AM monon");
  541. /* AM mono decoding is handled by tuner, not MSP chip */
  542. /* SCART switching control register */
  543. msp3400c_set_scart(client,SCART_MONO,0);
  544. src = 0x0200;
  545. break;
  546. }
  547. case VIDEO_SOUND_LANG1:
  548. src = 0x0000 | nicam;
  549. break;
  550. case VIDEO_SOUND_LANG2:
  551. src = 0x0010 | nicam;
  552. break;
  553. }
  554. dprintk("msp3400: setstereo final source/matrix = 0x%xn", src);
  556. if (dolby) {
  557. msp3400c_write(client,I2C_MSP3400C_DFP, 0x0008,0x0520);
  558. msp3400c_write(client,I2C_MSP3400C_DFP, 0x0009,0x0620);
  559. msp3400c_write(client,I2C_MSP3400C_DFP, 0x000a,src);
  560. msp3400c_write(client,I2C_MSP3400C_DFP, 0x000b,src);
  561. } else {
  562. msp3400c_write(client,I2C_MSP3400C_DFP, 0x0008,src);
  563. msp3400c_write(client,I2C_MSP3400C_DFP, 0x0009,src);
  564. msp3400c_write(client,I2C_MSP3400C_DFP, 0x000a,src);
  565. msp3400c_write(client,I2C_MSP3400C_DFP, 0x000b,src);
  566. }
  567. }
  569. static void
  570. msp3400c_print_mode(struct msp3400c *msp)
  571. {
  572. if (msp->main == msp->second) {
  573. printk("msp3400: mono sound carrier: %d.%03d MHzn",
  574.        msp->main/910000,(msp->main/910)%1000);
  575. } else {
  576. printk("msp3400: main sound carrier: %d.%03d MHzn",
  577.        msp->main/910000,(msp->main/910)%1000);
  578. }
  579. if (msp->mode == MSP_MODE_FM_NICAM1 ||
  580.     msp->mode == MSP_MODE_FM_NICAM2)
  581. printk("msp3400: NICAM/FM carrier   : %d.%03d MHzn",
  582.        msp->second/910000,(msp->second/910)%1000);
  583. if (msp->mode == MSP_MODE_AM_NICAM)
  584. printk("msp3400: NICAM/AM carrier   : %d.%03d MHzn",
  585.        msp->second/910000,(msp->second/910)%1000);
  586. if (msp->mode == MSP_MODE_FM_TERRA &&
  587.     msp->main != msp->second) {
  588. printk("msp3400: FM-stereo carrier : %d.%03d MHzn",
  589.        msp->second/910000,(msp->second/910)%1000);
  590. }
  591. }
  593. static void
  594. msp3400c_restore_dfp(struct i2c_client *client)
  595. {
  596. struct msp3400c *msp = client->data;
  597. int i;
  599. for (i = 0; i < DFP_COUNT; i++) {
  600. if (-1 == msp->dfp_regs[i])
  601. continue;
  602. msp3400c_write(client,I2C_MSP3400C_DFP, i, msp->dfp_regs[i]);
  603. }
  604. }
  606. /* ----------------------------------------------------------------------- */
  608. struct REGISTER_DUMP {
  609. int   addr;
  610. char *name;
  611. };
  613. struct REGISTER_DUMP d1[] = {
  614. { 0x007e, "autodetect" },
  615. { 0x0023, "C_AD_BITS " },
  616. { 0x0038, "ADD_BITS  " },
  617. { 0x003e, "CIB_BITS  " },
  618. { 0x0057, "ERROR_RATE" },
  619. };
  621. static int
  622. autodetect_stereo(struct i2c_client *client)
  623. {
  624. struct msp3400c *msp = client->data;
  625. int val;
  626. int newstereo = msp->stereo;
  627. int newnicam  = msp->nicam_on;
  628. int update = 0;
  630. switch (msp->mode) {
  631. case MSP_MODE_FM_TERRA:
  632. val = msp3400c_read(client, I2C_MSP3400C_DFP, 0x18);
  633. if (val > 32767)
  634. val -= 65536;
  635. dprintk("msp34xx: stereo detect register: %dn",val);
  637. if (val > 4096) {
  638. newstereo = VIDEO_SOUND_STEREO | VIDEO_SOUND_MONO;
  639. } else if (val < -4096) {
  640. newstereo = VIDEO_SOUND_LANG1 | VIDEO_SOUND_LANG2;
  641. } else {
  642. newstereo = VIDEO_SOUND_MONO;
  643. }
  644. newnicam = 0;
  645. break;
  646. case MSP_MODE_FM_NICAM1:
  647. case MSP_MODE_FM_NICAM2:
  648. case MSP_MODE_AM_NICAM:
  649. val = msp3400c_read(client, I2C_MSP3400C_DEM, 0x23);
  650. dprintk("msp34xx: nicam sync=%d, mode=%dn",val & 1, (val & 0x1e) >> 1);
  652. if (val & 1) {
  653. /* nicam synced */
  654. switch ((val & 0x1e) >> 1)  {
  655. case 0:
  656. case 8:
  657. newstereo = VIDEO_SOUND_STEREO;
  658. break;
  659. case 1:
  660. case 9:
  661. newstereo = VIDEO_SOUND_MONO
  662. | VIDEO_SOUND_LANG1;
  663. break;
  664. case 2:
  665. case 10:
  666. newstereo = VIDEO_SOUND_MONO
  667. | VIDEO_SOUND_LANG1
  668. | VIDEO_SOUND_LANG2;
  669. break;
  670. default:
  671. newstereo = VIDEO_SOUND_MONO;
  672. break;
  673. }
  674. newnicam=1;
  675. } else {
  676. newnicam = 0;
  677. newstereo = VIDEO_SOUND_MONO;
  678. }
  679. break;
  680. case MSP_MODE_BTSC:
  681. val = msp3400c_read(client, I2C_MSP3400C_DEM, 0x200);
  682. dprintk("msp3410: status=0x%x (pri=%s, sec=%s, %s%s%s)n",
  683. val,
  684. (val & 0x0002) ? "no"     : "yes",
  685. (val & 0x0004) ? "no"     : "yes",
  686. (val & 0x0040) ? "stereo" : "mono",
  687. (val & 0x0080) ? ", nicam 2nd mono" : "",
  688. (val & 0x0100) ? ", bilingual/SAP"  : "");
  689. newstereo = VIDEO_SOUND_MONO;
  690. if (val & 0x0040) newstereo |= VIDEO_SOUND_STEREO;
  691. if (val & 0x0100) newstereo |= VIDEO_SOUND_LANG1;
  692. break;
  693. }
  694. if (newstereo != msp->stereo) {
  695. update = 1;
  696. dprintk("msp34xx: watch: stereo %d => %dn",
  697. msp->stereo,newstereo);
  698. msp->stereo   = newstereo;
  699. }
  700. if (newnicam != msp->nicam_on) {
  701. update = 1;
  702. dprintk("msp34xx: watch: nicam %d => %dn",
  703. msp->nicam_on,newnicam);
  704. msp->nicam_on = newnicam;
  705. }
  706. return update;
  707. }
  709. /*
  710.  * A kernel thread for msp3400 control -- we don't want to block the
  711.  * in the ioctl while doing the sound carrier & stereo detect
  712.  */
  714. static void msp3400c_stereo_wake(unsigned long data)
  715. {
  716. struct msp3400c *msp = (struct msp3400c*)data;   /* XXX alpha ??? */
  718. wake_up_interruptible(&msp->wq);
  719. }
  721. /* stereo/multilang monitoring */
  722. static void watch_stereo(struct i2c_client *client)
  723. {
  724. struct msp3400c *msp = client->data;
  726. if (autodetect_stereo(client)) {
  727. if (msp->stereo & VIDEO_SOUND_STEREO)
  728. msp3400c_setstereo(client,VIDEO_SOUND_STEREO);
  729. else if (msp->stereo & VIDEO_SOUND_LANG1)
  730. msp3400c_setstereo(client,VIDEO_SOUND_LANG1);
  731. else
  732. msp3400c_setstereo(client,VIDEO_SOUND_MONO);
  733. }
  734. if (once)
  735. msp->watch_stereo = 0;
  736. if (msp->watch_stereo)
  737. mod_timer(&msp->wake_stereo, jiffies+5*HZ);
  738. }
  740. static int msp3400c_thread(void *data)
  741. {
  742. struct i2c_client *client = data;
  743. struct msp3400c *msp = client->data;
  745. struct CARRIER_DETECT *cd;
  746. int count, max1,max2,val1,val2, val,this;
  748. #ifdef CONFIG_SMP
  749. lock_kernel();
  750. #endif
  752. daemonize();
  753. sigfillset(&current->blocked);
  754. strcpy(current->comm,"msp3400");
  756. msp->thread = current;
  758. #ifdef CONFIG_SMP
  759. unlock_kernel();
  760. #endif
  762. printk("msp3400: daemon startedn");
  763. if(msp->notify != NULL)
  764. up(msp->notify);
  766. for (;;) {
  767. if (msp->rmmod)
  768. goto done;
  769. if (debug > 1)
  770. printk("msp3400: thread: sleepn");
  771. interruptible_sleep_on(&msp->wq);
  772. if (debug > 1)
  773. printk("msp3400: thread: wakeupn");
  774. if (msp->rmmod || signal_pending(current))
  775. goto done;
  777. if (VIDEO_MODE_RADIO == msp->norm ||
  778.     MSP_MODE_EXTERN  == msp->mode)
  779. continue;  /* nothing to do */
  781. msp->active = 1;
  783. if (msp->watch_stereo) {
  784. watch_stereo(client);
  785. msp->active = 0;
  786. continue;
  787. }
  789. /* some time for the tuner to sync */
  790. current->state   = TASK_INTERRUPTIBLE;
  791. schedule_timeout(HZ/5);
  792. if (signal_pending(current))
  793. goto done;
  795. restart:
  796. if (VIDEO_MODE_RADIO == msp->norm ||
  797.     MSP_MODE_EXTERN  == msp->mode)
  798. continue;  /* nothing to do */
  799. msp->restart = 0;
  800. msp3400c_setvolume(client, msp->muted, 0, 0);
  801. msp3400c_setmode(client, MSP_MODE_AM_DETECT /* +1 */ );
  802. val1 = val2 = 0;
  803. max1 = max2 = -1;
  804. del_timer(&msp->wake_stereo);
  805. msp->watch_stereo = 0;
  807. /* carrier detect pass #1 -- main carrier */
  808. cd = carrier_detect_main; count = CARRIER_COUNT(carrier_detect_main);
  810. if (amsound && (msp->norm == VIDEO_MODE_SECAM)) {
  811. /* autodetect doesn't work well with AM ... */
  812. max1 = 3;
  813. count = 0;
  814. dprintk("msp3400: AM sound overriden");
  815. }
  817. for (this = 0; this < count; this++) {
  818. msp3400c_setcarrier(client, cd[this].cdo,cd[this].cdo);
  820. current->state   = TASK_INTERRUPTIBLE;
  821. schedule_timeout(HZ/10);
  822. if (signal_pending(current))
  823. goto done;
  824. if (msp->restart)
  825. msp->restart = 0;
  827. val = msp3400c_read(client, I2C_MSP3400C_DFP, 0x1b);
  828. if (val > 32767)
  829. val -= 65536;
  830. if (val1 < val)
  831. val1 = val, max1 = this;
  832. dprintk("msp3400: carrier1 val: %5d / %sn", val,cd[this].name);
  833. }
  835. /* carrier detect pass #2 -- second (stereo) carrier */
  836. switch (max1) {
  837. case 1: /* 5.5 */
  838. cd = carrier_detect_55; count = CARRIER_COUNT(carrier_detect_55);
  839. break;
  840. case 3: /* 6.5 */
  841. cd = carrier_detect_65; count = CARRIER_COUNT(carrier_detect_65);
  842. break;
  843. case 0: /* 4.5 */
  844. case 2: /* 6.0 */
  845. default:
  846. cd = NULL; count = 0;
  847. break;
  848. }
  850. if (amsound && (msp->norm == VIDEO_MODE_SECAM)) {
  851. /* autodetect doesn't work well with AM ... */
  852. cd = NULL; count = 0; max2 = 0;
  853. }
  854. for (this = 0; this < count; this++) {
  855. msp3400c_setcarrier(client, cd[this].cdo,cd[this].cdo);
  857. current->state   = TASK_INTERRUPTIBLE;
  858. schedule_timeout(HZ/10);
  859. if (signal_pending(current))
  860. goto done;
  861. if (msp->restart)
  862. goto restart;
  864. val = msp3400c_read(client, I2C_MSP3400C_DFP, 0x1b);
  865. if (val > 32767)
  866. val -= 65536;
  867. if (val2 < val)
  868. val2 = val, max2 = this;
  869. dprintk("msp3400: carrier2 val: %5d / %sn", val,cd[this].name);
  870. }
  872. /* programm the msp3400 according to the results */
  873. msp->main   = carrier_detect_main[max1].cdo;
  874. switch (max1) {
  875. case 1: /* 5.5 */
  876. if (max2 == 0) {
  877. /* B/G FM-stereo */
  878. msp->second = carrier_detect_55[max2].cdo;
  879. msp3400c_setmode(client, MSP_MODE_FM_TERRA);
  880. msp->nicam_on = 0;
  881. msp3400c_setstereo(client, VIDEO_SOUND_MONO);
  882. msp->watch_stereo = 1;
  883. } else if (max2 == 1 && msp->nicam) {
  884. /* B/G NICAM */
  885. msp->second = carrier_detect_55[max2].cdo;
  886. msp3400c_setmode(client, MSP_MODE_FM_NICAM1);
  887. msp->nicam_on = 1;
  888. msp3400c_setcarrier(client, msp->second, msp->main);
  889. msp->watch_stereo = 1;
  890. } else {
  891. goto no_second;
  892. }
  893. break;
  894. case 2: /* 6.0 */
  895. /* PAL I NICAM */
  896. msp->second = MSP_CARRIER(6.552);
  897. msp3400c_setmode(client, MSP_MODE_FM_NICAM2);
  898. msp->nicam_on = 1;
  899. msp3400c_setcarrier(client, msp->second, msp->main);
  900. msp->watch_stereo = 1;
  901. break;
  902. case 3: /* 6.5 */
  903. if (max2 == 1 || max2 == 2) {
  904. /* D/K FM-stereo */
  905. msp->second = carrier_detect_65[max2].cdo;
  906. msp3400c_setmode(client, MSP_MODE_FM_TERRA);
  907. msp->nicam_on = 0;
  908. msp3400c_setstereo(client, VIDEO_SOUND_MONO);
  909. msp->watch_stereo = 1;
  910. } else if (max2 == 0 &&
  911.    msp->norm == VIDEO_MODE_SECAM) {
  912. /* L NICAM or AM-mono */
  913. msp->second = carrier_detect_65[max2].cdo;
  914. msp3400c_setmode(client, MSP_MODE_AM_NICAM);
  915. msp->nicam_on = 0;
  916. msp3400c_setstereo(client, VIDEO_SOUND_MONO);
  917. msp3400c_setcarrier(client, msp->second, msp->main);
  918. /* volume prescale for SCART (AM mono input) */
  919. msp3400c_write(client,I2C_MSP3400C_DFP, 0x000d, 0x1900);
  920. msp->watch_stereo = 1;
  921. } else if (max2 == 0 && msp->nicam) {
  922. /* D/K NICAM */
  923. msp->second = carrier_detect_65[max2].cdo;
  924. msp3400c_setmode(client, MSP_MODE_FM_NICAM1);
  925. msp->nicam_on = 1;
  926. msp3400c_setcarrier(client, msp->second, msp->main);
  927. msp->watch_stereo = 1;
  928. } else {
  929. goto no_second;
  930. }
  931. break;
  932. case 0: /* 4.5 */
  933. default:
  934. no_second:
  935. msp->second = carrier_detect_main[max1].cdo;
  936. msp3400c_setmode(client, MSP_MODE_FM_TERRA);
  937. msp->nicam_on = 0;
  938. msp3400c_setcarrier(client, msp->second, msp->main);
  939. msp->stereo = VIDEO_SOUND_MONO;
  940. msp3400c_setstereo(client, VIDEO_SOUND_MONO);
  941. break;
  942. }
  944. /* unmute + restore dfp registers */
  945. msp3400c_setvolume(client, msp->muted, msp->left, msp->right);
  946. msp3400c_restore_dfp(client);
  948. if (msp->watch_stereo)
  949. mod_timer(&msp->wake_stereo, jiffies+5*HZ);
  951. if (debug)
  952. msp3400c_print_mode(msp);
  954. msp->active = 0;
  955. }
  957. done:
  958. dprintk("msp3400: thread: exitn");
  959. msp->active = 0;
  960. msp->thread = NULL;
  962. if(msp->notify != NULL)
  963. up(msp->notify);
  964. return 0;
  965. }
  967. /* ----------------------------------------------------------------------- */
  968. /* this one uses the automatic sound standard detection of newer           */
  969. /* msp34xx chip versions                                                   */
  971. static struct MODES {
  972. int retval;
  973. int main, second;
  974. char *name;
  975. } modelist[] = {
  976. { 0x0000, 0, 0, "ERROR" },
  977. { 0x0001, 0, 0, "autodetect start" },
  978. { 0x0002, MSP_CARRIER(4.5), MSP_CARRIER(4.72), "4.5/4.72  M Dual FM-Stereo" },
  979. { 0x0003, MSP_CARRIER(5.5), MSP_CARRIER(5.7421875), "5.5/5.74  B/G Dual FM-Stereo" },
  980. { 0x0004, MSP_CARRIER(6.5), MSP_CARRIER(6.2578125), "6.5/6.25  D/K1 Dual FM-Stereo" },
  981. { 0x0005, MSP_CARRIER(6.5), MSP_CARRIER(6.7421875), "6.5/6.74  D/K2 Dual FM-Stereo" },
  982. { 0x0006, MSP_CARRIER(6.5), MSP_CARRIER(6.5), "6.5  D/K FM-Mono (HDEV3)" },
  983. { 0x0008, MSP_CARRIER(5.5), MSP_CARRIER(5.85), "5.5/5.85  B/G NICAM FM" },
  984. { 0x0009, MSP_CARRIER(6.5), MSP_CARRIER(5.85), "6.5/5.85  L NICAM AM" },
  985. { 0x000a, MSP_CARRIER(6.0), MSP_CARRIER(6.55), "6.0/6.55  I NICAM FM" },
  986. { 0x000b, MSP_CARRIER(6.5), MSP_CARRIER(5.85), "6.5/5.85  D/K NICAM FM" },
  987. { 0x000c, MSP_CARRIER(6.5), MSP_CARRIER(5.85), "6.5/5.85  D/K NICAM FM (HDEV2)" },
  988. { 0x0020, MSP_CARRIER(4.5), MSP_CARRIER(4.5), "4.5  M BTSC-Stereo" },
  989. { 0x0021, MSP_CARRIER(4.5), MSP_CARRIER(4.5), "4.5  M BTSC-Mono + SAP" },
  990. { 0x0030, MSP_CARRIER(4.5), MSP_CARRIER(4.5), "4.5  M EIA-J Japan Stereo" },
  991. { 0x0040, MSP_CARRIER(10.7), MSP_CARRIER(10.7), "10.7  FM-Stereo Radio" },
  992. { 0x0050, MSP_CARRIER(6.5), MSP_CARRIER(6.5), "6.5  SAT-Mono" },
  993. { 0x0051, MSP_CARRIER(7.02), MSP_CARRIER(7.20), "7.02/7.20  SAT-Stereo" },
  994. { 0x0060, MSP_CARRIER(7.2), MSP_CARRIER(7.2), "7.2  SAT ADR" },
  995. {     -1, 0, 0, NULL }, /* EOF */
  996. };
  997.  
  998. static int msp3410d_thread(void *data)
  999. {
  1000. struct i2c_client *client = data;
  1001. struct msp3400c *msp = client->data;
  1002. int mode,val,i,std;
  1003.     
  1004. #ifdef CONFIG_SMP
  1005. lock_kernel();
  1006. #endif
  1007.     
  1008. daemonize();
  1009. sigfillset(&current->blocked);
  1010. strcpy(current->comm,"msp3410 [auto]");
  1012. msp->thread = current;
  1014. #ifdef CONFIG_SMP
  1015. unlock_kernel();
  1016. #endif
  1018. printk("msp3410: daemon startedn");
  1019. if(msp->notify != NULL)
  1020. up(msp->notify);
  1022. for (;;) {
  1023. if (msp->rmmod)
  1024. goto done;
  1025. if (debug > 1)
  1026. printk("msp3410: thread: sleepn");
  1027. interruptible_sleep_on(&msp->wq);
  1028. if (debug > 1)
  1029. printk("msp3410: thread: wakeupn");
  1030. if (msp->rmmod || signal_pending(current))
  1031. goto done;
  1033. if (msp->mode == MSP_MODE_EXTERN)
  1034. continue;
  1036. msp->active = 1;
  1038. if (msp->watch_stereo) {
  1039. watch_stereo(client);
  1040. msp->active = 0;
  1041. continue;
  1042. }
  1044. /* some time for the tuner to sync */
  1045. current->state   = TASK_INTERRUPTIBLE;
  1046. schedule_timeout(HZ/5);
  1047. if (signal_pending(current))
  1048. goto done;
  1050. restart:
  1051. if (msp->mode == MSP_MODE_EXTERN)
  1052. continue;
  1053. msp->restart = 0;
  1054. del_timer(&msp->wake_stereo);
  1055. msp->watch_stereo = 0;
  1057. /* put into sane state (and mute) */
  1058. msp3400c_reset(client);
  1060. /* start autodetect */
  1061. switch (msp->norm) {
  1062. case VIDEO_MODE_PAL:
  1063. mode = 0x1003;
  1064. std  = 1;
  1065. break;
  1066. case VIDEO_MODE_NTSC:  /* BTSC */
  1067. mode = 0x2003;
  1068. std  = 0x0020;
  1069. break;
  1070. case VIDEO_MODE_SECAM: 
  1071. mode = 0x0003;
  1072. std  = 1;
  1073. break;
  1074. case VIDEO_MODE_RADIO: 
  1075. mode = 0x0003;
  1076. std  = 0x0040;
  1077. break;
  1078. default:
  1079. mode = 0x0003;
  1080. std  = 1;
  1081. break;
  1082. }
  1083. msp3400c_write(client, I2C_MSP3400C_DEM, 0x30, mode);
  1084. msp3400c_write(client, I2C_MSP3400C_DEM, 0x20, std);
  1086. if (debug) {
  1087. int i;
  1088. for (i = 0; modelist[i].name != NULL; i++)
  1089. if (modelist[i].retval == std)
  1090. break;
  1091. printk("msp3410: setting mode: %s (0x%04x)n",
  1092.        modelist[i].name ? modelist[i].name : "unknown",std);
  1093. }
  1095. if (std != 1) {
  1096. /* programmed some specific mode */
  1097. val = std;
  1098. } else {
  1099. /* triggered autodetect */
  1100. for (;;) {
  1101. current->state   = TASK_INTERRUPTIBLE;
  1102. schedule_timeout(HZ/10);
  1103. if (signal_pending(current))
  1104. goto done;
  1105. if (msp->restart)
  1106. goto restart;
  1108. /* check results */
  1109. val = msp3400c_read(client, I2C_MSP3400C_DEM, 0x7e);
  1110. if (val < 0x07ff)
  1111. break;
  1112. dprintk("msp3410: detection still in progressn");
  1113. }
  1114. }
  1115. for (i = 0; modelist[i].name != NULL; i++)
  1116. if (modelist[i].retval == val)
  1117. break;
  1118. dprintk("msp3410: current mode: %s (0x%04x)n",
  1119. modelist[i].name ? modelist[i].name : "unknown",
  1120. val);
  1121. msp->main   = modelist[i].main;
  1122. msp->second = modelist[i].second;
  1124. if (amsound && (msp->norm == VIDEO_MODE_SECAM) && (val != 0x0009)) {
  1125. /* autodetection has failed, let backup */
  1126. dprintk("msp3410: autodetection failed, switching to backup mode: %s (0x%04x)n",
  1127. modelist[8].name ? modelist[8].name : "unknown",val);
  1128. val = 0x0009;
  1129. msp3400c_write(client, I2C_MSP3400C_DEM, 0x20, val);
  1130. }
  1132. /* set various prescales */
  1133. msp3400c_write(client, I2C_MSP3400C_DFP, 0x0d, 0x1900); /* scart */
  1134. msp3400c_write(client, I2C_MSP3400C_DFP, 0x0e, 0x2403); /* FM */
  1135. msp3400c_write(client, I2C_MSP3400C_DFP, 0x10, 0x5a00); /* nicam */
  1137. /* set stereo */
  1138. switch (val) {
  1139. case 0x0008: /* B/G NICAM */
  1140. case 0x000a: /* I NICAM */
  1141. if (val == 0x0008)
  1142. msp->mode = MSP_MODE_FM_NICAM1;
  1143. else
  1144. msp->mode = MSP_MODE_FM_NICAM2;
  1145. /* just turn on stereo */
  1146. msp->stereo = VIDEO_SOUND_STEREO;
  1147. msp->nicam_on = 1;
  1148. msp->watch_stereo = 1;
  1149. msp3400c_setstereo(client,VIDEO_SOUND_STEREO);
  1150. break;
  1151. case 0x0009:
  1152. msp->mode = MSP_MODE_AM_NICAM;
  1153. msp->stereo = VIDEO_SOUND_MONO;
  1154. msp->nicam_on = 1;
  1155. msp3400c_setstereo(client,VIDEO_SOUND_MONO);
  1156. msp->watch_stereo = 1;
  1157. break;
  1158. case 0x0020: /* BTSC */
  1159. /* just turn on stereo */
  1160. msp->mode   = MSP_MODE_BTSC;
  1161. msp->stereo = VIDEO_SOUND_STEREO;
  1162. msp->nicam_on = 0;
  1163. msp->watch_stereo = 1;
  1164. msp3400c_setstereo(client,VIDEO_SOUND_STEREO);
  1165. break;
  1166. case 0x0040: /* FM radio */
  1167. msp->mode   = MSP_MODE_FM_RADIO;
  1168. msp->stereo = VIDEO_SOUND_STEREO;
  1169. msp->nicam_on = 0;
  1170. msp->watch_stereo = 0;
  1171. /* scart routing */
  1172. msp3400c_set_scart(client,SCART_IN2,0);
  1173. msp3400c_write(client,I2C_MSP3400C_DFP, 0x08, 0x0220);
  1174. msp3400c_write(client,I2C_MSP3400C_DFP, 0x09, 0x0220);
  1175. msp3400c_write(client,I2C_MSP3400C_DFP, 0x0b, 0x0220);
  1176. break;
  1177. case 0x0003:
  1178. msp->mode   = MSP_MODE_FM_TERRA;
  1179. msp->stereo = VIDEO_SOUND_MONO;
  1180. msp->nicam_on = 0;
  1181. msp->watch_stereo = 1;
  1182. break;
  1183. }
  1185. /* unmute + restore dfp registers */
  1186. msp3400c_setbass(client, msp->bass);
  1187. msp3400c_settreble(client, msp->treble);
  1188. msp3400c_setvolume(client, msp->muted, msp->left, msp->right);
  1189. msp3400c_restore_dfp(client);
  1191. if (msp->watch_stereo)
  1192. mod_timer(&msp->wake_stereo, jiffies+HZ);
  1194. msp->active = 0;
  1195. }
  1197. done:
  1198. dprintk("msp3410: thread: exitn");
  1199. msp->active = 0;
  1200. msp->thread = NULL;
  1202. if(msp->notify != NULL)
  1203. up(msp->notify);
  1204. return 0;
  1205. }
  1207. /* ----------------------------------------------------------------------- */
  1209. static int msp_attach(struct i2c_adapter *adap, int addr,
  1210.       unsigned short flags, int kind);
  1211. static int msp_detach(struct i2c_client *client);
  1212. static int msp_probe(struct i2c_adapter *adap);
  1213. static int msp_command(struct i2c_client *client, unsigned int cmd, void *arg);
  1215. static struct i2c_driver driver = {
  1216.         name:           "i2c msp3400 driver",
  1217.         id:             I2C_DRIVERID_MSP3400,
  1218.         flags:          I2C_DF_NOTIFY,
  1219.         attach_adapter: msp_probe,
  1220.         detach_client:  msp_detach,
  1221.         command:        msp_command,
  1222. };
  1224. static struct i2c_client client_template = 
  1225. {
  1226. name:   "(unset)",
  1227. flags:  I2C_CLIENT_ALLOW_USE,
  1228.         driver: &driver,
  1229. };
  1231. static int msp_attach(struct i2c_adapter *adap, int addr,
  1232.       unsigned short flags, int kind)
  1233. {
  1234. DECLARE_MUTEX_LOCKED(sem);
  1235. struct msp3400c *msp;
  1236.         struct i2c_client *c;
  1237. int              rev1,rev2,i;
  1239.         client_template.adapter = adap;
  1240.         client_template.addr = addr;
  1242.         if (-1 == msp3400c_reset(&client_template)) {
  1243.                 dprintk("msp3400: no chip foundn");
  1244.                 return -1;
  1245.         }
  1247.         if (NULL == (c = kmalloc(sizeof(struct i2c_client),GFP_KERNEL)))
  1248.                 return -ENOMEM;
  1249.         memcpy(c,&client_template,sizeof(struct i2c_client));
  1250. if (NULL == (msp = kmalloc(sizeof(struct msp3400c),GFP_KERNEL))) {
  1251. kfree(c);
  1252. return -ENOMEM;
  1253. }
  1255. memset(msp,0,sizeof(struct msp3400c));
  1256. msp->left   = 65535;
  1257. msp->right  = 65535;
  1258. msp->bass   = 32768;
  1259. msp->treble = 32768;
  1260. msp->input  = -1;
  1261. for (i = 0; i < DFP_COUNT; i++)
  1262. msp->dfp_regs[i] = -1;
  1264. c->data = msp;
  1265. init_waitqueue_head(&msp->wq);
  1267. if (-1 == msp3400c_reset(c)) {
  1268. kfree(msp);
  1269. kfree(c);
  1270. dprintk("msp3400: no chip foundn");
  1271. return -1;
  1272. }
  1273.     
  1274. rev1 = msp3400c_read(c, I2C_MSP3400C_DFP, 0x1e);
  1275. if (-1 != rev1)
  1276. rev2 = msp3400c_read(c, I2C_MSP3400C_DFP, 0x1f);
  1277. if ((-1 == rev1) || (0 == rev1 && 0 == rev2)) {
  1278. kfree(msp);
  1279. kfree(c);
  1280. printk("msp3400: error while reading chip versionn");
  1281. return -1;
  1282. }
  1284. #if 0
  1285. /* this will turn on a 1kHz beep - might be useful for debugging... */
  1286. msp3400c_write(client,I2C_MSP3400C_DFP, 0x0014, 0x1040);
  1287. #endif
  1289. sprintf(c->name,"MSP34%02d%c-%c%d",
  1290. (rev2>>8)&0xff, (rev1&0xff)+'@', ((rev1>>8)&0xff)+'@', rev2&0x1f);
  1291. msp->nicam = (((rev2>>8)&0xff) != 00) ? 1 : 0;
  1293. if (simple == -1) {
  1294. /* default mode */
  1295. /* msp->simple = (((rev2>>8)&0xff) == 0) ? 0 : 1; */
  1296. msp->simple = ((rev1&0xff)+'@' > 'C');
  1297. } else {
  1298. /* use insmod option */
  1299. msp->simple = simple;
  1300. }
  1302. /* timer for stereo checking */
  1303. msp->wake_stereo.function = msp3400c_stereo_wake;
  1304. msp->wake_stereo.data     = (unsigned long)msp;
  1306. /* hello world :-) */
  1307. printk(KERN_INFO "msp34xx: init: chip=%s",c->name);
  1308. if (msp->nicam)
  1309. printk(", has NICAM support");
  1310. printk("n");
  1312. /* startup control thread */
  1313. MOD_INC_USE_COUNT;
  1314. msp->notify = &sem;
  1315. kernel_thread(msp->simple ? msp3410d_thread : msp3400c_thread,
  1316.       (void *)c, 0);
  1317. down(&sem);
  1318. msp->notify = NULL;
  1319. wake_up_interruptible(&msp->wq);
  1321. /* update our own array */
  1322. for (i = 0; i < MSP3400_MAX; i++) {
  1323. if (NULL == msps[i]) {
  1324. msps[i] = c;
  1325. break;
  1326. }
  1327. }
  1329. /* done */
  1330.         i2c_attach_client(c);
  1331. return 0;
  1332. }
  1334. static int msp_detach(struct i2c_client *client)
  1335. {
  1336. DECLARE_MUTEX_LOCKED(sem);
  1337. struct msp3400c *msp  = (struct msp3400c*)client->data;
  1338. int i;
  1340. /* shutdown control thread */
  1341. del_timer(&msp->wake_stereo);
  1342. if (msp->thread) 
  1343. {
  1344. msp->notify = &sem;
  1345. msp->rmmod = 1;
  1346. wake_up_interruptible(&msp->wq);
  1347. down(&sem);
  1348. msp->notify = NULL;
  1349. }
  1350.      msp3400c_reset(client);
  1352.         /* update our own array */
  1353. for (i = 0; i < MSP3400_MAX; i++) {
  1354. if (client == msps[i]) {
  1355. msps[i] = NULL;
  1356. break;
  1357. }
  1358. }
  1360. i2c_detach_client(client);
  1361. kfree(msp);
  1362. kfree(client);
  1363. MOD_DEC_USE_COUNT;
  1364. return 0;
  1365. }
  1367. static int msp_probe(struct i2c_adapter *adap)
  1368. {
  1369. if (adap->id == (I2C_ALGO_BIT | I2C_HW_B_BT848))
  1370. return i2c_probe(adap, &addr_data, msp_attach);
  1371. return 0;
  1372. }
  1374. static void msp_wake_thread(struct i2c_client *client)
  1375. {
  1376. struct msp3400c *msp  = (struct msp3400c*)client->data;
  1378. msp3400c_setvolume(client,msp->muted,0,0);
  1379. msp->watch_stereo=0;
  1380. del_timer(&msp->wake_stereo);
  1381. if (msp->active)
  1382. msp->restart = 1;
  1383. wake_up_interruptible(&msp->wq);
  1384. }
  1386. static int msp_command(struct i2c_client *client, unsigned int cmd, void *arg)
  1387. {
  1388. struct msp3400c *msp  = (struct msp3400c*)client->data;
  1389.         __u16           *sarg = arg;
  1390. #if 0
  1391. int             *iarg = (int*)arg;
  1392. #endif
  1394. switch (cmd) {
  1396. case AUDC_SET_INPUT:
  1397. /* scart switching
  1398.      - IN1 is often used for external input
  1399.      - Hauppauge uses IN2 for the radio */
  1400. dprintk(KERN_DEBUG "msp34xx: AUDC_SET_INPUT(%d)n",*sarg);
  1401. if (*sarg == msp->input)
  1402. break;
  1403. msp->input = *sarg;
  1404. switch (*sarg) {
  1405. case AUDIO_RADIO:
  1406. msp->mode   = MSP_MODE_FM_RADIO;
  1407. msp->stereo = VIDEO_SOUND_STEREO;
  1408. msp3400c_set_scart(client,SCART_IN2,0);
  1409. msp3400c_write(client,I2C_MSP3400C_DFP,0x000d,0x1900);
  1410. msp3400c_setstereo(client,msp->stereo);
  1411. break;
  1412. case AUDIO_EXTERN:
  1413. msp->mode   = MSP_MODE_EXTERN;
  1414. msp->stereo = VIDEO_SOUND_STEREO;
  1415. msp3400c_set_scart(client,SCART_IN1,0);
  1416. msp3400c_write(client,I2C_MSP3400C_DFP,0x000d,0x1900);
  1417. msp3400c_setstereo(client,msp->stereo);
  1418. break;
  1419. case AUDIO_TUNER:
  1420. msp->mode   = -1;
  1421. msp_wake_thread(client);
  1422. break;
  1423. default:
  1424. if (*sarg & AUDIO_MUTE)
  1425. msp3400c_set_scart(client,SCART_MUTE,0);
  1426. break;
  1427. }
  1428. if (msp->active)
  1429. msp->restart = 1;
  1430. break;
  1432. case AUDC_SET_RADIO:
  1433. dprintk(KERN_DEBUG "msp34xx: AUDC_SET_RADIOn");
  1434. msp->norm = VIDEO_MODE_RADIO;
  1435. msp->watch_stereo=0;
  1436. del_timer(&msp->wake_stereo);
  1437. dprintk("msp34xx: switching to radio moden");
  1438. if (msp->simple) {
  1439. /* the thread will do for us */
  1440. msp_wake_thread(client);
  1441. } else {
  1442. /* set msp3400 to FM radio mode */
  1443. msp3400c_setmode(client,MSP_MODE_FM_RADIO);
  1444. msp3400c_setcarrier(client, MSP_CARRIER(10.7),MSP_CARRIER(10.7));
  1445. msp3400c_setvolume(client,msp->muted,msp->left,msp->right);
  1446. }
  1447. if (msp->active)
  1448. msp->restart = 1;
  1449. break;
  1451. #if 1
  1452. /* work-in-progress:  hook to control the DFP registers */
  1453. case MSP_SET_DFPREG:
  1454. {
  1455. struct msp_dfpreg *r = arg;
  1456. int i;
  1458. if (r->reg < 0 || r->reg >= DFP_COUNT)
  1459. return -EINVAL;
  1460. for (i = 0; i < sizeof(bl_dfp)/sizeof(int); i++)
  1461. if (r->reg == bl_dfp[i])
  1462. return -EINVAL;
  1463. msp->dfp_regs[r->reg] = r->value;
  1464. msp3400c_write(client,I2C_MSP3400C_DFP,r->reg,r->value);
  1465. return 0;
  1466. }
  1467. case MSP_GET_DFPREG:
  1468. {
  1469. struct msp_dfpreg *r = arg;
  1471. if (r->reg < 0 || r->reg >= DFP_COUNT)
  1472. return -EINVAL;
  1473. r->value = msp3400c_read(client,I2C_MSP3400C_DFP,r->reg);
  1474. return 0;
  1475. }
  1476. #endif
  1478. /* --- v4l ioctls --- */
  1479. /* take care: bttv does userspace copying, we'll get a
  1480.    kernel pointer here... */
  1481. case VIDIOCGAUDIO:
  1482. {
  1483. struct video_audio *va = arg;
  1485. dprintk(KERN_DEBUG "msp34xx: VIDIOCGAUDIOn");
  1486. va->flags |= VIDEO_AUDIO_VOLUME |
  1487. VIDEO_AUDIO_BASS |
  1488. VIDEO_AUDIO_TREBLE |
  1489. VIDEO_AUDIO_MUTABLE;
  1490. if (msp->muted)
  1491. va->flags |= VIDEO_AUDIO_MUTE;
  1492. va->volume=MAX(msp->left,msp->right);
  1493. va->balance=(32768*MIN(msp->left,msp->right))/
  1494. (va->volume ? va->volume : 1);
  1495. va->balance=(msp->left<msp->right)?
  1496. (65535-va->balance) : va->balance;
  1497. if (0 == va->volume)
  1498. va->balance = 32768;
  1499. va->bass = msp->bass;
  1500. va->treble = msp->treble;
  1502. if (msp->norm != VIDEO_MODE_RADIO) {
  1503. autodetect_stereo(client);
  1504. va->mode = msp->stereo;
  1505. }
  1506. break;
  1507. }
  1508. case VIDIOCSAUDIO:
  1509. {
  1510. struct video_audio *va = arg;
  1512. dprintk(KERN_DEBUG "msp34xx: VIDIOCSAUDIOn");
  1513. msp->muted = (va->flags & VIDEO_AUDIO_MUTE);
  1514. msp->left = (MIN(65536 - va->balance,32768) *
  1515.      va->volume) / 32768;
  1516. msp->right = (MIN(va->balance,32768) *
  1517.       va->volume) / 32768;
  1518. msp->bass = va->bass;
  1519. msp->treble = va->treble;
  1520. msp3400c_setvolume(client,msp->muted,msp->left,msp->right);
  1521. msp3400c_setbass(client,msp->bass);
  1522. msp3400c_settreble(client,msp->treble);
  1524. if (va->mode != 0) {
  1525. msp->watch_stereo=0;
  1526. del_timer(&msp->wake_stereo);
  1527. msp->stereo = va->mode;
  1528. msp3400c_setstereo(client,va->mode);
  1529. }
  1530. break;
  1531. }
  1532. case VIDIOCSCHAN:
  1533. {
  1534. struct video_channel *vc = arg;
  1536. dprintk(KERN_DEBUG "msp34xx: VIDIOCSCHANn");
  1537. dprintk("msp34xx: switching to TV moden");
  1538. msp->norm = vc->norm;
  1539. break;
  1540. }
  1541. case VIDIOCSFREQ:
  1542. {
  1543. /* new channel -- kick audio carrier scan */
  1544. dprintk(KERN_DEBUG "msp34xx: VIDIOCSFREQn");
  1545. msp_wake_thread(client);
  1546. break;
  1547. }
  1549. default:
  1550. /* nothing */
  1551. break;
  1552. }
  1553. return 0;
  1554. }
  1556. /* ----------------------------------------------------------------------- */
  1558. static int msp3400_init_module(void)
  1559. {
  1560. i2c_add_driver(&driver);
  1561. return 0;
  1562. }
  1564. static void msp3400_cleanup_module(void)
  1565. {
  1566. i2c_del_driver(&driver);
  1567. }
  1569. module_init(msp3400_init_module);
  1570. module_exit(msp3400_cleanup_module);
  1572. /*
  1573.  * Overrides for Emacs so that we follow Linus's tabbing style.
  1574.  * ---------------------------------------------------------------------------
  1575.  * Local variables:
  1576.  * c-basic-offset: 8
  1577.  * End:
  1578.  */