Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ali5451.c
Go to the documentation of this file.
1 /*
2  * Matt Wu <[email protected]>
3  * Apr 26, 2001
4  * Routines for control of ALi pci audio M5451
5  *
6  * BUGS:
7  * --
8  *
9  * TODO:
10  * --
11  *
12  * This program is free software; you can redistribute it and/or modify
13  * it under the terms of the GNU General Public Lcodecnse as published by
14  * the Free Software Foundation; either version 2 of the Lcodecnse, or
15  * (at your option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20  * GNU General Public Lcodecnse for more details.
21  *
22  * You should have received a copy of the GNU General Public Lcodecnse
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25  *
26  */
27 
28 #include <asm/io.h>
29 #include <linux/delay.h>
30 #include <linux/interrupt.h>
31 #include <linux/init.h>
32 #include <linux/pci.h>
33 #include <linux/slab.h>
34 #include <linux/module.h>
35 #include <linux/dma-mapping.h>
36 #include <sound/core.h>
37 #include <sound/pcm.h>
38 #include <sound/info.h>
39 #include <sound/ac97_codec.h>
40 #include <sound/mpu401.h>
41 #include <sound/initval.h>
42 
43 MODULE_AUTHOR("Matt Wu <[email protected]>");
44 MODULE_DESCRIPTION("ALI M5451");
45 MODULE_LICENSE("GPL");
46 MODULE_SUPPORTED_DEVICE("{{ALI,M5451,pci},{ALI,M5451}}");
47 
48 static int index = SNDRV_DEFAULT_IDX1; /* Index */
49 static char *id = SNDRV_DEFAULT_STR1; /* ID for this card */
50 static int pcm_channels = 32;
51 static bool spdif;
52 
53 module_param(index, int, 0444);
54 MODULE_PARM_DESC(index, "Index value for ALI M5451 PCI Audio.");
55 module_param(id, charp, 0444);
56 MODULE_PARM_DESC(id, "ID string for ALI M5451 PCI Audio.");
57 module_param(pcm_channels, int, 0444);
58 MODULE_PARM_DESC(pcm_channels, "PCM Channels");
59 module_param(spdif, bool, 0444);
60 MODULE_PARM_DESC(spdif, "Support SPDIF I/O");
61 
62 /* just for backward compatibility */
63 static bool enable;
64 module_param(enable, bool, 0444);
65 
66 
67 /*
68  * Debug part definitions
69  */
70 
71 /* #define ALI_DEBUG */
72 
73 #ifdef ALI_DEBUG
74 #define snd_ali_printk(format, args...) printk(KERN_DEBUG format, ##args);
75 #else
76 #define snd_ali_printk(format, args...)
77 #endif
78 
79 /*
80  * Constants definition
81  */
82 
83 #define DEVICE_ID_ALI5451 ((PCI_VENDOR_ID_AL<<16)|PCI_DEVICE_ID_AL_M5451)
84 
85 
86 #define ALI_CHANNELS 32
87 
88 #define ALI_PCM_IN_CHANNEL 31
89 #define ALI_SPDIF_IN_CHANNEL 19
90 #define ALI_SPDIF_OUT_CHANNEL 15
91 #define ALI_CENTER_CHANNEL 24
92 #define ALI_LEF_CHANNEL 23
93 #define ALI_SURR_LEFT_CHANNEL 26
94 #define ALI_SURR_RIGHT_CHANNEL 25
95 #define ALI_MODEM_IN_CHANNEL 21
96 #define ALI_MODEM_OUT_CHANNEL 20
97 
98 #define SNDRV_ALI_VOICE_TYPE_PCM 01
99 #define SNDRV_ALI_VOICE_TYPE_OTH 02
100 
101 #define ALI_5451_V02 0x02
102 
103 /*
104  * Direct Registers
105  */
106 
107 #define ALI_LEGACY_DMAR0 0x00 /* ADR0 */
108 #define ALI_LEGACY_DMAR4 0x04 /* CNT0 */
109 #define ALI_LEGACY_DMAR11 0x0b /* MOD */
110 #define ALI_LEGACY_DMAR15 0x0f /* MMR */
111 #define ALI_MPUR0 0x20
112 #define ALI_MPUR1 0x21
113 #define ALI_MPUR2 0x22
114 #define ALI_MPUR3 0x23
115 
116 #define ALI_AC97_WRITE 0x40
117 #define ALI_AC97_READ 0x44
118 
119 #define ALI_SCTRL 0x48
120 #define ALI_SPDIF_OUT_ENABLE 0x20
121 #define ALI_SCTRL_LINE_IN2 (1 << 9)
122 #define ALI_SCTRL_GPIO_IN2 (1 << 13)
123 #define ALI_SCTRL_LINE_OUT_EN (1 << 20)
124 #define ALI_SCTRL_GPIO_OUT_EN (1 << 23)
125 #define ALI_SCTRL_CODEC1_READY (1 << 24)
126 #define ALI_SCTRL_CODEC2_READY (1 << 25)
127 #define ALI_AC97_GPIO 0x4c
128 #define ALI_AC97_GPIO_ENABLE 0x8000
129 #define ALI_AC97_GPIO_DATA_SHIFT 16
130 #define ALI_SPDIF_CS 0x70
131 #define ALI_SPDIF_CTRL 0x74
132 #define ALI_SPDIF_IN_FUNC_ENABLE 0x02
133 #define ALI_SPDIF_IN_CH_STATUS 0x40
134 #define ALI_SPDIF_OUT_CH_STATUS 0xbf
135 #define ALI_START 0x80
136 #define ALI_STOP 0x84
137 #define ALI_CSPF 0x90
138 #define ALI_AINT 0x98
139 #define ALI_GC_CIR 0xa0
140  #define ENDLP_IE 0x00001000
141  #define MIDLP_IE 0x00002000
142 #define ALI_AINTEN 0xa4
143 #define ALI_VOLUME 0xa8
144 #define ALI_SBDELTA_DELTA_R 0xac
145 #define ALI_MISCINT 0xb0
146  #define ADDRESS_IRQ 0x00000020
147  #define TARGET_REACHED 0x00008000
148  #define MIXER_OVERFLOW 0x00000800
149  #define MIXER_UNDERFLOW 0x00000400
150  #define GPIO_IRQ 0x01000000
151 #define ALI_SBBL_SBCL 0xc0
152 #define ALI_SBCTRL_SBE2R_SBDD 0xc4
153 #define ALI_STIMER 0xc8
154 #define ALI_GLOBAL_CONTROL 0xd4
155 #define ALI_SPDIF_OUT_SEL_PCM 0x00000400 /* bit 10 */
156 #define ALI_SPDIF_IN_SUPPORT 0x00000800 /* bit 11 */
157 #define ALI_SPDIF_OUT_CH_ENABLE 0x00008000 /* bit 15 */
158 #define ALI_SPDIF_IN_CH_ENABLE 0x00080000 /* bit 19 */
159 #define ALI_PCM_IN_ENABLE 0x80000000 /* bit 31 */
160 
161 #define ALI_CSO_ALPHA_FMS 0xe0
162 #define ALI_LBA 0xe4
163 #define ALI_ESO_DELTA 0xe8
164 #define ALI_GVSEL_PAN_VOC_CTRL_EC 0xf0
165 #define ALI_EBUF1 0xf4
166 #define ALI_EBUF2 0xf8
167 
168 #define ALI_REG(codec, x) ((codec)->port + x)
169 
170 #define MAX_CODECS 2
171 
172 
173 struct snd_ali;
174 struct snd_ali_voice;
175 
176 struct snd_ali_channel_control {
177  /* register data */
178  struct REGDATA {
179  unsigned int start;
180  unsigned int stop;
181  unsigned int aint;
182  unsigned int ainten;
183  } data;
184 
185  /* register addresses */
186  struct REGS {
187  unsigned int start;
188  unsigned int stop;
189  unsigned int aint;
190  unsigned int ainten;
191  unsigned int ac97read;
192  unsigned int ac97write;
193  } regs;
194 
195 };
196 
197 struct snd_ali_voice {
198  unsigned int number;
199  unsigned int use :1,
200  pcm :1,
201  midi :1,
202  mode :1,
203  synth :1,
204  running :1;
205 
206  /* PCM data */
207  struct snd_ali *codec;
208  struct snd_pcm_substream *substream;
209  struct snd_ali_voice *extra;
210 
211  int eso; /* final ESO value for channel */
212  int count; /* runtime->period_size */
213 
214  /* --- */
215 
216  void *private_data;
217  void (*private_free)(void *private_data);
218 };
219 
220 
221 struct snd_alidev {
222 
223  struct snd_ali_voice voices[ALI_CHANNELS];
224 
225  unsigned int chcnt; /* num of opened channels */
226  unsigned int chmap; /* bitmap for opened channels */
227  unsigned int synthcount;
228 
229 };
230 
231 
232 #define ALI_GLOBAL_REGS 56
233 #define ALI_CHANNEL_REGS 8
234 struct snd_ali_image {
235  u32 regs[ALI_GLOBAL_REGS];
236  u32 channel_regs[ALI_CHANNELS][ALI_CHANNEL_REGS];
237 };
238 
239 
240 struct snd_ali {
241  int irq;
242  unsigned long port;
243  unsigned char revision;
244 
245  unsigned int hw_initialized :1;
246  unsigned int spdif_support :1;
247 
248  struct pci_dev *pci;
249  struct pci_dev *pci_m1533;
250  struct pci_dev *pci_m7101;
251 
252  struct snd_card *card;
253  struct snd_pcm *pcm[MAX_CODECS];
254  struct snd_alidev synth;
255  struct snd_ali_channel_control chregs;
256 
257  /* S/PDIF Mask */
258  unsigned int spdif_mask;
259 
260  unsigned int spurious_irq_count;
261  unsigned int spurious_irq_max_delta;
262 
263  unsigned int num_of_codecs;
264 
265  struct snd_ac97_bus *ac97_bus;
266  struct snd_ac97 *ac97[MAX_CODECS];
267  unsigned short ac97_ext_id;
268  unsigned short ac97_ext_status;
269 
270  spinlock_t reg_lock;
271  spinlock_t voice_alloc;
272 
273 #ifdef CONFIG_PM_SLEEP
274  struct snd_ali_image *image;
275 #endif
276 };
277 
278 static DEFINE_PCI_DEVICE_TABLE(snd_ali_ids) = {
279  {PCI_DEVICE(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M5451), 0, 0, 0},
280  {0, }
281 };
282 MODULE_DEVICE_TABLE(pci, snd_ali_ids);
283 
284 static void snd_ali_clear_voices(struct snd_ali *, unsigned int, unsigned int);
285 static unsigned short snd_ali_codec_peek(struct snd_ali *, int, unsigned short);
286 static void snd_ali_codec_poke(struct snd_ali *, int, unsigned short,
287  unsigned short);
288 
289 /*
290  * AC97 ACCESS
291  */
292 
293 static inline unsigned int snd_ali_5451_peek(struct snd_ali *codec,
294  unsigned int port)
295 {
296  return (unsigned int)inl(ALI_REG(codec, port));
297 }
298 
299 static inline void snd_ali_5451_poke(struct snd_ali *codec,
300  unsigned int port,
301  unsigned int val)
302 {
303  outl((unsigned int)val, ALI_REG(codec, port));
304 }
305 
306 static int snd_ali_codec_ready(struct snd_ali *codec,
307  unsigned int port)
308 {
309  unsigned long end_time;
310  unsigned int res;
311 
312  end_time = jiffies + msecs_to_jiffies(250);
313 
314  for (;;) {
315  res = snd_ali_5451_peek(codec,port);
316  if (!(res & 0x8000))
317  return 0;
318  if (!time_after_eq(end_time, jiffies))
319  break;
320  schedule_timeout_uninterruptible(1);
321  }
322 
323  snd_ali_5451_poke(codec, port, res & ~0x8000);
324  snd_printdd("ali_codec_ready: codec is not ready.\n ");
325  return -EIO;
326 }
327 
328 static int snd_ali_stimer_ready(struct snd_ali *codec)
329 {
330  unsigned long end_time;
331  unsigned long dwChk1,dwChk2;
332 
333  dwChk1 = snd_ali_5451_peek(codec, ALI_STIMER);
334  end_time = jiffies + msecs_to_jiffies(250);
335 
336  for (;;) {
337  dwChk2 = snd_ali_5451_peek(codec, ALI_STIMER);
338  if (dwChk2 != dwChk1)
339  return 0;
340  if (!time_after_eq(end_time, jiffies))
341  break;
342  schedule_timeout_uninterruptible(1);
343  }
344 
345  snd_printk(KERN_ERR "ali_stimer_read: stimer is not ready.\n");
346  return -EIO;
347 }
348 
349 static void snd_ali_codec_poke(struct snd_ali *codec,int secondary,
350  unsigned short reg,
351  unsigned short val)
352 {
353  unsigned int dwVal;
354  unsigned int port;
355 
356  if (reg >= 0x80) {
357  snd_printk(KERN_ERR "ali_codec_poke: reg(%xh) invalid.\n", reg);
358  return;
359  }
360 
361  port = codec->chregs.regs.ac97write;
362 
363  if (snd_ali_codec_ready(codec, port) < 0)
364  return;
365  if (snd_ali_stimer_ready(codec) < 0)
366  return;
367 
368  dwVal = (unsigned int) (reg & 0xff);
369  dwVal |= 0x8000 | (val << 16);
370  if (secondary)
371  dwVal |= 0x0080;
372  if (codec->revision == ALI_5451_V02)
373  dwVal |= 0x0100;
374 
375  snd_ali_5451_poke(codec, port, dwVal);
376 
377  return ;
378 }
379 
380 static unsigned short snd_ali_codec_peek(struct snd_ali *codec,
381  int secondary,
382  unsigned short reg)
383 {
384  unsigned int dwVal;
385  unsigned int port;
386 
387  if (reg >= 0x80) {
388  snd_printk(KERN_ERR "ali_codec_peek: reg(%xh) invalid.\n", reg);
389  return ~0;
390  }
391 
392  port = codec->chregs.regs.ac97read;
393 
394  if (snd_ali_codec_ready(codec, port) < 0)
395  return ~0;
396  if (snd_ali_stimer_ready(codec) < 0)
397  return ~0;
398 
399  dwVal = (unsigned int) (reg & 0xff);
400  dwVal |= 0x8000; /* bit 15*/
401  if (secondary)
402  dwVal |= 0x0080;
403 
404  snd_ali_5451_poke(codec, port, dwVal);
405 
406  if (snd_ali_stimer_ready(codec) < 0)
407  return ~0;
408  if (snd_ali_codec_ready(codec, port) < 0)
409  return ~0;
410 
411  return (snd_ali_5451_peek(codec, port) & 0xffff0000) >> 16;
412 }
413 
414 static void snd_ali_codec_write(struct snd_ac97 *ac97,
415  unsigned short reg,
416  unsigned short val )
417 {
418  struct snd_ali *codec = ac97->private_data;
419 
420  snd_ali_printk("codec_write: reg=%xh data=%xh.\n", reg, val);
421  if (reg == AC97_GPIO_STATUS) {
422  outl((val << ALI_AC97_GPIO_DATA_SHIFT) | ALI_AC97_GPIO_ENABLE,
423  ALI_REG(codec, ALI_AC97_GPIO));
424  return;
425  }
426  snd_ali_codec_poke(codec, ac97->num, reg, val);
427  return ;
428 }
429 
430 
431 static unsigned short snd_ali_codec_read(struct snd_ac97 *ac97,
432  unsigned short reg)
433 {
434  struct snd_ali *codec = ac97->private_data;
435 
436  snd_ali_printk("codec_read reg=%xh.\n", reg);
437  return snd_ali_codec_peek(codec, ac97->num, reg);
438 }
439 
440 /*
441  * AC97 Reset
442  */
443 
444 static int snd_ali_reset_5451(struct snd_ali *codec)
445 {
446  struct pci_dev *pci_dev;
447  unsigned short wCount, wReg;
448  unsigned int dwVal;
449 
450  pci_dev = codec->pci_m1533;
451  if (pci_dev) {
452  pci_read_config_dword(pci_dev, 0x7c, &dwVal);
453  pci_write_config_dword(pci_dev, 0x7c, dwVal | 0x08000000);
454  udelay(5000);
455  pci_read_config_dword(pci_dev, 0x7c, &dwVal);
456  pci_write_config_dword(pci_dev, 0x7c, dwVal & 0xf7ffffff);
457  udelay(5000);
458  }
459 
460  pci_dev = codec->pci;
461  pci_read_config_dword(pci_dev, 0x44, &dwVal);
462  pci_write_config_dword(pci_dev, 0x44, dwVal | 0x000c0000);
463  udelay(500);
464  pci_read_config_dword(pci_dev, 0x44, &dwVal);
465  pci_write_config_dword(pci_dev, 0x44, dwVal & 0xfffbffff);
466  udelay(5000);
467 
468  wCount = 200;
469  while(wCount--) {
470  wReg = snd_ali_codec_peek(codec, 0, AC97_POWERDOWN);
471  if ((wReg & 0x000f) == 0x000f)
472  return 0;
473  udelay(5000);
474  }
475 
476  /* non-fatal if you have a non PM capable codec */
477  /* snd_printk(KERN_WARNING "ali5451: reset time out\n"); */
478  return 0;
479 }
480 
481 /*
482  * ALI 5451 Controller
483  */
484 
485 static void snd_ali_enable_special_channel(struct snd_ali *codec,
486  unsigned int channel)
487 {
488  unsigned long dwVal;
489 
490  dwVal = inl(ALI_REG(codec, ALI_GLOBAL_CONTROL));
491  dwVal |= 1 << (channel & 0x0000001f);
492  outl(dwVal, ALI_REG(codec, ALI_GLOBAL_CONTROL));
493 }
494 
495 static void snd_ali_disable_special_channel(struct snd_ali *codec,
496  unsigned int channel)
497 {
498  unsigned long dwVal;
499 
500  dwVal = inl(ALI_REG(codec, ALI_GLOBAL_CONTROL));
501  dwVal &= ~(1 << (channel & 0x0000001f));
502  outl(dwVal, ALI_REG(codec, ALI_GLOBAL_CONTROL));
503 }
504 
505 static void snd_ali_enable_address_interrupt(struct snd_ali *codec)
506 {
507  unsigned int gc;
508 
509  gc = inl(ALI_REG(codec, ALI_GC_CIR));
510  gc |= ENDLP_IE;
511  gc |= MIDLP_IE;
512  outl( gc, ALI_REG(codec, ALI_GC_CIR));
513 }
514 
515 static void snd_ali_disable_address_interrupt(struct snd_ali *codec)
516 {
517  unsigned int gc;
518 
519  gc = inl(ALI_REG(codec, ALI_GC_CIR));
520  gc &= ~ENDLP_IE;
521  gc &= ~MIDLP_IE;
522  outl(gc, ALI_REG(codec, ALI_GC_CIR));
523 }
524 
525 static void snd_ali_disable_voice_irq(struct snd_ali *codec,
526  unsigned int channel)
527 {
528  unsigned int mask;
529  struct snd_ali_channel_control *pchregs = &(codec->chregs);
530 
531  snd_ali_printk("disable_voice_irq channel=%d\n",channel);
532 
533  mask = 1 << (channel & 0x1f);
534  pchregs->data.ainten = inl(ALI_REG(codec, pchregs->regs.ainten));
535  pchregs->data.ainten &= ~mask;
536  outl(pchregs->data.ainten, ALI_REG(codec, pchregs->regs.ainten));
537 }
538 
539 static int snd_ali_alloc_pcm_channel(struct snd_ali *codec, int channel)
540 {
541  unsigned int idx = channel & 0x1f;
542 
543  if (codec->synth.chcnt >= ALI_CHANNELS){
544  snd_printk(KERN_ERR
545  "ali_alloc_pcm_channel: no free channels.\n");
546  return -1;
547  }
548 
549  if (!(codec->synth.chmap & (1 << idx))) {
550  codec->synth.chmap |= 1 << idx;
551  codec->synth.chcnt++;
552  snd_ali_printk("alloc_pcm_channel no. %d.\n",idx);
553  return idx;
554  }
555  return -1;
556 }
557 
558 static int snd_ali_find_free_channel(struct snd_ali * codec, int rec)
559 {
560  int idx;
561  int result = -1;
562 
563  snd_ali_printk("find_free_channel: for %s\n",rec ? "rec" : "pcm");
564 
565  /* recording */
566  if (rec) {
567  if (codec->spdif_support &&
568  (inl(ALI_REG(codec, ALI_GLOBAL_CONTROL)) &
569  ALI_SPDIF_IN_SUPPORT))
570  idx = ALI_SPDIF_IN_CHANNEL;
571  else
572  idx = ALI_PCM_IN_CHANNEL;
573 
574  result = snd_ali_alloc_pcm_channel(codec, idx);
575  if (result >= 0)
576  return result;
577  else {
578  snd_printk(KERN_ERR "ali_find_free_channel: "
579  "record channel is busy now.\n");
580  return -1;
581  }
582  }
583 
584  /* playback... */
585  if (codec->spdif_support &&
586  (inl(ALI_REG(codec, ALI_GLOBAL_CONTROL)) &
587  ALI_SPDIF_OUT_CH_ENABLE)) {
588  idx = ALI_SPDIF_OUT_CHANNEL;
589  result = snd_ali_alloc_pcm_channel(codec, idx);
590  if (result >= 0)
591  return result;
592  else
593  snd_printk(KERN_ERR "ali_find_free_channel: "
594  "S/PDIF out channel is in busy now.\n");
595  }
596 
597  for (idx = 0; idx < ALI_CHANNELS; idx++) {
598  result = snd_ali_alloc_pcm_channel(codec, idx);
599  if (result >= 0)
600  return result;
601  }
602  snd_printk(KERN_ERR "ali_find_free_channel: no free channels.\n");
603  return -1;
604 }
605 
606 static void snd_ali_free_channel_pcm(struct snd_ali *codec, int channel)
607 {
608  unsigned int idx = channel & 0x0000001f;
609 
610  snd_ali_printk("free_channel_pcm channel=%d\n",channel);
611 
612  if (channel < 0 || channel >= ALI_CHANNELS)
613  return;
614 
615  if (!(codec->synth.chmap & (1 << idx))) {
616  snd_printk(KERN_ERR "ali_free_channel_pcm: "
617  "channel %d is not in use.\n", channel);
618  return;
619  } else {
620  codec->synth.chmap &= ~(1 << idx);
621  codec->synth.chcnt--;
622  }
623 }
624 
625 static void snd_ali_stop_voice(struct snd_ali *codec, unsigned int channel)
626 {
627  unsigned int mask = 1 << (channel & 0x1f);
628 
629  snd_ali_printk("stop_voice: channel=%d\n",channel);
630  outl(mask, ALI_REG(codec, codec->chregs.regs.stop));
631 }
632 
633 /*
634  * S/PDIF Part
635  */
636 
637 static void snd_ali_delay(struct snd_ali *codec,int interval)
638 {
639  unsigned long begintimer,currenttimer;
640 
641  begintimer = inl(ALI_REG(codec, ALI_STIMER));
642  currenttimer = inl(ALI_REG(codec, ALI_STIMER));
643 
644  while (currenttimer < begintimer + interval) {
645  if (snd_ali_stimer_ready(codec) < 0)
646  break;
647  currenttimer = inl(ALI_REG(codec, ALI_STIMER));
648  cpu_relax();
649  }
650 }
651 
652 static void snd_ali_detect_spdif_rate(struct snd_ali *codec)
653 {
654  u16 wval;
655  u16 count = 0;
656  u8 bval, R1 = 0, R2;
657 
658  bval = inb(ALI_REG(codec, ALI_SPDIF_CTRL + 1));
659  bval |= 0x1F;
660  outb(bval, ALI_REG(codec, ALI_SPDIF_CTRL + 1));
661 
662  while ((R1 < 0x0b || R1 > 0x0e) && R1 != 0x12 && count <= 50000) {
663  count ++;
664  snd_ali_delay(codec, 6);
665  bval = inb(ALI_REG(codec, ALI_SPDIF_CTRL + 1));
666  R1 = bval & 0x1F;
667  }
668 
669  if (count > 50000) {
670  snd_printk(KERN_ERR "ali_detect_spdif_rate: timeout!\n");
671  return;
672  }
673 
674  for (count = 0; count <= 50000; count++) {
675  snd_ali_delay(codec, 6);
676  bval = inb(ALI_REG(codec,ALI_SPDIF_CTRL + 1));
677  R2 = bval & 0x1F;
678  if (R2 != R1)
679  R1 = R2;
680  else
681  break;
682  }
683 
684  if (count > 50000) {
685  snd_printk(KERN_ERR "ali_detect_spdif_rate: timeout!\n");
686  return;
687  }
688 
689  if (R2 >= 0x0b && R2 <= 0x0e) {
690  wval = inw(ALI_REG(codec, ALI_SPDIF_CTRL + 2));
691  wval &= 0xe0f0;
692  wval |= (0x09 << 8) | 0x05;
693  outw(wval, ALI_REG(codec, ALI_SPDIF_CTRL + 2));
694 
695  bval = inb(ALI_REG(codec, ALI_SPDIF_CS + 3)) & 0xf0;
696  outb(bval | 0x02, ALI_REG(codec, ALI_SPDIF_CS + 3));
697  } else if (R2 == 0x12) {
698  wval = inw(ALI_REG(codec, ALI_SPDIF_CTRL + 2));
699  wval &= 0xe0f0;
700  wval |= (0x0e << 8) | 0x08;
701  outw(wval, ALI_REG(codec, ALI_SPDIF_CTRL + 2));
702 
703  bval = inb(ALI_REG(codec,ALI_SPDIF_CS + 3)) & 0xf0;
704  outb(bval | 0x03, ALI_REG(codec, ALI_SPDIF_CS + 3));
705  }
706 }
707 
708 static unsigned int snd_ali_get_spdif_in_rate(struct snd_ali *codec)
709 {
710  u32 dwRate;
711  u8 bval;
712 
713  bval = inb(ALI_REG(codec, ALI_SPDIF_CTRL));
714  bval &= 0x7f;
715  bval |= 0x40;
716  outb(bval, ALI_REG(codec, ALI_SPDIF_CTRL));
717 
718  snd_ali_detect_spdif_rate(codec);
719 
720  bval = inb(ALI_REG(codec, ALI_SPDIF_CS + 3));
721  bval &= 0x0f;
722 
723  switch (bval) {
724  case 0: dwRate = 44100; break;
725  case 1: dwRate = 48000; break;
726  case 2: dwRate = 32000; break;
727  default: dwRate = 0; break;
728  }
729 
730  return dwRate;
731 }
732 
733 static void snd_ali_enable_spdif_in(struct snd_ali *codec)
734 {
735  unsigned int dwVal;
736 
737  dwVal = inl(ALI_REG(codec, ALI_GLOBAL_CONTROL));
738  dwVal |= ALI_SPDIF_IN_SUPPORT;
739  outl(dwVal, ALI_REG(codec, ALI_GLOBAL_CONTROL));
740 
741  dwVal = inb(ALI_REG(codec, ALI_SPDIF_CTRL));
742  dwVal |= 0x02;
743  outb(dwVal, ALI_REG(codec, ALI_SPDIF_CTRL));
744 
745  snd_ali_enable_special_channel(codec, ALI_SPDIF_IN_CHANNEL);
746 }
747 
748 static void snd_ali_disable_spdif_in(struct snd_ali *codec)
749 {
750  unsigned int dwVal;
751 
752  dwVal = inl(ALI_REG(codec, ALI_GLOBAL_CONTROL));
753  dwVal &= ~ALI_SPDIF_IN_SUPPORT;
754  outl(dwVal, ALI_REG(codec, ALI_GLOBAL_CONTROL));
755 
756  snd_ali_disable_special_channel(codec, ALI_SPDIF_IN_CHANNEL);
757 }
758 
759 
760 static void snd_ali_set_spdif_out_rate(struct snd_ali *codec, unsigned int rate)
761 {
762  unsigned char bVal;
763  unsigned int dwRate;
764 
765  switch (rate) {
766  case 32000: dwRate = 0x300; break;
767  case 48000: dwRate = 0x200; break;
768  default: dwRate = 0; break;
769  }
770 
771  bVal = inb(ALI_REG(codec, ALI_SPDIF_CTRL));
772  bVal &= (unsigned char)(~(1<<6));
773 
774  bVal |= 0x80; /* select right */
775  outb(bVal, ALI_REG(codec, ALI_SPDIF_CTRL));
776  outb(dwRate | 0x20, ALI_REG(codec, ALI_SPDIF_CS + 2));
777 
778  bVal &= ~0x80; /* select left */
779  outb(bVal, ALI_REG(codec, ALI_SPDIF_CTRL));
780  outw(rate | 0x10, ALI_REG(codec, ALI_SPDIF_CS + 2));
781 }
782 
783 static void snd_ali_enable_spdif_out(struct snd_ali *codec)
784 {
785  unsigned short wVal;
786  unsigned char bVal;
787  struct pci_dev *pci_dev;
788 
789  pci_dev = codec->pci_m1533;
790  if (pci_dev == NULL)
791  return;
792  pci_read_config_byte(pci_dev, 0x61, &bVal);
793  bVal |= 0x40;
794  pci_write_config_byte(pci_dev, 0x61, bVal);
795  pci_read_config_byte(pci_dev, 0x7d, &bVal);
796  bVal |= 0x01;
797  pci_write_config_byte(pci_dev, 0x7d, bVal);
798 
799  pci_read_config_byte(pci_dev, 0x7e, &bVal);
800  bVal &= (~0x20);
801  bVal |= 0x10;
802  pci_write_config_byte(pci_dev, 0x7e, bVal);
803 
804  bVal = inb(ALI_REG(codec, ALI_SCTRL));
805  outb(bVal | ALI_SPDIF_OUT_ENABLE, ALI_REG(codec, ALI_SCTRL));
806 
807  bVal = inb(ALI_REG(codec, ALI_SPDIF_CTRL));
808  outb(bVal & ALI_SPDIF_OUT_CH_STATUS, ALI_REG(codec, ALI_SPDIF_CTRL));
809 
810  wVal = inw(ALI_REG(codec, ALI_GLOBAL_CONTROL));
811  wVal |= ALI_SPDIF_OUT_SEL_PCM;
812  outw(wVal, ALI_REG(codec, ALI_GLOBAL_CONTROL));
813  snd_ali_disable_special_channel(codec, ALI_SPDIF_OUT_CHANNEL);
814 }
815 
816 static void snd_ali_enable_spdif_chnout(struct snd_ali *codec)
817 {
818  unsigned short wVal;
819 
820  wVal = inw(ALI_REG(codec, ALI_GLOBAL_CONTROL));
821  wVal &= ~ALI_SPDIF_OUT_SEL_PCM;
822  outw(wVal, ALI_REG(codec, ALI_GLOBAL_CONTROL));
823 /*
824  wVal = inw(ALI_REG(codec, ALI_SPDIF_CS));
825  if (flag & ALI_SPDIF_OUT_NON_PCM)
826  wVal |= 0x0002;
827  else
828  wVal &= (~0x0002);
829  outw(wVal, ALI_REG(codec, ALI_SPDIF_CS));
830 */
831  snd_ali_enable_special_channel(codec, ALI_SPDIF_OUT_CHANNEL);
832 }
833 
834 static void snd_ali_disable_spdif_chnout(struct snd_ali *codec)
835 {
836  unsigned short wVal;
837 
838  wVal = inw(ALI_REG(codec, ALI_GLOBAL_CONTROL));
839  wVal |= ALI_SPDIF_OUT_SEL_PCM;
840  outw(wVal, ALI_REG(codec, ALI_GLOBAL_CONTROL));
841 
842  snd_ali_enable_special_channel(codec, ALI_SPDIF_OUT_CHANNEL);
843 }
844 
845 static void snd_ali_disable_spdif_out(struct snd_ali *codec)
846 {
847  unsigned char bVal;
848 
849  bVal = inb(ALI_REG(codec, ALI_SCTRL));
850  outb(bVal & ~ALI_SPDIF_OUT_ENABLE, ALI_REG(codec, ALI_SCTRL));
851 
852  snd_ali_disable_spdif_chnout(codec);
853 }
854 
855 static void snd_ali_update_ptr(struct snd_ali *codec, int channel)
856 {
857  struct snd_ali_voice *pvoice;
858  struct snd_pcm_runtime *runtime;
859  struct snd_ali_channel_control *pchregs;
860  unsigned int old, mask;
861 #ifdef ALI_DEBUG
862  unsigned int temp, cspf;
863 #endif
864 
865  pchregs = &(codec->chregs);
866 
867  /* check if interrupt occurred for channel */
868  old = pchregs->data.aint;
869  mask = 1U << (channel & 0x1f);
870 
871  if (!(old & mask))
872  return;
873 
874  pvoice = &codec->synth.voices[channel];
875  runtime = pvoice->substream->runtime;
876 
877  udelay(100);
878  spin_lock(&codec->reg_lock);
879 
880  if (pvoice->pcm && pvoice->substream) {
881  /* pcm interrupt */
882 #ifdef ALI_DEBUG
883  outb((u8)(pvoice->number), ALI_REG(codec, ALI_GC_CIR));
884  temp = inw(ALI_REG(codec, ALI_CSO_ALPHA_FMS + 2));
885  cspf = (inl(ALI_REG(codec, ALI_CSPF)) & mask) == mask;
886 #endif
887  if (pvoice->running) {
888  snd_ali_printk("update_ptr: cso=%4.4x cspf=%d.\n",
889  (u16)temp, cspf);
890  spin_unlock(&codec->reg_lock);
891  snd_pcm_period_elapsed(pvoice->substream);
892  spin_lock(&codec->reg_lock);
893  } else {
894  snd_ali_stop_voice(codec, channel);
895  snd_ali_disable_voice_irq(codec, channel);
896  }
897  } else if (codec->synth.voices[channel].synth) {
898  /* synth interrupt */
899  } else if (codec->synth.voices[channel].midi) {
900  /* midi interrupt */
901  } else {
902  /* unknown interrupt */
903  snd_ali_stop_voice(codec, channel);
904  snd_ali_disable_voice_irq(codec, channel);
905  }
906  spin_unlock(&codec->reg_lock);
907  outl(mask,ALI_REG(codec,pchregs->regs.aint));
908  pchregs->data.aint = old & (~mask);
909 }
910 
911 static irqreturn_t snd_ali_card_interrupt(int irq, void *dev_id)
912 {
913  struct snd_ali *codec = dev_id;
914  int channel;
915  unsigned int audio_int;
916  struct snd_ali_channel_control *pchregs;
917 
918  if (codec == NULL || !codec->hw_initialized)
919  return IRQ_NONE;
920 
921  audio_int = inl(ALI_REG(codec, ALI_MISCINT));
922  if (!audio_int)
923  return IRQ_NONE;
924 
925  pchregs = &(codec->chregs);
926  if (audio_int & ADDRESS_IRQ) {
927  /* get interrupt status for all channels */
928  pchregs->data.aint = inl(ALI_REG(codec, pchregs->regs.aint));
929  for (channel = 0; channel < ALI_CHANNELS; channel++)
930  snd_ali_update_ptr(codec, channel);
931  }
932  outl((TARGET_REACHED | MIXER_OVERFLOW | MIXER_UNDERFLOW),
933  ALI_REG(codec, ALI_MISCINT));
934 
935  return IRQ_HANDLED;
936 }
937 
938 
939 static struct snd_ali_voice *snd_ali_alloc_voice(struct snd_ali * codec,
940  int type, int rec, int channel)
941 {
942  struct snd_ali_voice *pvoice;
943  int idx;
944 
945  snd_ali_printk("alloc_voice: type=%d rec=%d\n", type, rec);
946 
947  spin_lock_irq(&codec->voice_alloc);
948  if (type == SNDRV_ALI_VOICE_TYPE_PCM) {
949  idx = channel > 0 ? snd_ali_alloc_pcm_channel(codec, channel) :
950  snd_ali_find_free_channel(codec,rec);
951  if (idx < 0) {
952  snd_printk(KERN_ERR "ali_alloc_voice: err.\n");
953  spin_unlock_irq(&codec->voice_alloc);
954  return NULL;
955  }
956  pvoice = &(codec->synth.voices[idx]);
957  pvoice->codec = codec;
958  pvoice->use = 1;
959  pvoice->pcm = 1;
960  pvoice->mode = rec;
961  spin_unlock_irq(&codec->voice_alloc);
962  return pvoice;
963  }
964  spin_unlock_irq(&codec->voice_alloc);
965  return NULL;
966 }
967 
968 
969 static void snd_ali_free_voice(struct snd_ali * codec,
970  struct snd_ali_voice *pvoice)
971 {
972  void (*private_free)(void *);
973  void *private_data;
974 
975  snd_ali_printk("free_voice: channel=%d\n",pvoice->number);
976  if (!pvoice->use)
977  return;
978  snd_ali_clear_voices(codec, pvoice->number, pvoice->number);
979  spin_lock_irq(&codec->voice_alloc);
980  private_free = pvoice->private_free;
981  private_data = pvoice->private_data;
982  pvoice->private_free = NULL;
983  pvoice->private_data = NULL;
984  if (pvoice->pcm)
985  snd_ali_free_channel_pcm(codec, pvoice->number);
986  pvoice->use = pvoice->pcm = pvoice->synth = 0;
987  pvoice->substream = NULL;
988  spin_unlock_irq(&codec->voice_alloc);
989  if (private_free)
990  private_free(private_data);
991 }
992 
993 
994 static void snd_ali_clear_voices(struct snd_ali *codec,
995  unsigned int v_min,
996  unsigned int v_max)
997 {
998  unsigned int i;
999 
1000  for (i = v_min; i <= v_max; i++) {
1001  snd_ali_stop_voice(codec, i);
1002  snd_ali_disable_voice_irq(codec, i);
1003  }
1004 }
1005 
1006 static void snd_ali_write_voice_regs(struct snd_ali *codec,
1007  unsigned int Channel,
1008  unsigned int LBA,
1009  unsigned int CSO,
1010  unsigned int ESO,
1011  unsigned int DELTA,
1012  unsigned int ALPHA_FMS,
1013  unsigned int GVSEL,
1014  unsigned int PAN,
1015  unsigned int VOL,
1016  unsigned int CTRL,
1017  unsigned int EC)
1018 {
1019  unsigned int ctlcmds[4];
1020 
1021  outb((unsigned char)(Channel & 0x001f), ALI_REG(codec, ALI_GC_CIR));
1022 
1023  ctlcmds[0] = (CSO << 16) | (ALPHA_FMS & 0x0000ffff);
1024  ctlcmds[1] = LBA;
1025  ctlcmds[2] = (ESO << 16) | (DELTA & 0x0ffff);
1026  ctlcmds[3] = (GVSEL << 31) |
1027  ((PAN & 0x0000007f) << 24) |
1028  ((VOL & 0x000000ff) << 16) |
1029  ((CTRL & 0x0000000f) << 12) |
1030  (EC & 0x00000fff);
1031 
1032  outb(Channel, ALI_REG(codec, ALI_GC_CIR));
1033 
1034  outl(ctlcmds[0], ALI_REG(codec, ALI_CSO_ALPHA_FMS));
1035  outl(ctlcmds[1], ALI_REG(codec, ALI_LBA));
1036  outl(ctlcmds[2], ALI_REG(codec, ALI_ESO_DELTA));
1037  outl(ctlcmds[3], ALI_REG(codec, ALI_GVSEL_PAN_VOC_CTRL_EC));
1038 
1039  outl(0x30000000, ALI_REG(codec, ALI_EBUF1)); /* Still Mode */
1040  outl(0x30000000, ALI_REG(codec, ALI_EBUF2)); /* Still Mode */
1041 }
1042 
1043 static unsigned int snd_ali_convert_rate(unsigned int rate, int rec)
1044 {
1045  unsigned int delta;
1046 
1047  if (rate < 4000)
1048  rate = 4000;
1049  if (rate > 48000)
1050  rate = 48000;
1051 
1052  if (rec) {
1053  if (rate == 44100)
1054  delta = 0x116a;
1055  else if (rate == 8000)
1056  delta = 0x6000;
1057  else if (rate == 48000)
1058  delta = 0x1000;
1059  else
1060  delta = ((48000 << 12) / rate) & 0x0000ffff;
1061  } else {
1062  if (rate == 44100)
1063  delta = 0xeb3;
1064  else if (rate == 8000)
1065  delta = 0x2ab;
1066  else if (rate == 48000)
1067  delta = 0x1000;
1068  else
1069  delta = (((rate << 12) + rate) / 48000) & 0x0000ffff;
1070  }
1071 
1072  return delta;
1073 }
1074 
1075 static unsigned int snd_ali_control_mode(struct snd_pcm_substream *substream)
1076 {
1077  unsigned int CTRL;
1078  struct snd_pcm_runtime *runtime = substream->runtime;
1079 
1080  /* set ctrl mode
1081  CTRL default: 8-bit (unsigned) mono, loop mode enabled
1082  */
1083  CTRL = 0x00000001;
1084  if (snd_pcm_format_width(runtime->format) == 16)
1085  CTRL |= 0x00000008; /* 16-bit data */
1086  if (!snd_pcm_format_unsigned(runtime->format))
1087  CTRL |= 0x00000002; /* signed data */
1088  if (runtime->channels > 1)
1089  CTRL |= 0x00000004; /* stereo data */
1090  return CTRL;
1091 }
1092 
1093 /*
1094  * PCM part
1095  */
1096 
1097 static int snd_ali_trigger(struct snd_pcm_substream *substream,
1098  int cmd)
1099 
1100 {
1101  struct snd_ali *codec = snd_pcm_substream_chip(substream);
1102  struct snd_pcm_substream *s;
1103  unsigned int what, whati, capture_flag;
1104  struct snd_ali_voice *pvoice, *evoice;
1105  unsigned int val;
1106  int do_start;
1107 
1108  switch (cmd) {
1109  case SNDRV_PCM_TRIGGER_START:
1110  case SNDRV_PCM_TRIGGER_RESUME:
1111  do_start = 1;
1112  break;
1113  case SNDRV_PCM_TRIGGER_STOP:
1114  case SNDRV_PCM_TRIGGER_SUSPEND:
1115  do_start = 0;
1116  break;
1117  default:
1118  return -EINVAL;
1119  }
1120 
1121  what = whati = capture_flag = 0;
1122  snd_pcm_group_for_each_entry(s, substream) {
1123  if ((struct snd_ali *) snd_pcm_substream_chip(s) == codec) {
1124  pvoice = s->runtime->private_data;
1125  evoice = pvoice->extra;
1126  what |= 1 << (pvoice->number & 0x1f);
1127  if (evoice == NULL)
1128  whati |= 1 << (pvoice->number & 0x1f);
1129  else {
1130  whati |= 1 << (evoice->number & 0x1f);
1131  what |= 1 << (evoice->number & 0x1f);
1132  }
1133  if (do_start) {
1134  pvoice->running = 1;
1135  if (evoice != NULL)
1136  evoice->running = 1;
1137  } else {
1138  pvoice->running = 0;
1139  if (evoice != NULL)
1140  evoice->running = 0;
1141  }
1142  snd_pcm_trigger_done(s, substream);
1143  if (pvoice->mode)
1144  capture_flag = 1;
1145  }
1146  }
1147  spin_lock(&codec->reg_lock);
1148  if (!do_start)
1149  outl(what, ALI_REG(codec, ALI_STOP));
1150  val = inl(ALI_REG(codec, ALI_AINTEN));
1151  if (do_start)
1152  val |= whati;
1153  else
1154  val &= ~whati;
1155  outl(val, ALI_REG(codec, ALI_AINTEN));
1156  if (do_start)
1157  outl(what, ALI_REG(codec, ALI_START));
1158  snd_ali_printk("trigger: what=%xh whati=%xh\n", what, whati);
1159  spin_unlock(&codec->reg_lock);
1160 
1161  return 0;
1162 }
1163 
1164 static int snd_ali_playback_hw_params(struct snd_pcm_substream *substream,
1165  struct snd_pcm_hw_params *hw_params)
1166 {
1167  struct snd_ali *codec = snd_pcm_substream_chip(substream);
1168  struct snd_pcm_runtime *runtime = substream->runtime;
1169  struct snd_ali_voice *pvoice = runtime->private_data;
1170  struct snd_ali_voice *evoice = pvoice->extra;
1171  int err;
1172 
1173  err = snd_pcm_lib_malloc_pages(substream,
1174  params_buffer_bytes(hw_params));
1175  if (err < 0)
1176  return err;
1177 
1178  /* voice management */
1179 
1180  if (params_buffer_size(hw_params) / 2 !=
1181  params_period_size(hw_params)) {
1182  if (!evoice) {
1183  evoice = snd_ali_alloc_voice(codec,
1184  SNDRV_ALI_VOICE_TYPE_PCM,
1185  0, -1);
1186  if (!evoice)
1187  return -ENOMEM;
1188  pvoice->extra = evoice;
1189  evoice->substream = substream;
1190  }
1191  } else {
1192  if (evoice) {
1193  snd_ali_free_voice(codec, evoice);
1194  pvoice->extra = evoice = NULL;
1195  }
1196  }
1197 
1198  return 0;
1199 }
1200 
1201 static int snd_ali_playback_hw_free(struct snd_pcm_substream *substream)
1202 {
1203  struct snd_ali *codec = snd_pcm_substream_chip(substream);
1204  struct snd_pcm_runtime *runtime = substream->runtime;
1205  struct snd_ali_voice *pvoice = runtime->private_data;
1206  struct snd_ali_voice *evoice = pvoice ? pvoice->extra : NULL;
1207 
1208  snd_pcm_lib_free_pages(substream);
1209  if (evoice) {
1210  snd_ali_free_voice(codec, evoice);
1211  pvoice->extra = NULL;
1212  }
1213  return 0;
1214 }
1215 
1216 static int snd_ali_hw_params(struct snd_pcm_substream *substream,
1217  struct snd_pcm_hw_params *hw_params)
1218 {
1219  return snd_pcm_lib_malloc_pages(substream,
1220  params_buffer_bytes(hw_params));
1221 }
1222 
1223 static int snd_ali_hw_free(struct snd_pcm_substream *substream)
1224 {
1225  return snd_pcm_lib_free_pages(substream);
1226 }
1227 
1228 static int snd_ali_playback_prepare(struct snd_pcm_substream *substream)
1229 {
1230  struct snd_ali *codec = snd_pcm_substream_chip(substream);
1231  struct snd_pcm_runtime *runtime = substream->runtime;
1232  struct snd_ali_voice *pvoice = runtime->private_data;
1233  struct snd_ali_voice *evoice = pvoice->extra;
1234 
1235  unsigned int LBA;
1236  unsigned int Delta;
1237  unsigned int ESO;
1238  unsigned int CTRL;
1239  unsigned int GVSEL;
1240  unsigned int PAN;
1241  unsigned int VOL;
1242  unsigned int EC;
1243 
1244  snd_ali_printk("playback_prepare ...\n");
1245 
1246  spin_lock_irq(&codec->reg_lock);
1247 
1248  /* set Delta (rate) value */
1249  Delta = snd_ali_convert_rate(runtime->rate, 0);
1250 
1251  if (pvoice->number == ALI_SPDIF_IN_CHANNEL ||
1252  pvoice->number == ALI_PCM_IN_CHANNEL)
1253  snd_ali_disable_special_channel(codec, pvoice->number);
1254  else if (codec->spdif_support &&
1255  (inl(ALI_REG(codec, ALI_GLOBAL_CONTROL)) &
1256  ALI_SPDIF_OUT_CH_ENABLE)
1257  && pvoice->number == ALI_SPDIF_OUT_CHANNEL) {
1258  snd_ali_set_spdif_out_rate(codec, runtime->rate);
1259  Delta = 0x1000;
1260  }
1261 
1262  /* set Loop Back Address */
1263  LBA = runtime->dma_addr;
1264 
1265  /* set interrupt count size */
1266  pvoice->count = runtime->period_size;
1267 
1268  /* set target ESO for channel */
1269  pvoice->eso = runtime->buffer_size;
1270 
1271  snd_ali_printk("playback_prepare: eso=%xh count=%xh\n",
1272  pvoice->eso, pvoice->count);
1273 
1274  /* set ESO to capture first MIDLP interrupt */
1275  ESO = pvoice->eso -1;
1276  /* set ctrl mode */
1277  CTRL = snd_ali_control_mode(substream);
1278 
1279  GVSEL = 1;
1280  PAN = 0;
1281  VOL = 0;
1282  EC = 0;
1283  snd_ali_printk("playback_prepare:\n");
1284  snd_ali_printk("ch=%d, Rate=%d Delta=%xh,GVSEL=%xh,PAN=%xh,CTRL=%xh\n",
1285  pvoice->number,runtime->rate,Delta,GVSEL,PAN,CTRL);
1286  snd_ali_write_voice_regs(codec,
1287  pvoice->number,
1288  LBA,
1289  0, /* cso */
1290  ESO,
1291  Delta,
1292  0, /* alpha */
1293  GVSEL,
1294  PAN,
1295  VOL,
1296  CTRL,
1297  EC);
1298  if (evoice) {
1299  evoice->count = pvoice->count;
1300  evoice->eso = pvoice->count << 1;
1301  ESO = evoice->eso - 1;
1302  snd_ali_write_voice_regs(codec,
1303  evoice->number,
1304  LBA,
1305  0, /* cso */
1306  ESO,
1307  Delta,
1308  0, /* alpha */
1309  GVSEL,
1310  0x7f,
1311  0x3ff,
1312  CTRL,
1313  EC);
1314  }
1315  spin_unlock_irq(&codec->reg_lock);
1316  return 0;
1317 }
1318 
1319 
1320 static int snd_ali_prepare(struct snd_pcm_substream *substream)
1321 {
1322  struct snd_ali *codec = snd_pcm_substream_chip(substream);
1323  struct snd_pcm_runtime *runtime = substream->runtime;
1324  struct snd_ali_voice *pvoice = runtime->private_data;
1325  unsigned int LBA;
1326  unsigned int Delta;
1327  unsigned int ESO;
1328  unsigned int CTRL;
1329  unsigned int GVSEL;
1330  unsigned int PAN;
1331  unsigned int VOL;
1332  unsigned int EC;
1333  u8 bValue;
1334 
1335  spin_lock_irq(&codec->reg_lock);
1336 
1337  snd_ali_printk("ali_prepare...\n");
1338 
1339  snd_ali_enable_special_channel(codec,pvoice->number);
1340 
1341  Delta = (pvoice->number == ALI_MODEM_IN_CHANNEL ||
1342  pvoice->number == ALI_MODEM_OUT_CHANNEL) ?
1343  0x1000 : snd_ali_convert_rate(runtime->rate, pvoice->mode);
1344 
1345  /* Prepare capture intr channel */
1346  if (pvoice->number == ALI_SPDIF_IN_CHANNEL) {
1347 
1348  unsigned int rate;
1349 
1350  spin_unlock_irq(&codec->reg_lock);
1351  if (codec->revision != ALI_5451_V02)
1352  return -1;
1353 
1354  rate = snd_ali_get_spdif_in_rate(codec);
1355  if (rate == 0) {
1356  snd_printk(KERN_WARNING "ali_capture_preapre: "
1357  "spdif rate detect err!\n");
1358  rate = 48000;
1359  }
1360  spin_lock_irq(&codec->reg_lock);
1361  bValue = inb(ALI_REG(codec,ALI_SPDIF_CTRL));
1362  if (bValue & 0x10) {
1363  outb(bValue,ALI_REG(codec,ALI_SPDIF_CTRL));
1364  printk(KERN_WARNING "clear SPDIF parity error flag.\n");
1365  }
1366 
1367  if (rate != 48000)
1368  Delta = ((rate << 12) / runtime->rate) & 0x00ffff;
1369  }
1370 
1371  /* set target ESO for channel */
1372  pvoice->eso = runtime->buffer_size;
1373 
1374  /* set interrupt count size */
1375  pvoice->count = runtime->period_size;
1376 
1377  /* set Loop Back Address */
1378  LBA = runtime->dma_addr;
1379 
1380  /* set ESO to capture first MIDLP interrupt */
1381  ESO = pvoice->eso - 1;
1382  CTRL = snd_ali_control_mode(substream);
1383  GVSEL = 0;
1384  PAN = 0x00;
1385  VOL = 0x00;
1386  EC = 0;
1387 
1388  snd_ali_write_voice_regs( codec,
1389  pvoice->number,
1390  LBA,
1391  0, /* cso */
1392  ESO,
1393  Delta,
1394  0, /* alpha */
1395  GVSEL,
1396  PAN,
1397  VOL,
1398  CTRL,
1399  EC);
1400 
1401  spin_unlock_irq(&codec->reg_lock);
1402 
1403  return 0;
1404 }
1405 
1406 
1407 static snd_pcm_uframes_t
1408 snd_ali_playback_pointer(struct snd_pcm_substream *substream)
1409 {
1410  struct snd_ali *codec = snd_pcm_substream_chip(substream);
1411  struct snd_pcm_runtime *runtime = substream->runtime;
1412  struct snd_ali_voice *pvoice = runtime->private_data;
1413  unsigned int cso;
1414 
1415  spin_lock(&codec->reg_lock);
1416  if (!pvoice->running) {
1417  spin_unlock(&codec->reg_lock);
1418  return 0;
1419  }
1420  outb(pvoice->number, ALI_REG(codec, ALI_GC_CIR));
1421  cso = inw(ALI_REG(codec, ALI_CSO_ALPHA_FMS + 2));
1422  spin_unlock(&codec->reg_lock);
1423  snd_ali_printk("playback pointer returned cso=%xh.\n", cso);
1424 
1425  return cso;
1426 }
1427 
1428 
1429 static snd_pcm_uframes_t snd_ali_pointer(struct snd_pcm_substream *substream)
1430 {
1431  struct snd_ali *codec = snd_pcm_substream_chip(substream);
1432  struct snd_pcm_runtime *runtime = substream->runtime;
1433  struct snd_ali_voice *pvoice = runtime->private_data;
1434  unsigned int cso;
1435 
1436  spin_lock(&codec->reg_lock);
1437  if (!pvoice->running) {
1438  spin_unlock_irq(&codec->reg_lock);
1439  return 0;
1440  }
1441  outb(pvoice->number, ALI_REG(codec, ALI_GC_CIR));
1442  cso = inw(ALI_REG(codec, ALI_CSO_ALPHA_FMS + 2));
1443  spin_unlock(&codec->reg_lock);
1444 
1445  return cso;
1446 }
1447 
1448 static struct snd_pcm_hardware snd_ali_playback =
1449 {
1450  .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1451  SNDRV_PCM_INFO_BLOCK_TRANSFER |
1452  SNDRV_PCM_INFO_MMAP_VALID |
1453  SNDRV_PCM_INFO_RESUME |
1454  SNDRV_PCM_INFO_SYNC_START),
1455  .formats = (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE |
1456  SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE),
1457  .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
1458  .rate_min = 4000,
1459  .rate_max = 48000,
1460  .channels_min = 1,
1461  .channels_max = 2,
1462  .buffer_bytes_max = (256*1024),
1463  .period_bytes_min = 64,
1464  .period_bytes_max = (256*1024),
1465  .periods_min = 1,
1466  .periods_max = 1024,
1467  .fifo_size = 0,
1468 };
1469 
1470 /*
1471  * Capture support device description
1472  */
1473 
1474 static struct snd_pcm_hardware snd_ali_capture =
1475 {
1476  .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1477  SNDRV_PCM_INFO_BLOCK_TRANSFER |
1478  SNDRV_PCM_INFO_MMAP_VALID |
1479  SNDRV_PCM_INFO_RESUME |
1480  SNDRV_PCM_INFO_SYNC_START),
1481  .formats = (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE |
1482  SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE),
1483  .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
1484  .rate_min = 4000,
1485  .rate_max = 48000,
1486  .channels_min = 1,
1487  .channels_max = 2,
1488  .buffer_bytes_max = (128*1024),
1489  .period_bytes_min = 64,
1490  .period_bytes_max = (128*1024),
1491  .periods_min = 1,
1492  .periods_max = 1024,
1493  .fifo_size = 0,
1494 };
1495 
1496 static void snd_ali_pcm_free_substream(struct snd_pcm_runtime *runtime)
1497 {
1498  struct snd_ali_voice *pvoice = runtime->private_data;
1499  struct snd_ali *codec;
1500 
1501  if (pvoice) {
1502  codec = pvoice->codec;
1503  snd_ali_free_voice(pvoice->codec, pvoice);
1504  }
1505 }
1506 
1507 static int snd_ali_open(struct snd_pcm_substream *substream, int rec,
1508  int channel, struct snd_pcm_hardware *phw)
1509 {
1510  struct snd_ali *codec = snd_pcm_substream_chip(substream);
1511  struct snd_pcm_runtime *runtime = substream->runtime;
1512  struct snd_ali_voice *pvoice;
1513 
1514  pvoice = snd_ali_alloc_voice(codec, SNDRV_ALI_VOICE_TYPE_PCM, rec,
1515  channel);
1516  if (!pvoice)
1517  return -EAGAIN;
1518 
1519  pvoice->substream = substream;
1520  runtime->private_data = pvoice;
1521  runtime->private_free = snd_ali_pcm_free_substream;
1522 
1523  runtime->hw = *phw;
1524  snd_pcm_set_sync(substream);
1525  snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
1526  0, 64*1024);
1527  return 0;
1528 }
1529 
1530 static int snd_ali_playback_open(struct snd_pcm_substream *substream)
1531 {
1532  return snd_ali_open(substream, 0, -1, &snd_ali_playback);
1533 }
1534 
1535 static int snd_ali_capture_open(struct snd_pcm_substream *substream)
1536 {
1537  return snd_ali_open(substream, 1, -1, &snd_ali_capture);
1538 }
1539 
1540 static int snd_ali_playback_close(struct snd_pcm_substream *substream)
1541 {
1542  return 0;
1543 }
1544 
1545 static int snd_ali_close(struct snd_pcm_substream *substream)
1546 {
1547  struct snd_ali *codec = snd_pcm_substream_chip(substream);
1548  struct snd_ali_voice *pvoice = substream->runtime->private_data;
1549 
1550  snd_ali_disable_special_channel(codec,pvoice->number);
1551 
1552  return 0;
1553 }
1554 
1555 static struct snd_pcm_ops snd_ali_playback_ops = {
1556  .open = snd_ali_playback_open,
1557  .close = snd_ali_playback_close,
1558  .ioctl = snd_pcm_lib_ioctl,
1559  .hw_params = snd_ali_playback_hw_params,
1560  .hw_free = snd_ali_playback_hw_free,
1561  .prepare = snd_ali_playback_prepare,
1562  .trigger = snd_ali_trigger,
1563  .pointer = snd_ali_playback_pointer,
1564 };
1565 
1566 static struct snd_pcm_ops snd_ali_capture_ops = {
1567  .open = snd_ali_capture_open,
1568  .close = snd_ali_close,
1569  .ioctl = snd_pcm_lib_ioctl,
1570  .hw_params = snd_ali_hw_params,
1571  .hw_free = snd_ali_hw_free,
1572  .prepare = snd_ali_prepare,
1573  .trigger = snd_ali_trigger,
1574  .pointer = snd_ali_pointer,
1575 };
1576 
1577 /*
1578  * Modem PCM
1579  */
1580 
1581 static int snd_ali_modem_hw_params(struct snd_pcm_substream *substream,
1582  struct snd_pcm_hw_params *hw_params)
1583 {
1584  struct snd_ali *chip = snd_pcm_substream_chip(substream);
1585  unsigned int modem_num = chip->num_of_codecs - 1;
1586  snd_ac97_write(chip->ac97[modem_num], AC97_LINE1_RATE,
1587  params_rate(hw_params));
1588  snd_ac97_write(chip->ac97[modem_num], AC97_LINE1_LEVEL, 0);
1589  return snd_ali_hw_params(substream, hw_params);
1590 }
1591 
1592 static struct snd_pcm_hardware snd_ali_modem =
1593 {
1594  .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1595  SNDRV_PCM_INFO_BLOCK_TRANSFER |
1596  SNDRV_PCM_INFO_MMAP_VALID |
1597  SNDRV_PCM_INFO_RESUME |
1598  SNDRV_PCM_INFO_SYNC_START),
1599  .formats = SNDRV_PCM_FMTBIT_S16_LE,
1600  .rates = (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_8000 |
1601  SNDRV_PCM_RATE_16000),
1602  .rate_min = 8000,
1603  .rate_max = 16000,
1604  .channels_min = 1,
1605  .channels_max = 1,
1606  .buffer_bytes_max = (256*1024),
1607  .period_bytes_min = 64,
1608  .period_bytes_max = (256*1024),
1609  .periods_min = 1,
1610  .periods_max = 1024,
1611  .fifo_size = 0,
1612 };
1613 
1614 static int snd_ali_modem_open(struct snd_pcm_substream *substream, int rec,
1615  int channel)
1616 {
1617  static unsigned int rates[] = {8000, 9600, 12000, 16000};
1618  static struct snd_pcm_hw_constraint_list hw_constraint_rates = {
1619  .count = ARRAY_SIZE(rates),
1620  .list = rates,
1621  .mask = 0,
1622  };
1623  int err = snd_ali_open(substream, rec, channel, &snd_ali_modem);
1624 
1625  if (err)
1626  return err;
1627  return snd_pcm_hw_constraint_list(substream->runtime, 0,
1628  SNDRV_PCM_HW_PARAM_RATE, &hw_constraint_rates);
1629 }
1630 
1631 static int snd_ali_modem_playback_open(struct snd_pcm_substream *substream)
1632 {
1633  return snd_ali_modem_open(substream, 0, ALI_MODEM_OUT_CHANNEL);
1634 }
1635 
1636 static int snd_ali_modem_capture_open(struct snd_pcm_substream *substream)
1637 {
1638  return snd_ali_modem_open(substream, 1, ALI_MODEM_IN_CHANNEL);
1639 }
1640 
1641 static struct snd_pcm_ops snd_ali_modem_playback_ops = {
1642  .open = snd_ali_modem_playback_open,
1643  .close = snd_ali_close,
1644  .ioctl = snd_pcm_lib_ioctl,
1645  .hw_params = snd_ali_modem_hw_params,
1646  .hw_free = snd_ali_hw_free,
1647  .prepare = snd_ali_prepare,
1648  .trigger = snd_ali_trigger,
1649  .pointer = snd_ali_pointer,
1650 };
1651 
1652 static struct snd_pcm_ops snd_ali_modem_capture_ops = {
1653  .open = snd_ali_modem_capture_open,
1654  .close = snd_ali_close,
1655  .ioctl = snd_pcm_lib_ioctl,
1656  .hw_params = snd_ali_modem_hw_params,
1657  .hw_free = snd_ali_hw_free,
1658  .prepare = snd_ali_prepare,
1659  .trigger = snd_ali_trigger,
1660  .pointer = snd_ali_pointer,
1661 };
1662 
1663 
1664 struct ali_pcm_description {
1665  char *name;
1666  unsigned int playback_num;
1667  unsigned int capture_num;
1668  struct snd_pcm_ops *playback_ops;
1669  struct snd_pcm_ops *capture_ops;
1670  unsigned short class;
1671 };
1672 
1673 
1674 static void snd_ali_pcm_free(struct snd_pcm *pcm)
1675 {
1676  struct snd_ali *codec = pcm->private_data;
1677  codec->pcm[pcm->device] = NULL;
1678 }
1679 
1680 
1681 static int __devinit snd_ali_pcm(struct snd_ali * codec, int device,
1682  struct ali_pcm_description *desc)
1683 {
1684  struct snd_pcm *pcm;
1685  int err;
1686 
1687  err = snd_pcm_new(codec->card, desc->name, device,
1688  desc->playback_num, desc->capture_num, &pcm);
1689  if (err < 0) {
1690  snd_printk(KERN_ERR "snd_ali_pcm: err called snd_pcm_new.\n");
1691  return err;
1692  }
1693  pcm->private_data = codec;
1694  pcm->private_free = snd_ali_pcm_free;
1695  if (desc->playback_ops)
1696  snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
1697  desc->playback_ops);
1698  if (desc->capture_ops)
1699  snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
1700  desc->capture_ops);
1701 
1702  snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
1703  snd_dma_pci_data(codec->pci),
1704  64*1024, 128*1024);
1705 
1706  pcm->info_flags = 0;
1707  pcm->dev_class = desc->class;
1708  pcm->dev_subclass = SNDRV_PCM_SUBCLASS_GENERIC_MIX;
1709  strcpy(pcm->name, desc->name);
1710  codec->pcm[0] = pcm;
1711  return 0;
1712 }
1713 
1714 static struct ali_pcm_description ali_pcms[] = {
1715  { .name = "ALI 5451",
1716  .playback_num = ALI_CHANNELS,
1717  .capture_num = 1,
1718  .playback_ops = &snd_ali_playback_ops,
1719  .capture_ops = &snd_ali_capture_ops
1720  },
1721  { .name = "ALI 5451 modem",
1722  .playback_num = 1,
1723  .capture_num = 1,
1724  .playback_ops = &snd_ali_modem_playback_ops,
1725  .capture_ops = &snd_ali_modem_capture_ops,
1726  .class = SNDRV_PCM_CLASS_MODEM
1727  }
1728 };
1729 
1730 static int __devinit snd_ali_build_pcms(struct snd_ali *codec)
1731 {
1732  int i, err;
1733  for (i = 0; i < codec->num_of_codecs && i < ARRAY_SIZE(ali_pcms); i++) {
1734  err = snd_ali_pcm(codec, i, &ali_pcms[i]);
1735  if (err < 0)
1736  return err;
1737  }
1738  return 0;
1739 }
1740 
1741 
1742 #define ALI5451_SPDIF(xname, xindex, value) \
1743 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex,\
1744 .info = snd_ali5451_spdif_info, .get = snd_ali5451_spdif_get, \
1745 .put = snd_ali5451_spdif_put, .private_value = value}
1746 
1747 #define snd_ali5451_spdif_info snd_ctl_boolean_mono_info
1748 
1749 static int snd_ali5451_spdif_get(struct snd_kcontrol *kcontrol,
1750  struct snd_ctl_elem_value *ucontrol)
1751 {
1752  struct snd_ali *codec = kcontrol->private_data;
1753  unsigned int spdif_enable;
1754 
1755  spdif_enable = ucontrol->value.integer.value[0] ? 1 : 0;
1756 
1757  spin_lock_irq(&codec->reg_lock);
1758  switch (kcontrol->private_value) {
1759  case 0:
1760  spdif_enable = (codec->spdif_mask & 0x02) ? 1 : 0;
1761  break;
1762  case 1:
1763  spdif_enable = ((codec->spdif_mask & 0x02) &&
1764  (codec->spdif_mask & 0x04)) ? 1 : 0;
1765  break;
1766  case 2:
1767  spdif_enable = (codec->spdif_mask & 0x01) ? 1 : 0;
1768  break;
1769  default:
1770  break;
1771  }
1772  ucontrol->value.integer.value[0] = spdif_enable;
1773  spin_unlock_irq(&codec->reg_lock);
1774  return 0;
1775 }
1776 
1777 static int snd_ali5451_spdif_put(struct snd_kcontrol *kcontrol,
1778  struct snd_ctl_elem_value *ucontrol)
1779 {
1780  struct snd_ali *codec = kcontrol->private_data;
1781  unsigned int change = 0, spdif_enable = 0;
1782 
1783  spdif_enable = ucontrol->value.integer.value[0] ? 1 : 0;
1784 
1785  spin_lock_irq(&codec->reg_lock);
1786  switch (kcontrol->private_value) {
1787  case 0:
1788  change = (codec->spdif_mask & 0x02) ? 1 : 0;
1789  change = change ^ spdif_enable;
1790  if (change) {
1791  if (spdif_enable) {
1792  codec->spdif_mask |= 0x02;
1793  snd_ali_enable_spdif_out(codec);
1794  } else {
1795  codec->spdif_mask &= ~(0x02);
1796  codec->spdif_mask &= ~(0x04);
1797  snd_ali_disable_spdif_out(codec);
1798  }
1799  }
1800  break;
1801  case 1:
1802  change = (codec->spdif_mask & 0x04) ? 1 : 0;
1803  change = change ^ spdif_enable;
1804  if (change && (codec->spdif_mask & 0x02)) {
1805  if (spdif_enable) {
1806  codec->spdif_mask |= 0x04;
1807  snd_ali_enable_spdif_chnout(codec);
1808  } else {
1809  codec->spdif_mask &= ~(0x04);
1810  snd_ali_disable_spdif_chnout(codec);
1811  }
1812  }
1813  break;
1814  case 2:
1815  change = (codec->spdif_mask & 0x01) ? 1 : 0;
1816  change = change ^ spdif_enable;
1817  if (change) {
1818  if (spdif_enable) {
1819  codec->spdif_mask |= 0x01;
1820  snd_ali_enable_spdif_in(codec);
1821  } else {
1822  codec->spdif_mask &= ~(0x01);
1823  snd_ali_disable_spdif_in(codec);
1824  }
1825  }
1826  break;
1827  default:
1828  break;
1829  }
1830  spin_unlock_irq(&codec->reg_lock);
1831 
1832  return change;
1833 }
1834 
1835 static struct snd_kcontrol_new snd_ali5451_mixer_spdif[] __devinitdata = {
1836  /* spdif aplayback switch */
1837  /* FIXME: "IEC958 Playback Switch" may conflict with one on ac97_codec */
1838  ALI5451_SPDIF(SNDRV_CTL_NAME_IEC958("Output ",NONE,SWITCH), 0, 0),
1839  /* spdif out to spdif channel */
1840  ALI5451_SPDIF(SNDRV_CTL_NAME_IEC958("Channel Output ",NONE,SWITCH), 0, 1),
1841  /* spdif in from spdif channel */
1842  ALI5451_SPDIF(SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH), 0, 2)
1843 };
1844 
1845 static int __devinit snd_ali_mixer(struct snd_ali * codec)
1846 {
1847  struct snd_ac97_template ac97;
1848  unsigned int idx;
1849  int i, err;
1850  static struct snd_ac97_bus_ops ops = {
1851  .write = snd_ali_codec_write,
1852  .read = snd_ali_codec_read,
1853  };
1854 
1855  err = snd_ac97_bus(codec->card, 0, &ops, codec, &codec->ac97_bus);
1856  if (err < 0)
1857  return err;
1858 
1859  memset(&ac97, 0, sizeof(ac97));
1860  ac97.private_data = codec;
1861 
1862  for (i = 0; i < codec->num_of_codecs; i++) {
1863  ac97.num = i;
1864  err = snd_ac97_mixer(codec->ac97_bus, &ac97, &codec->ac97[i]);
1865  if (err < 0) {
1866  snd_printk(KERN_ERR
1867  "ali mixer %d creating error.\n", i);
1868  if (i == 0)
1869  return err;
1870  codec->num_of_codecs = 1;
1871  break;
1872  }
1873  }
1874 
1875  if (codec->spdif_support) {
1876  for (idx = 0; idx < ARRAY_SIZE(snd_ali5451_mixer_spdif); idx++) {
1877  err = snd_ctl_add(codec->card,
1878  snd_ctl_new1(&snd_ali5451_mixer_spdif[idx], codec));
1879  if (err < 0)
1880  return err;
1881  }
1882  }
1883  return 0;
1884 }
1885 
1886 #ifdef CONFIG_PM_SLEEP
1887 static int ali_suspend(struct device *dev)
1888 {
1889  struct pci_dev *pci = to_pci_dev(dev);
1890  struct snd_card *card = dev_get_drvdata(dev);
1891  struct snd_ali *chip = card->private_data;
1892  struct snd_ali_image *im;
1893  int i, j;
1894 
1895  im = chip->image;
1896  if (!im)
1897  return 0;
1898 
1899  snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
1900  for (i = 0; i < chip->num_of_codecs; i++) {
1901  snd_pcm_suspend_all(chip->pcm[i]);
1902  snd_ac97_suspend(chip->ac97[i]);
1903  }
1904 
1905  spin_lock_irq(&chip->reg_lock);
1906 
1907  im->regs[ALI_MISCINT >> 2] = inl(ALI_REG(chip, ALI_MISCINT));
1908  /* im->regs[ALI_START >> 2] = inl(ALI_REG(chip, ALI_START)); */
1909  im->regs[ALI_STOP >> 2] = inl(ALI_REG(chip, ALI_STOP));
1910 
1911  /* disable all IRQ bits */
1912  outl(0, ALI_REG(chip, ALI_MISCINT));
1913 
1914  for (i = 0; i < ALI_GLOBAL_REGS; i++) {
1915  if ((i*4 == ALI_MISCINT) || (i*4 == ALI_STOP))
1916  continue;
1917  im->regs[i] = inl(ALI_REG(chip, i*4));
1918  }
1919 
1920  for (i = 0; i < ALI_CHANNELS; i++) {
1921  outb(i, ALI_REG(chip, ALI_GC_CIR));
1922  for (j = 0; j < ALI_CHANNEL_REGS; j++)
1923  im->channel_regs[i][j] = inl(ALI_REG(chip, j*4 + 0xe0));
1924  }
1925 
1926  /* stop all HW channel */
1927  outl(0xffffffff, ALI_REG(chip, ALI_STOP));
1928 
1929  spin_unlock_irq(&chip->reg_lock);
1930 
1931  pci_disable_device(pci);
1932  pci_save_state(pci);
1933  pci_set_power_state(pci, PCI_D3hot);
1934  return 0;
1935 }
1936 
1937 static int ali_resume(struct device *dev)
1938 {
1939  struct pci_dev *pci = to_pci_dev(dev);
1940  struct snd_card *card = dev_get_drvdata(dev);
1941  struct snd_ali *chip = card->private_data;
1942  struct snd_ali_image *im;
1943  int i, j;
1944 
1945  im = chip->image;
1946  if (!im)
1947  return 0;
1948 
1949  pci_set_power_state(pci, PCI_D0);
1950  pci_restore_state(pci);
1951  if (pci_enable_device(pci) < 0) {
1952  printk(KERN_ERR "ali5451: pci_enable_device failed, "
1953  "disabling device\n");
1954  snd_card_disconnect(card);
1955  return -EIO;
1956  }
1957  pci_set_master(pci);
1958 
1959  spin_lock_irq(&chip->reg_lock);
1960 
1961  for (i = 0; i < ALI_CHANNELS; i++) {
1962  outb(i, ALI_REG(chip, ALI_GC_CIR));
1963  for (j = 0; j < ALI_CHANNEL_REGS; j++)
1964  outl(im->channel_regs[i][j], ALI_REG(chip, j*4 + 0xe0));
1965  }
1966 
1967  for (i = 0; i < ALI_GLOBAL_REGS; i++) {
1968  if ((i*4 == ALI_MISCINT) || (i*4 == ALI_STOP) ||
1969  (i*4 == ALI_START))
1970  continue;
1971  outl(im->regs[i], ALI_REG(chip, i*4));
1972  }
1973 
1974  /* start HW channel */
1975  outl(im->regs[ALI_START >> 2], ALI_REG(chip, ALI_START));
1976  /* restore IRQ enable bits */
1977  outl(im->regs[ALI_MISCINT >> 2], ALI_REG(chip, ALI_MISCINT));
1978 
1979  spin_unlock_irq(&chip->reg_lock);
1980 
1981  for (i = 0 ; i < chip->num_of_codecs; i++)
1982  snd_ac97_resume(chip->ac97[i]);
1983 
1984  snd_power_change_state(card, SNDRV_CTL_POWER_D0);
1985  return 0;
1986 }
1987 
1988 static SIMPLE_DEV_PM_OPS(ali_pm, ali_suspend, ali_resume);
1989 #define ALI_PM_OPS &ali_pm
1990 #else
1991 #define ALI_PM_OPS NULL
1992 #endif /* CONFIG_PM_SLEEP */
1993 
1994 static int snd_ali_free(struct snd_ali * codec)
1995 {
1996  if (codec->hw_initialized)
1997  snd_ali_disable_address_interrupt(codec);
1998  if (codec->irq >= 0)
1999  free_irq(codec->irq, codec);
2000  if (codec->port)
2001  pci_release_regions(codec->pci);
2002  pci_disable_device(codec->pci);
2003 #ifdef CONFIG_PM_SLEEP
2004  kfree(codec->image);
2005 #endif
2006  pci_dev_put(codec->pci_m1533);
2007  pci_dev_put(codec->pci_m7101);
2008  kfree(codec);
2009  return 0;
2010 }
2011 
2012 static int snd_ali_chip_init(struct snd_ali *codec)
2013 {
2014  unsigned int legacy;
2015  unsigned char temp;
2016  struct pci_dev *pci_dev;
2017 
2018  snd_ali_printk("chip initializing ... \n");
2019 
2020  if (snd_ali_reset_5451(codec)) {
2021  snd_printk(KERN_ERR "ali_chip_init: reset 5451 error.\n");
2022  return -1;
2023  }
2024 
2025  if (codec->revision == ALI_5451_V02) {
2026  pci_dev = codec->pci_m1533;
2027  pci_read_config_byte(pci_dev, 0x59, &temp);
2028  temp |= 0x80;
2029  pci_write_config_byte(pci_dev, 0x59, temp);
2030 
2031  pci_dev = codec->pci_m7101;
2032  pci_read_config_byte(pci_dev, 0xb8, &temp);
2033  temp |= 0x20;
2034  pci_write_config_byte(pci_dev, 0xB8, temp);
2035  }
2036 
2037  pci_read_config_dword(codec->pci, 0x44, &legacy);
2038  legacy &= 0xff00ff00;
2039  legacy |= 0x000800aa;
2040  pci_write_config_dword(codec->pci, 0x44, legacy);
2041 
2042  outl(0x80000001, ALI_REG(codec, ALI_GLOBAL_CONTROL));
2043  outl(0x00000000, ALI_REG(codec, ALI_AINTEN));
2044  outl(0xffffffff, ALI_REG(codec, ALI_AINT));
2045  outl(0x00000000, ALI_REG(codec, ALI_VOLUME));
2046  outb(0x10, ALI_REG(codec, ALI_MPUR2));
2047 
2048  codec->ac97_ext_id = snd_ali_codec_peek(codec, 0, AC97_EXTENDED_ID);
2049  codec->ac97_ext_status = snd_ali_codec_peek(codec, 0,
2050  AC97_EXTENDED_STATUS);
2051  if (codec->spdif_support) {
2052  snd_ali_enable_spdif_out(codec);
2053  codec->spdif_mask = 0x00000002;
2054  }
2055 
2056  codec->num_of_codecs = 1;
2057 
2058  /* secondary codec - modem */
2059  if (inl(ALI_REG(codec, ALI_SCTRL)) & ALI_SCTRL_CODEC2_READY) {
2060  codec->num_of_codecs++;
2061  outl(inl(ALI_REG(codec, ALI_SCTRL)) |
2062  (ALI_SCTRL_LINE_IN2 | ALI_SCTRL_GPIO_IN2 |
2063  ALI_SCTRL_LINE_OUT_EN),
2064  ALI_REG(codec, ALI_SCTRL));
2065  }
2066 
2067  snd_ali_printk("chip initialize succeed.\n");
2068  return 0;
2069 
2070 }
2071 
2072 /* proc for register dump */
2073 static void snd_ali_proc_read(struct snd_info_entry *entry,
2074  struct snd_info_buffer *buf)
2075 {
2076  struct snd_ali *codec = entry->private_data;
2077  int i;
2078  for (i = 0; i < 256 ; i+= 4)
2079  snd_iprintf(buf, "%02x: %08x\n", i, inl(ALI_REG(codec, i)));
2080 }
2081 
2082 static void __devinit snd_ali_proc_init(struct snd_ali *codec)
2083 {
2084  struct snd_info_entry *entry;
2085  if (!snd_card_proc_new(codec->card, "ali5451", &entry))
2086  snd_info_set_text_ops(entry, codec, snd_ali_proc_read);
2087 }
2088 
2089 static int __devinit snd_ali_resources(struct snd_ali *codec)
2090 {
2091  int err;
2092 
2093  snd_ali_printk("resources allocation ...\n");
2094  err = pci_request_regions(codec->pci, "ALI 5451");
2095  if (err < 0)
2096  return err;
2097  codec->port = pci_resource_start(codec->pci, 0);
2098 
2099  if (request_irq(codec->pci->irq, snd_ali_card_interrupt,
2100  IRQF_SHARED, KBUILD_MODNAME, codec)) {
2101  snd_printk(KERN_ERR "Unable to request irq.\n");
2102  return -EBUSY;
2103  }
2104  codec->irq = codec->pci->irq;
2105  snd_ali_printk("resources allocated.\n");
2106  return 0;
2107 }
2108 static int snd_ali_dev_free(struct snd_device *device)
2109 {
2110  struct snd_ali *codec = device->device_data;
2111  snd_ali_free(codec);
2112  return 0;
2113 }
2114 
2115 static int __devinit snd_ali_create(struct snd_card *card,
2116  struct pci_dev *pci,
2117  int pcm_streams,
2118  int spdif_support,
2119  struct snd_ali ** r_ali)
2120 {
2121  struct snd_ali *codec;
2122  int i, err;
2123  unsigned short cmdw;
2124  static struct snd_device_ops ops = {
2125  .dev_free = snd_ali_dev_free,
2126  };
2127 
2128  *r_ali = NULL;
2129 
2130  snd_ali_printk("creating ...\n");
2131 
2132  /* enable PCI device */
2133  err = pci_enable_device(pci);
2134  if (err < 0)
2135  return err;
2136  /* check, if we can restrict PCI DMA transfers to 31 bits */
2137  if (pci_set_dma_mask(pci, DMA_BIT_MASK(31)) < 0 ||
2138  pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(31)) < 0) {
2139  snd_printk(KERN_ERR "architecture does not support "
2140  "31bit PCI busmaster DMA\n");
2141  pci_disable_device(pci);
2142  return -ENXIO;
2143  }
2144 
2145  codec = kzalloc(sizeof(*codec), GFP_KERNEL);
2146  if (!codec) {
2147  pci_disable_device(pci);
2148  return -ENOMEM;
2149  }
2150 
2151  spin_lock_init(&codec->reg_lock);
2152  spin_lock_init(&codec->voice_alloc);
2153 
2154  codec->card = card;
2155  codec->pci = pci;
2156  codec->irq = -1;
2157  codec->revision = pci->revision;
2158  codec->spdif_support = spdif_support;
2159 
2160  if (pcm_streams < 1)
2161  pcm_streams = 1;
2162  if (pcm_streams > 32)
2163  pcm_streams = 32;
2164 
2165  pci_set_master(pci);
2166  pci_read_config_word(pci, PCI_COMMAND, &cmdw);
2167  if ((cmdw & PCI_COMMAND_IO) != PCI_COMMAND_IO) {
2168  cmdw |= PCI_COMMAND_IO;
2169  pci_write_config_word(pci, PCI_COMMAND, cmdw);
2170  }
2171  pci_set_master(pci);
2172 
2173  if (snd_ali_resources(codec)) {
2174  snd_ali_free(codec);
2175  return -EBUSY;
2176  }
2177 
2178  synchronize_irq(pci->irq);
2179 
2180  codec->synth.chmap = 0;
2181  codec->synth.chcnt = 0;
2182  codec->spdif_mask = 0;
2183  codec->synth.synthcount = 0;
2184 
2185  if (codec->revision == ALI_5451_V02)
2186  codec->chregs.regs.ac97read = ALI_AC97_WRITE;
2187  else
2188  codec->chregs.regs.ac97read = ALI_AC97_READ;
2189  codec->chregs.regs.ac97write = ALI_AC97_WRITE;
2190 
2191  codec->chregs.regs.start = ALI_START;
2192  codec->chregs.regs.stop = ALI_STOP;
2193  codec->chregs.regs.aint = ALI_AINT;
2194  codec->chregs.regs.ainten = ALI_AINTEN;
2195 
2196  codec->chregs.data.start = 0x00;
2197  codec->chregs.data.stop = 0x00;
2198  codec->chregs.data.aint = 0x00;
2199  codec->chregs.data.ainten = 0x00;
2200 
2201  /* M1533: southbridge */
2202  codec->pci_m1533 = pci_get_device(0x10b9, 0x1533, NULL);
2203  if (!codec->pci_m1533) {
2204  snd_printk(KERN_ERR "ali5451: cannot find ALi 1533 chip.\n");
2205  snd_ali_free(codec);
2206  return -ENODEV;
2207  }
2208  /* M7101: power management */
2209  codec->pci_m7101 = pci_get_device(0x10b9, 0x7101, NULL);
2210  if (!codec->pci_m7101 && codec->revision == ALI_5451_V02) {
2211  snd_printk(KERN_ERR "ali5451: cannot find ALi 7101 chip.\n");
2212  snd_ali_free(codec);
2213  return -ENODEV;
2214  }
2215 
2216  snd_ali_printk("snd_device_new is called.\n");
2217  err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, codec, &ops);
2218  if (err < 0) {
2219  snd_ali_free(codec);
2220  return err;
2221  }
2222 
2223  snd_card_set_dev(card, &pci->dev);
2224 
2225  /* initialise synth voices*/
2226  for (i = 0; i < ALI_CHANNELS; i++)
2227  codec->synth.voices[i].number = i;
2228 
2229  err = snd_ali_chip_init(codec);
2230  if (err < 0) {
2231  snd_printk(KERN_ERR "ali create: chip init error.\n");
2232  return err;
2233  }
2234 
2235 #ifdef CONFIG_PM_SLEEP
2236  codec->image = kmalloc(sizeof(*codec->image), GFP_KERNEL);
2237  if (!codec->image)
2238  snd_printk(KERN_WARNING "can't allocate apm buffer\n");
2239 #endif
2240 
2241  snd_ali_enable_address_interrupt(codec);
2242  codec->hw_initialized = 1;
2243 
2244  *r_ali = codec;
2245  snd_ali_printk("created.\n");
2246  return 0;
2247 }
2248 
2249 static int __devinit snd_ali_probe(struct pci_dev *pci,
2250  const struct pci_device_id *pci_id)
2251 {
2252  struct snd_card *card;
2253  struct snd_ali *codec;
2254  int err;
2255 
2256  snd_ali_printk("probe ...\n");
2257 
2258  err = snd_card_create(index, id, THIS_MODULE, 0, &card);
2259  if (err < 0)
2260  return err;
2261 
2262  err = snd_ali_create(card, pci, pcm_channels, spdif, &codec);
2263  if (err < 0)
2264  goto error;
2265  card->private_data = codec;
2266 
2267  snd_ali_printk("mixer building ...\n");
2268  err = snd_ali_mixer(codec);
2269  if (err < 0)
2270  goto error;
2271 
2272  snd_ali_printk("pcm building ...\n");
2273  err = snd_ali_build_pcms(codec);
2274  if (err < 0)
2275  goto error;
2276 
2277  snd_ali_proc_init(codec);
2278 
2279  strcpy(card->driver, "ALI5451");
2280  strcpy(card->shortname, "ALI 5451");
2281 
2282  sprintf(card->longname, "%s at 0x%lx, irq %i",
2283  card->shortname, codec->port, codec->irq);
2284 
2285  snd_ali_printk("register card.\n");
2286  err = snd_card_register(card);
2287  if (err < 0)
2288  goto error;
2289 
2290  pci_set_drvdata(pci, card);
2291  return 0;
2292 
2293  error:
2294  snd_card_free(card);
2295  return err;
2296 }
2297 
2298 static void __devexit snd_ali_remove(struct pci_dev *pci)
2299 {
2300  snd_card_free(pci_get_drvdata(pci));
2301  pci_set_drvdata(pci, NULL);
2302 }
2303 
2304 static struct pci_driver ali5451_driver = {
2305  .name = KBUILD_MODNAME,
2306  .id_table = snd_ali_ids,
2307  .probe = snd_ali_probe,
2308  .remove = __devexit_p(snd_ali_remove),
2309  .driver = {
2310  .pm = ALI_PM_OPS,
2311  },
2312 };
2313 
2314 module_pci_driver(ali5451_driver);
Generated on Thu Jan 10 2013 15:05:36 for Linux Kernel by   doxygen 1.8.2