[PATCH] pcmcia: embed dev_link_t into struct pcmcia_device
[linux-3.10.git] / sound / pcmcia / pdaudiocf / pdaudiocf.c
1 /*
2  * Driver for Sound Core PDAudioCF soundcard
3  *
4  * Copyright (c) 2003 by Jaroslav Kysela <perex@suse.cz>
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
21 #include <sound/driver.h>
22 #include <sound/core.h>
23 #include <linux/slab.h>
24 #include <linux/moduleparam.h>
25 #include <pcmcia/ciscode.h>
26 #include <pcmcia/cisreg.h>
27 #include "pdaudiocf.h"
28 #include <sound/initval.h>
29 #include <linux/init.h>
30
31 /*
32  */
33
34 #define CARD_NAME       "PDAudio-CF"
35
36 MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
37 MODULE_DESCRIPTION("Sound Core " CARD_NAME);
38 MODULE_LICENSE("GPL");
39 MODULE_SUPPORTED_DEVICE("{{Sound Core," CARD_NAME "}}");
40
41 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
42 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
43 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;      /* Enable switches */
44
45 module_param_array(index, int, NULL, 0444);
46 MODULE_PARM_DESC(index, "Index value for " CARD_NAME " soundcard.");
47 module_param_array(id, charp, NULL, 0444);
48 MODULE_PARM_DESC(id, "ID string for " CARD_NAME " soundcard.");
49 module_param_array(enable, bool, NULL, 0444);
50 MODULE_PARM_DESC(enable, "Enable " CARD_NAME " soundcard.");
51
52 /*
53  */
54
55 static struct snd_card *card_list[SNDRV_CARDS];
56
57 /*
58  * prototypes
59  */
60 static void pdacf_config(dev_link_t *link);
61 static void snd_pdacf_detach(struct pcmcia_device *p_dev);
62
63 static void pdacf_release(dev_link_t *link)
64 {
65         pcmcia_disable_device(link->handle);
66 }
67
68 /*
69  * destructor
70  */
71 static int snd_pdacf_free(struct snd_pdacf *pdacf)
72 {
73         dev_link_t *link = pdacf->p_dev;
74
75         pdacf_release(link);
76
77         card_list[pdacf->index] = NULL;
78         pdacf->card = NULL;
79
80         kfree(pdacf);
81         return 0;
82 }
83
84 static int snd_pdacf_dev_free(struct snd_device *device)
85 {
86         struct snd_pdacf *chip = device->device_data;
87         return snd_pdacf_free(chip);
88 }
89
90 /*
91  * snd_pdacf_attach - attach callback for cs
92  */
93 static int snd_pdacf_attach(struct pcmcia_device *p_dev)
94 {
95         int i;
96         dev_link_t *link;               /* Info for cardmgr */
97         struct snd_pdacf *pdacf;
98         struct snd_card *card;
99         static struct snd_device_ops ops = {
100                 .dev_free =     snd_pdacf_dev_free,
101         };
102
103         link = dev_to_instance(p_dev);
104
105         snd_printdd(KERN_DEBUG "pdacf_attach called\n");
106         /* find an empty slot from the card list */
107         for (i = 0; i < SNDRV_CARDS; i++) {
108                 if (! card_list[i])
109                         break;
110         }
111         if (i >= SNDRV_CARDS) {
112                 snd_printk(KERN_ERR "pdacf: too many cards found\n");
113                 return -EINVAL;
114         }
115         if (! enable[i])
116                 return -ENODEV; /* disabled explicitly */
117
118         /* ok, create a card instance */
119         card = snd_card_new(index[i], id[i], THIS_MODULE, 0);
120         if (card == NULL) {
121                 snd_printk(KERN_ERR "pdacf: cannot create a card instance\n");
122                 return -ENOMEM;
123         }
124
125         pdacf = snd_pdacf_create(card);
126         if (! pdacf)
127                 return -EIO;
128
129         if (snd_device_new(card, SNDRV_DEV_LOWLEVEL, pdacf, &ops) < 0) {
130                 kfree(pdacf);
131                 snd_card_free(card);
132                 return -ENODEV;
133         }
134
135         pdacf->index = i;
136         card_list[i] = card;
137
138         pdacf->p_dev = p_dev;
139         link->priv = pdacf;
140
141         link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
142         link->io.NumPorts1 = 16;
143
144         link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT | IRQ_FORCED_PULSE;
145         // link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED;
146
147         link->irq.IRQInfo1 = 0 /* | IRQ_LEVEL_ID */;
148         link->irq.Handler = pdacf_interrupt;
149         link->irq.Instance = pdacf;
150         link->conf.Attributes = CONF_ENABLE_IRQ;
151         link->conf.IntType = INT_MEMORY_AND_IO;
152         link->conf.ConfigIndex = 1;
153         link->conf.Present = PRESENT_OPTION;
154
155         pdacf_config(link);
156
157         return 0;
158 }
159
160
161 /**
162  * snd_pdacf_assign_resources - initialize the hardware and card instance.
163  * @port: i/o port for the card
164  * @irq: irq number for the card
165  *
166  * this function assigns the specified port and irq, boot the card,
167  * create pcm and control instances, and initialize the rest hardware.
168  *
169  * returns 0 if successful, or a negative error code.
170  */
171 static int snd_pdacf_assign_resources(struct snd_pdacf *pdacf, int port, int irq)
172 {
173         int err;
174         struct snd_card *card = pdacf->card;
175
176         snd_printdd(KERN_DEBUG "pdacf assign resources: port = 0x%x, irq = %d\n", port, irq);
177         pdacf->port = port;
178         pdacf->irq = irq;
179         pdacf->chip_status |= PDAUDIOCF_STAT_IS_CONFIGURED;
180
181         err = snd_pdacf_ak4117_create(pdacf);
182         if (err < 0)
183                 return err;     
184
185         strcpy(card->driver, "PDAudio-CF");
186         sprintf(card->shortname, "Core Sound %s", card->driver);
187         sprintf(card->longname, "%s at 0x%x, irq %i",
188                 card->shortname, port, irq);
189
190         err = snd_pdacf_pcm_new(pdacf);
191         if (err < 0)
192                 return err;
193
194         if ((err = snd_card_register(card)) < 0)
195                 return err;
196
197         return 0;
198 }
199
200
201 /*
202  * snd_pdacf_detach - detach callback for cs
203  */
204 static void snd_pdacf_detach(struct pcmcia_device *p_dev)
205 {
206         dev_link_t *link = dev_to_instance(p_dev);
207         struct snd_pdacf *chip = link->priv;
208
209         snd_printdd(KERN_DEBUG "pdacf_detach called\n");
210
211         if (chip->chip_status & PDAUDIOCF_STAT_IS_CONFIGURED)
212                 snd_pdacf_powerdown(chip);
213         chip->chip_status |= PDAUDIOCF_STAT_IS_STALE; /* to be sure */
214         snd_card_disconnect(chip->card);
215         snd_card_free_in_thread(chip->card);
216 }
217
218 /*
219  * configuration callback
220  */
221
222 #define CS_CHECK(fn, ret) \
223 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
224
225 static void pdacf_config(dev_link_t *link)
226 {
227         client_handle_t handle = link->handle;
228         struct snd_pdacf *pdacf = link->priv;
229         tuple_t tuple;
230         cisparse_t *parse = NULL;
231         u_short buf[32];
232         int last_fn, last_ret;
233
234         snd_printdd(KERN_DEBUG "pdacf_config called\n");
235         parse = kmalloc(sizeof(*parse), GFP_KERNEL);
236         if (! parse) {
237                 snd_printk(KERN_ERR "pdacf_config: cannot allocate\n");
238                 return;
239         }
240         tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
241         tuple.Attributes = 0;
242         tuple.TupleData = (cisdata_t *)buf;
243         tuple.TupleDataMax = sizeof(buf);
244         tuple.TupleOffset = 0;
245         tuple.DesiredTuple = CISTPL_CONFIG;
246         CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
247         CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
248         CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, parse));
249         link->conf.ConfigBase = parse->config.base;
250         link->conf.ConfigIndex = 0x5;
251         kfree(parse);
252
253         /* Configure card */
254         link->state |= DEV_CONFIG;
255
256         CS_CHECK(RequestIO, pcmcia_request_io(handle, &link->io));
257         CS_CHECK(RequestIRQ, pcmcia_request_irq(link->handle, &link->irq));
258         CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link->handle, &link->conf));
259
260         if (snd_pdacf_assign_resources(pdacf, link->io.BasePort1, link->irq.AssignedIRQ) < 0)
261                 goto failed;
262
263         link->dev_node = &pdacf->node;
264         link->state &= ~DEV_CONFIG_PENDING;
265         return;
266
267 cs_failed:
268         cs_error(link->handle, last_fn, last_ret);
269 failed:
270         pcmcia_disable_device(link->handle);
271 }
272
273 #ifdef CONFIG_PM
274
275 static int pdacf_suspend(struct pcmcia_device *dev)
276 {
277         dev_link_t *link = dev_to_instance(dev);
278         struct snd_pdacf *chip = link->priv;
279
280         snd_printdd(KERN_DEBUG "SUSPEND\n");
281         if (chip) {
282                 snd_printdd(KERN_DEBUG "snd_pdacf_suspend calling\n");
283                 snd_pdacf_suspend(chip, PMSG_SUSPEND);
284         }
285
286         return 0;
287 }
288
289 static int pdacf_resume(struct pcmcia_device *dev)
290 {
291         dev_link_t *link = dev_to_instance(dev);
292         struct snd_pdacf *chip = link->priv;
293
294         snd_printdd(KERN_DEBUG "RESUME\n");
295         if (DEV_OK(link)) {
296                 if (chip) {
297                         snd_printdd(KERN_DEBUG "calling snd_pdacf_resume\n");
298                         snd_pdacf_resume(chip);
299                 }
300         }
301         snd_printdd(KERN_DEBUG "resume done!\n");
302
303         return 0;
304 }
305
306 #endif
307
308 /*
309  * Module entry points
310  */
311 static struct pcmcia_device_id snd_pdacf_ids[] = {
312         PCMCIA_DEVICE_MANF_CARD(0x015d, 0x4c45),
313         PCMCIA_DEVICE_NULL
314 };
315 MODULE_DEVICE_TABLE(pcmcia, snd_pdacf_ids);
316
317 static struct pcmcia_driver pdacf_cs_driver = {
318         .owner          = THIS_MODULE,
319         .drv            = {
320                 .name   = "snd-pdaudiocf",
321         },
322         .probe          = snd_pdacf_attach,
323         .remove         = snd_pdacf_detach,
324         .id_table       = snd_pdacf_ids,
325 #ifdef CONFIG_PM
326         .suspend        = pdacf_suspend,
327         .resume         = pdacf_resume,
328 #endif
329
330 };
331
332 static int __init init_pdacf(void)
333 {
334         return pcmcia_register_driver(&pdacf_cs_driver);
335 }
336
337 static void __exit exit_pdacf(void)
338 {
339         pcmcia_unregister_driver(&pdacf_cs_driver);
340 }
341
342 module_init(init_pdacf);
343 module_exit(exit_pdacf);