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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
ac97_codec.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：33k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

ac97_codec.c：源码内容
  2. /*
  3.  * ac97_codec.c: Generic AC97 mixer/modem module
  4.  *
  5.  * Derived from ac97 mixer in maestro and trident driver.
  6.  *
  7.  * Copyright 2000 Silicon Integrated System Corporation
  8.  *
  9.  * This program is free software; you can redistribute it and/or modify
  10.  * it under the terms of the GNU General Public License as published by
  11.  * the Free Software Foundation; either version 2 of the License, or
  12.  * (at your option) any later version.
  13.  *
  14.  * This program is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  * GNU General Public License for more details.
  18.  *
  19.  * You should have received a copy of the GNU General Public License
  20.  * along with this program; if not, write to the Free Software
  21.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22.  *
  23.  **************************************************************************
  24.  *
  25.  * The Intel Audio Codec '97 specification is available at the Intel
  26.  * audio homepage: http://developer.intel.com/ial/scalableplatforms/audio/
  27.  *
  28.  * The specification itself is currently available at:
  29.  * ftp://download.intel.com/ial/scalableplatforms/ac97r22.pdf
  30.  *
  31.  **************************************************************************
  32.  *
  33.  * History
  34.  * v0.4 Mar 15 2000 Ollie Lho
  35.  * dual codecs support verified with 4 channels output
  36.  * v0.3 Feb 22 2000 Ollie Lho
  37.  * bug fix for record mask setting
  38.  * v0.2 Feb 10 2000 Ollie Lho
  39.  * add ac97_read_proc for /proc/driver/{vendor}/ac97
  40.  * v0.1 Jan 14 2000 Ollie Lho <ollie@sis.com.tw> 
  41.  * Isolated from trident.c to support multiple ac97 codec
  42.  */
  43. #include <linux/module.h>
  44. #include <linux/version.h>
  45. #include <linux/kernel.h>
  46. #include <linux/string.h>
  47. #include <linux/errno.h>
  48. #include <linux/bitops.h>
  49. #include <linux/delay.h>
  50. #include <linux/ac97_codec.h>
  51. #include <asm/uaccess.h>
  53. static int ac97_read_mixer(struct ac97_codec *codec, int oss_channel);
  54. static void ac97_write_mixer(struct ac97_codec *codec, int oss_channel, 
  55.      unsigned int left, unsigned int right);
  56. static void ac97_set_mixer(struct ac97_codec *codec, unsigned int oss_mixer, unsigned int val );
  57. static int ac97_recmask_io(struct ac97_codec *codec, int rw, int mask);
  58. static int ac97_mixer_ioctl(struct ac97_codec *codec, unsigned int cmd, unsigned long arg);
  60. static int ac97_init_mixer(struct ac97_codec *codec);
  62. static int wolfson_init(struct ac97_codec * codec);
  63. static int tritech_init(struct ac97_codec * codec);
  64. static int tritech_maestro_init(struct ac97_codec * codec);
  65. static int sigmatel_9708_init(struct ac97_codec *codec);
  66. static int sigmatel_9721_init(struct ac97_codec *codec);
  67. static int sigmatel_9744_init(struct ac97_codec *codec);
  68. static int eapd_control(struct ac97_codec *codec, int);
  69. static int crystal_digital_control(struct ac97_codec *codec, int mode);
  72. /*
  73.  * AC97 operations.
  74.  *
  75.  * If you are adding a codec then you should be able to use
  76.  * eapd_ops - any codec that supports EAPD amp control (most)
  77.  * null_ops - any ancient codec that supports nothing
  78.  *
  79.  * The three functions are
  80.  * init - used for non AC97 standard initialisation
  81.  * amplifier - used to do amplifier control (1=on 0=off)
  82.  * digital - switch to digital modes (0 = analog)
  83.  *
  84.  * Not all codecs support all features, not all drivers use all the
  85.  * operations yet
  86.  */
  87.  
  88. static struct ac97_ops null_ops = { NULL, NULL, NULL };
  89. static struct ac97_ops default_ops = { NULL, eapd_control, NULL };
  90. static struct ac97_ops wolfson_ops = { wolfson_init, NULL, NULL };
  91. static struct ac97_ops tritech_ops = { tritech_init, NULL, NULL };
  92. static struct ac97_ops tritech_m_ops = { tritech_maestro_init, NULL, NULL };
  93. static struct ac97_ops sigmatel_9708_ops = { sigmatel_9708_init, NULL, NULL };
  94. static struct ac97_ops sigmatel_9721_ops = { sigmatel_9721_init, NULL, NULL };
  95. static struct ac97_ops sigmatel_9744_ops = { sigmatel_9744_init, NULL, NULL };
  96. static struct ac97_ops crystal_digital_ops = { NULL, eapd_control, crystal_digital_control };
  98. /* sorted by vendor/device id */
  99. static const struct {
  100. u32 id;
  101. char *name;
  102. struct ac97_ops *ops;
  103. } ac97_codec_ids[] = {
  104. {0x41445303, "Analog Devices AD1819", &null_ops},
  105. {0x41445340, "Analog Devices AD1881", &null_ops},
  106. {0x41445348, "Analog Devices AD1881A", &null_ops},
  107. {0x41445360, "Analog Devices AD1885", &default_ops},
  108. {0x41445460, "Analog Devices AD1885", &default_ops},
  109. {0x414B4D00, "Asahi Kasei AK4540", &null_ops},
  110. {0x414B4D01, "Asahi Kasei AK4542", &null_ops},
  111. {0x414B4D02, "Asahi Kasei AK4543", &null_ops},
  112. {0x414C4710, "ALC200/200P", &null_ops},
  113. {0x43525900, "Cirrus Logic CS4297", &default_ops},
  114. {0x43525903, "Cirrus Logic CS4297", &default_ops},
  115. {0x43525913, "Cirrus Logic CS4297A rev A", &default_ops},
  116. {0x43525914, "Cirrus Logic CS4297A rev B", &default_ops},
  117. {0x43525923, "Cirrus Logic CS4298", &null_ops},
  118. {0x4352592B, "Cirrus Logic CS4294", &null_ops},
  119. {0x4352592D, "Cirrus Logic CS4294", &null_ops},
  120. {0x43525931, "Cirrus Logic CS4299 rev A", &crystal_digital_ops},
  121. {0x43525933, "Cirrus Logic CS4299 rev C", &crystal_digital_ops},
  122. {0x43525934, "Cirrus Logic CS4299 rev D", &crystal_digital_ops},
  123. {0x4352594d, "Cirrus Logic CS4201" , &null_ops},
  124. {0x45838308, "ESS Allegro ES1988", &null_ops},
  125. {0x49434511, "ICE1232", &null_ops}, /* I hope --jk */
  126. {0x4e534331, "National Semiconductor LM4549", &null_ops},
  127. {0x50534304, "Philips UCB1400", &default_ops},
  128. {0x53494c22, "Silicon Laboratory Si3036", &null_ops},
  129. {0x53494c23, "Silicon Laboratory Si3038", &null_ops},
  130. {0x545200FF, "TriTech TR?????", &tritech_m_ops},
  131. {0x54524102, "TriTech TR28022", &null_ops},
  132. {0x54524103, "TriTech TR28023", &null_ops},
  133. {0x54524106, "TriTech TR28026", &null_ops},
  134. {0x54524108, "TriTech TR28028", &tritech_ops},
  135. {0x54524123, "TriTech TR A5", &null_ops},
  136. {0x574D4C00, "Wolfson WM9704", &wolfson_ops},
  137. {0x574D4C03, "Wolfson WM9703/9704", &wolfson_ops},
  138. {0x574D4C04, "Wolfson WM9704 (quad)", &wolfson_ops},
  139. {0x83847600, "SigmaTel STAC????", &null_ops},
  140. {0x83847604, "SigmaTel STAC9701/3/4/5", &null_ops},
  141. {0x83847605, "SigmaTel STAC9704", &null_ops},
  142. {0x83847608, "SigmaTel STAC9708", &sigmatel_9708_ops},
  143. {0x83847609, "SigmaTel STAC9721/23", &sigmatel_9721_ops},
  144. {0x83847644, "SigmaTel STAC9744/45", &sigmatel_9744_ops},
  145. {0x83847656, "SigmaTel STAC9756/57", &sigmatel_9744_ops},
  146. {0x83847684, "SigmaTel STAC9783/84?", &null_ops},
  147. {0x57454301, "Winbond 83971D", &null_ops},
  148. };
  150. static const char *ac97_stereo_enhancements[] =
  151. {
  152. /*   0 */ "No 3D Stereo Enhancement",
  153. /*   1 */ "Analog Devices Phat Stereo",
  154. /*   2 */ "Creative Stereo Enhancement",
  155. /*   3 */ "National Semi 3D Stereo Enhancement",
  156. /*   4 */ "YAMAHA Ymersion",
  157. /*   5 */ "BBE 3D Stereo Enhancement",
  158. /*   6 */ "Crystal Semi 3D Stereo Enhancement",
  159. /*   7 */ "Qsound QXpander",
  160. /*   8 */ "Spatializer 3D Stereo Enhancement",
  161. /*   9 */ "SRS 3D Stereo Enhancement",
  162. /*  10 */ "Platform Tech 3D Stereo Enhancement",
  163. /*  11 */ "AKM 3D Audio",
  164. /*  12 */ "Aureal Stereo Enhancement",
  165. /*  13 */ "Aztech 3D Enhancement",
  166. /*  14 */ "Binaura 3D Audio Enhancement",
  167. /*  15 */ "ESS Technology Stereo Enhancement",
  168. /*  16 */ "Harman International VMAx",
  169. /*  17 */ "Nvidea 3D Stereo Enhancement",
  170. /*  18 */ "Philips Incredible Sound",
  171. /*  19 */ "Texas Instruments 3D Stereo Enhancement",
  172. /*  20 */ "VLSI Technology 3D Stereo Enhancement",
  173. /*  21 */ "TriTech 3D Stereo Enhancement",
  174. /*  22 */ "Realtek 3D Stereo Enhancement",
  175. /*  23 */ "Samsung 3D Stereo Enhancement",
  176. /*  24 */ "Wolfson Microelectronics 3D Enhancement",
  177. /*  25 */ "Delta Integration 3D Enhancement",
  178. /*  26 */ "SigmaTel 3D Enhancement",
  179. /*  27 */ "Winbond 3D Stereo Enhancement",
  180. /*  28 */ "Rockwell 3D Stereo Enhancement",
  181. /*  29 */ "Reserved 29",
  182. /*  30 */ "Reserved 30",
  183. /*  31 */ "Reserved 31"
  184. };
  186. /* this table has default mixer values for all OSS mixers. */
  187. static struct mixer_defaults {
  188. int mixer;
  189. unsigned int value;
  190. } mixer_defaults[SOUND_MIXER_NRDEVICES] = {
  191. /* all values 0 -> 100 in bytes */
  192. {SOUND_MIXER_VOLUME, 0x4343},
  193. {SOUND_MIXER_BASS, 0x4343},
  194. {SOUND_MIXER_TREBLE, 0x4343},
  195. {SOUND_MIXER_PCM, 0x4343},
  196. {SOUND_MIXER_SPEAKER, 0x4343},
  197. {SOUND_MIXER_LINE, 0x4343},
  198. {SOUND_MIXER_MIC, 0x0000},
  199. {SOUND_MIXER_CD, 0x4343},
  200. {SOUND_MIXER_ALTPCM, 0x4343},
  201. {SOUND_MIXER_IGAIN, 0x4343},
  202. {SOUND_MIXER_LINE1, 0x4343},
  203. {SOUND_MIXER_PHONEIN, 0x4343},
  204. {SOUND_MIXER_PHONEOUT, 0x4343},
  205. {SOUND_MIXER_VIDEO, 0x4343},
  206. {-1,0}
  207. };
  209. /* table to scale scale from OSS mixer value to AC97 mixer register value */
  210. static struct ac97_mixer_hw {
  211. unsigned char offset;
  212. int scale;
  213. } ac97_hw[SOUND_MIXER_NRDEVICES]= {
  214. [SOUND_MIXER_VOLUME] = {AC97_MASTER_VOL_STEREO,64},
  215. [SOUND_MIXER_BASS] = {AC97_MASTER_TONE, 16},
  216. [SOUND_MIXER_TREBLE] = {AC97_MASTER_TONE, 16},
  217. [SOUND_MIXER_PCM] = {AC97_PCMOUT_VOL, 32},
  218. [SOUND_MIXER_SPEAKER] = {AC97_PCBEEP_VOL, 16},
  219. [SOUND_MIXER_LINE] = {AC97_LINEIN_VOL, 32},
  220. [SOUND_MIXER_MIC] = {AC97_MIC_VOL, 32},
  221. [SOUND_MIXER_CD] = {AC97_CD_VOL, 32},
  222. [SOUND_MIXER_ALTPCM] = {AC97_HEADPHONE_VOL, 64},
  223. [SOUND_MIXER_IGAIN] = {AC97_RECORD_GAIN, 16},
  224. [SOUND_MIXER_LINE1] = {AC97_AUX_VOL, 32},
  225. [SOUND_MIXER_PHONEIN] =  {AC97_PHONE_VOL, 32},
  226. [SOUND_MIXER_PHONEOUT] =  {AC97_MASTER_VOL_MONO, 64},
  227. [SOUND_MIXER_VIDEO] = {AC97_VIDEO_VOL, 32},
  228. };
  230. /* the following tables allow us to go from OSS <-> ac97 quickly. */
  231. enum ac97_recsettings {
  232. AC97_REC_MIC=0,
  233. AC97_REC_CD,
  234. AC97_REC_VIDEO,
  235. AC97_REC_AUX,
  236. AC97_REC_LINE,
  237. AC97_REC_STEREO, /* combination of all enabled outputs..  */
  238. AC97_REC_MONO,       /*.. or the mono equivalent */
  239. AC97_REC_PHONE
  240. };
  242. static const unsigned int ac97_rm2oss[] = {
  243. [AC97_REC_MIC]   = SOUND_MIXER_MIC,
  244. [AC97_REC_CD]   = SOUND_MIXER_CD,
  245. [AC97_REC_VIDEO] = SOUND_MIXER_VIDEO,
  246. [AC97_REC_AUX]   = SOUND_MIXER_LINE1,
  247. [AC97_REC_LINE]  = SOUND_MIXER_LINE,
  248. [AC97_REC_STEREO]= SOUND_MIXER_IGAIN,
  249. [AC97_REC_PHONE] = SOUND_MIXER_PHONEIN
  250. };
  252. /* indexed by bit position */
  253. static const unsigned int ac97_oss_rm[] = {
  254. [SOUND_MIXER_MIC]  = AC97_REC_MIC,
  255. [SOUND_MIXER_CD]  = AC97_REC_CD,
  256. [SOUND_MIXER_VIDEO]  = AC97_REC_VIDEO,
  257. [SOUND_MIXER_LINE1]  = AC97_REC_AUX,
  258. [SOUND_MIXER_LINE]  = AC97_REC_LINE,
  259. [SOUND_MIXER_IGAIN] = AC97_REC_STEREO,
  260. [SOUND_MIXER_PHONEIN]  = AC97_REC_PHONE
  261. };
  263. /* reads the given OSS mixer from the ac97 the caller must have insured that the ac97 knows
  264.    about that given mixer, and should be holding a spinlock for the card */
  265. static int ac97_read_mixer(struct ac97_codec *codec, int oss_channel) 
  266. {
  267. u16 val;
  268. int ret = 0;
  269. int scale;
  270. struct ac97_mixer_hw *mh = &ac97_hw[oss_channel];
  272. val = codec->codec_read(codec , mh->offset);
  274. if (val & AC97_MUTE) {
  275. ret = 0;
  276. } else if (AC97_STEREO_MASK & (1 << oss_channel)) {
  277. /* nice stereo mixers .. */
  278. int left,right;
  280. left = (val >> 8)  & 0x7f;
  281. right = val  & 0x7f;
  283. if (oss_channel == SOUND_MIXER_IGAIN) {
  284. right = (right * 100) / mh->scale;
  285. left = (left * 100) / mh->scale;
  286. } else {
  287. /* these may have 5 or 6 bit resolution */
  288. if(oss_channel == SOUND_MIXER_VOLUME || oss_channel == SOUND_MIXER_ALTPCM)
  289. scale = (1 << codec->bit_resolution);
  290. else
  291. scale = mh->scale;
  293. right = 100 - ((right * 100) / scale);
  294. left = 100 - ((left * 100) / scale);
  295. }
  296. ret = left | (right << 8);
  297. } else if (oss_channel == SOUND_MIXER_SPEAKER) {
  298. ret = 100 - ((((val & 0x1e)>>1) * 100) / mh->scale);
  299. } else if (oss_channel == SOUND_MIXER_PHONEIN) {
  300. ret = 100 - (((val & 0x1f) * 100) / mh->scale);
  301. } else if (oss_channel == SOUND_MIXER_PHONEOUT) {
  302. scale = (1 << codec->bit_resolution);
  303. ret = 100 - (((val & 0x1f) * 100) / scale);
  304. } else if (oss_channel == SOUND_MIXER_MIC) {
  305. ret = 100 - (((val & 0x1f) * 100) / mh->scale);
  306. /*  the low bit is optional in the tone sliders and masking
  307.     it lets us avoid the 0xf 'bypass'.. */
  308. } else if (oss_channel == SOUND_MIXER_BASS) {
  309. ret = 100 - ((((val >> 8) & 0xe) * 100) / mh->scale);
  310. } else if (oss_channel == SOUND_MIXER_TREBLE) {
  311. ret = 100 - (((val & 0xe) * 100) / mh->scale);
  312. }
  314. #ifdef DEBUG
  315. printk("ac97_codec: read OSS mixer %2d (%s ac97 register 0x%02x), "
  316.        "0x%04x -> 0x%04xn",
  317.        oss_channel, codec->id ? "Secondary" : "Primary",
  318.        mh->offset, val, ret);
  319. #endif
  321. return ret;
  322. }
  324. /* write the OSS encoded volume to the given OSS encoded mixer, again caller's job to
  325.    make sure all is well in arg land, call with spinlock held */
  326. static void ac97_write_mixer(struct ac97_codec *codec, int oss_channel,
  327.       unsigned int left, unsigned int right)
  328. {
  329. u16 val = 0;
  330. int scale;
  331. struct ac97_mixer_hw *mh = &ac97_hw[oss_channel];
  333. #ifdef DEBUG
  334. printk("ac97_codec: wrote OSS mixer %2d (%s ac97 register 0x%02x), "
  335.        "left vol:%2d, right vol:%2d:",
  336.        oss_channel, codec->id ? "Secondary" : "Primary",
  337.        mh->offset, left, right);
  338. #endif
  340. if (AC97_STEREO_MASK & (1 << oss_channel)) {
  341. /* stereo mixers */
  342. if (left == 0 && right == 0) {
  343. val = AC97_MUTE;
  344. } else {
  345. if (oss_channel == SOUND_MIXER_IGAIN) {
  346. right = (right * mh->scale) / 100;
  347. left = (left * mh->scale) / 100;
  348. if (right >= mh->scale)
  349. right = mh->scale-1;
  350. if (left >= mh->scale)
  351. left = mh->scale-1;
  352. } else {
  353. /* these may have 5 or 6 bit resolution */
  354. if (oss_channel == SOUND_MIXER_VOLUME ||
  355.     oss_channel == SOUND_MIXER_ALTPCM)
  356. scale = (1 << codec->bit_resolution);
  357. else
  358. scale = mh->scale;
  360. right = ((100 - right) * scale) / 100;
  361. left = ((100 - left) * scale) / 100;
  362. if (right >= scale)
  363. right = scale-1;
  364. if (left >= scale)
  365. left = scale-1;
  366. }
  367. val = (left << 8) | right;
  368. }
  369. } else if (oss_channel == SOUND_MIXER_BASS) {
  370. val = codec->codec_read(codec , mh->offset) & ~0x0f00;
  371. left = ((100 - left) * mh->scale) / 100;
  372. if (left >= mh->scale)
  373. left = mh->scale-1;
  374. val |= (left << 8) & 0x0e00;
  375. } else if (oss_channel == SOUND_MIXER_TREBLE) {
  376. val = codec->codec_read(codec , mh->offset) & ~0x000f;
  377. left = ((100 - left) * mh->scale) / 100;
  378. if (left >= mh->scale)
  379. left = mh->scale-1;
  380. val |= left & 0x000e;
  381. } else if(left == 0) {
  382. val = AC97_MUTE;
  383. } else if (oss_channel == SOUND_MIXER_SPEAKER) {
  384. left = ((100 - left) * mh->scale) / 100;
  385. if (left >= mh->scale)
  386. left = mh->scale-1;
  387. val = left << 1;
  388. } else if (oss_channel == SOUND_MIXER_PHONEIN) {
  389. left = ((100 - left) * mh->scale) / 100;
  390. if (left >= mh->scale)
  391. left = mh->scale-1;
  392. val = left;
  393. } else if (oss_channel == SOUND_MIXER_PHONEOUT) {
  394. scale = (1 << codec->bit_resolution);
  395. left = ((100 - left) * scale) / 100;
  396. if (left >= mh->scale)
  397. left = mh->scale-1;
  398. val = left;
  399. } else if (oss_channel == SOUND_MIXER_MIC) {
  400. val = codec->codec_read(codec , mh->offset) & ~0x801f;
  401. left = ((100 - left) * mh->scale) / 100;
  402. if (left >= mh->scale)
  403. left = mh->scale-1;
  404. val |= left;
  405. /*  the low bit is optional in the tone sliders and masking
  406.     it lets us avoid the 0xf 'bypass'.. */
  407. }
  408. #ifdef DEBUG
  409. printk(" 0x%04x", val);
  410. #endif
  412. codec->codec_write(codec, mh->offset, val);
  414. #ifdef DEBUG
  415. val = codec->codec_read(codec, mh->offset);
  416. printk(" -> 0x%04xn", val);
  417. #endif
  418. }
  420. /* a thin wrapper for write_mixer */
  421. static void ac97_set_mixer(struct ac97_codec *codec, unsigned int oss_mixer, unsigned int val ) 
  422. {
  423. unsigned int left,right;
  425. /* cleanse input a little */
  426. right = ((val >> 8)  & 0xff) ;
  427. left = (val  & 0xff) ;
  429. if (right > 100) right = 100;
  430. if (left > 100) left = 100;
  432. codec->mixer_state[oss_mixer] = (right << 8) | left;
  433. codec->write_mixer(codec, oss_mixer, left, right);
  434. }
  436. /* read or write the recmask, the ac97 can really have left and right recording
  437.    inputs independantly set, but OSS doesn't seem to want us to express that to
  438.    the user. the caller guarantees that we have a supported bit set, and they
  439.    must be holding the card's spinlock */
  440. static int ac97_recmask_io(struct ac97_codec *codec, int rw, int mask) 
  441. {
  442. unsigned int val;
  444. if (rw) {
  445. /* read it from the card */
  446. val = codec->codec_read(codec, AC97_RECORD_SELECT);
  447. #ifdef DEBUG
  448. printk("ac97_codec: ac97 recmask to set to 0x%04xn", val);
  449. #endif
  450. return (1 << ac97_rm2oss[val & 0x07]);
  451. }
  453. /* else, write the first set in the mask as the
  454.    output */
  455. /* clear out current set value first (AC97 supports only 1 input!) */
  456. val = (1 << ac97_rm2oss[codec->codec_read(codec, AC97_RECORD_SELECT) & 0x07]);
  457. if (mask != val)
  458.     mask &= ~val;
  459.        
  460. val = ffs(mask); 
  461. val = ac97_oss_rm[val-1];
  462. val |= val << 8;  /* set both channels */
  464. #ifdef DEBUG
  465. printk("ac97_codec: setting ac97 recmask to 0x%04xn", val);
  466. #endif
  468. codec->codec_write(codec, AC97_RECORD_SELECT, val);
  470. return 0;
  471. };
  473. static int ac97_mixer_ioctl(struct ac97_codec *codec, unsigned int cmd, unsigned long arg)
  474. {
  475. int i, val = 0;
  477. if (cmd == SOUND_MIXER_INFO) {
  478. mixer_info info;
  479. strncpy(info.id, codec->name, sizeof(info.id));
  480. strncpy(info.name, codec->name, sizeof(info.name));
  481. info.modify_counter = codec->modcnt;
  482. if (copy_to_user((void *)arg, &info, sizeof(info)))
  483. return -EFAULT;
  484. return 0;
  485. }
  486. if (cmd == SOUND_OLD_MIXER_INFO) {
  487. _old_mixer_info info;
  488. strncpy(info.id, codec->name, sizeof(info.id));
  489. strncpy(info.name, codec->name, sizeof(info.name));
  490. if (copy_to_user((void *)arg, &info, sizeof(info)))
  491. return -EFAULT;
  492. return 0;
  493. }
  495. if (_IOC_TYPE(cmd) != 'M' || _SIOC_SIZE(cmd) != sizeof(int))
  496. return -EINVAL;
  498. if (cmd == OSS_GETVERSION)
  499. return put_user(SOUND_VERSION, (int *)arg);
  501. if (_SIOC_DIR(cmd) == _SIOC_READ) {
  502. switch (_IOC_NR(cmd)) {
  503. case SOUND_MIXER_RECSRC: /* give them the current record source */
  504. if (!codec->recmask_io) {
  505. val = 0;
  506. } else {
  507. val = codec->recmask_io(codec, 1, 0);
  508. }
  509. break;
  511. case SOUND_MIXER_DEVMASK: /* give them the supported mixers */
  512. val = codec->supported_mixers;
  513. break;
  515. case SOUND_MIXER_RECMASK: /* Arg contains a bit for each supported recording source */
  516. val = codec->record_sources;
  517. break;
  519. case SOUND_MIXER_STEREODEVS: /* Mixer channels supporting stereo */
  520. val = codec->stereo_mixers;
  521. break;
  523. case SOUND_MIXER_CAPS:
  524. val = SOUND_CAP_EXCL_INPUT;
  525. break;
  527. default: /* read a specific mixer */
  528. i = _IOC_NR(cmd);
  530. if (!supported_mixer(codec, i)) 
  531. return -EINVAL;
  533. /* do we ever want to touch the hardware? */
  534.         /* val = codec->read_mixer(codec, i); */
  535. val = codec->mixer_state[i];
  536.   break;
  537. }
  538. return put_user(val, (int *)arg);
  539. }
  541. if (_SIOC_DIR(cmd) == (_SIOC_WRITE|_SIOC_READ)) {
  542. codec->modcnt++;
  543. if (get_user(val, (int *)arg))
  544. return -EFAULT;
  546. switch (_IOC_NR(cmd)) {
  547. case SOUND_MIXER_RECSRC: /* Arg contains a bit for each recording source */
  548. if (!codec->recmask_io) return -EINVAL;
  549. if (!val) return 0;
  550. if (!(val &= codec->record_sources)) return -EINVAL;
  552. codec->recmask_io(codec, 0, val);
  554. return 0;
  555. default: /* write a specific mixer */
  556. i = _IOC_NR(cmd);
  558. if (!supported_mixer(codec, i)) 
  559. return -EINVAL;
  561. ac97_set_mixer(codec, i, val);
  563. return 0;
  564. }
  565. }
  566. return -EINVAL;
  567. }
  569. /* entry point for /proc/driver/controller_vendor/ac97/%d */
  570. int ac97_read_proc (char *page, char **start, off_t off,
  571.     int count, int *eof, void *data)
  572. {
  573. int len = 0, cap, extid, val, id1, id2;
  574. struct ac97_codec *codec;
  575. int is_ac97_20 = 0;
  577. if ((codec = data) == NULL)
  578. return -ENODEV;
  580. id1 = codec->codec_read(codec, AC97_VENDOR_ID1);
  581. id2 = codec->codec_read(codec, AC97_VENDOR_ID2);
  582. len += sprintf (page+len, "Vendor name      : %sn", codec->name);
  583. len += sprintf (page+len, "Vendor id        : %04X %04Xn", id1, id2);
  585. extid = codec->codec_read(codec, AC97_EXTENDED_ID);
  586. extid &= ~((1<<2)|(1<<4)|(1<<5)|(1<<10)|(1<<11)|(1<<12)|(1<<13));
  587. len += sprintf (page+len, "AC97 Version     : %sn",
  588. extid ? "2.0 or later" : "1.0");
  589. if (extid) is_ac97_20 = 1;
  591. cap = codec->codec_read(codec, AC97_RESET);
  592. len += sprintf (page+len, "Capabilities     :%s%s%s%s%s%sn",
  593. cap & 0x0001 ? " -dedicated MIC PCM IN channel-" : "",
  594. cap & 0x0002 ? " -reserved1-" : "",
  595. cap & 0x0004 ? " -bass & treble-" : "",
  596. cap & 0x0008 ? " -simulated stereo-" : "",
  597. cap & 0x0010 ? " -headphone out-" : "",
  598. cap & 0x0020 ? " -loudness-" : "");
  599. val = cap & 0x00c0;
  600. len += sprintf (page+len, "DAC resolutions  :%s%s%sn",
  601. " -16-bit-",
  602. val & 0x0040 ? " -18-bit-" : "",
  603. val & 0x0080 ? " -20-bit-" : "");
  604. val = cap & 0x0300;
  605. len += sprintf (page+len, "ADC resolutions  :%s%s%sn",
  606. " -16-bit-",
  607. val & 0x0100 ? " -18-bit-" : "",
  608. val & 0x0200 ? " -20-bit-" : "");
  609. len += sprintf (page+len, "3D enhancement   : %sn",
  610. ac97_stereo_enhancements[(cap >> 10) & 0x1f]);
  612. val = codec->codec_read(codec, AC97_GENERAL_PURPOSE);
  613. len += sprintf (page+len, "POP path         : %s 3Dn"
  614. "Sim. stereo      : %sn"
  615. "3D enhancement   : %sn"
  616. "Loudness         : %sn"
  617. "Mono output      : %sn"
  618. "MIC select       : %sn"
  619. "ADC/DAC loopback : %sn",
  620. val & 0x8000 ? "post" : "pre",
  621. val & 0x4000 ? "on" : "off",
  622. val & 0x2000 ? "on" : "off",
  623. val & 0x1000 ? "on" : "off",
  624. val & 0x0200 ? "MIC" : "MIX",
  625. val & 0x0100 ? "MIC2" : "MIC1",
  626. val & 0x0080 ? "on" : "off");
  628. extid = codec->codec_read(codec, AC97_EXTENDED_ID);
  629. cap = extid;
  630. len += sprintf (page+len, "Ext Capabilities :%s%s%s%s%s%s%sn",
  631. cap & 0x0001 ? " -var rate PCM audio-" : "",
  632. cap & 0x0002 ? " -2x PCM audio out-" : "",
  633. cap & 0x0008 ? " -var rate MIC in-" : "",
  634. cap & 0x0040 ? " -PCM center DAC-" : "",
  635. cap & 0x0080 ? " -PCM surround DAC-" : "",
  636. cap & 0x0100 ? " -PCM LFE DAC-" : "",
  637. cap & 0x0200 ? " -slot/DAC mappings-" : "");
  638. if (is_ac97_20) {
  639. len += sprintf (page+len, "Front DAC rate   : %dn",
  640. codec->codec_read(codec, AC97_PCM_FRONT_DAC_RATE));
  641. }
  643. return len;
  644. }
  646. /**
  647.  * ac97_probe_codec - Initialize and setup AC97-compatible codec
  648.  * @codec: (in/out) Kernel info for a single AC97 codec
  649.  *
  650.  * Reset the AC97 codec, then initialize the mixer and
  651.  * the rest of the @codec structure.
  652.  *
  653.  * The codec_read and codec_write fields of @codec are
  654.  * required to be setup and working when this function
  655.  * is called.  All other fields are set by this function.
  656.  *
  657.  * codec_wait field of @codec can optionally be provided
  658.  * when calling this function.  If codec_wait is not %NULL,
  659.  * this function will call codec_wait any time it is
  660.  * necessary to wait for the audio chip to reach the
  661.  * codec-ready state.  If codec_wait is %NULL, then
  662.  * the default behavior is to call schedule_timeout.
  663.  * Currently codec_wait is used to wait for AC97 codec
  664.  * reset to complete. 
  665.  *
  666.  * Returns 1 (true) on success, or 0 (false) on failure.
  667.  */
  668.  
  669. int ac97_probe_codec(struct ac97_codec *codec)
  670. {
  671. u16 id1, id2;
  672. u16 audio, modem;
  673. int i;
  675. /* probing AC97 codec, AC97 2.0 says that bit 15 of register 0x00 (reset) should 
  676.  * be read zero.
  677.  *
  678.  * FIXME: is the following comment outdated?  -jgarzik 
  679.  * Probing of AC97 in this way is not reliable, it is not even SAFE !!
  680.  */
  681. codec->codec_write(codec, AC97_RESET, 0L);
  683. /* also according to spec, we wait for codec-ready state */
  684. if (codec->codec_wait)
  685. codec->codec_wait(codec);
  686. else
  687. udelay(10);
  689. if ((audio = codec->codec_read(codec, AC97_RESET)) & 0x8000) {
  690. printk(KERN_ERR "ac97_codec: %s ac97 codec not presentn",
  691.        codec->id ? "Secondary" : "Primary");
  692. return 0;
  693. }
  695. /* probe for Modem Codec */
  696. codec->codec_write(codec, AC97_EXTENDED_MODEM_ID, 0L);
  697. modem = codec->codec_read(codec, AC97_EXTENDED_MODEM_ID);
  699. codec->name = NULL;
  700. codec->codec_ops = &null_ops;
  702. id1 = codec->codec_read(codec, AC97_VENDOR_ID1);
  703. id2 = codec->codec_read(codec, AC97_VENDOR_ID2);
  704. for (i = 0; i < ARRAY_SIZE(ac97_codec_ids); i++) {
  705. if (ac97_codec_ids[i].id == ((id1 << 16) | id2)) {
  706. codec->type = ac97_codec_ids[i].id;
  707. codec->name = ac97_codec_ids[i].name;
  708. codec->codec_ops = ac97_codec_ids[i].ops;
  709. break;
  710. }
  711. }
  712. if (codec->name == NULL)
  713. codec->name = "Unknown";
  714. printk(KERN_INFO "ac97_codec: AC97 %s codec, id: 0x%04x:"
  715.        "0x%04x (%s)n", audio ? "Audio" : (modem ? "Modem" : ""),
  716.        id1, id2, codec->name);
  718. return ac97_init_mixer(codec);
  719. }
  721. static int ac97_init_mixer(struct ac97_codec *codec)
  722. {
  723. u16 cap;
  724. int i;
  726. cap = codec->codec_read(codec, AC97_RESET);
  728. /* mixer masks */
  729. codec->supported_mixers = AC97_SUPPORTED_MASK;
  730. codec->stereo_mixers = AC97_STEREO_MASK;
  731. codec->record_sources = AC97_RECORD_MASK;
  732. if (!(cap & 0x04))
  733. codec->supported_mixers &= ~(SOUND_MASK_BASS|SOUND_MASK_TREBLE);
  734. if (!(cap & 0x10))
  735. codec->supported_mixers &= ~SOUND_MASK_ALTPCM;
  737. /* detect bit resolution */
  738. codec->codec_write(codec, AC97_MASTER_VOL_STEREO, 0x2020);
  739. if(codec->codec_read(codec, AC97_MASTER_VOL_STEREO) == 0x1f1f)
  740. codec->bit_resolution = 5;
  741. else
  742. codec->bit_resolution = 6;
  744. /* generic OSS to AC97 wrapper */
  745. codec->read_mixer = ac97_read_mixer;
  746. codec->write_mixer = ac97_write_mixer;
  747. codec->recmask_io = ac97_recmask_io;
  748. codec->mixer_ioctl = ac97_mixer_ioctl;
  750. /* codec specific initialization for 4-6 channel output or secondary codec stuff */
  751. if (codec->codec_ops->init != NULL) {
  752. codec->codec_ops->init(codec);
  753. }
  755. /* initialize mixer channel volumes */
  756. for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
  757. struct mixer_defaults *md = &mixer_defaults[i];
  758. if (md->mixer == -1) 
  759. break;
  760. if (!supported_mixer(codec, md->mixer)) 
  761. continue;
  762. ac97_set_mixer(codec, md->mixer, md->value);
  763. }
  765. return 1;
  766. }
  768. #define AC97_SIGMATEL_ANALOG    0x6c /* Analog Special */
  769. #define AC97_SIGMATEL_DAC2INVERT 0x6e
  770. #define AC97_SIGMATEL_BIAS1     0x70
  771. #define AC97_SIGMATEL_BIAS2     0x72
  772. #define AC97_SIGMATEL_MULTICHN  0x74 /* Multi-Channel programming */
  773. #define AC97_SIGMATEL_CIC1      0x76
  774. #define AC97_SIGMATEL_CIC2      0x78
  777. static int sigmatel_9708_init(struct ac97_codec * codec)
  778. {
  779. u16 codec72, codec6c;
  781. codec72 = codec->codec_read(codec, AC97_SIGMATEL_BIAS2) & 0x8000;
  782. codec6c = codec->codec_read(codec, AC97_SIGMATEL_ANALOG);
  784. if ((codec72==0) && (codec6c==0)) {
  785. codec->codec_write(codec, AC97_SIGMATEL_CIC1, 0xabba);
  786. codec->codec_write(codec, AC97_SIGMATEL_CIC2, 0x1000);
  787. codec->codec_write(codec, AC97_SIGMATEL_BIAS1, 0xabba);
  788. codec->codec_write(codec, AC97_SIGMATEL_BIAS2, 0x0007);
  789. } else if ((codec72==0x8000) && (codec6c==0)) {
  790. codec->codec_write(codec, AC97_SIGMATEL_CIC1, 0xabba);
  791. codec->codec_write(codec, AC97_SIGMATEL_CIC2, 0x1001);
  792. codec->codec_write(codec, AC97_SIGMATEL_DAC2INVERT, 0x0008);
  793. } else if ((codec72==0x8000) && (codec6c==0x0080)) {
  794. /* nothing */
  795. }
  796. codec->codec_write(codec, AC97_SIGMATEL_MULTICHN, 0x0000);
  797. return 0;
  798. }
  801. static int sigmatel_9721_init(struct ac97_codec * codec)
  802. {
  803. /* Only set up secondary codec */
  804. if (codec->id == 0)
  805. return 0;
  807. codec->codec_write(codec, AC97_SURROUND_MASTER, 0L);
  809. /* initialize SigmaTel STAC9721/23 as secondary codec, decoding AC link
  810.    sloc 3,4 = 0x01, slot 7,8 = 0x00, */
  811. codec->codec_write(codec, AC97_SIGMATEL_MULTICHN, 0x00);
  813. /* we don't have the crystal when we are on an AMR card, so use
  814.    BIT_CLK as our clock source. Write the magic word ABBA and read
  815.    back to enable register 0x78 */
  816. codec->codec_write(codec, AC97_SIGMATEL_CIC1, 0xabba);
  817. codec->codec_read(codec, AC97_SIGMATEL_CIC1);
  819. /* sync all the clocks*/
  820. codec->codec_write(codec, AC97_SIGMATEL_CIC2, 0x3802);
  822. return 0;
  823. }
  826. static int sigmatel_9744_init(struct ac97_codec * codec)
  827. {
  828. // patch for SigmaTel
  829. codec->codec_write(codec, AC97_SIGMATEL_CIC1, 0xabba);
  830. codec->codec_write(codec, AC97_SIGMATEL_CIC2, 0x0000); // is this correct? --jk
  831. codec->codec_write(codec, AC97_SIGMATEL_BIAS1, 0xabba);
  832. codec->codec_write(codec, AC97_SIGMATEL_BIAS2, 0x0002);
  833. codec->codec_write(codec, AC97_SIGMATEL_MULTICHN, 0x0000);
  834. return 0;
  835. }
  838. static int wolfson_init(struct ac97_codec * codec)
  839. {
  840. codec->codec_write(codec, 0x72, 0x0808);
  841. codec->codec_write(codec, 0x74, 0x0808);
  843. // patch for DVD noise
  844. codec->codec_write(codec, 0x5a, 0x0200);
  846. // init vol as PCM vol
  847. codec->codec_write(codec, 0x70,
  848. codec->codec_read(codec, AC97_PCMOUT_VOL));
  850. codec->codec_write(codec, AC97_SURROUND_MASTER, 0x0000);
  851. return 0;
  852. }
  855. static int tritech_init(struct ac97_codec * codec)
  856. {
  857. codec->codec_write(codec, 0x26, 0x0300);
  858. codec->codec_write(codec, 0x26, 0x0000);
  859. codec->codec_write(codec, AC97_SURROUND_MASTER, 0x0000);
  860. codec->codec_write(codec, AC97_RESERVED_3A, 0x0000);
  861. return 0;
  862. }
  865. /* copied from drivers/sound/maestro.c */
  866. static int tritech_maestro_init(struct ac97_codec * codec)
  867. {
  868. /* no idea what this does */
  869. codec->codec_write(codec, 0x2A, 0x0001);
  870. codec->codec_write(codec, 0x2C, 0x0000);
  871. codec->codec_write(codec, 0x2C, 0XFFFF);
  872. return 0;
  873. }
  876. /*
  877.  * This is basically standard AC97. It should work as a default for
  878.  * almost all modern codecs. Note that some cards wire EAPD *backwards*
  879.  * That side of it is up to the card driver not us to cope with.
  880.  *
  881.  */
  883. static int eapd_control(struct ac97_codec * codec, int on)
  884. {
  885. if(on)
  886. codec->codec_write(codec, AC97_POWER_CONTROL,
  887. codec->codec_read(codec, AC97_POWER_CONTROL)|0x8000);
  888. else
  889. codec->codec_write(codec, AC97_POWER_CONTROL,
  890. codec->codec_read(codec, AC97_POWER_CONTROL)&~0x8000);
  891. return 0;
  892. }
  894. /*
  895.  * Crystal digital audio control (CS4299
  896.  */
  897.  
  898. static int crystal_digital_control(struct ac97_codec *codec, int mode)
  899. {
  900. u16 cv;
  902. switch(mode)
  903. {
  904. case 0: cv = 0x0; break; /* SPEN off */
  905. case 1: cv = 0x8004; break; /* 48KHz digital */
  906. case 2: cv = 0x8104; break; /* 44.1KHz digital */
  907. default:
  908. return -1; /* Not supported yet(eg AC3) */
  909. }
  910. codec->codec_write(codec, 0x68, cv);
  911. return 0;
  912. }
  914. /* copied from drivers/sound/maestro.c */
  915. #if 0  /* there has been 1 person on the planet with a pt101 that we
  916.         know of.  If they care, they can put this back in :) */
  917. static int pt101_init(struct ac97_codec * codec)
  918. {
  919. printk(KERN_INFO "ac97_codec: PT101 Codec detected, initializing but _not_ installing mixer device.n");
  920. /* who knows.. */
  921. codec->codec_write(codec, 0x2A, 0x0001);
  922. codec->codec_write(codec, 0x2C, 0x0000);
  923. codec->codec_write(codec, 0x2C, 0xFFFF);
  924. codec->codec_write(codec, 0x10, 0x9F1F);
  925. codec->codec_write(codec, 0x12, 0x0808);
  926. codec->codec_write(codec, 0x14, 0x9F1F);
  927. codec->codec_write(codec, 0x16, 0x9F1F);
  928. codec->codec_write(codec, 0x18, 0x0404);
  929. codec->codec_write(codec, 0x1A, 0x0000);
  930. codec->codec_write(codec, 0x1C, 0x0000);
  931. codec->codec_write(codec, 0x02, 0x0404);
  932. codec->codec_write(codec, 0x04, 0x0808);
  933. codec->codec_write(codec, 0x0C, 0x801F);
  934. codec->codec_write(codec, 0x0E, 0x801F);
  935. return 0;
  936. }
  937. #endif
  940. EXPORT_SYMBOL(ac97_read_proc);
  941. EXPORT_SYMBOL(ac97_probe_codec);
  943. /*
  944.  * AC97 library support routines
  945.  */
  946.  
  947. /**
  948.  * ac97_set_dac_rate - set codec rate adaption
  949.  * @codec: ac97 code
  950.  * @rate: rate in hertz
  951.  *
  952.  * Set the DAC rate. Assumes the codec supports VRA. The caller is
  953.  * expected to have checked this little detail.
  954.  */
  955.  
  956. unsigned int ac97_set_dac_rate(struct ac97_codec *codec, unsigned int rate)
  957. {
  958. unsigned int new_rate = rate;
  959. u32 dacp;
  960. u32 mast_vol, phone_vol, mono_vol, pcm_vol;
  961. u32 mute_vol = 0x8000; /* The mute volume? */
  963. if(rate != codec->codec_read(codec, AC97_PCM_FRONT_DAC_RATE))
  964. {
  965. /* Mute several registers */
  966. mast_vol = codec->codec_read(codec, AC97_MASTER_VOL_STEREO);
  967. mono_vol = codec->codec_read(codec, AC97_MASTER_VOL_MONO);
  968. phone_vol = codec->codec_read(codec, AC97_HEADPHONE_VOL);
  969. pcm_vol = codec->codec_read(codec, AC97_PCMOUT_VOL);
  970. codec->codec_write(codec, AC97_MASTER_VOL_STEREO, mute_vol);
  971. codec->codec_write(codec, AC97_MASTER_VOL_MONO, mute_vol);
  972. codec->codec_write(codec, AC97_HEADPHONE_VOL, mute_vol);
  973. codec->codec_write(codec, AC97_PCMOUT_VOL, mute_vol);
  975. /* Power down the DAC */
  976. dacp=codec->codec_read(codec, AC97_POWER_CONTROL);
  977. codec->codec_write(codec, AC97_POWER_CONTROL, dacp|0x0200);
  978. /* Load the rate and read the effective rate */
  979. codec->codec_write(codec, AC97_PCM_FRONT_DAC_RATE, rate);
  980. new_rate=codec->codec_read(codec, AC97_PCM_FRONT_DAC_RATE);
  981. /* Power it back up */
  982. codec->codec_write(codec, AC97_POWER_CONTROL, dacp);
  984. /* Restore volumes */
  985. codec->codec_write(codec, AC97_MASTER_VOL_STEREO, mast_vol);
  986. codec->codec_write(codec, AC97_MASTER_VOL_MONO, mono_vol);
  987. codec->codec_write(codec, AC97_HEADPHONE_VOL, phone_vol);
  988. codec->codec_write(codec, AC97_PCMOUT_VOL, pcm_vol);
  989. }
  990. return new_rate;
  991. }
  993. EXPORT_SYMBOL(ac97_set_dac_rate);
  995. /**
  996.  * ac97_set_adc_rate - set codec rate adaption
  997.  * @codec: ac97 code
  998.  * @rate: rate in hertz
  999.  *
  1000.  * Set the ADC rate. Assumes the codec supports VRA. The caller is
  1001.  * expected to have checked this little detail.
  1002.  */
  1004. unsigned int ac97_set_adc_rate(struct ac97_codec *codec, unsigned int rate)
  1005. {
  1006. unsigned int new_rate = rate;
  1007. u32 dacp;
  1009. if(rate != codec->codec_read(codec, AC97_PCM_LR_ADC_RATE))
  1010. {
  1011. /* Power down the ADC */
  1012. dacp=codec->codec_read(codec, AC97_POWER_CONTROL);
  1013. codec->codec_write(codec, AC97_POWER_CONTROL, dacp|0x0100);
  1014. /* Load the rate and read the effective rate */
  1015. codec->codec_write(codec, AC97_PCM_LR_ADC_RATE, rate);
  1016. new_rate=codec->codec_read(codec, AC97_PCM_LR_ADC_RATE);
  1017. /* Power it back up */
  1018. codec->codec_write(codec, AC97_POWER_CONTROL, dacp);
  1019. }
  1020. return new_rate;
  1021. }
  1023. EXPORT_SYMBOL(ac97_set_adc_rate);
  1025. int ac97_save_state(struct ac97_codec *codec)
  1026. {
  1027. return 0;
  1028. }
  1030. EXPORT_SYMBOL(ac97_save_state);
  1032. int ac97_restore_state(struct ac97_codec *codec)
  1033. {
  1034. int i;
  1035. unsigned int left, right, val;
  1037. for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
  1038. if (!supported_mixer(codec, i)) 
  1039. continue;
  1041. val = codec->mixer_state[i];
  1042. right = val >> 8;
  1043. left = val  & 0xff;
  1044. codec->write_mixer(codec, i, left, right);
  1045. }
  1046. return 0;
  1047. }
  1049. EXPORT_SYMBOL(ac97_restore_state);
  1051. MODULE_LICENSE("GPL");