int wait_for_xmitr(void) { int tmout = SPK_XMITR_TIMEOUT; if ((synth->alive) && (timeouts >= NUM_DISABLE_TIMEOUTS)) { pr_warn("%s: too many timeouts, deactivating speakup\n", synth->long_name); synth->alive = 0; speakup_start_ttys(); timeouts = 0; return 0; } while (spk_serial_tx_busy()) { if (--tmout == 0) { pr_warn("%s: timed out (tx busy)\n", synth->long_name); timeouts++; return 0; } udelay(1); } tmout = SPK_CTS_TIMEOUT; while (!((inb_p(speakup_info.port_tts + UART_MSR)) & UART_MSR_CTS)) { if (--tmout == 0) { timeouts++; return 0; } udelay(1); } timeouts = 0; return 1; }
static int spk_ttyio_out(struct spk_synth *in_synth, const char ch) { mutex_lock(&speakup_tty_mutex); if (in_synth->alive && speakup_tty && speakup_tty->ops->write) { int ret = speakup_tty->ops->write(speakup_tty, &ch, 1); mutex_unlock(&speakup_tty_mutex); if (ret == 0) /* No room */ return 0; if (ret < 0) { pr_warn("%s: I/O error, deactivating speakup\n", in_synth->long_name); /* No synth any more, so nobody will restart TTYs, and we thus * need to do it ourselves. Now that there is no synth we can * let application flood anyway */ in_synth->alive = 0; speakup_start_ttys(); return 0; } return 1; } mutex_unlock(&speakup_tty_mutex); return 0; }
static ssize_t softsynth_read(struct file *fp, char __user *buf, size_t count, loff_t *pos) { int chars_sent = 0; char __user *cp; char *init; char ch; int empty; unsigned long flags; DEFINE_WAIT(wait); spin_lock_irqsave(&speakup_info.spinlock, flags); while (1) { prepare_to_wait(&speakup_event, &wait, TASK_INTERRUPTIBLE); if (!synth_buffer_empty() || speakup_info.flushing) break; spin_unlock_irqrestore(&speakup_info.spinlock, flags); if (fp->f_flags & O_NONBLOCK) { finish_wait(&speakup_event, &wait); return -EAGAIN; } if (signal_pending(current)) { finish_wait(&speakup_event, &wait); return -ERESTARTSYS; } schedule(); spin_lock_irqsave(&speakup_info.spinlock, flags); } finish_wait(&speakup_event, &wait); cp = buf; init = get_initstring(); while (chars_sent < count) { if (speakup_info.flushing) { speakup_info.flushing = 0; ch = '\x18'; } else if (synth_buffer_empty()) { break; } else if (init[init_pos]) { ch = init[init_pos++]; } else { ch = synth_buffer_getc(); } spin_unlock_irqrestore(&speakup_info.spinlock, flags); if (copy_to_user(cp, &ch, 1)) return -EFAULT; spin_lock_irqsave(&speakup_info.spinlock, flags); chars_sent++; cp++; } *pos += chars_sent; empty = synth_buffer_empty(); spin_unlock_irqrestore(&speakup_info.spinlock, flags); if (empty) { speakup_start_ttys(); *pos = 0; } return chars_sent; }
static int softsynth_close(struct inode *inode, struct file *fp) { unsigned long flags; spk_lock(flags); synth_soft.alive = 0; initialized = 0; spk_unlock(flags); /* */ speakup_start_ttys(); return 0; }
static int softsynth_close(struct inode *inode, struct file *fp) { unsigned long flags; spin_lock_irqsave(&speakup_info.spinlock, flags); synth_soft.alive = 0; init_pos = 0; spin_unlock_irqrestore(&speakup_info.spinlock, flags); /* Make sure we let applications go before leaving */ speakup_start_ttys(); return 0; }
int speakup_thread(void *data) { unsigned long flags; int should_break; struct bleep our_sound; our_sound.active = 0; our_sound.freq = 0; our_sound.jiffies = 0; mutex_lock(&spk_mutex); while (1) { DEFINE_WAIT(wait); while (1) { spin_lock_irqsave(&speakup_info.spinlock, flags); our_sound = spk_unprocessed_sound; spk_unprocessed_sound.active = 0; prepare_to_wait(&speakup_event, &wait, TASK_INTERRUPTIBLE); should_break = kthread_should_stop() || our_sound.active || (synth && synth->catch_up && synth->alive && (speakup_info.flushing || !synth_buffer_empty())); spin_unlock_irqrestore(&speakup_info.spinlock, flags); if (should_break) break; mutex_unlock(&spk_mutex); schedule(); mutex_lock(&spk_mutex); } finish_wait(&speakup_event, &wait); if (kthread_should_stop()) break; if (our_sound.active) kd_mksound(our_sound.freq, our_sound.jiffies); if (synth && synth->catch_up && synth->alive) { /* It is up to the callee to take the lock, so that it * can sleep whenever it likes */ synth->catch_up(synth); } speakup_start_ttys(); } mutex_unlock(&spk_mutex); return 0; }
static int check_tty(struct tty_struct *tty) { if (!tty) { pr_warn("%s: I/O error, deactivating speakup\n", spk_ttyio_synth->long_name); /* No synth any more, so nobody will restart TTYs, and we thus * need to do it ourselves. Now that there is no synth we can * let application flood anyway */ spk_ttyio_synth->alive = 0; speakup_start_ttys(); return 1; } return 0; }
int spk_wait_for_xmitr(void) { int tmout = SPK_XMITR_TIMEOUT; if ((synth->alive) && (timeouts >= NUM_DISABLE_TIMEOUTS)) { pr_warn("%s: too many timeouts, deactivating speakup\n", synth->long_name); synth->alive = 0; /* No synth any more, so nobody will restart TTYs, and we thus * need to do it ourselves. Now that there is no synth we can * let application flood anyway */ speakup_start_ttys(); timeouts = 0; return 0; } while (spk_serial_tx_busy()) { if (--tmout == 0) { pr_warn("%s: timed out (tx busy)\n", synth->long_name); timeouts++; return 0; } udelay(1); } tmout = SPK_CTS_TIMEOUT; while (!((inb_p(speakup_info.port_tts + UART_MSR)) & UART_MSR_CTS)) { /* CTS */ if (--tmout == 0) { /* pr_warn("%s: timed out (cts)\n", * synth->long_name); */ timeouts++; return 0; } udelay(1); } timeouts = 0; return 1; }