Commit | Line | Data |
---|---|---|
5f7591c0 | 1 | /* |
bd15eba3 | 2 | * SAA713x ALSA support for V4L |
5f7591c0 | 3 | * |
bd15eba3 RC |
4 | * This program is free software; you can redistribute it and/or modify |
5 | * it under the terms of the GNU General Public License as published by | |
6 | * the Free Software Foundation, version 2 | |
7 | * | |
8 | * This program is distributed in the hope that it will be useful, | |
9 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
10 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
11 | * GNU General Public License for more details. | |
12 | * | |
13 | * You should have received a copy of the GNU General Public License | |
14 | * along with this program; if not, write to the Free Software | |
15 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
5f7591c0 | 16 | * |
5f7591c0 NS |
17 | */ |
18 | ||
bd15eba3 RC |
19 | #include <linux/init.h> |
20 | #include <linux/slab.h> | |
21 | #include <linux/time.h> | |
22 | #include <linux/wait.h> | |
bd15eba3 | 23 | #include <linux/module.h> |
5f7591c0 | 24 | #include <sound/core.h> |
5f7591c0 | 25 | #include <sound/control.h> |
bd15eba3 | 26 | #include <sound/pcm.h> |
d5ee43af | 27 | #include <sound/pcm_params.h> |
5f7591c0 | 28 | #include <sound/initval.h> |
871242b9 | 29 | #include <linux/interrupt.h> |
5f7591c0 NS |
30 | |
31 | #include "saa7134.h" | |
32 | #include "saa7134-reg.h" | |
33 | ||
ff699e6b | 34 | static unsigned int debug; |
79dd0c69 RC |
35 | module_param(debug, int, 0644); |
36 | MODULE_PARM_DESC(debug,"enable debug messages [alsa]"); | |
37 | ||
b2c15ea9 RC |
38 | /* |
39 | * Configuration macros | |
40 | */ | |
41 | ||
bd15eba3 | 42 | /* defaults */ |
736dadaa | 43 | #define MIXER_ADDR_UNSELECTED -1 |
b2c15ea9 RC |
44 | #define MIXER_ADDR_TVTUNER 0 |
45 | #define MIXER_ADDR_LINE1 1 | |
46 | #define MIXER_ADDR_LINE2 2 | |
47 | #define MIXER_ADDR_LAST 2 | |
5f7591c0 | 48 | |
674434c6 | 49 | |
bd15eba3 RC |
50 | static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ |
51 | static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ | |
ede22415 | 52 | static int enable[SNDRV_CARDS] = {1, [1 ... (SNDRV_CARDS - 1)] = 1}; |
bd15eba3 | 53 | |
b54134be | 54 | module_param_array(index, int, NULL, 0444); |
ede22415 | 55 | module_param_array(enable, int, NULL, 0444); |
b54134be | 56 | MODULE_PARM_DESC(index, "Index value for SAA7134 capture interface(s)."); |
ede22415 | 57 | MODULE_PARM_DESC(enable, "Enable (or not) the SAA7134 capture interface(s)."); |
b54134be | 58 | |
79dd0c69 | 59 | #define dprintk(fmt, arg...) if (debug) \ |
f85c657f | 60 | printk(KERN_DEBUG "%s/alsa: " fmt, dev->name , ##arg) |
674434c6 MCC |
61 | |
62 | ||
bd15eba3 | 63 | |
b2c15ea9 RC |
64 | /* |
65 | * Main chip structure | |
66 | */ | |
674434c6 | 67 | |
bd15eba3 | 68 | typedef struct snd_card_saa7134 { |
f7cbb7fc | 69 | struct snd_card *card; |
bd15eba3 RC |
70 | spinlock_t mixer_lock; |
71 | int mixer_volume[MIXER_ADDR_LAST+1][2]; | |
736dadaa OJ |
72 | int capture_source_addr; |
73 | int capture_source[2]; | |
74 | struct snd_kcontrol *capture_ctl[MIXER_ADDR_LAST+1]; | |
4ac97914 | 75 | struct pci_dev *pci; |
4aabf633 | 76 | struct saa7134_dev *dev; |
bd15eba3 | 77 | |
4ac97914 | 78 | unsigned long iobase; |
aac0ca6a RB |
79 | s16 irq; |
80 | u16 mute_was_on; | |
bd15eba3 RC |
81 | |
82 | spinlock_t lock; | |
83 | } snd_card_saa7134_t; | |
84 | ||
07eef6ce | 85 | |
b2c15ea9 RC |
86 | /* |
87 | * PCM structure | |
88 | */ | |
89 | ||
bd15eba3 | 90 | typedef struct snd_card_saa7134_pcm { |
4aabf633 | 91 | struct saa7134_dev *dev; |
bd15eba3 RC |
92 | |
93 | spinlock_t lock; | |
4aabf633 | 94 | |
f7cbb7fc | 95 | struct snd_pcm_substream *substream; |
bd15eba3 | 96 | } snd_card_saa7134_pcm_t; |
5f7591c0 | 97 | |
f7cbb7fc | 98 | static struct snd_card *snd_saa7134_cards[SNDRV_CARDS]; |
5f7591c0 | 99 | |
79dd0c69 | 100 | |
b2c15ea9 RC |
101 | /* |
102 | * saa7134 DMA audio stop | |
103 | * | |
104 | * Called when the capture device is released or the buffer overflows | |
105 | * | |
c817e763 | 106 | * - Copied verbatim from saa7134-oss's dsp_dma_stop. |
b2c15ea9 RC |
107 | * |
108 | */ | |
109 | ||
bd15eba3 RC |
110 | static void saa7134_dma_stop(struct saa7134_dev *dev) |
111 | { | |
b54134be RC |
112 | dev->dmasound.dma_blk = -1; |
113 | dev->dmasound.dma_running = 0; | |
4ac97914 | 114 | saa7134_set_dmabits(dev); |
bd15eba3 | 115 | } |
5f7591c0 | 116 | |
b2c15ea9 RC |
117 | /* |
118 | * saa7134 DMA audio start | |
119 | * | |
120 | * Called when preparing the capture device for use | |
121 | * | |
c817e763 | 122 | * - Copied verbatim from saa7134-oss's dsp_dma_start. |
b2c15ea9 RC |
123 | * |
124 | */ | |
125 | ||
bd15eba3 RC |
126 | static void saa7134_dma_start(struct saa7134_dev *dev) |
127 | { | |
b54134be RC |
128 | dev->dmasound.dma_blk = 0; |
129 | dev->dmasound.dma_running = 1; | |
4ac97914 | 130 | saa7134_set_dmabits(dev); |
bd15eba3 | 131 | } |
5f7591c0 | 132 | |
b2c15ea9 RC |
133 | /* |
134 | * saa7134 audio DMA IRQ handler | |
135 | * | |
136 | * Called whenever we get an SAA7134_IRQ_REPORT_DONE_RA3 interrupt | |
137 | * Handles shifting between the 2 buffers, manages the read counters, | |
138 | * and notifies ALSA when periods elapse | |
139 | * | |
140 | * - Mostly copied from saa7134-oss's saa7134_irq_oss_done. | |
141 | * | |
142 | */ | |
143 | ||
943a4902 AB |
144 | static void saa7134_irq_alsa_done(struct saa7134_dev *dev, |
145 | unsigned long status) | |
bd15eba3 RC |
146 | { |
147 | int next_blk, reg = 0; | |
5f7591c0 | 148 | |
bd15eba3 | 149 | spin_lock(&dev->slock); |
b54134be | 150 | if (UNSET == dev->dmasound.dma_blk) { |
bd15eba3 RC |
151 | dprintk("irq: recording stopped\n"); |
152 | goto done; | |
153 | } | |
154 | if (0 != (status & 0x0f000000)) | |
155 | dprintk("irq: lost %ld\n", (status >> 24) & 0x0f); | |
156 | if (0 == (status & 0x10000000)) { | |
157 | /* odd */ | |
b54134be | 158 | if (0 == (dev->dmasound.dma_blk & 0x01)) |
bd15eba3 RC |
159 | reg = SAA7134_RS_BA1(6); |
160 | } else { | |
161 | /* even */ | |
b54134be | 162 | if (1 == (dev->dmasound.dma_blk & 0x01)) |
bd15eba3 RC |
163 | reg = SAA7134_RS_BA2(6); |
164 | } | |
165 | if (0 == reg) { | |
166 | dprintk("irq: field oops [%s]\n", | |
167 | (status & 0x10000000) ? "even" : "odd"); | |
168 | goto done; | |
169 | } | |
5f7591c0 | 170 | |
b54134be RC |
171 | if (dev->dmasound.read_count >= dev->dmasound.blksize * (dev->dmasound.blocks-2)) { |
172 | dprintk("irq: overrun [full=%d/%d] - Blocks in %d\n",dev->dmasound.read_count, | |
173 | dev->dmasound.bufsize, dev->dmasound.blocks); | |
d5ee43af | 174 | spin_unlock(&dev->slock); |
b534f8f9 | 175 | snd_pcm_stream_lock(dev->dmasound.substream); |
b54134be | 176 | snd_pcm_stop(dev->dmasound.substream,SNDRV_PCM_STATE_XRUN); |
b534f8f9 | 177 | snd_pcm_stream_unlock(dev->dmasound.substream); |
d5ee43af | 178 | return; |
bd15eba3 | 179 | } |
5f7591c0 | 180 | |
4ac97914 | 181 | /* next block addr */ |
b54134be RC |
182 | next_blk = (dev->dmasound.dma_blk + 2) % dev->dmasound.blocks; |
183 | saa_writel(reg,next_blk * dev->dmasound.blksize); | |
79dd0c69 | 184 | if (debug > 2) |
4ac97914 MCC |
185 | dprintk("irq: ok, %s, next_blk=%d, addr=%x, blocks=%u, size=%u, read=%u\n", |
186 | (status & 0x10000000) ? "even" : "odd ", next_blk, | |
b54134be | 187 | next_blk * dev->dmasound.blksize, dev->dmasound.blocks, dev->dmasound.blksize, dev->dmasound.read_count); |
5f7591c0 | 188 | |
4ac97914 | 189 | /* update status & wake waiting readers */ |
b54134be RC |
190 | dev->dmasound.dma_blk = (dev->dmasound.dma_blk + 1) % dev->dmasound.blocks; |
191 | dev->dmasound.read_count += dev->dmasound.blksize; | |
5f7591c0 | 192 | |
b54134be | 193 | dev->dmasound.recording_on = reg; |
5f7591c0 | 194 | |
b54134be | 195 | if (dev->dmasound.read_count >= snd_pcm_lib_period_bytes(dev->dmasound.substream)) { |
4ac97914 | 196 | spin_unlock(&dev->slock); |
b54134be | 197 | snd_pcm_period_elapsed(dev->dmasound.substream); |
4ac97914 | 198 | spin_lock(&dev->slock); |
bd15eba3 | 199 | } |
4aabf633 | 200 | |
bd15eba3 | 201 | done: |
4ac97914 | 202 | spin_unlock(&dev->slock); |
5f7591c0 | 203 | |
bd15eba3 | 204 | } |
5f7591c0 | 205 | |
79dd0c69 RC |
206 | /* |
207 | * IRQ request handler | |
208 | * | |
209 | * Runs along with saa7134's IRQ handler, discards anything that isn't | |
210 | * DMA sound | |
211 | * | |
212 | */ | |
213 | ||
7d12e780 | 214 | static irqreturn_t saa7134_alsa_irq(int irq, void *dev_id) |
79dd0c69 | 215 | { |
afd1a0c9 MCC |
216 | struct saa7134_dmasound *dmasound = dev_id; |
217 | struct saa7134_dev *dev = dmasound->priv_data; | |
4aabf633 | 218 | |
79dd0c69 RC |
219 | unsigned long report, status; |
220 | int loop, handled = 0; | |
221 | ||
222 | for (loop = 0; loop < 10; loop++) { | |
223 | report = saa_readl(SAA7134_IRQ_REPORT); | |
224 | status = saa_readl(SAA7134_IRQ_STATUS); | |
225 | ||
226 | if (report & SAA7134_IRQ_REPORT_DONE_RA3) { | |
227 | handled = 1; | |
843b1378 HL |
228 | saa_writel(SAA7134_IRQ_REPORT, |
229 | SAA7134_IRQ_REPORT_DONE_RA3); | |
79dd0c69 RC |
230 | saa7134_irq_alsa_done(dev, status); |
231 | } else { | |
232 | goto out; | |
233 | } | |
234 | } | |
235 | ||
236 | if (loop == 10) { | |
237 | dprintk("error! looping IRQ!"); | |
238 | } | |
239 | ||
240 | out: | |
241 | return IRQ_RETVAL(handled); | |
242 | } | |
243 | ||
b2c15ea9 RC |
244 | /* |
245 | * ALSA capture trigger | |
246 | * | |
247 | * - One of the ALSA capture callbacks. | |
248 | * | |
249 | * Called whenever a capture is started or stopped. Must be defined, | |
250 | * but there's nothing we want to do here | |
251 | * | |
252 | */ | |
5f7591c0 | 253 | |
f7cbb7fc | 254 | static int snd_card_saa7134_capture_trigger(struct snd_pcm_substream * substream, |
bd15eba3 | 255 | int cmd) |
5f7591c0 | 256 | { |
f7cbb7fc | 257 | struct snd_pcm_runtime *runtime = substream->runtime; |
4aabf633 RC |
258 | snd_card_saa7134_pcm_t *pcm = runtime->private_data; |
259 | struct saa7134_dev *dev=pcm->dev; | |
b54134be RC |
260 | int err = 0; |
261 | ||
d5ee43af | 262 | spin_lock(&dev->slock); |
c817e763 | 263 | if (cmd == SNDRV_PCM_TRIGGER_START) { |
b54134be RC |
264 | /* start dma */ |
265 | saa7134_dma_start(dev); | |
c817e763 | 266 | } else if (cmd == SNDRV_PCM_TRIGGER_STOP) { |
b54134be RC |
267 | /* stop dma */ |
268 | saa7134_dma_stop(dev); | |
c817e763 RC |
269 | } else { |
270 | err = -EINVAL; | |
271 | } | |
d5ee43af | 272 | spin_unlock(&dev->slock); |
b54134be | 273 | |
c817e763 | 274 | return err; |
5f7591c0 NS |
275 | } |
276 | ||
b2c15ea9 RC |
277 | /* |
278 | * DMA buffer initialization | |
279 | * | |
280 | * Uses V4L functions to initialize the DMA. Shouldn't be necessary in | |
281 | * ALSA, but I was unable to use ALSA's own DMA, and had to force the | |
282 | * usage of V4L's | |
283 | * | |
c817e763 RC |
284 | * - Copied verbatim from saa7134-oss. |
285 | * | |
b2c15ea9 RC |
286 | */ |
287 | ||
bd15eba3 | 288 | static int dsp_buffer_init(struct saa7134_dev *dev) |
5f7591c0 | 289 | { |
4ac97914 MCC |
290 | int err; |
291 | ||
4aabf633 RC |
292 | BUG_ON(!dev->dmasound.bufsize); |
293 | ||
b54134be RC |
294 | videobuf_dma_init(&dev->dmasound.dma); |
295 | err = videobuf_dma_init_kernel(&dev->dmasound.dma, PCI_DMA_FROMDEVICE, | |
296 | (dev->dmasound.bufsize + PAGE_SIZE) >> PAGE_SHIFT); | |
4ac97914 MCC |
297 | if (0 != err) |
298 | return err; | |
299 | return 0; | |
5f7591c0 NS |
300 | } |
301 | ||
d5ee43af RC |
302 | /* |
303 | * DMA buffer release | |
304 | * | |
305 | * Called after closing the device, during snd_card_saa7134_capture_close | |
306 | * | |
307 | */ | |
308 | ||
309 | static int dsp_buffer_free(struct saa7134_dev *dev) | |
310 | { | |
ae24601b | 311 | BUG_ON(!dev->dmasound.blksize); |
d5ee43af RC |
312 | |
313 | videobuf_dma_free(&dev->dmasound.dma); | |
314 | ||
315 | dev->dmasound.blocks = 0; | |
316 | dev->dmasound.blksize = 0; | |
317 | dev->dmasound.bufsize = 0; | |
318 | ||
b930e1d8 | 319 | return 0; |
d5ee43af RC |
320 | } |
321 | ||
736dadaa OJ |
322 | /* |
323 | * Setting the capture source and updating the ALSA controls | |
324 | */ | |
325 | static int snd_saa7134_capsrc_set(struct snd_kcontrol *kcontrol, | |
326 | int left, int right, bool force_notify) | |
327 | { | |
328 | snd_card_saa7134_t *chip = snd_kcontrol_chip(kcontrol); | |
329 | int change = 0, addr = kcontrol->private_value; | |
330 | int active, old_addr; | |
331 | u32 anabar, xbarin; | |
332 | int analog_io, rate; | |
333 | struct saa7134_dev *dev; | |
334 | ||
335 | dev = chip->dev; | |
336 | ||
337 | spin_lock_irq(&chip->mixer_lock); | |
338 | ||
339 | active = left != 0 || right != 0; | |
340 | old_addr = chip->capture_source_addr; | |
341 | ||
342 | /* The active capture source cannot be deactivated */ | |
343 | if (active) { | |
344 | change = old_addr != addr || | |
345 | chip->capture_source[0] != left || | |
346 | chip->capture_source[1] != right; | |
347 | ||
348 | chip->capture_source[0] = left; | |
349 | chip->capture_source[1] = right; | |
350 | chip->capture_source_addr = addr; | |
351 | dev->dmasound.input = addr; | |
352 | } | |
353 | spin_unlock_irq(&chip->mixer_lock); | |
354 | ||
355 | if (change) { | |
356 | switch (dev->pci->device) { | |
357 | ||
358 | case PCI_DEVICE_ID_PHILIPS_SAA7134: | |
359 | switch (addr) { | |
360 | case MIXER_ADDR_TVTUNER: | |
361 | saa_andorb(SAA7134_AUDIO_FORMAT_CTRL, | |
362 | 0xc0, 0xc0); | |
363 | saa_andorb(SAA7134_SIF_SAMPLE_FREQ, | |
364 | 0x03, 0x00); | |
365 | break; | |
366 | case MIXER_ADDR_LINE1: | |
367 | case MIXER_ADDR_LINE2: | |
368 | analog_io = (MIXER_ADDR_LINE1 == addr) ? | |
369 | 0x00 : 0x08; | |
370 | rate = (32000 == dev->dmasound.rate) ? | |
371 | 0x01 : 0x03; | |
372 | saa_andorb(SAA7134_ANALOG_IO_SELECT, | |
373 | 0x08, analog_io); | |
374 | saa_andorb(SAA7134_AUDIO_FORMAT_CTRL, | |
375 | 0xc0, 0x80); | |
376 | saa_andorb(SAA7134_SIF_SAMPLE_FREQ, | |
377 | 0x03, rate); | |
378 | break; | |
379 | } | |
380 | ||
381 | break; | |
382 | case PCI_DEVICE_ID_PHILIPS_SAA7133: | |
383 | case PCI_DEVICE_ID_PHILIPS_SAA7135: | |
384 | xbarin = 0x03; /* adc */ | |
385 | anabar = 0; | |
386 | switch (addr) { | |
387 | case MIXER_ADDR_TVTUNER: | |
388 | xbarin = 0; /* Demodulator */ | |
389 | anabar = 2; /* DACs */ | |
390 | break; | |
391 | case MIXER_ADDR_LINE1: | |
392 | anabar = 0; /* aux1, aux1 */ | |
393 | break; | |
394 | case MIXER_ADDR_LINE2: | |
395 | anabar = 9; /* aux2, aux2 */ | |
396 | break; | |
397 | } | |
398 | ||
399 | /* output xbar always main channel */ | |
400 | saa_dsp_writel(dev, SAA7133_DIGITAL_OUTPUT_SEL1, | |
401 | 0xbbbb10); | |
402 | ||
403 | if (left || right) { | |
404 | /* We've got data, turn the input on */ | |
405 | saa_dsp_writel(dev, SAA7133_DIGITAL_INPUT_XBAR1, | |
406 | xbarin); | |
407 | saa_writel(SAA7133_ANALOG_IO_SELECT, anabar); | |
408 | } else { | |
409 | saa_dsp_writel(dev, SAA7133_DIGITAL_INPUT_XBAR1, | |
410 | 0); | |
411 | saa_writel(SAA7133_ANALOG_IO_SELECT, 0); | |
412 | } | |
413 | break; | |
414 | } | |
415 | } | |
416 | ||
417 | if (change) { | |
418 | if (force_notify) | |
419 | snd_ctl_notify(chip->card, | |
420 | SNDRV_CTL_EVENT_MASK_VALUE, | |
421 | &chip->capture_ctl[addr]->id); | |
422 | ||
423 | if (old_addr != MIXER_ADDR_UNSELECTED && old_addr != addr) | |
424 | snd_ctl_notify(chip->card, | |
425 | SNDRV_CTL_EVENT_MASK_VALUE, | |
426 | &chip->capture_ctl[old_addr]->id); | |
427 | } | |
428 | ||
429 | return change; | |
430 | } | |
d5ee43af | 431 | |
b2c15ea9 RC |
432 | /* |
433 | * ALSA PCM preparation | |
434 | * | |
435 | * - One of the ALSA capture callbacks. | |
436 | * | |
437 | * Called right after the capture device is opened, this function configures | |
438 | * the buffer using the previously defined functions, allocates the memory, | |
439 | * sets up the hardware registers, and then starts the DMA. When this function | |
440 | * returns, the audio should be flowing. | |
441 | * | |
442 | */ | |
5f7591c0 | 443 | |
f7cbb7fc | 444 | static int snd_card_saa7134_capture_prepare(struct snd_pcm_substream * substream) |
5f7591c0 | 445 | { |
f7cbb7fc | 446 | struct snd_pcm_runtime *runtime = substream->runtime; |
d5ee43af | 447 | int bswap, sign; |
4ac97914 | 448 | u32 fmt, control; |
bd15eba3 | 449 | snd_card_saa7134_t *saa7134 = snd_pcm_substream_chip(substream); |
4ac97914 | 450 | struct saa7134_dev *dev; |
4aabf633 | 451 | snd_card_saa7134_pcm_t *pcm = runtime->private_data; |
bd15eba3 | 452 | |
4aabf633 | 453 | pcm->dev->dmasound.substream = substream; |
bd15eba3 | 454 | |
d5ee43af | 455 | dev = saa7134->dev; |
bd15eba3 | 456 | |
d5ee43af | 457 | if (snd_pcm_format_width(runtime->format) == 8) |
bd15eba3 | 458 | fmt = 0x00; |
d5ee43af | 459 | else |
bd15eba3 | 460 | fmt = 0x01; |
4ac97914 | 461 | |
d5ee43af | 462 | if (snd_pcm_format_signed(runtime->format)) |
bd15eba3 | 463 | sign = 1; |
d5ee43af | 464 | else |
bd15eba3 | 465 | sign = 0; |
bd15eba3 | 466 | |
d5ee43af RC |
467 | if (snd_pcm_format_big_endian(runtime->format)) |
468 | bswap = 1; | |
469 | else | |
470 | bswap = 0; | |
4ac97914 MCC |
471 | |
472 | switch (dev->pci->device) { | |
473 | case PCI_DEVICE_ID_PHILIPS_SAA7134: | |
474 | if (1 == runtime->channels) | |
475 | fmt |= (1 << 3); | |
476 | if (2 == runtime->channels) | |
477 | fmt |= (3 << 3); | |
478 | if (sign) | |
479 | fmt |= 0x04; | |
480 | ||
b54134be RC |
481 | fmt |= (MIXER_ADDR_TVTUNER == dev->dmasound.input) ? 0xc0 : 0x80; |
482 | saa_writeb(SAA7134_NUM_SAMPLES0, ((dev->dmasound.blksize - 1) & 0x0000ff)); | |
483 | saa_writeb(SAA7134_NUM_SAMPLES1, ((dev->dmasound.blksize - 1) & 0x00ff00) >> 8); | |
484 | saa_writeb(SAA7134_NUM_SAMPLES2, ((dev->dmasound.blksize - 1) & 0xff0000) >> 16); | |
4ac97914 MCC |
485 | saa_writeb(SAA7134_AUDIO_FORMAT_CTRL, fmt); |
486 | ||
487 | break; | |
488 | case PCI_DEVICE_ID_PHILIPS_SAA7133: | |
489 | case PCI_DEVICE_ID_PHILIPS_SAA7135: | |
490 | if (1 == runtime->channels) | |
491 | fmt |= (1 << 4); | |
492 | if (2 == runtime->channels) | |
493 | fmt |= (2 << 4); | |
494 | if (!sign) | |
495 | fmt |= 0x04; | |
b54134be | 496 | saa_writel(SAA7133_NUM_SAMPLES, dev->dmasound.blksize -1); |
4ac97914 | 497 | saa_writel(SAA7133_AUDIO_CHANNEL, 0x543210 | (fmt << 24)); |
4ac97914 MCC |
498 | break; |
499 | } | |
500 | ||
501 | dprintk("rec_start: afmt=%d ch=%d => fmt=0x%x swap=%c\n", | |
502 | runtime->format, runtime->channels, fmt, | |
503 | bswap ? 'b' : '-'); | |
504 | /* dma: setup channel 6 (= AUDIO) */ | |
505 | control = SAA7134_RS_CONTROL_BURST_16 | | |
506 | SAA7134_RS_CONTROL_ME | | |
b54134be | 507 | (dev->dmasound.pt.dma >> 12); |
4ac97914 MCC |
508 | if (bswap) |
509 | control |= SAA7134_RS_CONTROL_BSWAP; | |
bd15eba3 | 510 | |
4ac97914 | 511 | saa_writel(SAA7134_RS_BA1(6),0); |
b54134be | 512 | saa_writel(SAA7134_RS_BA2(6),dev->dmasound.blksize); |
4ac97914 MCC |
513 | saa_writel(SAA7134_RS_PITCH(6),0); |
514 | saa_writel(SAA7134_RS_CONTROL(6),control); | |
bd15eba3 | 515 | |
b54134be | 516 | dev->dmasound.rate = runtime->rate; |
5f7591c0 | 517 | |
736dadaa OJ |
518 | /* Setup and update the card/ALSA controls */ |
519 | snd_saa7134_capsrc_set(saa7134->capture_ctl[dev->dmasound.input], 1, 1, | |
520 | true); | |
521 | ||
bd15eba3 | 522 | return 0; |
5f7591c0 | 523 | |
bd15eba3 | 524 | } |
5f7591c0 | 525 | |
b2c15ea9 RC |
526 | /* |
527 | * ALSA pointer fetching | |
528 | * | |
529 | * - One of the ALSA capture callbacks. | |
530 | * | |
531 | * Called whenever a period elapses, it must return the current hardware | |
532 | * position of the buffer. | |
533 | * Also resets the read counter used to prevent overruns | |
534 | * | |
535 | */ | |
5f7591c0 | 536 | |
f7cbb7fc TI |
537 | static snd_pcm_uframes_t |
538 | snd_card_saa7134_capture_pointer(struct snd_pcm_substream * substream) | |
5f7591c0 | 539 | { |
f7cbb7fc | 540 | struct snd_pcm_runtime *runtime = substream->runtime; |
4aabf633 RC |
541 | snd_card_saa7134_pcm_t *pcm = runtime->private_data; |
542 | struct saa7134_dev *dev=pcm->dev; | |
5f7591c0 | 543 | |
b54134be RC |
544 | if (dev->dmasound.read_count) { |
545 | dev->dmasound.read_count -= snd_pcm_lib_period_bytes(substream); | |
546 | dev->dmasound.read_offset += snd_pcm_lib_period_bytes(substream); | |
547 | if (dev->dmasound.read_offset == dev->dmasound.bufsize) | |
548 | dev->dmasound.read_offset = 0; | |
bd15eba3 | 549 | } |
5f7591c0 | 550 | |
b54134be | 551 | return bytes_to_frames(runtime, dev->dmasound.read_offset); |
bd15eba3 | 552 | } |
5f7591c0 | 553 | |
b2c15ea9 RC |
554 | /* |
555 | * ALSA hardware capabilities definition | |
7b543602 OJ |
556 | * |
557 | * Report only 32kHz for ALSA: | |
558 | * | |
559 | * - SAA7133/35 uses DDEP (DemDec Easy Programming mode), which works in 32kHz | |
560 | * only | |
561 | * - SAA7134 for TV mode uses DemDec mode (32kHz) | |
562 | * - Radio works in 32kHz only | |
563 | * - When recording 48kHz from Line1/Line2, switching of capture source to TV | |
564 | * means | |
565 | * switching to 32kHz without any frequency translation | |
b2c15ea9 | 566 | */ |
5f7591c0 | 567 | |
f7cbb7fc | 568 | static struct snd_pcm_hardware snd_card_saa7134_capture = |
5f7591c0 | 569 | { |
4ac97914 | 570 | .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | |
f2421ca3 MCC |
571 | SNDRV_PCM_INFO_BLOCK_TRANSFER | |
572 | SNDRV_PCM_INFO_MMAP_VALID), | |
b54134be RC |
573 | .formats = SNDRV_PCM_FMTBIT_S16_LE | \ |
574 | SNDRV_PCM_FMTBIT_S16_BE | \ | |
575 | SNDRV_PCM_FMTBIT_S8 | \ | |
576 | SNDRV_PCM_FMTBIT_U8 | \ | |
577 | SNDRV_PCM_FMTBIT_U16_LE | \ | |
578 | SNDRV_PCM_FMTBIT_U16_BE, | |
7b543602 | 579 | .rates = SNDRV_PCM_RATE_32000, |
b54134be | 580 | .rate_min = 32000, |
7b543602 | 581 | .rate_max = 32000, |
b54134be RC |
582 | .channels_min = 1, |
583 | .channels_max = 2, | |
584 | .buffer_bytes_max = (256*1024), | |
bd15eba3 | 585 | .period_bytes_min = 64, |
b54134be | 586 | .period_bytes_max = (256*1024), |
174eb8e8 | 587 | .periods_min = 4, |
b54134be | 588 | .periods_max = 1024, |
bd15eba3 | 589 | }; |
5f7591c0 | 590 | |
f7cbb7fc | 591 | static void snd_card_saa7134_runtime_free(struct snd_pcm_runtime *runtime) |
bd15eba3 | 592 | { |
4aabf633 | 593 | snd_card_saa7134_pcm_t *pcm = runtime->private_data; |
bd15eba3 | 594 | |
4aabf633 | 595 | kfree(pcm); |
5f7591c0 NS |
596 | } |
597 | ||
bd15eba3 | 598 | |
b2c15ea9 RC |
599 | /* |
600 | * ALSA hardware params | |
601 | * | |
602 | * - One of the ALSA capture callbacks. | |
603 | * | |
604 | * Called on initialization, right before the PCM preparation | |
b2c15ea9 RC |
605 | * |
606 | */ | |
607 | ||
f7cbb7fc TI |
608 | static int snd_card_saa7134_hw_params(struct snd_pcm_substream * substream, |
609 | struct snd_pcm_hw_params * hw_params) | |
5f7591c0 | 610 | { |
d5ee43af RC |
611 | snd_card_saa7134_t *saa7134 = snd_pcm_substream_chip(substream); |
612 | struct saa7134_dev *dev; | |
613 | unsigned int period_size, periods; | |
614 | int err; | |
615 | ||
616 | period_size = params_period_bytes(hw_params); | |
617 | periods = params_periods(hw_params); | |
618 | ||
5e246b85 TI |
619 | if (period_size < 0x100 || period_size > 0x10000) |
620 | return -EINVAL; | |
621 | if (periods < 4) | |
622 | return -EINVAL; | |
623 | if (period_size * periods > 1024 * 1024) | |
624 | return -EINVAL; | |
d5ee43af RC |
625 | |
626 | dev = saa7134->dev; | |
627 | ||
628 | if (dev->dmasound.blocks == periods && | |
629 | dev->dmasound.blksize == period_size) | |
630 | return 0; | |
631 | ||
632 | /* release the old buffer */ | |
633 | if (substream->runtime->dma_area) { | |
634 | saa7134_pgtable_free(dev->pci, &dev->dmasound.pt); | |
95268403 | 635 | videobuf_dma_unmap(&dev->pci->dev, &dev->dmasound.dma); |
d5ee43af RC |
636 | dsp_buffer_free(dev); |
637 | substream->runtime->dma_area = NULL; | |
638 | } | |
639 | dev->dmasound.blocks = periods; | |
640 | dev->dmasound.blksize = period_size; | |
641 | dev->dmasound.bufsize = period_size * periods; | |
642 | ||
643 | err = dsp_buffer_init(dev); | |
644 | if (0 != err) { | |
645 | dev->dmasound.blocks = 0; | |
646 | dev->dmasound.blksize = 0; | |
647 | dev->dmasound.bufsize = 0; | |
648 | return err; | |
649 | } | |
650 | ||
95268403 | 651 | if (0 != (err = videobuf_dma_map(&dev->pci->dev, &dev->dmasound.dma))) { |
d5ee43af RC |
652 | dsp_buffer_free(dev); |
653 | return err; | |
654 | } | |
655 | if (0 != (err = saa7134_pgtable_alloc(dev->pci,&dev->dmasound.pt))) { | |
95268403 | 656 | videobuf_dma_unmap(&dev->pci->dev, &dev->dmasound.dma); |
d5ee43af RC |
657 | dsp_buffer_free(dev); |
658 | return err; | |
659 | } | |
660 | if (0 != (err = saa7134_pgtable_build(dev->pci,&dev->dmasound.pt, | |
661 | dev->dmasound.dma.sglist, | |
662 | dev->dmasound.dma.sglen, | |
663 | 0))) { | |
664 | saa7134_pgtable_free(dev->pci, &dev->dmasound.pt); | |
95268403 | 665 | videobuf_dma_unmap(&dev->pci->dev, &dev->dmasound.dma); |
d5ee43af RC |
666 | dsp_buffer_free(dev); |
667 | return err; | |
668 | } | |
669 | ||
670 | /* I should be able to use runtime->dma_addr in the control | |
671 | byte, but it doesn't work. So I allocate the DMA using the | |
672 | V4L functions, and force ALSA to use that as the DMA area */ | |
673 | ||
bb6dbe74 | 674 | substream->runtime->dma_area = dev->dmasound.dma.vaddr; |
32d111a9 AP |
675 | substream->runtime->dma_bytes = dev->dmasound.bufsize; |
676 | substream->runtime->dma_addr = 0; | |
d5ee43af | 677 | |
32d111a9 | 678 | return 0; |
bd15eba3 | 679 | |
5f7591c0 NS |
680 | } |
681 | ||
b2c15ea9 RC |
682 | /* |
683 | * ALSA hardware release | |
684 | * | |
685 | * - One of the ALSA capture callbacks. | |
686 | * | |
687 | * Called after closing the device, but before snd_card_saa7134_capture_close | |
d5ee43af | 688 | * It stops the DMA audio and releases the buffers. |
b2c15ea9 RC |
689 | * |
690 | */ | |
691 | ||
f7cbb7fc | 692 | static int snd_card_saa7134_hw_free(struct snd_pcm_substream * substream) |
5f7591c0 | 693 | { |
d5ee43af RC |
694 | snd_card_saa7134_t *saa7134 = snd_pcm_substream_chip(substream); |
695 | struct saa7134_dev *dev; | |
5f7591c0 | 696 | |
d5ee43af | 697 | dev = saa7134->dev; |
5f7591c0 | 698 | |
d5ee43af RC |
699 | if (substream->runtime->dma_area) { |
700 | saa7134_pgtable_free(dev->pci, &dev->dmasound.pt); | |
95268403 | 701 | videobuf_dma_unmap(&dev->pci->dev, &dev->dmasound.dma); |
d5ee43af RC |
702 | dsp_buffer_free(dev); |
703 | substream->runtime->dma_area = NULL; | |
704 | } | |
bd15eba3 | 705 | |
4ac97914 | 706 | return 0; |
5f7591c0 NS |
707 | } |
708 | ||
b2c15ea9 RC |
709 | /* |
710 | * ALSA capture finish | |
711 | * | |
712 | * - One of the ALSA capture callbacks. | |
713 | * | |
d5ee43af | 714 | * Called after closing the device. |
b2c15ea9 RC |
715 | * |
716 | */ | |
bd15eba3 | 717 | |
f7cbb7fc | 718 | static int snd_card_saa7134_capture_close(struct snd_pcm_substream * substream) |
5f7591c0 | 719 | { |
dafcaaf8 RC |
720 | snd_card_saa7134_t *saa7134 = snd_pcm_substream_chip(substream); |
721 | struct saa7134_dev *dev = saa7134->dev; | |
722 | ||
aac0ca6a RB |
723 | if (saa7134->mute_was_on) { |
724 | dev->ctl_mute = 1; | |
725 | saa7134_tvaudio_setmute(dev); | |
726 | } | |
4ac97914 | 727 | return 0; |
5f7591c0 NS |
728 | } |
729 | ||
b2c15ea9 RC |
730 | /* |
731 | * ALSA capture start | |
732 | * | |
733 | * - One of the ALSA capture callbacks. | |
734 | * | |
735 | * Called when opening the device. It creates and populates the PCM | |
736 | * structure | |
737 | * | |
738 | */ | |
5f7591c0 | 739 | |
f7cbb7fc | 740 | static int snd_card_saa7134_capture_open(struct snd_pcm_substream * substream) |
b2c15ea9 | 741 | { |
f7cbb7fc | 742 | struct snd_pcm_runtime *runtime = substream->runtime; |
4aabf633 | 743 | snd_card_saa7134_pcm_t *pcm; |
4ac97914 | 744 | snd_card_saa7134_t *saa7134 = snd_pcm_substream_chip(substream); |
83ee87a3 | 745 | struct saa7134_dev *dev; |
5cfbacd0 | 746 | int amux, err; |
5f7591c0 | 747 | |
83ee87a3 MCC |
748 | if (!saa7134) { |
749 | printk(KERN_ERR "BUG: saa7134 can't find device struct." | |
750 | " Can't proceed with open\n"); | |
751 | return -ENODEV; | |
752 | } | |
753 | dev = saa7134->dev; | |
3593cab5 | 754 | mutex_lock(&dev->dmasound.lock); |
5f7591c0 | 755 | |
b54134be RC |
756 | dev->dmasound.read_count = 0; |
757 | dev->dmasound.read_offset = 0; | |
bd15eba3 | 758 | |
5cfbacd0 HH |
759 | amux = dev->input->amux; |
760 | if ((amux < 1) || (amux > 3)) | |
761 | amux = 1; | |
762 | dev->dmasound.input = amux - 1; | |
763 | ||
3593cab5 | 764 | mutex_unlock(&dev->dmasound.lock); |
5f7591c0 | 765 | |
4aabf633 RC |
766 | pcm = kzalloc(sizeof(*pcm), GFP_KERNEL); |
767 | if (pcm == NULL) | |
bd15eba3 | 768 | return -ENOMEM; |
bd15eba3 | 769 | |
4aabf633 RC |
770 | pcm->dev=saa7134->dev; |
771 | ||
772 | spin_lock_init(&pcm->lock); | |
bd15eba3 | 773 | |
4aabf633 RC |
774 | pcm->substream = substream; |
775 | runtime->private_data = pcm; | |
bd15eba3 RC |
776 | runtime->private_free = snd_card_saa7134_runtime_free; |
777 | runtime->hw = snd_card_saa7134_capture; | |
778 | ||
aac0ca6a RB |
779 | if (dev->ctl_mute != 0) { |
780 | saa7134->mute_was_on = 1; | |
781 | dev->ctl_mute = 0; | |
782 | saa7134_tvaudio_setmute(dev); | |
783 | } | |
dafcaaf8 | 784 | |
174eb8e8 HL |
785 | err = snd_pcm_hw_constraint_integer(runtime, |
786 | SNDRV_PCM_HW_PARAM_PERIODS); | |
787 | if (err < 0) | |
788 | return err; | |
789 | ||
790 | err = snd_pcm_hw_constraint_step(runtime, 0, | |
791 | SNDRV_PCM_HW_PARAM_PERIODS, 2); | |
792 | if (err < 0) | |
4ac97914 | 793 | return err; |
5f7591c0 NS |
794 | |
795 | return 0; | |
796 | } | |
797 | ||
32d111a9 AP |
798 | /* |
799 | * page callback (needed for mmap) | |
800 | */ | |
801 | ||
802 | static struct page *snd_card_saa7134_page(struct snd_pcm_substream *substream, | |
803 | unsigned long offset) | |
804 | { | |
805 | void *pageptr = substream->runtime->dma_area + offset; | |
806 | return vmalloc_to_page(pageptr); | |
807 | } | |
808 | ||
b2c15ea9 RC |
809 | /* |
810 | * ALSA capture callbacks definition | |
811 | */ | |
5f7591c0 | 812 | |
f7cbb7fc | 813 | static struct snd_pcm_ops snd_card_saa7134_capture_ops = { |
bd15eba3 RC |
814 | .open = snd_card_saa7134_capture_open, |
815 | .close = snd_card_saa7134_capture_close, | |
816 | .ioctl = snd_pcm_lib_ioctl, | |
817 | .hw_params = snd_card_saa7134_hw_params, | |
818 | .hw_free = snd_card_saa7134_hw_free, | |
819 | .prepare = snd_card_saa7134_capture_prepare, | |
820 | .trigger = snd_card_saa7134_capture_trigger, | |
821 | .pointer = snd_card_saa7134_capture_pointer, | |
32d111a9 | 822 | .page = snd_card_saa7134_page, |
5f7591c0 NS |
823 | }; |
824 | ||
b2c15ea9 RC |
825 | /* |
826 | * ALSA PCM setup | |
827 | * | |
828 | * Called when initializing the board. Sets up the name and hooks up | |
829 | * the callbacks | |
830 | * | |
831 | */ | |
832 | ||
833 | static int snd_card_saa7134_pcm(snd_card_saa7134_t *saa7134, int device) | |
bd15eba3 | 834 | { |
f7cbb7fc | 835 | struct snd_pcm *pcm; |
bd15eba3 | 836 | int err; |
5f7591c0 | 837 | |
bd15eba3 RC |
838 | if ((err = snd_pcm_new(saa7134->card, "SAA7134 PCM", device, 0, 1, &pcm)) < 0) |
839 | return err; | |
840 | snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_card_saa7134_capture_ops); | |
841 | pcm->private_data = saa7134; | |
842 | pcm->info_flags = 0; | |
843 | strcpy(pcm->name, "SAA7134 PCM"); | |
bd15eba3 RC |
844 | return 0; |
845 | } | |
5f7591c0 | 846 | |
bd15eba3 RC |
847 | #define SAA713x_VOLUME(xname, xindex, addr) \ |
848 | { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \ | |
849 | .info = snd_saa7134_volume_info, \ | |
850 | .get = snd_saa7134_volume_get, .put = snd_saa7134_volume_put, \ | |
851 | .private_value = addr } | |
5f7591c0 | 852 | |
f7cbb7fc TI |
853 | static int snd_saa7134_volume_info(struct snd_kcontrol * kcontrol, |
854 | struct snd_ctl_elem_info * uinfo) | |
bd15eba3 RC |
855 | { |
856 | uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; | |
857 | uinfo->count = 2; | |
858 | uinfo->value.integer.min = 0; | |
859 | uinfo->value.integer.max = 20; | |
860 | return 0; | |
861 | } | |
5f7591c0 | 862 | |
f7cbb7fc TI |
863 | static int snd_saa7134_volume_get(struct snd_kcontrol * kcontrol, |
864 | struct snd_ctl_elem_value * ucontrol) | |
bd15eba3 RC |
865 | { |
866 | snd_card_saa7134_t *chip = snd_kcontrol_chip(kcontrol); | |
bd15eba3 RC |
867 | int addr = kcontrol->private_value; |
868 | ||
bd15eba3 RC |
869 | ucontrol->value.integer.value[0] = chip->mixer_volume[addr][0]; |
870 | ucontrol->value.integer.value[1] = chip->mixer_volume[addr][1]; | |
bd15eba3 RC |
871 | return 0; |
872 | } | |
5f7591c0 | 873 | |
f7cbb7fc TI |
874 | static int snd_saa7134_volume_put(struct snd_kcontrol * kcontrol, |
875 | struct snd_ctl_elem_value * ucontrol) | |
5f7591c0 | 876 | { |
bd15eba3 | 877 | snd_card_saa7134_t *chip = snd_kcontrol_chip(kcontrol); |
5cfbacd0 HH |
878 | struct saa7134_dev *dev = chip->dev; |
879 | ||
bd15eba3 RC |
880 | int change, addr = kcontrol->private_value; |
881 | int left, right; | |
882 | ||
883 | left = ucontrol->value.integer.value[0]; | |
884 | if (left < 0) | |
885 | left = 0; | |
886 | if (left > 20) | |
887 | left = 20; | |
888 | right = ucontrol->value.integer.value[1]; | |
889 | if (right < 0) | |
890 | right = 0; | |
891 | if (right > 20) | |
892 | right = 20; | |
d5ee43af | 893 | spin_lock_irq(&chip->mixer_lock); |
5cfbacd0 HH |
894 | change = 0; |
895 | if (chip->mixer_volume[addr][0] != left) { | |
896 | change = 1; | |
897 | right = left; | |
898 | } | |
899 | if (chip->mixer_volume[addr][1] != right) { | |
900 | change = 1; | |
901 | left = right; | |
902 | } | |
903 | if (change) { | |
904 | switch (dev->pci->device) { | |
905 | case PCI_DEVICE_ID_PHILIPS_SAA7134: | |
906 | switch (addr) { | |
907 | case MIXER_ADDR_TVTUNER: | |
908 | left = 20; | |
909 | break; | |
910 | case MIXER_ADDR_LINE1: | |
911 | saa_andorb(SAA7134_ANALOG_IO_SELECT, 0x10, | |
912 | (left > 10) ? 0x00 : 0x10); | |
913 | break; | |
914 | case MIXER_ADDR_LINE2: | |
915 | saa_andorb(SAA7134_ANALOG_IO_SELECT, 0x20, | |
916 | (left > 10) ? 0x00 : 0x20); | |
917 | break; | |
918 | } | |
919 | break; | |
920 | case PCI_DEVICE_ID_PHILIPS_SAA7133: | |
921 | case PCI_DEVICE_ID_PHILIPS_SAA7135: | |
922 | switch (addr) { | |
923 | case MIXER_ADDR_TVTUNER: | |
924 | left = 20; | |
925 | break; | |
926 | case MIXER_ADDR_LINE1: | |
927 | saa_andorb(0x0594, 0x10, | |
928 | (left > 10) ? 0x00 : 0x10); | |
929 | break; | |
930 | case MIXER_ADDR_LINE2: | |
931 | saa_andorb(0x0594, 0x20, | |
932 | (left > 10) ? 0x00 : 0x20); | |
933 | break; | |
934 | } | |
935 | break; | |
936 | } | |
937 | chip->mixer_volume[addr][0] = left; | |
938 | chip->mixer_volume[addr][1] = right; | |
939 | } | |
d5ee43af | 940 | spin_unlock_irq(&chip->mixer_lock); |
bd15eba3 RC |
941 | return change; |
942 | } | |
5f7591c0 | 943 | |
bd15eba3 RC |
944 | #define SAA713x_CAPSRC(xname, xindex, addr) \ |
945 | { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \ | |
946 | .info = snd_saa7134_capsrc_info, \ | |
947 | .get = snd_saa7134_capsrc_get, .put = snd_saa7134_capsrc_put, \ | |
948 | .private_value = addr } | |
5f7591c0 | 949 | |
f7cbb7fc TI |
950 | static int snd_saa7134_capsrc_info(struct snd_kcontrol * kcontrol, |
951 | struct snd_ctl_elem_info * uinfo) | |
bd15eba3 RC |
952 | { |
953 | uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; | |
b2c15ea9 | 954 | uinfo->count = 2; |
bd15eba3 RC |
955 | uinfo->value.integer.min = 0; |
956 | uinfo->value.integer.max = 1; | |
957 | return 0; | |
958 | } | |
5f7591c0 | 959 | |
f7cbb7fc TI |
960 | static int snd_saa7134_capsrc_get(struct snd_kcontrol * kcontrol, |
961 | struct snd_ctl_elem_value * ucontrol) | |
bd15eba3 RC |
962 | { |
963 | snd_card_saa7134_t *chip = snd_kcontrol_chip(kcontrol); | |
bd15eba3 RC |
964 | int addr = kcontrol->private_value; |
965 | ||
d5ee43af | 966 | spin_lock_irq(&chip->mixer_lock); |
736dadaa OJ |
967 | if (chip->capture_source_addr == addr) { |
968 | ucontrol->value.integer.value[0] = chip->capture_source[0]; | |
969 | ucontrol->value.integer.value[1] = chip->capture_source[1]; | |
970 | } else { | |
971 | ucontrol->value.integer.value[0] = 0; | |
972 | ucontrol->value.integer.value[1] = 0; | |
973 | } | |
d5ee43af | 974 | spin_unlock_irq(&chip->mixer_lock); |
4aabf633 | 975 | |
5f7591c0 NS |
976 | return 0; |
977 | } | |
978 | ||
f7cbb7fc TI |
979 | static int snd_saa7134_capsrc_put(struct snd_kcontrol * kcontrol, |
980 | struct snd_ctl_elem_value * ucontrol) | |
5f7591c0 | 981 | { |
bd15eba3 | 982 | int left, right; |
bd15eba3 RC |
983 | left = ucontrol->value.integer.value[0] & 1; |
984 | right = ucontrol->value.integer.value[1] & 1; | |
bd15eba3 | 985 | |
736dadaa | 986 | return snd_saa7134_capsrc_set(kcontrol, left, right, false); |
5f7591c0 NS |
987 | } |
988 | ||
736dadaa | 989 | static struct snd_kcontrol_new snd_saa7134_volume_controls[] = { |
bd15eba3 | 990 | SAA713x_VOLUME("Video Volume", 0, MIXER_ADDR_TVTUNER), |
bd15eba3 | 991 | SAA713x_VOLUME("Line Volume", 1, MIXER_ADDR_LINE1), |
bd15eba3 | 992 | SAA713x_VOLUME("Line Volume", 2, MIXER_ADDR_LINE2), |
736dadaa OJ |
993 | }; |
994 | ||
995 | static struct snd_kcontrol_new snd_saa7134_capture_controls[] = { | |
996 | SAA713x_CAPSRC("Video Capture Switch", 0, MIXER_ADDR_TVTUNER), | |
997 | SAA713x_CAPSRC("Line Capture Switch", 1, MIXER_ADDR_LINE1), | |
bd15eba3 RC |
998 | SAA713x_CAPSRC("Line Capture Switch", 2, MIXER_ADDR_LINE2), |
999 | }; | |
5f7591c0 | 1000 | |
b2c15ea9 RC |
1001 | /* |
1002 | * ALSA mixer setup | |
1003 | * | |
1004 | * Called when initializing the board. Sets up the name and hooks up | |
1005 | * the callbacks | |
1006 | * | |
1007 | */ | |
1008 | ||
1009 | static int snd_card_saa7134_new_mixer(snd_card_saa7134_t * chip) | |
bd15eba3 | 1010 | { |
f7cbb7fc | 1011 | struct snd_card *card = chip->card; |
736dadaa | 1012 | struct snd_kcontrol *kcontrol; |
bd15eba3 | 1013 | unsigned int idx; |
736dadaa | 1014 | int err, addr; |
bd15eba3 | 1015 | |
bd15eba3 | 1016 | strcpy(card->mixername, "SAA7134 Mixer"); |
5f7591c0 | 1017 | |
736dadaa OJ |
1018 | for (idx = 0; idx < ARRAY_SIZE(snd_saa7134_volume_controls); idx++) { |
1019 | kcontrol = snd_ctl_new1(&snd_saa7134_volume_controls[idx], | |
1020 | chip); | |
1021 | err = snd_ctl_add(card, kcontrol); | |
1022 | if (err < 0) | |
bd15eba3 RC |
1023 | return err; |
1024 | } | |
736dadaa OJ |
1025 | |
1026 | for (idx = 0; idx < ARRAY_SIZE(snd_saa7134_capture_controls); idx++) { | |
1027 | kcontrol = snd_ctl_new1(&snd_saa7134_capture_controls[idx], | |
1028 | chip); | |
1029 | addr = snd_saa7134_capture_controls[idx].private_value; | |
1030 | chip->capture_ctl[addr] = kcontrol; | |
1031 | err = snd_ctl_add(card, kcontrol); | |
1032 | if (err < 0) | |
1033 | return err; | |
1034 | } | |
1035 | ||
1036 | chip->capture_source_addr = MIXER_ADDR_UNSELECTED; | |
bd15eba3 RC |
1037 | return 0; |
1038 | } | |
1039 | ||
f7cbb7fc | 1040 | static void snd_saa7134_free(struct snd_card * card) |
5f7591c0 | 1041 | { |
d5ee43af | 1042 | snd_card_saa7134_t *chip = card->private_data; |
c817e763 | 1043 | |
4aabf633 | 1044 | if (chip->dev->dmasound.priv_data == NULL) |
d5ee43af | 1045 | return; |
4aabf633 | 1046 | |
f000fd80 | 1047 | if (chip->irq >= 0) |
4aabf633 | 1048 | free_irq(chip->irq, &chip->dev->dmasound); |
c817e763 | 1049 | |
4aabf633 RC |
1050 | chip->dev->dmasound.priv_data = NULL; |
1051 | ||
bd15eba3 | 1052 | } |
5f7591c0 | 1053 | |
b2c15ea9 RC |
1054 | /* |
1055 | * ALSA initialization | |
1056 | * | |
c817e763 RC |
1057 | * Called by the init routine, once for each saa7134 device present, |
1058 | * it creates the basic structures and registers the ALSA devices | |
b2c15ea9 RC |
1059 | * |
1060 | */ | |
1061 | ||
943a4902 | 1062 | static int alsa_card_saa7134_create(struct saa7134_dev *dev, int devnum) |
bd15eba3 | 1063 | { |
79dd0c69 | 1064 | |
f7cbb7fc | 1065 | struct snd_card *card; |
b2c15ea9 | 1066 | snd_card_saa7134_t *chip; |
bd15eba3 | 1067 | int err; |
5f7591c0 | 1068 | |
79dd0c69 | 1069 | |
4aabf633 | 1070 | if (devnum >= SNDRV_CARDS) |
4ac97914 | 1071 | return -ENODEV; |
4aabf633 | 1072 | if (!enable[devnum]) |
bd15eba3 | 1073 | return -ENODEV; |
b2c15ea9 | 1074 | |
758021bf TI |
1075 | err = snd_card_create(index[devnum], id[devnum], THIS_MODULE, |
1076 | sizeof(snd_card_saa7134_t), &card); | |
1077 | if (err < 0) | |
1078 | return err; | |
5f7591c0 | 1079 | |
bd15eba3 | 1080 | strcpy(card->driver, "SAA7134"); |
5f7591c0 | 1081 | |
bd15eba3 | 1082 | /* Card "creation" */ |
b2c15ea9 | 1083 | |
c817e763 | 1084 | card->private_free = snd_saa7134_free; |
abf84383 | 1085 | chip = card->private_data; |
5f7591c0 | 1086 | |
4ac97914 | 1087 | spin_lock_init(&chip->lock); |
b54134be | 1088 | spin_lock_init(&chip->mixer_lock); |
5f7591c0 | 1089 | |
4aabf633 | 1090 | chip->dev = dev; |
5f7591c0 | 1091 | |
4ac97914 | 1092 | chip->card = card; |
b2c15ea9 | 1093 | |
4aabf633 | 1094 | chip->pci = dev->pci; |
4aabf633 RC |
1095 | chip->iobase = pci_resource_start(dev->pci, 0); |
1096 | ||
5f7591c0 | 1097 | |
4aabf633 | 1098 | err = request_irq(dev->pci->irq, saa7134_alsa_irq, |
8076fe32 | 1099 | IRQF_SHARED | IRQF_DISABLED, dev->name, |
4aabf633 | 1100 | (void*) &dev->dmasound); |
79dd0c69 RC |
1101 | |
1102 | if (err < 0) { | |
1103 | printk(KERN_ERR "%s: can't get IRQ %d for ALSA\n", | |
4aabf633 | 1104 | dev->name, dev->pci->irq); |
b54134be | 1105 | goto __nodev; |
79dd0c69 RC |
1106 | } |
1107 | ||
d5ee43af | 1108 | chip->irq = dev->pci->irq; |
4aabf633 | 1109 | |
3593cab5 | 1110 | mutex_init(&dev->dmasound.lock); |
5f7591c0 | 1111 | |
bd15eba3 RC |
1112 | if ((err = snd_card_saa7134_new_mixer(chip)) < 0) |
1113 | goto __nodev; | |
5f7591c0 | 1114 | |
bd15eba3 RC |
1115 | if ((err = snd_card_saa7134_pcm(chip, 0)) < 0) |
1116 | goto __nodev; | |
b2c15ea9 | 1117 | |
bd15eba3 | 1118 | snd_card_set_dev(card, &chip->pci->dev); |
5f7591c0 | 1119 | |
bd15eba3 | 1120 | /* End of "creation" */ |
5f7591c0 | 1121 | |
bd15eba3 | 1122 | strcpy(card->shortname, "SAA7134"); |
4ac97914 | 1123 | sprintf(card->longname, "%s at 0x%lx irq %d", |
4aabf633 | 1124 | chip->dev->name, chip->iobase, chip->irq); |
5f7591c0 | 1125 | |
f5b974cb RC |
1126 | printk(KERN_INFO "%s/alsa: %s registered as card %d\n",dev->name,card->longname,index[devnum]); |
1127 | ||
bd15eba3 | 1128 | if ((err = snd_card_register(card)) == 0) { |
4aabf633 | 1129 | snd_saa7134_cards[devnum] = card; |
bd15eba3 RC |
1130 | return 0; |
1131 | } | |
1132 | ||
1133 | __nodev: | |
1134 | snd_card_free(card); | |
bd15eba3 | 1135 | return err; |
5f7591c0 NS |
1136 | } |
1137 | ||
f5b974cb RC |
1138 | |
1139 | static int alsa_device_init(struct saa7134_dev *dev) | |
1140 | { | |
1141 | dev->dmasound.priv_data = dev; | |
1142 | alsa_card_saa7134_create(dev,dev->nr); | |
1143 | return 1; | |
1144 | } | |
1145 | ||
1146 | static int alsa_device_exit(struct saa7134_dev *dev) | |
1147 | { | |
d5ce15e8 MCC |
1148 | if (!snd_saa7134_cards[dev->nr]) |
1149 | return 1; | |
f5b974cb RC |
1150 | |
1151 | snd_card_free(snd_saa7134_cards[dev->nr]); | |
1152 | snd_saa7134_cards[dev->nr] = NULL; | |
1153 | return 1; | |
1154 | } | |
1155 | ||
79dd0c69 RC |
1156 | /* |
1157 | * Module initializer | |
1158 | * | |
1159 | * Loops through present saa7134 cards, and assigns an ALSA device | |
1160 | * to each one | |
1161 | * | |
1162 | */ | |
1163 | ||
1164 | static int saa7134_alsa_init(void) | |
1165 | { | |
4aabf633 | 1166 | struct saa7134_dev *dev = NULL; |
c817e763 | 1167 | struct list_head *list; |
79dd0c69 | 1168 | |
166fb6b4 AB |
1169 | saa7134_dmasound_init = alsa_device_init; |
1170 | saa7134_dmasound_exit = alsa_device_exit; | |
7bb95296 | 1171 | |
afd1a0c9 | 1172 | printk(KERN_INFO "saa7134 ALSA driver for DMA sound loaded\n"); |
c817e763 RC |
1173 | |
1174 | list_for_each(list,&saa7134_devlist) { | |
4aabf633 | 1175 | dev = list_entry(list, struct saa7134_dev, devlist); |
40c41c8c MCC |
1176 | if (dev->pci->device == PCI_DEVICE_ID_PHILIPS_SAA7130) |
1177 | printk(KERN_INFO "%s/alsa: %s doesn't support digital audio\n", | |
1178 | dev->name, saa7134_boards[dev->board].name); | |
1179 | else | |
1180 | alsa_device_init(dev); | |
c817e763 | 1181 | } |
79dd0c69 | 1182 | |
4aabf633 | 1183 | if (dev == NULL) |
79dd0c69 RC |
1184 | printk(KERN_INFO "saa7134 ALSA: no saa7134 cards found\n"); |
1185 | ||
1186 | return 0; | |
674434c6 | 1187 | |
79dd0c69 RC |
1188 | } |
1189 | ||
1190 | /* | |
1191 | * Module destructor | |
1192 | */ | |
1193 | ||
943a4902 | 1194 | static void saa7134_alsa_exit(void) |
5f7591c0 | 1195 | { |
4ac97914 | 1196 | int idx; |
b54134be | 1197 | |
79dd0c69 | 1198 | for (idx = 0; idx < SNDRV_CARDS; idx++) { |
d5ce15e8 MCC |
1199 | if (snd_saa7134_cards[idx]) |
1200 | snd_card_free(snd_saa7134_cards[idx]); | |
bd15eba3 | 1201 | } |
b54134be | 1202 | |
78457018 AB |
1203 | saa7134_dmasound_init = NULL; |
1204 | saa7134_dmasound_exit = NULL; | |
79dd0c69 | 1205 | printk(KERN_INFO "saa7134 ALSA driver for DMA sound unloaded\n"); |
b54134be | 1206 | |
79dd0c69 | 1207 | return; |
5f7591c0 | 1208 | } |
79dd0c69 | 1209 | |
c7ac6b42 LT |
1210 | /* We initialize this late, to make sure the sound system is up and running */ |
1211 | late_initcall(saa7134_alsa_init); | |
79dd0c69 RC |
1212 | module_exit(saa7134_alsa_exit); |
1213 | MODULE_LICENSE("GPL"); | |
1214 | MODULE_AUTHOR("Ricardo Cerqueira"); |