int metafile::tx_start_r()
{
if(!tx_recursion)
return tx_start();
tx_recursion++;
assert(tx_recursion);
return 0;
}
static void rs_start(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_start"))
return;
save_flags(flags);
cli();
rx_start(info->use_ints);
tx_start(info->use_ints);
restore_flags(flags);
}
static void uart_speed(void)
{
struct uart_regs *uart = uart_info.uart;
uart->line_ctrl = LCR_Divisor_Latch;
uart->fifo = (char)UART_115200; /* lower baud rate div */
uart->irqe = (char)(UART_115200>>8); /* upper baud rate div */
uart->line_ctrl = 0;
uart->line_ctrl = LCR_8_Bit_Word_1;
uart->iir = (FCR_Fifo_Enable | FCR_Rx_Fifo_Reset | FCR_Tx_Fifo_Reset ); /* fifo ctrl */
uart->irqe = IER_Rx_Holding_Reg; /* enable rx intr */
tx_start(uart, uart_info.use_ints);
start_rx();
}
static void rs_start(struct tty_struct *tty)
{
unsigned long flags;
struct cnxt_serial *info = (struct cnxt_serial *)tty->driver_data;
if (serial_paranoia_check(info,tty->device, "rs_start"))
return;
save_flags(flags);
cli();
tx_start(info->uart, info->use_ints);
start_rx();
restore_flags(flags);
}
static void rs_flush_chars(struct tty_struct *tty)
{
struct cnxt_serial *info = (struct cnxt_serial *)tty->driver_data;
unsigned long flags;
if (serial_paranoia_check(info, tty->device, "rs_flush_chars"))
return;
if(!info->use_ints){
for(;;) {
if (info->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
!info->xmit_buf)
return;
/* Enable transmitter */
save_flags(flags); cli();
tx_start(info->uart,info->use_ints);
}
}else{
if (info->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
!info->xmit_buf)
return;
/* Enable transmitter */
save_flags(flags); cli();
tx_start(info->uart, info->use_ints);
}
if(!info->use_ints)
wait_EOT(info->uart);
/* Send char */
//xmit_char(info->xmit_buf[info->xmit_tail++]);
xmit_string(info,(char *)&info->xmit_buf[info->xmit_tail++],1);
info->xmit_tail = info->xmit_tail & (SERIAL_XMIT_SIZE-1);
info->xmit_cnt--;
restore_flags(flags);
}
/*
* This routine is called to set the UART divisor registers to match
* the specified baud rate for a serial port.
*/
static void change_speed(struct cnxt_serial *info)
{
unsigned cflag;
int i;
if (!info->tty || !info->tty->termios)
return;
cflag = info->tty->termios->c_cflag;
/* set the baudrate */
i = cflag & CBAUD;
info->baud = baud_table[i];
uart_speed();
start_rx();
tx_start(info->uart, info->use_ints);
return;
}
//////////////////////
// tx_send_packet: transmit a data packet
//
// length: length of raw packet including header
// pkt: pointer to packet
//
void tx_send_pkt(pkt_t *pkt, uint8_t length) {
log_packet('T', pkt, length);
led_on();
set_tx_packet_length(length);
tx_send_payload(0x80 + REG_FIFO, length, (uint8_t *)pkt); // Clock out payload
// Set TXON bit to start the tx cycle
tx_start();
led_off(); led_on(); // toggle to note time to here
tx_packet_count++;
// wait for the packet transmission to complete
// per p.81 TXON is "Automatically cleared in FIFO mode once the packet is sent"
// we spin for about 10ms here...
while (!rf_interrupt()) {;}
rf_read_status();
// TODO: consider a better place to restore
// this one wastes time going back into rx mode during long prints
set_rx_mode();
led_off();
}
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 h8_sci_device::tx_dropped_edge()
{
logerror("%s: tx_dropped_edge state=%s bit=%d\n", tag(), state_names[tx_state], tx_bit);
switch(tx_state) {
case ST_START:
tx_cb(false);
assert(tx_bit == 1);
tx_state = ST_BIT;
tx_bit = smr & SMR_CHR ? 7 : 8;
break;
case ST_BIT:
tx_parity ^= (tsr & 1);
tx_cb(tsr & 1);
tsr >>= 1;
tx_bit--;
if(!tx_bit) {
if(smr & SMR_CA) {
if(!(ssr & SSR_TDRE))
tx_start();
else {
tx_state = ST_LAST_TICK;
tx_bit = 0;
}
} else if(smr & SMR_PE) {
tx_state = ST_PARITY;
tx_bit = 1;
} else {
tx_state = ST_STOP;
tx_bit = smr & SMR_STOP ? 2 : 1;
}
}
break;
case ST_PARITY:
tx_cb(tx_parity);
assert(tx_bit == 1);
tx_state = ST_STOP;
tx_bit = smr & SMR_STOP ? 2 : 1;
break;
case ST_STOP:
tx_cb(true);
tx_bit--;
if(!tx_bit) {
if(!(ssr & SSR_TDRE))
tx_start();
else {
tx_state = ST_LAST_TICK;
tx_bit = 0;
}
}
break;
case ST_LAST_TICK:
tx_state = ST_IDLE;
tx_bit = 0;
clock_stop(CLK_TX);
tx_cb(1);
ssr |= SSR_TEND;
if(scr & SCR_TEIE)
intc->internal_interrupt(tei_int);
break;
default:
abort();
}
logerror("%s: -> state=%s bit=%d\n", tag(), state_names[tx_state], tx_bit);
}
// Syntatic sugar to start transmitting a C string
int tx_start_string(char *s){
return tx_start(s,strlen(s));
}
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();
}
static void xmit_string(struct cnxt_serial * info, char *p, int len)
{
struct uart_regs *uart = info->uart;
uart->fifo = (char)*p;
tx_start(uart, info->use_ints);
}