Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Driver for Digigram VXpocket V2/440 soundcards |
| 3 | * |
| 4 | * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de> |
| 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify |
| 7 | * it under the terms of the GNU General Public License as published by |
| 8 | * the Free Software Foundation; either version 2 of the License, or |
| 9 | * (at your option) any later version. |
| 10 | * |
| 11 | * This program is distributed in the hope that it will be useful, |
| 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 14 | * GNU General Public License for more details. |
| 15 | * |
| 16 | * You should have received a copy of the GNU General Public License |
| 17 | * along with this program; if not, write to the Free Software |
| 18 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| 19 | */ |
| 20 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 21 | |
| 22 | #include <sound/driver.h> |
| 23 | #include <linux/init.h> |
| 24 | #include <linux/moduleparam.h> |
| 25 | #include <sound/core.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 26 | #include "vxpocket.h" |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 27 | #include <pcmcia/ciscode.h> |
| 28 | #include <pcmcia/cisreg.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 29 | #include <sound/initval.h> |
| 30 | |
| 31 | /* |
| 32 | */ |
| 33 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 34 | MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>"); |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 35 | MODULE_DESCRIPTION("Digigram VXPocket"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 36 | MODULE_LICENSE("GPL"); |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 37 | MODULE_SUPPORTED_DEVICE("{{Digigram,VXPocket},{Digigram,VXPocket440}}"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 38 | |
| 39 | static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ |
| 40 | static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ |
| 41 | static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable switches */ |
| 42 | static int ibl[SNDRV_CARDS]; |
| 43 | |
| 44 | module_param_array(index, int, NULL, 0444); |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 45 | MODULE_PARM_DESC(index, "Index value for VXPocket soundcard."); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 46 | module_param_array(id, charp, NULL, 0444); |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 47 | MODULE_PARM_DESC(id, "ID string for VXPocket soundcard."); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 48 | module_param_array(enable, bool, NULL, 0444); |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 49 | MODULE_PARM_DESC(enable, "Enable VXPocket soundcard."); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 50 | module_param_array(ibl, int, NULL, 0444); |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 51 | MODULE_PARM_DESC(ibl, "Capture IBL size for VXPocket soundcard."); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 52 | |
| 53 | |
| 54 | /* |
| 55 | */ |
| 56 | |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 57 | static unsigned int card_alloc; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 58 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 59 | |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 60 | /* |
| 61 | */ |
| 62 | static void vxpocket_release(dev_link_t *link) |
| 63 | { |
Dominik Brodowski | 5f2a71f | 2006-01-15 09:32:39 +0100 | [diff] [blame] | 64 | pcmcia_disable_device(link->handle); |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 65 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 66 | |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 67 | /* |
| 68 | * destructor, called from snd_card_free_in_thread() |
| 69 | */ |
Takashi Iwai | af26367 | 2005-11-17 14:46:59 +0100 | [diff] [blame] | 70 | static int snd_vxpocket_dev_free(struct snd_device *device) |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 71 | { |
Takashi Iwai | af26367 | 2005-11-17 14:46:59 +0100 | [diff] [blame] | 72 | struct vx_core *chip = device->device_data; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 73 | |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 74 | snd_vx_free_firmware(chip); |
| 75 | kfree(chip); |
| 76 | return 0; |
| 77 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 78 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 79 | |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 80 | /* |
| 81 | * Hardware information |
| 82 | */ |
| 83 | |
| 84 | /* VX-pocket V2 |
| 85 | * |
| 86 | * 1 DSP, 1 sync UER |
| 87 | * 1 programmable clock (NIY) |
| 88 | * 1 stereo analog input (line/micro) |
| 89 | * 1 stereo analog output |
| 90 | * Only output levels can be modified |
| 91 | */ |
| 92 | |
| 93 | static struct snd_vx_hardware vxpocket_hw = { |
| 94 | .name = "VXPocket", |
| 95 | .type = VX_TYPE_VXPOCKET, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 96 | |
| 97 | /* hardware specs */ |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 98 | .num_codecs = 1, |
| 99 | .num_ins = 1, |
| 100 | .num_outs = 1, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 101 | .output_level_max = VX_ANALOG_OUT_LEVEL_MAX, |
| 102 | }; |
| 103 | |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 104 | /* VX-pocket 440 |
| 105 | * |
| 106 | * 1 DSP, 1 sync UER, 1 sync World Clock (NIY) |
| 107 | * SMPTE (NIY) |
| 108 | * 2 stereo analog input (line/micro) |
| 109 | * 2 stereo analog output |
| 110 | * Only output levels can be modified |
| 111 | * UER, but only for the first two inputs and outputs. |
| 112 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 113 | |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 114 | static struct snd_vx_hardware vxp440_hw = { |
| 115 | .name = "VXPocket440", |
| 116 | .type = VX_TYPE_VXP440, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 117 | |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 118 | /* hardware specs */ |
| 119 | .num_codecs = 2, |
| 120 | .num_ins = 2, |
| 121 | .num_outs = 2, |
| 122 | .output_level_max = VX_ANALOG_OUT_LEVEL_MAX, |
| 123 | }; |
| 124 | |
| 125 | |
| 126 | /* |
| 127 | * create vxpocket instance |
| 128 | */ |
Dominik Brodowski | fd23823 | 2006-03-05 10:45:09 +0100 | [diff] [blame^] | 129 | static struct snd_vxpocket *snd_vxpocket_new(struct snd_card *card, int ibl, |
| 130 | struct pcmcia_device *p_dev) |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 131 | { |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 132 | dev_link_t *link; /* Info for cardmgr */ |
Takashi Iwai | af26367 | 2005-11-17 14:46:59 +0100 | [diff] [blame] | 133 | struct vx_core *chip; |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 134 | struct snd_vxpocket *vxp; |
Takashi Iwai | af26367 | 2005-11-17 14:46:59 +0100 | [diff] [blame] | 135 | static struct snd_device_ops ops = { |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 136 | .dev_free = snd_vxpocket_dev_free, |
| 137 | }; |
| 138 | |
Dominik Brodowski | fd23823 | 2006-03-05 10:45:09 +0100 | [diff] [blame^] | 139 | link = dev_to_instance(p_dev); |
| 140 | |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 141 | chip = snd_vx_create(card, &vxpocket_hw, &snd_vxpocket_ops, |
Takashi Iwai | af26367 | 2005-11-17 14:46:59 +0100 | [diff] [blame] | 142 | sizeof(struct snd_vxpocket) - sizeof(struct vx_core)); |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 143 | if (! chip) |
| 144 | return NULL; |
| 145 | |
| 146 | if (snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops) < 0) { |
| 147 | kfree(chip); |
| 148 | return NULL; |
| 149 | } |
| 150 | chip->ibl.size = ibl; |
| 151 | |
| 152 | vxp = (struct snd_vxpocket *)chip; |
| 153 | |
Dominik Brodowski | fd23823 | 2006-03-05 10:45:09 +0100 | [diff] [blame^] | 154 | vxp->p_dev = p_dev; |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 155 | link->priv = chip; |
| 156 | |
| 157 | link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO; |
| 158 | link->io.NumPorts1 = 16; |
| 159 | |
| 160 | link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT; |
| 161 | |
| 162 | link->irq.IRQInfo1 = IRQ_LEVEL_ID; |
| 163 | link->irq.Handler = &snd_vx_irq_handler; |
| 164 | link->irq.Instance = chip; |
| 165 | |
| 166 | link->conf.Attributes = CONF_ENABLE_IRQ; |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 167 | link->conf.IntType = INT_MEMORY_AND_IO; |
| 168 | link->conf.ConfigIndex = 1; |
| 169 | link->conf.Present = PRESENT_OPTION; |
| 170 | |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 171 | return vxp; |
| 172 | } |
| 173 | |
| 174 | |
| 175 | /** |
| 176 | * snd_vxpocket_assign_resources - initialize the hardware and card instance. |
| 177 | * @port: i/o port for the card |
| 178 | * @irq: irq number for the card |
| 179 | * |
| 180 | * this function assigns the specified port and irq, boot the card, |
| 181 | * create pcm and control instances, and initialize the rest hardware. |
| 182 | * |
| 183 | * returns 0 if successful, or a negative error code. |
| 184 | */ |
Takashi Iwai | af26367 | 2005-11-17 14:46:59 +0100 | [diff] [blame] | 185 | static int snd_vxpocket_assign_resources(struct vx_core *chip, int port, int irq) |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 186 | { |
| 187 | int err; |
Takashi Iwai | af26367 | 2005-11-17 14:46:59 +0100 | [diff] [blame] | 188 | struct snd_card *card = chip->card; |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 189 | struct snd_vxpocket *vxp = (struct snd_vxpocket *)chip; |
| 190 | |
| 191 | snd_printdd(KERN_DEBUG "vxpocket assign resources: port = 0x%x, irq = %d\n", port, irq); |
| 192 | vxp->port = port; |
| 193 | |
| 194 | sprintf(card->shortname, "Digigram %s", card->driver); |
| 195 | sprintf(card->longname, "%s at 0x%x, irq %i", |
| 196 | card->shortname, port, irq); |
| 197 | |
| 198 | chip->irq = irq; |
| 199 | |
| 200 | if ((err = snd_vx_setup_firmware(chip)) < 0) |
| 201 | return err; |
| 202 | |
| 203 | return 0; |
| 204 | } |
| 205 | |
| 206 | |
| 207 | /* |
| 208 | * configuration callback |
| 209 | */ |
| 210 | |
| 211 | #define CS_CHECK(fn, ret) \ |
| 212 | do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0) |
| 213 | |
| 214 | static void vxpocket_config(dev_link_t *link) |
| 215 | { |
| 216 | client_handle_t handle = link->handle; |
Takashi Iwai | af26367 | 2005-11-17 14:46:59 +0100 | [diff] [blame] | 217 | struct vx_core *chip = link->priv; |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 218 | struct snd_vxpocket *vxp = (struct snd_vxpocket *)chip; |
| 219 | tuple_t tuple; |
| 220 | cisparse_t *parse; |
| 221 | u_short buf[32]; |
| 222 | int last_fn, last_ret; |
| 223 | |
| 224 | snd_printdd(KERN_DEBUG "vxpocket_config called\n"); |
| 225 | parse = kmalloc(sizeof(*parse), GFP_KERNEL); |
| 226 | if (! parse) { |
| 227 | snd_printk(KERN_ERR "vx: cannot allocate\n"); |
| 228 | return; |
| 229 | } |
| 230 | tuple.Attributes = 0; |
| 231 | tuple.TupleData = (cisdata_t *)buf; |
| 232 | tuple.TupleDataMax = sizeof(buf); |
| 233 | tuple.TupleOffset = 0; |
| 234 | tuple.DesiredTuple = CISTPL_CONFIG; |
| 235 | CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple)); |
| 236 | CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple)); |
| 237 | CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, parse)); |
| 238 | link->conf.ConfigBase = parse->config.base; |
| 239 | link->conf.Present = parse->config.rmask[0]; |
| 240 | |
| 241 | /* redefine hardware record according to the VERSION1 string */ |
| 242 | tuple.DesiredTuple = CISTPL_VERS_1; |
| 243 | CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple)); |
| 244 | CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple)); |
| 245 | CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, parse)); |
| 246 | if (! strcmp(parse->version_1.str + parse->version_1.ofs[1], "VX-POCKET")) { |
| 247 | snd_printdd("VX-pocket is detected\n"); |
| 248 | } else { |
| 249 | snd_printdd("VX-pocket 440 is detected\n"); |
| 250 | /* overwrite the hardware information */ |
| 251 | chip->hw = &vxp440_hw; |
| 252 | chip->type = vxp440_hw.type; |
| 253 | strcpy(chip->card->driver, vxp440_hw.name); |
| 254 | } |
| 255 | |
| 256 | /* Configure card */ |
| 257 | link->state |= DEV_CONFIG; |
| 258 | |
| 259 | CS_CHECK(RequestIO, pcmcia_request_io(handle, &link->io)); |
| 260 | CS_CHECK(RequestIRQ, pcmcia_request_irq(link->handle, &link->irq)); |
| 261 | CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link->handle, &link->conf)); |
| 262 | |
| 263 | chip->dev = &handle_to_dev(link->handle); |
Takashi Iwai | 5ba094d | 2005-08-23 19:27:31 +0200 | [diff] [blame] | 264 | snd_card_set_dev(chip->card, chip->dev); |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 265 | |
| 266 | if (snd_vxpocket_assign_resources(chip, link->io.BasePort1, link->irq.AssignedIRQ) < 0) |
| 267 | goto failed; |
| 268 | |
Dominik Brodowski | fd23823 | 2006-03-05 10:45:09 +0100 | [diff] [blame^] | 269 | link->dev_node = &vxp->node; |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 270 | link->state &= ~DEV_CONFIG_PENDING; |
| 271 | kfree(parse); |
| 272 | return; |
| 273 | |
| 274 | cs_failed: |
| 275 | cs_error(link->handle, last_fn, last_ret); |
| 276 | failed: |
Dominik Brodowski | 50db3fd | 2006-01-15 10:05:19 +0100 | [diff] [blame] | 277 | pcmcia_disable_device(link->handle); |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 278 | kfree(parse); |
| 279 | } |
| 280 | |
Dominik Brodowski | efe3cd1 | 2006-01-06 00:27:16 +0100 | [diff] [blame] | 281 | #ifdef CONFIG_PM |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 282 | |
Dominik Brodowski | efe3cd1 | 2006-01-06 00:27:16 +0100 | [diff] [blame] | 283 | static int vxp_suspend(struct pcmcia_device *dev) |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 284 | { |
Dominik Brodowski | efe3cd1 | 2006-01-06 00:27:16 +0100 | [diff] [blame] | 285 | dev_link_t *link = dev_to_instance(dev); |
Takashi Iwai | af26367 | 2005-11-17 14:46:59 +0100 | [diff] [blame] | 286 | struct vx_core *chip = link->priv; |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 287 | |
Dominik Brodowski | efe3cd1 | 2006-01-06 00:27:16 +0100 | [diff] [blame] | 288 | snd_printdd(KERN_DEBUG "SUSPEND\n"); |
Dominik Brodowski | efe3cd1 | 2006-01-06 00:27:16 +0100 | [diff] [blame] | 289 | if (chip) { |
| 290 | snd_printdd(KERN_DEBUG "snd_vx_suspend calling\n"); |
| 291 | snd_vx_suspend(chip, PMSG_SUSPEND); |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 292 | } |
Dominik Brodowski | efe3cd1 | 2006-01-06 00:27:16 +0100 | [diff] [blame] | 293 | |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 294 | return 0; |
| 295 | } |
| 296 | |
Dominik Brodowski | efe3cd1 | 2006-01-06 00:27:16 +0100 | [diff] [blame] | 297 | static int vxp_resume(struct pcmcia_device *dev) |
| 298 | { |
| 299 | dev_link_t *link = dev_to_instance(dev); |
| 300 | struct vx_core *chip = link->priv; |
| 301 | |
| 302 | snd_printdd(KERN_DEBUG "RESUME\n"); |
Dominik Brodowski | efe3cd1 | 2006-01-06 00:27:16 +0100 | [diff] [blame] | 303 | if (DEV_OK(link)) { |
| 304 | //struct snd_vxpocket *vxp = (struct snd_vxpocket *)chip; |
Dominik Brodowski | efe3cd1 | 2006-01-06 00:27:16 +0100 | [diff] [blame] | 305 | if (chip) { |
| 306 | snd_printdd(KERN_DEBUG "calling snd_vx_resume\n"); |
| 307 | snd_vx_resume(chip); |
| 308 | } |
| 309 | } |
| 310 | snd_printdd(KERN_DEBUG "resume done!\n"); |
| 311 | |
| 312 | return 0; |
| 313 | } |
| 314 | |
| 315 | #endif |
| 316 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 317 | |
| 318 | /* |
| 319 | */ |
Dominik Brodowski | efe3cd1 | 2006-01-06 00:27:16 +0100 | [diff] [blame] | 320 | static int vxpocket_attach(struct pcmcia_device *p_dev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 321 | { |
Takashi Iwai | af26367 | 2005-11-17 14:46:59 +0100 | [diff] [blame] | 322 | struct snd_card *card; |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 323 | struct snd_vxpocket *vxp; |
| 324 | int i; |
| 325 | |
| 326 | /* find an empty slot from the card list */ |
| 327 | for (i = 0; i < SNDRV_CARDS; i++) { |
| 328 | if (! card_alloc & (1 << i)) |
| 329 | break; |
| 330 | } |
| 331 | if (i >= SNDRV_CARDS) { |
| 332 | snd_printk(KERN_ERR "vxpocket: too many cards found\n"); |
Dominik Brodowski | efe3cd1 | 2006-01-06 00:27:16 +0100 | [diff] [blame] | 333 | return -EINVAL; |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 334 | } |
| 335 | if (! enable[i]) |
Dominik Brodowski | efe3cd1 | 2006-01-06 00:27:16 +0100 | [diff] [blame] | 336 | return -ENODEV; /* disabled explicitly */ |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 337 | |
| 338 | /* ok, create a card instance */ |
| 339 | card = snd_card_new(index[i], id[i], THIS_MODULE, 0); |
| 340 | if (card == NULL) { |
| 341 | snd_printk(KERN_ERR "vxpocket: cannot create a card instance\n"); |
Dominik Brodowski | efe3cd1 | 2006-01-06 00:27:16 +0100 | [diff] [blame] | 342 | return -ENOMEM; |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 343 | } |
| 344 | |
Dominik Brodowski | fd23823 | 2006-03-05 10:45:09 +0100 | [diff] [blame^] | 345 | vxp = snd_vxpocket_new(card, ibl[i], p_dev); |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 346 | if (! vxp) { |
| 347 | snd_card_free(card); |
Dominik Brodowski | efe3cd1 | 2006-01-06 00:27:16 +0100 | [diff] [blame] | 348 | return -ENODEV; |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 349 | } |
Takashi Iwai | 0ed1cad | 2005-11-17 16:06:05 +0100 | [diff] [blame] | 350 | card->private_data = vxp; |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 351 | |
Takashi Iwai | adf111e | 2005-08-23 19:01:38 +0200 | [diff] [blame] | 352 | vxp->index = i; |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 353 | card_alloc |= 1 << i; |
| 354 | |
Dominik Brodowski | fd23823 | 2006-03-05 10:45:09 +0100 | [diff] [blame^] | 355 | vxp->p_dev = p_dev; |
| 356 | vxp->p_dev->state |= DEV_PRESENT | DEV_CONFIG_PENDING; |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 357 | |
Dominik Brodowski | fd23823 | 2006-03-05 10:45:09 +0100 | [diff] [blame^] | 358 | vxpocket_config(p_dev); |
Dominik Brodowski | efe3cd1 | 2006-01-06 00:27:16 +0100 | [diff] [blame] | 359 | |
| 360 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 361 | } |
| 362 | |
Dominik Brodowski | efe3cd1 | 2006-01-06 00:27:16 +0100 | [diff] [blame] | 363 | static void vxpocket_detach(struct pcmcia_device *p_dev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 364 | { |
Dominik Brodowski | efe3cd1 | 2006-01-06 00:27:16 +0100 | [diff] [blame] | 365 | dev_link_t *link = dev_to_instance(p_dev); |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 366 | struct snd_vxpocket *vxp; |
Takashi Iwai | af26367 | 2005-11-17 14:46:59 +0100 | [diff] [blame] | 367 | struct vx_core *chip; |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 368 | |
| 369 | if (! link) |
| 370 | return; |
| 371 | |
| 372 | vxp = link->priv; |
Takashi Iwai | af26367 | 2005-11-17 14:46:59 +0100 | [diff] [blame] | 373 | chip = (struct vx_core *)vxp; |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 374 | card_alloc &= ~(1 << vxp->index); |
| 375 | |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 376 | chip->chip_status |= VX_STAT_IS_STALE; /* to be sure */ |
| 377 | snd_card_disconnect(chip->card); |
| 378 | vxpocket_release(link); |
| 379 | snd_card_free_in_thread(chip->card); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 380 | } |
| 381 | |
| 382 | /* |
| 383 | * Module entry points |
| 384 | */ |
| 385 | |
Dominik Brodowski | e9a07af | 2005-06-27 16:28:33 -0700 | [diff] [blame] | 386 | static struct pcmcia_device_id vxp_ids[] = { |
| 387 | PCMCIA_DEVICE_MANF_CARD(0x01f1, 0x0100), |
| 388 | PCMCIA_DEVICE_NULL |
| 389 | }; |
| 390 | MODULE_DEVICE_TABLE(pcmcia, vxp_ids); |
| 391 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 392 | static struct pcmcia_driver vxp_cs_driver = { |
| 393 | .owner = THIS_MODULE, |
| 394 | .drv = { |
Takashi Iwai | 6d00a31 | 2005-06-30 13:40:51 +0200 | [diff] [blame] | 395 | .name = "snd-vxpocket", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 396 | }, |
Dominik Brodowski | efe3cd1 | 2006-01-06 00:27:16 +0100 | [diff] [blame] | 397 | .probe = vxpocket_attach, |
| 398 | .remove = vxpocket_detach, |
Dominik Brodowski | e9a07af | 2005-06-27 16:28:33 -0700 | [diff] [blame] | 399 | .id_table = vxp_ids, |
Dominik Brodowski | efe3cd1 | 2006-01-06 00:27:16 +0100 | [diff] [blame] | 400 | #ifdef CONFIG_PM |
| 401 | .suspend = vxp_suspend, |
| 402 | .resume = vxp_resume, |
| 403 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 404 | }; |
| 405 | |
| 406 | static int __init init_vxpocket(void) |
| 407 | { |
| 408 | return pcmcia_register_driver(&vxp_cs_driver); |
| 409 | } |
| 410 | |
| 411 | static void __exit exit_vxpocket(void) |
| 412 | { |
| 413 | pcmcia_unregister_driver(&vxp_cs_driver); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 414 | } |
| 415 | |
| 416 | module_init(init_vxpocket); |
| 417 | module_exit(exit_vxpocket); |