if (!E100_RTS_GET(info) &&
CIRC_SPACE(info->recv.head, info->recv.tail, SERIAL_RECV_SIZE) < TTY_THROTTLE_LIMIT)
- info->tty->driver.throttle(info->tty);
+ info->tty->driver->throttle(info->tty);
START_FLUSH_FAST_TIMER(info, "receive_chars");
/* unthrottle if we have throttled */
if (E100_RTS_GET(info) &&
CIRC_SPACE(info->recv.head, info->recv.tail, SERIAL_RECV_SIZE) > TTY_THROTTLE_LIMIT)
- tty->driver.unthrottle(info->tty);
+ tty->driver->unthrottle(info->tty);
}
static _INLINE_ void
#endif
shutdown(info);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
tty->closing = 0;
* If this is a callout device, then just make sure the normal
* device isn't being used.
*/
- if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
+ if (tty->driver->subtype == SERIAL_TYPE_CALLOUT) {
if (info->flags & ASYNC_NORMAL_ACTIVE)
return -EBUSY;
if ((info->flags & ASYNC_CALLOUT_ACTIVE) &&
/* find which port we want to open */
- line = MINOR(tty->device) - tty->driver.minor_start;
+ line = MINOR(tty->device) - tty->driver->minor_start;
if (line < 0 || line >= NR_PORTS)
return -ENODEV;
#ifdef SERIAL_DEBUG_OPEN
printk("[%d] rs_open %s%d, count = %d\n", current->pid,
- tty->driver.name, info->line,
+ tty->driver->name, info->line,
info->count);
#endif
}
if ((info->count == 1) && (info->flags & ASYNC_SPLIT_TERMIOS)) {
- if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
+ if (tty->driver->subtype == SERIAL_TYPE_NORMAL)
*tty->termios = info->normal_termios;
else
*tty->termios = info->callout_termios;
* the line discipline to only process XON/XOFF characters.
*/
shutdown(info);
- if (tty->driver.flush_buffer) tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer) tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer) tty->ldisc.flush_buffer(tty);
info->event = 0;
info->tty = 0;
unsigned long page;
MOD_INC_USE_COUNT;
- line = minor(tty->device) - tty->driver.minor_start;
+ line = minor(tty->device) - tty->driver->minor_start;
if ((line < 0) || (line >= NR_PORTS)) {
MOD_DEC_USE_COUNT;
return -ENODEV;
info->tty = tty;
#ifdef SIMSERIAL_DEBUG
- printk("rs_open %s%d, count = %d\n", tty->driver.name, info->line,
+ printk("rs_open %s%d, count = %d\n", tty->driver->name, info->line,
info->state->count);
#endif
info->tty->low_latency = (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
if ((info->state->count == 1) &&
(info->flags & ASYNC_SPLIT_TERMIOS)) {
- if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
+ if (tty->driver->subtype == SERIAL_TYPE_NORMAL)
*tty->termios = info->state->normal_termios;
else
*tty->termios = info->state->callout_termios;
rs_wait_until_sent(tty, info->timeout);
}
shutdown(info);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
tty->closing = 0;
* If this is a callout device, then just make sure the normal
* device isn't being used.
*/
- if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
+ if (tty->driver->subtype == SERIAL_TYPE_CALLOUT) {
if (info->flags & ASYNC_NORMAL_ACTIVE)
return -EBUSY;
if ((info->flags & ASYNC_CALLOUT_ACTIVE) &&
unsigned long page;
MOD_INC_USE_COUNT;
- line = MINOR(tty->device) - tty->driver.minor_start;
+ line = MINOR(tty->device) - tty->driver->minor_start;
if ((line < 0) || (line >= NR_PORTS)) {
MOD_DEC_USE_COUNT;
return -ENODEV;
}
#ifdef SERIAL_DEBUG_OPEN
- printk("rs_open %s%d, count = %d\n", tty->driver.name, info->line,
+ printk("rs_open %s%d, count = %d\n", tty->driver->name, info->line,
info->state->count);
#endif
info->tty->low_latency = (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
if ((info->state->count == 1) &&
(info->flags & ASYNC_SPLIT_TERMIOS)) {
- if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
+ if (tty->driver->subtype == SERIAL_TYPE_NORMAL)
*tty->termios = info->state->normal_termios;
else
*tty->termios = info->state->callout_termios;
rs_wait_until_sent(tty, info->timeout);
}
shutdown(info);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
tty->closing = 0;
* If this is a callout device, then just make sure the normal
* device isn't being used.
*/
- if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
+ if (tty->driver->subtype == SERIAL_TYPE_CALLOUT) {
if (info->flags & ASYNC_NORMAL_ACTIVE)
return -EBUSY;
if ((info->flags & ASYNC_CALLOUT_ACTIVE) &&
unsigned long page;
MOD_INC_USE_COUNT;
- line = MINOR(tty->device) - tty->driver.minor_start;
+ line = MINOR(tty->device) - tty->driver->minor_start;
if ((line < 0) || (line >= NR_PORTS)) {
MOD_DEC_USE_COUNT;
return -ENODEV;
#ifdef SERIAL_DEBUG_OPEN
baget_printk("rs_open %s%d, count = %d\n",
- tty->driver.name, info->line,
+ tty->driver->name, info->line,
info->state->count);
#endif
info->tty->low_latency = (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
if ((info->state->count == 1) &&
(info->flags & ASYNC_SPLIT_TERMIOS)) {
- if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
+ if (tty->driver->subtype == SERIAL_TYPE_NORMAL)
*tty->termios = info->state->normal_termios;
else
*tty->termios = info->state->callout_termios;
static struct tty_struct *get_real_tty(struct tty_struct *tp)
{
- if (tp->driver.type == TTY_DRIVER_TYPE_PTY &&
- tp->driver.subtype == PTY_TYPE_MASTER)
+ if (tp->driver->type == TTY_DRIVER_TYPE_PTY &&
+ tp->driver->subtype == PTY_TYPE_MASTER)
return tp->link;
else
return tp;
if (tty_paranoia_check(tty, inode->i_rdev, "tty_ioctl"))
return -EINVAL;
- if (tty->driver.ioctl != vt_ioctl)
+ if (tty->driver->ioctl != vt_ioctl)
return -EINVAL;
/*
#if DEBUG
printk("siccuart_flush_buffer(%d) called\n",
- MINOR(tty->device) - tty->driver.minor_start);
+ MINOR(tty->device) - tty->driver->minor_start);
#endif
save_flags(flags); cli();
info->xmit.head = info->xmit.tail = 0;
state->count = 1;
}
if (--state->count < 0) {
- printk("rs_close: bad serial port count for %s%d: %d\n", tty->driver.name, info->state->line, state->count);
+ printk("rs_close: bad serial port count for %s%d: %d\n", tty->driver->name, info->state->line, state->count);
state->count = 0;
}
if (state->count) {
siccuart_wait_until_sent(tty, info->timeout);
}
siccuart_shutdown(info);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
tty->closing = 0;
expire = jiffies + timeout;
#if DEBUG
printk("siccuart_wait_until_sent(%d), jiff=%lu, expire=%lu char_time=%lu...\n",
- MINOR(tty->device) - tty->driver.minor_start, jiffies,
+ MINOR(tty->device) - tty->driver->minor_start, jiffies,
expire, char_time);
#endif
while ((readb(info->port->uart_base + BL_SICC_LSR) & _LSR_TX_ALL) != _LSR_TX_ALL) {
* If this is a callout device, then just make sure the normal
* device isn't being used.
*/
- if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
+ if (tty->driver->subtype == SERIAL_TYPE_CALLOUT) {
if (info->flags & ASYNC_NORMAL_ACTIVE)
return -EBUSY;
if ((info->flags & ASYNC_CALLOUT_ACTIVE) &&
static int siccuart_open(struct tty_struct *tty, struct file *filp)
{
struct SICC_info *info;
- int retval, line = MINOR(tty->device) - tty->driver.minor_start;
+ int retval, line = MINOR(tty->device) - tty->driver->minor_start;
// is this a line that we've got?
if ((info->state->count == 1) &&
(info->flags & ASYNC_SPLIT_TERMIOS)) {
- if (tty->driver.subtype == SERIAL_TYPE_NORMAL) {
+ if (tty->driver->subtype == SERIAL_TYPE_NORMAL) {
*tty->termios = info->state->normal_termios;
}
else {
rs_8xx_wait_until_sent(tty, info->timeout);
}
shutdown(info);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
tty->closing = 0;
* If this is a callout device, then just make sure the normal
* device isn't being used.
*/
- if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
+ if (tty->driver->subtype == SERIAL_TYPE_CALLOUT) {
if (info->flags & ASYNC_NORMAL_ACTIVE)
return -EBUSY;
if ((info->flags & ASYNC_CALLOUT_ACTIVE) &&
ser_info_t *info;
int retval, line;
- line = minor(tty->device) - tty->driver.minor_start;
+ line = minor(tty->device) - tty->driver->minor_start;
if ((line < 0) || (line >= NR_PORTS))
return -ENODEV;
retval = get_async_struct(line, &info);
return -ENODEV;
#ifdef SERIAL_DEBUG_OPEN
- printk("rs_open %s%d, count = %d\n", tty->driver.name, info->line,
+ printk("rs_open %s%d, count = %d\n", tty->driver->name, info->line,
info->state->count);
#endif
tty->driver_data = info;
if ((info->state->count == 1) &&
(info->flags & ASYNC_SPLIT_TERMIOS)) {
- if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
+ if (tty->driver->subtype == SERIAL_TYPE_NORMAL)
*tty->termios = info->state->normal_termios;
else
*tty->termios = info->state->callout_termios;
rs_8xx_wait_until_sent(tty, info->timeout);
}
shutdown(info);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
tty->closing = 0;
* If this is a callout device, then just make sure the normal
* device isn't being used.
*/
- if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
+ if (tty->driver->subtype == SERIAL_TYPE_CALLOUT) {
if (info->flags & ASYNC_NORMAL_ACTIVE)
return -EBUSY;
if ((info->flags & ASYNC_CALLOUT_ACTIVE) &&
ser_info_t *info;
int retval, line;
- line = MINOR(tty->device) - tty->driver.minor_start;
+ line = MINOR(tty->device) - tty->driver->minor_start;
if ((line < 0) || (line >= NR_PORTS))
return -ENODEV;
retval = get_async_struct(line, &info);
return -ENODEV;
#ifdef SERIAL_DEBUG_OPEN
- printk("rs_open %s%d, count = %d\n", tty->driver.name, info->line,
+ printk("rs_open %s%d, count = %d\n", tty->driver->name, info->line,
info->state->count);
#endif
tty->driver_data = info;
if ((info->state->count == 1) &&
(info->flags & ASYNC_SPLIT_TERMIOS)) {
- if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
+ if (tty->driver->subtype == SERIAL_TYPE_NORMAL)
*tty->termios = info->state->normal_termios;
else
*tty->termios = info->state->callout_termios;
if (tty_paranoia_check(tty, inode->i_rdev, "tty_ioctl"))
return -EINVAL;
- if (tty->driver.ioctl != vt_ioctl)
+ if (tty->driver->ioctl != vt_ioctl)
return -EINVAL;
/*
if (tty_paranoia_check(tty, inode->i_rdev, "tty_ioctl"))
return -EINVAL;
- if (tty->driver.ioctl != vt_ioctl)
+ if (tty->driver->ioctl != vt_ioctl)
return -EINVAL;
/*
buf = new;
}
- i = minor(tty->device) - tty->driver.minor_start;
+ i = minor(tty->device) - tty->driver->minor_start;
line = &lines[i];
down(&line->sem);
int n, err = 0;
if(tty == NULL) n = 0;
- else n = minor(tty->device) - tty->driver.minor_start;
+ else n = minor(tty->device) - tty->driver->minor_start;
line = &lines[n];
down(&line->sem);
int n;
if(tty == NULL) n = 0;
- else n = minor(tty->device) - tty->driver.minor_start;
+ else n = minor(tty->device) - tty->driver->minor_start;
line = &lines[n];
down(&line->sem);
if (tty_paranoia_check(tty, inode->i_rdev, "tty_ioctl"))
return -EINVAL;
- if (tty->driver.ioctl != vt_ioctl)
+ if (tty->driver->ioctl != vt_ioctl)
return -EINVAL;
/*
int len;
set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
- len = tty->driver.write(tty, 0, skb->data, skb->len);
+ len = tty->driver->write(tty, 0, skb->data, skb->len);
hdev->stat.byte_tx += len;
skb_pull(skb, len);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (test_bit(HCI_UART_PROTO_SET, &hu->flags))
hu->proto->flush(hu);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
return 0;
}
hu->hdev.stat.byte_rx += count;
spin_unlock(&hu->rx_lock);
- if (test_and_clear_bit(TTY_THROTTLED,&tty->flags) && tty->driver.unthrottle)
- tty->driver.unthrottle(tty);
+ if (test_and_clear_bit(TTY_THROTTLED,&tty->flags) && tty->driver->unthrottle)
+ tty->driver->unthrottle(tty);
}
static int hci_uart_register_dev(struct hci_uart *hu)
rs_wait_until_sent(tty, info->timeout);
}
shutdown(info);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
tty->closing = 0;
* If this is a callout device, then just make sure the normal
* device isn't being used.
*/
- if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
+ if (tty->driver->subtype == SERIAL_TYPE_CALLOUT) {
if (info->flags & ASYNC_NORMAL_ACTIVE)
return -EBUSY;
if ((info->flags & ASYNC_CALLOUT_ACTIVE) &&
unsigned long page;
MOD_INC_USE_COUNT;
- line = minor(tty->device) - tty->driver.minor_start;
+ line = minor(tty->device) - tty->driver->minor_start;
if ((line < 0) || (line >= NR_PORTS)) {
MOD_DEC_USE_COUNT;
return -ENODEV;
return -ENODEV;
#ifdef SERIAL_DEBUG_OPEN
- printk("rs_open %s%d, count = %d\n", tty->driver.name, info->line,
+ printk("rs_open %s%d, count = %d\n", tty->driver->name, info->line,
info->state->count);
#endif
info->tty->low_latency = (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
if ((info->state->count == 1) &&
(info->flags & ASYNC_SPLIT_TERMIOS)) {
- if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
+ if (tty->driver->subtype == SERIAL_TYPE_NORMAL)
*tty->termios = info->state->normal_termios;
else
*tty->termios = info->state->callout_termios;
* If this is a callout device, then just make sure the normal
* device isn't being used.
*/
- if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
+ if (tty->driver->subtype == SERIAL_TYPE_CALLOUT) {
if (info->flags & ASYNC_NORMAL_ACTIVE){
return -EBUSY;
}
unsigned long page;
MOD_INC_USE_COUNT;
- line = minor(tty->device) - tty->driver.minor_start;
+ line = minor(tty->device) - tty->driver->minor_start;
if ((line < 0) || (NR_PORTS <= line)){
MOD_DEC_USE_COUNT;
return -ENODEV;
}
if ((info->count == 1) && (info->flags & ASYNC_SPLIT_TERMIOS)) {
- if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
+ if (tty->driver->subtype == SERIAL_TYPE_NORMAL)
*tty->termios = info->normal_termios;
else
*tty->termios = info->callout_termios;
CY_UNLOCK(info, flags);
shutdown(info);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
CY_LOCK(info, flags);
*/
shutdown(info);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer (tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer (tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer (tty);
tty->closing = 0;
* If this is a callout device, then just make sure the normal
* device isn't being used.
*/
- if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
+ if (tty->driver->subtype == SERIAL_TYPE_CALLOUT) {
if (info->flags & DZ_NORMAL_ACTIVE)
return -EBUSY;
struct dz_serial *info;
int retval, line;
- line = minor(tty->device) - tty->driver.minor_start;
+ line = minor(tty->device) - tty->driver->minor_start;
/*
* The dz lines for the mouse/keyboard must be opened using their
return retval;
if ((info->count == 1) && (info->flags & DZ_SPLIT_TERMIOS)) {
- if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
+ if (tty->driver->subtype == SERIAL_TYPE_NORMAL)
*tty->termios = info->normal_termios;
else
*tty->termios = info->callout_termios;
struct channel *ch;
unsigned long flags;
- if (tty->driver.subtype == SERIAL_TYPE_INFO)
+ if (tty->driver->subtype == SERIAL_TYPE_INFO)
{
return;
}
tty_wait_until_sent(tty, 3000); /* 30 seconds timeout */
}
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
save_flags(flags);
cli();
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
/* Stop users from hurting themselves on control minor */
- if (tty->driver.subtype == SERIAL_TYPE_INFO)
+ if (tty->driver->subtype == SERIAL_TYPE_INFO)
{
return (0) ;
}
device isn't being used.
-------------------------------------------------------------------- */
- if (tty->driver.subtype == SERIAL_TYPE_CALLOUT)
+ if (tty->driver->subtype == SERIAL_TYPE_CALLOUT)
{ /* A cud device has been opened */
if (ch->asyncflags & ASYNC_NORMAL_ACTIVE)
return -EBUSY;
/* Nothing "real" happens in open of control device */
- if (tty->driver.subtype == SERIAL_TYPE_INFO)
+ if (tty->driver->subtype == SERIAL_TYPE_INFO)
{
return (0) ;
}
- line = minor(tty->device) - tty->driver.minor_start;
+ line = minor(tty->device) - tty->driver->minor_start;
if (line < 0 || line >= nbdevs)
{
printk(KERN_ERR "<Error> - pc_open : line out of range in pc_open\n");
/* Should this be here except for SPLIT termios ? */
if (ch->count == 1)
{
- if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
+ if (tty->driver->subtype == SERIAL_TYPE_NORMAL)
*tty->termios = ch->normal_termios;
else
*tty->termios = ch->callout_termios;
the driver will wait on carrier detect.
------------------------------------------------------------------- */
- if ((ts->c_cflag & CLOCAL) || (tty->driver.subtype == SERIAL_TYPE_CALLOUT))
+ if ((ts->c_cflag & CLOCAL) || (tty->driver->subtype == SERIAL_TYPE_CALLOUT))
{ /* Begin it is a cud device or a ttyD device with CLOCAL on */
ch->asyncflags &= ~ASYNC_CHECK_CD;
} /* End it is a cud device or a ttyD device with CLOCAL on */
struct channel *ch = (struct channel *) tty->driver_data;
/* The control device has it's own set of commands */
- if (tty->driver.subtype == SERIAL_TYPE_INFO)
+ if (tty->driver->subtype == SERIAL_TYPE_INFO)
{ /* Begin if subtype is the control device */
switch (cmd)
rs_wait_until_sent(tty, info->timeout);
}
shutdown(info);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
tty->closing = 0;
* If this is a callout device, then just make sure the normal
* device isn't being used.
*/
- if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
+ if (tty->driver->subtype == SERIAL_TYPE_CALLOUT) {
if (info->flags & ASYNC_NORMAL_ACTIVE)
return -EBUSY;
if ((info->flags & ASYNC_CALLOUT_ACTIVE) &&
struct esp_struct *info;
int retval, line;
- line = minor(tty->device) - tty->driver.minor_start;
+ line = minor(tty->device) - tty->driver->minor_start;
if ((line < 0) || (line >= NR_PORTS))
return -ENODEV;
}
#ifdef SERIAL_DEBUG_OPEN
- printk("esp_open %s%d, count = %d\n", tty->driver.name, info->line,
+ printk("esp_open %s%d, count = %d\n", tty->driver->name, info->line,
info->count);
#endif
MOD_INC_USE_COUNT;
}
if ((info->count == 1) && (info->flags & ASYNC_SPLIT_TERMIOS)) {
- if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
+ if (tty->driver->subtype == SERIAL_TYPE_NORMAL)
*tty->termios = info->normal_termios;
else
*tty->termios = info->callout_termios;
* If this is a callout device, then just make sure the normal
* device isn't being used.
*/
- if (tty->driver.subtype == GS_TYPE_CALLOUT) {
+ if (tty->driver->subtype == GS_TYPE_CALLOUT) {
if (port->flags & ASYNC_NORMAL_ACTIVE)
return -EBUSY;
if ((port->flags & ASYNC_CALLOUT_ACTIVE) &&
port->flags &= ~GS_ACTIVE;
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
tty->closing = 0;
static int hvc_open(struct tty_struct *tty, struct file * filp)
{
- int line = minor(tty->device) - tty->driver.minor_start;
+ int line = minor(tty->device) - tty->driver->minor_start;
struct hvc_struct *hp;
unsigned long flags;
* (These are the only tests the standard serial driver makes for
* callout devices.)
*/
- if ( tty->driver.subtype == SERIAL_TYPE_CALLOUT ) {
+ if ( tty->driver->subtype == SERIAL_TYPE_CALLOUT ) {
if ( pCh->flags & ASYNC_NORMAL_ACTIVE ) {
return -EBUSY;
}
if ( tty->count == 1 ) {
i2QueueCommands(PTYPE_INLINE, pCh, 0, 2, CMD_CTSFL_DSAB, CMD_RTSFL_DSAB);
if ( pCh->flags & ASYNC_SPLIT_TERMIOS ) {
- if ( tty->driver.subtype == SERIAL_TYPE_NORMAL ) {
+ if ( tty->driver->subtype == SERIAL_TYPE_NORMAL ) {
*tty->termios = pCh->NormalTermios;
} else {
*tty->termios = pCh->CalloutTermios;
serviceOutgoingFifo ( pCh->pMyBord );
- if ( tty->driver.flush_buffer )
- tty->driver.flush_buffer(tty);
+ if ( tty->driver->flush_buffer )
+ tty->driver->flush_buffer(tty);
if ( tty->ldisc.flush_buffer )
tty->ldisc.flush_buffer(tty);
tty->closing = 0;
/* trying to open a callout device... check for constraints */
- if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
+ if (tty->driver->subtype == SERIAL_TYPE_CALLOUT) {
#ifdef ISICOM_DEBUG
printk(KERN_DEBUG "ISICOM: bl_ti_rdy: callout open.\n");
#endif
#ifdef ISICOM_DEBUG
printk(KERN_DEBUG "ISICOM: open start!!!.\n");
#endif
- line = minor(tty->device) - tty->driver.minor_start;
+ line = minor(tty->device) - tty->driver->minor_start;
#ifdef ISICOM_DEBUG
printk(KERN_DEBUG "line = %d.\n", line);
return error;
if ((port->count == 1) && (port->flags & ASYNC_SPLIT_TERMIOS)) {
- if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
+ if (tty->driver->subtype == SERIAL_TYPE_NORMAL)
*tty->termios = port->normal_termios;
else
*tty->termios = port->callout_termios;
outw(card->port_status, card->base + 0x02);
}
isicom_shutdown_port(port);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
tty->closing = 0;
* previous opens still in effect. If we are a normal serial device
* then also we might have to wait for carrier.
*/
- if (tty->driver.subtype == STL_DRVTYPCALLOUT) {
+ if (tty->driver->subtype == STL_DRVTYPCALLOUT) {
if (portp->flags & ASYNC_NORMAL_ACTIVE)
return(-EBUSY);
if (portp->flags & ASYNC_CALLOUT_ACTIVE) {
}
if ((portp->refcount == 1) && (portp->flags & ASYNC_SPLIT_TERMIOS)) {
- if (tty->driver.subtype == STL_DRVTYPSERIAL)
+ if (tty->driver->subtype == STL_DRVTYPSERIAL)
*tty->termios = portp->normaltermios;
else
*tty->termios = portp->callouttermios;
clear_bit(keycode, key_down);
if (rep && (!vc_kbd_mode(kbd, VC_REPEAT) || (tty &&
- (!L_ECHO(tty) && tty->driver.chars_in_buffer(tty))))) {
+ (!L_ECHO(tty) && tty->driver->chars_in_buffer(tty))))) {
/*
* Don't repeat a key if the input buffers are not empty and the
* characters get aren't echoed locally. This makes key repeat
#define WAKEUP_CHARS 256
-#define PORTNO(x) (minor((x)->device) - (x)->driver.minor_start)
+#define PORTNO(x) (minor((x)->device) - (x)->driver->minor_start)
static int verbose = 0;
static int ttymajor = MOXAMAJOR;
tty->driver_data = ch;
ch->tty = tty;
if (ch->count == 1 && (ch->asyncflags & ASYNC_SPLIT_TERMIOS)) {
- if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
+ if (tty->driver->subtype == SERIAL_TYPE_NORMAL)
*tty->termios = ch->normal_termios;
else
*tty->termios = ch->callout_termios;
shut_down(ch);
MoxaPortFlushData(port, 2);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
tty->closing = 0;
* If this is a callout device, then just make sure the normal
* device isn't being used.
*/
- if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
+ if (tty->driver->subtype == SERIAL_TYPE_CALLOUT) {
if (ch->asyncflags & ASYNC_NORMAL_ACTIVE)
return (-EBUSY);
if ((ch->asyncflags & ASYNC_CALLOUT_ACTIVE) &&
#define UART_MCR_AFE 0x20
#define UART_LSR_SPECIAL 0x1E
-#define PORTNO(x) (minor((x)->device) - (x)->driver.minor_start)
+#define PORTNO(x) (minor((x)->device) - (x)->driver->minor_start)
#define RELEVANT_IFLAG(iflag) (iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
return (retval);
if ((info->count == 1) && (info->flags & ASYNC_SPLIT_TERMIOS)) {
- if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
+ if (tty->driver->subtype == SERIAL_TYPE_NORMAL)
*tty->termios = info->normal_termios;
else
*tty->termios = info->callout_termios;
}
}
mxser_shutdown(info);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
tty->closing = 0;
* If this is a callout device, then just make sure the normal
* device isn't being used.
*/
- if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
+ if (tty->driver->subtype == SERIAL_TYPE_CALLOUT) {
if (info->flags & ASYNC_NORMAL_ACTIVE)
return (-EBUSY);
if ((info->flags & ASYNC_CALLOUT_ACTIVE) &&
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer (tty);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer (tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer (tty);
if (debuglevel >= DEBUG_LEVEL_INFO)
printk("%s(%d)n_hdlc_tty_open() success\n",__FILE__,__LINE__);
/* Send the next block of data to device */
tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
- actual = tty->driver.write(tty, 0, tbuf->buf, tbuf->count);
+ actual = tty->driver->write(tty, 0, tbuf->buf, tbuf->count);
/* if transmit error, throw frame away by */
/* pretending it was accepted by driver */
case TIOCOUTQ:
/* get the pending tx byte count in the driver */
- count = tty->driver.chars_in_buffer ?
- tty->driver.chars_in_buffer(tty) : 0;
+ count = tty->driver->chars_in_buffer ?
+ tty->driver->chars_in_buffer(tty) : 0;
/* add size of next output frame in queue */
spin_lock_irqsave(&n_hdlc->tx_buf_list.spinlock,flags);
if (n_hdlc->tx_buf_list.head)
if(tty==NULL)
return;
- if(tty->driver.put_char)
+ if(tty->driver->put_char)
{
- tty->driver.put_char(tty, ch);
+ tty->driver->put_char(tty, ch);
}
pInfo->bcc ^= ch;
}
if(tty==NULL)
return;
- if(tty->driver.flush_chars)
+ if(tty->driver->flush_chars)
{
- tty->driver.flush_chars(tty);
+ tty->driver->flush_chars(tty);
}
}
return;
}
- if(tty->driver.write_room)
- room=tty->driver.write_room(tty);
+ if(tty->driver->write_room)
+ room=tty->driver->write_room(tty);
TRACE_PS("transmit_block %x, room %d, length %d",
(int)pBlock, room, pBlock->length);
{
if (tty->count &&
test_and_clear_bit(TTY_THROTTLED, &tty->flags) &&
- tty->driver.unthrottle)
- tty->driver.unthrottle(tty);
+ tty->driver->unthrottle)
+ tty->driver->unthrottle(tty);
}
/*
{
int space, spaces;
- space = tty->driver.write_room(tty);
+ space = tty->driver->write_room(tty);
if (!space)
return -1;
if (O_ONLCR(tty)) {
if (space < 2)
return -1;
- tty->driver.put_char(tty, '\r');
+ tty->driver->put_char(tty, '\r');
tty->column = 0;
}
tty->canon_column = tty->column;
if (space < spaces)
return -1;
tty->column += spaces;
- tty->driver.write(tty, 0, " ", spaces);
+ tty->driver->write(tty, 0, " ", spaces);
return 0;
}
tty->column += spaces;
break;
}
}
- tty->driver.put_char(tty, c);
+ tty->driver->put_char(tty, c);
return 0;
}
int i;
char *cp;
- space = tty->driver.write_room(tty);
+ space = tty->driver->write_room(tty);
if (!space)
return 0;
if (nr > space)
}
}
break_out:
- if (tty->driver.flush_chars)
- tty->driver.flush_chars(tty);
- i = tty->driver.write(tty, 0, buf, i);
+ if (tty->driver->flush_chars)
+ tty->driver->flush_chars(tty);
+ i = tty->driver->write(tty, 0, buf, i);
return i;
}
static inline void put_char(unsigned char c, struct tty_struct *tty)
{
- tty->driver.put_char(tty, c);
+ tty->driver->put_char(tty, c);
}
/* Must be called only when L_ECHO(tty) is true. */
kill_pg(tty->pgrp, sig, 1);
if (flush || !L_NOFLSH(tty)) {
n_tty_flush_buffer(tty);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
}
}
break;
}
}
- if (tty->driver.flush_chars)
- tty->driver.flush_chars(tty);
+ if (tty->driver->flush_chars)
+ tty->driver->flush_chars(tty);
}
if (!tty->icanon && (tty->read_cnt >= tty->minimum_to_wake)) {
if (n_tty_receive_room(tty) < TTY_THRESHOLD_THROTTLE) {
/* check TTY_THROTTLED first so it indicates our state */
if (!test_and_set_bit(TTY_THROTTLED, &tty->flags) &&
- tty->driver.throttle)
- tty->driver.throttle(tty);
+ tty->driver->throttle)
+ tty->driver->throttle(tty);
}
}
tty->raw = 1;
if ((I_IGNBRK(tty) || (!I_BRKINT(tty) && !I_PARMRK(tty))) &&
(I_IGNPAR(tty) || !I_INPCK(tty)) &&
- (tty->driver.flags & TTY_DRIVER_REAL_RAW))
+ (tty->driver->flags & TTY_DRIVER_REAL_RAW))
tty->real_raw = 1;
else
tty->real_raw = 0;
break;
b++; nr--;
}
- if (tty->driver.flush_chars)
- tty->driver.flush_chars(tty);
+ if (tty->driver->flush_chars)
+ tty->driver->flush_chars(tty);
} else {
- c = tty->driver.write(tty, 1, b, nr);
+ c = tty->driver->write(tty, 1, b, nr);
if (c < 0) {
retval = c;
goto break_out;
else
tty->minimum_to_wake = 1;
}
- if (tty->driver.chars_in_buffer(tty) < WAKEUP_CHARS)
+ if (tty->driver->chars_in_buffer(tty) < WAKEUP_CHARS)
mask |= POLLOUT | POLLWRNORM;
return mask;
}
if (debug_level >= DEBUG_LEVEL_INFO)
printk("%s(%d):mgslpc_set_termios %s\n", __FILE__,__LINE__,
- tty->driver.name );
+ tty->driver->name );
/* just return if nothing has changed */
if ((tty->termios->c_cflag == old_termios->c_cflag)
if (info->flags & ASYNC_INITIALIZED)
mgslpc_wait_until_sent(tty, info->timeout);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
cleanup:
if (debug_level >= DEBUG_LEVEL_INFO)
printk("%s(%d):mgslpc_close(%s) exit, count=%d\n", __FILE__,__LINE__,
- tty->driver.name, info->count);
+ tty->driver->name, info->count);
}
/* Wait until the transmitter is empty.
if (debug_level >= DEBUG_LEVEL_INFO)
printk("%s(%d):block_til_ready on %s\n",
- __FILE__,__LINE__, tty->driver.name );
+ __FILE__,__LINE__, tty->driver->name );
- if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
+ if (tty->driver->subtype == SERIAL_TYPE_CALLOUT) {
/* this is a callout device */
/* just verify that normal device is not in use */
if (info->flags & ASYNC_NORMAL_ACTIVE)
if (debug_level >= DEBUG_LEVEL_INFO)
printk("%s(%d):block_til_ready before block on %s count=%d\n",
- __FILE__,__LINE__, tty->driver.name, info->count );
+ __FILE__,__LINE__, tty->driver->name, info->count );
spin_lock_irqsave(&info->lock, flags);
if (!tty_hung_up_p(filp)) {
if (debug_level >= DEBUG_LEVEL_INFO)
printk("%s(%d):block_til_ready blocking on %s count=%d\n",
- __FILE__,__LINE__, tty->driver.name, info->count );
+ __FILE__,__LINE__, tty->driver->name, info->count );
schedule();
}
if (debug_level >= DEBUG_LEVEL_INFO)
printk("%s(%d):block_til_ready after blocking on %s count=%d\n",
- __FILE__,__LINE__, tty->driver.name, info->count );
+ __FILE__,__LINE__, tty->driver->name, info->count );
if (!retval)
info->flags |= ASYNC_NORMAL_ACTIVE;
unsigned long flags;
/* verify range of specified line number */
- line = minor(tty->device) - tty->driver.minor_start;
+ line = minor(tty->device) - tty->driver->minor_start;
if ((line < 0) || (line >= mgslpc_device_count)) {
printk("%s(%d):mgslpc_open with illegal line #%d.\n",
__FILE__,__LINE__,line);
if (debug_level >= DEBUG_LEVEL_INFO)
printk("%s(%d):mgslpc_open(%s), old ref count = %d\n",
- __FILE__,__LINE__,tty->driver.name, info->count);
+ __FILE__,__LINE__,tty->driver->name, info->count);
/* If port is closing, signal caller to try again */
if (tty_hung_up_p(filp) || info->flags & ASYNC_CLOSING){
if ((info->count == 1) &&
info->flags & ASYNC_SPLIT_TERMIOS) {
- if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
+ if (tty->driver->subtype == SERIAL_TYPE_NORMAL)
*tty->termios = info->normal_termios;
else
*tty->termios = info->callout_termios;
int boardnum;
int retval;
- line = minor(tty->device) - tty->driver.minor_start;
+ line = minor(tty->device) - tty->driver->minor_start;
if(line < 0 || line >= nbdevs) {
printk("line out of range in pcxe_open\n");
* If this is a callout device, then just make sure the normal
* device isn't being used.
*/
- if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
+ if (tty->driver->subtype == SERIAL_TYPE_CALLOUT) {
if (ch->asyncflags & ASYNC_NORMAL_ACTIVE)
return -EBUSY;
if (ch->asyncflags & ASYNC_CALLOUT_ACTIVE) {
save_flags(flags);
cli();
if((ch->count == 1) && (ch->asyncflags & ASYNC_SPLIT_TERMIOS)) {
- if(tty->driver.subtype == SERIAL_TYPE_NORMAL)
+ if(tty->driver->subtype == SERIAL_TYPE_NORMAL)
*tty->termios = ch->normal_termios;
else
*tty->termios = ch->callout_termios;
tty_wait_until_sent(tty, 3000); /* 30 seconds timeout */
}
- if(tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if(tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if(tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
shutdown(info);
{
if (!tty)
return;
- if (tty->driver.subtype == PTY_TYPE_MASTER) {
+ if (tty->driver->subtype == PTY_TYPE_MASTER) {
if (tty->count > 1)
printk("master pty_close: count = %d!!\n", tty->count);
} else {
wake_up_interruptible(&tty->link->read_wait);
wake_up_interruptible(&tty->link->write_wait);
set_bit(TTY_OTHER_CLOSED, &tty->link->flags);
- if (tty->driver.subtype == PTY_TYPE_MASTER) {
+ if (tty->driver->subtype == PTY_TYPE_MASTER) {
set_bit(TTY_OTHER_CLOSED, &tty->flags);
#ifdef CONFIG_UNIX98_PTYS
{
unsigned int major = major(tty->device) - UNIX98_PTY_MASTER_MAJOR;
if ( major < UNIX98_NR_MAJORS ) {
devpts_pty_kill( minor(tty->device)
- - tty->driver.minor_start + tty->driver.name_base );
+ - tty->driver->minor_start + tty->driver->name_base );
}
}
#endif
/* The ldisc must report 0 if no characters available to be read */
count = to->ldisc.chars_in_buffer(to);
- if (tty->driver.subtype == PTY_TYPE_SLAVE) return count;
+ if (tty->driver->subtype == PTY_TYPE_SLAVE) return count;
/* Master side driver ... if the other side's read buffer is less than
* half full, return 0 to allow writers to proceed; otherwise return
static int pty_get_device_number(struct tty_struct *tty, unsigned int *value)
{
unsigned int result = minor(tty->device)
- - tty->driver.minor_start + tty->driver.name_base;
+ - tty->driver->minor_start + tty->driver->name_base;
return put_user(result, value);
}
#endif
retval = -ENODEV;
if (!tty || !tty->link)
goto out;
- line = minor(tty->device) - tty->driver.minor_start;
+ line = minor(tty->device) - tty->driver->minor_start;
if ((line < 0) || (line >= NR_PTYS))
goto out;
- pty = (struct pty_struct *)(tty->driver.driver_state) + line;
+ pty = (struct pty_struct *)(tty->driver->driver_state) + line;
tty->driver_data = pty;
retval = -EIO;
* If this is a callout device, then just make sure the normal
* device isn't being used.
*/
- if (tty->driver.subtype == RISCOM_TYPE_CALLOUT) {
+ if (tty->driver->subtype == RISCOM_TYPE_CALLOUT) {
if (port->flags & ASYNC_NORMAL_ACTIVE)
return -EBUSY;
if ((port->flags & ASYNC_CALLOUT_ACTIVE) &&
return error;
if ((port->count == 1) && (port->flags & ASYNC_SPLIT_TERMIOS)) {
- if (tty->driver.subtype == RISCOM_TYPE_NORMAL)
+ if (tty->driver->subtype == RISCOM_TYPE_NORMAL)
*tty->termios = port->normal_termios;
else
*tty->termios = port->callout_termios;
}
}
rc_shutdown_port(bp, port);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
tty->closing = 0;
* If this is a callout device, then just make sure the normal
* device isn't being used.
*/
- if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
+ if (tty->driver->subtype == SERIAL_TYPE_CALLOUT) {
if (info->flags & ROCKET_NORMAL_ACTIVE)
return -EBUSY;
if ((info->flags & ROCKET_CALLOUT_ACTIVE) &&
CHANNEL_t *cp;
unsigned long page;
- line = minor(tty->device) - tty->driver.minor_start;
+ line = minor(tty->device) - tty->driver->minor_start;
if ((line < 0) || (line >= MAX_RP_PORTS))
return -ENODEV;
if (!tmp_buf) {
}
if ((info->count == 1) && (info->flags & ROCKET_SPLIT_TERMIOS)) {
- if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
+ if (tty->driver->subtype == SERIAL_TYPE_NORMAL)
*tty->termios = info->normal_termios;
else
*tty->termios = info->callout_termios;
if (C_HUPCL(tty)) {
sClrDTR(cp);
}
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
static char *rp_tty_name(struct tty_struct *tty, char *buf)
{
if (tty)
- sprintf(buf, "%s%d", tty->driver.name,
- minor(tty->device) - tty->driver.minor_start +
- tty->driver.name_base);
+ sprintf(buf, "%s%d", tty->driver->name,
+ minor(tty->device) - tty->driver->minor_start +
+ tty->driver->name_base);
else
strcpy(buf, "NULL tty");
return buf;
}
if ((port->gs.count == 1) && (port->gs.flags & ASYNC_SPLIT_TERMIOS)){
- if (tty->driver.subtype == A2232_TTY_SUBTYPE_NORMAL)
+ if (tty->driver->subtype == A2232_TTY_SUBTYPE_NORMAL)
*tty->termios = port->gs.normal_termios;
else
*tty->termios = port->gs.callout_termios;
if (info->flags & ASYNC_INITIALIZED)
tty_wait_until_sent(tty, 3000); /* 30 seconds timeout */
shutdown(info);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
info->event = 0;
* If this is a callout device, then just make sure the normal
* device isn't being used.
*/
- if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
+ if (tty->driver->subtype == SERIAL_TYPE_CALLOUT) {
if (info->flags & ASYNC_NORMAL_ACTIVE){
return -EBUSY;
}
int retval, line;
/* CP('O'); */
- line = minor(tty->device) - tty->driver.minor_start;
+ line = minor(tty->device) - tty->driver->minor_start;
if ((line < 0) || (NR_PORTS <= line)){
return -ENODEV;
}
}
if ((info->count == 1) && (info->flags & ASYNC_SPLIT_TERMIOS)) {
- if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
+ if (tty->driver->subtype == SERIAL_TYPE_NORMAL)
*tty->termios = info->normal_termios;
else
*tty->termios = info->callout_termios;
return -EIO;
}
- line = minor(tty->device) - tty->driver.minor_start;
+ line = minor(tty->device) - tty->driver->minor_start;
rs_dprintk (TX3912_UART_DEBUG_OPEN, "%d: opening line %d. tty=%p ctty=%p)\n",
(int) current->pid, line, tty, current->tty);
/* tty->low_latency = 1; */
if ((port->gs.count == 1) && (port->gs.flags & ASYNC_SPLIT_TERMIOS)) {
- if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
+ if (tty->driver->subtype == SERIAL_TYPE_NORMAL)
*tty->termios = port->gs.normal_termios;
else
*tty->termios = port->gs.callout_termios;
}
if ((port->gs.count == 1) && (port->gs.flags & ASYNC_SPLIT_TERMIOS)) {
- if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
+ if (tty->driver->subtype == SERIAL_TYPE_NORMAL)
*tty->termios = port->gs.normal_termios;
else
*tty->termios = port->gs.callout_termios;
* If this is a callout device, then just make sure the normal
* device isn't being used.
*/
- if (tty->driver.subtype == SPECIALIX_TYPE_CALLOUT) {
+ if (tty->driver->subtype == SPECIALIX_TYPE_CALLOUT) {
if (port->flags & ASYNC_NORMAL_ACTIVE)
return -EBUSY;
if ((port->flags & ASYNC_CALLOUT_ACTIVE) &&
return error;
if ((port->count == 1) && (port->flags & ASYNC_SPLIT_TERMIOS)) {
- if (tty->driver.subtype == SPECIALIX_TYPE_NORMAL)
+ if (tty->driver->subtype == SPECIALIX_TYPE_NORMAL)
*tty->termios = port->normal_termios;
else
*tty->termios = port->callout_termios;
}
sx_shutdown_port(bp, port);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
tty->closing = 0;
* previous opens still in effect. If we are a normal serial device
* then also we might have to wait for carrier.
*/
- if (tty->driver.subtype == STL_DRVTYPCALLOUT) {
+ if (tty->driver->subtype == STL_DRVTYPCALLOUT) {
if (portp->flags & ASYNC_NORMAL_ACTIVE)
return(-EBUSY);
if (portp->flags & ASYNC_CALLOUT_ACTIVE) {
}
if ((portp->refcount == 1) && (portp->flags & ASYNC_SPLIT_TERMIOS)) {
- if (tty->driver.subtype == STL_DRVTYPSERIAL)
+ if (tty->driver->subtype == STL_DRVTYPSERIAL)
*tty->termios = portp->normaltermios;
else
*tty->termios = portp->callouttermios;
/* tty->low_latency = 1; */
if ((port->gs.count == 1) && (port->gs.flags & ASYNC_SPLIT_TERMIOS)) {
- if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
+ if (tty->driver->subtype == SERIAL_TYPE_NORMAL)
*tty->termios = port->gs.normal_termios;
else
*tty->termios = port->gs.callout_termios;
if (debug_level >= DEBUG_LEVEL_INFO)
printk("%s(%d):mgsl_set_termios %s\n", __FILE__,__LINE__,
- tty->driver.name );
+ tty->driver->name );
/* just return if nothing has changed */
if ((tty->termios->c_cflag == old_termios->c_cflag)
if (info->flags & ASYNC_INITIALIZED)
mgsl_wait_until_sent(tty, info->timeout);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
cleanup:
if (debug_level >= DEBUG_LEVEL_INFO)
printk("%s(%d):mgsl_close(%s) exit, count=%d\n", __FILE__,__LINE__,
- tty->driver.name, info->count);
+ tty->driver->name, info->count);
} /* end of mgsl_close() */
if (debug_level >= DEBUG_LEVEL_INFO)
printk("%s(%d):block_til_ready on %s\n",
- __FILE__,__LINE__, tty->driver.name );
+ __FILE__,__LINE__, tty->driver->name );
- if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
+ if (tty->driver->subtype == SERIAL_TYPE_CALLOUT) {
/* this is a callout device */
/* just verify that normal device is not in use */
if (info->flags & ASYNC_NORMAL_ACTIVE)
if (debug_level >= DEBUG_LEVEL_INFO)
printk("%s(%d):block_til_ready before block on %s count=%d\n",
- __FILE__,__LINE__, tty->driver.name, info->count );
+ __FILE__,__LINE__, tty->driver->name, info->count );
spin_lock_irqsave(&info->irq_spinlock, flags);
if (!tty_hung_up_p(filp)) {
if (debug_level >= DEBUG_LEVEL_INFO)
printk("%s(%d):block_til_ready blocking on %s count=%d\n",
- __FILE__,__LINE__, tty->driver.name, info->count );
+ __FILE__,__LINE__, tty->driver->name, info->count );
schedule();
}
if (debug_level >= DEBUG_LEVEL_INFO)
printk("%s(%d):block_til_ready after blocking on %s count=%d\n",
- __FILE__,__LINE__, tty->driver.name, info->count );
+ __FILE__,__LINE__, tty->driver->name, info->count );
if (!retval)
info->flags |= ASYNC_NORMAL_ACTIVE;
unsigned long flags;
/* verify range of specified line number */
- line = minor(tty->device) - tty->driver.minor_start;
+ line = minor(tty->device) - tty->driver->minor_start;
if ((line < 0) || (line >= mgsl_device_count)) {
printk("%s(%d):mgsl_open with illegal line #%d.\n",
__FILE__,__LINE__,line);
if (debug_level >= DEBUG_LEVEL_INFO)
printk("%s(%d):mgsl_open(%s), old ref count = %d\n",
- __FILE__,__LINE__,tty->driver.name, info->count);
+ __FILE__,__LINE__,tty->driver->name, info->count);
/* If port is closing, signal caller to try again */
if (tty_hung_up_p(filp) || info->flags & ASYNC_CLOSING){
if ((info->count == 1) &&
info->flags & ASYNC_SPLIT_TERMIOS) {
- if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
+ if (tty->driver->subtype == SERIAL_TYPE_NORMAL)
*tty->termios = info->normal_termios;
else
*tty->termios = info->callout_termios;
int retval, line;
unsigned long flags;
- line = minor(tty->device) - tty->driver.minor_start;
+ line = minor(tty->device) - tty->driver->minor_start;
if ((line < 0) || (line >= synclinkmp_device_count)) {
printk("%s(%d): open with illegal line #%d.\n",
__FILE__,__LINE__,line);
if (debug_level >= DEBUG_LEVEL_INFO)
printk("%s(%d):%s open(), old ref count = %d\n",
- __FILE__,__LINE__,tty->driver.name, info->count);
+ __FILE__,__LINE__,tty->driver->name, info->count);
/* If port is closing, signal caller to try again */
if (tty_hung_up_p(filp) || info->flags & ASYNC_CLOSING){
if ((info->count == 1) &&
info->flags & ASYNC_SPLIT_TERMIOS) {
- if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
+ if (tty->driver->subtype == SERIAL_TYPE_NORMAL)
*tty->termios = info->normal_termios;
else
*tty->termios = info->callout_termios;
if (info->flags & ASYNC_INITIALIZED)
wait_until_sent(tty, info->timeout);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
cleanup:
if (debug_level >= DEBUG_LEVEL_INFO)
printk("%s(%d):%s close() exit, count=%d\n", __FILE__,__LINE__,
- tty->driver.name, info->count);
+ tty->driver->name, info->count);
}
/* Called by tty_hangup() when a hangup is signaled.
if (debug_level >= DEBUG_LEVEL_INFO)
printk("%s(%d):%s set_termios()\n", __FILE__,__LINE__,
- tty->driver.name );
+ tty->driver->name );
/* just return if nothing has changed */
if ((tty->termios->c_cflag == old_termios->c_cflag)
if (debug_level >= DEBUG_LEVEL_INFO)
printk("%s(%d):%s block_til_ready()\n",
- __FILE__,__LINE__, tty->driver.name );
+ __FILE__,__LINE__, tty->driver->name );
- if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
+ if (tty->driver->subtype == SERIAL_TYPE_CALLOUT) {
/* this is a callout device */
/* just verify that normal device is not in use */
if (info->flags & ASYNC_NORMAL_ACTIVE)
if (debug_level >= DEBUG_LEVEL_INFO)
printk("%s(%d):%s block_til_ready() before block, count=%d\n",
- __FILE__,__LINE__, tty->driver.name, info->count );
+ __FILE__,__LINE__, tty->driver->name, info->count );
spin_lock_irqsave(&info->lock, flags);
if (!tty_hung_up_p(filp)) {
if (debug_level >= DEBUG_LEVEL_INFO)
printk("%s(%d):%s block_til_ready() count=%d\n",
- __FILE__,__LINE__, tty->driver.name, info->count );
+ __FILE__,__LINE__, tty->driver->name, info->count );
schedule();
}
if (debug_level >= DEBUG_LEVEL_INFO)
printk("%s(%d):%s block_til_ready() after, count=%d\n",
- __FILE__,__LINE__, tty->driver.name, info->count );
+ __FILE__,__LINE__, tty->driver->name, info->count );
if (!retval)
info->flags |= ASYNC_NORMAL_ACTIVE;
static char *
_tty_make_name(struct tty_struct *tty, const char *name, char *buf)
{
- int idx = (tty)? minor(tty->device) - tty->driver.minor_start:0;
+ int idx = (tty)? minor(tty->device) - tty->driver->minor_start:0;
if (!tty) /* Hmm. NULL pointer. That's fun. */
strcpy(buf, "NULL tty");
else
sprintf(buf, name,
- idx + tty->driver.name_base);
+ idx + tty->driver->name_base);
return buf;
}
-#define TTY_NUMBER(tty) (minor((tty)->device) - (tty)->driver.minor_start + \
- (tty)->driver.name_base)
+#define TTY_NUMBER(tty) (minor((tty)->device) - (tty)->driver->minor_start + \
+ (tty)->driver->name_base)
char *tty_name(struct tty_struct *tty, char *buf)
{
- return _tty_make_name(tty, (tty)?tty->driver.name:NULL, buf);
+ return _tty_make_name(tty, (tty)?tty->driver->name:NULL, buf);
}
EXPORT_SYMBOL(tty_name);
count++;
}
file_list_unlock();
- if (tty->driver.type == TTY_DRIVER_TYPE_PTY &&
- tty->driver.subtype == PTY_TYPE_SLAVE &&
+ if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
+ tty->driver->subtype == PTY_TYPE_SLAVE &&
tty->link && tty->link->count)
count++;
if (tty->count != count) {
module_put(o_ldisc.owner);
}
- if (tty->ldisc.num != o_ldisc.num && tty->driver.set_ldisc)
- tty->driver.set_ldisc(tty);
+ if (tty->ldisc.num != o_ldisc.num && tty->driver->set_ldisc)
+ tty->driver->set_ldisc(tty);
return retval;
}
local_irq_save(flags); // FIXME: is this safe?
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
tty->ldisc.write_wakeup)
(tty->ldisc.write_wakeup)(tty);
* Shutdown the current line discipline, and reset it to
* N_TTY.
*/
- if (tty->driver.flags & TTY_DRIVER_RESET_TERMIOS)
- *tty->termios = tty->driver.init_termios;
+ if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
+ *tty->termios = tty->driver->init_termios;
if (tty->ldisc.num != ldiscs[N_TTY].num) {
if (tty->ldisc.close)
(tty->ldisc.close)(tty);
* So we just call close() the right number of times.
*/
if (cons_filp) {
- if (tty->driver.close)
+ if (tty->driver->close)
for (n = 0; n < closecount; n++)
- tty->driver.close(tty, cons_filp);
- } else if (tty->driver.hangup)
- (tty->driver.hangup)(tty);
+ tty->driver->close(tty, cons_filp);
+ } else if (tty->driver->hangup)
+ (tty->driver->hangup)(tty);
unlock_kernel();
}
tty = current->tty;
if (tty) {
tty_pgrp = tty->pgrp;
- if (on_exit && tty->driver.type != TTY_DRIVER_TYPE_PTY)
+ if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
tty_vhangup(tty);
} else {
if (current->tty_old_pgrp) {
tty->ctrl_status |= TIOCPKT_STOP;
wake_up_interruptible(&tty->link->read_wait);
}
- if (tty->driver.stop)
- (tty->driver.stop)(tty);
+ if (tty->driver->stop)
+ (tty->driver->stop)(tty);
}
void start_tty(struct tty_struct *tty)
tty->ctrl_status |= TIOCPKT_START;
wake_up_interruptible(&tty->link->read_wait);
}
- if (tty->driver.start)
- (tty->driver.start)(tty);
+ if (tty->driver->start)
+ (tty->driver->start)(tty);
if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
tty->ldisc.write_wakeup)
(tty->ldisc.write_wakeup)(tty);
tty = (struct tty_struct *)file->private_data;
if (tty_paranoia_check(tty, inode->i_rdev, "tty_write"))
return -EIO;
- if (!tty || !tty->driver.write || (test_bit(TTY_IO_ERROR, &tty->flags)))
+ if (!tty || !tty->driver->write || (test_bit(TTY_IO_ERROR, &tty->flags)))
return -EIO;
#if 0
if (!is_console && L_TOSTOP(tty) && (tty->pgrp > 0) &&
goto fail_no_mem;
initialize_tty_struct(tty);
tty->device = device;
- tty->driver = *driver;
+ tty->driver = driver;
tp_loc = &driver->termios[idx];
if (!*tp_loc) {
initialize_tty_struct(o_tty);
o_tty->device = mk_kdev(driver->other->major,
driver->other->minor_start + idx);
- o_tty->driver = *driver->other;
+ o_tty->driver = driver->other;
o_tp_loc = &driver->other->termios[idx];
if (!*o_tp_loc) {
tty->link->count++;
}
tty->count++;
- tty->driver = *driver; /* N.B. why do this every time?? */
+ tty->driver = driver; /* N.B. why do this every time?? */
success:
*ret_tty = tty;
struct termios *tp;
if ((o_tty = tty->link) != NULL) {
- o_tty->driver.table[idx] = NULL;
- if (o_tty->driver.flags & TTY_DRIVER_RESET_TERMIOS) {
- tp = o_tty->driver.termios[idx];
- o_tty->driver.termios[idx] = NULL;
+ o_tty->driver->table[idx] = NULL;
+ if (o_tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
+ tp = o_tty->driver->termios[idx];
+ o_tty->driver->termios[idx] = NULL;
kfree(tp);
}
o_tty->magic = 0;
- (*o_tty->driver.refcount)--;
+ (*o_tty->driver->refcount)--;
file_list_lock();
list_del(&o_tty->tty_files);
file_list_unlock();
free_tty_struct(o_tty);
}
- tty->driver.table[idx] = NULL;
- if (tty->driver.flags & TTY_DRIVER_RESET_TERMIOS) {
- tp = tty->driver.termios[idx];
- tty->driver.termios[idx] = NULL;
+ tty->driver->table[idx] = NULL;
+ if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
+ tp = tty->driver->termios[idx];
+ tty->driver->termios[idx] = NULL;
kfree(tp);
}
tty->magic = 0;
- (*tty->driver.refcount)--;
+ (*tty->driver->refcount)--;
file_list_lock();
list_del(&tty->tty_files);
file_list_unlock();
- module_put(tty->driver.owner);
+ module_put(tty->driver->owner);
free_tty_struct(tty);
}
tty_fasync(-1, filp, 0);
- idx = minor(tty->device) - tty->driver.minor_start;
- pty_master = (tty->driver.type == TTY_DRIVER_TYPE_PTY &&
- tty->driver.subtype == PTY_TYPE_MASTER);
+ idx = minor(tty->device) - tty->driver->minor_start;
+ pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
+ tty->driver->subtype == PTY_TYPE_MASTER);
o_tty = tty->link;
#ifdef TTY_PARANOIA_CHECK
- if (idx < 0 || idx >= tty->driver.num) {
+ if (idx < 0 || idx >= tty->driver->num) {
printk(KERN_DEBUG "release_dev: bad idx when trying to "
"free (%s)\n", cdevname(tty->device));
return;
}
- if (tty != tty->driver.table[idx]) {
+ if (tty != tty->driver->table[idx]) {
printk(KERN_DEBUG "release_dev: driver.table[%d] not tty "
"for (%s)\n", idx, cdevname(tty->device));
return;
}
- if (tty->termios != tty->driver.termios[idx]) {
+ if (tty->termios != tty->driver->termios[idx]) {
printk(KERN_DEBUG "release_dev: driver.termios[%d] not termios "
"for (%s)\n",
idx, cdevname(tty->device));
return;
}
- if (tty->termios_locked != tty->driver.termios_locked[idx]) {
+ if (tty->termios_locked != tty->driver->termios_locked[idx]) {
printk(KERN_DEBUG "release_dev: driver.termios_locked[%d] not "
"termios_locked for (%s)\n",
idx, cdevname(tty->device));
#endif
#ifdef TTY_PARANOIA_CHECK
- if (tty->driver.other) {
- if (o_tty != tty->driver.other->table[idx]) {
+ if (tty->driver->other) {
+ if (o_tty != tty->driver->other->table[idx]) {
printk(KERN_DEBUG "release_dev: other->table[%d] "
"not o_tty for (%s)\n",
idx, cdevname(tty->device));
return;
}
- if (o_tty->termios != tty->driver.other->termios[idx]) {
+ if (o_tty->termios != tty->driver->other->termios[idx]) {
printk(KERN_DEBUG "release_dev: other->termios[%d] "
"not o_termios for (%s)\n",
idx, cdevname(tty->device));
return;
}
if (o_tty->termios_locked !=
- tty->driver.other->termios_locked[idx]) {
+ tty->driver->other->termios_locked[idx]) {
printk(KERN_DEBUG "release_dev: other->termios_locked["
"%d] not o_termios_locked for (%s)\n",
idx, cdevname(tty->device));
}
#endif
- if (tty->driver.close)
- tty->driver.close(tty, filp);
+ if (tty->driver->close)
+ tty->driver->close(tty, filp);
/*
* Sanity check: if tty->count is going to zero, there shouldn't be
filp->private_data = tty;
file_move(filp, &tty->tty_files);
check_tty_count(tty, "tty_open");
- if (tty->driver.type == TTY_DRIVER_TYPE_PTY &&
- tty->driver.subtype == PTY_TYPE_MASTER)
+ if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
+ tty->driver->subtype == PTY_TYPE_MASTER)
noctty = 1;
#ifdef TTY_DEBUG_HANGUP
printk(KERN_DEBUG "opening %s...", tty_name(tty, buf));
#endif
- if (tty->driver.open)
- retval = tty->driver.open(tty, filp);
+ if (tty->driver->open)
+ retval = tty->driver->open(tty, filp);
else
retval = -ENODEV;
filp->f_flags = saved_flags;
tty->session = current->session;
tty->pgrp = current->pgrp;
}
- if ((tty->driver.type == TTY_DRIVER_TYPE_SERIAL) &&
- (tty->driver.subtype == SERIAL_TYPE_CALLOUT) &&
+ if ((tty->driver->type == TTY_DRIVER_TYPE_SERIAL) &&
+ (tty->driver->subtype == SERIAL_TYPE_CALLOUT) &&
(tty->count == 1)) {
static int nr_warns;
if (nr_warns < 5) {
if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
return 0;
#ifdef CONFIG_VT
- if (tty->driver.type == TTY_DRIVER_TYPE_CONSOLE) {
- unsigned int currcons = minor(tty->device) - tty->driver.minor_start;
+ if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
+ unsigned int currcons = minor(tty->device) - tty->driver->minor_start;
if (vc_resize(currcons, tmp_ws.ws_col, tmp_ws.ws_row))
return -ENXIO;
}
{
set_current_state(TASK_INTERRUPTIBLE);
- tty->driver.break_ctl(tty, -1);
+ tty->driver->break_ctl(tty, -1);
if (!signal_pending(current))
schedule_timeout(duration);
- tty->driver.break_ctl(tty, 0);
+ tty->driver->break_ctl(tty, 0);
if (signal_pending(current))
return -EINTR;
return 0;
{
int retval = -EINVAL;
- if (tty->driver.tiocmget) {
- retval = tty->driver.tiocmget(tty, file);
+ if (tty->driver->tiocmget) {
+ retval = tty->driver->tiocmget(tty, file);
if (retval >= 0)
retval = put_user(retval, (int *)arg);
{
int retval = -EINVAL;
- if (tty->driver.tiocmset) {
+ if (tty->driver->tiocmset) {
unsigned int set, clear, val;
retval = get_user(val, (unsigned int *)arg);
set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2;
clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2;
- retval = tty->driver.tiocmset(tty, file, set, clear);
+ retval = tty->driver->tiocmset(tty, file, set, clear);
}
return retval;
}
return -EINVAL;
real_tty = tty;
- if (tty->driver.type == TTY_DRIVER_TYPE_PTY &&
- tty->driver.subtype == PTY_TYPE_MASTER)
+ if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
+ tty->driver->subtype == PTY_TYPE_MASTER)
real_tty = tty->link;
/*
* Break handling by driver
*/
- if (!tty->driver.break_ctl) {
+ if (!tty->driver->break_ctl) {
switch(cmd) {
case TIOCSBRK:
case TIOCCBRK:
- if (tty->driver.ioctl)
- return tty->driver.ioctl(tty, file, cmd, arg);
+ if (tty->driver->ioctl)
+ return tty->driver->ioctl(tty, file, cmd, arg);
return -EINVAL;
/* These two ioctl's always return success; even if */
/* the driver doesn't support them. */
case TCSBRK:
case TCSBRKP:
- if (!tty->driver.ioctl)
+ if (!tty->driver->ioctl)
return 0;
- retval = tty->driver.ioctl(tty, file, cmd, arg);
+ retval = tty->driver->ioctl(tty, file, cmd, arg);
if (retval == -ENOIOCTLCMD)
retval = 0;
return retval;
* Break handling
*/
case TIOCSBRK: /* Turn break on, unconditionally */
- tty->driver.break_ctl(tty, -1);
+ tty->driver->break_ctl(tty, -1);
return 0;
case TIOCCBRK: /* Turn break off, unconditionally */
- tty->driver.break_ctl(tty, 0);
+ tty->driver->break_ctl(tty, 0);
return 0;
case TCSBRK: /* SVID version: non-zero arg --> no break */
/*
case TIOCMBIS:
return tty_tiocmset(tty, file, cmd, arg);
}
- if (tty->driver.ioctl) {
- int retval = (tty->driver.ioctl)(tty, file, cmd, arg);
+ if (tty->driver->ioctl) {
+ int retval = (tty->driver->ioctl)(tty, file, cmd, arg);
if (retval != -ENOIOCTLCMD)
return retval;
}
session = tty->session;
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
read_lock(&tasklist_lock);
for_each_task_pid(session, PIDTYPE_SID, p, l, pid) {
if (p->tty == tty || session > 0) {
*/
static void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
{
- tty->driver.write(tty, 0, &ch, 1);
+ tty->driver->write(tty, 0, &ch, 1);
}
#ifdef CONFIG_DEVFS_FS
printk(KERN_DEBUG "%s wait until sent...\n", tty_name(tty, buf));
#endif
- if (!tty->driver.chars_in_buffer)
+ if (!tty->driver->chars_in_buffer)
return;
add_wait_queue(&tty->write_wait, &wait);
if (!timeout)
do {
#ifdef TTY_DEBUG_WAIT_UNTIL_SENT
printk(KERN_DEBUG "waiting %s...(%d)\n", tty_name(tty, buf),
- tty->driver.chars_in_buffer(tty));
+ tty->driver->chars_in_buffer(tty));
#endif
set_current_state(TASK_INTERRUPTIBLE);
if (signal_pending(current))
goto stop_waiting;
- if (!tty->driver.chars_in_buffer(tty))
+ if (!tty->driver->chars_in_buffer(tty))
break;
timeout = schedule_timeout(timeout);
} while (timeout);
- if (tty->driver.wait_until_sent)
- tty->driver.wait_until_sent(tty, timeout);
+ if (tty->driver->wait_until_sent)
+ tty->driver->wait_until_sent(tty, timeout);
stop_waiting:
set_current_state(TASK_RUNNING);
remove_wait_queue(&tty->write_wait, &wait);
}
}
- if (tty->driver.set_termios)
- (*tty->driver.set_termios)(tty, &old_termios);
+ if (tty->driver->set_termios)
+ (*tty->driver->set_termios)(tty, &old_termios);
if (tty->ldisc.set_termios)
(*tty->ldisc.set_termios)(tty, &old_termios);
{
int was_stopped = tty->stopped;
- if (tty->driver.send_xchar) {
- tty->driver.send_xchar(tty, ch);
+ if (tty->driver->send_xchar) {
+ tty->driver->send_xchar(tty, ch);
return;
}
if (was_stopped)
start_tty(tty);
- tty->driver.write(tty, 0, &ch, 1);
+ tty->driver->write(tty, 0, &ch, 1);
if (was_stopped)
stop_tty(tty);
}
struct tty_struct * real_tty;
int retval;
- if (tty->driver.type == TTY_DRIVER_TYPE_PTY &&
- tty->driver.subtype == PTY_TYPE_MASTER)
+ if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
+ tty->driver->subtype == PTY_TYPE_MASTER)
real_tty = tty->link;
else
real_tty = tty;
tty->ldisc.flush_buffer(tty);
/* fall through */
case TCOFLUSH:
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
break;
default:
return -EINVAL;
}
return 0;
case TIOCOUTQ:
- return put_user(tty->driver.chars_in_buffer ?
- tty->driver.chars_in_buffer(tty) : 0,
+ return put_user(tty->driver->chars_in_buffer ?
+ tty->driver->chars_in_buffer(tty) : 0,
(int *) arg);
case TIOCINQ:
retval = tty->read_cnt;
{
int pktmode;
- if (tty->driver.type != TTY_DRIVER_TYPE_PTY ||
- tty->driver.subtype != PTY_TYPE_MASTER)
+ if (tty->driver->type != TTY_DRIVER_TYPE_PTY ||
+ tty->driver->subtype != PTY_TYPE_MASTER)
return -ENOTTY;
if (get_user(pktmode, (int *) arg))
return -EFAULT;
}
if ((port->gs.count == 1) && (port->gs.flags & ASYNC_SPLIT_TERMIOS)) {
- if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
+ if (tty->driver->subtype == SERIAL_TYPE_NORMAL)
*tty->termios = port->gs.normal_termios;
else
*tty->termios = port->gs.callout_termios;
int lines;
int ret;
- if (tty->driver.type != TTY_DRIVER_TYPE_CONSOLE)
+ if (tty->driver->type != TTY_DRIVER_TYPE_CONSOLE)
return -EINVAL;
if (current->tty != tty && !capable(CAP_SYS_ADMIN))
return -EPERM;
int console_num;
if (!tty)
return;
- console_num = minor(tty->device) - (tty->driver.minor_start);
+ console_num = minor(tty->device) - (tty->driver->minor_start);
if (!vc_cons_allocated(console_num))
return;
set_vc_kbd_led(kbd_table + console_num, VC_SCROLLOCK);
int console_num;
if (!tty)
return;
- console_num = minor(tty->device) - (tty->driver.minor_start);
+ console_num = minor(tty->device) - (tty->driver->minor_start);
if (!vc_cons_allocated(console_num))
return;
clr_vc_kbd_led(kbd_table + console_num, VC_SCROLLOCK);
unsigned int currcons;
int i;
- currcons = minor(tty->device) - tty->driver.minor_start;
+ currcons = minor(tty->device) - tty->driver->minor_start;
i = vc_allocate(currcons);
if (i)
if (!tty)
return;
if (tty->count != 1) return;
- vcs_make_devfs (minor(tty->device) - tty->driver.minor_start, 1);
+ vcs_make_devfs (minor(tty->device) - tty->driver->minor_start, 1);
vt = (struct vt_struct*)tty->driver_data;
if (vt)
vc_cons[vt->vc_num].d->vc_tty = NULL;
static int serport_serio_write(struct serio *serio, unsigned char data)
{
struct serport *serport = serio->driver;
- return -(serport->tty->driver.write(serport->tty, 0, &data, 1) != 1);
+ return -(serport->tty->driver->write(serport->tty, 0, &data, 1) != 1);
}
static int serport_serio_open(struct serio *serio)
* If this is a callout device, then just make sure the normal
* device isn't being used.
*/
- if (tty->driver.subtype == ISDN_SERIAL_TYPE_CALLOUT) {
+ if (tty->driver->subtype == ISDN_SERIAL_TYPE_CALLOUT) {
if (info->flags & ISDN_ASYNC_NORMAL_ACTIVE)
return -EBUSY;
if ((info->flags & ISDN_ASYNC_CALLOUT_ACTIVE) &&
MOD_INC_USE_COUNT;
- line = minor(tty->device) - tty->driver.minor_start;
+ line = minor(tty->device) - tty->driver->minor_start;
if (line < 0 || line > ISDN_MAX_CHANNELS)
return -ENODEV;
info = &isdn_mdm.info[line];
if (isdn_tty_paranoia_check(info, tty->device, "isdn_tty_open"))
return -ENODEV;
#ifdef ISDN_DEBUG_MODEM_OPEN
- printk(KERN_DEBUG "isdn_tty_open %s%d, count = %d\n", tty->driver.name,
+ printk(KERN_DEBUG "isdn_tty_open %s%d, count = %d\n", tty->driver->name,
info->line, info->count);
#endif
info->count++;
return retval;
}
if ((info->count == 1) && (info->flags & ISDN_ASYNC_SPLIT_TERMIOS)) {
- if (tty->driver.subtype == ISDN_SERIAL_TYPE_NORMAL)
+ if (tty->driver->subtype == ISDN_SERIAL_TYPE_NORMAL)
*tty->termios = info->normal_termios;
else
*tty->termios = info->callout_termios;
}
dev->modempoll--;
isdn_tty_shutdown(info);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
info->tty = 0;
specific irqs */
spin_unlock_irqrestore(&info->lock, flags);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
tty->closing = 0;
* If this is a callout device, then just make sure the normal
* device isn't being used.
*/
- if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
+ if (tty->driver->subtype == SERIAL_TYPE_CALLOUT) {
if (info->flags & ZILOG_NORMAL_ACTIVE)
return -EBUSY;
if ((info->flags & ZILOG_CALLOUT_ACTIVE) &&
unsigned long page;
MOD_INC_USE_COUNT;
- line = minor(tty->device) - tty->driver.minor_start;
+ line = minor(tty->device) - tty->driver->minor_start;
if ((line < 0) || (line >= zs_channels_found)) {
MOD_DEC_USE_COUNT;
return -ENODEV;
#endif
if (serial_paranoia_check(info, tty->device, "rs_open"))
return -ENODEV;
- OPNDBG("rs_open %s%d, count = %d, tty=%p\n", tty->driver.name,
+ OPNDBG("rs_open %s%d, count = %d, tty=%p\n", tty->driver->name,
info->line, info->count, tty);
info->count++;
}
if ((info->count == 1) && (info->flags & ZILOG_SPLIT_TERMIOS)) {
- if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
+ if (tty->driver->subtype == SERIAL_TYPE_NORMAL)
*tty->termios = info->normal_termios;
else
*tty->termios = info->callout_termios;
immediately after data has arrived. */
if (sp->duplex == 1) {
sp->led_state = 0x70;
- sp->tty->driver.write(sp->tty, 0, &sp->led_state, 1);
+ sp->tty->driver->write(sp->tty, 0, &sp->led_state, 1);
sp->tx_enable = 1;
- actual = sp->tty->driver.write(sp->tty, 0, sp->xbuff, count);
+ actual = sp->tty->driver->write(sp->tty, 0, sp->xbuff, count);
sp->xleft = count - actual;
sp->xhead = sp->xbuff + actual;
sp->led_state = 0x60;
- sp->tty->driver.write(sp->tty, 0, &sp->led_state, 1);
+ sp->tty->driver->write(sp->tty, 0, &sp->led_state, 1);
} else {
sp->xleft = count;
sp->xhead = sp->xbuff;
}
if (sp->tx_enable == 1) {
- actual = tty->driver.write(tty, 0, sp->xhead, sp->xleft);
+ actual = tty->driver->write(tty, 0, sp->xhead, sp->xleft);
sp->xleft -= actual;
sp->xhead += actual;
}
if (((sp->status1 & SIXP_DCD_MASK) == 0) && (random < sp->persistence)) {
sp->led_state = 0x70;
- sp->tty->driver.write(sp->tty, 0, &sp->led_state, 1);
+ sp->tty->driver->write(sp->tty, 0, &sp->led_state, 1);
sp->tx_enable = 1;
- actual = sp->tty->driver.write(sp->tty, 0, sp->xbuff, sp->status2);
+ actual = sp->tty->driver->write(sp->tty, 0, sp->xbuff, sp->status2);
sp->xleft -= actual;
sp->xhead += actual;
sp->led_state = 0x60;
- sp->tty->driver.write(sp->tty, 0, &sp->led_state, 1);
+ sp->tty->driver->write(sp->tty, 0, &sp->led_state, 1);
sp->status2 = 0;
} else
sp_start_tx_timer(sp);
return -ENFILE;
sp->tty = tty;
tty->disc_data = sp;
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
{
unsigned char inbyte = 0xe8;
- sp->tty->driver.write(sp->tty, 0, &inbyte, 1);
+ sp->tty->driver->write(sp->tty, 0, &inbyte, 1);
del_timer(&sp->resync_t);
sp->resync_t.data = (unsigned long) sp;
else { /* output watchdog char if idle */
if ((sp->status2 != 0) && (sp->duplex == 1)) {
sp->led_state = 0x70;
- sp->tty->driver.write(sp->tty, 0, &sp->led_state, 1);
+ sp->tty->driver->write(sp->tty, 0, &sp->led_state, 1);
sp->tx_enable = 1;
- actual = sp->tty->driver.write(sp->tty, 0, sp->xbuff, sp->status2);
+ actual = sp->tty->driver->write(sp->tty, 0, sp->xbuff, sp->status2);
sp->xleft -= actual;
sp->xhead += actual;
sp->led_state = 0x60;
}
/* needed to trigger the TNC watchdog */
- sp->tty->driver.write(sp->tty, 0, &sp->led_state, 1);
+ sp->tty->driver->write(sp->tty, 0, &sp->led_state, 1);
/* if the state byte has been received, the TNC is present,
so the resync timer can be reset. */
/* resync the TNC */
sp->led_state = 0x60;
- sp->tty->driver.write(sp->tty, 0, &sp->led_state, 1);
- sp->tty->driver.write(sp->tty, 0, &resync_cmd, 1);
+ sp->tty->driver->write(sp->tty, 0, &sp->led_state, 1);
+ sp->tty->driver->write(sp->tty, 0, &resync_cmd, 1);
/* Start resync timer again -- the TNC might be still absent */
if ((sp->status & SIXP_RX_DCD_MASK) ==
SIXP_RX_DCD_MASK) {
sp->led_state = 0x68;
- sp->tty->driver.write(sp->tty, 0, &sp->led_state, 1);
+ sp->tty->driver->write(sp->tty, 0, &sp->led_state, 1);
}
} else {
sp->led_state = 0x60;
/* fill trailing bytes with zeroes */
- sp->tty->driver.write(sp->tty, 0, &sp->led_state, 1);
+ sp->tty->driver->write(sp->tty, 0, &sp->led_state, 1);
rest = sp->rx_count;
if (rest != 0)
for (i = rest; i <= 3; i++)
break;
}
ax->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
- actual = ax->tty->driver.write(ax->tty, 0, ax->xbuff, count);
+ actual = ax->tty->driver->write(ax->tty, 0, ax->xbuff, count);
ax->tx_packets++;
ax->dev->trans_start = jiffies;
ax->xleft = count - actual;
} else {
count = kiss_esc(p, (unsigned char *) ax->mkiss->xbuff, len);
ax->mkiss->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
- actual = ax->mkiss->tty->driver.write(ax->mkiss->tty, 0, ax->mkiss->xbuff, count);
+ actual = ax->mkiss->tty->driver->write(ax->mkiss->tty, 0, ax->mkiss->xbuff, count);
ax->tx_packets++;
ax->mkiss->dev->trans_start = jiffies;
ax->mkiss->xleft = count - actual;
return;
}
- actual = tty->driver.write(tty, 0, ax->xhead, ax->xleft);
+ actual = tty->driver->write(tty, 0, ax->xhead, ax->xleft);
ax->xleft -= actual;
ax->xhead += actual;
}
}
printk(KERN_ERR "mkiss: %s: transmit timed out, %s?\n", dev->name,
- (ax->tty->driver.chars_in_buffer(ax->tty) || ax->xleft) ?
+ (ax->tty->driver->chars_in_buffer(ax->tty) || ax->xleft) ?
"bad line quality" : "driver error");
ax->xleft = 0;
ax->mkiss = NULL;
tmp_ax = NULL;
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
ASSERT(priv != NULL, return -1;);
ASSERT(priv->magic == IRTTY_MAGIC, return -1;);
- return priv->tty->driver.chars_in_buffer(priv->tty);
+ return priv->tty->driver->chars_in_buffer(priv->tty);
}
/* Wait (sleep) until underlaying hardware finished transmission
ASSERT(priv->magic == IRTTY_MAGIC, return;);
tty = priv->tty;
- if (tty->driver.wait_until_sent) {
+ if (tty->driver->wait_until_sent) {
lock_kernel();
- tty->driver.wait_until_sent(tty, MSECS_TO_JIFFIES(100));
+ tty->driver->wait_until_sent(tty, MSECS_TO_JIFFIES(100));
unlock_kernel();
}
else {
}
tty->termios->c_cflag = cflag;
- if (tty->driver.set_termios)
- tty->driver.set_termios(tty, &old_termios);
+ if (tty->driver->set_termios)
+ tty->driver->set_termios(tty, &old_termios);
unlock_kernel();
priv->io.speed = speed;
* This function is not yet defined for all tty driver, so
* let's be careful... Jean II
*/
- ASSERT(priv->tty->driver.tiocmset != NULL, return -1;);
- priv->tty->driver.tiocmset(priv->tty, NULL, set, clear);
+ ASSERT(priv->tty->driver->tiocmset != NULL, return -1;);
+ priv->tty->driver->tiocmset(priv->tty, NULL, set, clear);
return 0;
}
ASSERT(priv->magic == IRTTY_MAGIC, return -1;);
tty = priv->tty;
- if (!tty->driver.write)
+ if (!tty->driver->write)
return 0;
tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
- if (tty->driver.write_room) {
- writelen = tty->driver.write_room(tty);
+ if (tty->driver->write_room) {
+ writelen = tty->driver->write_room(tty);
if (writelen > len)
writelen = len;
}
else
writelen = len;
- return tty->driver.write(tty, 0, ptr, writelen);
+ return tty->driver->write(tty, 0, ptr, writelen);
}
/* ------------------------------------------------------- */
cflag |= CREAD;
tty->termios->c_cflag = cflag;
- if (tty->driver.set_termios)
- tty->driver.set_termios(tty, &old_termios);
+ if (tty->driver->set_termios)
+ tty->driver->set_termios(tty, &old_termios);
unlock_kernel();
}
tty = priv->tty;
- if (tty->driver.start)
- tty->driver.start(tty);
+ if (tty->driver->start)
+ tty->driver->start(tty);
/* Make sure we can receive more data */
irtty_stop_receiver(tty, FALSE);
/* Make sure we don't receive more data */
irtty_stop_receiver(tty, TRUE);
- if (tty->driver.stop)
- tty->driver.stop(tty);
+ if (tty->driver->stop)
+ tty->driver->stop(tty);
up(&irtty_sem);
/* stop the underlying driver */
irtty_stop_receiver(tty, TRUE);
- if (tty->driver.stop)
- tty->driver.stop(tty);
+ if (tty->driver->stop)
+ tty->driver->stop(tty);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
/* from old irtty - but what is it good for?
* we _are_ the ldisc and we _don't_ implement flush_buffer!
/* create device name - could we use tty_name() here? */
- if (strchr(tty->driver.name, '%')) {
- sprintf(hwname, tty->driver.name,
- minor(tty->device) - tty->driver.minor_start +
- tty->driver.name_base);
+ if (strchr(tty->driver->name, '%')) {
+ sprintf(hwname, tty->driver->name,
+ minor(tty->device) - tty->driver->minor_start +
+ tty->driver->name_base);
}
else {
- sprintf(hwname, "%s%d", tty->driver.name,
- minor(tty->device) - tty->driver.minor_start +
- tty->driver.name_base);
+ sprintf(hwname, "%s%d", tty->driver->name,
+ minor(tty->device) - tty->driver->minor_start +
+ tty->driver->name_base);
}
/* apply mtt override */
/* Stop tty */
irtty_stop_receiver(tty, TRUE);
tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
- if (tty->driver.stop)
- tty->driver.stop(tty);
+ if (tty->driver->stop)
+ tty->driver->stop(tty);
kfree(priv);
tty->disc_data = self;
/* Give self a name */
- sprintf(name, "%s%d", tty->driver.name,
- minor(tty->device) - tty->driver.minor_start +
- tty->driver.name_base);
+ sprintf(name, "%s%d", tty->driver->name,
+ minor(tty->device) - tty->driver->minor_start +
+ tty->driver->name_base);
hashbin_insert(irtty, (irda_queue_t *) self, (int) self, NULL);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
/* This is unsafe, but currently under discussion - Jean II */
self->tty->termios->c_cflag = cflag;
- self->tty->driver.set_termios(self->tty, &old_termios);
+ self->tty->driver->set_termios(self->tty, &old_termios);
}
/*
/* This is unsafe, but currently under discussion - Jean II */
self->tty->termios->c_cflag = cflag;
- self->tty->driver.set_termios(self->tty, &old_termios);
+ self->tty->driver->set_termios(self->tty, &old_termios);
self->io.speed = speed;
}
* Make sure all data is sent before changing the speed of the
* serial port.
*/
- if (self->tty->driver.chars_in_buffer(self->tty)) {
+ if (self->tty->driver->chars_in_buffer(self->tty)) {
/* Keep state, and try again later */
ret = MSECS_TO_JIFFIES(10);
break;
dev->trans_start = jiffies;
self->stats.tx_bytes += self->tx_buff.len;
- if (self->tty->driver.write)
- actual = self->tty->driver.write(self->tty, 0,
+ if (self->tty->driver->write)
+ actual = self->tty->driver->write(self->tty, 0,
self->tx_buff.data,
self->tx_buff.len);
/* Hide the part we just transmitted */
/* Finished with frame? */
if (self->tx_buff.len > 0) {
/* Write data left in transmit buffer */
- actual = tty->driver.write(tty, 0, self->tx_buff.data,
+ actual = tty->driver->write(tty, 0, self->tx_buff.data,
self->tx_buff.len);
self->tx_buff.data += actual;
set_fs(get_ds());
/* This is probably unsafe, but currently under discussion - Jean II */
- if (tty->driver.ioctl(tty, NULL, TIOCMSET, (unsigned long) &arg)) {
+ if (tty->driver->ioctl(tty, NULL, TIOCMSET, (unsigned long) &arg)) {
IRDA_DEBUG(2, "%s(), error doing ioctl!\n", __FUNCTION__);
}
set_fs(fs);
ASSERT(self != NULL, return 0;);
ASSERT(self->magic == IRTTY_MAGIC, return 0;);
- if (self->tty->driver.write)
- actual = self->tty->driver.write(self->tty, 0, buf, len);
+ if (self->tty->driver->write)
+ actual = self->tty->driver->write(self->tty, 0, buf, len);
return actual;
}
irtty_stop_receiver(self, FALSE);
/* Give self a hardware name */
- sprintf(hwname, "%s%d", tty->driver.name,
- minor(tty->device) - tty->driver.minor_start +
- tty->driver.name_base);
+ sprintf(hwname, "%s%d", tty->driver->name,
+ minor(tty->device) - tty->driver->minor_start +
+ tty->driver->name_base);
/*
* Open new IrLAP layer instance, now that everything should be
spin_unlock_bh(&ap->recv_lock);
ap_put(ap);
if (test_and_clear_bit(TTY_THROTTLED, &tty->flags)
- && tty->driver.unthrottle)
- tty->driver.unthrottle(tty);
+ && tty->driver->unthrottle)
+ tty->driver->unthrottle(tty);
}
static void
if (!tty_stuffed && ap->optr < ap->olim) {
avail = ap->olim - ap->optr;
set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
- sent = tty->driver.write(tty, 0, ap->optr, avail);
+ sent = tty->driver->write(tty, 0, ap->optr, avail);
if (sent < 0)
goto flush; /* error, e.g. loss of CD */
ap->optr += sent;
spin_unlock_bh(&ap->recv_lock);
sp_put(ap);
if (test_and_clear_bit(TTY_THROTTLED, &tty->flags)
- && tty->driver.unthrottle)
- tty->driver.unthrottle(tty);
+ && tty->driver->unthrottle)
+ tty->driver->unthrottle(tty);
}
static void
tty_stuffed = 0;
if (!tty_stuffed && ap->tpkt != 0) {
set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
- sent = tty->driver.write(tty, 0, ap->tpkt->data, ap->tpkt->len);
+ sent = tty->driver->write(tty, 0, ap->tpkt->data, ap->tpkt->len);
if (sent < 0)
goto flush; /* error, e.g. loss of CD */
if (sent < ap->tpkt->len) {
* 14 Oct 1994 Dmitry Gorodchanin.
*/
sl->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
- actual = sl->tty->driver.write(sl->tty, 0, sl->xbuff, count);
+ actual = sl->tty->driver->write(sl->tty, 0, sl->xbuff, count);
#ifdef SL_CHECK_TRANSMIT
sl->dev->trans_start = jiffies;
#endif
return;
}
- actual = tty->driver.write(tty, 0, sl->xhead, sl->xleft);
+ actual = tty->driver->write(tty, 0, sl->xhead, sl->xleft);
sl->xleft -= actual;
sl->xhead += actual;
}
goto out;
}
printk(KERN_WARNING "%s: transmit timed out, %s?\n", dev->name,
- (sl->tty->driver.chars_in_buffer(sl->tty) || sl->xleft) ?
+ (sl->tty->driver->chars_in_buffer(sl->tty) || sl->xleft) ?
"bad line quality" : "driver error");
sl->xleft = 0;
sl->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
tty->disc_data = sl;
sl->line = tty->device;
sl->pid = current->pid;
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
if (!netif_queue_stopped(sl->dev))
{
/* if device busy no outfill */
- sl->tty->driver.write(sl->tty, 0, &s, 1);
+ sl->tty->driver->write(sl->tty, 0, &s, 1);
}
}
else
return -ENODEV;
}
- port = minor(tty->device) - tty->driver.minor_start;
+ port = minor(tty->device) - tty->driver->minor_start;
if ((port < 0) || (port >= CPC_TTY_NPORTS)){
CPC_TTY_DBG("pc300_tty: open invalid minor %i\n",MINOR(tty->device));
if (!tty->driver_data){
int port;
- port = minor(tty->device) - tty->driver.minor_start;
+ port = minor(tty->device) - tty->driver->minor_start;
if ((port < 0) || (port >= NR_PORTS))
return -ENODEV;
* 14 Oct 1994 Dmitry Gorodchanin.
*/
sl->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
- actual = sl->tty->driver.write(sl->tty, 0, sl->xbuff, count);
+ actual = sl->tty->driver->write(sl->tty, 0, sl->xbuff, count);
sl->xleft = count - actual;
sl->xhead = sl->xbuff + actual;
/* VSV */
return;
}
- actual = tty->driver.write(tty, 0, sl->xhead, sl->xleft);
+ actual = tty->driver->write(tty, 0, sl->xhead, sl->xleft);
sl->xleft -= actual;
sl->xhead += actual;
}
* 14 Oct 1994 Dmitry Gorodchanin.
*/
printk(KERN_WARNING "%s: transmit timed out, %s?\n", dev->name,
- (sl->tty->driver.chars_in_buffer(sl->tty) || sl->xleft) ?
+ (sl->tty->driver->chars_in_buffer(sl->tty) || sl->xleft) ?
"bad line quality" : "driver error");
sl->xleft = 0;
sl->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
sl->tty = tty;
tty->disc_data = sl;
- if (tty->driver.flush_buffer) {
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer) {
+ tty->driver->flush_buffer(tty);
}
if (tty->ldisc.flush_buffer) {
tty->ldisc.flush_buffer(tty);
struct termios old_termios = *(tty->termios);
tty->termios->c_cflag &= ~CBAUD; /* Clear the old baud setting */
tty->termios->c_cflag |= baudcode; /* Set the new baud setting */
- tty->driver.set_termios(tty, &old_termios);
+ tty->driver->set_termios(tty, &old_termios);
}
/*
set_baud(tty, strip_info->user_baud);
}
- tty->driver.write(tty, 0, s.string, s.length);
+ tty->driver->write(tty, 0, s.string, s.length);
#ifdef EXT_COUNTERS
strip_info->tx_ebytes += s.length;
#endif
if (strip_info->tx_left > 0) {
int num_written =
- tty->driver.write(tty, 0, strip_info->tx_head,
+ tty->driver->write(tty, 0, strip_info->tx_head,
strip_info->tx_left);
strip_info->tx_left -= num_written;
strip_info->tx_head += num_written;
strip_info->tty = tty;
tty->disc_data = strip_info;
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
struct raw3215_info *raw;
int retval, line;
- line = minor(tty->device) - tty->driver.minor_start;
+ line = minor(tty->device) - tty->driver->minor_start;
if ((line < 0) || (line >= NR_3215))
return -ENODEV;
int retval,
line;
- line = minor(tty->device) - tty->driver.minor_start;
+ line = minor(tty->device) - tty->driver->minor_start;
if (line < 0 || line > CTC_TTY_MAX_DEVICES)
return -ENODEV;
info = &driver->info[line];
if (!info->netdev)
return -ENODEV;
#ifdef CTC_DEBUG_MODEM_OPEN
- printk(KERN_DEBUG "ctc_tty_open %s%d, count = %d\n", tty->driver.name,
+ printk(KERN_DEBUG "ctc_tty_open %s%d, count = %d\n", tty->driver->name,
info->line, info->count);
#endif
spin_lock_irqsave(&ctc_tty_lock, saveflags);
}
}
ctc_tty_shutdown(info);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
info->tty = 0;
printk("aurora_close: shutdown_port\n");
#endif
aurora_shutdown_port(bp, port);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
tty->closing = 0;
uart->ustcnt &= ~(USTCNT_RXEN | USTCNT_RX_INTR_MASK);
shutdown(info);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
tty->closing = 0;
* If this is a callout device, then just make sure the normal
* device isn't being used.
*/
- if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
+ if (tty->driver->subtype == SERIAL_TYPE_CALLOUT) {
if (info->flags & S_NORMAL_ACTIVE)
return -EBUSY;
if ((info->flags & S_CALLOUT_ACTIVE) &&
struct m68k_serial *info;
int retval, line;
- line = minor(tty->device) - tty->driver.minor_start;
+ line = minor(tty->device) - tty->driver->minor_start;
if (line >= NR_PORTS || line < 0) /* we have exactly one */
return -ENODEV;
}
if ((info->count == 1) && (info->flags & S_SPLIT_TERMIOS)) {
- if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
+ if (tty->driver->subtype == SERIAL_TYPE_NORMAL)
*tty->termios = info->normal_termios;
else
*tty->termios = info->callout_termios;
rs_360_wait_until_sent(tty, info->timeout);
}
shutdown(info);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
tty->closing = 0;
* If this is a callout device, then just make sure the normal
* device isn't being used.
*/
- if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
+ if (tty->driver->subtype == SERIAL_TYPE_CALLOUT) {
if (info->flags & ASYNC_NORMAL_ACTIVE)
return -EBUSY;
if ((info->flags & ASYNC_CALLOUT_ACTIVE) &&
ser_info_t *info;
int retval, line;
- line = minor(tty->device) - tty->driver.minor_start;
+ line = minor(tty->device) - tty->driver->minor_start;
if ((line < 0) || (line >= NR_PORTS))
return -ENODEV;
retval = get_async_struct(line, &info);
return -ENODEV;
#ifdef SERIAL_DEBUG_OPEN
- printk("rs_open %s%d, count = %d\n", tty->driver.name, info->line,
+ printk("rs_open %s%d, count = %d\n", tty->driver->name, info->line,
info->state->count);
#endif
tty->driver_data = info;
if ((info->state->count == 1) &&
(info->flags & ASYNC_SPLIT_TERMIOS)) {
- if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
+ if (tty->driver->subtype == SERIAL_TYPE_NORMAL)
*tty->termios = info->state->normal_termios;
else
*tty->termios = info->state->callout_termios;
unsigned long flags;
DPRINTK("uart_flush_buffer(%d) called\n",
- minor(tty->device) - tty->driver.minor_start);
+ minor(tty->device) - tty->driver->minor_start);
spin_lock_irqsave(&port->lock, flags);
uart_circ_clear(&state->info->xmit);
* need to rate-limit; it's CAP_SYS_ADMIN only. */
if (port->flags & UPF_SPD_MASK) {
printk(KERN_NOTICE "%s sets custom speed on %s%d. This is deprecated.\n",
- current->comm, state->info->tty->driver.name,
+ current->comm, state->info->tty->driver->name,
state->port->line);
}
uart_change_speed(state, NULL);
}
if (--state->count < 0) {
printk("rs_close: bad serial port count for %s%d: %d\n",
- tty->driver.name, port->line, state->count);
+ tty->driver->name, port->line, state->count);
state->count = 0;
}
if (state->count)
*/
static int uart_open(struct tty_struct *tty, struct file *filp)
{
- struct uart_driver *drv = (struct uart_driver *)tty->driver.driver_state;
+ struct uart_driver *drv = (struct uart_driver *)tty->driver->driver_state;
struct uart_state *state;
- int retval, line = minor(tty->device) - tty->driver.minor_start;
+ int retval, line = minor(tty->device) - tty->driver->minor_start;
BUG_ON(!kernel_locked());
DPRINTK("uart_open(%d) called\n", line);
/*
- * tty->driver.num won't change, so we won't fail here with
+ * tty->driver->num won't change, so we won't fail here with
* tty->driver_data set to something non-NULL (and therefore
* we won't get caught by uart_close()).
*/
retval = -ENODEV;
- if (line >= tty->driver.num)
+ if (line >= tty->driver->num)
goto fail;
/*
} else
#endif
shutdown(info);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
tty->closing = 0;
* If this is a callout device, then just make sure the normal
* device isn't being used.
*/
- if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
+ if (tty->driver->subtype == SERIAL_TYPE_CALLOUT) {
if (info->flags & ASYNC_NORMAL_ACTIVE)
return -EBUSY;
if ((info->flags & ASYNC_CALLOUT_ACTIVE) &&
struct mcf_serial *info;
int retval, line;
- line = minor(tty->device) - tty->driver.minor_start;
+ line = minor(tty->device) - tty->driver->minor_start;
if ((line < 0) || (line >= NR_PORTS))
return -ENODEV;
info = mcfrs_table + line;
if (serial_paranoia_check(info, tty->device, "mcfrs_open"))
return -ENODEV;
#ifdef SERIAL_DEBUG_OPEN
- printk("mcfrs_open %s%d, count = %d\n", tty->driver.name, info->line,
+ printk("mcfrs_open %s%d, count = %d\n", tty->driver->name, info->line,
info->count);
#endif
info->count++;
}
if ((info->count == 1) && (info->flags & ASYNC_SPLIT_TERMIOS)) {
- if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
+ if (tty->driver->subtype == SERIAL_TYPE_NORMAL)
*tty->termios = info->normal_termios;
else
*tty->termios = info->callout_termios;
ZS_CLEARFIFO(info->zs_channel);
shutdown(info);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
tty->closing = 0;
* If this is a callout device, then just make sure the normal
* device isn't being used.
*/
- if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
+ if (tty->driver->subtype == SERIAL_TYPE_CALLOUT) {
if (info->flags & ZILOG_NORMAL_ACTIVE)
return -EBUSY;
if ((info->flags & ZILOG_CALLOUT_ACTIVE) &&
struct sgi_serial *info;
int retval, line;
- line = MINOR(tty->device) - tty->driver.minor_start;
+ line = MINOR(tty->device) - tty->driver->minor_start;
/* The zilog lines for the mouse/keyboard must be
* opened using their respective drivers.
*/
if (serial_paranoia_check(info, tty->device, "rs_open"))
return -ENODEV;
#ifdef SERIAL_DEBUG_OPEN
- printk("rs_open %s%d, count = %d\n", tty->driver.name, info->line,
+ printk("rs_open %s%d, count = %d\n", tty->driver->name, info->line,
info->count);
#endif
info->count++;
}
if ((info->count == 1) && (info->flags & ZILOG_SPLIT_TERMIOS)) {
- if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
+ if (tty->driver->subtype == SERIAL_TYPE_NORMAL)
*tty->termios = info->normal_termios;
else
*tty->termios = info->callout_termios;
}
shutdown(info);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
tty->closing = 0;
* If this is a callout device, then just make sure the normal
* device isn't being used.
*/
- if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
+ if (tty->driver->subtype == SERIAL_TYPE_CALLOUT) {
if (info->flags & ZILOG_NORMAL_ACTIVE)
return -EBUSY;
if ((info->flags & ZILOG_CALLOUT_ACTIVE) &&
struct dec_serial *info;
int retval, line;
- line = MINOR(tty->device) - tty->driver.minor_start;
+ line = MINOR(tty->device) - tty->driver->minor_start;
if ((line < 0) || (line >= zs_channels_found))
return -ENODEV;
info = zs_soft + line;
if (serial_paranoia_check(info, tty->device, "rs_open"))
return -ENODEV;
#ifdef SERIAL_DEBUG_OPEN
- printk("rs_open %s%d, count = %d\n", tty->driver.name, info->line,
+ printk("rs_open %s%d, count = %d\n", tty->driver->name, info->line,
info->count);
#endif
}
if ((info->count == 1) && (info->flags & ZILOG_SPLIT_TERMIOS)) {
- if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
+ if (tty->driver->subtype == SERIAL_TYPE_NORMAL)
*tty->termios = info->normal_termios;
else
*tty->termios = info->callout_termios;
}
/* flush driver and line discipline buffers */
- if( tty->driver.flush_buffer )
- tty->driver.flush_buffer( tty );
+ if( tty->driver->flush_buffer )
+ tty->driver->flush_buffer( tty );
if( tty->ldisc.flush_buffer )
tty->ldisc.flush_buffer( tty );
}
*/
- if (port->tty->driver.flush_buffer)
- port->tty->driver.flush_buffer(port->tty);
+ if (port->tty->driver->flush_buffer)
+ port->tty->driver->flush_buffer(port->tty);
if (port->tty->ldisc.flush_buffer)
port->tty->ldisc.flush_buffer(port->tty);
*/
struct tty_struct {
int magic;
- struct tty_driver driver;
+ struct tty_driver *driver;
struct tty_ldisc ldisc;
struct termios *termios, *termios_locked;
int pgrp;
*/
void tty_write_message(struct tty_struct *tty, char *msg)
{
- if (tty && tty->driver.write)
- tty->driver.write(tty, 0, msg, strlen(msg));
+ if (tty && tty->driver->write)
+ tty->driver->write(tty, 0, msg, strlen(msg));
return;
}
struct rfcomm_dlc *dlc;
int err, id;
- id = minor(tty->device) - tty->driver.minor_start;
+ id = minor(tty->device) - tty->driver->minor_start;
BT_DBG("tty %p id %d", tty, id);
/* The tty for the current task */
my_tty = current->tty;
if (my_tty != NULL) {
- (*(my_tty->driver).write)(my_tty, 0, str, strlen(str));
- (*(my_tty->driver).write)(my_tty, 0, "\015\012", 2);
+ my_tty->driver->write(my_tty, 0, str, strlen(str));
+ my_tty->driver->write(my_tty, 0, "\015\012", 2);
}
}
tty = self->tty;
- if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
+ if (tty->driver->subtype == SERIAL_TYPE_CALLOUT) {
/* this is a callout device */
/* just verify that normal device is not in use */
if (self->flags & ASYNC_NORMAL_ACTIVE)
add_wait_queue(&self->open_wait, &wait);
IRDA_DEBUG(2, "%s(%d):block_til_ready before block on %s open_count=%d\n",
- __FILE__,__LINE__, tty->driver.name, self->open_count );
+ __FILE__,__LINE__, tty->driver->name, self->open_count );
/* As far as I can see, we protect open_count - Jean II */
spin_lock_irqsave(&self->spinlock, flags);
}
IRDA_DEBUG(1, "%s(%d):block_til_ready blocking on %s open_count=%d\n",
- __FILE__,__LINE__, tty->driver.name, self->open_count );
+ __FILE__,__LINE__, tty->driver->name, self->open_count );
schedule();
}
self->blocked_open--;
IRDA_DEBUG(1, "%s(%d):block_til_ready after blocking on %s open_count=%d\n",
- __FILE__,__LINE__, tty->driver.name, self->open_count);
+ __FILE__,__LINE__, tty->driver->name, self->open_count);
if (!retval)
self->flags |= ASYNC_NORMAL_ACTIVE;
IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
MOD_INC_USE_COUNT;
- line = minor(tty->device) - tty->driver.minor_start;
+ line = minor(tty->device) - tty->driver->minor_start;
if ((line < 0) || (line >= IRCOMM_TTY_PORTS)) {
MOD_DEC_USE_COUNT;
return -ENODEV;
self->tty = tty;
spin_unlock_irqrestore(&self->spinlock, flags);
- IRDA_DEBUG(1, "%s(), %s%d, count = %d\n", __FUNCTION__ , tty->driver.name,
+ IRDA_DEBUG(1, "%s(), %s%d, count = %d\n", __FUNCTION__ , tty->driver->name,
self->line, self->open_count);
/* Not really used by us, but lets do it anyway */
ircomm_tty_shutdown(self);
- if (tty->driver.flush_buffer)
- tty->driver.flush_buffer(tty);
+ if (tty->driver->flush_buffer)
+ tty->driver->flush_buffer(tty);
if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
projects / linux / commitdiff