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