static void rs_stop(struct tty_struct *tty) { struct cnxt_serial *info = (struct cnxt_serial *)tty->driver_data; if (serial_paranoia_check(info, tty->device, "rs_stop")) return; #if 0 save_flags(flags); cli(); tx_stop(info->uart); restore_flags(flags); #endif }
/* * ------------------------------------------------------------ * rs_stop() and rs_start() * * This routines are called before setting or resetting tty->stopped. * They enable or disable transmitter interrupts, as necessary. * ------------------------------------------------------------ */ static void rs_stop(struct tty_struct *tty) { struct s3c3410_serial *info = (struct s3c3410_serial *) tty->driver_data; unsigned long flags = 0; if (serial_paranoia_check(info, tty->device, "rs_stop")) return; save_flags(flags); cli(); tx_stop(); rx_stop(); restore_flags(flags); }
/* * This is the serial driver's generic interrupt routine */ static void rs_interruptTx(int irq, void *dev_id, struct pt_regs *regs) { unsigned int count, status; struct s3c3410_serial *info = &s3c3410_info; if (info->x_char) { outb(info->x_char, S3C3410X_UART_BASE+S3C3410X_UTXH_B); info->x_char = 0; return; } if ((info->xmit_cnt <= 0) || info->tty->stopped || info->tty->hw_stopped ) { tx_stop(); return; } for (count = TX_FIFO_DEPTH; count > 0; --count) { status = inb(S3C3410X_UART_BASE+S3C3410X_UFSTAT); if (status & UFSTAT_TFF) { handle_status (info, UFSTAT_TFF); break; } else { outb(info->xmit_buf[info->xmit_tail++], S3C3410X_UART_BASE+S3C3410X_UTXH_B); info->xmit_tail = info->xmit_tail & (SERIAL_XMIT_SIZE - 1); if (--info->xmit_cnt <= 0) break; } } if (info->xmit_cnt < WAKEUP_CHARS) rs_sched_event(info, RS_EVENT_WRITE_WAKEUP); if (info->xmit_cnt <= 0) tx_stop(); return; }
int audio_device_release(session_t *sp, audio_desc_t the_dev) { if (sp->audio_device == 0) { debug_msg("Audio device already released from session\n"); return FALSE; } if (sp->audio_device != the_dev) { debug_msg("Releasing wrong device!\n"); return FALSE; } /* Mix is going to be destroyed - tone_generator and * voxlet have pointers to mixer in their state that * is about to expire. Could pass mixer as argument * to their process functions... */ if (sp->tone_generator) { tonegen_destroy(&sp->tone_generator); } if (sp->local_file_player) { voxlet_destroy(&sp->local_file_player); } cushion_destroy(&sp->cushion); mix_destroy(&sp->ms); tx_stop(sp->tb); tx_destroy(&sp->tb); source_list_clear(sp->active_sources); audio_close(sp->audio_device); sp->audio_device = 0; xfree(zero_buf); zero_buf = NULL; return FALSE; }
static int whitebox_release(struct inode* inode, struct file* filp) { struct whitebox_user_source *user_source = &whitebox_device->user_source; struct whitebox_rf_sink *rf_sink = &whitebox_device->rf_sink; struct whitebox_user_sink *user_sink = &whitebox_device->user_sink; struct whitebox_rf_source *rf_source = &whitebox_device->rf_source; d_printk(2, "whitebox release\n"); if (atomic_read(&use_count) != 1) { d_printk(0, "Device not in use"); return -ENOENT; } if (whitebox_device->state == WDS_TX || whitebox_device->state == WDS_TX_STREAMING) { while (tx_stop(whitebox_device) < 0) cpu_relax(); } if (whitebox_device->state == WDS_RX || whitebox_device->state == WDS_RX_STREAMING) { while (rx_stop(whitebox_device) < 0) cpu_relax(); } // Turn off LO whitebox_device->adf4351_regs[2] |= WA_PD_MASK; whitebox_gpio_adf4351_write(whitebox_device->platform_data, whitebox_device->adf4351_regs[2]); // Disable DAC whitebox_gpio_dac_disable(whitebox_device->platform_data); whitebox_rf_sink_free(rf_sink); whitebox_user_source_free(user_source); whitebox_rf_source_free(rf_source); whitebox_user_sink_free(user_sink); atomic_dec(&use_count); return 0; }
int audio_device_reconfigure(session_t *sp) { audio_config prev_config, *curr_config, *new_config; audio_port_t iport = 0, oport = 0; int change_req; assert(sp->new_config != NULL); new_config = sp->new_config; change_req = FALSE; if (new_config->device == 0) { /* No request to change audio device */ new_config->device = sp->audio_device; } else if (new_config->device != sp->audio_device) { /* Request to change device */ change_req = TRUE; debug_msg("Change device requested.\n"); } if (sp->audio_device) { iport = audio_get_iport(sp->audio_device); oport = audio_get_oport(sp->audio_device); } if (new_config->primary == 0) { /* No request to change primary encoding */ new_config->primary = codec_get_by_payload(sp->encodings[0]); } else if (codec_audio_formats_compatible(new_config->primary, codec_get_by_payload(sp->encodings[0])) == FALSE) { /* Request to change primary and format incompatible so * device needs rejigging */ change_req = TRUE; debug_msg("Change primary requested.\n"); } else { /* Request to change primary to compatible coding. */ sp->encodings[0] = codec_get_payload(new_config->primary); } if (new_config->render_3d == -1) { /* No request to change 3d rendering */ new_config->render_3d = sp->render_3d; } else if (new_config->render_3d != sp->render_3d) { change_req = TRUE; debug_msg("Change 3d rendering enabled requested.\n"); } if (change_req) { /* Store current config in case it reconfig attempt fails */ prev_config.device = sp->audio_device; prev_config.primary = codec_get_by_payload(sp->encodings[0]); prev_config.render_3d = sp->render_3d; if (sp->audio_device) { audio_device_release(sp, sp->audio_device); } if (audio_device_attempt_config(sp, new_config)) { /* New config acceptable */ curr_config = new_config; } else if (audio_device_attempt_config(sp, &prev_config)) { /* else attempt to fallback to previous config */ curr_config = &prev_config; debug_msg("Fellback to old dev config\n"); } else { /* Fallback to guaranteed config - something * went badly wrong */ ac_destroy(&new_config); audio_device_get_safe_config(&new_config); assert(new_config); if (audio_device_attempt_config(sp, new_config) == FALSE) { /* should never get here */ abort(); } curr_config = new_config; debug_msg("Fell back to safe config\n"); } debug_msg("0x%08x 0x%08x\n", prev_config.device, curr_config->device); if (prev_config.device == curr_config->device) { debug_msg("Restoring ports\n"); audio_set_iport(curr_config->device, iport); audio_set_oport(curr_config->device, oport); } else { const audio_port_details_t *papd; /* Ports will be squiffy */ papd = audio_get_iport_details(curr_config->device, 0); audio_set_iport(curr_config->device, papd->port); papd = audio_get_oport_details(curr_config->device, 0); audio_set_oport(curr_config->device, papd->port); } audio_loopback(curr_config->device, sp->loopback_gain); sp->audio_device = curr_config->device; sp->encodings[0] = codec_get_payload(curr_config->primary); /* If using redundancy check it is still relevent */ if (sp->num_encodings > 1 && !codec_audio_formats_compatible(curr_config->primary, codec_get_by_payload(sp->encodings[1]))) { const cc_details_t *ccd; channel_encoder_destroy(&sp->channel_coder); ccd = channel_get_null_coder(); channel_encoder_create(ccd->descriptor, &sp->channel_coder); sp->num_encodings = 1; } sp->render_3d = curr_config->render_3d; } else { debug_msg("audio device reconfigure - nothing to do.\n"); if (tx_is_sending(sp->tb)) { tx_stop(sp->tb); tx_start(sp->tb); } } tx_igain_update(sp->tb); ac_destroy(&sp->new_config); return change_req; }
void settings_load_early(session_t *sp) { /* FIXME: This needs to be updated for the transcoder */ char *name, *param, *primary_codec, *port, *silence; int freq, chan, mute; uint32_t i, n, success, device_exists; const cc_details_t *ccd; const audio_device_details_t *add = NULL; const audio_port_details_t *apd = NULL; const converter_details_t *cod = NULL; const repair_details_t *r = NULL; codec_id_t cid; load_init(); /* Initial settings come from the common prefs file... */ init_part_two(); /* Switch to pulling settings from the RAT specific prefs file... */ if (sp->mode == AUDIO_TOOL) { name = setting_load_str("audioDevice", "No Audio Device"); } else { name = (char *) xmalloc(20); sprintf(name, "Transcoder Port %d", sp->id+1); } /* User may not have a (valid) audio device entry in the */ /* settings file, or have "No Audio Device" there. In */ /* either case try to use first available device, if */ /* it's in use we'll fallback to dummy device anyway. */ device_exists = FALSE; n = (int)audio_get_device_count(); for(i = 0; i < n; i++) { add = audio_get_device_details(i); if (strcmp(add->name, name) == 0) { device_exists = TRUE; break; } } if (strcmp(name, "No Audio Device") == 0 || device_exists == FALSE) { add = audio_get_device_details(0); } audio_device_register_change_device(sp, add->descriptor); freq = setting_load_int("audioFrequency", 8000); chan = setting_load_int("audioChannelsIn", 1); primary_codec = setting_load_str("audioPrimary", "GSM"); cid = codec_get_matching(primary_codec, (uint16_t)freq, (uint16_t)chan); if (codec_id_is_valid(cid) == FALSE) { /* Codec name is garbage...should only happen on upgrades */ cid = codec_get_matching("GSM", (uint16_t)freq, (uint16_t)chan); } audio_device_register_change_primary(sp, cid); audio_device_reconfigure(sp); port = setting_load_str("audioOutputPort", "Headphone"); n = audio_get_oport_count(sp->audio_device); for(i = 0; i < n; i++) { apd = audio_get_oport_details(sp->audio_device, i); if (!strcasecmp(port, apd->name)) { break; } } audio_set_oport(sp->audio_device, apd->port); port = setting_load_str("audioInputPort", "Microphone"); n = audio_get_iport_count(sp->audio_device); for(i = 0; i < n; i++) { apd = audio_get_iport_details(sp->audio_device, i); if (!strcasecmp(port, apd->name)) { break; } } audio_set_iport(sp->audio_device, apd->port); audio_set_ogain(sp->audio_device, setting_load_int("audioOutputGain", 75)); audio_set_igain(sp->audio_device, setting_load_int("audioInputGain", 75)); tx_igain_update(sp->tb); name = setting_load_str("audioChannelCoding", "None"); param = setting_load_str("audioChannelParameters", "None"); do { n = channel_get_coder_count(); for (i = 0; i < n; i++ ) { ccd = channel_get_coder_details(i); if (strcmp(ccd->name, name) == 0) { if (sp->channel_coder) { channel_encoder_destroy(&sp->channel_coder); } channel_encoder_create(ccd->descriptor, &sp->channel_coder); break; } } success = channel_encoder_set_parameters(sp->channel_coder, param); if (success == 0) { /* Could not set parameters for channel coder, fall back to "None" */ name = "None"; param = ""; } } while (success == 0); channel_encoder_set_units_per_packet(sp->channel_coder, (uint16_t) setting_load_int("audioUnits", 1)); /* Set default repair to be first available */ r = repair_get_details(0); sp->repair = r->id; name = setting_load_str("audioRepair", "Pattern-Match"); n = (int)repair_get_count(); for(i = 0; i < n; i++) { r = repair_get_details((uint16_t)i); if (strcasecmp(r->name, name) == 0) { sp->repair = r->id; break; } } /* Set default converter to be first available */ cod = converter_get_details(0); sp->converter = cod->id; name = setting_load_str("audioAutoConvert", "High Quality"); n = (int)converter_get_count(); /* If converter setting name matches then override existing choice */ for(i = 0; i < n; i++) { cod = converter_get_details(i); if (strcasecmp(cod->name, name) == 0) { sp->converter = cod->id; break; } } silence = setting_load_str("audioSilence", "Automatic"); sp->silence_detection = sd_name_to_type(silence); sp->manual_sd_thresh = setting_load_int("audioSilenceManualThresh", 100); if (sp->manual_sd) { manual_sd_set_thresh(sp->manual_sd, sp->manual_sd_thresh); } sp->limit_playout = setting_load_int("audioLimitPlayout", 0); sp->min_playout = setting_load_int("audioMinPlayout", 0); sp->max_playout = setting_load_int("audioMaxPlayout", 2000); sp->lecture = setting_load_int("audioLecture", 0); sp->agc_on = setting_load_int("audioAGC", 0); sp->loopback_gain = setting_load_int("audioLoopback", 0); audio_loopback(sp->audio_device, sp->loopback_gain); sp->echo_suppress = setting_load_int("audioEchoSuppress", 0); sp->meter = setting_load_int("audioPowermeters", 1); sp->rtp_promiscuous_mode = setting_load_int("rtpPromiscuousMode", 0); sp->rtp_wait_for_rtcp = setting_load_int("rtpWaitForRTCP", 1); /* Ignore saved render_3d setting. Break initial device config stuff. V.fiddly to fix. */ /* sp->render_3d = setting_load_int("audio3dRendering", 0); */ mute = setting_load_int("audioInputMute", sp->mode==TRANSCODER?0:1); if (mute && tx_is_sending(sp->tb)) { tx_stop(sp->tb); } else if (mute == 0 && tx_is_sending(sp->tb) == 0) { tx_start(sp->tb); } setting_load_int("audioOutputMute", 1); xmemchk(); load_done(); }