Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-2.6
[linux-2.6.git] / sound / drivers / vx / vx_hwdep.c
1 /*
2  * Driver for Digigram VX soundcards
3  *
4  * DSP firmware management
5  *
6  * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>
7  *
8  *   This program is free software; you can redistribute it and/or modify
9  *   it under the terms of the GNU General Public License as published by
10  *   the Free Software Foundation; either version 2 of the License, or
11  *   (at your option) any later version.
12  *
13  *   This program is distributed in the hope that it will be useful,
14  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  *   GNU General Public License for more details.
17  *
18  *   You should have received a copy of the GNU General Public License
19  *   along with this program; if not, write to the Free Software
20  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
21  */
22
23 #include <linux/device.h>
24 #include <linux/firmware.h>
25 #include <linux/vmalloc.h>
26 #include <sound/core.h>
27 #include <sound/hwdep.h>
28 #include <sound/vx_core.h>
29
30 #ifdef SND_VX_FW_LOADER
31
32 MODULE_FIRMWARE("vx/bx_1_vxp.b56");
33 MODULE_FIRMWARE("vx/bx_1_vp4.b56");
34 MODULE_FIRMWARE("vx/x1_1_vx2.xlx");
35 MODULE_FIRMWARE("vx/x1_2_v22.xlx");
36 MODULE_FIRMWARE("vx/x1_1_vxp.xlx");
37 MODULE_FIRMWARE("vx/x1_1_vp4.xlx");
38 MODULE_FIRMWARE("vx/bd56002.boot");
39 MODULE_FIRMWARE("vx/bd563v2.boot");
40 MODULE_FIRMWARE("vx/bd563s3.boot");
41 MODULE_FIRMWARE("vx/l_1_vx2.d56");
42 MODULE_FIRMWARE("vx/l_1_v22.d56");
43 MODULE_FIRMWARE("vx/l_1_vxp.d56");
44 MODULE_FIRMWARE("vx/l_1_vp4.d56");
45
46 int snd_vx_setup_firmware(struct vx_core *chip)
47 {
48         static char *fw_files[VX_TYPE_NUMS][4] = {
49                 [VX_TYPE_BOARD] = {
50                         NULL, "x1_1_vx2.xlx", "bd56002.boot", "l_1_vx2.d56",
51                 },
52                 [VX_TYPE_V2] = {
53                         NULL, "x1_2_v22.xlx", "bd563v2.boot", "l_1_v22.d56",
54                 },
55                 [VX_TYPE_MIC] = {
56                         NULL, "x1_2_v22.xlx", "bd563v2.boot", "l_1_v22.d56",
57                 },
58                 [VX_TYPE_VXPOCKET] = {
59                         "bx_1_vxp.b56", "x1_1_vxp.xlx", "bd563s3.boot", "l_1_vxp.d56"
60                 },
61                 [VX_TYPE_VXP440] = {
62                         "bx_1_vp4.b56", "x1_1_vp4.xlx", "bd563s3.boot", "l_1_vp4.d56"
63                 },
64         };
65
66         int i, err;
67
68         for (i = 0; i < 4; i++) {
69                 char path[32];
70                 const struct firmware *fw;
71                 if (! fw_files[chip->type][i])
72                         continue;
73                 sprintf(path, "vx/%s", fw_files[chip->type][i]);
74                 if (request_firmware(&fw, path, chip->dev)) {
75                         snd_printk(KERN_ERR "vx: can't load firmware %s\n", path);
76                         return -ENOENT;
77                 }
78                 err = chip->ops->load_dsp(chip, i, fw);
79                 if (err < 0) {
80                         release_firmware(fw);
81                         return err;
82                 }
83                 if (i == 1)
84                         chip->chip_status |= VX_STAT_XILINX_LOADED;
85 #ifdef CONFIG_PM
86                 chip->firmware[i] = fw;
87 #else
88                 release_firmware(fw);
89 #endif
90         }
91
92         /* ok, we reached to the last one */
93         /* create the devices if not built yet */
94         if ((err = snd_vx_pcm_new(chip)) < 0)
95                 return err;
96
97         if ((err = snd_vx_mixer_new(chip)) < 0)
98                 return err;
99
100         if (chip->ops->add_controls)
101                 if ((err = chip->ops->add_controls(chip)) < 0)
102                         return err;
103
104         chip->chip_status |= VX_STAT_DEVICE_INIT;
105         chip->chip_status |= VX_STAT_CHIP_INIT;
106
107         return snd_card_register(chip->card);
108 }
109
110 /* exported */
111 void snd_vx_free_firmware(struct vx_core *chip)
112 {
113 #ifdef CONFIG_PM
114         int i;
115         for (i = 0; i < 4; i++)
116                 release_firmware(chip->firmware[i]);
117 #endif
118 }
119
120 #else /* old style firmware loading */
121
122 static int vx_hwdep_dsp_status(struct snd_hwdep *hw,
123                                struct snd_hwdep_dsp_status *info)
124 {
125         static char *type_ids[VX_TYPE_NUMS] = {
126                 [VX_TYPE_BOARD] = "vxboard",
127                 [VX_TYPE_V2] = "vx222",
128                 [VX_TYPE_MIC] = "vx222",
129                 [VX_TYPE_VXPOCKET] = "vxpocket",
130                 [VX_TYPE_VXP440] = "vxp440",
131         };
132         struct vx_core *vx = hw->private_data;
133
134         if (snd_BUG_ON(!type_ids[vx->type]))
135                 return -EINVAL;
136         strcpy(info->id, type_ids[vx->type]);
137         if (vx_is_pcmcia(vx))
138                 info->num_dsps = 4;
139         else
140                 info->num_dsps = 3;
141         if (vx->chip_status & VX_STAT_CHIP_INIT)
142                 info->chip_ready = 1;
143         info->version = VX_DRIVER_VERSION;
144         return 0;
145 }
146
147 static void free_fw(const struct firmware *fw)
148 {
149         if (fw) {
150                 vfree(fw->data);
151                 kfree(fw);
152         }
153 }
154
155 static int vx_hwdep_dsp_load(struct snd_hwdep *hw,
156                              struct snd_hwdep_dsp_image *dsp)
157 {
158         struct vx_core *vx = hw->private_data;
159         int index, err;
160         struct firmware *fw;
161
162         if (snd_BUG_ON(!vx->ops->load_dsp))
163                 return -ENXIO;
164
165         fw = kmalloc(sizeof(*fw), GFP_KERNEL);
166         if (! fw) {
167                 snd_printk(KERN_ERR "cannot allocate firmware\n");
168                 return -ENOMEM;
169         }
170         fw->size = dsp->length;
171         fw->data = vmalloc(fw->size);
172         if (! fw->data) {
173                 snd_printk(KERN_ERR "cannot allocate firmware image (length=%d)\n",
174                            (int)fw->size);
175                 kfree(fw);
176                 return -ENOMEM;
177         }
178         if (copy_from_user((void *)fw->data, dsp->image, dsp->length)) {
179                 free_fw(fw);
180                 return -EFAULT;
181         }
182
183         index = dsp->index;
184         if (! vx_is_pcmcia(vx))
185                 index++;
186         err = vx->ops->load_dsp(vx, index, fw);
187         if (err < 0) {
188                 free_fw(fw);
189                 return err;
190         }
191 #ifdef CONFIG_PM
192         vx->firmware[index] = fw;
193 #else
194         free_fw(fw);
195 #endif
196
197         if (index == 1)
198                 vx->chip_status |= VX_STAT_XILINX_LOADED;
199         if (index < 3)
200                 return 0;
201
202         /* ok, we reached to the last one */
203         /* create the devices if not built yet */
204         if (! (vx->chip_status & VX_STAT_DEVICE_INIT)) {
205                 if ((err = snd_vx_pcm_new(vx)) < 0)
206                         return err;
207
208                 if ((err = snd_vx_mixer_new(vx)) < 0)
209                         return err;
210
211                 if (vx->ops->add_controls)
212                         if ((err = vx->ops->add_controls(vx)) < 0)
213                                 return err;
214
215                 if ((err = snd_card_register(vx->card)) < 0)
216                         return err;
217
218                 vx->chip_status |= VX_STAT_DEVICE_INIT;
219         }
220         vx->chip_status |= VX_STAT_CHIP_INIT;
221         return 0;
222 }
223
224
225 /* exported */
226 int snd_vx_setup_firmware(struct vx_core *chip)
227 {
228         int err;
229         struct snd_hwdep *hw;
230
231         if ((err = snd_hwdep_new(chip->card, SND_VX_HWDEP_ID, 0, &hw)) < 0)
232                 return err;
233
234         hw->iface = SNDRV_HWDEP_IFACE_VX;
235         hw->private_data = chip;
236         hw->ops.dsp_status = vx_hwdep_dsp_status;
237         hw->ops.dsp_load = vx_hwdep_dsp_load;
238         hw->exclusive = 1;
239         sprintf(hw->name, "VX Loader (%s)", chip->card->driver);
240         chip->hwdep = hw;
241
242         return snd_card_register(chip->card);
243 }
244
245 /* exported */
246 void snd_vx_free_firmware(struct vx_core *chip)
247 {
248 #ifdef CONFIG_PM
249         int i;
250         for (i = 0; i < 4; i++)
251                 free_fw(chip->firmware[i]);
252 #endif
253 }
254
255 #endif /* SND_VX_FW_LOADER */
256
257 EXPORT_SYMBOL(snd_vx_setup_firmware);
258 EXPORT_SYMBOL(snd_vx_free_firmware);