via82xx_modem.c 35 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249
  1. /*
  2. * ALSA modem driver for VIA VT82xx (South Bridge)
  3. *
  4. * VT82C686A/B/C, VT8233A/C, VT8235
  5. *
  6. * Copyright (c) 2000 Jaroslav Kysela <perex@perex.cz>
  7. * Tjeerd.Mulder <Tjeerd.Mulder@fujitsu-siemens.com>
  8. * 2002 Takashi Iwai <tiwai@suse.de>
  9. *
  10. * This program is free software; you can redistribute it and/or modify
  11. * it under the terms of the GNU General Public License as published by
  12. * the Free Software Foundation; either version 2 of the License, or
  13. * (at your option) any later version.
  14. *
  15. * This program is distributed in the hope that it will be useful,
  16. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18. * GNU General Public License for more details.
  19. *
  20. * You should have received a copy of the GNU General Public License
  21. * along with this program; if not, write to the Free Software
  22. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  23. *
  24. */
  25. /*
  26. * Changes:
  27. *
  28. * Sep. 2, 2004 Sasha Khapyorsky <sashak@alsa-project.org>
  29. * Modified from original audio driver 'via82xx.c' to support AC97
  30. * modems.
  31. */
  32. #include <asm/io.h>
  33. #include <linux/delay.h>
  34. #include <linux/interrupt.h>
  35. #include <linux/init.h>
  36. #include <linux/pci.h>
  37. #include <linux/slab.h>
  38. #include <linux/moduleparam.h>
  39. #include <sound/core.h>
  40. #include <sound/pcm.h>
  41. #include <sound/pcm_params.h>
  42. #include <sound/info.h>
  43. #include <sound/ac97_codec.h>
  44. #include <sound/initval.h>
  45. #if 0
  46. #define POINTER_DEBUG
  47. #endif
  48. MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
  49. MODULE_DESCRIPTION("VIA VT82xx modem");
  50. MODULE_LICENSE("GPL");
  51. MODULE_SUPPORTED_DEVICE("{{VIA,VT82C686A/B/C modem,pci}}");
  52. static int index = -2; /* Exclude the first card */
  53. static char *id = SNDRV_DEFAULT_STR1; /* ID for this card */
  54. static int ac97_clock = 48000;
  55. module_param(index, int, 0444);
  56. MODULE_PARM_DESC(index, "Index value for VIA 82xx bridge.");
  57. module_param(id, charp, 0444);
  58. MODULE_PARM_DESC(id, "ID string for VIA 82xx bridge.");
  59. module_param(ac97_clock, int, 0444);
  60. MODULE_PARM_DESC(ac97_clock, "AC'97 codec clock (default 48000Hz).");
  61. /* just for backward compatibility */
  62. static int enable;
  63. module_param(enable, bool, 0444);
  64. /*
  65. * Direct registers
  66. */
  67. #define VIAREG(via, x) ((via)->port + VIA_REG_##x)
  68. #define VIADEV_REG(viadev, x) ((viadev)->port + VIA_REG_##x)
  69. /* common offsets */
  70. #define VIA_REG_OFFSET_STATUS 0x00 /* byte - channel status */
  71. #define VIA_REG_STAT_ACTIVE 0x80 /* RO */
  72. #define VIA_REG_STAT_PAUSED 0x40 /* RO */
  73. #define VIA_REG_STAT_TRIGGER_QUEUED 0x08 /* RO */
  74. #define VIA_REG_STAT_STOPPED 0x04 /* RWC */
  75. #define VIA_REG_STAT_EOL 0x02 /* RWC */
  76. #define VIA_REG_STAT_FLAG 0x01 /* RWC */
  77. #define VIA_REG_OFFSET_CONTROL 0x01 /* byte - channel control */
  78. #define VIA_REG_CTRL_START 0x80 /* WO */
  79. #define VIA_REG_CTRL_TERMINATE 0x40 /* WO */
  80. #define VIA_REG_CTRL_AUTOSTART 0x20
  81. #define VIA_REG_CTRL_PAUSE 0x08 /* RW */
  82. #define VIA_REG_CTRL_INT_STOP 0x04
  83. #define VIA_REG_CTRL_INT_EOL 0x02
  84. #define VIA_REG_CTRL_INT_FLAG 0x01
  85. #define VIA_REG_CTRL_RESET 0x01 /* RW - probably reset? undocumented */
  86. #define VIA_REG_CTRL_INT (VIA_REG_CTRL_INT_FLAG | VIA_REG_CTRL_INT_EOL | VIA_REG_CTRL_AUTOSTART)
  87. #define VIA_REG_OFFSET_TYPE 0x02 /* byte - channel type (686 only) */
  88. #define VIA_REG_TYPE_AUTOSTART 0x80 /* RW - autostart at EOL */
  89. #define VIA_REG_TYPE_16BIT 0x20 /* RW */
  90. #define VIA_REG_TYPE_STEREO 0x10 /* RW */
  91. #define VIA_REG_TYPE_INT_LLINE 0x00
  92. #define VIA_REG_TYPE_INT_LSAMPLE 0x04
  93. #define VIA_REG_TYPE_INT_LESSONE 0x08
  94. #define VIA_REG_TYPE_INT_MASK 0x0c
  95. #define VIA_REG_TYPE_INT_EOL 0x02
  96. #define VIA_REG_TYPE_INT_FLAG 0x01
  97. #define VIA_REG_OFFSET_TABLE_PTR 0x04 /* dword - channel table pointer */
  98. #define VIA_REG_OFFSET_CURR_PTR 0x04 /* dword - channel current pointer */
  99. #define VIA_REG_OFFSET_STOP_IDX 0x08 /* dword - stop index, channel type, sample rate */
  100. #define VIA_REG_OFFSET_CURR_COUNT 0x0c /* dword - channel current count (24 bit) */
  101. #define VIA_REG_OFFSET_CURR_INDEX 0x0f /* byte - channel current index (for via8233 only) */
  102. #define DEFINE_VIA_REGSET(name,val) \
  103. enum {\
  104. VIA_REG_##name##_STATUS = (val),\
  105. VIA_REG_##name##_CONTROL = (val) + 0x01,\
  106. VIA_REG_##name##_TYPE = (val) + 0x02,\
  107. VIA_REG_##name##_TABLE_PTR = (val) + 0x04,\
  108. VIA_REG_##name##_CURR_PTR = (val) + 0x04,\
  109. VIA_REG_##name##_STOP_IDX = (val) + 0x08,\
  110. VIA_REG_##name##_CURR_COUNT = (val) + 0x0c,\
  111. }
  112. /* modem block */
  113. DEFINE_VIA_REGSET(MO, 0x40);
  114. DEFINE_VIA_REGSET(MI, 0x50);
  115. /* AC'97 */
  116. #define VIA_REG_AC97 0x80 /* dword */
  117. #define VIA_REG_AC97_CODEC_ID_MASK (3<<30)
  118. #define VIA_REG_AC97_CODEC_ID_SHIFT 30
  119. #define VIA_REG_AC97_CODEC_ID_PRIMARY 0x00
  120. #define VIA_REG_AC97_CODEC_ID_SECONDARY 0x01
  121. #define VIA_REG_AC97_SECONDARY_VALID (1<<27)
  122. #define VIA_REG_AC97_PRIMARY_VALID (1<<25)
  123. #define VIA_REG_AC97_BUSY (1<<24)
  124. #define VIA_REG_AC97_READ (1<<23)
  125. #define VIA_REG_AC97_CMD_SHIFT 16
  126. #define VIA_REG_AC97_CMD_MASK 0x7e
  127. #define VIA_REG_AC97_DATA_SHIFT 0
  128. #define VIA_REG_AC97_DATA_MASK 0xffff
  129. #define VIA_REG_SGD_SHADOW 0x84 /* dword */
  130. #define VIA_REG_SGD_STAT_PB_FLAG (1<<0)
  131. #define VIA_REG_SGD_STAT_CP_FLAG (1<<1)
  132. #define VIA_REG_SGD_STAT_FM_FLAG (1<<2)
  133. #define VIA_REG_SGD_STAT_PB_EOL (1<<4)
  134. #define VIA_REG_SGD_STAT_CP_EOL (1<<5)
  135. #define VIA_REG_SGD_STAT_FM_EOL (1<<6)
  136. #define VIA_REG_SGD_STAT_PB_STOP (1<<8)
  137. #define VIA_REG_SGD_STAT_CP_STOP (1<<9)
  138. #define VIA_REG_SGD_STAT_FM_STOP (1<<10)
  139. #define VIA_REG_SGD_STAT_PB_ACTIVE (1<<12)
  140. #define VIA_REG_SGD_STAT_CP_ACTIVE (1<<13)
  141. #define VIA_REG_SGD_STAT_FM_ACTIVE (1<<14)
  142. #define VIA_REG_SGD_STAT_MR_FLAG (1<<16)
  143. #define VIA_REG_SGD_STAT_MW_FLAG (1<<17)
  144. #define VIA_REG_SGD_STAT_MR_EOL (1<<20)
  145. #define VIA_REG_SGD_STAT_MW_EOL (1<<21)
  146. #define VIA_REG_SGD_STAT_MR_STOP (1<<24)
  147. #define VIA_REG_SGD_STAT_MW_STOP (1<<25)
  148. #define VIA_REG_SGD_STAT_MR_ACTIVE (1<<28)
  149. #define VIA_REG_SGD_STAT_MW_ACTIVE (1<<29)
  150. #define VIA_REG_GPI_STATUS 0x88
  151. #define VIA_REG_GPI_INTR 0x8c
  152. #define VIA_TBL_BIT_FLAG 0x40000000
  153. #define VIA_TBL_BIT_EOL 0x80000000
  154. /* pci space */
  155. #define VIA_ACLINK_STAT 0x40
  156. #define VIA_ACLINK_C11_READY 0x20
  157. #define VIA_ACLINK_C10_READY 0x10
  158. #define VIA_ACLINK_C01_READY 0x04 /* secondary codec ready */
  159. #define VIA_ACLINK_LOWPOWER 0x02 /* low-power state */
  160. #define VIA_ACLINK_C00_READY 0x01 /* primary codec ready */
  161. #define VIA_ACLINK_CTRL 0x41
  162. #define VIA_ACLINK_CTRL_ENABLE 0x80 /* 0: disable, 1: enable */
  163. #define VIA_ACLINK_CTRL_RESET 0x40 /* 0: assert, 1: de-assert */
  164. #define VIA_ACLINK_CTRL_SYNC 0x20 /* 0: release SYNC, 1: force SYNC hi */
  165. #define VIA_ACLINK_CTRL_SDO 0x10 /* 0: release SDO, 1: force SDO hi */
  166. #define VIA_ACLINK_CTRL_VRA 0x08 /* 0: disable VRA, 1: enable VRA */
  167. #define VIA_ACLINK_CTRL_PCM 0x04 /* 0: disable PCM, 1: enable PCM */
  168. #define VIA_ACLINK_CTRL_FM 0x02 /* via686 only */
  169. #define VIA_ACLINK_CTRL_SB 0x01 /* via686 only */
  170. #define VIA_ACLINK_CTRL_INIT (VIA_ACLINK_CTRL_ENABLE|\
  171. VIA_ACLINK_CTRL_RESET|\
  172. VIA_ACLINK_CTRL_PCM)
  173. #define VIA_FUNC_ENABLE 0x42
  174. #define VIA_FUNC_MIDI_PNP 0x80 /* FIXME: it's 0x40 in the datasheet! */
  175. #define VIA_FUNC_MIDI_IRQMASK 0x40 /* FIXME: not documented! */
  176. #define VIA_FUNC_RX2C_WRITE 0x20
  177. #define VIA_FUNC_SB_FIFO_EMPTY 0x10
  178. #define VIA_FUNC_ENABLE_GAME 0x08
  179. #define VIA_FUNC_ENABLE_FM 0x04
  180. #define VIA_FUNC_ENABLE_MIDI 0x02
  181. #define VIA_FUNC_ENABLE_SB 0x01
  182. #define VIA_PNP_CONTROL 0x43
  183. #define VIA_MC97_CTRL 0x44
  184. #define VIA_MC97_CTRL_ENABLE 0x80
  185. #define VIA_MC97_CTRL_SECONDARY 0x40
  186. #define VIA_MC97_CTRL_INIT (VIA_MC97_CTRL_ENABLE|\
  187. VIA_MC97_CTRL_SECONDARY)
  188. /*
  189. * pcm stream
  190. */
  191. struct snd_via_sg_table {
  192. unsigned int offset;
  193. unsigned int size;
  194. } ;
  195. #define VIA_TABLE_SIZE 255
  196. struct viadev {
  197. unsigned int reg_offset;
  198. unsigned long port;
  199. int direction; /* playback = 0, capture = 1 */
  200. struct snd_pcm_substream *substream;
  201. int running;
  202. unsigned int tbl_entries; /* # descriptors */
  203. struct snd_dma_buffer table;
  204. struct snd_via_sg_table *idx_table;
  205. /* for recovery from the unexpected pointer */
  206. unsigned int lastpos;
  207. unsigned int bufsize;
  208. unsigned int bufsize2;
  209. };
  210. enum { TYPE_CARD_VIA82XX_MODEM = 1 };
  211. #define VIA_MAX_MODEM_DEVS 2
  212. struct via82xx_modem {
  213. int irq;
  214. unsigned long port;
  215. unsigned int intr_mask; /* SGD_SHADOW mask to check interrupts */
  216. struct pci_dev *pci;
  217. struct snd_card *card;
  218. unsigned int num_devs;
  219. unsigned int playback_devno, capture_devno;
  220. struct viadev devs[VIA_MAX_MODEM_DEVS];
  221. struct snd_pcm *pcms[2];
  222. struct snd_ac97_bus *ac97_bus;
  223. struct snd_ac97 *ac97;
  224. unsigned int ac97_clock;
  225. unsigned int ac97_secondary; /* secondary AC'97 codec is present */
  226. spinlock_t reg_lock;
  227. struct snd_info_entry *proc_entry;
  228. };
  229. static struct pci_device_id snd_via82xx_modem_ids[] = {
  230. { PCI_VDEVICE(VIA, 0x3068), TYPE_CARD_VIA82XX_MODEM, },
  231. { 0, }
  232. };
  233. MODULE_DEVICE_TABLE(pci, snd_via82xx_modem_ids);
  234. /*
  235. */
  236. /*
  237. * allocate and initialize the descriptor buffers
  238. * periods = number of periods
  239. * fragsize = period size in bytes
  240. */
  241. static int build_via_table(struct viadev *dev, struct snd_pcm_substream *substream,
  242. struct pci_dev *pci,
  243. unsigned int periods, unsigned int fragsize)
  244. {
  245. unsigned int i, idx, ofs, rest;
  246. struct via82xx_modem *chip = snd_pcm_substream_chip(substream);
  247. if (dev->table.area == NULL) {
  248. /* the start of each lists must be aligned to 8 bytes,
  249. * but the kernel pages are much bigger, so we don't care
  250. */
  251. if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci),
  252. PAGE_ALIGN(VIA_TABLE_SIZE * 2 * 8),
  253. &dev->table) < 0)
  254. return -ENOMEM;
  255. }
  256. if (! dev->idx_table) {
  257. dev->idx_table = kmalloc(sizeof(*dev->idx_table) * VIA_TABLE_SIZE, GFP_KERNEL);
  258. if (! dev->idx_table)
  259. return -ENOMEM;
  260. }
  261. /* fill the entries */
  262. idx = 0;
  263. ofs = 0;
  264. for (i = 0; i < periods; i++) {
  265. rest = fragsize;
  266. /* fill descriptors for a period.
  267. * a period can be split to several descriptors if it's
  268. * over page boundary.
  269. */
  270. do {
  271. unsigned int r;
  272. unsigned int flag;
  273. unsigned int addr;
  274. if (idx >= VIA_TABLE_SIZE) {
  275. snd_printk(KERN_ERR "via82xx: too much table size!\n");
  276. return -EINVAL;
  277. }
  278. addr = snd_pcm_sgbuf_get_addr(substream, ofs);
  279. ((u32 *)dev->table.area)[idx << 1] = cpu_to_le32(addr);
  280. r = PAGE_SIZE - (ofs % PAGE_SIZE);
  281. if (rest < r)
  282. r = rest;
  283. rest -= r;
  284. if (! rest) {
  285. if (i == periods - 1)
  286. flag = VIA_TBL_BIT_EOL; /* buffer boundary */
  287. else
  288. flag = VIA_TBL_BIT_FLAG; /* period boundary */
  289. } else
  290. flag = 0; /* period continues to the next */
  291. /*
  292. printk(KERN_DEBUG "via: tbl %d: at %d size %d "
  293. "(rest %d)\n", idx, ofs, r, rest);
  294. */
  295. ((u32 *)dev->table.area)[(idx<<1) + 1] = cpu_to_le32(r | flag);
  296. dev->idx_table[idx].offset = ofs;
  297. dev->idx_table[idx].size = r;
  298. ofs += r;
  299. idx++;
  300. } while (rest > 0);
  301. }
  302. dev->tbl_entries = idx;
  303. dev->bufsize = periods * fragsize;
  304. dev->bufsize2 = dev->bufsize / 2;
  305. return 0;
  306. }
  307. static int clean_via_table(struct viadev *dev, struct snd_pcm_substream *substream,
  308. struct pci_dev *pci)
  309. {
  310. if (dev->table.area) {
  311. snd_dma_free_pages(&dev->table);
  312. dev->table.area = NULL;
  313. }
  314. kfree(dev->idx_table);
  315. dev->idx_table = NULL;
  316. return 0;
  317. }
  318. /*
  319. * Basic I/O
  320. */
  321. static inline unsigned int snd_via82xx_codec_xread(struct via82xx_modem *chip)
  322. {
  323. return inl(VIAREG(chip, AC97));
  324. }
  325. static inline void snd_via82xx_codec_xwrite(struct via82xx_modem *chip, unsigned int val)
  326. {
  327. outl(val, VIAREG(chip, AC97));
  328. }
  329. static int snd_via82xx_codec_ready(struct via82xx_modem *chip, int secondary)
  330. {
  331. unsigned int timeout = 1000; /* 1ms */
  332. unsigned int val;
  333. while (timeout-- > 0) {
  334. udelay(1);
  335. if (!((val = snd_via82xx_codec_xread(chip)) & VIA_REG_AC97_BUSY))
  336. return val & 0xffff;
  337. }
  338. snd_printk(KERN_ERR "codec_ready: codec %i is not ready [0x%x]\n",
  339. secondary, snd_via82xx_codec_xread(chip));
  340. return -EIO;
  341. }
  342. static int snd_via82xx_codec_valid(struct via82xx_modem *chip, int secondary)
  343. {
  344. unsigned int timeout = 1000; /* 1ms */
  345. unsigned int val, val1;
  346. unsigned int stat = !secondary ? VIA_REG_AC97_PRIMARY_VALID :
  347. VIA_REG_AC97_SECONDARY_VALID;
  348. while (timeout-- > 0) {
  349. val = snd_via82xx_codec_xread(chip);
  350. val1 = val & (VIA_REG_AC97_BUSY | stat);
  351. if (val1 == stat)
  352. return val & 0xffff;
  353. udelay(1);
  354. }
  355. return -EIO;
  356. }
  357. static void snd_via82xx_codec_wait(struct snd_ac97 *ac97)
  358. {
  359. struct via82xx_modem *chip = ac97->private_data;
  360. int err;
  361. err = snd_via82xx_codec_ready(chip, ac97->num);
  362. /* here we need to wait fairly for long time.. */
  363. msleep(500);
  364. }
  365. static void snd_via82xx_codec_write(struct snd_ac97 *ac97,
  366. unsigned short reg,
  367. unsigned short val)
  368. {
  369. struct via82xx_modem *chip = ac97->private_data;
  370. unsigned int xval;
  371. if(reg == AC97_GPIO_STATUS) {
  372. outl(val, VIAREG(chip, GPI_STATUS));
  373. return;
  374. }
  375. xval = !ac97->num ? VIA_REG_AC97_CODEC_ID_PRIMARY : VIA_REG_AC97_CODEC_ID_SECONDARY;
  376. xval <<= VIA_REG_AC97_CODEC_ID_SHIFT;
  377. xval |= reg << VIA_REG_AC97_CMD_SHIFT;
  378. xval |= val << VIA_REG_AC97_DATA_SHIFT;
  379. snd_via82xx_codec_xwrite(chip, xval);
  380. snd_via82xx_codec_ready(chip, ac97->num);
  381. }
  382. static unsigned short snd_via82xx_codec_read(struct snd_ac97 *ac97, unsigned short reg)
  383. {
  384. struct via82xx_modem *chip = ac97->private_data;
  385. unsigned int xval, val = 0xffff;
  386. int again = 0;
  387. xval = ac97->num << VIA_REG_AC97_CODEC_ID_SHIFT;
  388. xval |= ac97->num ? VIA_REG_AC97_SECONDARY_VALID : VIA_REG_AC97_PRIMARY_VALID;
  389. xval |= VIA_REG_AC97_READ;
  390. xval |= (reg & 0x7f) << VIA_REG_AC97_CMD_SHIFT;
  391. while (1) {
  392. if (again++ > 3) {
  393. snd_printk(KERN_ERR "codec_read: codec %i is not valid [0x%x]\n",
  394. ac97->num, snd_via82xx_codec_xread(chip));
  395. return 0xffff;
  396. }
  397. snd_via82xx_codec_xwrite(chip, xval);
  398. udelay (20);
  399. if (snd_via82xx_codec_valid(chip, ac97->num) >= 0) {
  400. udelay(25);
  401. val = snd_via82xx_codec_xread(chip);
  402. break;
  403. }
  404. }
  405. return val & 0xffff;
  406. }
  407. static void snd_via82xx_channel_reset(struct via82xx_modem *chip, struct viadev *viadev)
  408. {
  409. outb(VIA_REG_CTRL_PAUSE | VIA_REG_CTRL_TERMINATE | VIA_REG_CTRL_RESET,
  410. VIADEV_REG(viadev, OFFSET_CONTROL));
  411. inb(VIADEV_REG(viadev, OFFSET_CONTROL));
  412. udelay(50);
  413. /* disable interrupts */
  414. outb(0x00, VIADEV_REG(viadev, OFFSET_CONTROL));
  415. /* clear interrupts */
  416. outb(0x03, VIADEV_REG(viadev, OFFSET_STATUS));
  417. outb(0x00, VIADEV_REG(viadev, OFFSET_TYPE)); /* for via686 */
  418. // outl(0, VIADEV_REG(viadev, OFFSET_CURR_PTR));
  419. viadev->lastpos = 0;
  420. }
  421. /*
  422. * Interrupt handler
  423. */
  424. static irqreturn_t snd_via82xx_interrupt(int irq, void *dev_id)
  425. {
  426. struct via82xx_modem *chip = dev_id;
  427. unsigned int status;
  428. unsigned int i;
  429. status = inl(VIAREG(chip, SGD_SHADOW));
  430. if (! (status & chip->intr_mask)) {
  431. return IRQ_NONE;
  432. }
  433. // _skip_sgd:
  434. /* check status for each stream */
  435. spin_lock(&chip->reg_lock);
  436. for (i = 0; i < chip->num_devs; i++) {
  437. struct viadev *viadev = &chip->devs[i];
  438. unsigned char c_status = inb(VIADEV_REG(viadev, OFFSET_STATUS));
  439. c_status &= (VIA_REG_STAT_EOL|VIA_REG_STAT_FLAG|VIA_REG_STAT_STOPPED);
  440. if (! c_status)
  441. continue;
  442. if (viadev->substream && viadev->running) {
  443. spin_unlock(&chip->reg_lock);
  444. snd_pcm_period_elapsed(viadev->substream);
  445. spin_lock(&chip->reg_lock);
  446. }
  447. outb(c_status, VIADEV_REG(viadev, OFFSET_STATUS)); /* ack */
  448. }
  449. spin_unlock(&chip->reg_lock);
  450. return IRQ_HANDLED;
  451. }
  452. /*
  453. * PCM callbacks
  454. */
  455. /*
  456. * trigger callback
  457. */
  458. static int snd_via82xx_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
  459. {
  460. struct via82xx_modem *chip = snd_pcm_substream_chip(substream);
  461. struct viadev *viadev = substream->runtime->private_data;
  462. unsigned char val = 0;
  463. switch (cmd) {
  464. case SNDRV_PCM_TRIGGER_START:
  465. case SNDRV_PCM_TRIGGER_SUSPEND:
  466. val |= VIA_REG_CTRL_START;
  467. viadev->running = 1;
  468. break;
  469. case SNDRV_PCM_TRIGGER_STOP:
  470. val = VIA_REG_CTRL_TERMINATE;
  471. viadev->running = 0;
  472. break;
  473. case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
  474. val |= VIA_REG_CTRL_PAUSE;
  475. viadev->running = 0;
  476. break;
  477. case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
  478. viadev->running = 1;
  479. break;
  480. default:
  481. return -EINVAL;
  482. }
  483. outb(val, VIADEV_REG(viadev, OFFSET_CONTROL));
  484. if (cmd == SNDRV_PCM_TRIGGER_STOP)
  485. snd_via82xx_channel_reset(chip, viadev);
  486. return 0;
  487. }
  488. /*
  489. * pointer callbacks
  490. */
  491. /*
  492. * calculate the linear position at the given sg-buffer index and the rest count
  493. */
  494. #define check_invalid_pos(viadev,pos) \
  495. ((pos) < viadev->lastpos && ((pos) >= viadev->bufsize2 ||\
  496. viadev->lastpos < viadev->bufsize2))
  497. static inline unsigned int calc_linear_pos(struct viadev *viadev, unsigned int idx,
  498. unsigned int count)
  499. {
  500. unsigned int size, res;
  501. size = viadev->idx_table[idx].size;
  502. res = viadev->idx_table[idx].offset + size - count;
  503. /* check the validity of the calculated position */
  504. if (size < count) {
  505. snd_printd(KERN_ERR "invalid via82xx_cur_ptr (size = %d, count = %d)\n",
  506. (int)size, (int)count);
  507. res = viadev->lastpos;
  508. } else if (check_invalid_pos(viadev, res)) {
  509. #ifdef POINTER_DEBUG
  510. printk(KERN_DEBUG "fail: idx = %i/%i, lastpos = 0x%x, "
  511. "bufsize2 = 0x%x, offsize = 0x%x, size = 0x%x, "
  512. "count = 0x%x\n", idx, viadev->tbl_entries, viadev->lastpos,
  513. viadev->bufsize2, viadev->idx_table[idx].offset,
  514. viadev->idx_table[idx].size, count);
  515. #endif
  516. if (count && size < count) {
  517. snd_printd(KERN_ERR "invalid via82xx_cur_ptr, "
  518. "using last valid pointer\n");
  519. res = viadev->lastpos;
  520. } else {
  521. if (! count)
  522. /* bogus count 0 on the DMA boundary? */
  523. res = viadev->idx_table[idx].offset;
  524. else
  525. /* count register returns full size
  526. * when end of buffer is reached
  527. */
  528. res = viadev->idx_table[idx].offset + size;
  529. if (check_invalid_pos(viadev, res)) {
  530. snd_printd(KERN_ERR "invalid via82xx_cur_ptr (2), "
  531. "using last valid pointer\n");
  532. res = viadev->lastpos;
  533. }
  534. }
  535. }
  536. viadev->lastpos = res; /* remember the last position */
  537. if (res >= viadev->bufsize)
  538. res -= viadev->bufsize;
  539. return res;
  540. }
  541. /*
  542. * get the current pointer on via686
  543. */
  544. static snd_pcm_uframes_t snd_via686_pcm_pointer(struct snd_pcm_substream *substream)
  545. {
  546. struct via82xx_modem *chip = snd_pcm_substream_chip(substream);
  547. struct viadev *viadev = substream->runtime->private_data;
  548. unsigned int idx, ptr, count, res;
  549. if (snd_BUG_ON(!viadev->tbl_entries))
  550. return 0;
  551. if (!(inb(VIADEV_REG(viadev, OFFSET_STATUS)) & VIA_REG_STAT_ACTIVE))
  552. return 0;
  553. spin_lock(&chip->reg_lock);
  554. count = inl(VIADEV_REG(viadev, OFFSET_CURR_COUNT)) & 0xffffff;
  555. /* The via686a does not have the current index register,
  556. * so we need to calculate the index from CURR_PTR.
  557. */
  558. ptr = inl(VIADEV_REG(viadev, OFFSET_CURR_PTR));
  559. if (ptr <= (unsigned int)viadev->table.addr)
  560. idx = 0;
  561. else /* CURR_PTR holds the address + 8 */
  562. idx = ((ptr - (unsigned int)viadev->table.addr) / 8 - 1) %
  563. viadev->tbl_entries;
  564. res = calc_linear_pos(viadev, idx, count);
  565. spin_unlock(&chip->reg_lock);
  566. return bytes_to_frames(substream->runtime, res);
  567. }
  568. /*
  569. * hw_params callback:
  570. * allocate the buffer and build up the buffer description table
  571. */
  572. static int snd_via82xx_hw_params(struct snd_pcm_substream *substream,
  573. struct snd_pcm_hw_params *hw_params)
  574. {
  575. struct via82xx_modem *chip = snd_pcm_substream_chip(substream);
  576. struct viadev *viadev = substream->runtime->private_data;
  577. int err;
  578. err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
  579. if (err < 0)
  580. return err;
  581. err = build_via_table(viadev, substream, chip->pci,
  582. params_periods(hw_params),
  583. params_period_bytes(hw_params));
  584. if (err < 0)
  585. return err;
  586. snd_ac97_write(chip->ac97, AC97_LINE1_RATE, params_rate(hw_params));
  587. snd_ac97_write(chip->ac97, AC97_LINE1_LEVEL, 0);
  588. return 0;
  589. }
  590. /*
  591. * hw_free callback:
  592. * clean up the buffer description table and release the buffer
  593. */
  594. static int snd_via82xx_hw_free(struct snd_pcm_substream *substream)
  595. {
  596. struct via82xx_modem *chip = snd_pcm_substream_chip(substream);
  597. struct viadev *viadev = substream->runtime->private_data;
  598. clean_via_table(viadev, substream, chip->pci);
  599. snd_pcm_lib_free_pages(substream);
  600. return 0;
  601. }
  602. /*
  603. * set up the table pointer
  604. */
  605. static void snd_via82xx_set_table_ptr(struct via82xx_modem *chip, struct viadev *viadev)
  606. {
  607. snd_via82xx_codec_ready(chip, chip->ac97_secondary);
  608. outl((u32)viadev->table.addr, VIADEV_REG(viadev, OFFSET_TABLE_PTR));
  609. udelay(20);
  610. snd_via82xx_codec_ready(chip, chip->ac97_secondary);
  611. }
  612. /*
  613. * prepare callback for playback and capture
  614. */
  615. static int snd_via82xx_pcm_prepare(struct snd_pcm_substream *substream)
  616. {
  617. struct via82xx_modem *chip = snd_pcm_substream_chip(substream);
  618. struct viadev *viadev = substream->runtime->private_data;
  619. snd_via82xx_channel_reset(chip, viadev);
  620. /* this must be set after channel_reset */
  621. snd_via82xx_set_table_ptr(chip, viadev);
  622. outb(VIA_REG_TYPE_AUTOSTART|VIA_REG_TYPE_INT_EOL|VIA_REG_TYPE_INT_FLAG,
  623. VIADEV_REG(viadev, OFFSET_TYPE));
  624. return 0;
  625. }
  626. /*
  627. * pcm hardware definition, identical for both playback and capture
  628. */
  629. static struct snd_pcm_hardware snd_via82xx_hw =
  630. {
  631. .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
  632. SNDRV_PCM_INFO_BLOCK_TRANSFER |
  633. SNDRV_PCM_INFO_MMAP_VALID |
  634. /* SNDRV_PCM_INFO_RESUME | */
  635. SNDRV_PCM_INFO_PAUSE),
  636. .formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE,
  637. .rates = SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_KNOT,
  638. .rate_min = 8000,
  639. .rate_max = 16000,
  640. .channels_min = 1,
  641. .channels_max = 1,
  642. .buffer_bytes_max = 128 * 1024,
  643. .period_bytes_min = 32,
  644. .period_bytes_max = 128 * 1024,
  645. .periods_min = 2,
  646. .periods_max = VIA_TABLE_SIZE / 2,
  647. .fifo_size = 0,
  648. };
  649. /*
  650. * open callback skeleton
  651. */
  652. static int snd_via82xx_modem_pcm_open(struct via82xx_modem *chip, struct viadev *viadev,
  653. struct snd_pcm_substream *substream)
  654. {
  655. struct snd_pcm_runtime *runtime = substream->runtime;
  656. int err;
  657. static unsigned int rates[] = { 8000, 9600, 12000, 16000 };
  658. static struct snd_pcm_hw_constraint_list hw_constraints_rates = {
  659. .count = ARRAY_SIZE(rates),
  660. .list = rates,
  661. .mask = 0,
  662. };
  663. runtime->hw = snd_via82xx_hw;
  664. if ((err = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
  665. &hw_constraints_rates)) < 0)
  666. return err;
  667. /* we may remove following constaint when we modify table entries
  668. in interrupt */
  669. if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
  670. return err;
  671. runtime->private_data = viadev;
  672. viadev->substream = substream;
  673. return 0;
  674. }
  675. /*
  676. * open callback for playback
  677. */
  678. static int snd_via82xx_playback_open(struct snd_pcm_substream *substream)
  679. {
  680. struct via82xx_modem *chip = snd_pcm_substream_chip(substream);
  681. struct viadev *viadev = &chip->devs[chip->playback_devno + substream->number];
  682. return snd_via82xx_modem_pcm_open(chip, viadev, substream);
  683. }
  684. /*
  685. * open callback for capture
  686. */
  687. static int snd_via82xx_capture_open(struct snd_pcm_substream *substream)
  688. {
  689. struct via82xx_modem *chip = snd_pcm_substream_chip(substream);
  690. struct viadev *viadev = &chip->devs[chip->capture_devno + substream->pcm->device];
  691. return snd_via82xx_modem_pcm_open(chip, viadev, substream);
  692. }
  693. /*
  694. * close callback
  695. */
  696. static int snd_via82xx_pcm_close(struct snd_pcm_substream *substream)
  697. {
  698. struct viadev *viadev = substream->runtime->private_data;
  699. viadev->substream = NULL;
  700. return 0;
  701. }
  702. /* via686 playback callbacks */
  703. static struct snd_pcm_ops snd_via686_playback_ops = {
  704. .open = snd_via82xx_playback_open,
  705. .close = snd_via82xx_pcm_close,
  706. .ioctl = snd_pcm_lib_ioctl,
  707. .hw_params = snd_via82xx_hw_params,
  708. .hw_free = snd_via82xx_hw_free,
  709. .prepare = snd_via82xx_pcm_prepare,
  710. .trigger = snd_via82xx_pcm_trigger,
  711. .pointer = snd_via686_pcm_pointer,
  712. .page = snd_pcm_sgbuf_ops_page,
  713. };
  714. /* via686 capture callbacks */
  715. static struct snd_pcm_ops snd_via686_capture_ops = {
  716. .open = snd_via82xx_capture_open,
  717. .close = snd_via82xx_pcm_close,
  718. .ioctl = snd_pcm_lib_ioctl,
  719. .hw_params = snd_via82xx_hw_params,
  720. .hw_free = snd_via82xx_hw_free,
  721. .prepare = snd_via82xx_pcm_prepare,
  722. .trigger = snd_via82xx_pcm_trigger,
  723. .pointer = snd_via686_pcm_pointer,
  724. .page = snd_pcm_sgbuf_ops_page,
  725. };
  726. static void init_viadev(struct via82xx_modem *chip, int idx, unsigned int reg_offset,
  727. int direction)
  728. {
  729. chip->devs[idx].reg_offset = reg_offset;
  730. chip->devs[idx].direction = direction;
  731. chip->devs[idx].port = chip->port + reg_offset;
  732. }
  733. /*
  734. * create a pcm instance for via686a/b
  735. */
  736. static int __devinit snd_via686_pcm_new(struct via82xx_modem *chip)
  737. {
  738. struct snd_pcm *pcm;
  739. int err;
  740. chip->playback_devno = 0;
  741. chip->capture_devno = 1;
  742. chip->num_devs = 2;
  743. chip->intr_mask = 0x330000; /* FLAGS | EOL for MR, MW */
  744. err = snd_pcm_new(chip->card, chip->card->shortname, 0, 1, 1, &pcm);
  745. if (err < 0)
  746. return err;
  747. snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_via686_playback_ops);
  748. snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_via686_capture_ops);
  749. pcm->dev_class = SNDRV_PCM_CLASS_MODEM;
  750. pcm->private_data = chip;
  751. strcpy(pcm->name, chip->card->shortname);
  752. chip->pcms[0] = pcm;
  753. init_viadev(chip, 0, VIA_REG_MO_STATUS, 0);
  754. init_viadev(chip, 1, VIA_REG_MI_STATUS, 1);
  755. if ((err = snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
  756. snd_dma_pci_data(chip->pci),
  757. 64*1024, 128*1024)) < 0)
  758. return err;
  759. return 0;
  760. }
  761. /*
  762. * Mixer part
  763. */
  764. static void snd_via82xx_mixer_free_ac97_bus(struct snd_ac97_bus *bus)
  765. {
  766. struct via82xx_modem *chip = bus->private_data;
  767. chip->ac97_bus = NULL;
  768. }
  769. static void snd_via82xx_mixer_free_ac97(struct snd_ac97 *ac97)
  770. {
  771. struct via82xx_modem *chip = ac97->private_data;
  772. chip->ac97 = NULL;
  773. }
  774. static int __devinit snd_via82xx_mixer_new(struct via82xx_modem *chip)
  775. {
  776. struct snd_ac97_template ac97;
  777. int err;
  778. static struct snd_ac97_bus_ops ops = {
  779. .write = snd_via82xx_codec_write,
  780. .read = snd_via82xx_codec_read,
  781. .wait = snd_via82xx_codec_wait,
  782. };
  783. if ((err = snd_ac97_bus(chip->card, 0, &ops, chip, &chip->ac97_bus)) < 0)
  784. return err;
  785. chip->ac97_bus->private_free = snd_via82xx_mixer_free_ac97_bus;
  786. chip->ac97_bus->clock = chip->ac97_clock;
  787. memset(&ac97, 0, sizeof(ac97));
  788. ac97.private_data = chip;
  789. ac97.private_free = snd_via82xx_mixer_free_ac97;
  790. ac97.pci = chip->pci;
  791. ac97.scaps = AC97_SCAP_SKIP_AUDIO | AC97_SCAP_POWER_SAVE;
  792. ac97.num = chip->ac97_secondary;
  793. if ((err = snd_ac97_mixer(chip->ac97_bus, &ac97, &chip->ac97)) < 0)
  794. return err;
  795. return 0;
  796. }
  797. /*
  798. * proc interface
  799. */
  800. static void snd_via82xx_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
  801. {
  802. struct via82xx_modem *chip = entry->private_data;
  803. int i;
  804. snd_iprintf(buffer, "%s\n\n", chip->card->longname);
  805. for (i = 0; i < 0xa0; i += 4) {
  806. snd_iprintf(buffer, "%02x: %08x\n", i, inl(chip->port + i));
  807. }
  808. }
  809. static void __devinit snd_via82xx_proc_init(struct via82xx_modem *chip)
  810. {
  811. struct snd_info_entry *entry;
  812. if (! snd_card_proc_new(chip->card, "via82xx", &entry))
  813. snd_info_set_text_ops(entry, chip, snd_via82xx_proc_read);
  814. }
  815. /*
  816. *
  817. */
  818. static int snd_via82xx_chip_init(struct via82xx_modem *chip)
  819. {
  820. unsigned int val;
  821. unsigned long end_time;
  822. unsigned char pval;
  823. pci_read_config_byte(chip->pci, VIA_MC97_CTRL, &pval);
  824. if((pval & VIA_MC97_CTRL_INIT) != VIA_MC97_CTRL_INIT) {
  825. pci_write_config_byte(chip->pci, 0x44, pval|VIA_MC97_CTRL_INIT);
  826. udelay(100);
  827. }
  828. pci_read_config_byte(chip->pci, VIA_ACLINK_STAT, &pval);
  829. if (! (pval & VIA_ACLINK_C00_READY)) { /* codec not ready? */
  830. /* deassert ACLink reset, force SYNC */
  831. pci_write_config_byte(chip->pci, VIA_ACLINK_CTRL,
  832. VIA_ACLINK_CTRL_ENABLE |
  833. VIA_ACLINK_CTRL_RESET |
  834. VIA_ACLINK_CTRL_SYNC);
  835. udelay(100);
  836. #if 1 /* FIXME: should we do full reset here for all chip models? */
  837. pci_write_config_byte(chip->pci, VIA_ACLINK_CTRL, 0x00);
  838. udelay(100);
  839. #else
  840. /* deassert ACLink reset, force SYNC (warm AC'97 reset) */
  841. pci_write_config_byte(chip->pci, VIA_ACLINK_CTRL,
  842. VIA_ACLINK_CTRL_RESET|VIA_ACLINK_CTRL_SYNC);
  843. udelay(2);
  844. #endif
  845. /* ACLink on, deassert ACLink reset, VSR, SGD data out */
  846. pci_write_config_byte(chip->pci, VIA_ACLINK_CTRL, VIA_ACLINK_CTRL_INIT);
  847. udelay(100);
  848. }
  849. pci_read_config_byte(chip->pci, VIA_ACLINK_CTRL, &pval);
  850. if ((pval & VIA_ACLINK_CTRL_INIT) != VIA_ACLINK_CTRL_INIT) {
  851. /* ACLink on, deassert ACLink reset, VSR, SGD data out */
  852. pci_write_config_byte(chip->pci, VIA_ACLINK_CTRL, VIA_ACLINK_CTRL_INIT);
  853. udelay(100);
  854. }
  855. /* wait until codec ready */
  856. end_time = jiffies + msecs_to_jiffies(750);
  857. do {
  858. pci_read_config_byte(chip->pci, VIA_ACLINK_STAT, &pval);
  859. if (pval & VIA_ACLINK_C00_READY) /* primary codec ready */
  860. break;
  861. schedule_timeout_uninterruptible(1);
  862. } while (time_before(jiffies, end_time));
  863. if ((val = snd_via82xx_codec_xread(chip)) & VIA_REG_AC97_BUSY)
  864. snd_printk(KERN_ERR "AC'97 codec is not ready [0x%x]\n", val);
  865. snd_via82xx_codec_xwrite(chip, VIA_REG_AC97_READ |
  866. VIA_REG_AC97_SECONDARY_VALID |
  867. (VIA_REG_AC97_CODEC_ID_SECONDARY << VIA_REG_AC97_CODEC_ID_SHIFT));
  868. end_time = jiffies + msecs_to_jiffies(750);
  869. snd_via82xx_codec_xwrite(chip, VIA_REG_AC97_READ |
  870. VIA_REG_AC97_SECONDARY_VALID |
  871. (VIA_REG_AC97_CODEC_ID_SECONDARY << VIA_REG_AC97_CODEC_ID_SHIFT));
  872. do {
  873. if ((val = snd_via82xx_codec_xread(chip)) & VIA_REG_AC97_SECONDARY_VALID) {
  874. chip->ac97_secondary = 1;
  875. goto __ac97_ok2;
  876. }
  877. schedule_timeout_uninterruptible(1);
  878. } while (time_before(jiffies, end_time));
  879. /* This is ok, the most of motherboards have only one codec */
  880. __ac97_ok2:
  881. /* route FM trap to IRQ, disable FM trap */
  882. // pci_write_config_byte(chip->pci, VIA_FM_NMI_CTRL, 0);
  883. /* disable all GPI interrupts */
  884. outl(0, VIAREG(chip, GPI_INTR));
  885. return 0;
  886. }
  887. #ifdef CONFIG_PM
  888. /*
  889. * power management
  890. */
  891. static int snd_via82xx_suspend(struct pci_dev *pci, pm_message_t state)
  892. {
  893. struct snd_card *card = pci_get_drvdata(pci);
  894. struct via82xx_modem *chip = card->private_data;
  895. int i;
  896. snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
  897. for (i = 0; i < 2; i++)
  898. snd_pcm_suspend_all(chip->pcms[i]);
  899. for (i = 0; i < chip->num_devs; i++)
  900. snd_via82xx_channel_reset(chip, &chip->devs[i]);
  901. synchronize_irq(chip->irq);
  902. snd_ac97_suspend(chip->ac97);
  903. pci_disable_device(pci);
  904. pci_save_state(pci);
  905. pci_set_power_state(pci, pci_choose_state(pci, state));
  906. return 0;
  907. }
  908. static int snd_via82xx_resume(struct pci_dev *pci)
  909. {
  910. struct snd_card *card = pci_get_drvdata(pci);
  911. struct via82xx_modem *chip = card->private_data;
  912. int i;
  913. pci_set_power_state(pci, PCI_D0);
  914. pci_restore_state(pci);
  915. if (pci_enable_device(pci) < 0) {
  916. printk(KERN_ERR "via82xx-modem: pci_enable_device failed, "
  917. "disabling device\n");
  918. snd_card_disconnect(card);
  919. return -EIO;
  920. }
  921. pci_set_master(pci);
  922. snd_via82xx_chip_init(chip);
  923. snd_ac97_resume(chip->ac97);
  924. for (i = 0; i < chip->num_devs; i++)
  925. snd_via82xx_channel_reset(chip, &chip->devs[i]);
  926. snd_power_change_state(card, SNDRV_CTL_POWER_D0);
  927. return 0;
  928. }
  929. #endif /* CONFIG_PM */
  930. static int snd_via82xx_free(struct via82xx_modem *chip)
  931. {
  932. unsigned int i;
  933. if (chip->irq < 0)
  934. goto __end_hw;
  935. /* disable interrupts */
  936. for (i = 0; i < chip->num_devs; i++)
  937. snd_via82xx_channel_reset(chip, &chip->devs[i]);
  938. __end_hw:
  939. if (chip->irq >= 0)
  940. free_irq(chip->irq, chip);
  941. pci_release_regions(chip->pci);
  942. pci_disable_device(chip->pci);
  943. kfree(chip);
  944. return 0;
  945. }
  946. static int snd_via82xx_dev_free(struct snd_device *device)
  947. {
  948. struct via82xx_modem *chip = device->device_data;
  949. return snd_via82xx_free(chip);
  950. }
  951. static int __devinit snd_via82xx_create(struct snd_card *card,
  952. struct pci_dev *pci,
  953. int chip_type,
  954. int revision,
  955. unsigned int ac97_clock,
  956. struct via82xx_modem ** r_via)
  957. {
  958. struct via82xx_modem *chip;
  959. int err;
  960. static struct snd_device_ops ops = {
  961. .dev_free = snd_via82xx_dev_free,
  962. };
  963. if ((err = pci_enable_device(pci)) < 0)
  964. return err;
  965. if ((chip = kzalloc(sizeof(*chip), GFP_KERNEL)) == NULL) {
  966. pci_disable_device(pci);
  967. return -ENOMEM;
  968. }
  969. spin_lock_init(&chip->reg_lock);
  970. chip->card = card;
  971. chip->pci = pci;
  972. chip->irq = -1;
  973. if ((err = pci_request_regions(pci, card->driver)) < 0) {
  974. kfree(chip);
  975. pci_disable_device(pci);
  976. return err;
  977. }
  978. chip->port = pci_resource_start(pci, 0);
  979. if (request_irq(pci->irq, snd_via82xx_interrupt, IRQF_SHARED,
  980. card->driver, chip)) {
  981. snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
  982. snd_via82xx_free(chip);
  983. return -EBUSY;
  984. }
  985. chip->irq = pci->irq;
  986. if (ac97_clock >= 8000 && ac97_clock <= 48000)
  987. chip->ac97_clock = ac97_clock;
  988. synchronize_irq(chip->irq);
  989. if ((err = snd_via82xx_chip_init(chip)) < 0) {
  990. snd_via82xx_free(chip);
  991. return err;
  992. }
  993. if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
  994. snd_via82xx_free(chip);
  995. return err;
  996. }
  997. /* The 8233 ac97 controller does not implement the master bit
  998. * in the pci command register. IMHO this is a violation of the PCI spec.
  999. * We call pci_set_master here because it does not hurt. */
  1000. pci_set_master(pci);
  1001. snd_card_set_dev(card, &pci->dev);
  1002. *r_via = chip;
  1003. return 0;
  1004. }
  1005. static int __devinit snd_via82xx_probe(struct pci_dev *pci,
  1006. const struct pci_device_id *pci_id)
  1007. {
  1008. struct snd_card *card;
  1009. struct via82xx_modem *chip;
  1010. int chip_type = 0, card_type;
  1011. unsigned int i;
  1012. int err;
  1013. err = snd_card_create(index, id, THIS_MODULE, 0, &card);
  1014. if (err < 0)
  1015. return err;
  1016. card_type = pci_id->driver_data;
  1017. switch (card_type) {
  1018. case TYPE_CARD_VIA82XX_MODEM:
  1019. strcpy(card->driver, "VIA82XX-MODEM");
  1020. sprintf(card->shortname, "VIA 82XX modem");
  1021. break;
  1022. default:
  1023. snd_printk(KERN_ERR "invalid card type %d\n", card_type);
  1024. err = -EINVAL;
  1025. goto __error;
  1026. }
  1027. if ((err = snd_via82xx_create(card, pci, chip_type, pci->revision,
  1028. ac97_clock, &chip)) < 0)
  1029. goto __error;
  1030. card->private_data = chip;
  1031. if ((err = snd_via82xx_mixer_new(chip)) < 0)
  1032. goto __error;
  1033. if ((err = snd_via686_pcm_new(chip)) < 0 )
  1034. goto __error;
  1035. /* disable interrupts */
  1036. for (i = 0; i < chip->num_devs; i++)
  1037. snd_via82xx_channel_reset(chip, &chip->devs[i]);
  1038. sprintf(card->longname, "%s at 0x%lx, irq %d",
  1039. card->shortname, chip->port, chip->irq);
  1040. snd_via82xx_proc_init(chip);
  1041. if ((err = snd_card_register(card)) < 0) {
  1042. snd_card_free(card);
  1043. return err;
  1044. }
  1045. pci_set_drvdata(pci, card);
  1046. return 0;
  1047. __error:
  1048. snd_card_free(card);
  1049. return err;
  1050. }
  1051. static void __devexit snd_via82xx_remove(struct pci_dev *pci)
  1052. {
  1053. snd_card_free(pci_get_drvdata(pci));
  1054. pci_set_drvdata(pci, NULL);
  1055. }
  1056. static struct pci_driver driver = {
  1057. .name = "VIA 82xx Modem",
  1058. .id_table = snd_via82xx_modem_ids,
  1059. .probe = snd_via82xx_probe,
  1060. .remove = __devexit_p(snd_via82xx_remove),
  1061. #ifdef CONFIG_PM
  1062. .suspend = snd_via82xx_suspend,
  1063. .resume = snd_via82xx_resume,
  1064. #endif
  1065. };
  1066. static int __init alsa_card_via82xx_init(void)
  1067. {
  1068. return pci_register_driver(&driver);
  1069. }
  1070. static void __exit alsa_card_via82xx_exit(void)
  1071. {
  1072. pci_unregister_driver(&driver);
  1073. }
  1074. module_init(alsa_card_via82xx_init)
  1075. module_exit(alsa_card_via82xx_exit)