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();
}
