void __libnet_internal__serial_close(struct port *p)
{
flush_send_buffer(p);
if (p->fifo_enabled)
disable_fifo(p);
uninstall_isr(p);
}
void flush_send_buffers(struct sb_config *sb, struct connection_pair *cp)
{
register int i, cb;
lock_whole_buffer(sb);
cb = sb->current_buffer;
unlock_whole_buffer(sb);
/* flush all buffers preceding current_buffer */
if (cb > 0) {
for (i = (cb - 1); i != 0; --i)
flush_send_buffer(sb, &sb->buffers[i], cp);
flush_send_buffer(sb, &sb->buffers[0], cp);
}
/* current_buffer may have wrapped around */
lock_whole_buffer(sb);
if (sb->prev_buffer > cb) {
fprintf(stderr, "looks like buffer wrapped around. (%d, %d)", sb->prev_buffer, cb);
for (i = sb->prev_buffer; i < sb->n_buffers; ++i)
flush_send_buffer(sb, &sb->buffers[i], cp);
}
unlock_whole_buffer(sb);
/* current_buffer may be too slow to fill */
lock_whole_buffer(sb);
if(sb->prev_buffer != cb){
sb->prev_buffer = cb;
unlock_whole_buffer(sb);
return;
}
if (sb->skips == 8) {
fprintf(stderr, "buffer %d had 8 chances to fill but did not!\n", cb);
if(flush_send_buffer(sb, &sb->buffers[cb], cp) == 0){
unlock_whole_buffer(sb);
u_sleep(0, FLUSH_TIMEOUT); /* ZZZZzzzzzz */
}else{
(sb->skips) = 0;
unlock_whole_buffer(sb);
}
} else {
++(sb->skips);
unlock_whole_buffer(sb);
}
}
int init_send(struct ir_remote *remote,struct ir_ncode *code)
{
int i, repeat=0;
if(is_grundig(remote) ||
is_goldstar(remote) || is_serial(remote) || is_bo(remote))
{
logprintf(LOG_ERR,"sorry, can't send this protocol yet");
return(0);
}
clear_send_buffer();
if(is_biphase(remote))
{
send_buffer.is_biphase=1;
}
if(repeat_remote==NULL)
{
remote->repeat_countdown=remote->min_repeat;
}
else
{
repeat = 1;
}
init_send_loop:
if(repeat && has_repeat(remote))
{
if(remote->flags&REPEAT_HEADER && has_header(remote))
{
send_header(remote);
}
send_repeat(remote);
}
else
{
if(!is_raw(remote))
{
ir_code next_code;
if(code->transmit_state == NULL)
{
next_code = code->code;
}
else
{
next_code = code->transmit_state->code;
}
send_code(remote, next_code, repeat);
if(has_toggle_mask(remote))
{
remote->toggle_mask_state++;
if(remote->toggle_mask_state==4)
{
remote->toggle_mask_state=2;
}
}
send_buffer.data=send_buffer._data;
}
else
{
if(code->signals==NULL)
{
logprintf(LOG_ERR, "no signals for raw send");
return 0;
}
if(send_buffer.wptr>0)
{
send_signals(code->signals, code->length);
}
else
{
send_buffer.data=code->signals;
send_buffer.wptr=code->length;
for(i=0; i<code->length; i++)
{
send_buffer.sum+=code->signals[i];
}
}
}
}
sync_send_buffer();
if(bad_send_buffer())
{
logprintf(LOG_ERR,"buffer too small");
return(0);
}
if(has_repeat_gap(remote) && repeat && has_repeat(remote))
{
remote->min_remaining_gap=remote->repeat_gap;
remote->max_remaining_gap=remote->repeat_gap;
}
else if(is_const(remote))
{
if(min_gap(remote)>send_buffer.sum)
{
remote->min_remaining_gap=min_gap(remote)-send_buffer.sum;
remote->max_remaining_gap=max_gap(remote)-send_buffer.sum;
}
else
{
logprintf(LOG_ERR,"too short gap: %u",remote->gap);
remote->min_remaining_gap=min_gap(remote);
remote->max_remaining_gap=max_gap(remote);
return(0);
}
}
else
{
remote->min_remaining_gap=min_gap(remote);
remote->max_remaining_gap=max_gap(remote);
}
/* update transmit state */
if(code->next != NULL)
{
if(code->transmit_state == NULL)
{
code->transmit_state = code->next;
}
else
{
code->transmit_state = code->transmit_state->next;
}
}
if((remote->repeat_countdown>0 || code->transmit_state != NULL) &&
remote->min_remaining_gap<LIRCD_EXACT_GAP_THRESHOLD)
{
if(send_buffer.data!=send_buffer._data)
{
lirc_t *signals;
int n;
LOGPRINTF(1, "unrolling raw signal optimisation");
signals=send_buffer.data;
n=send_buffer.wptr;
send_buffer.data=send_buffer._data;
send_buffer.wptr=0;
send_signals(signals, n);
}
LOGPRINTF(1, "concatenating low gap signals");
if(code->next == NULL || code->transmit_state == NULL)
{
remote->repeat_countdown--;
}
send_space(remote->min_remaining_gap);
flush_send_buffer();
send_buffer.sum=0;
repeat = 1;
goto init_send_loop;
}
LOGPRINTF(3, "transmit buffer ready");
return(1);
}
