static int mixart_set_pipe_state(struct mixart_mgr *mgr, struct mixart_pipe *pipe, int start) { struct mixart_group_state_req group_state; struct mixart_group_state_resp group_state_resp; struct mixart_msg request; int err; u32 system_msg_uid; switch(pipe->status) { case PIPE_RUNNING: case PIPE_CLOCK_SET: if(start) return 0; /* already started */ break; case PIPE_STOPPED: if(!start) return 0; /* already stopped */ break; default: snd_printk(KERN_ERR "error mixart_set_pipe_state called with wrong pipe->status!\n"); return -EINVAL; /* function called with wrong pipe status */ } system_msg_uid = 0x12345678; /* the event ! (take care: the MSB and two LSB's have to be 0) */ /* wait on the last MSG_SYSTEM_SEND_SYNCHRO_CMD command to be really finished */ request.message_id = MSG_SYSTEM_WAIT_SYNCHRO_CMD; request.uid = (struct mixart_uid){0,0}; request.data = &system_msg_uid; request.size = sizeof(system_msg_uid); err = snd_mixart_send_msg_wait_notif(mgr, &request, system_msg_uid); if(err) { snd_printk(KERN_ERR "error : MSG_SYSTEM_WAIT_SYNCHRO_CMD was not notified !\n"); return err; } /* start or stop the pipe (1 pipe) */ memset(&group_state, 0, sizeof(group_state)); group_state.pipe_count = 1; group_state.pipe_uid[0] = pipe->group_uid; if(start) request.message_id = MSG_STREAM_START_STREAM_GRP_PACKET; else request.message_id = MSG_STREAM_STOP_STREAM_GRP_PACKET; request.uid = pipe->group_uid; /*(struct mixart_uid){0,0};*/ request.data = &group_state; request.size = sizeof(group_state); err = snd_mixart_send_msg(mgr, &request, sizeof(group_state_resp), &group_state_resp); if (err < 0 || group_state_resp.txx_status != 0) { snd_printk(KERN_ERR "error MSG_STREAM_ST***_STREAM_GRP_PACKET err=%x stat=%x !\n", err, group_state_resp.txx_status); return -EINVAL; } if(start) { u32 stat; group_state.pipe_count = 0; /* in case of start same command once again with pipe_count=0 */ err = snd_mixart_send_msg(mgr, &request, sizeof(group_state_resp), &group_state_resp); if (err < 0 || group_state_resp.txx_status != 0) { snd_printk(KERN_ERR "error MSG_STREAM_START_STREAM_GRP_PACKET err=%x stat=%x !\n", err, group_state_resp.txx_status); return -EINVAL; } /* in case of start send a synchro top */ request.message_id = MSG_SYSTEM_SEND_SYNCHRO_CMD; request.uid = (struct mixart_uid){0,0}; request.data = NULL; request.size = 0; err = snd_mixart_send_msg(mgr, &request, sizeof(stat), &stat); if (err < 0 || stat != 0) { snd_printk(KERN_ERR "error MSG_SYSTEM_SEND_SYNCHRO_CMD err=%x stat=%x !\n", err, stat); return -EINVAL; } pipe->status = PIPE_RUNNING; } else /* !start */ pipe->status = PIPE_STOPPED; return 0; } static int mixart_set_clock(struct mixart_mgr *mgr, struct mixart_pipe *pipe, unsigned int rate) { struct mixart_msg request; struct mixart_clock_properties clock_properties; struct mixart_clock_properties_resp clock_prop_resp; int err; switch(pipe->status) { case PIPE_CLOCK_SET: break; case PIPE_RUNNING: if(rate != 0) break; default: if(rate == 0) return 0; /* nothing to do */ else { snd_printk(KERN_ERR "error mixart_set_clock(%d) called with wrong pipe->status !\n", rate); return -EINVAL; } } memset(&clock_properties, 0, sizeof(clock_properties)); clock_properties.clock_generic_type = (rate != 0) ? CGT_INTERNAL_CLOCK : CGT_NO_CLOCK; clock_properties.clock_mode = CM_STANDALONE; clock_properties.frequency = rate; clock_properties.nb_callers = 1; /* only one entry in uid_caller ! */ clock_properties.uid_caller[0] = pipe->group_uid; snd_printdd("mixart_set_clock to %d kHz\n", rate); request.message_id = MSG_CLOCK_SET_PROPERTIES; request.uid = mgr->uid_console_manager; request.data = &clock_properties; request.size = sizeof(clock_properties); err = snd_mixart_send_msg(mgr, &request, sizeof(clock_prop_resp), &clock_prop_resp); if (err < 0 || clock_prop_resp.status != 0 || clock_prop_resp.clock_mode != CM_STANDALONE) { 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); return -EINVAL; } if(rate) pipe->status = PIPE_CLOCK_SET; else pipe->status = PIPE_RUNNING; return 0; } /* * Allocate or reference output pipe for analog IOs (pcmp0/1) */ struct mixart_pipe * snd_mixart_add_ref_pipe(struct snd_mixart *chip, int pcm_number, int capture, int monitoring) { int stream_count; struct mixart_pipe *pipe; struct mixart_msg request; if(capture) { if (pcm_number == MIXART_PCM_ANALOG) { pipe = &(chip->pipe_in_ana); /* analog inputs */ } else { pipe = &(chip->pipe_in_dig); /* digital inputs */ } request.message_id = MSG_STREAM_ADD_OUTPUT_GROUP; stream_count = MIXART_CAPTURE_STREAMS; } else { if (pcm_number == MIXART_PCM_ANALOG) { pipe = &(chip->pipe_out_ana); /* analog outputs */ } else { pipe = &(chip->pipe_out_dig); /* digital outputs */ } request.message_id = MSG_STREAM_ADD_INPUT_GROUP; stream_count = MIXART_PLAYBACK_STREAMS; } /* a new stream is opened and there are already all streams in use */ if( (monitoring == 0) && (pipe->references >= stream_count) ) { return NULL; } /* pipe is not yet defined */ if( pipe->status == PIPE_UNDEFINED ) { int err, i; struct { struct mixart_streaming_group_req sgroup_req; struct mixart_streaming_group sgroup_resp; } *buf; snd_printdd("add_ref_pipe audio chip(%d) pcm(%d)\n", chip->chip_idx, pcm_number); buf = kmalloc(sizeof(*buf), GFP_KERNEL); if (!buf) return NULL; request.uid = (struct mixart_uid){0,0}; /* should be StreamManagerUID, but zero is OK if there is only one ! */ request.data = &buf->sgroup_req; request.size = sizeof(buf->sgroup_req); memset(&buf->sgroup_req, 0, sizeof(buf->sgroup_req)); buf->sgroup_req.stream_count = stream_count; buf->sgroup_req.channel_count = 2; buf->sgroup_req.latency = 256; buf->sgroup_req.connector = pipe->uid_left_connector; /* the left connector */ for (i=0; i<stream_count; i++) { int j; struct mixart_flowinfo *flowinfo; struct mixart_bufferinfo *bufferinfo; /* we don't yet know the format, so config 16 bit pcm audio for instance */ buf->sgroup_req.stream_info[i].size_max_byte_frame = 1024; buf->sgroup_req.stream_info[i].size_max_sample_frame = 256; buf->sgroup_req.stream_info[i].nb_bytes_max_per_sample = MIXART_FLOAT_P__4_0_TO_HEX; /* is 4.0f */ /* find the right bufferinfo_array */ j = (chip->chip_idx * MIXART_MAX_STREAM_PER_CARD) + (pcm_number * (MIXART_PLAYBACK_STREAMS + MIXART_CAPTURE_STREAMS)) + i; if(capture) j += MIXART_PLAYBACK_STREAMS; /* in the array capture is behind playback */ buf->sgroup_req.flow_entry[i] = j; flowinfo = (struct mixart_flowinfo *)chip->mgr->flowinfo.area; flowinfo[j].bufferinfo_array_phy_address = (u32)chip->mgr->bufferinfo.addr + (j * sizeof(struct mixart_bufferinfo)); flowinfo[j].bufferinfo_count = 1; /* 1 will set the miXart to ring-buffer mode ! */ bufferinfo = (struct mixart_bufferinfo *)chip->mgr->bufferinfo.area; bufferinfo[j].buffer_address = 0; /* buffer is not yet allocated */ bufferinfo[j].available_length = 0; /* buffer is not yet allocated */ /* construct the identifier of the stream buffer received in the interrupts ! */ bufferinfo[j].buffer_id = (chip->chip_idx << MIXART_NOTIFY_CARD_OFFSET) + (pcm_number << MIXART_NOTIFY_PCM_OFFSET ) + i; if(capture) { bufferinfo[j].buffer_id |= MIXART_NOTIFY_CAPT_MASK; } } err = snd_mixart_send_msg(chip->mgr, &request, sizeof(buf->sgroup_resp), &buf->sgroup_resp); if((err < 0) || (buf->sgroup_resp.status != 0)) { snd_printk(KERN_ERR "error MSG_STREAM_ADD_**PUT_GROUP err=%x stat=%x !\n", err, buf->sgroup_resp.status); kfree(buf); return NULL; } pipe->group_uid = buf->sgroup_resp.group; /* id of the pipe, as returned by embedded */ pipe->stream_count = buf->sgroup_resp.stream_count; /* pipe->stream_uid[i] = buf->sgroup_resp.stream[i].stream_uid; */ pipe->status = PIPE_STOPPED; kfree(buf); } if(monitoring) pipe->monitoring = 1; else pipe->references++; return pipe; }
static int mixart_set_pipe_state(mixart_mgr_t *mgr, mixart_pipe_t* pipe, int start) { mixart_group_state_req_t group_state; mixart_group_state_resp_t group_state_resp; mixart_msg_t request; int err; u32 system_msg_uid; switch(pipe->status) { case PIPE_RUNNING: case PIPE_CLOCK_SET: if(start) return 0; /* already started */ break; case PIPE_STOPPED: if(!start) return 0; /* already stopped */ break; default: snd_printk(KERN_ERR "error mixart_set_pipe_state called with wrong pipe->status!\n"); return -EINVAL; /* function called with wrong pipe status */ } system_msg_uid = 0x12345678; /* the event ! (take care: the MSB and two LSB's have to be 0) */ /* wait on the last MSG_SYSTEM_SEND_SYNCHRO_CMD command to be really finished */ request.message_id = MSG_SYSTEM_WAIT_SYNCHRO_CMD; request.uid = (mixart_uid_t){0,0}; request.data = &system_msg_uid; request.size = sizeof(system_msg_uid); err = snd_mixart_send_msg_wait_notif(mgr, &request, system_msg_uid); if(err) { snd_printk(KERN_ERR "error : MSG_SYSTEM_WAIT_SYNCHRO_CMD was not notified !\n"); return err; } /* start or stop the pipe (1 pipe) */ memset(&group_state, 0, sizeof(group_state)); group_state.pipe_count = 1; group_state.pipe_uid[0] = pipe->group_uid; if(start) request.message_id = MSG_STREAM_START_STREAM_GRP_PACKET; else request.message_id = MSG_STREAM_STOP_STREAM_GRP_PACKET; request.uid = pipe->group_uid; /*(mixart_uid_t){0,0};*/ request.data = &group_state; request.size = sizeof(group_state); err = snd_mixart_send_msg(mgr, &request, sizeof(group_state_resp), &group_state_resp); if (err < 0 || group_state_resp.txx_status != 0) { snd_printk(KERN_ERR "error MSG_STREAM_ST***_STREAM_GRP_PACKET err=%x stat=%x !\n", err, group_state_resp.txx_status); return -EINVAL; } if(start) { u32 stat; group_state.pipe_count = 0; /* in case of start same command once again with pipe_count=0 */ err = snd_mixart_send_msg(mgr, &request, sizeof(group_state_resp), &group_state_resp); if (err < 0 || group_state_resp.txx_status != 0) { snd_printk(KERN_ERR "error MSG_STREAM_START_STREAM_GRP_PACKET err=%x stat=%x !\n", err, group_state_resp.txx_status); return -EINVAL; } /* in case of start send a synchro top */ request.message_id = MSG_SYSTEM_SEND_SYNCHRO_CMD; request.uid = (mixart_uid_t){0,0}; request.data = NULL; request.size = 0; err = snd_mixart_send_msg(mgr, &request, sizeof(stat), &stat); if (err < 0 || stat != 0) { snd_printk(KERN_ERR "error MSG_SYSTEM_SEND_SYNCHRO_CMD err=%x stat=%x !\n", err, stat); return -EINVAL; } pipe->status = PIPE_RUNNING; } else /* !start */ pipe->status = PIPE_STOPPED; return 0; }