Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * Driver for Digigram miXart soundcards | |
3 | * | |
4 | * main file with alsa callbacks | |
5 | * | |
6 | * Copyright (c) 2003 by Digigram <alsa@digigram.com> | |
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 | ||
1da177e4 LT |
24 | #include <linux/init.h> |
25 | #include <linux/interrupt.h> | |
26 | #include <linux/pci.h> | |
9d2f928d | 27 | #include <linux/dma-mapping.h> |
65a77217 | 28 | #include <linux/module.h> |
62932df8 | 29 | #include <linux/mutex.h> |
5a0e3ad6 | 30 | #include <linux/slab.h> |
910638ae | 31 | |
1da177e4 LT |
32 | #include <sound/core.h> |
33 | #include <sound/initval.h> | |
34 | #include <sound/info.h> | |
35 | #include <sound/control.h> | |
36 | #include <sound/pcm.h> | |
37 | #include <sound/pcm_params.h> | |
38 | #include "mixart.h" | |
39 | #include "mixart_hwdep.h" | |
40 | #include "mixart_core.h" | |
41 | #include "mixart_mixer.h" | |
42 | ||
43 | #define CARD_NAME "miXart" | |
44 | ||
45 | MODULE_AUTHOR("Digigram <alsa@digigram.com>"); | |
46 | MODULE_DESCRIPTION("Digigram " CARD_NAME); | |
47 | MODULE_LICENSE("GPL"); | |
48 | MODULE_SUPPORTED_DEVICE("{{Digigram," CARD_NAME "}}"); | |
49 | ||
50 | static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ | |
51 | static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ | |
a67ff6a5 | 52 | static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable this card */ |
1da177e4 LT |
53 | |
54 | module_param_array(index, int, NULL, 0444); | |
55 | MODULE_PARM_DESC(index, "Index value for Digigram " CARD_NAME " soundcard."); | |
56 | module_param_array(id, charp, NULL, 0444); | |
57 | MODULE_PARM_DESC(id, "ID string for Digigram " CARD_NAME " soundcard."); | |
58 | module_param_array(enable, bool, NULL, 0444); | |
59 | MODULE_PARM_DESC(enable, "Enable Digigram " CARD_NAME " soundcard."); | |
60 | ||
61 | /* | |
62 | */ | |
63 | ||
cebe41d4 | 64 | static DEFINE_PCI_DEVICE_TABLE(snd_mixart_ids) = { |
28d27aae | 65 | { PCI_VDEVICE(MOTOROLA, 0x0003), 0, }, /* MC8240 */ |
1da177e4 LT |
66 | { 0, } |
67 | }; | |
68 | ||
69 | MODULE_DEVICE_TABLE(pci, snd_mixart_ids); | |
70 | ||
71 | ||
67b48b88 TI |
72 | static int mixart_set_pipe_state(struct mixart_mgr *mgr, |
73 | struct mixart_pipe *pipe, int start) | |
1da177e4 | 74 | { |
67b48b88 TI |
75 | struct mixart_group_state_req group_state; |
76 | struct mixart_group_state_resp group_state_resp; | |
77 | struct mixart_msg request; | |
1da177e4 LT |
78 | int err; |
79 | u32 system_msg_uid; | |
80 | ||
81 | switch(pipe->status) { | |
82 | case PIPE_RUNNING: | |
83 | case PIPE_CLOCK_SET: | |
84 | if(start) return 0; /* already started */ | |
85 | break; | |
86 | case PIPE_STOPPED: | |
87 | if(!start) return 0; /* already stopped */ | |
88 | break; | |
89 | default: | |
90 | snd_printk(KERN_ERR "error mixart_set_pipe_state called with wrong pipe->status!\n"); | |
91 | return -EINVAL; /* function called with wrong pipe status */ | |
92 | } | |
93 | ||
94 | system_msg_uid = 0x12345678; /* the event ! (take care: the MSB and two LSB's have to be 0) */ | |
95 | ||
96 | /* wait on the last MSG_SYSTEM_SEND_SYNCHRO_CMD command to be really finished */ | |
97 | ||
98 | request.message_id = MSG_SYSTEM_WAIT_SYNCHRO_CMD; | |
67b48b88 | 99 | request.uid = (struct mixart_uid){0,0}; |
1da177e4 LT |
100 | request.data = &system_msg_uid; |
101 | request.size = sizeof(system_msg_uid); | |
102 | ||
103 | err = snd_mixart_send_msg_wait_notif(mgr, &request, system_msg_uid); | |
104 | if(err) { | |
105 | snd_printk(KERN_ERR "error : MSG_SYSTEM_WAIT_SYNCHRO_CMD was not notified !\n"); | |
106 | return err; | |
107 | } | |
108 | ||
109 | /* start or stop the pipe (1 pipe) */ | |
110 | ||
111 | memset(&group_state, 0, sizeof(group_state)); | |
112 | group_state.pipe_count = 1; | |
113 | group_state.pipe_uid[0] = pipe->group_uid; | |
114 | ||
115 | if(start) | |
116 | request.message_id = MSG_STREAM_START_STREAM_GRP_PACKET; | |
117 | else | |
118 | request.message_id = MSG_STREAM_STOP_STREAM_GRP_PACKET; | |
119 | ||
67b48b88 | 120 | request.uid = pipe->group_uid; /*(struct mixart_uid){0,0};*/ |
1da177e4 LT |
121 | request.data = &group_state; |
122 | request.size = sizeof(group_state); | |
123 | ||
124 | err = snd_mixart_send_msg(mgr, &request, sizeof(group_state_resp), &group_state_resp); | |
125 | if (err < 0 || group_state_resp.txx_status != 0) { | |
126 | snd_printk(KERN_ERR "error MSG_STREAM_ST***_STREAM_GRP_PACKET err=%x stat=%x !\n", err, group_state_resp.txx_status); | |
127 | return -EINVAL; | |
128 | } | |
129 | ||
130 | if(start) { | |
131 | u32 stat; | |
132 | ||
133 | group_state.pipe_count = 0; /* in case of start same command once again with pipe_count=0 */ | |
134 | ||
135 | err = snd_mixart_send_msg(mgr, &request, sizeof(group_state_resp), &group_state_resp); | |
136 | if (err < 0 || group_state_resp.txx_status != 0) { | |
137 | snd_printk(KERN_ERR "error MSG_STREAM_START_STREAM_GRP_PACKET err=%x stat=%x !\n", err, group_state_resp.txx_status); | |
138 | return -EINVAL; | |
139 | } | |
140 | ||
141 | /* in case of start send a synchro top */ | |
142 | ||
143 | request.message_id = MSG_SYSTEM_SEND_SYNCHRO_CMD; | |
67b48b88 | 144 | request.uid = (struct mixart_uid){0,0}; |
1da177e4 LT |
145 | request.data = NULL; |
146 | request.size = 0; | |
147 | ||
148 | err = snd_mixart_send_msg(mgr, &request, sizeof(stat), &stat); | |
149 | if (err < 0 || stat != 0) { | |
150 | snd_printk(KERN_ERR "error MSG_SYSTEM_SEND_SYNCHRO_CMD err=%x stat=%x !\n", err, stat); | |
151 | return -EINVAL; | |
152 | } | |
153 | ||
154 | pipe->status = PIPE_RUNNING; | |
155 | } | |
156 | else /* !start */ | |
157 | pipe->status = PIPE_STOPPED; | |
158 | ||
159 | return 0; | |
160 | } | |
161 | ||
162 | ||
67b48b88 TI |
163 | static int mixart_set_clock(struct mixart_mgr *mgr, |
164 | struct mixart_pipe *pipe, unsigned int rate) | |
1da177e4 | 165 | { |
67b48b88 TI |
166 | struct mixart_msg request; |
167 | struct mixart_clock_properties clock_properties; | |
168 | struct mixart_clock_properties_resp clock_prop_resp; | |
1da177e4 LT |
169 | int err; |
170 | ||
171 | switch(pipe->status) { | |
172 | case PIPE_CLOCK_SET: | |
173 | break; | |
174 | case PIPE_RUNNING: | |
175 | if(rate != 0) | |
176 | break; | |
177 | default: | |
178 | if(rate == 0) | |
179 | return 0; /* nothing to do */ | |
180 | else { | |
181 | snd_printk(KERN_ERR "error mixart_set_clock(%d) called with wrong pipe->status !\n", rate); | |
182 | return -EINVAL; | |
183 | } | |
184 | } | |
185 | ||
186 | memset(&clock_properties, 0, sizeof(clock_properties)); | |
187 | clock_properties.clock_generic_type = (rate != 0) ? CGT_INTERNAL_CLOCK : CGT_NO_CLOCK; | |
188 | clock_properties.clock_mode = CM_STANDALONE; | |
189 | clock_properties.frequency = rate; | |
190 | clock_properties.nb_callers = 1; /* only one entry in uid_caller ! */ | |
191 | clock_properties.uid_caller[0] = pipe->group_uid; | |
192 | ||
193 | snd_printdd("mixart_set_clock to %d kHz\n", rate); | |
194 | ||
195 | request.message_id = MSG_CLOCK_SET_PROPERTIES; | |
196 | request.uid = mgr->uid_console_manager; | |
197 | request.data = &clock_properties; | |
198 | request.size = sizeof(clock_properties); | |
199 | ||
200 | err = snd_mixart_send_msg(mgr, &request, sizeof(clock_prop_resp), &clock_prop_resp); | |
201 | if (err < 0 || clock_prop_resp.status != 0 || clock_prop_resp.clock_mode != CM_STANDALONE) { | |
202 | snd_printk(KERN_ERR "error MSG_CLOCK_SET_PROPERTIES err=%x stat=%x mod=%x !\n", err, clock_prop_resp.status, clock_prop_resp.clock_mode); | |
203 | return -EINVAL; | |
204 | } | |
205 | ||
206 | if(rate) pipe->status = PIPE_CLOCK_SET; | |
207 | else pipe->status = PIPE_RUNNING; | |
208 | ||
209 | return 0; | |
210 | } | |
211 | ||
212 | ||
213 | /* | |
214 | * Allocate or reference output pipe for analog IOs (pcmp0/1) | |
215 | */ | |
67b48b88 TI |
216 | struct mixart_pipe * |
217 | snd_mixart_add_ref_pipe(struct snd_mixart *chip, int pcm_number, int capture, | |
218 | int monitoring) | |
1da177e4 LT |
219 | { |
220 | int stream_count; | |
67b48b88 TI |
221 | struct mixart_pipe *pipe; |
222 | struct mixart_msg request; | |
1da177e4 LT |
223 | |
224 | if(capture) { | |
225 | if (pcm_number == MIXART_PCM_ANALOG) { | |
226 | pipe = &(chip->pipe_in_ana); /* analog inputs */ | |
227 | } else { | |
228 | pipe = &(chip->pipe_in_dig); /* digital inputs */ | |
229 | } | |
230 | request.message_id = MSG_STREAM_ADD_OUTPUT_GROUP; | |
231 | stream_count = MIXART_CAPTURE_STREAMS; | |
232 | } else { | |
233 | if (pcm_number == MIXART_PCM_ANALOG) { | |
234 | pipe = &(chip->pipe_out_ana); /* analog outputs */ | |
235 | } else { | |
236 | pipe = &(chip->pipe_out_dig); /* digital outputs */ | |
237 | } | |
238 | request.message_id = MSG_STREAM_ADD_INPUT_GROUP; | |
239 | stream_count = MIXART_PLAYBACK_STREAMS; | |
240 | } | |
241 | ||
242 | /* a new stream is opened and there are already all streams in use */ | |
243 | if( (monitoring == 0) && (pipe->references >= stream_count) ) { | |
244 | return NULL; | |
245 | } | |
246 | ||
247 | /* pipe is not yet defined */ | |
248 | if( pipe->status == PIPE_UNDEFINED ) { | |
249 | int err, i; | |
250 | struct { | |
67b48b88 TI |
251 | struct mixart_streaming_group_req sgroup_req; |
252 | struct mixart_streaming_group sgroup_resp; | |
1da177e4 LT |
253 | } *buf; |
254 | ||
255 | snd_printdd("add_ref_pipe audio chip(%d) pcm(%d)\n", chip->chip_idx, pcm_number); | |
256 | ||
257 | buf = kmalloc(sizeof(*buf), GFP_KERNEL); | |
258 | if (!buf) | |
259 | return NULL; | |
260 | ||
67b48b88 | 261 | request.uid = (struct mixart_uid){0,0}; /* should be StreamManagerUID, but zero is OK if there is only one ! */ |
1da177e4 LT |
262 | request.data = &buf->sgroup_req; |
263 | request.size = sizeof(buf->sgroup_req); | |
264 | ||
265 | memset(&buf->sgroup_req, 0, sizeof(buf->sgroup_req)); | |
266 | ||
267 | buf->sgroup_req.stream_count = stream_count; | |
268 | buf->sgroup_req.channel_count = 2; | |
269 | buf->sgroup_req.latency = 256; | |
270 | buf->sgroup_req.connector = pipe->uid_left_connector; /* the left connector */ | |
271 | ||
272 | for (i=0; i<stream_count; i++) { | |
273 | int j; | |
274 | struct mixart_flowinfo *flowinfo; | |
275 | struct mixart_bufferinfo *bufferinfo; | |
276 | ||
277 | /* we don't yet know the format, so config 16 bit pcm audio for instance */ | |
278 | buf->sgroup_req.stream_info[i].size_max_byte_frame = 1024; | |
279 | buf->sgroup_req.stream_info[i].size_max_sample_frame = 256; | |
280 | buf->sgroup_req.stream_info[i].nb_bytes_max_per_sample = MIXART_FLOAT_P__4_0_TO_HEX; /* is 4.0f */ | |
281 | ||
282 | /* find the right bufferinfo_array */ | |
283 | j = (chip->chip_idx * MIXART_MAX_STREAM_PER_CARD) + (pcm_number * (MIXART_PLAYBACK_STREAMS + MIXART_CAPTURE_STREAMS)) + i; | |
284 | if(capture) j += MIXART_PLAYBACK_STREAMS; /* in the array capture is behind playback */ | |
285 | ||
286 | buf->sgroup_req.flow_entry[i] = j; | |
287 | ||
288 | flowinfo = (struct mixart_flowinfo *)chip->mgr->flowinfo.area; | |
67b48b88 | 289 | flowinfo[j].bufferinfo_array_phy_address = (u32)chip->mgr->bufferinfo.addr + (j * sizeof(struct mixart_bufferinfo)); |
1da177e4 LT |
290 | flowinfo[j].bufferinfo_count = 1; /* 1 will set the miXart to ring-buffer mode ! */ |
291 | ||
292 | bufferinfo = (struct mixart_bufferinfo *)chip->mgr->bufferinfo.area; | |
293 | bufferinfo[j].buffer_address = 0; /* buffer is not yet allocated */ | |
294 | bufferinfo[j].available_length = 0; /* buffer is not yet allocated */ | |
295 | ||
296 | /* construct the identifier of the stream buffer received in the interrupts ! */ | |
297 | bufferinfo[j].buffer_id = (chip->chip_idx << MIXART_NOTIFY_CARD_OFFSET) + (pcm_number << MIXART_NOTIFY_PCM_OFFSET ) + i; | |
298 | if(capture) { | |
299 | bufferinfo[j].buffer_id |= MIXART_NOTIFY_CAPT_MASK; | |
300 | } | |
301 | } | |
302 | ||
303 | err = snd_mixart_send_msg(chip->mgr, &request, sizeof(buf->sgroup_resp), &buf->sgroup_resp); | |
304 | if((err < 0) || (buf->sgroup_resp.status != 0)) { | |
305 | snd_printk(KERN_ERR "error MSG_STREAM_ADD_**PUT_GROUP err=%x stat=%x !\n", err, buf->sgroup_resp.status); | |
306 | kfree(buf); | |
307 | return NULL; | |
308 | } | |
309 | ||
310 | pipe->group_uid = buf->sgroup_resp.group; /* id of the pipe, as returned by embedded */ | |
311 | pipe->stream_count = buf->sgroup_resp.stream_count; | |
312 | /* pipe->stream_uid[i] = buf->sgroup_resp.stream[i].stream_uid; */ | |
313 | ||
314 | pipe->status = PIPE_STOPPED; | |
315 | kfree(buf); | |
316 | } | |
317 | ||
318 | if(monitoring) pipe->monitoring = 1; | |
319 | else pipe->references++; | |
320 | ||
321 | return pipe; | |
322 | } | |
323 | ||
324 | ||
67b48b88 TI |
325 | int snd_mixart_kill_ref_pipe(struct mixart_mgr *mgr, |
326 | struct mixart_pipe *pipe, int monitoring) | |
1da177e4 LT |
327 | { |
328 | int err = 0; | |
329 | ||
330 | if(pipe->status == PIPE_UNDEFINED) | |
331 | return 0; | |
332 | ||
333 | if(monitoring) | |
334 | pipe->monitoring = 0; | |
335 | else | |
336 | pipe->references--; | |
337 | ||
338 | if((pipe->references <= 0) && (pipe->monitoring == 0)) { | |
339 | ||
67b48b88 TI |
340 | struct mixart_msg request; |
341 | struct mixart_delete_group_resp delete_resp; | |
1da177e4 LT |
342 | |
343 | /* release the clock */ | |
344 | err = mixart_set_clock( mgr, pipe, 0); | |
345 | if( err < 0 ) { | |
346 | snd_printk(KERN_ERR "mixart_set_clock(0) return error!\n"); | |
347 | } | |
348 | ||
349 | /* stop the pipe */ | |
350 | err = mixart_set_pipe_state(mgr, pipe, 0); | |
351 | if( err < 0 ) { | |
352 | snd_printk(KERN_ERR "error stopping pipe!\n"); | |
353 | } | |
354 | ||
355 | request.message_id = MSG_STREAM_DELETE_GROUP; | |
67b48b88 | 356 | request.uid = (struct mixart_uid){0,0}; |
1da177e4 LT |
357 | request.data = &pipe->group_uid; /* the streaming group ! */ |
358 | request.size = sizeof(pipe->group_uid); | |
359 | ||
360 | /* delete the pipe */ | |
361 | err = snd_mixart_send_msg(mgr, &request, sizeof(delete_resp), &delete_resp); | |
362 | if ((err < 0) || (delete_resp.status != 0)) { | |
363 | snd_printk(KERN_ERR "error MSG_STREAM_DELETE_GROUP err(%x), status(%x)\n", err, delete_resp.status); | |
364 | } | |
365 | ||
67b48b88 | 366 | pipe->group_uid = (struct mixart_uid){0,0}; |
1da177e4 LT |
367 | pipe->stream_count = 0; |
368 | pipe->status = PIPE_UNDEFINED; | |
369 | } | |
370 | ||
371 | return err; | |
372 | } | |
373 | ||
67b48b88 | 374 | static int mixart_set_stream_state(struct mixart_stream *stream, int start) |
1da177e4 | 375 | { |
67b48b88 TI |
376 | struct snd_mixart *chip; |
377 | struct mixart_stream_state_req stream_state_req; | |
378 | struct mixart_msg request; | |
1da177e4 LT |
379 | |
380 | if(!stream->substream) | |
381 | return -EINVAL; | |
382 | ||
383 | memset(&stream_state_req, 0, sizeof(stream_state_req)); | |
384 | stream_state_req.stream_count = 1; | |
385 | stream_state_req.stream_info.stream_desc.uid_pipe = stream->pipe->group_uid; | |
386 | stream_state_req.stream_info.stream_desc.stream_idx = stream->substream->number; | |
387 | ||
388 | if (stream->substream->stream == SNDRV_PCM_STREAM_PLAYBACK) | |
389 | request.message_id = start ? MSG_STREAM_START_INPUT_STAGE_PACKET : MSG_STREAM_STOP_INPUT_STAGE_PACKET; | |
390 | else | |
391 | request.message_id = start ? MSG_STREAM_START_OUTPUT_STAGE_PACKET : MSG_STREAM_STOP_OUTPUT_STAGE_PACKET; | |
392 | ||
67b48b88 | 393 | request.uid = (struct mixart_uid){0,0}; |
1da177e4 LT |
394 | request.data = &stream_state_req; |
395 | request.size = sizeof(stream_state_req); | |
396 | ||
397 | stream->abs_period_elapsed = 0; /* reset stream pos */ | |
398 | stream->buf_periods = 0; | |
399 | stream->buf_period_frag = 0; | |
400 | ||
401 | chip = snd_pcm_substream_chip(stream->substream); | |
402 | ||
403 | return snd_mixart_send_msg_nonblock(chip->mgr, &request); | |
404 | } | |
405 | ||
406 | /* | |
407 | * Trigger callback | |
408 | */ | |
409 | ||
67b48b88 | 410 | static int snd_mixart_trigger(struct snd_pcm_substream *subs, int cmd) |
1da177e4 | 411 | { |
67b48b88 | 412 | struct mixart_stream *stream = subs->runtime->private_data; |
1da177e4 LT |
413 | |
414 | switch (cmd) { | |
415 | case SNDRV_PCM_TRIGGER_START: | |
416 | ||
417 | snd_printdd("SNDRV_PCM_TRIGGER_START\n"); | |
418 | ||
419 | /* START_STREAM */ | |
420 | if( mixart_set_stream_state(stream, 1) ) | |
421 | return -EINVAL; | |
422 | ||
423 | stream->status = MIXART_STREAM_STATUS_RUNNING; | |
424 | ||
425 | break; | |
426 | case SNDRV_PCM_TRIGGER_STOP: | |
427 | ||
428 | /* STOP_STREAM */ | |
429 | if( mixart_set_stream_state(stream, 0) ) | |
430 | return -EINVAL; | |
431 | ||
432 | stream->status = MIXART_STREAM_STATUS_OPEN; | |
433 | ||
434 | snd_printdd("SNDRV_PCM_TRIGGER_STOP\n"); | |
435 | ||
436 | break; | |
437 | ||
438 | case SNDRV_PCM_TRIGGER_PAUSE_PUSH: | |
439 | /* TODO */ | |
440 | stream->status = MIXART_STREAM_STATUS_PAUSE; | |
441 | snd_printdd("SNDRV_PCM_PAUSE_PUSH\n"); | |
442 | break; | |
443 | case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: | |
444 | /* TODO */ | |
445 | stream->status = MIXART_STREAM_STATUS_RUNNING; | |
446 | snd_printdd("SNDRV_PCM_PAUSE_RELEASE\n"); | |
447 | break; | |
448 | default: | |
449 | return -EINVAL; | |
450 | } | |
451 | return 0; | |
452 | } | |
453 | ||
67b48b88 | 454 | static int mixart_sync_nonblock_events(struct mixart_mgr *mgr) |
1da177e4 | 455 | { |
ef21ca24 | 456 | unsigned long timeout = jiffies + HZ; |
1da177e4 | 457 | while (atomic_read(&mgr->msg_processed) > 0) { |
ef21ca24 | 458 | if (time_after(jiffies, timeout)) { |
1da177e4 LT |
459 | snd_printk(KERN_ERR "mixart: cannot process nonblock events!\n"); |
460 | return -EBUSY; | |
461 | } | |
8433a509 | 462 | schedule_timeout_uninterruptible(1); |
1da177e4 LT |
463 | } |
464 | return 0; | |
465 | } | |
466 | ||
467 | /* | |
468 | * prepare callback for all pcms | |
469 | */ | |
67b48b88 | 470 | static int snd_mixart_prepare(struct snd_pcm_substream *subs) |
1da177e4 | 471 | { |
67b48b88 TI |
472 | struct snd_mixart *chip = snd_pcm_substream_chip(subs); |
473 | struct mixart_stream *stream = subs->runtime->private_data; | |
1da177e4 | 474 | |
7bb2acb7 | 475 | /* TODO de façon non bloquante, réappliquer les hw_params (rate, bits, codec) */ |
1da177e4 LT |
476 | |
477 | snd_printdd("snd_mixart_prepare\n"); | |
478 | ||
479 | mixart_sync_nonblock_events(chip->mgr); | |
480 | ||
481 | /* only the first stream can choose the sample rate */ | |
482 | /* the further opened streams will be limited to its frequency (see open) */ | |
483 | if(chip->mgr->ref_count_rate == 1) | |
484 | chip->mgr->sample_rate = subs->runtime->rate; | |
485 | ||
486 | /* set the clock only once (first stream) on the same pipe */ | |
487 | if(stream->pipe->references == 1) { | |
488 | if( mixart_set_clock(chip->mgr, stream->pipe, subs->runtime->rate) ) | |
489 | return -EINVAL; | |
490 | } | |
491 | ||
492 | return 0; | |
493 | } | |
494 | ||
495 | ||
67b48b88 | 496 | static int mixart_set_format(struct mixart_stream *stream, snd_pcm_format_t format) |
1da177e4 LT |
497 | { |
498 | int err; | |
67b48b88 TI |
499 | struct snd_mixart *chip; |
500 | struct mixart_msg request; | |
501 | struct mixart_stream_param_desc stream_param; | |
502 | struct mixart_return_uid resp; | |
1da177e4 LT |
503 | |
504 | chip = snd_pcm_substream_chip(stream->substream); | |
505 | ||
506 | memset(&stream_param, 0, sizeof(stream_param)); | |
507 | ||
508 | stream_param.coding_type = CT_LINEAR; | |
509 | stream_param.number_of_channel = stream->channels; | |
510 | ||
511 | stream_param.sampling_freq = chip->mgr->sample_rate; | |
512 | if(stream_param.sampling_freq == 0) | |
513 | stream_param.sampling_freq = 44100; /* if frequency not yet defined, use some default */ | |
514 | ||
515 | switch(format){ | |
516 | case SNDRV_PCM_FORMAT_U8: | |
517 | stream_param.sample_type = ST_INTEGER_8; | |
518 | stream_param.sample_size = 8; | |
519 | break; | |
520 | case SNDRV_PCM_FORMAT_S16_LE: | |
521 | stream_param.sample_type = ST_INTEGER_16LE; | |
522 | stream_param.sample_size = 16; | |
523 | break; | |
524 | case SNDRV_PCM_FORMAT_S16_BE: | |
525 | stream_param.sample_type = ST_INTEGER_16BE; | |
526 | stream_param.sample_size = 16; | |
527 | break; | |
528 | case SNDRV_PCM_FORMAT_S24_3LE: | |
529 | stream_param.sample_type = ST_INTEGER_24LE; | |
530 | stream_param.sample_size = 24; | |
531 | break; | |
532 | case SNDRV_PCM_FORMAT_S24_3BE: | |
533 | stream_param.sample_type = ST_INTEGER_24BE; | |
534 | stream_param.sample_size = 24; | |
535 | break; | |
536 | case SNDRV_PCM_FORMAT_FLOAT_LE: | |
537 | stream_param.sample_type = ST_FLOATING_POINT_32LE; | |
538 | stream_param.sample_size = 32; | |
539 | break; | |
540 | case SNDRV_PCM_FORMAT_FLOAT_BE: | |
541 | stream_param.sample_type = ST_FLOATING_POINT_32BE; | |
542 | stream_param.sample_size = 32; | |
543 | break; | |
544 | default: | |
545 | snd_printk(KERN_ERR "error mixart_set_format() : unknown format\n"); | |
546 | return -EINVAL; | |
547 | } | |
548 | ||
549 | snd_printdd("set SNDRV_PCM_FORMAT sample_type(%d) sample_size(%d) freq(%d) channels(%d)\n", | |
550 | stream_param.sample_type, stream_param.sample_size, stream_param.sampling_freq, stream->channels); | |
551 | ||
552 | /* TODO: what else to configure ? */ | |
553 | /* stream_param.samples_per_frame = 2; */ | |
554 | /* stream_param.bytes_per_frame = 4; */ | |
555 | /* stream_param.bytes_per_sample = 2; */ | |
556 | ||
557 | stream_param.pipe_count = 1; /* set to 1 */ | |
558 | stream_param.stream_count = 1; /* set to 1 */ | |
559 | stream_param.stream_desc[0].uid_pipe = stream->pipe->group_uid; | |
560 | stream_param.stream_desc[0].stream_idx = stream->substream->number; | |
561 | ||
562 | request.message_id = MSG_STREAM_SET_INPUT_STAGE_PARAM; | |
67b48b88 | 563 | request.uid = (struct mixart_uid){0,0}; |
1da177e4 LT |
564 | request.data = &stream_param; |
565 | request.size = sizeof(stream_param); | |
566 | ||
567 | err = snd_mixart_send_msg(chip->mgr, &request, sizeof(resp), &resp); | |
568 | if((err < 0) || resp.error_code) { | |
569 | snd_printk(KERN_ERR "MSG_STREAM_SET_INPUT_STAGE_PARAM err=%x; resp=%x\n", err, resp.error_code); | |
570 | return -EINVAL; | |
571 | } | |
572 | return 0; | |
573 | } | |
574 | ||
575 | ||
576 | /* | |
577 | * HW_PARAMS callback for all pcms | |
578 | */ | |
67b48b88 TI |
579 | static int snd_mixart_hw_params(struct snd_pcm_substream *subs, |
580 | struct snd_pcm_hw_params *hw) | |
1da177e4 | 581 | { |
67b48b88 TI |
582 | struct snd_mixart *chip = snd_pcm_substream_chip(subs); |
583 | struct mixart_mgr *mgr = chip->mgr; | |
584 | struct mixart_stream *stream = subs->runtime->private_data; | |
1da177e4 LT |
585 | snd_pcm_format_t format; |
586 | int err; | |
587 | int channels; | |
588 | ||
589 | /* set up channels */ | |
590 | channels = params_channels(hw); | |
591 | ||
592 | /* set up format for the stream */ | |
593 | format = params_format(hw); | |
594 | ||
62932df8 | 595 | mutex_lock(&mgr->setup_mutex); |
1da177e4 LT |
596 | |
597 | /* update the stream levels */ | |
598 | if( stream->pcm_number <= MIXART_PCM_DIGITAL ) { | |
599 | int is_aes = stream->pcm_number > MIXART_PCM_ANALOG; | |
600 | if( subs->stream == SNDRV_PCM_STREAM_PLAYBACK ) | |
601 | mixart_update_playback_stream_level(chip, is_aes, subs->number); | |
602 | else | |
603 | mixart_update_capture_stream_level( chip, is_aes); | |
604 | } | |
605 | ||
606 | stream->channels = channels; | |
607 | ||
608 | /* set the format to the board */ | |
609 | err = mixart_set_format(stream, format); | |
610 | if(err < 0) { | |
82f5d571 | 611 | mutex_unlock(&mgr->setup_mutex); |
1da177e4 LT |
612 | return err; |
613 | } | |
614 | ||
615 | /* allocate buffer */ | |
616 | err = snd_pcm_lib_malloc_pages(subs, params_buffer_bytes(hw)); | |
617 | ||
618 | if (err > 0) { | |
619 | struct mixart_bufferinfo *bufferinfo; | |
620 | int i = (chip->chip_idx * MIXART_MAX_STREAM_PER_CARD) + (stream->pcm_number * (MIXART_PLAYBACK_STREAMS+MIXART_CAPTURE_STREAMS)) + subs->number; | |
621 | if( subs->stream == SNDRV_PCM_STREAM_CAPTURE ) { | |
622 | i += MIXART_PLAYBACK_STREAMS; /* in array capture is behind playback */ | |
623 | } | |
624 | ||
625 | bufferinfo = (struct mixart_bufferinfo *)chip->mgr->bufferinfo.area; | |
626 | bufferinfo[i].buffer_address = subs->runtime->dma_addr; | |
627 | bufferinfo[i].available_length = subs->runtime->dma_bytes; | |
628 | /* bufferinfo[i].buffer_id is already defined */ | |
629 | ||
630 | snd_printdd("snd_mixart_hw_params(pcm %d) : dma_addr(%x) dma_bytes(%x) subs-number(%d)\n", i, | |
631 | bufferinfo[i].buffer_address, | |
632 | bufferinfo[i].available_length, | |
633 | subs->number); | |
634 | } | |
62932df8 | 635 | mutex_unlock(&mgr->setup_mutex); |
1da177e4 LT |
636 | |
637 | return err; | |
638 | } | |
639 | ||
67b48b88 | 640 | static int snd_mixart_hw_free(struct snd_pcm_substream *subs) |
1da177e4 | 641 | { |
67b48b88 | 642 | struct snd_mixart *chip = snd_pcm_substream_chip(subs); |
1da177e4 LT |
643 | snd_pcm_lib_free_pages(subs); |
644 | mixart_sync_nonblock_events(chip->mgr); | |
645 | return 0; | |
646 | } | |
647 | ||
648 | ||
649 | ||
650 | /* | |
651 | * TODO CONFIGURATION SPACE for all pcms, mono pcm must update channels_max | |
652 | */ | |
67b48b88 | 653 | static struct snd_pcm_hardware snd_mixart_analog_caps = |
1da177e4 LT |
654 | { |
655 | .info = ( SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | | |
b83f346b | 656 | SNDRV_PCM_INFO_MMAP_VALID | |
1da177e4 LT |
657 | SNDRV_PCM_INFO_PAUSE), |
658 | .formats = ( SNDRV_PCM_FMTBIT_U8 | | |
659 | SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE | | |
660 | SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_S24_3BE | | |
661 | SNDRV_PCM_FMTBIT_FLOAT_LE | SNDRV_PCM_FMTBIT_FLOAT_BE ), | |
662 | .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000, | |
663 | .rate_min = 8000, | |
664 | .rate_max = 48000, | |
665 | .channels_min = 1, | |
666 | .channels_max = 2, | |
667 | .buffer_bytes_max = (32*1024), | |
668 | .period_bytes_min = 256, /* 256 frames U8 mono*/ | |
669 | .period_bytes_max = (16*1024), | |
670 | .periods_min = 2, | |
671 | .periods_max = (32*1024/256), | |
672 | }; | |
673 | ||
67b48b88 | 674 | static struct snd_pcm_hardware snd_mixart_digital_caps = |
1da177e4 LT |
675 | { |
676 | .info = ( SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | | |
b83f346b | 677 | SNDRV_PCM_INFO_MMAP_VALID | |
1da177e4 LT |
678 | SNDRV_PCM_INFO_PAUSE), |
679 | .formats = ( SNDRV_PCM_FMTBIT_U8 | | |
680 | SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE | | |
681 | SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_S24_3BE | | |
682 | SNDRV_PCM_FMTBIT_FLOAT_LE | SNDRV_PCM_FMTBIT_FLOAT_BE ), | |
683 | .rates = SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000, | |
684 | .rate_min = 32000, | |
685 | .rate_max = 48000, | |
686 | .channels_min = 1, | |
687 | .channels_max = 2, | |
688 | .buffer_bytes_max = (32*1024), | |
689 | .period_bytes_min = 256, /* 256 frames U8 mono*/ | |
690 | .period_bytes_max = (16*1024), | |
691 | .periods_min = 2, | |
692 | .periods_max = (32*1024/256), | |
693 | }; | |
694 | ||
695 | ||
67b48b88 | 696 | static int snd_mixart_playback_open(struct snd_pcm_substream *subs) |
1da177e4 | 697 | { |
67b48b88 TI |
698 | struct snd_mixart *chip = snd_pcm_substream_chip(subs); |
699 | struct mixart_mgr *mgr = chip->mgr; | |
700 | struct snd_pcm_runtime *runtime = subs->runtime; | |
701 | struct snd_pcm *pcm = subs->pcm; | |
702 | struct mixart_stream *stream; | |
703 | struct mixart_pipe *pipe; | |
1da177e4 LT |
704 | int err = 0; |
705 | int pcm_number; | |
706 | ||
62932df8 | 707 | mutex_lock(&mgr->setup_mutex); |
1da177e4 LT |
708 | |
709 | if ( pcm == chip->pcm ) { | |
710 | pcm_number = MIXART_PCM_ANALOG; | |
711 | runtime->hw = snd_mixart_analog_caps; | |
712 | } else { | |
da3cec35 | 713 | snd_BUG_ON(pcm != chip->pcm_dig); |
1da177e4 LT |
714 | pcm_number = MIXART_PCM_DIGITAL; |
715 | runtime->hw = snd_mixart_digital_caps; | |
716 | } | |
717 | snd_printdd("snd_mixart_playback_open C%d/P%d/Sub%d\n", chip->chip_idx, pcm_number, subs->number); | |
718 | ||
719 | /* get stream info */ | |
720 | stream = &(chip->playback_stream[pcm_number][subs->number]); | |
721 | ||
722 | if (stream->status != MIXART_STREAM_STATUS_FREE){ | |
723 | /* streams in use */ | |
724 | snd_printk(KERN_ERR "snd_mixart_playback_open C%d/P%d/Sub%d in use\n", chip->chip_idx, pcm_number, subs->number); | |
725 | err = -EBUSY; | |
726 | goto _exit_open; | |
727 | } | |
728 | ||
729 | /* get pipe pointer (out pipe) */ | |
730 | pipe = snd_mixart_add_ref_pipe(chip, pcm_number, 0, 0); | |
731 | ||
732 | if (pipe == NULL) { | |
733 | err = -EINVAL; | |
734 | goto _exit_open; | |
735 | } | |
736 | ||
737 | /* start the pipe if necessary */ | |
738 | err = mixart_set_pipe_state(chip->mgr, pipe, 1); | |
739 | if( err < 0 ) { | |
740 | snd_printk(KERN_ERR "error starting pipe!\n"); | |
741 | snd_mixart_kill_ref_pipe(chip->mgr, pipe, 0); | |
742 | err = -EINVAL; | |
743 | goto _exit_open; | |
744 | } | |
745 | ||
746 | stream->pipe = pipe; | |
747 | stream->pcm_number = pcm_number; | |
748 | stream->status = MIXART_STREAM_STATUS_OPEN; | |
749 | stream->substream = subs; | |
750 | stream->channels = 0; /* not configured yet */ | |
751 | ||
752 | runtime->private_data = stream; | |
753 | ||
754 | snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 32); | |
755 | snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 64); | |
756 | ||
757 | /* if a sample rate is already used, another stream cannot change */ | |
758 | if(mgr->ref_count_rate++) { | |
759 | if(mgr->sample_rate) { | |
760 | runtime->hw.rate_min = runtime->hw.rate_max = mgr->sample_rate; | |
761 | } | |
762 | } | |
763 | ||
764 | _exit_open: | |
62932df8 | 765 | mutex_unlock(&mgr->setup_mutex); |
1da177e4 LT |
766 | |
767 | return err; | |
768 | } | |
769 | ||
770 | ||
67b48b88 | 771 | static int snd_mixart_capture_open(struct snd_pcm_substream *subs) |
1da177e4 | 772 | { |
67b48b88 TI |
773 | struct snd_mixart *chip = snd_pcm_substream_chip(subs); |
774 | struct mixart_mgr *mgr = chip->mgr; | |
775 | struct snd_pcm_runtime *runtime = subs->runtime; | |
776 | struct snd_pcm *pcm = subs->pcm; | |
777 | struct mixart_stream *stream; | |
778 | struct mixart_pipe *pipe; | |
1da177e4 LT |
779 | int err = 0; |
780 | int pcm_number; | |
781 | ||
62932df8 | 782 | mutex_lock(&mgr->setup_mutex); |
1da177e4 LT |
783 | |
784 | if ( pcm == chip->pcm ) { | |
785 | pcm_number = MIXART_PCM_ANALOG; | |
786 | runtime->hw = snd_mixart_analog_caps; | |
787 | } else { | |
da3cec35 | 788 | snd_BUG_ON(pcm != chip->pcm_dig); |
1da177e4 LT |
789 | pcm_number = MIXART_PCM_DIGITAL; |
790 | runtime->hw = snd_mixart_digital_caps; | |
791 | } | |
792 | ||
793 | runtime->hw.channels_min = 2; /* for instance, no mono */ | |
794 | ||
795 | snd_printdd("snd_mixart_capture_open C%d/P%d/Sub%d\n", chip->chip_idx, pcm_number, subs->number); | |
796 | ||
797 | /* get stream info */ | |
798 | stream = &(chip->capture_stream[pcm_number]); | |
799 | ||
800 | if (stream->status != MIXART_STREAM_STATUS_FREE){ | |
801 | /* streams in use */ | |
802 | snd_printk(KERN_ERR "snd_mixart_capture_open C%d/P%d/Sub%d in use\n", chip->chip_idx, pcm_number, subs->number); | |
803 | err = -EBUSY; | |
804 | goto _exit_open; | |
805 | } | |
806 | ||
807 | /* get pipe pointer (in pipe) */ | |
808 | pipe = snd_mixart_add_ref_pipe(chip, pcm_number, 1, 0); | |
809 | ||
810 | if (pipe == NULL) { | |
811 | err = -EINVAL; | |
812 | goto _exit_open; | |
813 | } | |
814 | ||
815 | /* start the pipe if necessary */ | |
816 | err = mixart_set_pipe_state(chip->mgr, pipe, 1); | |
817 | if( err < 0 ) { | |
818 | snd_printk(KERN_ERR "error starting pipe!\n"); | |
819 | snd_mixart_kill_ref_pipe(chip->mgr, pipe, 0); | |
820 | err = -EINVAL; | |
821 | goto _exit_open; | |
822 | } | |
823 | ||
824 | stream->pipe = pipe; | |
825 | stream->pcm_number = pcm_number; | |
826 | stream->status = MIXART_STREAM_STATUS_OPEN; | |
827 | stream->substream = subs; | |
828 | stream->channels = 0; /* not configured yet */ | |
829 | ||
830 | runtime->private_data = stream; | |
831 | ||
832 | snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 32); | |
833 | snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 64); | |
834 | ||
835 | /* if a sample rate is already used, another stream cannot change */ | |
836 | if(mgr->ref_count_rate++) { | |
837 | if(mgr->sample_rate) { | |
838 | runtime->hw.rate_min = runtime->hw.rate_max = mgr->sample_rate; | |
839 | } | |
840 | } | |
841 | ||
842 | _exit_open: | |
62932df8 | 843 | mutex_unlock(&mgr->setup_mutex); |
1da177e4 LT |
844 | |
845 | return err; | |
846 | } | |
847 | ||
848 | ||
849 | ||
67b48b88 | 850 | static int snd_mixart_close(struct snd_pcm_substream *subs) |
1da177e4 | 851 | { |
67b48b88 TI |
852 | struct snd_mixart *chip = snd_pcm_substream_chip(subs); |
853 | struct mixart_mgr *mgr = chip->mgr; | |
854 | struct mixart_stream *stream = subs->runtime->private_data; | |
1da177e4 | 855 | |
62932df8 | 856 | mutex_lock(&mgr->setup_mutex); |
1da177e4 LT |
857 | |
858 | snd_printdd("snd_mixart_close C%d/P%d/Sub%d\n", chip->chip_idx, stream->pcm_number, subs->number); | |
859 | ||
860 | /* sample rate released */ | |
861 | if(--mgr->ref_count_rate == 0) { | |
862 | mgr->sample_rate = 0; | |
863 | } | |
864 | ||
865 | /* delete pipe */ | |
866 | if (snd_mixart_kill_ref_pipe(mgr, stream->pipe, 0 ) < 0) { | |
867 | ||
868 | snd_printk(KERN_ERR "error snd_mixart_kill_ref_pipe C%dP%d\n", chip->chip_idx, stream->pcm_number); | |
869 | } | |
870 | ||
871 | stream->pipe = NULL; | |
872 | stream->status = MIXART_STREAM_STATUS_FREE; | |
873 | stream->substream = NULL; | |
874 | ||
62932df8 | 875 | mutex_unlock(&mgr->setup_mutex); |
1da177e4 LT |
876 | return 0; |
877 | } | |
878 | ||
879 | ||
67b48b88 | 880 | static snd_pcm_uframes_t snd_mixart_stream_pointer(struct snd_pcm_substream *subs) |
1da177e4 | 881 | { |
67b48b88 TI |
882 | struct snd_pcm_runtime *runtime = subs->runtime; |
883 | struct mixart_stream *stream = runtime->private_data; | |
1da177e4 LT |
884 | |
885 | return (snd_pcm_uframes_t)((stream->buf_periods * runtime->period_size) + stream->buf_period_frag); | |
886 | } | |
887 | ||
888 | ||
889 | ||
67b48b88 | 890 | static struct snd_pcm_ops snd_mixart_playback_ops = { |
1da177e4 LT |
891 | .open = snd_mixart_playback_open, |
892 | .close = snd_mixart_close, | |
893 | .ioctl = snd_pcm_lib_ioctl, | |
894 | .prepare = snd_mixart_prepare, | |
895 | .hw_params = snd_mixart_hw_params, | |
896 | .hw_free = snd_mixart_hw_free, | |
897 | .trigger = snd_mixart_trigger, | |
898 | .pointer = snd_mixart_stream_pointer, | |
899 | }; | |
900 | ||
67b48b88 | 901 | static struct snd_pcm_ops snd_mixart_capture_ops = { |
1da177e4 LT |
902 | .open = snd_mixart_capture_open, |
903 | .close = snd_mixart_close, | |
904 | .ioctl = snd_pcm_lib_ioctl, | |
905 | .prepare = snd_mixart_prepare, | |
906 | .hw_params = snd_mixart_hw_params, | |
907 | .hw_free = snd_mixart_hw_free, | |
908 | .trigger = snd_mixart_trigger, | |
909 | .pointer = snd_mixart_stream_pointer, | |
910 | }; | |
911 | ||
67b48b88 | 912 | static void preallocate_buffers(struct snd_mixart *chip, struct snd_pcm *pcm) |
1da177e4 LT |
913 | { |
914 | #if 0 | |
67b48b88 | 915 | struct snd_pcm_substream *subs; |
1da177e4 LT |
916 | int stream; |
917 | ||
918 | for (stream = 0; stream < 2; stream++) { | |
919 | int idx = 0; | |
920 | for (subs = pcm->streams[stream].substream; subs; subs = subs->next, idx++) | |
921 | /* set up the unique device id with the chip index */ | |
922 | subs->dma_device.id = subs->pcm->device << 16 | | |
923 | subs->stream << 8 | (subs->number + 1) | | |
924 | (chip->chip_idx + 1) << 24; | |
925 | } | |
926 | #endif | |
927 | snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, | |
928 | snd_dma_pci_data(chip->mgr->pci), 32*1024, 32*1024); | |
929 | } | |
930 | ||
931 | /* | |
932 | */ | |
67b48b88 | 933 | static int snd_mixart_pcm_analog(struct snd_mixart *chip) |
1da177e4 LT |
934 | { |
935 | int err; | |
67b48b88 | 936 | struct snd_pcm *pcm; |
1da177e4 LT |
937 | char name[32]; |
938 | ||
939 | sprintf(name, "miXart analog %d", chip->chip_idx); | |
940 | if ((err = snd_pcm_new(chip->card, name, MIXART_PCM_ANALOG, | |
941 | MIXART_PLAYBACK_STREAMS, | |
942 | MIXART_CAPTURE_STREAMS, &pcm)) < 0) { | |
943 | snd_printk(KERN_ERR "cannot create the analog pcm %d\n", chip->chip_idx); | |
944 | return err; | |
945 | } | |
946 | ||
947 | pcm->private_data = chip; | |
948 | ||
949 | snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_mixart_playback_ops); | |
950 | snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_mixart_capture_ops); | |
951 | ||
952 | pcm->info_flags = 0; | |
953 | strcpy(pcm->name, name); | |
954 | ||
955 | preallocate_buffers(chip, pcm); | |
956 | ||
957 | chip->pcm = pcm; | |
958 | return 0; | |
959 | } | |
960 | ||
961 | ||
962 | /* | |
963 | */ | |
67b48b88 | 964 | static int snd_mixart_pcm_digital(struct snd_mixart *chip) |
1da177e4 LT |
965 | { |
966 | int err; | |
67b48b88 | 967 | struct snd_pcm *pcm; |
1da177e4 LT |
968 | char name[32]; |
969 | ||
970 | sprintf(name, "miXart AES/EBU %d", chip->chip_idx); | |
971 | if ((err = snd_pcm_new(chip->card, name, MIXART_PCM_DIGITAL, | |
972 | MIXART_PLAYBACK_STREAMS, | |
973 | MIXART_CAPTURE_STREAMS, &pcm)) < 0) { | |
974 | snd_printk(KERN_ERR "cannot create the digital pcm %d\n", chip->chip_idx); | |
975 | return err; | |
976 | } | |
977 | ||
978 | pcm->private_data = chip; | |
979 | ||
980 | snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_mixart_playback_ops); | |
981 | snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_mixart_capture_ops); | |
982 | ||
983 | pcm->info_flags = 0; | |
984 | strcpy(pcm->name, name); | |
985 | ||
986 | preallocate_buffers(chip, pcm); | |
987 | ||
988 | chip->pcm_dig = pcm; | |
989 | return 0; | |
990 | } | |
991 | ||
67b48b88 | 992 | static int snd_mixart_chip_free(struct snd_mixart *chip) |
1da177e4 LT |
993 | { |
994 | kfree(chip); | |
995 | return 0; | |
996 | } | |
997 | ||
67b48b88 | 998 | static int snd_mixart_chip_dev_free(struct snd_device *device) |
1da177e4 | 999 | { |
67b48b88 | 1000 | struct snd_mixart *chip = device->device_data; |
1da177e4 LT |
1001 | return snd_mixart_chip_free(chip); |
1002 | } | |
1003 | ||
1004 | ||
1005 | /* | |
1006 | */ | |
e23e7a14 | 1007 | static int snd_mixart_create(struct mixart_mgr *mgr, struct snd_card *card, int idx) |
1da177e4 LT |
1008 | { |
1009 | int err; | |
67b48b88 TI |
1010 | struct snd_mixart *chip; |
1011 | static struct snd_device_ops ops = { | |
1da177e4 LT |
1012 | .dev_free = snd_mixart_chip_dev_free, |
1013 | }; | |
1014 | ||
73f6a12e | 1015 | chip = kzalloc(sizeof(*chip), GFP_KERNEL); |
1da177e4 LT |
1016 | if (! chip) { |
1017 | snd_printk(KERN_ERR "cannot allocate chip\n"); | |
1018 | return -ENOMEM; | |
1019 | } | |
1020 | ||
1021 | chip->card = card; | |
1022 | chip->chip_idx = idx; | |
1023 | chip->mgr = mgr; | |
1024 | ||
1025 | if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) { | |
1026 | snd_mixart_chip_free(chip); | |
1027 | return err; | |
1028 | } | |
1029 | ||
73f6a12e | 1030 | mgr->chip[idx] = chip; |
1da177e4 LT |
1031 | snd_card_set_dev(card, &mgr->pci->dev); |
1032 | ||
1033 | return 0; | |
1034 | } | |
1035 | ||
67b48b88 | 1036 | int snd_mixart_create_pcm(struct snd_mixart* chip) |
1da177e4 LT |
1037 | { |
1038 | int err; | |
1039 | ||
1040 | err = snd_mixart_pcm_analog(chip); | |
1041 | if (err < 0) | |
1042 | return err; | |
1043 | ||
1044 | if(chip->mgr->board_type == MIXART_DAUGHTER_TYPE_AES) { | |
1045 | ||
1046 | err = snd_mixart_pcm_digital(chip); | |
1047 | if (err < 0) | |
1048 | return err; | |
1049 | } | |
1050 | return err; | |
1051 | } | |
1052 | ||
1053 | ||
1054 | /* | |
1055 | * release all the cards assigned to a manager instance | |
1056 | */ | |
67b48b88 | 1057 | static int snd_mixart_free(struct mixart_mgr *mgr) |
1da177e4 LT |
1058 | { |
1059 | unsigned int i; | |
1060 | ||
1061 | for (i = 0; i < mgr->num_cards; i++) { | |
1062 | if (mgr->chip[i]) | |
1063 | snd_card_free(mgr->chip[i]->card); | |
1064 | } | |
1065 | ||
1066 | /* stop mailbox */ | |
1067 | snd_mixart_exit_mailbox(mgr); | |
1068 | ||
1069 | /* release irq */ | |
1070 | if (mgr->irq >= 0) | |
437a5a46 | 1071 | free_irq(mgr->irq, mgr); |
1da177e4 LT |
1072 | |
1073 | /* reset board if some firmware was loaded */ | |
1074 | if(mgr->dsp_loaded) { | |
1075 | snd_mixart_reset_board(mgr); | |
1076 | snd_printdd("reset miXart !\n"); | |
1077 | } | |
1078 | ||
1079 | /* release the i/o ports */ | |
1080 | for (i = 0; i < 2; i++) { | |
1081 | if (mgr->mem[i].virt) | |
1082 | iounmap(mgr->mem[i].virt); | |
1083 | } | |
1084 | pci_release_regions(mgr->pci); | |
1085 | ||
1086 | /* free flowarray */ | |
1087 | if(mgr->flowinfo.area) { | |
1088 | snd_dma_free_pages(&mgr->flowinfo); | |
1089 | mgr->flowinfo.area = NULL; | |
1090 | } | |
1091 | /* free bufferarray */ | |
1092 | if(mgr->bufferinfo.area) { | |
1093 | snd_dma_free_pages(&mgr->bufferinfo); | |
1094 | mgr->bufferinfo.area = NULL; | |
1095 | } | |
1096 | ||
1097 | pci_disable_device(mgr->pci); | |
1098 | kfree(mgr); | |
1099 | return 0; | |
1100 | } | |
1101 | ||
1102 | /* | |
1103 | * proc interface | |
1104 | */ | |
1da177e4 LT |
1105 | |
1106 | /* | |
1107 | mixart_BA0 proc interface for BAR 0 - read callback | |
1108 | */ | |
24e4a121 TI |
1109 | static ssize_t snd_mixart_BA0_read(struct snd_info_entry *entry, |
1110 | void *file_private_data, | |
1111 | struct file *file, char __user *buf, | |
1112 | size_t count, loff_t pos) | |
1da177e4 | 1113 | { |
67b48b88 | 1114 | struct mixart_mgr *mgr = entry->private_data; |
1da177e4 | 1115 | |
b0cc58a2 DC |
1116 | count = count & ~3; /* make sure the read size is a multiple of 4 bytes */ |
1117 | if (copy_to_user_fromio(buf, MIXART_MEM(mgr, pos), count)) | |
1da177e4 LT |
1118 | return -EFAULT; |
1119 | return count; | |
1120 | } | |
1121 | ||
1122 | /* | |
1123 | mixart_BA1 proc interface for BAR 1 - read callback | |
1124 | */ | |
24e4a121 TI |
1125 | static ssize_t snd_mixart_BA1_read(struct snd_info_entry *entry, |
1126 | void *file_private_data, | |
1127 | struct file *file, char __user *buf, | |
1128 | size_t count, loff_t pos) | |
1da177e4 | 1129 | { |
67b48b88 | 1130 | struct mixart_mgr *mgr = entry->private_data; |
1da177e4 | 1131 | |
b0cc58a2 DC |
1132 | count = count & ~3; /* make sure the read size is a multiple of 4 bytes */ |
1133 | if (copy_to_user_fromio(buf, MIXART_REG(mgr, pos), count)) | |
1da177e4 LT |
1134 | return -EFAULT; |
1135 | return count; | |
1136 | } | |
1137 | ||
1138 | static struct snd_info_entry_ops snd_mixart_proc_ops_BA0 = { | |
1139 | .read = snd_mixart_BA0_read, | |
1da177e4 LT |
1140 | }; |
1141 | ||
1142 | static struct snd_info_entry_ops snd_mixart_proc_ops_BA1 = { | |
1143 | .read = snd_mixart_BA1_read, | |
1da177e4 LT |
1144 | }; |
1145 | ||
1146 | ||
67b48b88 TI |
1147 | static void snd_mixart_proc_read(struct snd_info_entry *entry, |
1148 | struct snd_info_buffer *buffer) | |
1da177e4 | 1149 | { |
67b48b88 | 1150 | struct snd_mixart *chip = entry->private_data; |
1da177e4 LT |
1151 | u32 ref; |
1152 | ||
1153 | snd_iprintf(buffer, "Digigram miXart (alsa card %d)\n\n", chip->chip_idx); | |
1154 | ||
1155 | /* stats available when embedded OS is running */ | |
1156 | if (chip->mgr->dsp_loaded & ( 1 << MIXART_MOTHERBOARD_ELF_INDEX)) { | |
1157 | snd_iprintf(buffer, "- hardware -\n"); | |
1158 | switch (chip->mgr->board_type ) { | |
1159 | case MIXART_DAUGHTER_TYPE_NONE : snd_iprintf(buffer, "\tmiXart8 (no daughter board)\n\n"); break; | |
1160 | case MIXART_DAUGHTER_TYPE_AES : snd_iprintf(buffer, "\tmiXart8 AES/EBU\n\n"); break; | |
1161 | case MIXART_DAUGHTER_TYPE_COBRANET : snd_iprintf(buffer, "\tmiXart8 Cobranet\n\n"); break; | |
1162 | default: snd_iprintf(buffer, "\tUNKNOWN!\n\n"); break; | |
1163 | } | |
1164 | ||
1165 | snd_iprintf(buffer, "- system load -\n"); | |
1166 | ||
1167 | /* get perf reference */ | |
1168 | ||
1169 | ref = readl_be( MIXART_MEM( chip->mgr, MIXART_PSEUDOREG_PERF_SYSTEM_LOAD_OFFSET)); | |
1170 | ||
1171 | if (ref) { | |
1172 | u32 mailbox = 100 * readl_be( MIXART_MEM( chip->mgr, MIXART_PSEUDOREG_PERF_MAILBX_LOAD_OFFSET)) / ref; | |
1173 | u32 streaming = 100 * readl_be( MIXART_MEM( chip->mgr, MIXART_PSEUDOREG_PERF_STREAM_LOAD_OFFSET)) / ref; | |
1174 | u32 interr = 100 * readl_be( MIXART_MEM( chip->mgr, MIXART_PSEUDOREG_PERF_INTERR_LOAD_OFFSET)) / ref; | |
1175 | ||
1176 | snd_iprintf(buffer, "\tstreaming : %d\n", streaming); | |
1177 | snd_iprintf(buffer, "\tmailbox : %d\n", mailbox); | |
cf2fbdd2 | 1178 | snd_iprintf(buffer, "\tinterrupts handling : %d\n\n", interr); |
1da177e4 LT |
1179 | } |
1180 | } /* endif elf loaded */ | |
1181 | } | |
1182 | ||
e23e7a14 | 1183 | static void snd_mixart_proc_init(struct snd_mixart *chip) |
1da177e4 | 1184 | { |
67b48b88 | 1185 | struct snd_info_entry *entry; |
1da177e4 LT |
1186 | |
1187 | /* text interface to read perf and temp meters */ | |
1188 | if (! snd_card_proc_new(chip->card, "board_info", &entry)) { | |
1189 | entry->private_data = chip; | |
1da177e4 LT |
1190 | entry->c.text.read = snd_mixart_proc_read; |
1191 | } | |
1192 | ||
1193 | if (! snd_card_proc_new(chip->card, "mixart_BA0", &entry)) { | |
1194 | entry->content = SNDRV_INFO_CONTENT_DATA; | |
1195 | entry->private_data = chip->mgr; | |
1196 | entry->c.ops = &snd_mixart_proc_ops_BA0; | |
1197 | entry->size = MIXART_BA0_SIZE; | |
1198 | } | |
1199 | if (! snd_card_proc_new(chip->card, "mixart_BA1", &entry)) { | |
1200 | entry->content = SNDRV_INFO_CONTENT_DATA; | |
1201 | entry->private_data = chip->mgr; | |
1202 | entry->c.ops = &snd_mixart_proc_ops_BA1; | |
1203 | entry->size = MIXART_BA1_SIZE; | |
1204 | } | |
1205 | } | |
1206 | /* end of proc interface */ | |
1207 | ||
1208 | ||
1209 | /* | |
1210 | * probe function - creates the card manager | |
1211 | */ | |
e23e7a14 BP |
1212 | static int snd_mixart_probe(struct pci_dev *pci, |
1213 | const struct pci_device_id *pci_id) | |
1da177e4 LT |
1214 | { |
1215 | static int dev; | |
67b48b88 | 1216 | struct mixart_mgr *mgr; |
1da177e4 LT |
1217 | unsigned int i; |
1218 | int err; | |
1219 | size_t size; | |
1220 | ||
1221 | /* | |
1222 | */ | |
1223 | if (dev >= SNDRV_CARDS) | |
1224 | return -ENODEV; | |
1225 | if (! enable[dev]) { | |
1226 | dev++; | |
1227 | return -ENOENT; | |
1228 | } | |
1229 | ||
1230 | /* enable PCI device */ | |
1231 | if ((err = pci_enable_device(pci)) < 0) | |
1232 | return err; | |
1233 | pci_set_master(pci); | |
1234 | ||
1235 | /* check if we can restrict PCI DMA transfers to 32 bits */ | |
284901a9 | 1236 | if (pci_set_dma_mask(pci, DMA_BIT_MASK(32)) < 0) { |
1da177e4 LT |
1237 | snd_printk(KERN_ERR "architecture does not support 32bit PCI busmaster DMA\n"); |
1238 | pci_disable_device(pci); | |
1239 | return -ENXIO; | |
1240 | } | |
1241 | ||
1242 | /* | |
1243 | */ | |
e560d8d8 | 1244 | mgr = kzalloc(sizeof(*mgr), GFP_KERNEL); |
1da177e4 LT |
1245 | if (! mgr) { |
1246 | pci_disable_device(pci); | |
1247 | return -ENOMEM; | |
1248 | } | |
1249 | ||
1250 | mgr->pci = pci; | |
1251 | mgr->irq = -1; | |
1252 | ||
1253 | /* resource assignment */ | |
1254 | if ((err = pci_request_regions(pci, CARD_NAME)) < 0) { | |
1255 | kfree(mgr); | |
1256 | pci_disable_device(pci); | |
1257 | return err; | |
1258 | } | |
1259 | for (i = 0; i < 2; i++) { | |
1260 | mgr->mem[i].phys = pci_resource_start(pci, i); | |
2f5ad54e | 1261 | mgr->mem[i].virt = pci_ioremap_bar(pci, i); |
f9ff161a TI |
1262 | if (!mgr->mem[i].virt) { |
1263 | printk(KERN_ERR "unable to remap resource 0x%lx\n", | |
1264 | mgr->mem[i].phys); | |
1265 | snd_mixart_free(mgr); | |
1266 | return -EBUSY; | |
1267 | } | |
1da177e4 LT |
1268 | } |
1269 | ||
437a5a46 | 1270 | if (request_irq(pci->irq, snd_mixart_interrupt, IRQF_SHARED, |
934c2b6d | 1271 | KBUILD_MODNAME, mgr)) { |
1da177e4 LT |
1272 | snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq); |
1273 | snd_mixart_free(mgr); | |
1274 | return -EBUSY; | |
1275 | } | |
1276 | mgr->irq = pci->irq; | |
1277 | ||
1278 | sprintf(mgr->shortname, "Digigram miXart"); | |
1279 | sprintf(mgr->longname, "%s at 0x%lx & 0x%lx, irq %i", mgr->shortname, mgr->mem[0].phys, mgr->mem[1].phys, mgr->irq); | |
1280 | ||
1281 | /* ISR spinlock */ | |
1282 | spin_lock_init(&mgr->lock); | |
1283 | ||
1284 | /* init mailbox */ | |
1285 | mgr->msg_fifo_readptr = 0; | |
1286 | mgr->msg_fifo_writeptr = 0; | |
1287 | ||
1288 | spin_lock_init(&mgr->msg_lock); | |
62932df8 | 1289 | mutex_init(&mgr->msg_mutex); |
1da177e4 LT |
1290 | init_waitqueue_head(&mgr->msg_sleep); |
1291 | atomic_set(&mgr->msg_processed, 0); | |
1292 | ||
1293 | /* init setup mutex*/ | |
62932df8 | 1294 | mutex_init(&mgr->setup_mutex); |
1da177e4 LT |
1295 | |
1296 | /* init message taslket */ | |
67b48b88 | 1297 | tasklet_init(&mgr->msg_taskq, snd_mixart_msg_tasklet, (unsigned long) mgr); |
1da177e4 LT |
1298 | |
1299 | /* card assignment */ | |
1300 | mgr->num_cards = MIXART_MAX_CARDS; /* 4 FIXME: configurable? */ | |
1301 | for (i = 0; i < mgr->num_cards; i++) { | |
67b48b88 | 1302 | struct snd_card *card; |
1da177e4 LT |
1303 | char tmpid[16]; |
1304 | int idx; | |
1305 | ||
1306 | if (index[dev] < 0) | |
1307 | idx = index[dev]; | |
1308 | else | |
1309 | idx = index[dev] + i; | |
1310 | snprintf(tmpid, sizeof(tmpid), "%s-%d", id[dev] ? id[dev] : "MIXART", i); | |
e58de7ba | 1311 | err = snd_card_create(idx, tmpid, THIS_MODULE, 0, &card); |
1da177e4 | 1312 | |
e58de7ba | 1313 | if (err < 0) { |
1da177e4 LT |
1314 | snd_printk(KERN_ERR "cannot allocate the card %d\n", i); |
1315 | snd_mixart_free(mgr); | |
e58de7ba | 1316 | return err; |
1da177e4 LT |
1317 | } |
1318 | ||
1319 | strcpy(card->driver, CARD_NAME); | |
1320 | sprintf(card->shortname, "%s [PCM #%d]", mgr->shortname, i); | |
1321 | sprintf(card->longname, "%s [PCM #%d]", mgr->longname, i); | |
1322 | ||
1323 | if ((err = snd_mixart_create(mgr, card, i)) < 0) { | |
73f6a12e | 1324 | snd_card_free(card); |
1da177e4 LT |
1325 | snd_mixart_free(mgr); |
1326 | return err; | |
1327 | } | |
1328 | ||
1329 | if(i==0) { | |
1330 | /* init proc interface only for chip0 */ | |
1331 | snd_mixart_proc_init(mgr->chip[i]); | |
1332 | } | |
1333 | ||
1334 | if ((err = snd_card_register(card)) < 0) { | |
1335 | snd_mixart_free(mgr); | |
1336 | return err; | |
1337 | } | |
1338 | } | |
1339 | ||
1340 | /* init firmware status (mgr->dsp_loaded reset in hwdep_new) */ | |
1341 | mgr->board_type = MIXART_DAUGHTER_TYPE_NONE; | |
1342 | ||
1343 | /* create array of streaminfo */ | |
67b48b88 TI |
1344 | size = PAGE_ALIGN( (MIXART_MAX_STREAM_PER_CARD * MIXART_MAX_CARDS * |
1345 | sizeof(struct mixart_flowinfo)) ); | |
1da177e4 LT |
1346 | if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci), |
1347 | size, &mgr->flowinfo) < 0) { | |
1348 | snd_mixart_free(mgr); | |
1349 | return -ENOMEM; | |
1350 | } | |
1351 | /* init streaminfo_array */ | |
1352 | memset(mgr->flowinfo.area, 0, size); | |
1353 | ||
1354 | /* create array of bufferinfo */ | |
67b48b88 TI |
1355 | size = PAGE_ALIGN( (MIXART_MAX_STREAM_PER_CARD * MIXART_MAX_CARDS * |
1356 | sizeof(struct mixart_bufferinfo)) ); | |
1da177e4 LT |
1357 | if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci), |
1358 | size, &mgr->bufferinfo) < 0) { | |
1359 | snd_mixart_free(mgr); | |
1360 | return -ENOMEM; | |
1361 | } | |
1362 | /* init bufferinfo_array */ | |
1363 | memset(mgr->bufferinfo.area, 0, size); | |
1364 | ||
1365 | /* set up firmware */ | |
1366 | err = snd_mixart_setup_firmware(mgr); | |
1367 | if (err < 0) { | |
1368 | snd_mixart_free(mgr); | |
1369 | return err; | |
1370 | } | |
1371 | ||
1372 | pci_set_drvdata(pci, mgr); | |
1373 | dev++; | |
1374 | return 0; | |
1375 | } | |
1376 | ||
e23e7a14 | 1377 | static void snd_mixart_remove(struct pci_dev *pci) |
1da177e4 LT |
1378 | { |
1379 | snd_mixart_free(pci_get_drvdata(pci)); | |
1da177e4 LT |
1380 | } |
1381 | ||
e9f66d9b | 1382 | static struct pci_driver mixart_driver = { |
3733e424 | 1383 | .name = KBUILD_MODNAME, |
1da177e4 LT |
1384 | .id_table = snd_mixart_ids, |
1385 | .probe = snd_mixart_probe, | |
e23e7a14 | 1386 | .remove = snd_mixart_remove, |
1da177e4 LT |
1387 | }; |
1388 | ||
e9f66d9b | 1389 | module_pci_driver(mixart_driver); |