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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
msp3400.c
资源名称：dvd-munitions.tar.gz　[点击查看]
上传用户：aoeyumen
上传日期：2007-01-06
资源大小：3329k
文件大小：32k
源码类别：

DVD

开发平台：

Unix_Linux

msp3400.c：源码内容
  1. /*
  2.  * programming the msp34* sound processor family
  3.  *
  4.  * (c) 1997,1998 Gerd Knorr <kraxel@goldbach.in-berlin.de>
  5.  *
  6.  * what works and what doesn't:
  7.  *
  8.  *  AM-Mono
  9.  *      probably doesn't (untested)
  10.  *
  11.  *  FM-Mono
  12.  *      should work. The stereo modes are backward compatible to FM-mono,
  13.  *      therefore FM-Mono should be allways available.
  14.  *
  15.  *  FM-Stereo (B/G, used in germany)
  16.  *      should work, with autodetect
  17.  *
  18.  *  FM-Stereo (satellite)
  19.  *      should work, no autodetect (i.e. default is mono, but you can
  20.  *      switch to stereo -- untested)
  21.  *
  22.  *  NICAM (B/G, used in UK, Scandinavia and Spain)
  23.  *      should work, with autodetect. Support for NICAM was added by
  24.  *      Pekka Pietikainen <pp@netppl.fi>
  25.  *
  26.  *
  27.  * TODO:
  28.  *   - better SAT support
  29.  *
  30.  *
  31.  * 980623  Thomas Sailer (sailer@ife.ee.ethz.ch)
  32.  *         using soundcore instead of OSS
  33.  *
  34.  */
  36. #include <linux/module.h>
  37. #include <linux/version.h>
  38. #include <linux/kernel.h>
  39. #include <linux/sched.h>
  40. #include <linux/string.h>
  41. #include <linux/timer.h>
  42. #include <linux/delay.h>
  43. #include <linux/errno.h>
  44. #include <linux/malloc.h>
  45. #ifdef __SMP__
  46. #include <asm/pgtable.h>
  47. #include <linux/smp_lock.h>
  48. #endif
  50. /* kernel_thread */
  51. #define __KERNEL_SYSCALLS__
  52. #include <linux/unistd.h>
  54. #include <linux/i2c.h>
  55. #include <linux/videodev.h>
  57. #include "msp3400.h"
  60. /* sound mixer stuff */ 
  61. #include <linux/config.h>
  63. #if LINUX_VERSION_CODE > 0x020140 /* need modular sound driver */
  64. # if defined(CONFIG_SOUND) || defined(CONFIG_SOUND_MODULE)
  65. #  define REGISTER_MIXER 1
  66. # endif
  67. #endif
  69. #undef REGISTER_MIXER
  71. static int debug = 0; /* insmod parameter */
  73. struct msp3400c {
  74. struct i2c_bus     *bus;
  76. int nicam;
  77. int mode;
  78. int norm;
  79. int stereo;
  80. int main, second; /* sound carrier */
  82. int left, right; /* volume */
  83. int bass, treble;
  85. /* thread */
  86. struct task_struct  *thread;
  87. struct wait_queue   *wq;
  88. struct semaphore    *notify;
  89. int                  active,restart,rmmod;
  91. int                  watch_stereo;
  92. struct timer_list    wake_stereo;
  93. };
  95. #define VIDEO_MODE_RADIO 16      /* norm magic for radio mode */
  97. /* ---------------------------------------------------------------------- */
  99. #define dprintk     if (debug) printk
  101. #if LINUX_VERSION_CODE < 0x020100
  102. /* 2.0.x */
  103. #define signal_pending(current)  (current->signal & ~current->blocked)
  104. #define sigfillset(set)
  105. #define mdelay(x) udelay(1000*x)
  106. #else
  107. MODULE_PARM(debug,"i");
  108. #endif
  110. #if LINUX_VERSION_CODE < 0x02017f
  111. void schedule_timeout(int j)
  112. {
  113. current->timeout = jiffies + j;
  114. schedule();
  115. }
  116. #endif
  118. /* ---------------------------------------------------------------------- */
  120. #define I2C_MSP3400C       0x80
  121. #define I2C_MSP3400C_DEM   0x10
  122. #define I2C_MSP3400C_DFP   0x12
  124. /* ----------------------------------------------------------------------- */
  125. /* functions for talking to the MSP3400C Sound processor                   */
  127. static int msp3400c_reset(struct i2c_bus *bus)
  128. {
  129. int ret = 0;
  130.     
  131. mdelay(2);
  132. i2c_start(bus);
  133. i2c_sendbyte(bus, I2C_MSP3400C,2000);
  134. i2c_sendbyte(bus, 0x00,0);
  135. i2c_sendbyte(bus, 0x80,0);
  136. i2c_sendbyte(bus, 0x00,0);
  137. i2c_stop(bus);
  138. mdelay(2);
  139. i2c_start(bus);
  140. if (0 != i2c_sendbyte(bus, I2C_MSP3400C,2000) ||
  141.     0 != i2c_sendbyte(bus, 0x00,0) ||
  142.     0 != i2c_sendbyte(bus, 0x00,0) ||
  143.     0 != i2c_sendbyte(bus, 0x00,0)) {
  144. ret = -1;
  145. printk(KERN_ERR "msp3400: chip reset failed, penguin on i2c bus?n");
  146. }
  147. i2c_stop(bus);
  148. mdelay(2);
  149. return ret;
  150. }
  152. static int
  153. msp3400c_read(struct i2c_bus *bus, int dev, int addr)
  154. {
  155. int ret=0;
  156. short val = 0;
  157. i2c_start(bus);
  158. if (0 != i2c_sendbyte(bus, I2C_MSP3400C,2000) ||
  159.     0 != i2c_sendbyte(bus, dev+1,       0)    ||
  160.     0 != i2c_sendbyte(bus, addr >> 8,   0)    ||
  161.     0 != i2c_sendbyte(bus, addr & 0xff, 0)) {
  162. ret = -1;
  163. } else {
  164. i2c_start(bus);
  165. if (0 != i2c_sendbyte(bus, I2C_MSP3400C+1,2000)) {
  166. ret = -1;
  167. } else {
  168. val |= (int)i2c_readbyte(bus,0) << 8;
  169. val |= (int)i2c_readbyte(bus,1);
  170. }
  171. }
  172. i2c_stop(bus);
  173. if (-1 == ret) {
  174. printk(KERN_WARNING "msp3400: I/O error, trying reset (read %s 0x%x)n",
  175.        (dev == I2C_MSP3400C_DEM) ? "Demod" : "Audio", addr);
  176. msp3400c_reset(bus);
  177. }
  178. return val;
  179. }
  181. static int
  182. msp3400c_write(struct i2c_bus *bus, int dev, int addr, int val)
  183. {
  184. int ret = 0;
  185.     
  186. i2c_start(bus);
  187. if (0 != i2c_sendbyte(bus, I2C_MSP3400C,2000) ||
  188.     0 != i2c_sendbyte(bus, dev,         0)    ||
  189.     0 != i2c_sendbyte(bus, addr >> 8,   0)    ||
  190.     0 != i2c_sendbyte(bus, addr & 0xff, 0)    ||
  191.     0 != i2c_sendbyte(bus, val >> 8,    0)    ||
  192.     0 != i2c_sendbyte(bus, val & 0xff,  0))
  193. ret = -1;
  194. i2c_stop(bus);
  195. if (-1 == ret) {
  196. printk(KERN_WARNING "msp3400: I/O error, trying reset (write %s 0x%x)n",
  197.        (dev == I2C_MSP3400C_DEM) ? "Demod" : "Audio", addr);
  198. msp3400c_reset(bus);
  199. }
  200. return ret;
  201. }
  203. /* ------------------------------------------------------------------------ */
  205. /* This macro is allowed for *constants* only, gcc must calculate it
  206.    at compile time.  Remember -- no floats in kernel mode */
  207. #define MSP_CARRIER(freq) ((int)((float)(freq/18.432)*(1<<24)))
  209. #define MSP_MODE_AM_DETECT   0
  210. #define MSP_MODE_FM_RADIO    2
  211. #define MSP_MODE_FM_TERRA    3
  212. #define MSP_MODE_FM_SAT      4
  213. #define MSP_MODE_FM_NICAM1   5
  214. #define MSP_MODE_FM_NICAM2   6
  216. static struct MSP_INIT_DATA_DEM {
  217. int fir1[6];
  218. int fir2[6];
  219. int cdo1;
  220. int cdo2;
  221. int ad_cv;
  222. int mode_reg;
  223. int dfp_src;
  224. int dfp_matrix;
  225. } msp_init_data[] = {
  226. /* AM (for carrier detect / msp3400) */
  227. { { 75, 19, 36, 35, 39, 40 }, { 75, 19, 36, 35, 39, 40 },
  228.   MSP_CARRIER(5.5), MSP_CARRIER(5.5),
  229.   0x00d0, 0x0500,   0x0020, 0x3000},
  231. /* AM (for carrier detect / msp3410) */
  232. { { -1, -1, -8, 2, 59, 126 }, { -1, -1, -8, 2, 59, 126 },
  233.   MSP_CARRIER(5.5), MSP_CARRIER(5.5),
  234.   0x00d0, 0x0100,   0x0020, 0x3000},
  236. /* FM Radio */
  237. { { -8, -8, 4, 6, 78, 107 }, { -8, -8, 4, 6, 78, 107 },
  238.   MSP_CARRIER(10.7), MSP_CARRIER(10.7),
  239.   0x00d0, 0x0480, 0x0020, 0x3000 },
  241. /* Terrestial FM-mono + FM-stereo */
  242. { {  3, 18, 27, 48, 66, 72 }, {  3, 18, 27, 48, 66, 72 },
  243.   MSP_CARRIER(5.5), MSP_CARRIER(5.5),
  244.   0x00d0, 0x0480,   0x0030, 0x3000},
  246. /* Sat FM-mono */
  247. { {  1,  9, 14, 24, 33, 37 }, {  3, 18, 27, 48, 66, 72 },
  248.   MSP_CARRIER(6.5), MSP_CARRIER(6.5),
  249.   0x00c6, 0x0480,   0x0000, 0x3000},
  251. /* NICAM B/G, D/K */
  252. { { -2, -8, -10, 10, 50, 86 }, {  3, 18, 27, 48, 66, 72 },
  253.   MSP_CARRIER(5.5), MSP_CARRIER(5.5),
  254.   0x00d0, 0x0040,   0x0120, 0x3000},
  256. /* NICAM I */
  257. { {  2, 4, -6, -4, 40, 94 }, {  3, 18, 27, 48, 66, 72 },
  258.   MSP_CARRIER(6.0), MSP_CARRIER(6.0),
  259.   0x00d0, 0x0040,   0x0120, 0x3000},
  260. };
  262. struct CARRIER_DETECT {
  263. int   cdo;
  264. char *name;
  265. };
  267. static struct CARRIER_DETECT carrier_detect_main[] = {
  268. /* main carrier */
  269. { MSP_CARRIER(4.5),        "4.5   NTSC"                   }, 
  270. { MSP_CARRIER(5.5),        "5.5   PAL B/G"                }, 
  271. { MSP_CARRIER(6.0),        "6.0   PAL I"                  },
  272. { MSP_CARRIER(6.5),        "6.5   PAL D/K + SAT + SECAM"  }
  273. };
  275. static struct CARRIER_DETECT carrier_detect_55[] = {
  276. /* PAL B/G */
  277. { MSP_CARRIER(5.7421875),  "5.742 PAL B/G FM-stereo"     }, 
  278. { MSP_CARRIER(5.85),       "5.85  PAL B/G NICAM"         }
  279. };
  281. static struct CARRIER_DETECT carrier_detect_65[] = {
  282. /* PAL SAT / SECAM */
  283. { MSP_CARRIER(5.85),       "5.85  PAL D/K NICAM" },
  284. { MSP_CARRIER(6.2578125),  "6.25  PAL D/K1 FM-stereo" },
  285. { MSP_CARRIER(6.7421875),  "6.74  PAL D/K2 FM-stereo" },
  286. { MSP_CARRIER(7.02),       "7.02  PAL SAT FM-stereo s/b" },
  287. { MSP_CARRIER(7.20),       "7.20  PAL SAT FM-stereo s"   },
  288. { MSP_CARRIER(7.38),       "7.38  PAL SAT FM-stereo b"   },
  289. };
  291. #define CARRIER_COUNT(x) (sizeof(x)/sizeof(struct CARRIER_DETECT))
  293. /* ------------------------------------------------------------------------ */
  295. static void msp3400c_setcarrier(struct i2c_bus *bus, int cdo1, int cdo2)
  296. {
  297. msp3400c_write(bus,I2C_MSP3400C_DEM, 0x0093, cdo1 & 0xfff);
  298. msp3400c_write(bus,I2C_MSP3400C_DEM, 0x009b, cdo1 >> 12);
  299. msp3400c_write(bus,I2C_MSP3400C_DEM, 0x00a3, cdo2 & 0xfff);
  300. msp3400c_write(bus,I2C_MSP3400C_DEM, 0x00ab, cdo2 >> 12);
  301. msp3400c_write(bus,I2C_MSP3400C_DEM, 0x0056, 0); /*LOAD_REG_1/2*/
  302. }
  304. static void msp3400c_setvolume(struct i2c_bus *bus, int left, int right)
  305. {
  306. int vol,val,balance;
  308. vol     = (left > right) ? left : right;
  309. val     = (vol * 0x73 / 65535) << 8;
  310. balance = 0;
  311. if (vol > 0)
  312. balance = ((right-left) * 127) / vol;
  314. dprintk("msp3400: setvolume: %d:%d 0x%02x 0x%02xn",
  315. left,right,val>>8,balance);
  316. msp3400c_write(bus,I2C_MSP3400C_DFP, 0x0000, val); /* loudspeaker */
  317. msp3400c_write(bus,I2C_MSP3400C_DFP, 0x0006, val); /* headphones  */
  318. /* scart - on/off only */
  319. msp3400c_write(bus,I2C_MSP3400C_DFP, 0x0007, val ? 0x4000 : 0);
  320. msp3400c_write(bus,I2C_MSP3400C_DFP, 0x0001, balance << 8);
  321. }
  323. static void msp3400c_setbass(struct i2c_bus *bus, int bass)
  324. {
  325. int val = ((bass-32768) * 0x60 / 65535) << 8;
  327. dprintk("msp3400: setbass: %d 0x%02xn",bass, val>>8);
  328. msp3400c_write(bus,I2C_MSP3400C_DFP, 0x0002, val); /* loudspeaker */
  329. }
  331. static void msp3400c_settreble(struct i2c_bus *bus, int treble)
  332. {
  333. int val = ((treble-32768) * 0x60 / 65535) << 8;
  335. dprintk("msp3400: settreble: %d 0x%02xn",treble, val>>8);
  336. msp3400c_write(bus,I2C_MSP3400C_DFP, 0x0003, val); /* loudspeaker */
  337. }
  339. static void msp3400c_setmode(struct msp3400c *msp, int type)
  340. {
  341. int i;
  343. dprintk("msp3400: setmode: %dn",type);
  344. msp->mode   = type;
  345. msp->stereo = VIDEO_SOUND_MONO;
  347. msp3400c_write(msp->bus,I2C_MSP3400C_DEM, 0x00bb,          /* ad_cv */
  348.        msp_init_data[type].ad_cv);
  349.     
  350. for (i = 5; i >= 0; i--)                                   /* fir 1 */
  351. msp3400c_write(msp->bus,I2C_MSP3400C_DEM, 0x0001,
  352.        msp_init_data[type].fir1[i]);
  353.     
  354. msp3400c_write(msp->bus,I2C_MSP3400C_DEM, 0x0005, 0x0004); /* fir 2 */
  355. msp3400c_write(msp->bus,I2C_MSP3400C_DEM, 0x0005, 0x0040);
  356. msp3400c_write(msp->bus,I2C_MSP3400C_DEM, 0x0005, 0x0000);
  357. for (i = 5; i >= 0; i--)
  358. msp3400c_write(msp->bus,I2C_MSP3400C_DEM, 0x0005,
  359.        msp_init_data[type].fir2[i]);
  360.     
  361. msp3400c_write(msp->bus,I2C_MSP3400C_DEM, 0x0083,     /* MODE_REG */
  362.        msp_init_data[type].mode_reg);
  363.     
  364. msp3400c_setcarrier(msp->bus, msp_init_data[type].cdo1,
  365.     msp_init_data[type].cdo2);
  366.     
  367. msp3400c_write(msp->bus,I2C_MSP3400C_DEM, 0x0056, 0); /*LOAD_REG_1/2*/
  369. msp3400c_write(msp->bus,I2C_MSP3400C_DFP, 0x0008,
  370.        msp_init_data[type].dfp_src);
  371. msp3400c_write(msp->bus,I2C_MSP3400C_DFP, 0x0009,
  372.        msp_init_data[type].dfp_src);
  373. msp3400c_write(msp->bus,I2C_MSP3400C_DFP, 0x000a,
  374.        msp_init_data[type].dfp_src);
  375. msp3400c_write(msp->bus,I2C_MSP3400C_DFP, 0x000e,
  376.        msp_init_data[type].dfp_matrix);
  378. if (msp->nicam) {
  379. /* msp3410 needs some more initialization */
  380. msp3400c_write(msp->bus,I2C_MSP3400C_DFP, 0x0010, 0x3000);
  381. }
  382. }
  384. static void msp3400c_setstereo(struct msp3400c *msp, int mode)
  385. {
  386. int nicam=0; /* channel source: FM/AM or nicam */
  388. /* switch demodulator */
  389. switch (msp->mode) {
  390. case MSP_MODE_FM_TERRA:
  391. dprintk("msp3400: FM setstereo: %dn",mode);
  392. msp->stereo = mode;
  393. msp3400c_setcarrier(msp->bus,msp->second,msp->main);
  394. switch (mode) {
  395. case VIDEO_SOUND_STEREO:
  396. msp3400c_write(msp->bus,I2C_MSP3400C_DFP, 0x000e, 0x3001);
  397. break;
  398. case VIDEO_SOUND_MONO:
  399. case VIDEO_SOUND_LANG1:
  400. case VIDEO_SOUND_LANG2:
  401. msp3400c_write(msp->bus,I2C_MSP3400C_DFP, 0x000e, 0x3000);
  402. break;
  403. }
  404. break;
  405. case MSP_MODE_FM_SAT:
  406. dprintk("msp3400: SAT setstereo: %dn",mode);
  407. msp->stereo = mode;
  408. switch (mode) {
  409. case VIDEO_SOUND_MONO:
  410. msp3400c_setcarrier(msp->bus, MSP_CARRIER(6.5), MSP_CARRIER(6.5));
  411. break;
  412. case VIDEO_SOUND_STEREO:
  413. msp3400c_setcarrier(msp->bus, MSP_CARRIER(7.2), MSP_CARRIER(7.02));
  414. break;
  415. case VIDEO_SOUND_LANG1:
  416. msp3400c_setcarrier(msp->bus, MSP_CARRIER(7.38), MSP_CARRIER(7.02));
  417. break;
  418. case VIDEO_SOUND_LANG2:
  419. msp3400c_setcarrier(msp->bus, MSP_CARRIER(7.38), MSP_CARRIER(7.02));
  420. break;
  421. }
  422. break;
  423. case MSP_MODE_FM_NICAM1:
  424. case MSP_MODE_FM_NICAM2:
  425. dprintk("msp3400: NICAM setstereo: %dn",mode);
  426. msp->stereo = mode;
  427. msp3400c_setcarrier(msp->bus,msp->second,msp->main);
  428. nicam=0x0100;
  429. break;
  430. default:
  431. /* can't do stereo - abort here */
  432. return;
  433. }
  435. /* switch audio */
  436. switch (mode) {
  437. case VIDEO_SOUND_STEREO:
  438. msp3400c_write(msp->bus,I2C_MSP3400C_DFP, 0x0008,0x0020|nicam);
  439. msp3400c_write(msp->bus,I2C_MSP3400C_DFP, 0x0009,0x0020|nicam);
  440. msp3400c_write(msp->bus,I2C_MSP3400C_DFP, 0x000a,0x0020|nicam);
  441. #if 0
  442. msp3400c_write(msp->bus,I2C_MSP3400C_DFP, 0x0005,0x4000);
  443. #endif
  444. break;
  445. case VIDEO_SOUND_MONO:
  446. case VIDEO_SOUND_LANG1:
  447. msp3400c_write(msp->bus,I2C_MSP3400C_DFP, 0x0008,0x0000|nicam);
  448. msp3400c_write(msp->bus,I2C_MSP3400C_DFP, 0x0009,0x0000|nicam);
  449. msp3400c_write(msp->bus,I2C_MSP3400C_DFP, 0x000a,0x0000|nicam);
  450. break;
  451. case VIDEO_SOUND_LANG2:
  452. msp3400c_write(msp->bus,I2C_MSP3400C_DFP, 0x0008,0x0010|nicam);
  453. msp3400c_write(msp->bus,I2C_MSP3400C_DFP, 0x0009,0x0010|nicam);
  454. msp3400c_write(msp->bus,I2C_MSP3400C_DFP, 0x000a,0x0010|nicam);
  455. break;
  456. }
  457. }
  459. static void
  460. msp3400c_print_mode(struct msp3400c *msp)
  461. {
  462. if (msp->main == msp->second) {
  463. printk("msp3400: mono sound carrier: %d.%03d MHzn",
  464.        msp->main/910000,(msp->main/910)%1000);
  465. } else {
  466. printk("msp3400: main sound carrier: %d.%03d MHzn",
  467.        msp->main/910000,(msp->main/910)%1000);
  468. }
  469. if (msp->mode == MSP_MODE_FM_NICAM1 ||
  470.     msp->mode == MSP_MODE_FM_NICAM2)
  471. printk("msp3400: NICAM carrier     : %d.%03d MHzn",
  472.        msp->second/910000,(msp->second/910)%1000);
  473. if (msp->mode == MSP_MODE_FM_TERRA &&
  474.     msp->main != msp->second) {
  475. printk("msp3400: FM-stereo carrier : %d.%03d MHzn",
  476.        msp->second/910000,(msp->second/910)%1000);
  477. }
  478. }
  480. /* ----------------------------------------------------------------------- */
  482. struct REGISTER_DUMP {
  483. int   addr;
  484. char *name;
  485. };
  487. struct REGISTER_DUMP d1[] = {
  488. { 0x007e, "autodetect" },
  489. { 0x0023, "C_AD_BITS " },
  490. { 0x0038, "ADD_BITS  " },
  491. { 0x003e, "CIB_BITS  " },
  492. { 0x0057, "ERROR_RATE" },
  493. };
  495. /*
  496.  * A kernel thread for msp3400 control -- we don't want to block the
  497.  * in the ioctl while doing the sound carrier & stereo detect
  498.  */
  500. static void msp3400c_stereo_wake(unsigned long data)
  501. {
  502. struct msp3400c *msp = (struct msp3400c*)data;   /* XXX alpha ??? */
  504. wake_up_interruptible(&msp->wq);
  505. }
  507. static int msp3400c_thread(void *data)
  508. {
  509. struct msp3400c *msp = data;
  510.     
  511. struct CARRIER_DETECT *cd;
  512. int                   count, max1,max2,val1,val2, val,this;
  513. int                   newstereo;
  514. LOCK_FLAGS;
  515.     
  516. #ifdef __SMP__
  517. lock_kernel();
  518. #endif
  519.     
  520. exit_mm(current);
  521. current->session = 1;
  522. current->pgrp = 1;
  523. sigfillset(&current->blocked);
  524. current->fs->umask = 0;
  525. strcpy(current->comm,"msp3400");
  527. msp->wq     = NULL;
  528. msp->thread = current;
  530. #ifdef __SMP__
  531. unlock_kernel();
  532. #endif
  534. dprintk("msp3400: thread: startn");
  535. if(msp->notify != NULL)
  536. up(msp->notify);
  538. for (;;) {
  539. if (msp->rmmod)
  540. goto done;
  541. if (debug > 1)
  542. printk("msp3400: thread: sleepn");
  543. interruptible_sleep_on(&msp->wq);
  544. if (debug > 1)
  545. printk("msp3400: thread: wakeupn");
  546. if (msp->rmmod || signal_pending(current))
  547. goto done;
  549. if (VIDEO_MODE_RADIO == msp->norm)
  550. continue;  /* nothing to do */
  552. msp->active = 1;
  554. if (msp->watch_stereo) {
  555. /* do that stereo/multilang handling */
  556. LOCK_I2C_BUS(msp->bus);
  557. newstereo = msp->stereo;
  558. switch (msp->mode) {
  559. case MSP_MODE_FM_TERRA:
  560. val = msp3400c_read(msp->bus, I2C_MSP3400C_DFP, 0x18);
  561. dprintk("msp3400: stereo detect register: %dn",val);
  563. if (val > 4096) {
  564. newstereo = VIDEO_SOUND_STEREO;
  565. } else if (val < -4096) {
  566. newstereo = VIDEO_SOUND_LANG1;
  567. } else {
  568. newstereo = VIDEO_SOUND_MONO;
  569. }
  570. break;
  571. case MSP_MODE_FM_NICAM1:
  572. case MSP_MODE_FM_NICAM2:
  573. val = msp3400c_read(msp->bus, I2C_MSP3400C_DEM, 0x23);
  574. switch ((val & 0x1e) >> 1)  {
  575. case 0:
  576. case 8:
  577. newstereo = VIDEO_SOUND_STEREO;
  578. break;
  579. default:
  580. newstereo = VIDEO_SOUND_MONO;
  581. break;
  582. }
  583. break;
  584. }
  585. if (msp->stereo != newstereo) {
  586. dprintk("msp3400: watch: stereo %d ==> %dn",
  587. msp->stereo,newstereo);
  588. msp3400c_setstereo(msp,newstereo);
  589. }
  590. UNLOCK_I2C_BUS(msp->bus);
  591. if (msp->watch_stereo) {
  592. del_timer(&msp->wake_stereo);
  593. msp->wake_stereo.expires = jiffies + 5*HZ;
  594. add_timer(&msp->wake_stereo);
  595. }
  597. msp->active = 0;
  598. continue;
  599. }
  601. restart:
  602. LOCK_I2C_BUS(msp->bus);
  603. msp3400c_setvolume(msp->bus, 0, 0);
  604. msp3400c_setmode(msp, MSP_MODE_AM_DETECT);
  605. val1 = val2 = 0;
  606. max1 = max2 = -1;
  607. del_timer(&msp->wake_stereo);
  608. msp->watch_stereo = 0;
  610. /* carrier detect pass #1 -- main carrier */
  611. cd = carrier_detect_main; count = CARRIER_COUNT(carrier_detect_main);
  612. for (this = 0; this < count; this++) {
  613. msp3400c_setcarrier(msp->bus, cd[this].cdo,cd[this].cdo);
  614. UNLOCK_I2C_BUS(msp->bus);
  616. current->state   = TASK_INTERRUPTIBLE;
  617. schedule_timeout(HZ/25);
  618. if (signal_pending(current))
  619. goto done;
  620. if (msp->restart) {
  621. msp->restart = 0;
  622. goto restart;
  623. }
  625. LOCK_I2C_BUS(msp->bus);
  626. val = msp3400c_read(msp->bus, I2C_MSP3400C_DFP, 0x1b);
  627. if (val1 < val)
  628. val1 = val, max1 = this;
  629. dprintk("msp3400: carrier1 val: %5d / %sn", val,cd[this].name);
  630. }
  632. /* carrier detect pass #2 -- second (stereo) carrier */
  633. switch (max1) {
  634. case 1: /* 5.5 */
  635. cd = carrier_detect_55; count = CARRIER_COUNT(carrier_detect_55);
  636. break;
  637. case 3: /* 6.5 */
  638. cd = carrier_detect_65; count = CARRIER_COUNT(carrier_detect_65);
  639. break;
  640. case 0: /* 4.5 */
  641. case 2: /* 6.0 */
  642. default:
  643. cd = NULL; count = 0;
  644. break;
  645. }
  646. for (this = 0; this < count; this++) {
  647. msp3400c_setcarrier(msp->bus, cd[this].cdo,cd[this].cdo);
  648. UNLOCK_I2C_BUS(msp->bus);
  650. current->state   = TASK_INTERRUPTIBLE;
  651. schedule_timeout(HZ/25);
  652. if (signal_pending(current))
  653. goto done;
  654. if (msp->restart) {
  655. msp->restart = 0;
  656. goto restart;
  657. }
  659. LOCK_I2C_BUS(msp->bus);
  660. val = msp3400c_read(msp->bus, I2C_MSP3400C_DFP, 0x1b);
  661. if (val2 < val)
  662. val2 = val, max2 = this;
  663. dprintk("msp3400: carrier2 val: %5d / %sn", val,cd[this].name);
  664. }
  666. /* programm the msp3400 according to the results */
  667. msp->main   = carrier_detect_main[max1].cdo;
  668. switch (max1) {
  669. case 1: /* 5.5 */
  670. if (max2 == 0) {
  671. /* B/G FM-stereo */
  672. msp->second = carrier_detect_55[max2].cdo;
  673. msp3400c_setmode(msp, MSP_MODE_FM_TERRA);
  674. msp3400c_setstereo(msp, VIDEO_SOUND_MONO);
  675. msp->watch_stereo = 1;
  676. } else if (max2 == 1 && msp->nicam) {
  677. /* B/G NICAM */
  678. msp->second = carrier_detect_55[max2].cdo;
  679. msp3400c_setmode(msp, MSP_MODE_FM_NICAM1);
  680. msp3400c_setcarrier(msp->bus, msp->second, msp->main);
  681. msp->watch_stereo = 1;
  682. } else {
  683. goto no_second;
  684. }
  685. break;
  686. case 2: /* 6.0 */
  687. /* PAL I NICAM */
  688. msp->second = MSP_CARRIER(6.552);
  689. msp3400c_setmode(msp, MSP_MODE_FM_NICAM2);
  690. msp3400c_setcarrier(msp->bus, msp->second, msp->main);
  691. msp->watch_stereo = 1;
  692. break;
  693. case 3: /* 6.5 */
  694. if (max2 == 1 || max2 == 2) {
  695. /* D/K FM-stereo */
  696. msp->second = carrier_detect_65[max2].cdo;
  697. msp3400c_setmode(msp, MSP_MODE_FM_TERRA);
  698. msp3400c_setstereo(msp, VIDEO_SOUND_MONO);
  699. msp->watch_stereo = 1;
  700. } else if (max2 == 0 && msp->nicam) {
  701. /* D/K NICAM */
  702. msp->second = carrier_detect_65[max2].cdo;
  703. msp3400c_setmode(msp, MSP_MODE_FM_NICAM1);
  704. msp3400c_setcarrier(msp->bus, msp->second, msp->main);
  705. msp->watch_stereo = 1;
  706. } else {
  707. goto no_second;
  708. }
  709. break;
  710. case 0: /* 4.5 */
  711. default:
  712. no_second:
  713. msp->second = carrier_detect_main[max1].cdo;
  714. msp3400c_setmode(msp, MSP_MODE_FM_TERRA);
  715. msp3400c_setcarrier(msp->bus, msp->second, msp->main);
  716. break;
  717. }
  719. /* unmute */
  720. msp3400c_setvolume(msp->bus, msp->left, msp->right);
  721. UNLOCK_I2C_BUS(msp->bus);
  723. if (msp->watch_stereo) {
  724. del_timer(&msp->wake_stereo);
  725. msp->wake_stereo.expires = jiffies + 2*HZ;
  726. add_timer(&msp->wake_stereo);
  727. }
  729. if (debug)
  730. msp3400c_print_mode(msp);
  732. msp->active = 0;
  733. }
  735. done:
  736. dprintk("msp3400: thread: exitn");
  737. msp->active = 0;
  738. msp->thread = NULL;
  740. if(msp->notify != NULL)
  741. up(msp->notify);
  742. return 0;
  743. }
  746. #if 0 /* not finished yet */
  748. static int msp3410d_thread(void *data)
  749. {
  750. unsigned long flags;
  751. struct msp3400c *msp = data;
  752. struct semaphore sem = MUTEX_LOCKED;
  753. int              i, val;
  755. /* lock_kernel(); */
  756.     
  757. exit_mm(current);
  758. current->session = 1;
  759. current->pgrp = 1;
  760. sigfillset(&current->blocked);
  761. current->fs->umask = 0;
  762. strcpy(current->comm,"msp3410 (nicam)");
  764. msp->wait   = &sem;
  765. msp->thread = current;
  767. /* unlock_kernel(); */
  769. dprintk("msp3410: thread: startn");
  770. if(msp->notify != NULL)
  771. up(msp->notify);
  773. for (;;) {
  774. if (msp->rmmod)
  775. goto done;
  776. dprintk("msp3410: thread: sleepn");
  777. down_interruptible(&sem);
  778. dprintk("msp3410: thread: wakeupn");
  779. if (msp->rmmod)
  780. goto done;
  782. if (VIDEO_MODE_RADIO == msp->norm)
  783. continue;  /* nothing to do */
  785. msp->active = 1;
  787. restart:
  788. LOCK_I2C_BUS(msp->bus);
  789. /* mute */
  790. msp3400c_setvolume(msp->bus, 0);
  791. /* quick & dirty hack:
  792.    get the audio proccessor into some useful state */
  793. msp3400c_setmode(msp, MSP_MODE_FM_NICAM1);
  794. /* kick autodetect */
  795. msp3400c_write(msp->bus, I2C_MSP3400C_DFP, 0x20, 0x01);
  796. msp3400c_write(msp->bus, I2C_MSP3400C_DFP, 0x21, 0x01);
  797. UNLOCK_I2C_BUS(msp->bus);
  799. /* wait 1 sec */
  800. current->state = TASK_INTERRUPTIBLE;
  801. current->timeout = jiffies + HZ;
  802. schedule();
  803. if (signal_pending(current))
  804. goto done;
  805. if (msp->restart) {
  806. msp->restart = 0;
  807. goto restart;
  808. }
  810. LOCK_I2C_BUS(msp->bus);
  811. /* debug register dump */
  812. for (i = 0; i < sizeof(d1)/sizeof(struct REGISTER_DUMP); i++) {
  813. val = msp3400c_read(msp->bus,I2C_MSP3400C_DEM,d1[i].addr);
  814. printk(KERN_DEBUG "msp3400: %s = 0x%xn",d1[i].name,val);
  815. }
  816. /* unmute */
  817. msp3400c_setvolume(msp->bus, msp->volume);
  818. UNLOCK_I2C_BUS(msp->bus);
  820. msp->active = 0;
  821. }
  823. done:
  824. dprintk("msp3410: thread: exitn");
  825. msp->wait   = NULL;
  826. msp->active = 0;
  827. msp->thread = NULL;
  829. if(msp->notify != NULL)
  830. up(msp->notify);
  831. return 0;
  832. }
  833. #endif
  835. /* ----------------------------------------------------------------------- */
  836. /* mixer stuff -- with the modular sound driver in 2.1.x we can easily     */
  837. /* register the msp3400 as mixer device                                    */
  839. #ifdef REGISTER_MIXER
  841. #include <linux/sound.h>
  842. #include <linux/soundcard.h>
  843. #include <asm/uaccess.h>
  845. static struct msp3400c *mspmix = NULL;  /* ugly hack, should do something more sensible */
  846. static int mixer_num;
  847. static int mixer_modcnt = 0;
  848. static struct semaphore mixer_sem = MUTEX;
  850. static int mix_to_v4l(int i)
  851. {
  852. int r;
  854. r = ((i & 0xff) * 65536 + 50) / 100;
  855. if (r > 65535) r = 65535;
  856. if (r <     0) r =     0;
  857. return r;
  858. }
  860. static int v4l_to_mix(int i)
  861. {
  862. int r;
  864. r = (i * 100 + 32768) / 65536;
  865. if (r > 100) r = 100;
  866. if (r <   0) r =   0;
  867. return r | (r << 8);
  868. }
  870. static int v4l_to_mix2(int l, int r)
  871. {
  872. r = (r * 100 + 32768) / 65536;
  873. if (r > 100) r = 100;
  874. if (r <   0) r =   0;
  875. l = (l * 100 + 32768) / 65536;
  876. if (l > 100) l = 100;
  877. if (l <   0) l =   0;
  878. return (r << 8) | l;
  879. }
  881. static int
  882. msp3400c_mixer_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
  883. {
  884. int ret,val = 0;
  885. LOCK_FLAGS;
  887.         if (cmd == SOUND_MIXER_INFO) {
  888.                 mixer_info info;
  889.                 strncpy(info.id, "MSP3400", sizeof(info.id));
  890.                 strncpy(info.name, "MSP 3400", sizeof(info.name));
  891.                 info.modify_counter = mixer_modcnt;
  892.                 if (copy_to_user((void *)arg, &info, sizeof(info)))
  893.                         return -EFAULT;
  894.                 return 0;
  895.         }
  896.         if (cmd == SOUND_OLD_MIXER_INFO) {
  897.                 _old_mixer_info info;
  898.                 strncpy(info.id, "MSP3400", sizeof(info.id));
  899.                 strncpy(info.name, "MSP 3400", sizeof(info.name));
  900.                 if (copy_to_user((void *)arg, &info, sizeof(info)))
  901.                         return -EFAULT;
  902.                 return 0;
  903.         }
  904.         if (cmd == OSS_GETVERSION)
  905.                 return put_user(SOUND_VERSION, (int *)arg);
  907. if (_SIOC_DIR(cmd) & _SIOC_WRITE)
  908. if (get_user(val, (int *)arg))
  909. return -EFAULT;
  910.     
  911. down(&mixer_sem);
  912. if (!mspmix) {
  913. up(&mixer_sem);
  914. return -ENODEV;
  915. }
  917. switch (cmd) {
  918. case MIXER_READ(SOUND_MIXER_RECMASK):
  919. case MIXER_READ(SOUND_MIXER_CAPS):
  920. case MIXER_READ(SOUND_MIXER_RECSRC):
  921. case MIXER_WRITE(SOUND_MIXER_RECSRC):
  922. ret = 0;
  923. break;
  925. case MIXER_READ(SOUND_MIXER_STEREODEVS):
  926. ret = SOUND_MASK_VOLUME;
  927. break;
  928. case MIXER_READ(SOUND_MIXER_DEVMASK):
  929. ret = SOUND_MASK_VOLUME | SOUND_MASK_BASS | SOUND_MASK_TREBLE;
  930. break;
  932. case MIXER_WRITE(SOUND_MIXER_VOLUME):
  933. mspmix->left  = mix_to_v4l(val);
  934. mspmix->right = mix_to_v4l(val >> 8);
  935. LOCK_I2C_BUS(mspmix->bus);
  936. msp3400c_setvolume(mspmix->bus,mspmix->left,mspmix->right);
  937. UNLOCK_I2C_BUS(mspmix->bus);
  938. mixer_modcnt++;
  939. /* fall */
  940. case MIXER_READ(SOUND_MIXER_VOLUME):
  941. ret = v4l_to_mix2(mspmix->left, mspmix->right);
  942. break;
  944. case MIXER_WRITE(SOUND_MIXER_BASS):
  945. mspmix->bass = mix_to_v4l(val);
  946. LOCK_I2C_BUS(mspmix->bus);
  947. msp3400c_setbass(mspmix->bus,mspmix->bass);
  948. UNLOCK_I2C_BUS(mspmix->bus);
  949. mixer_modcnt++;
  950. /* fall */
  951. case MIXER_READ(SOUND_MIXER_BASS):
  952. ret = v4l_to_mix(mspmix->bass);
  953. break;
  955. case MIXER_WRITE(SOUND_MIXER_TREBLE):
  956. mspmix->treble = mix_to_v4l(val);
  957. LOCK_I2C_BUS(mspmix->bus);
  958. msp3400c_settreble(mspmix->bus,mspmix->treble);
  959. UNLOCK_I2C_BUS(mspmix->bus);
  960. mixer_modcnt++;
  961. /* fall */
  962. case MIXER_READ(SOUND_MIXER_TREBLE):
  963. ret = v4l_to_mix(mspmix->treble);
  964. break;
  966. default:
  967. up(&mixer_sem);
  968. return -EINVAL;
  969. }
  970. up(&mixer_sem);
  971. if (put_user(ret, (int *)arg))
  972. return -EFAULT;
  973. return 0;
  974. }
  976. static int
  977. msp3400c_mixer_open(struct inode *inode, struct file *file)
  978. {
  979.         MOD_INC_USE_COUNT;
  980.         return 0;
  981. }
  983. static int
  984. msp3400c_mixer_release(struct inode *inode, struct file *file)
  985. {
  986.         MOD_DEC_USE_COUNT;
  987.         return 0;
  988. }
  990. static loff_t
  991. msp3400c_mixer_llseek(struct file *file, loff_t offset, int origin)
  992. {
  993.         return -ESPIPE;
  994. }
  996. static /*const*/ struct file_operations msp3400c_mixer_fops = {
  997.         &msp3400c_mixer_llseek,
  998.         NULL,  /* read */
  999.         NULL,  /* write */
  1000.         NULL,  /* readdir */
  1001.         NULL,  /* poll */
  1002.         &msp3400c_mixer_ioctl,
  1003.         NULL,  /* mmap */
  1004.         &msp3400c_mixer_open,
  1005. NULL,
  1006.         &msp3400c_mixer_release,
  1007.         NULL,  /* fsync */
  1008.         NULL,  /* fasync */
  1009.         NULL,  /* check_media_change */
  1010.         NULL,  /* revalidate */
  1011.         NULL,  /* lock */
  1012. };
  1014. #endif
  1016. /* ----------------------------------------------------------------------- */
  1018. static int msp3400c_attach(struct i2c_device *device)
  1019. {
  1020. struct semaphore sem = MUTEX_LOCKED;
  1021. struct msp3400c *msp;
  1022. int              rev1,rev2;
  1023. LOCK_FLAGS;
  1025. device->data = msp = kmalloc(sizeof(struct msp3400c),GFP_KERNEL);
  1026. if (NULL == msp)
  1027. return -ENOMEM;
  1028. memset(msp,0,sizeof(struct msp3400c));
  1029. msp->bus = device->bus;
  1030. msp->left   = 65535;
  1031. msp->right  = 65535;
  1032. msp->bass   = 32768;
  1033. msp->treble = 32768;
  1035. LOCK_I2C_BUS(msp->bus);
  1036. if (-1 == msp3400c_reset(msp->bus)) {
  1037. UNLOCK_I2C_BUS(msp->bus);
  1038. kfree(msp);
  1039. dprintk("msp3400: no chip foundn");
  1040. return -1;
  1041. }
  1042.     
  1043. rev1 = msp3400c_read(msp->bus, I2C_MSP3400C_DFP, 0x1e);
  1044. rev2 = msp3400c_read(msp->bus, I2C_MSP3400C_DFP, 0x1f);
  1045. if (0 == rev1 && 0 == rev2) {
  1046. UNLOCK_I2C_BUS(msp->bus);
  1047. kfree(msp);
  1048. printk("msp3400: error while reading chip versionn");
  1049. return -1;
  1050. }
  1052. msp3400c_setmode(msp, MSP_MODE_FM_TERRA);
  1053. msp3400c_setvolume(msp->bus, msp->left, msp->right);
  1054. msp3400c_setbass(msp->bus, msp->bass);
  1055. msp3400c_settreble(msp->bus, msp->treble);
  1056.     
  1057. #if 0
  1058. /* this will turn on a 1kHz beep - might be useful for debugging... */
  1059. msp3400c_write(msp->bus,I2C_MSP3400C_DFP, 0x0014, 0x1040);
  1060. #endif
  1061. UNLOCK_I2C_BUS(msp->bus);
  1063. sprintf(device->name,"MSP34%02d%c-%c%d",
  1064. (rev2>>8)&0xff, (rev1&0xff)+'@', ((rev1>>8)&0xff)+'@', rev2&0x1f);
  1065. msp->nicam = (((rev2>>8)&0xff) != 00) ? 1 : 0;
  1067. /* timer for stereo checking */
  1068. msp->wake_stereo.function = msp3400c_stereo_wake;
  1069. msp->wake_stereo.data     = (unsigned long)msp;
  1071. /* startup control thread */
  1072. MOD_INC_USE_COUNT;
  1073. msp->wq     = NULL;
  1074. msp->notify = &sem;
  1075. kernel_thread(msp3400c_thread, (void *)msp, 0);
  1076. down(&sem);
  1077. msp->notify = NULL;
  1078. wake_up_interruptible(&msp->wq);
  1080. printk(KERN_INFO "msp3400: init: chip=%s",device->name);
  1081. if (msp->nicam)
  1082. printk(", has NICAM support");
  1083. #ifdef REGISTER_MIXER
  1084. down(&mixer_sem);
  1085. mspmix = msp;
  1086. up(&mixer_sem);
  1087. #endif
  1088. printk("n");
  1089. return 0;
  1090. }
  1092. static int msp3400c_detach(struct i2c_device *device)
  1093. {
  1094. struct semaphore sem = MUTEX_LOCKED;
  1095. struct msp3400c *msp  = (struct msp3400c*)device->data;
  1096. LOCK_FLAGS;
  1097.     
  1098. #ifdef REGISTER_MIXER
  1099. down(&mixer_sem);
  1100. mspmix = NULL;
  1101. up(&mixer_sem);
  1102. #endif
  1104. /* shutdown control thread */
  1105. del_timer(&msp->wake_stereo);
  1106. if (msp->thread) 
  1107. {
  1108. msp->notify = &sem;
  1109. msp->rmmod = 1;
  1110. wake_up_interruptible(&msp->wq);
  1111. down(&sem);
  1112. msp->notify = NULL;
  1113. }
  1114.     
  1115. LOCK_I2C_BUS(msp->bus);
  1116. msp3400c_reset(msp->bus);
  1117. UNLOCK_I2C_BUS(msp->bus);
  1119. kfree(msp);
  1120. MOD_DEC_USE_COUNT;
  1121. return 0;
  1122. }
  1124. static int msp3400c_command(struct i2c_device *device,
  1125.  unsigned int cmd, void *arg)
  1126. {
  1127. struct msp3400c *msp  = (struct msp3400c*)device->data;
  1128. int             *iarg = (int*)arg;
  1129.         __u16           *sarg = arg;
  1130. LOCK_FLAGS;
  1132. switch (cmd) {
  1133. case MSP_SET_RADIO:
  1134. msp->norm = VIDEO_MODE_RADIO;
  1135. msp->watch_stereo=0;
  1136. del_timer(&msp->wake_stereo);
  1137. LOCK_I2C_BUS(msp->bus);
  1138. msp3400c_setmode(msp,MSP_MODE_FM_RADIO);
  1139. msp3400c_setcarrier(msp->bus, MSP_CARRIER(10.7),MSP_CARRIER(10.7));
  1140. msp3400c_setvolume(msp->bus,msp->left, msp->right);
  1141. UNLOCK_I2C_BUS(msp->bus);
  1142. break;
  1143. case MSP_SET_TVNORM:
  1144. msp->norm = *iarg;
  1145. break;
  1146. case MSP_SWITCH_MUTE:
  1147. /* channels switching step one -- mute */
  1148. msp->watch_stereo=0;
  1149. del_timer(&msp->wake_stereo);
  1150. LOCK_I2C_BUS(msp->bus);
  1151. msp3400c_setvolume(msp->bus,0,0);
  1152. UNLOCK_I2C_BUS(msp->bus);
  1153. break;
  1154. case MSP_NEWCHANNEL:
  1155. /* channels switching step two -- trigger sound carrier scan */
  1156. msp->watch_stereo=0;
  1157. del_timer(&msp->wake_stereo);
  1158. if (msp->active)
  1159. msp->restart = 1;
  1160. wake_up_interruptible(&msp->wq);
  1161. break;
  1163. case MSP_GET_VOLUME:
  1164. *sarg = (msp->left > msp->right) ? msp->left : msp->right;
  1165. break;
  1166. case MSP_SET_VOLUME:
  1167. msp->left = msp->right = *sarg;
  1168. LOCK_I2C_BUS(msp->bus);
  1169. msp3400c_setvolume(msp->bus,msp->left, msp->right);
  1170. UNLOCK_I2C_BUS(msp->bus);
  1171. break;
  1173. case MSP_GET_BASS:
  1174. *sarg = msp->bass;
  1175. break;
  1176. case MSP_SET_BASS:
  1177. msp->bass = *sarg;
  1178. LOCK_I2C_BUS(msp->bus);
  1179. msp3400c_setbass(msp->bus,msp->bass);
  1180. UNLOCK_I2C_BUS(msp->bus);
  1181. break;
  1183. case MSP_GET_TREBLE:
  1184. *sarg = msp->treble;
  1185. break;
  1186. case MSP_SET_TREBLE:
  1187. msp->treble = *sarg;
  1188. LOCK_I2C_BUS(msp->bus);
  1189. msp3400c_settreble(msp->bus,msp->treble);
  1190. UNLOCK_I2C_BUS(msp->bus);
  1191. break;
  1193. case MSP_GET_STEREO:
  1194. *sarg = msp->stereo;
  1195. break;
  1196. case MSP_SET_STEREO:
  1197. if (*sarg) {
  1198. msp->watch_stereo=0;
  1199. del_timer(&msp->wake_stereo);
  1200. LOCK_I2C_BUS(msp->bus);
  1201. msp3400c_setstereo(msp,*sarg);
  1202. UNLOCK_I2C_BUS(msp->bus);
  1203. }
  1204. break;
  1206. case MSP_GET_DC:
  1207. LOCK_I2C_BUS(msp->bus);
  1208. *sarg = ((int)msp3400c_read(msp->bus, I2C_MSP3400C_DFP, 0x1b) +
  1209.  (int)msp3400c_read(msp->bus, I2C_MSP3400C_DFP, 0x1c));
  1210. UNLOCK_I2C_BUS(msp->bus);
  1211. break;
  1213.         case MSP_GET_UNIT:
  1214. LOCK_I2C_BUS(msp->bus);
  1215.          *sarg = (int)msp3400c_read(msp->bus, I2C_MSP3400C_DFP, 0x1e);
  1216. UNLOCK_I2C_BUS(msp->bus);
  1217.                 break;
  1219. default:
  1220. return -EINVAL;
  1221. }
  1222. return 0;
  1223. }
  1225. /* ----------------------------------------------------------------------- */
  1227. struct i2c_driver i2c_driver_msp = {
  1228. "msp3400",                    /* name       */
  1229. I2C_DRIVERID_MSP3400,         /* ID         */
  1230. I2C_MSP3400C, I2C_MSP3400C,   /* addr range */
  1232. msp3400c_attach,
  1233. msp3400c_detach,
  1234. msp3400c_command
  1235. };
  1237. #ifdef MODULE
  1238. int init_module(void)
  1239. #else
  1240.      int msp3400c_init(void)
  1241. #endif
  1242. {
  1243. i2c_register_driver(&i2c_driver_msp);
  1244. #ifdef REGISTER_MIXER
  1245. if ((mixer_num = register_sound_mixer(&msp3400c_mixer_fops, -1)) < 0)
  1246. printk(KERN_ERR "msp3400c: cannot allocate mixer devicen");
  1247. #endif
  1248. return 0;
  1249. }
  1251. #ifdef MODULE
  1252. void cleanup_module(void)
  1253. {
  1254. i2c_unregister_driver(&i2c_driver_msp);
  1255. #ifdef REGISTER_MIXER
  1256. if (mixer_num >= 0)
  1257. unregister_sound_mixer(mixer_num);
  1258. #endif
  1259. }
  1260. #endif
  1262. /*
  1263.  * Overrides for Emacs so that we follow Linus's tabbing style.
  1264.  * ---------------------------------------------------------------------------
  1265.  * Local variables:
  1266.  * c-basic-offset: 8
  1267.  * End:
  1268.  */