Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 1 | /* |
| 2 | * |
| 3 | * Support for audio capture |
| 4 | * PCI function #1 of the cx2388x. |
| 5 | * |
Trent Piepho | 05b2723 | 2007-08-24 01:06:34 -0300 | [diff] [blame] | 6 | * (c) 2007 Trent Piepho <xyzzy@speakeasy.org> |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 7 | * (c) 2005,2006 Ricardo Cerqueira <v4l@cerqueira.org> |
Mauro Carvalho Chehab | 2e7c6dc | 2006-04-03 07:53:40 -0300 | [diff] [blame] | 8 | * (c) 2005 Mauro Carvalho Chehab <mchehab@infradead.org> |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 9 | * Based on a dummy cx88 module by Gerd Knorr <kraxel@bytesex.org> |
Jaroslav Kysela | c1017a4 | 2007-10-15 09:50:19 +0200 | [diff] [blame] | 10 | * Based on dummy.c by Jaroslav Kysela <perex@perex.cz> |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 11 | * |
| 12 | * This program is free software; you can redistribute it and/or modify |
| 13 | * it under the terms of the GNU General Public License as published by |
| 14 | * the Free Software Foundation; either version 2 of the License, 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 License for more details. |
| 21 | * |
| 22 | * You should have received a copy of the GNU General Public License |
| 23 | * along with this program; if not, write to the Free Software |
| 24 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
| 25 | */ |
| 26 | |
| 27 | #include <linux/module.h> |
| 28 | #include <linux/init.h> |
| 29 | #include <linux/device.h> |
| 30 | #include <linux/interrupt.h> |
Trent Piepho | f6210c9 | 2007-08-24 01:06:36 -0300 | [diff] [blame] | 31 | #include <linux/vmalloc.h> |
Andrew Morton | c24228d | 2007-05-06 14:51:55 -0700 | [diff] [blame] | 32 | #include <linux/dma-mapping.h> |
Trent Piepho | 19453bc | 2007-08-18 22:54:49 -0300 | [diff] [blame] | 33 | #include <linux/pci.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 34 | #include <linux/slab.h> |
Andrew Morton | c24228d | 2007-05-06 14:51:55 -0700 | [diff] [blame] | 35 | |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 36 | #include <asm/delay.h> |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 37 | #include <sound/core.h> |
| 38 | #include <sound/pcm.h> |
| 39 | #include <sound/pcm_params.h> |
| 40 | #include <sound/control.h> |
| 41 | #include <sound/initval.h> |
Trent Piepho | bbaccc0 | 2007-09-06 23:02:25 -0300 | [diff] [blame] | 42 | #include <sound/tlv.h> |
Lawrence Rust | 6951803 | 2011-02-06 17:46:12 -0300 | [diff] [blame] | 43 | #include <media/wm8775.h> |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 44 | |
| 45 | #include "cx88.h" |
| 46 | #include "cx88-reg.h" |
| 47 | |
| 48 | #define dprintk(level,fmt, arg...) if (debug >= level) \ |
| 49 | printk(KERN_INFO "%s/1: " fmt, chip->core->name , ## arg) |
| 50 | |
| 51 | #define dprintk_core(level,fmt, arg...) if (debug >= level) \ |
| 52 | printk(KERN_DEBUG "%s/1: " fmt, chip->core->name , ## arg) |
| 53 | |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 54 | /**************************************************************************** |
| 55 | Data type declarations - Can be moded to a header file later |
| 56 | ****************************************************************************/ |
| 57 | |
Laurent Pinchart | fecfede | 2010-05-11 10:36:31 -0300 | [diff] [blame] | 58 | struct cx88_audio_buffer { |
| 59 | unsigned int bpl; |
| 60 | struct btcx_riscmem risc; |
| 61 | struct videobuf_dmabuf dma; |
| 62 | }; |
| 63 | |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 64 | struct cx88_audio_dev { |
| 65 | struct cx88_core *core; |
| 66 | struct cx88_dmaqueue q; |
| 67 | |
| 68 | /* pci i/o */ |
| 69 | struct pci_dev *pci; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 70 | |
| 71 | /* audio controls */ |
| 72 | int irq; |
| 73 | |
Takashi Iwai | f7cbb7f | 2006-01-13 18:48:06 +0100 | [diff] [blame] | 74 | struct snd_card *card; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 75 | |
| 76 | spinlock_t reg_lock; |
Trent Piepho | 05b2723 | 2007-08-24 01:06:34 -0300 | [diff] [blame] | 77 | atomic_t count; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 78 | |
| 79 | unsigned int dma_size; |
| 80 | unsigned int period_size; |
| 81 | unsigned int num_periods; |
| 82 | |
Mauro Carvalho Chehab | c1accaa | 2007-08-23 16:37:49 -0300 | [diff] [blame] | 83 | struct videobuf_dmabuf *dma_risc; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 84 | |
Laurent Pinchart | fecfede | 2010-05-11 10:36:31 -0300 | [diff] [blame] | 85 | struct cx88_audio_buffer *buf; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 86 | |
Trent Piepho | 05b2723 | 2007-08-24 01:06:34 -0300 | [diff] [blame] | 87 | struct snd_pcm_substream *substream; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 88 | }; |
| 89 | typedef struct cx88_audio_dev snd_cx88_card_t; |
| 90 | |
| 91 | |
| 92 | |
| 93 | /**************************************************************************** |
| 94 | Module global static vars |
| 95 | ****************************************************************************/ |
| 96 | |
| 97 | static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ |
lawrence rust | 2e4e98e | 2010-08-25 09:50:20 -0300 | [diff] [blame] | 98 | static const char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 99 | static int enable[SNDRV_CARDS] = {1, [1 ... (SNDRV_CARDS - 1)] = 1}; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 100 | |
| 101 | module_param_array(enable, bool, NULL, 0444); |
| 102 | MODULE_PARM_DESC(enable, "Enable cx88x soundcard. default enabled."); |
| 103 | |
| 104 | module_param_array(index, int, NULL, 0444); |
| 105 | MODULE_PARM_DESC(index, "Index value for cx88x capture interface(s)."); |
| 106 | |
| 107 | |
| 108 | /**************************************************************************** |
| 109 | Module macros |
| 110 | ****************************************************************************/ |
| 111 | |
| 112 | MODULE_DESCRIPTION("ALSA driver module for cx2388x based TV cards"); |
| 113 | MODULE_AUTHOR("Ricardo Cerqueira"); |
Mauro Carvalho Chehab | 2e7c6dc | 2006-04-03 07:53:40 -0300 | [diff] [blame] | 114 | MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@infradead.org>"); |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 115 | MODULE_LICENSE("GPL"); |
Mauro Carvalho Chehab | 1990d50 | 2011-06-24 14:45:49 -0300 | [diff] [blame^] | 116 | MODULE_VERSION(CX88_VERSION); |
| 117 | |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 118 | MODULE_SUPPORTED_DEVICE("{{Conexant,23881}," |
| 119 | "{{Conexant,23882}," |
| 120 | "{{Conexant,23883}"); |
Mauro Carvalho Chehab | a5ed425 | 2006-01-13 14:10:19 -0200 | [diff] [blame] | 121 | static unsigned int debug; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 122 | module_param(debug,int,0644); |
| 123 | MODULE_PARM_DESC(debug,"enable debug messages"); |
| 124 | |
| 125 | /**************************************************************************** |
| 126 | Module specific funtions |
| 127 | ****************************************************************************/ |
| 128 | |
| 129 | /* |
| 130 | * BOARD Specific: Sets audio DMA |
| 131 | */ |
| 132 | |
Mauro Carvalho Chehab | be8a82d | 2006-02-07 06:49:14 -0200 | [diff] [blame] | 133 | static int _cx88_start_audio_dma(snd_cx88_card_t *chip) |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 134 | { |
Laurent Pinchart | fecfede | 2010-05-11 10:36:31 -0300 | [diff] [blame] | 135 | struct cx88_audio_buffer *buf = chip->buf; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 136 | struct cx88_core *core=chip->core; |
lawrence rust | 2e4e98e | 2010-08-25 09:50:20 -0300 | [diff] [blame] | 137 | const struct sram_channel *audio_ch = &cx88_sram_channels[SRAM_CH25]; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 138 | |
Trent Piepho | 59fd8f8 | 2007-08-18 22:09:42 -0300 | [diff] [blame] | 139 | /* Make sure RISC/FIFO are off before changing FIFO/RISC settings */ |
| 140 | cx_clear(MO_AUD_DMACNTRL, 0x11); |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 141 | |
| 142 | /* setup fifo + format - out channel */ |
Trent Piepho | 59fd8f8 | 2007-08-18 22:09:42 -0300 | [diff] [blame] | 143 | cx88_sram_channel_setup(chip->core, audio_ch, buf->bpl, buf->risc.dma); |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 144 | |
| 145 | /* sets bpl size */ |
| 146 | cx_write(MO_AUDD_LNGTH, buf->bpl); |
| 147 | |
| 148 | /* reset counter */ |
Trent Piepho | 05b2723 | 2007-08-24 01:06:34 -0300 | [diff] [blame] | 149 | cx_write(MO_AUDD_GPCNTRL, GP_COUNT_CONTROL_RESET); |
| 150 | atomic_set(&chip->count, 0); |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 151 | |
Trent Piepho | 05b2723 | 2007-08-24 01:06:34 -0300 | [diff] [blame] | 152 | dprintk(1, "Start audio DMA, %d B/line, %d lines/FIFO, %d periods, %d " |
| 153 | "byte buffer\n", buf->bpl, cx_read(audio_ch->cmds_start + 8)>>1, |
Trent Piepho | 59fd8f8 | 2007-08-18 22:09:42 -0300 | [diff] [blame] | 154 | chip->num_periods, buf->bpl * chip->num_periods); |
| 155 | |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 156 | /* Enables corresponding bits at AUD_INT_STAT */ |
Trent Piepho | 59fd8f8 | 2007-08-18 22:09:42 -0300 | [diff] [blame] | 157 | cx_write(MO_AUD_INTMSK, AUD_INT_OPC_ERR | AUD_INT_DN_SYNC | |
| 158 | AUD_INT_DN_RISCI2 | AUD_INT_DN_RISCI1); |
| 159 | |
| 160 | /* Clean any pending interrupt bits already set */ |
| 161 | cx_write(MO_AUD_INTSTAT, ~0); |
| 162 | |
| 163 | /* enable audio irqs */ |
| 164 | cx_set(MO_PCI_INTMSK, chip->core->pci_irqmask | PCI_INT_AUDINT); |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 165 | |
| 166 | /* start dma */ |
| 167 | cx_set(MO_DEV_CNTRL2, (1<<5)); /* Enables Risc Processor */ |
| 168 | cx_set(MO_AUD_DMACNTRL, 0x11); /* audio downstream FIFO and RISC enable */ |
| 169 | |
| 170 | if (debug) |
Trent Piepho | 59fd8f8 | 2007-08-18 22:09:42 -0300 | [diff] [blame] | 171 | cx88_sram_channel_dump(chip->core, audio_ch); |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 172 | |
| 173 | return 0; |
| 174 | } |
| 175 | |
| 176 | /* |
| 177 | * BOARD Specific: Resets audio DMA |
| 178 | */ |
Mauro Carvalho Chehab | be8a82d | 2006-02-07 06:49:14 -0200 | [diff] [blame] | 179 | static int _cx88_stop_audio_dma(snd_cx88_card_t *chip) |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 180 | { |
| 181 | struct cx88_core *core=chip->core; |
| 182 | dprintk(1, "Stopping audio DMA\n"); |
| 183 | |
| 184 | /* stop dma */ |
| 185 | cx_clear(MO_AUD_DMACNTRL, 0x11); |
| 186 | |
| 187 | /* disable irqs */ |
Trent Piepho | 8ddac9e | 2007-08-18 06:57:55 -0300 | [diff] [blame] | 188 | cx_clear(MO_PCI_INTMSK, PCI_INT_AUDINT); |
Trent Piepho | 59fd8f8 | 2007-08-18 22:09:42 -0300 | [diff] [blame] | 189 | cx_clear(MO_AUD_INTMSK, AUD_INT_OPC_ERR | AUD_INT_DN_SYNC | |
| 190 | AUD_INT_DN_RISCI2 | AUD_INT_DN_RISCI1); |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 191 | |
| 192 | if (debug) |
| 193 | cx88_sram_channel_dump(chip->core, &cx88_sram_channels[SRAM_CH25]); |
| 194 | |
| 195 | return 0; |
| 196 | } |
| 197 | |
Trent Piepho | 05b2723 | 2007-08-24 01:06:34 -0300 | [diff] [blame] | 198 | #define MAX_IRQ_LOOP 50 |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 199 | |
| 200 | /* |
| 201 | * BOARD Specific: IRQ dma bits |
| 202 | */ |
lawrence rust | 2e4e98e | 2010-08-25 09:50:20 -0300 | [diff] [blame] | 203 | static const char *cx88_aud_irqs[32] = { |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 204 | "dn_risci1", "up_risci1", "rds_dn_risc1", /* 0-2 */ |
| 205 | NULL, /* reserved */ |
| 206 | "dn_risci2", "up_risci2", "rds_dn_risc2", /* 4-6 */ |
| 207 | NULL, /* reserved */ |
| 208 | "dnf_of", "upf_uf", "rds_dnf_uf", /* 8-10 */ |
| 209 | NULL, /* reserved */ |
| 210 | "dn_sync", "up_sync", "rds_dn_sync", /* 12-14 */ |
| 211 | NULL, /* reserved */ |
| 212 | "opc_err", "par_err", "rip_err", /* 16-18 */ |
| 213 | "pci_abort", "ber_irq", "mchg_irq" /* 19-21 */ |
| 214 | }; |
| 215 | |
| 216 | /* |
| 217 | * BOARD Specific: Threats IRQ audio specific calls |
| 218 | */ |
| 219 | static void cx8801_aud_irq(snd_cx88_card_t *chip) |
| 220 | { |
| 221 | struct cx88_core *core = chip->core; |
| 222 | u32 status, mask; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 223 | |
| 224 | status = cx_read(MO_AUD_INTSTAT); |
| 225 | mask = cx_read(MO_AUD_INTMSK); |
Trent Piepho | 05b2723 | 2007-08-24 01:06:34 -0300 | [diff] [blame] | 226 | if (0 == (status & mask)) |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 227 | return; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 228 | cx_write(MO_AUD_INTSTAT, status); |
| 229 | if (debug > 1 || (status & mask & ~0xff)) |
| 230 | cx88_print_irqbits(core->name, "irq aud", |
Mauro Carvalho Chehab | 66623a0 | 2007-03-29 08:47:04 -0300 | [diff] [blame] | 231 | cx88_aud_irqs, ARRAY_SIZE(cx88_aud_irqs), |
| 232 | status, mask); |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 233 | /* risc op code error */ |
Trent Piepho | 59fd8f8 | 2007-08-18 22:09:42 -0300 | [diff] [blame] | 234 | if (status & AUD_INT_OPC_ERR) { |
Trent Piepho | 05b2723 | 2007-08-24 01:06:34 -0300 | [diff] [blame] | 235 | printk(KERN_WARNING "%s/1: Audio risc op code error\n",core->name); |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 236 | cx_clear(MO_AUD_DMACNTRL, 0x11); |
| 237 | cx88_sram_channel_dump(core, &cx88_sram_channels[SRAM_CH25]); |
| 238 | } |
Trent Piepho | 05b2723 | 2007-08-24 01:06:34 -0300 | [diff] [blame] | 239 | if (status & AUD_INT_DN_SYNC) { |
| 240 | dprintk(1, "Downstream sync error\n"); |
| 241 | cx_write(MO_AUDD_GPCNTRL, GP_COUNT_CONTROL_RESET); |
| 242 | return; |
| 243 | } |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 244 | /* risc1 downstream */ |
Trent Piepho | 59fd8f8 | 2007-08-18 22:09:42 -0300 | [diff] [blame] | 245 | if (status & AUD_INT_DN_RISCI1) { |
Trent Piepho | 05b2723 | 2007-08-24 01:06:34 -0300 | [diff] [blame] | 246 | atomic_set(&chip->count, cx_read(MO_AUDD_GPCNT)); |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 247 | snd_pcm_period_elapsed(chip->substream); |
| 248 | } |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 249 | /* FIXME: Any other status should deserve a special handling? */ |
| 250 | } |
| 251 | |
| 252 | /* |
| 253 | * BOARD Specific: Handles IRQ calls |
| 254 | */ |
David Howells | 7d12e78 | 2006-10-05 14:55:46 +0100 | [diff] [blame] | 255 | static irqreturn_t cx8801_irq(int irq, void *dev_id) |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 256 | { |
| 257 | snd_cx88_card_t *chip = dev_id; |
| 258 | struct cx88_core *core = chip->core; |
| 259 | u32 status; |
| 260 | int loop, handled = 0; |
| 261 | |
| 262 | for (loop = 0; loop < MAX_IRQ_LOOP; loop++) { |
Trent Piepho | 8ddac9e | 2007-08-18 06:57:55 -0300 | [diff] [blame] | 263 | status = cx_read(MO_PCI_INTSTAT) & |
| 264 | (core->pci_irqmask | PCI_INT_AUDINT); |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 265 | if (0 == status) |
| 266 | goto out; |
Trent Piepho | 05b2723 | 2007-08-24 01:06:34 -0300 | [diff] [blame] | 267 | dprintk(3, "cx8801_irq loop %d/%d, status %x\n", |
| 268 | loop, MAX_IRQ_LOOP, status); |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 269 | handled = 1; |
| 270 | cx_write(MO_PCI_INTSTAT, status); |
| 271 | |
Trent Piepho | 5ba862b | 2007-08-18 07:02:26 -0300 | [diff] [blame] | 272 | if (status & core->pci_irqmask) |
| 273 | cx88_core_irq(core, status); |
Trent Piepho | 05b2723 | 2007-08-24 01:06:34 -0300 | [diff] [blame] | 274 | if (status & PCI_INT_AUDINT) |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 275 | cx8801_aud_irq(chip); |
Trent Piepho | 05b2723 | 2007-08-24 01:06:34 -0300 | [diff] [blame] | 276 | } |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 277 | |
| 278 | if (MAX_IRQ_LOOP == loop) { |
Trent Piepho | 05b2723 | 2007-08-24 01:06:34 -0300 | [diff] [blame] | 279 | printk(KERN_ERR |
| 280 | "%s/1: IRQ loop detected, disabling interrupts\n", |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 281 | core->name); |
Trent Piepho | 8ddac9e | 2007-08-18 06:57:55 -0300 | [diff] [blame] | 282 | cx_clear(MO_PCI_INTMSK, PCI_INT_AUDINT); |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 283 | } |
| 284 | |
| 285 | out: |
| 286 | return IRQ_RETVAL(handled); |
| 287 | } |
| 288 | |
| 289 | |
| 290 | static int dsp_buffer_free(snd_cx88_card_t *chip) |
| 291 | { |
| 292 | BUG_ON(!chip->dma_size); |
| 293 | |
| 294 | dprintk(2,"Freeing buffer\n"); |
Laurent Pinchart | 9526840 | 2010-05-11 10:36:30 -0300 | [diff] [blame] | 295 | videobuf_dma_unmap(&chip->pci->dev, chip->dma_risc); |
Mauro Carvalho Chehab | c1accaa | 2007-08-23 16:37:49 -0300 | [diff] [blame] | 296 | videobuf_dma_free(chip->dma_risc); |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 297 | btcx_riscmem_free(chip->pci,&chip->buf->risc); |
| 298 | kfree(chip->buf); |
| 299 | |
Mauro Carvalho Chehab | c1accaa | 2007-08-23 16:37:49 -0300 | [diff] [blame] | 300 | chip->dma_risc = NULL; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 301 | chip->dma_size = 0; |
| 302 | |
Trent Piepho | 05b2723 | 2007-08-24 01:06:34 -0300 | [diff] [blame] | 303 | return 0; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 304 | } |
| 305 | |
| 306 | /**************************************************************************** |
| 307 | ALSA PCM Interface |
| 308 | ****************************************************************************/ |
| 309 | |
| 310 | /* |
| 311 | * Digital hardware definition |
| 312 | */ |
Trent Piepho | 05b2723 | 2007-08-24 01:06:34 -0300 | [diff] [blame] | 313 | #define DEFAULT_FIFO_SIZE 4096 |
lawrence rust | 2e4e98e | 2010-08-25 09:50:20 -0300 | [diff] [blame] | 314 | static const struct snd_pcm_hardware snd_cx88_digital_hw = { |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 315 | .info = SNDRV_PCM_INFO_MMAP | |
| 316 | SNDRV_PCM_INFO_INTERLEAVED | |
| 317 | SNDRV_PCM_INFO_BLOCK_TRANSFER | |
| 318 | SNDRV_PCM_INFO_MMAP_VALID, |
| 319 | .formats = SNDRV_PCM_FMTBIT_S16_LE, |
| 320 | |
| 321 | .rates = SNDRV_PCM_RATE_48000, |
| 322 | .rate_min = 48000, |
| 323 | .rate_max = 48000, |
Trent Piepho | 5a5b3b5 | 2007-08-18 21:01:40 -0300 | [diff] [blame] | 324 | .channels_min = 2, |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 325 | .channels_max = 2, |
Trent Piepho | 05b2723 | 2007-08-24 01:06:34 -0300 | [diff] [blame] | 326 | /* Analog audio output will be full of clicks and pops if there |
| 327 | are not exactly four lines in the SRAM FIFO buffer. */ |
| 328 | .period_bytes_min = DEFAULT_FIFO_SIZE/4, |
| 329 | .period_bytes_max = DEFAULT_FIFO_SIZE/4, |
| 330 | .periods_min = 1, |
| 331 | .periods_max = 1024, |
| 332 | .buffer_bytes_max = (1024*1024), |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 333 | }; |
| 334 | |
| 335 | /* |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 336 | * audio pcm capture open callback |
| 337 | */ |
Takashi Iwai | f7cbb7f | 2006-01-13 18:48:06 +0100 | [diff] [blame] | 338 | static int snd_cx88_pcm_open(struct snd_pcm_substream *substream) |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 339 | { |
| 340 | snd_cx88_card_t *chip = snd_pcm_substream_chip(substream); |
Takashi Iwai | f7cbb7f | 2006-01-13 18:48:06 +0100 | [diff] [blame] | 341 | struct snd_pcm_runtime *runtime = substream->runtime; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 342 | int err; |
| 343 | |
Mauro Carvalho Chehab | 83ee87a | 2008-06-14 09:41:18 -0300 | [diff] [blame] | 344 | if (!chip) { |
| 345 | printk(KERN_ERR "BUG: cx88 can't find device struct." |
| 346 | " Can't proceed with open\n"); |
| 347 | return -ENODEV; |
| 348 | } |
| 349 | |
Trent Piepho | 05b2723 | 2007-08-24 01:06:34 -0300 | [diff] [blame] | 350 | err = snd_pcm_hw_constraint_pow2(runtime, 0, SNDRV_PCM_HW_PARAM_PERIODS); |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 351 | if (err < 0) |
| 352 | goto _error; |
| 353 | |
| 354 | chip->substream = substream; |
| 355 | |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 356 | runtime->hw = snd_cx88_digital_hw; |
| 357 | |
Trent Piepho | 05b2723 | 2007-08-24 01:06:34 -0300 | [diff] [blame] | 358 | if (cx88_sram_channels[SRAM_CH25].fifo_size != DEFAULT_FIFO_SIZE) { |
| 359 | unsigned int bpl = cx88_sram_channels[SRAM_CH25].fifo_size / 4; |
| 360 | bpl &= ~7; /* must be multiple of 8 */ |
| 361 | runtime->hw.period_bytes_min = bpl; |
| 362 | runtime->hw.period_bytes_max = bpl; |
| 363 | } |
| 364 | |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 365 | return 0; |
| 366 | _error: |
| 367 | dprintk(1,"Error opening PCM!\n"); |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 368 | return err; |
| 369 | } |
| 370 | |
| 371 | /* |
| 372 | * audio close callback |
| 373 | */ |
Takashi Iwai | f7cbb7f | 2006-01-13 18:48:06 +0100 | [diff] [blame] | 374 | static int snd_cx88_close(struct snd_pcm_substream *substream) |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 375 | { |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 376 | return 0; |
| 377 | } |
| 378 | |
| 379 | /* |
| 380 | * hw_params callback |
| 381 | */ |
Takashi Iwai | f7cbb7f | 2006-01-13 18:48:06 +0100 | [diff] [blame] | 382 | static int snd_cx88_hw_params(struct snd_pcm_substream * substream, |
| 383 | struct snd_pcm_hw_params * hw_params) |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 384 | { |
| 385 | snd_cx88_card_t *chip = snd_pcm_substream_chip(substream); |
Mauro Carvalho Chehab | c1accaa | 2007-08-23 16:37:49 -0300 | [diff] [blame] | 386 | struct videobuf_dmabuf *dma; |
| 387 | |
Laurent Pinchart | fecfede | 2010-05-11 10:36:31 -0300 | [diff] [blame] | 388 | struct cx88_audio_buffer *buf; |
Trent Piepho | 05b2723 | 2007-08-24 01:06:34 -0300 | [diff] [blame] | 389 | int ret; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 390 | |
| 391 | if (substream->runtime->dma_area) { |
| 392 | dsp_buffer_free(chip); |
| 393 | substream->runtime->dma_area = NULL; |
| 394 | } |
| 395 | |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 396 | chip->period_size = params_period_bytes(hw_params); |
| 397 | chip->num_periods = params_periods(hw_params); |
| 398 | chip->dma_size = chip->period_size * params_periods(hw_params); |
| 399 | |
| 400 | BUG_ON(!chip->dma_size); |
Trent Piepho | 05b2723 | 2007-08-24 01:06:34 -0300 | [diff] [blame] | 401 | BUG_ON(chip->num_periods & (chip->num_periods-1)); |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 402 | |
Laurent Pinchart | fecfede | 2010-05-11 10:36:31 -0300 | [diff] [blame] | 403 | buf = kzalloc(sizeof(*buf), GFP_KERNEL); |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 404 | if (NULL == buf) |
| 405 | return -ENOMEM; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 406 | |
Laurent Pinchart | fecfede | 2010-05-11 10:36:31 -0300 | [diff] [blame] | 407 | buf->bpl = chip->period_size; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 408 | |
Laurent Pinchart | fecfede | 2010-05-11 10:36:31 -0300 | [diff] [blame] | 409 | dma = &buf->dma; |
Mauro Carvalho Chehab | c1accaa | 2007-08-23 16:37:49 -0300 | [diff] [blame] | 410 | videobuf_dma_init(dma); |
| 411 | ret = videobuf_dma_init_kernel(dma, PCI_DMA_FROMDEVICE, |
Laurent Pinchart | fecfede | 2010-05-11 10:36:31 -0300 | [diff] [blame] | 412 | (PAGE_ALIGN(chip->dma_size) >> PAGE_SHIFT)); |
Trent Piepho | 05b2723 | 2007-08-24 01:06:34 -0300 | [diff] [blame] | 413 | if (ret < 0) |
| 414 | goto error; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 415 | |
Laurent Pinchart | 9526840 | 2010-05-11 10:36:30 -0300 | [diff] [blame] | 416 | ret = videobuf_dma_map(&chip->pci->dev, dma); |
Trent Piepho | 05b2723 | 2007-08-24 01:06:34 -0300 | [diff] [blame] | 417 | if (ret < 0) |
| 418 | goto error; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 419 | |
Mauro Carvalho Chehab | c1accaa | 2007-08-23 16:37:49 -0300 | [diff] [blame] | 420 | ret = cx88_risc_databuffer(chip->pci, &buf->risc, dma->sglist, |
Laurent Pinchart | fecfede | 2010-05-11 10:36:31 -0300 | [diff] [blame] | 421 | chip->period_size, chip->num_periods, 1); |
Trent Piepho | 05b2723 | 2007-08-24 01:06:34 -0300 | [diff] [blame] | 422 | if (ret < 0) |
| 423 | goto error; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 424 | |
Trent Piepho | 05b2723 | 2007-08-24 01:06:34 -0300 | [diff] [blame] | 425 | /* Loop back to start of program */ |
| 426 | buf->risc.jmp[0] = cpu_to_le32(RISC_JUMP|RISC_IRQ1|RISC_CNT_INC); |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 427 | buf->risc.jmp[1] = cpu_to_le32(buf->risc.dma); |
| 428 | |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 429 | chip->buf = buf; |
Mauro Carvalho Chehab | c1accaa | 2007-08-23 16:37:49 -0300 | [diff] [blame] | 430 | chip->dma_risc = dma; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 431 | |
Laurent Pinchart | bb6dbe7 | 2010-05-11 10:36:34 -0300 | [diff] [blame] | 432 | substream->runtime->dma_area = chip->dma_risc->vaddr; |
Trent Piepho | f6210c9 | 2007-08-24 01:06:36 -0300 | [diff] [blame] | 433 | substream->runtime->dma_bytes = chip->dma_size; |
| 434 | substream->runtime->dma_addr = 0; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 435 | return 0; |
Trent Piepho | 05b2723 | 2007-08-24 01:06:34 -0300 | [diff] [blame] | 436 | |
| 437 | error: |
| 438 | kfree(buf); |
| 439 | return ret; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 440 | } |
| 441 | |
| 442 | /* |
| 443 | * hw free callback |
| 444 | */ |
Takashi Iwai | f7cbb7f | 2006-01-13 18:48:06 +0100 | [diff] [blame] | 445 | static int snd_cx88_hw_free(struct snd_pcm_substream * substream) |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 446 | { |
| 447 | |
| 448 | snd_cx88_card_t *chip = snd_pcm_substream_chip(substream); |
| 449 | |
| 450 | if (substream->runtime->dma_area) { |
| 451 | dsp_buffer_free(chip); |
| 452 | substream->runtime->dma_area = NULL; |
| 453 | } |
| 454 | |
| 455 | return 0; |
| 456 | } |
| 457 | |
| 458 | /* |
| 459 | * prepare callback |
| 460 | */ |
Takashi Iwai | f7cbb7f | 2006-01-13 18:48:06 +0100 | [diff] [blame] | 461 | static int snd_cx88_prepare(struct snd_pcm_substream *substream) |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 462 | { |
| 463 | return 0; |
| 464 | } |
| 465 | |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 466 | /* |
| 467 | * trigger callback |
| 468 | */ |
Takashi Iwai | f7cbb7f | 2006-01-13 18:48:06 +0100 | [diff] [blame] | 469 | static int snd_cx88_card_trigger(struct snd_pcm_substream *substream, int cmd) |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 470 | { |
| 471 | snd_cx88_card_t *chip = snd_pcm_substream_chip(substream); |
| 472 | int err; |
| 473 | |
Trent Piepho | 05b2723 | 2007-08-24 01:06:34 -0300 | [diff] [blame] | 474 | /* Local interrupts are already disabled by ALSA */ |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 475 | spin_lock(&chip->reg_lock); |
| 476 | |
| 477 | switch (cmd) { |
| 478 | case SNDRV_PCM_TRIGGER_START: |
| 479 | err=_cx88_start_audio_dma(chip); |
| 480 | break; |
| 481 | case SNDRV_PCM_TRIGGER_STOP: |
| 482 | err=_cx88_stop_audio_dma(chip); |
| 483 | break; |
| 484 | default: |
| 485 | err=-EINVAL; |
| 486 | break; |
| 487 | } |
| 488 | |
| 489 | spin_unlock(&chip->reg_lock); |
| 490 | |
| 491 | return err; |
| 492 | } |
| 493 | |
| 494 | /* |
| 495 | * pointer callback |
| 496 | */ |
Takashi Iwai | f7cbb7f | 2006-01-13 18:48:06 +0100 | [diff] [blame] | 497 | static snd_pcm_uframes_t snd_cx88_pointer(struct snd_pcm_substream *substream) |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 498 | { |
| 499 | snd_cx88_card_t *chip = snd_pcm_substream_chip(substream); |
Takashi Iwai | f7cbb7f | 2006-01-13 18:48:06 +0100 | [diff] [blame] | 500 | struct snd_pcm_runtime *runtime = substream->runtime; |
Trent Piepho | 05b2723 | 2007-08-24 01:06:34 -0300 | [diff] [blame] | 501 | u16 count; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 502 | |
Trent Piepho | 05b2723 | 2007-08-24 01:06:34 -0300 | [diff] [blame] | 503 | count = atomic_read(&chip->count); |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 504 | |
Harvey Harrison | 32d83ef | 2008-04-08 23:20:00 -0300 | [diff] [blame] | 505 | // dprintk(2, "%s - count %d (+%u), period %d, frame %lu\n", __func__, |
Trent Piepho | 05b2723 | 2007-08-24 01:06:34 -0300 | [diff] [blame] | 506 | // count, new, count & (runtime->periods-1), |
| 507 | // runtime->period_size * (count & (runtime->periods-1))); |
| 508 | return runtime->period_size * (count & (runtime->periods-1)); |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 509 | } |
| 510 | |
| 511 | /* |
Trent Piepho | f6210c9 | 2007-08-24 01:06:36 -0300 | [diff] [blame] | 512 | * page callback (needed for mmap) |
| 513 | */ |
| 514 | static struct page *snd_cx88_page(struct snd_pcm_substream *substream, |
| 515 | unsigned long offset) |
| 516 | { |
| 517 | void *pageptr = substream->runtime->dma_area + offset; |
| 518 | return vmalloc_to_page(pageptr); |
| 519 | } |
| 520 | |
| 521 | /* |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 522 | * operators |
| 523 | */ |
Takashi Iwai | f7cbb7f | 2006-01-13 18:48:06 +0100 | [diff] [blame] | 524 | static struct snd_pcm_ops snd_cx88_pcm_ops = { |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 525 | .open = snd_cx88_pcm_open, |
| 526 | .close = snd_cx88_close, |
| 527 | .ioctl = snd_pcm_lib_ioctl, |
| 528 | .hw_params = snd_cx88_hw_params, |
| 529 | .hw_free = snd_cx88_hw_free, |
| 530 | .prepare = snd_cx88_prepare, |
| 531 | .trigger = snd_cx88_card_trigger, |
| 532 | .pointer = snd_cx88_pointer, |
Trent Piepho | f6210c9 | 2007-08-24 01:06:36 -0300 | [diff] [blame] | 533 | .page = snd_cx88_page, |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 534 | }; |
| 535 | |
| 536 | /* |
| 537 | * create a PCM device |
| 538 | */ |
lawrence rust | 2e4e98e | 2010-08-25 09:50:20 -0300 | [diff] [blame] | 539 | static int __devinit snd_cx88_pcm(snd_cx88_card_t *chip, int device, const char *name) |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 540 | { |
| 541 | int err; |
Takashi Iwai | f7cbb7f | 2006-01-13 18:48:06 +0100 | [diff] [blame] | 542 | struct snd_pcm *pcm; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 543 | |
| 544 | err = snd_pcm_new(chip->card, name, device, 0, 1, &pcm); |
| 545 | if (err < 0) |
| 546 | return err; |
| 547 | pcm->private_data = chip; |
| 548 | strcpy(pcm->name, name); |
| 549 | snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_cx88_pcm_ops); |
| 550 | |
| 551 | return 0; |
| 552 | } |
| 553 | |
| 554 | /**************************************************************************** |
| 555 | CONTROL INTERFACE |
| 556 | ****************************************************************************/ |
Trent Piepho | 54ac005 | 2007-09-06 23:02:23 -0300 | [diff] [blame] | 557 | static int snd_cx88_volume_info(struct snd_kcontrol *kcontrol, |
| 558 | struct snd_ctl_elem_info *info) |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 559 | { |
| 560 | info->type = SNDRV_CTL_ELEM_TYPE_INTEGER; |
Trent Piepho | 82896f2 | 2007-09-06 23:02:23 -0300 | [diff] [blame] | 561 | info->count = 2; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 562 | info->value.integer.min = 0; |
| 563 | info->value.integer.max = 0x3f; |
| 564 | |
| 565 | return 0; |
| 566 | } |
| 567 | |
Trent Piepho | 54ac005 | 2007-09-06 23:02:23 -0300 | [diff] [blame] | 568 | static int snd_cx88_volume_get(struct snd_kcontrol *kcontrol, |
| 569 | struct snd_ctl_elem_value *value) |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 570 | { |
| 571 | snd_cx88_card_t *chip = snd_kcontrol_chip(kcontrol); |
| 572 | struct cx88_core *core=chip->core; |
Trent Piepho | 82896f2 | 2007-09-06 23:02:23 -0300 | [diff] [blame] | 573 | int vol = 0x3f - (cx_read(AUD_VOL_CTL) & 0x3f), |
| 574 | bal = cx_read(AUD_BAL_CTL); |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 575 | |
Trent Piepho | 82896f2 | 2007-09-06 23:02:23 -0300 | [diff] [blame] | 576 | value->value.integer.value[(bal & 0x40) ? 0 : 1] = vol; |
| 577 | vol -= (bal & 0x3f); |
| 578 | value->value.integer.value[(bal & 0x40) ? 1 : 0] = vol < 0 ? 0 : vol; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 579 | |
| 580 | return 0; |
| 581 | } |
| 582 | |
Lawrence Rust | 6951803 | 2011-02-06 17:46:12 -0300 | [diff] [blame] | 583 | static void snd_cx88_wm8775_volume_put(struct snd_kcontrol *kcontrol, |
| 584 | struct snd_ctl_elem_value *value) |
| 585 | { |
| 586 | snd_cx88_card_t *chip = snd_kcontrol_chip(kcontrol); |
| 587 | struct cx88_core *core = chip->core; |
| 588 | struct v4l2_control client_ctl; |
| 589 | int left = value->value.integer.value[0]; |
| 590 | int right = value->value.integer.value[1]; |
| 591 | int v, b; |
| 592 | |
| 593 | memset(&client_ctl, 0, sizeof(client_ctl)); |
| 594 | |
| 595 | /* Pass volume & balance onto any WM8775 */ |
| 596 | if (left >= right) { |
| 597 | v = left << 10; |
| 598 | b = left ? (0x8000 * right) / left : 0x8000; |
| 599 | } else { |
| 600 | v = right << 10; |
| 601 | b = right ? 0xffff - (0x8000 * left) / right : 0x8000; |
| 602 | } |
| 603 | client_ctl.value = v; |
| 604 | client_ctl.id = V4L2_CID_AUDIO_VOLUME; |
| 605 | call_hw(core, WM8775_GID, core, s_ctrl, &client_ctl); |
| 606 | |
| 607 | client_ctl.value = b; |
| 608 | client_ctl.id = V4L2_CID_AUDIO_BALANCE; |
| 609 | call_hw(core, WM8775_GID, core, s_ctrl, &client_ctl); |
| 610 | } |
| 611 | |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 612 | /* OK - TODO: test it */ |
Trent Piepho | 54ac005 | 2007-09-06 23:02:23 -0300 | [diff] [blame] | 613 | static int snd_cx88_volume_put(struct snd_kcontrol *kcontrol, |
| 614 | struct snd_ctl_elem_value *value) |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 615 | { |
| 616 | snd_cx88_card_t *chip = snd_kcontrol_chip(kcontrol); |
| 617 | struct cx88_core *core=chip->core; |
Clemens Ladisch | cca80b9 | 2010-02-22 06:45:07 -0300 | [diff] [blame] | 618 | int left, right, v, b; |
Trent Piepho | 82896f2 | 2007-09-06 23:02:23 -0300 | [diff] [blame] | 619 | int changed = 0; |
| 620 | u32 old; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 621 | |
Lawrence Rust | 6951803 | 2011-02-06 17:46:12 -0300 | [diff] [blame] | 622 | if (core->board.audio_chip == V4L2_IDENT_WM8775) |
| 623 | snd_cx88_wm8775_volume_put(kcontrol, value); |
| 624 | |
Clemens Ladisch | cca80b9 | 2010-02-22 06:45:07 -0300 | [diff] [blame] | 625 | left = value->value.integer.value[0] & 0x3f; |
| 626 | right = value->value.integer.value[1] & 0x3f; |
| 627 | b = right - left; |
Trent Piepho | 82896f2 | 2007-09-06 23:02:23 -0300 | [diff] [blame] | 628 | if (b < 0) { |
Lawrence Rust | 6951803 | 2011-02-06 17:46:12 -0300 | [diff] [blame] | 629 | v = 0x3f - left; |
| 630 | b = (-b) | 0x40; |
Trent Piepho | 82896f2 | 2007-09-06 23:02:23 -0300 | [diff] [blame] | 631 | } else { |
Lawrence Rust | 6951803 | 2011-02-06 17:46:12 -0300 | [diff] [blame] | 632 | v = 0x3f - right; |
Trent Piepho | 82896f2 | 2007-09-06 23:02:23 -0300 | [diff] [blame] | 633 | } |
Trent Piepho | 05b2723 | 2007-08-24 01:06:34 -0300 | [diff] [blame] | 634 | /* Do we really know this will always be called with IRQs on? */ |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 635 | spin_lock_irq(&chip->reg_lock); |
Trent Piepho | 82896f2 | 2007-09-06 23:02:23 -0300 | [diff] [blame] | 636 | old = cx_read(AUD_VOL_CTL); |
| 637 | if (v != (old & 0x3f)) { |
Lawrence Rust | 6951803 | 2011-02-06 17:46:12 -0300 | [diff] [blame] | 638 | cx_swrite(SHADOW_AUD_VOL_CTL, AUD_VOL_CTL, (old & ~0x3f) | v); |
| 639 | changed = 1; |
Trent Piepho | 82896f2 | 2007-09-06 23:02:23 -0300 | [diff] [blame] | 640 | } |
Lawrence Rust | 6951803 | 2011-02-06 17:46:12 -0300 | [diff] [blame] | 641 | if ((cx_read(AUD_BAL_CTL) & 0x7f) != b) { |
| 642 | cx_write(AUD_BAL_CTL, b); |
| 643 | changed = 1; |
Trent Piepho | 82896f2 | 2007-09-06 23:02:23 -0300 | [diff] [blame] | 644 | } |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 645 | spin_unlock_irq(&chip->reg_lock); |
| 646 | |
Trent Piepho | 82896f2 | 2007-09-06 23:02:23 -0300 | [diff] [blame] | 647 | return changed; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 648 | } |
| 649 | |
Trent Piepho | bbaccc0 | 2007-09-06 23:02:25 -0300 | [diff] [blame] | 650 | static const DECLARE_TLV_DB_SCALE(snd_cx88_db_scale, -6300, 100, 0); |
| 651 | |
lawrence rust | 2e4e98e | 2010-08-25 09:50:20 -0300 | [diff] [blame] | 652 | static const struct snd_kcontrol_new snd_cx88_volume = { |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 653 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, |
Trent Piepho | bbaccc0 | 2007-09-06 23:02:25 -0300 | [diff] [blame] | 654 | .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | |
| 655 | SNDRV_CTL_ELEM_ACCESS_TLV_READ, |
Lawrence Rust | 6951803 | 2011-02-06 17:46:12 -0300 | [diff] [blame] | 656 | .name = "Analog-TV Volume", |
Trent Piepho | 54ac005 | 2007-09-06 23:02:23 -0300 | [diff] [blame] | 657 | .info = snd_cx88_volume_info, |
| 658 | .get = snd_cx88_volume_get, |
| 659 | .put = snd_cx88_volume_put, |
Trent Piepho | bbaccc0 | 2007-09-06 23:02:25 -0300 | [diff] [blame] | 660 | .tlv.p = snd_cx88_db_scale, |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 661 | }; |
| 662 | |
Trent Piepho | 54ac005 | 2007-09-06 23:02:23 -0300 | [diff] [blame] | 663 | static int snd_cx88_switch_get(struct snd_kcontrol *kcontrol, |
| 664 | struct snd_ctl_elem_value *value) |
| 665 | { |
| 666 | snd_cx88_card_t *chip = snd_kcontrol_chip(kcontrol); |
| 667 | struct cx88_core *core = chip->core; |
| 668 | u32 bit = kcontrol->private_value; |
| 669 | |
| 670 | value->value.integer.value[0] = !(cx_read(AUD_VOL_CTL) & bit); |
| 671 | return 0; |
| 672 | } |
| 673 | |
| 674 | static int snd_cx88_switch_put(struct snd_kcontrol *kcontrol, |
| 675 | struct snd_ctl_elem_value *value) |
| 676 | { |
| 677 | snd_cx88_card_t *chip = snd_kcontrol_chip(kcontrol); |
| 678 | struct cx88_core *core = chip->core; |
| 679 | u32 bit = kcontrol->private_value; |
| 680 | int ret = 0; |
| 681 | u32 vol; |
| 682 | |
| 683 | spin_lock_irq(&chip->reg_lock); |
| 684 | vol = cx_read(AUD_VOL_CTL); |
| 685 | if (value->value.integer.value[0] != !(vol & bit)) { |
| 686 | vol ^= bit; |
Lawrence Rust | 6951803 | 2011-02-06 17:46:12 -0300 | [diff] [blame] | 687 | cx_swrite(SHADOW_AUD_VOL_CTL, AUD_VOL_CTL, vol); |
| 688 | /* Pass mute onto any WM8775 */ |
| 689 | if ((core->board.audio_chip == V4L2_IDENT_WM8775) && |
| 690 | ((1<<6) == bit)) { |
| 691 | struct v4l2_control client_ctl; |
| 692 | |
| 693 | memset(&client_ctl, 0, sizeof(client_ctl)); |
| 694 | client_ctl.value = 0 != (vol & bit); |
| 695 | client_ctl.id = V4L2_CID_AUDIO_MUTE; |
| 696 | call_hw(core, WM8775_GID, core, s_ctrl, &client_ctl); |
| 697 | } |
Trent Piepho | 54ac005 | 2007-09-06 23:02:23 -0300 | [diff] [blame] | 698 | ret = 1; |
| 699 | } |
| 700 | spin_unlock_irq(&chip->reg_lock); |
| 701 | return ret; |
| 702 | } |
| 703 | |
lawrence rust | 2e4e98e | 2010-08-25 09:50:20 -0300 | [diff] [blame] | 704 | static const struct snd_kcontrol_new snd_cx88_dac_switch = { |
Trent Piepho | 54ac005 | 2007-09-06 23:02:23 -0300 | [diff] [blame] | 705 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, |
Lawrence Rust | 6951803 | 2011-02-06 17:46:12 -0300 | [diff] [blame] | 706 | .name = "Audio-Out Switch", |
Trent Piepho | 54ac005 | 2007-09-06 23:02:23 -0300 | [diff] [blame] | 707 | .info = snd_ctl_boolean_mono_info, |
| 708 | .get = snd_cx88_switch_get, |
| 709 | .put = snd_cx88_switch_put, |
| 710 | .private_value = (1<<8), |
| 711 | }; |
| 712 | |
lawrence rust | 2e4e98e | 2010-08-25 09:50:20 -0300 | [diff] [blame] | 713 | static const struct snd_kcontrol_new snd_cx88_source_switch = { |
Trent Piepho | 54ac005 | 2007-09-06 23:02:23 -0300 | [diff] [blame] | 714 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, |
Lawrence Rust | 6951803 | 2011-02-06 17:46:12 -0300 | [diff] [blame] | 715 | .name = "Analog-TV Switch", |
Trent Piepho | 54ac005 | 2007-09-06 23:02:23 -0300 | [diff] [blame] | 716 | .info = snd_ctl_boolean_mono_info, |
| 717 | .get = snd_cx88_switch_get, |
| 718 | .put = snd_cx88_switch_put, |
| 719 | .private_value = (1<<6), |
| 720 | }; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 721 | |
Lawrence Rust | 6951803 | 2011-02-06 17:46:12 -0300 | [diff] [blame] | 722 | static int snd_cx88_alc_get(struct snd_kcontrol *kcontrol, |
| 723 | struct snd_ctl_elem_value *value) |
| 724 | { |
| 725 | snd_cx88_card_t *chip = snd_kcontrol_chip(kcontrol); |
| 726 | struct cx88_core *core = chip->core; |
| 727 | struct v4l2_control client_ctl; |
| 728 | |
| 729 | memset(&client_ctl, 0, sizeof(client_ctl)); |
| 730 | client_ctl.id = V4L2_CID_AUDIO_LOUDNESS; |
| 731 | call_hw(core, WM8775_GID, core, g_ctrl, &client_ctl); |
| 732 | value->value.integer.value[0] = client_ctl.value ? 1 : 0; |
| 733 | |
| 734 | return 0; |
| 735 | } |
| 736 | |
| 737 | static int snd_cx88_alc_put(struct snd_kcontrol *kcontrol, |
| 738 | struct snd_ctl_elem_value *value) |
| 739 | { |
| 740 | snd_cx88_card_t *chip = snd_kcontrol_chip(kcontrol); |
| 741 | struct cx88_core *core = chip->core; |
| 742 | struct v4l2_control client_ctl; |
| 743 | |
| 744 | memset(&client_ctl, 0, sizeof(client_ctl)); |
| 745 | client_ctl.value = 0 != value->value.integer.value[0]; |
| 746 | client_ctl.id = V4L2_CID_AUDIO_LOUDNESS; |
| 747 | call_hw(core, WM8775_GID, core, s_ctrl, &client_ctl); |
| 748 | |
| 749 | return 0; |
| 750 | } |
| 751 | |
| 752 | static struct snd_kcontrol_new snd_cx88_alc_switch = { |
| 753 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, |
| 754 | .name = "Line-In ALC Switch", |
| 755 | .info = snd_ctl_boolean_mono_info, |
| 756 | .get = snd_cx88_alc_get, |
| 757 | .put = snd_cx88_alc_put, |
| 758 | }; |
| 759 | |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 760 | /**************************************************************************** |
| 761 | Basic Flow for Sound Devices |
| 762 | ****************************************************************************/ |
| 763 | |
| 764 | /* |
| 765 | * PCI ID Table - 14f1:8801 and 14f1:8811 means function 1: Audio |
| 766 | * Only boards with eeprom and byte 1 at eeprom=1 have it |
| 767 | */ |
| 768 | |
lawrence rust | 2e4e98e | 2010-08-25 09:50:20 -0300 | [diff] [blame] | 769 | static const struct pci_device_id const cx88_audio_pci_tbl[] __devinitdata = { |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 770 | {0x14f1,0x8801,PCI_ANY_ID,PCI_ANY_ID,0,0,0}, |
| 771 | {0x14f1,0x8811,PCI_ANY_ID,PCI_ANY_ID,0,0,0}, |
| 772 | {0, } |
| 773 | }; |
| 774 | MODULE_DEVICE_TABLE(pci, cx88_audio_pci_tbl); |
| 775 | |
| 776 | /* |
| 777 | * Chip-specific destructor |
| 778 | */ |
| 779 | |
| 780 | static int snd_cx88_free(snd_cx88_card_t *chip) |
| 781 | { |
| 782 | |
Jeff Garzik | f000fd8 | 2008-04-22 13:50:34 +0200 | [diff] [blame] | 783 | if (chip->irq >= 0) |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 784 | free_irq(chip->irq, chip); |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 785 | |
| 786 | cx88_core_put(chip->core,chip->pci); |
| 787 | |
| 788 | pci_disable_device(chip->pci); |
| 789 | return 0; |
| 790 | } |
| 791 | |
| 792 | /* |
| 793 | * Component Destructor |
| 794 | */ |
Takashi Iwai | f7cbb7f | 2006-01-13 18:48:06 +0100 | [diff] [blame] | 795 | static void snd_cx88_dev_free(struct snd_card * card) |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 796 | { |
| 797 | snd_cx88_card_t *chip = card->private_data; |
| 798 | |
| 799 | snd_cx88_free(chip); |
| 800 | } |
| 801 | |
| 802 | |
| 803 | /* |
| 804 | * Alsa Constructor - Component probe |
| 805 | */ |
| 806 | |
Mauro Carvalho Chehab | a5ed425 | 2006-01-13 14:10:19 -0200 | [diff] [blame] | 807 | static int devno; |
Takashi Iwai | f7cbb7f | 2006-01-13 18:48:06 +0100 | [diff] [blame] | 808 | static int __devinit snd_cx88_create(struct snd_card *card, |
| 809 | struct pci_dev *pci, |
Lawrence Rust | 6951803 | 2011-02-06 17:46:12 -0300 | [diff] [blame] | 810 | snd_cx88_card_t **rchip, |
| 811 | struct cx88_core **core_ptr) |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 812 | { |
| 813 | snd_cx88_card_t *chip; |
| 814 | struct cx88_core *core; |
| 815 | int err; |
Trent Piepho | 19453bc | 2007-08-18 22:54:49 -0300 | [diff] [blame] | 816 | unsigned char pci_lat; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 817 | |
| 818 | *rchip = NULL; |
| 819 | |
| 820 | err = pci_enable_device(pci); |
| 821 | if (err < 0) |
| 822 | return err; |
| 823 | |
| 824 | pci_set_master(pci); |
| 825 | |
Joe Perches | abf8438 | 2010-07-12 17:50:03 -0300 | [diff] [blame] | 826 | chip = card->private_data; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 827 | |
| 828 | core = cx88_core_get(pci); |
Duncan Sands | 31dcbf9 | 2006-03-14 12:12:39 -0300 | [diff] [blame] | 829 | if (NULL == core) { |
| 830 | err = -EINVAL; |
Duncan Sands | 31dcbf9 | 2006-03-14 12:12:39 -0300 | [diff] [blame] | 831 | return err; |
| 832 | } |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 833 | |
Yang Hongyang | 284901a | 2009-04-06 19:01:15 -0700 | [diff] [blame] | 834 | if (!pci_dma_supported(pci,DMA_BIT_MASK(32))) { |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 835 | dprintk(0, "%s/1: Oops: no 32bit PCI DMA ???\n",core->name); |
| 836 | err = -EIO; |
Lawrence Rust | 6951803 | 2011-02-06 17:46:12 -0300 | [diff] [blame] | 837 | cx88_core_put(core, pci); |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 838 | return err; |
| 839 | } |
| 840 | |
| 841 | |
| 842 | /* pci init */ |
| 843 | chip->card = card; |
| 844 | chip->pci = pci; |
| 845 | chip->irq = -1; |
| 846 | spin_lock_init(&chip->reg_lock); |
| 847 | |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 848 | chip->core = core; |
| 849 | |
| 850 | /* get irq */ |
| 851 | err = request_irq(chip->pci->irq, cx8801_irq, |
Thomas Gleixner | 8076fe3 | 2006-07-01 19:29:37 -0700 | [diff] [blame] | 852 | IRQF_SHARED | IRQF_DISABLED, chip->core->name, chip); |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 853 | if (err < 0) { |
| 854 | dprintk(0, "%s: can't get IRQ %d\n", |
| 855 | chip->core->name, chip->pci->irq); |
| 856 | return err; |
| 857 | } |
| 858 | |
| 859 | /* print pci info */ |
Trent Piepho | 19453bc | 2007-08-18 22:54:49 -0300 | [diff] [blame] | 860 | pci_read_config_byte(pci, PCI_LATENCY_TIMER, &pci_lat); |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 861 | |
| 862 | dprintk(1,"ALSA %s/%i: found at %s, rev: %d, irq: %d, " |
Greg Kroah-Hartman | 228aef6 | 2006-06-12 15:16:52 -0700 | [diff] [blame] | 863 | "latency: %d, mmio: 0x%llx\n", core->name, devno, |
Trent Piepho | 19453bc | 2007-08-18 22:54:49 -0300 | [diff] [blame] | 864 | pci_name(pci), pci->revision, pci->irq, |
| 865 | pci_lat, (unsigned long long)pci_resource_start(pci,0)); |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 866 | |
| 867 | chip->irq = pci->irq; |
| 868 | synchronize_irq(chip->irq); |
| 869 | |
| 870 | snd_card_set_dev(card, &pci->dev); |
| 871 | |
| 872 | *rchip = chip; |
Lawrence Rust | 6951803 | 2011-02-06 17:46:12 -0300 | [diff] [blame] | 873 | *core_ptr = core; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 874 | |
| 875 | return 0; |
| 876 | } |
| 877 | |
| 878 | static int __devinit cx88_audio_initdev(struct pci_dev *pci, |
| 879 | const struct pci_device_id *pci_id) |
| 880 | { |
Takashi Iwai | f7cbb7f | 2006-01-13 18:48:06 +0100 | [diff] [blame] | 881 | struct snd_card *card; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 882 | snd_cx88_card_t *chip; |
Hans Verkuil | d6972cc | 2011-03-06 09:31:00 -0300 | [diff] [blame] | 883 | struct cx88_core *core = NULL; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 884 | int err; |
| 885 | |
| 886 | if (devno >= SNDRV_CARDS) |
| 887 | return (-ENODEV); |
| 888 | |
| 889 | if (!enable[devno]) { |
| 890 | ++devno; |
| 891 | return (-ENOENT); |
| 892 | } |
| 893 | |
Takashi Iwai | 758021b | 2009-01-12 15:17:09 +0100 | [diff] [blame] | 894 | err = snd_card_create(index[devno], id[devno], THIS_MODULE, |
| 895 | sizeof(snd_cx88_card_t), &card); |
| 896 | if (err < 0) |
| 897 | return err; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 898 | |
| 899 | card->private_free = snd_cx88_dev_free; |
| 900 | |
Lawrence Rust | 6951803 | 2011-02-06 17:46:12 -0300 | [diff] [blame] | 901 | err = snd_cx88_create(card, pci, &chip, &core); |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 902 | if (err < 0) |
Julia Lawall | a8782f6 | 2008-12-02 19:34:52 -0300 | [diff] [blame] | 903 | goto error; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 904 | |
| 905 | err = snd_cx88_pcm(chip, 0, "CX88 Digital"); |
Trent Piepho | 82896f2 | 2007-09-06 23:02:23 -0300 | [diff] [blame] | 906 | if (err < 0) |
| 907 | goto error; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 908 | |
Trent Piepho | 54ac005 | 2007-09-06 23:02:23 -0300 | [diff] [blame] | 909 | err = snd_ctl_add(card, snd_ctl_new1(&snd_cx88_volume, chip)); |
| 910 | if (err < 0) |
| 911 | goto error; |
| 912 | err = snd_ctl_add(card, snd_ctl_new1(&snd_cx88_dac_switch, chip)); |
| 913 | if (err < 0) |
| 914 | goto error; |
| 915 | err = snd_ctl_add(card, snd_ctl_new1(&snd_cx88_source_switch, chip)); |
Trent Piepho | 82896f2 | 2007-09-06 23:02:23 -0300 | [diff] [blame] | 916 | if (err < 0) |
| 917 | goto error; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 918 | |
Lawrence Rust | 6951803 | 2011-02-06 17:46:12 -0300 | [diff] [blame] | 919 | /* If there's a wm8775 then add a Line-In ALC switch */ |
| 920 | if (core->board.audio_chip == V4L2_IDENT_WM8775) |
| 921 | snd_ctl_add(card, snd_ctl_new1(&snd_cx88_alc_switch, chip)); |
| 922 | |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 923 | strcpy (card->driver, "CX88x"); |
| 924 | sprintf(card->shortname, "Conexant CX%x", pci->device); |
Greg Kroah-Hartman | 228aef6 | 2006-06-12 15:16:52 -0700 | [diff] [blame] | 925 | sprintf(card->longname, "%s at %#llx", |
| 926 | card->shortname,(unsigned long long)pci_resource_start(pci, 0)); |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 927 | strcpy (card->mixername, "CX88"); |
| 928 | |
| 929 | dprintk (0, "%s/%i: ALSA support for cx2388x boards\n", |
| 930 | card->driver,devno); |
| 931 | |
| 932 | err = snd_card_register(card); |
Trent Piepho | 82896f2 | 2007-09-06 23:02:23 -0300 | [diff] [blame] | 933 | if (err < 0) |
| 934 | goto error; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 935 | pci_set_drvdata(pci,card); |
| 936 | |
| 937 | devno++; |
| 938 | return 0; |
Trent Piepho | 82896f2 | 2007-09-06 23:02:23 -0300 | [diff] [blame] | 939 | |
| 940 | error: |
| 941 | snd_card_free(card); |
| 942 | return err; |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 943 | } |
| 944 | /* |
| 945 | * ALSA destructor |
| 946 | */ |
| 947 | static void __devexit cx88_audio_finidev(struct pci_dev *pci) |
| 948 | { |
| 949 | struct cx88_audio_dev *card = pci_get_drvdata(pci); |
| 950 | |
| 951 | snd_card_free((void *)card); |
| 952 | |
| 953 | pci_set_drvdata(pci, NULL); |
| 954 | |
| 955 | devno--; |
| 956 | } |
| 957 | |
| 958 | /* |
| 959 | * PCI driver definition |
| 960 | */ |
| 961 | |
| 962 | static struct pci_driver cx88_audio_pci_driver = { |
| 963 | .name = "cx88_audio", |
| 964 | .id_table = cx88_audio_pci_tbl, |
| 965 | .probe = cx88_audio_initdev, |
Jean Delvare | e36bc31 | 2009-06-04 11:07:16 -0300 | [diff] [blame] | 966 | .remove = __devexit_p(cx88_audio_finidev), |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 967 | }; |
| 968 | |
| 969 | /**************************************************************************** |
| 970 | LINUX MODULE INIT |
| 971 | ****************************************************************************/ |
| 972 | |
| 973 | /* |
| 974 | * module init |
| 975 | */ |
Jean Delvare | e36bc31 | 2009-06-04 11:07:16 -0300 | [diff] [blame] | 976 | static int __init cx88_audio_init(void) |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 977 | { |
Mauro Carvalho Chehab | 1990d50 | 2011-06-24 14:45:49 -0300 | [diff] [blame^] | 978 | printk(KERN_INFO "cx2388x alsa driver version %s loaded\n", |
| 979 | CX88_VERSION); |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 980 | return pci_register_driver(&cx88_audio_pci_driver); |
| 981 | } |
| 982 | |
| 983 | /* |
| 984 | * module remove |
| 985 | */ |
Jean Delvare | e36bc31 | 2009-06-04 11:07:16 -0300 | [diff] [blame] | 986 | static void __exit cx88_audio_fini(void) |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 987 | { |
Mauro Carvalho Chehab | b7f355d | 2006-01-09 15:32:44 -0200 | [diff] [blame] | 988 | pci_unregister_driver(&cx88_audio_pci_driver); |
| 989 | } |
| 990 | |
| 991 | module_init(cx88_audio_init); |
| 992 | module_exit(cx88_audio_fini); |