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