Merge git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/tty-2.6
* git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/tty-2.6: (79 commits) USB serial: update the console driver usb-serial: straighten out serial_open usb-serial: add missing tests and debug lines usb-serial: rename subroutines usb-serial: fix termios initialization logic usb-serial: acquire references when a new tty is installed usb-serial: change logic of serial lookups usb-serial: put subroutines in logical order usb-serial: change referencing of port and serial structures tty: Char: mxser, use THRE for ASPP_OQUEUE ioctl tty: Char: mxser, add support for CP112UL uartlite: support shared interrupt lines tty: USB: serial/mct_u232, fix tty refcnt tty: riscom8, fix tty refcnt tty: riscom8, fix shutdown declaration TTY: fix typos tty: Power: fix suspend vt regression tty: vt: use printk_once tty: handle VT specific compat ioctls in vt driver n_tty: move echoctl check and clean up logic ...
This commit is contained in:
commit
e11c675ede
|
@ -95,7 +95,7 @@ void foo(void)
|
|||
OFFSET(__iobase, mn10300_serial_port, _iobase);
|
||||
|
||||
DEFINE(__UART_XMIT_SIZE, UART_XMIT_SIZE);
|
||||
OFFSET(__xmit_buffer, uart_info, xmit.buf);
|
||||
OFFSET(__xmit_head, uart_info, xmit.head);
|
||||
OFFSET(__xmit_tail, uart_info, xmit.tail);
|
||||
OFFSET(__xmit_buffer, uart_state, xmit.buf);
|
||||
OFFSET(__xmit_head, uart_state, xmit.head);
|
||||
OFFSET(__xmit_tail, uart_state, xmit.tail);
|
||||
}
|
||||
|
|
File diff suppressed because it is too large
Load diff
|
@ -572,7 +572,7 @@ static void check_modem_status(struct esp_struct *info)
|
|||
info->icount.dcd++;
|
||||
if (status & UART_MSR_DCTS)
|
||||
info->icount.cts++;
|
||||
wake_up_interruptible(&info->delta_msr_wait);
|
||||
wake_up_interruptible(&info->port.delta_msr_wait);
|
||||
}
|
||||
|
||||
if ((info->port.flags & ASYNC_CHECK_CD) && (status & UART_MSR_DDCD)) {
|
||||
|
@ -927,7 +927,7 @@ static void shutdown(struct esp_struct *info)
|
|||
* clear delta_msr_wait queue to avoid mem leaks: we may free the irq
|
||||
* here so the queue might never be waken up
|
||||
*/
|
||||
wake_up_interruptible(&info->delta_msr_wait);
|
||||
wake_up_interruptible(&info->port.delta_msr_wait);
|
||||
wake_up_interruptible(&info->break_wait);
|
||||
|
||||
/* stop a DMA transfer on the port being closed */
|
||||
|
@ -1800,7 +1800,7 @@ static int rs_ioctl(struct tty_struct *tty, struct file *file,
|
|||
spin_unlock_irqrestore(&info->lock, flags);
|
||||
while (1) {
|
||||
/* FIXME: convert to new style wakeup */
|
||||
interruptible_sleep_on(&info->delta_msr_wait);
|
||||
interruptible_sleep_on(&info->port.delta_msr_wait);
|
||||
/* see if a signal did it */
|
||||
if (signal_pending(current))
|
||||
return -ERESTARTSYS;
|
||||
|
@ -2452,7 +2452,6 @@ static int __init espserial_init(void)
|
|||
info->config.flow_off = flow_off;
|
||||
info->config.pio_threshold = pio_threshold;
|
||||
info->next_port = ports;
|
||||
init_waitqueue_head(&info->delta_msr_wait);
|
||||
init_waitqueue_head(&info->break_wait);
|
||||
ports = info;
|
||||
printk(KERN_INFO "ttyP%d at 0x%04x (irq = %d) is an ESP ",
|
||||
|
|
|
@ -846,36 +846,52 @@ static int isicom_carrier_raised(struct tty_port *port)
|
|||
return (ip->status & ISI_DCD)?1 : 0;
|
||||
}
|
||||
|
||||
static int isicom_open(struct tty_struct *tty, struct file *filp)
|
||||
static struct tty_port *isicom_find_port(struct tty_struct *tty)
|
||||
{
|
||||
struct isi_port *port;
|
||||
struct isi_board *card;
|
||||
unsigned int board;
|
||||
int error, line;
|
||||
int line = tty->index;
|
||||
|
||||
line = tty->index;
|
||||
if (line < 0 || line > PORT_COUNT-1)
|
||||
return -ENODEV;
|
||||
return NULL;
|
||||
board = BOARD(line);
|
||||
card = &isi_card[board];
|
||||
|
||||
if (!(card->status & FIRMWARE_LOADED))
|
||||
return -ENODEV;
|
||||
return NULL;
|
||||
|
||||
/* open on a port greater than the port count for the card !!! */
|
||||
if (line > ((board * 16) + card->port_count - 1))
|
||||
return -ENODEV;
|
||||
return NULL;
|
||||
|
||||
port = &isi_ports[line];
|
||||
if (isicom_paranoia_check(port, tty->name, "isicom_open"))
|
||||
return -ENODEV;
|
||||
return NULL;
|
||||
|
||||
return &port->port;
|
||||
}
|
||||
|
||||
static int isicom_open(struct tty_struct *tty, struct file *filp)
|
||||
{
|
||||
struct isi_port *port;
|
||||
struct isi_board *card;
|
||||
struct tty_port *tport;
|
||||
int error = 0;
|
||||
|
||||
tport = isicom_find_port(tty);
|
||||
if (tport == NULL)
|
||||
return -ENODEV;
|
||||
port = container_of(tport, struct isi_port, port);
|
||||
card = &isi_card[BOARD(tty->index)];
|
||||
isicom_setup_board(card);
|
||||
|
||||
/* FIXME: locking on port.count etc */
|
||||
port->port.count++;
|
||||
tty->driver_data = port;
|
||||
tty_port_tty_set(&port->port, tty);
|
||||
/* FIXME: Locking on Initialized flag */
|
||||
if (!test_bit(ASYNCB_INITIALIZED, &tport->flags))
|
||||
error = isicom_setup_port(tty);
|
||||
if (error == 0)
|
||||
error = tty_port_block_til_ready(&port->port, tty, filp);
|
||||
|
@ -952,19 +968,12 @@ static void isicom_flush_buffer(struct tty_struct *tty)
|
|||
tty_wakeup(tty);
|
||||
}
|
||||
|
||||
static void isicom_close(struct tty_struct *tty, struct file *filp)
|
||||
static void isicom_close_port(struct tty_port *port)
|
||||
{
|
||||
struct isi_port *ip = tty->driver_data;
|
||||
struct tty_port *port = &ip->port;
|
||||
struct isi_board *card;
|
||||
struct isi_port *ip = container_of(port, struct isi_port, port);
|
||||
struct isi_board *card = ip->card;
|
||||
unsigned long flags;
|
||||
|
||||
BUG_ON(!ip);
|
||||
|
||||
card = ip->card;
|
||||
if (isicom_paranoia_check(ip, tty->name, "isicom_close"))
|
||||
return;
|
||||
|
||||
/* indicate to the card that no more data can be received
|
||||
on this port */
|
||||
spin_lock_irqsave(&card->card_lock, flags);
|
||||
|
@ -974,9 +983,19 @@ static void isicom_close(struct tty_struct *tty, struct file *filp)
|
|||
}
|
||||
isicom_shutdown_port(ip);
|
||||
spin_unlock_irqrestore(&card->card_lock, flags);
|
||||
}
|
||||
|
||||
static void isicom_close(struct tty_struct *tty, struct file *filp)
|
||||
{
|
||||
struct isi_port *ip = tty->driver_data;
|
||||
struct tty_port *port = &ip->port;
|
||||
if (isicom_paranoia_check(ip, tty->name, "isicom_close"))
|
||||
return;
|
||||
|
||||
if (tty_port_close_start(port, tty, filp) == 0)
|
||||
return;
|
||||
isicom_close_port(port);
|
||||
isicom_flush_buffer(tty);
|
||||
|
||||
tty_port_close_end(port, tty);
|
||||
}
|
||||
|
||||
|
|
|
@ -48,7 +48,7 @@
|
|||
|
||||
#include "mxser.h"
|
||||
|
||||
#define MXSER_VERSION "2.0.4" /* 1.12 */
|
||||
#define MXSER_VERSION "2.0.5" /* 1.14 */
|
||||
#define MXSERMAJOR 174
|
||||
|
||||
#define MXSER_BOARDS 4 /* Max. boards */
|
||||
|
@ -69,6 +69,7 @@
|
|||
#define PCI_DEVICE_ID_POS104UL 0x1044
|
||||
#define PCI_DEVICE_ID_CB108 0x1080
|
||||
#define PCI_DEVICE_ID_CP102UF 0x1023
|
||||
#define PCI_DEVICE_ID_CP112UL 0x1120
|
||||
#define PCI_DEVICE_ID_CB114 0x1142
|
||||
#define PCI_DEVICE_ID_CP114UL 0x1143
|
||||
#define PCI_DEVICE_ID_CB134I 0x1341
|
||||
|
@ -139,7 +140,8 @@ static const struct mxser_cardinfo mxser_cards[] = {
|
|||
{ "CP-138U series", 8, },
|
||||
{ "POS-104UL series", 4, },
|
||||
{ "CP-114UL series", 4, },
|
||||
/*30*/ { "CP-102UF series", 2, }
|
||||
/*30*/ { "CP-102UF series", 2, },
|
||||
{ "CP-112UL series", 2, },
|
||||
};
|
||||
|
||||
/* driver_data correspond to the lines in the structure above
|
||||
|
@ -170,6 +172,7 @@ static struct pci_device_id mxser_pcibrds[] = {
|
|||
{ PCI_VDEVICE(MOXA, PCI_DEVICE_ID_POS104UL), .driver_data = 28 },
|
||||
{ PCI_VDEVICE(MOXA, PCI_DEVICE_ID_CP114UL), .driver_data = 29 },
|
||||
{ PCI_VDEVICE(MOXA, PCI_DEVICE_ID_CP102UF), .driver_data = 30 },
|
||||
{ PCI_VDEVICE(MOXA, PCI_DEVICE_ID_CP112UL), .driver_data = 31 },
|
||||
{ }
|
||||
};
|
||||
MODULE_DEVICE_TABLE(pci, mxser_pcibrds);
|
||||
|
@ -258,7 +261,6 @@ struct mxser_port {
|
|||
struct mxser_mon mon_data;
|
||||
|
||||
spinlock_t slock;
|
||||
wait_queue_head_t delta_msr_wait;
|
||||
};
|
||||
|
||||
struct mxser_board {
|
||||
|
@ -818,7 +820,7 @@ static void mxser_check_modem_status(struct tty_struct *tty,
|
|||
if (status & UART_MSR_DCTS)
|
||||
port->icount.cts++;
|
||||
port->mon_data.modem_status = status;
|
||||
wake_up_interruptible(&port->delta_msr_wait);
|
||||
wake_up_interruptible(&port->port.delta_msr_wait);
|
||||
|
||||
if ((port->port.flags & ASYNC_CHECK_CD) && (status & UART_MSR_DDCD)) {
|
||||
if (status & UART_MSR_DCD)
|
||||
|
@ -973,7 +975,7 @@ static void mxser_shutdown(struct tty_struct *tty)
|
|||
* clear delta_msr_wait queue to avoid mem leaks: we may free the irq
|
||||
* here so the queue might never be waken up
|
||||
*/
|
||||
wake_up_interruptible(&info->delta_msr_wait);
|
||||
wake_up_interruptible(&info->port.delta_msr_wait);
|
||||
|
||||
/*
|
||||
* Free the IRQ, if necessary
|
||||
|
@ -1073,34 +1075,17 @@ static void mxser_flush_buffer(struct tty_struct *tty)
|
|||
}
|
||||
|
||||
|
||||
/*
|
||||
* This routine is called when the serial port gets closed. First, we
|
||||
* wait for the last remaining data to be sent. Then, we unlink its
|
||||
* async structure from the interrupt chain if necessary, and we free
|
||||
* that IRQ if nothing is left in the chain.
|
||||
*/
|
||||
static void mxser_close(struct tty_struct *tty, struct file *filp)
|
||||
static void mxser_close_port(struct tty_struct *tty, struct tty_port *port)
|
||||
{
|
||||
struct mxser_port *info = tty->driver_data;
|
||||
struct tty_port *port = &info->port;
|
||||
|
||||
struct mxser_port *info = container_of(port, struct mxser_port, port);
|
||||
unsigned long timeout;
|
||||
|
||||
if (tty->index == MXSER_PORTS)
|
||||
return;
|
||||
if (!info)
|
||||
return;
|
||||
|
||||
if (tty_port_close_start(port, tty, filp) == 0)
|
||||
return;
|
||||
|
||||
/*
|
||||
* Save the termios structure, since this port may have
|
||||
* separate termios for callout and dialin.
|
||||
*
|
||||
* FIXME: Can this go ?
|
||||
*/
|
||||
if (info->port.flags & ASYNC_NORMAL_ACTIVE)
|
||||
if (port->flags & ASYNC_NORMAL_ACTIVE)
|
||||
info->normal_termios = *tty->termios;
|
||||
/*
|
||||
* At this point we stop accepting input. To do this, we
|
||||
|
@ -1112,7 +1097,7 @@ static void mxser_close(struct tty_struct *tty, struct file *filp)
|
|||
if (info->board->chip_flag)
|
||||
info->IER &= ~MOXA_MUST_RECV_ISR;
|
||||
|
||||
if (info->port.flags & ASYNC_INITIALIZED) {
|
||||
if (port->flags & ASYNC_INITIALIZED) {
|
||||
outb(info->IER, info->ioaddr + UART_IER);
|
||||
/*
|
||||
* Before we drop DTR, make sure the UART transmitter
|
||||
|
@ -1127,8 +1112,26 @@ static void mxser_close(struct tty_struct *tty, struct file *filp)
|
|||
}
|
||||
}
|
||||
mxser_shutdown(tty);
|
||||
mxser_flush_buffer(tty);
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
* This routine is called when the serial port gets closed. First, we
|
||||
* wait for the last remaining data to be sent. Then, we unlink its
|
||||
* async structure from the interrupt chain if necessary, and we free
|
||||
* that IRQ if nothing is left in the chain.
|
||||
*/
|
||||
static void mxser_close(struct tty_struct *tty, struct file *filp)
|
||||
{
|
||||
struct mxser_port *info = tty->driver_data;
|
||||
struct tty_port *port = &info->port;
|
||||
|
||||
if (tty->index == MXSER_PORTS)
|
||||
return;
|
||||
if (tty_port_close_start(port, tty, filp) == 0)
|
||||
return;
|
||||
mxser_close_port(tty, port);
|
||||
mxser_flush_buffer(tty);
|
||||
/* Right now the tty_port set is done outside of the close_end helper
|
||||
as we don't yet have everyone using refcounts */
|
||||
tty_port_close_end(port, tty);
|
||||
|
@ -1761,7 +1764,7 @@ static int mxser_ioctl(struct tty_struct *tty, struct file *file,
|
|||
cnow = info->icount; /* note the counters on entry */
|
||||
spin_unlock_irqrestore(&info->slock, flags);
|
||||
|
||||
return wait_event_interruptible(info->delta_msr_wait,
|
||||
return wait_event_interruptible(info->port.delta_msr_wait,
|
||||
mxser_cflags_changed(info, arg, &cnow));
|
||||
/*
|
||||
* Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
|
||||
|
@ -1803,7 +1806,7 @@ static int mxser_ioctl(struct tty_struct *tty, struct file *file,
|
|||
|
||||
lock_kernel();
|
||||
len = mxser_chars_in_buffer(tty);
|
||||
lsr = inb(info->ioaddr + UART_LSR) & UART_LSR_TEMT;
|
||||
lsr = inb(info->ioaddr + UART_LSR) & UART_LSR_THRE;
|
||||
len += (lsr ? 0 : 1);
|
||||
unlock_kernel();
|
||||
|
||||
|
@ -2413,7 +2416,6 @@ static int __devinit mxser_initbrd(struct mxser_board *brd,
|
|||
info->port.close_delay = 5 * HZ / 10;
|
||||
info->port.closing_wait = 30 * HZ;
|
||||
info->normal_termios = mxvar_sdriver->init_termios;
|
||||
init_waitqueue_head(&info->delta_msr_wait);
|
||||
memset(&info->mon_data, 0, sizeof(struct mxser_mon));
|
||||
info->err_shadow = 0;
|
||||
spin_lock_init(&info->slock);
|
||||
|
|
|
@ -272,7 +272,8 @@ static inline int is_continuation(unsigned char c, struct tty_struct *tty)
|
|||
*
|
||||
* This is a helper function that handles one output character
|
||||
* (including special characters like TAB, CR, LF, etc.),
|
||||
* putting the results in the tty driver's write buffer.
|
||||
* doing OPOST processing and putting the results in the
|
||||
* tty driver's write buffer.
|
||||
*
|
||||
* Note that Linux currently ignores TABDLY, CRDLY, VTDLY, FFDLY
|
||||
* and NLDLY. They simply aren't relevant in the world today.
|
||||
|
@ -350,8 +351,9 @@ static int do_output_char(unsigned char c, struct tty_struct *tty, int space)
|
|||
* @c: character (or partial unicode symbol)
|
||||
* @tty: terminal device
|
||||
*
|
||||
* Perform OPOST processing. Returns -1 when the output device is
|
||||
* full and the character must be retried.
|
||||
* Output one character with OPOST processing.
|
||||
* Returns -1 when the output device is full and the character
|
||||
* must be retried.
|
||||
*
|
||||
* Locking: output_lock to protect column state and space left
|
||||
* (also, this is called from n_tty_write under the
|
||||
|
@ -377,8 +379,11 @@ static int process_output(unsigned char c, struct tty_struct *tty)
|
|||
/**
|
||||
* process_output_block - block post processor
|
||||
* @tty: terminal device
|
||||
* @inbuf: user buffer
|
||||
* @nr: number of bytes
|
||||
* @buf: character buffer
|
||||
* @nr: number of bytes to output
|
||||
*
|
||||
* Output a block of characters with OPOST processing.
|
||||
* Returns the number of characters output.
|
||||
*
|
||||
* This path is used to speed up block console writes, among other
|
||||
* things when processing blocks of output data. It handles only
|
||||
|
@ -571,11 +576,14 @@ static void process_echoes(struct tty_struct *tty)
|
|||
break;
|
||||
|
||||
default:
|
||||
if (iscntrl(op)) {
|
||||
if (L_ECHOCTL(tty)) {
|
||||
/*
|
||||
* Ensure there is enough space
|
||||
* for the whole ctrl pair.
|
||||
* If the op is not a special byte code,
|
||||
* it is a ctrl char tagged to be echoed
|
||||
* as "^X" (where X is the letter
|
||||
* representing the control char).
|
||||
* Note that we must ensure there is
|
||||
* enough space for the whole ctrl pair.
|
||||
*
|
||||
*/
|
||||
if (space < 2) {
|
||||
no_space_left = 1;
|
||||
|
@ -585,19 +593,6 @@ static void process_echoes(struct tty_struct *tty)
|
|||
tty_put_char(tty, op ^ 0100);
|
||||
tty->column += 2;
|
||||
space -= 2;
|
||||
} else {
|
||||
if (!space) {
|
||||
no_space_left = 1;
|
||||
break;
|
||||
}
|
||||
tty_put_char(tty, op);
|
||||
space--;
|
||||
}
|
||||
}
|
||||
/*
|
||||
* If above falls through, this was an
|
||||
* undefined op.
|
||||
*/
|
||||
cp += 2;
|
||||
nr -= 2;
|
||||
}
|
||||
|
@ -605,12 +600,18 @@ static void process_echoes(struct tty_struct *tty)
|
|||
if (no_space_left)
|
||||
break;
|
||||
} else {
|
||||
int retval;
|
||||
|
||||
retval = do_output_char(c, tty, space);
|
||||
if (O_OPOST(tty) &&
|
||||
!(test_bit(TTY_HW_COOK_OUT, &tty->flags))) {
|
||||
int retval = do_output_char(c, tty, space);
|
||||
if (retval < 0)
|
||||
break;
|
||||
space -= retval;
|
||||
} else {
|
||||
if (!space)
|
||||
break;
|
||||
tty_put_char(tty, c);
|
||||
space -= 1;
|
||||
}
|
||||
cp += 1;
|
||||
nr -= 1;
|
||||
}
|
||||
|
@ -798,8 +799,8 @@ static void echo_char_raw(unsigned char c, struct tty_struct *tty)
|
|||
* Echo user input back onto the screen. This must be called only when
|
||||
* L_ECHO(tty) is true. Called from the driver receive_buf path.
|
||||
*
|
||||
* This variant tags control characters to be possibly echoed as
|
||||
* as "^X" (where X is the letter representing the control char).
|
||||
* This variant tags control characters to be echoed as "^X"
|
||||
* (where X is the letter representing the control char).
|
||||
*
|
||||
* Locking: echo_lock to protect the echo buffer
|
||||
*/
|
||||
|
@ -812,7 +813,7 @@ static void echo_char(unsigned char c, struct tty_struct *tty)
|
|||
add_echo_byte(ECHO_OP_START, tty);
|
||||
add_echo_byte(ECHO_OP_START, tty);
|
||||
} else {
|
||||
if (iscntrl(c) && c != '\t')
|
||||
if (L_ECHOCTL(tty) && iscntrl(c) && c != '\t')
|
||||
add_echo_byte(ECHO_OP_START, tty);
|
||||
add_echo_byte(c, tty);
|
||||
}
|
||||
|
|
|
@ -343,7 +343,7 @@ static void rc_receive_exc(struct riscom_board const *bp)
|
|||
if (port == NULL)
|
||||
return;
|
||||
|
||||
tty = port->port.tty;
|
||||
tty = tty_port_tty_get(&port->port);
|
||||
|
||||
#ifdef RC_REPORT_OVERRUN
|
||||
status = rc_in(bp, CD180_RCSR);
|
||||
|
@ -355,18 +355,18 @@ static void rc_receive_exc(struct riscom_board const *bp)
|
|||
#endif
|
||||
ch = rc_in(bp, CD180_RDR);
|
||||
if (!status)
|
||||
return;
|
||||
goto out;
|
||||
if (status & RCSR_TOUT) {
|
||||
printk(KERN_WARNING "rc%d: port %d: Receiver timeout. "
|
||||
"Hardware problems ?\n",
|
||||
board_No(bp), port_No(port));
|
||||
return;
|
||||
goto out;
|
||||
|
||||
} else if (status & RCSR_BREAK) {
|
||||
printk(KERN_INFO "rc%d: port %d: Handling break...\n",
|
||||
board_No(bp), port_No(port));
|
||||
flag = TTY_BREAK;
|
||||
if (port->port.flags & ASYNC_SAK)
|
||||
if (tty && (port->port.flags & ASYNC_SAK))
|
||||
do_SAK(tty);
|
||||
|
||||
} else if (status & RCSR_PE)
|
||||
|
@ -380,9 +380,13 @@ static void rc_receive_exc(struct riscom_board const *bp)
|
|||
else
|
||||
flag = TTY_NORMAL;
|
||||
|
||||
if (tty) {
|
||||
tty_insert_flip_char(tty, ch, flag);
|
||||
tty_flip_buffer_push(tty);
|
||||
}
|
||||
out:
|
||||
tty_kref_put(tty);
|
||||
}
|
||||
|
||||
static void rc_receive(struct riscom_board const *bp)
|
||||
{
|
||||
|
@ -394,7 +398,7 @@ static void rc_receive(struct riscom_board const *bp)
|
|||
if (port == NULL)
|
||||
return;
|
||||
|
||||
tty = port->port.tty;
|
||||
tty = tty_port_tty_get(&port->port);
|
||||
|
||||
count = rc_in(bp, CD180_RDCR);
|
||||
|
||||
|
@ -403,15 +407,14 @@ static void rc_receive(struct riscom_board const *bp)
|
|||
#endif
|
||||
|
||||
while (count--) {
|
||||
if (tty_buffer_request_room(tty, 1) == 0) {
|
||||
printk(KERN_WARNING "rc%d: port %d: Working around "
|
||||
"flip buffer overflow.\n",
|
||||
board_No(bp), port_No(port));
|
||||
break;
|
||||
}
|
||||
tty_insert_flip_char(tty, rc_in(bp, CD180_RDR), TTY_NORMAL);
|
||||
u8 ch = rc_in(bp, CD180_RDR);
|
||||
if (tty)
|
||||
tty_insert_flip_char(tty, ch, TTY_NORMAL);
|
||||
}
|
||||
if (tty) {
|
||||
tty_flip_buffer_push(tty);
|
||||
tty_kref_put(tty);
|
||||
}
|
||||
}
|
||||
|
||||
static void rc_transmit(struct riscom_board const *bp)
|
||||
|
@ -424,22 +427,22 @@ static void rc_transmit(struct riscom_board const *bp)
|
|||
if (port == NULL)
|
||||
return;
|
||||
|
||||
tty = port->port.tty;
|
||||
tty = tty_port_tty_get(&port->port);
|
||||
|
||||
if (port->IER & IER_TXEMPTY) {
|
||||
/* FIFO drained */
|
||||
rc_out(bp, CD180_CAR, port_No(port));
|
||||
port->IER &= ~IER_TXEMPTY;
|
||||
rc_out(bp, CD180_IER, port->IER);
|
||||
return;
|
||||
goto out;
|
||||
}
|
||||
|
||||
if ((port->xmit_cnt <= 0 && !port->break_length)
|
||||
|| tty->stopped || tty->hw_stopped) {
|
||||
|| (tty && (tty->stopped || tty->hw_stopped))) {
|
||||
rc_out(bp, CD180_CAR, port_No(port));
|
||||
port->IER &= ~IER_TXRDY;
|
||||
rc_out(bp, CD180_IER, port->IER);
|
||||
return;
|
||||
goto out;
|
||||
}
|
||||
|
||||
if (port->break_length) {
|
||||
|
@ -464,7 +467,7 @@ static void rc_transmit(struct riscom_board const *bp)
|
|||
rc_out(bp, CD180_CCR, CCR_CORCHG2);
|
||||
port->break_length = 0;
|
||||
}
|
||||
return;
|
||||
goto out;
|
||||
}
|
||||
|
||||
count = CD180_NFIFO;
|
||||
|
@ -480,8 +483,10 @@ static void rc_transmit(struct riscom_board const *bp)
|
|||
port->IER &= ~IER_TXRDY;
|
||||
rc_out(bp, CD180_IER, port->IER);
|
||||
}
|
||||
if (port->xmit_cnt <= port->wakeup_chars)
|
||||
if (tty && port->xmit_cnt <= port->wakeup_chars)
|
||||
tty_wakeup(tty);
|
||||
out:
|
||||
tty_kref_put(tty);
|
||||
}
|
||||
|
||||
static void rc_check_modem(struct riscom_board const *bp)
|
||||
|
@ -494,24 +499,27 @@ static void rc_check_modem(struct riscom_board const *bp)
|
|||
if (port == NULL)
|
||||
return;
|
||||
|
||||
tty = port->port.tty;
|
||||
tty = tty_port_tty_get(&port->port);
|
||||
|
||||
mcr = rc_in(bp, CD180_MCR);
|
||||
if (mcr & MCR_CDCHG) {
|
||||
if (rc_in(bp, CD180_MSVR) & MSVR_CD)
|
||||
wake_up_interruptible(&port->port.open_wait);
|
||||
else
|
||||
else if (tty)
|
||||
tty_hangup(tty);
|
||||
}
|
||||
|
||||
#ifdef RISCOM_BRAIN_DAMAGED_CTS
|
||||
if (mcr & MCR_CTSCHG) {
|
||||
if (rc_in(bp, CD180_MSVR) & MSVR_CTS) {
|
||||
tty->hw_stopped = 0;
|
||||
port->IER |= IER_TXRDY;
|
||||
if (tty) {
|
||||
tty->hw_stopped = 0;
|
||||
if (port->xmit_cnt <= port->wakeup_chars)
|
||||
tty_wakeup(tty);
|
||||
}
|
||||
} else {
|
||||
if (tty)
|
||||
tty->hw_stopped = 1;
|
||||
port->IER &= ~IER_TXRDY;
|
||||
}
|
||||
|
@ -519,11 +527,14 @@ static void rc_check_modem(struct riscom_board const *bp)
|
|||
}
|
||||
if (mcr & MCR_DSRCHG) {
|
||||
if (rc_in(bp, CD180_MSVR) & MSVR_DSR) {
|
||||
tty->hw_stopped = 0;
|
||||
port->IER |= IER_TXRDY;
|
||||
if (tty) {
|
||||
tty->hw_stopped = 0;
|
||||
if (port->xmit_cnt <= port->wakeup_chars)
|
||||
tty_wakeup(tty);
|
||||
}
|
||||
} else {
|
||||
if (tty)
|
||||
tty->hw_stopped = 1;
|
||||
port->IER &= ~IER_TXRDY;
|
||||
}
|
||||
|
@ -533,6 +544,7 @@ static void rc_check_modem(struct riscom_board const *bp)
|
|||
|
||||
/* Clear change bits */
|
||||
rc_out(bp, CD180_MCR, 0);
|
||||
tty_kref_put(tty);
|
||||
}
|
||||
|
||||
/* The main interrupt processing routine */
|
||||
|
@ -632,9 +644,9 @@ static void rc_shutdown_board(struct riscom_board *bp)
|
|||
* Setting up port characteristics.
|
||||
* Must be called with disabled interrupts
|
||||
*/
|
||||
static void rc_change_speed(struct riscom_board *bp, struct riscom_port *port)
|
||||
static void rc_change_speed(struct tty_struct *tty, struct riscom_board *bp,
|
||||
struct riscom_port *port)
|
||||
{
|
||||
struct tty_struct *tty = port->port.tty;
|
||||
unsigned long baud;
|
||||
long tmp;
|
||||
unsigned char cor1 = 0, cor3 = 0;
|
||||
|
@ -781,7 +793,8 @@ static void rc_change_speed(struct riscom_board *bp, struct riscom_port *port)
|
|||
}
|
||||
|
||||
/* Must be called with interrupts enabled */
|
||||
static int rc_setup_port(struct riscom_board *bp, struct riscom_port *port)
|
||||
static int rc_setup_port(struct tty_struct *tty, struct riscom_board *bp,
|
||||
struct riscom_port *port)
|
||||
{
|
||||
unsigned long flags;
|
||||
|
||||
|
@ -793,11 +806,11 @@ static int rc_setup_port(struct riscom_board *bp, struct riscom_port *port)
|
|||
|
||||
spin_lock_irqsave(&riscom_lock, flags);
|
||||
|
||||
clear_bit(TTY_IO_ERROR, &port->port.tty->flags);
|
||||
clear_bit(TTY_IO_ERROR, &tty->flags);
|
||||
if (port->port.count == 1)
|
||||
bp->count++;
|
||||
port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
|
||||
rc_change_speed(bp, port);
|
||||
rc_change_speed(tty, bp, port);
|
||||
port->port.flags |= ASYNC_INITIALIZED;
|
||||
|
||||
spin_unlock_irqrestore(&riscom_lock, flags);
|
||||
|
@ -898,9 +911,9 @@ static int rc_open(struct tty_struct *tty, struct file *filp)
|
|||
|
||||
port->port.count++;
|
||||
tty->driver_data = port;
|
||||
port->port.tty = tty;
|
||||
tty_port_tty_set(&port->port, tty);
|
||||
|
||||
error = rc_setup_port(bp, port);
|
||||
error = rc_setup_port(tty, bp, port);
|
||||
if (error == 0)
|
||||
error = tty_port_block_til_ready(&port->port, tty, filp);
|
||||
return error;
|
||||
|
@ -921,21 +934,13 @@ static void rc_flush_buffer(struct tty_struct *tty)
|
|||
tty_wakeup(tty);
|
||||
}
|
||||
|
||||
static void rc_close(struct tty_struct *tty, struct file *filp)
|
||||
static void rc_close_port(struct tty_port *port)
|
||||
{
|
||||
struct riscom_port *port = tty->driver_data;
|
||||
struct riscom_board *bp;
|
||||
unsigned long flags;
|
||||
struct riscom_port *rp = container_of(port, struct riscom_port, port);
|
||||
struct riscom_board *bp = port_Board(rp);
|
||||
unsigned long timeout;
|
||||
|
||||
if (!port || rc_paranoia_check(port, tty->name, "close"))
|
||||
return;
|
||||
|
||||
bp = port_Board(port);
|
||||
|
||||
if (tty_port_close_start(&port->port, tty, filp) == 0)
|
||||
return;
|
||||
|
||||
/*
|
||||
* At this point we stop accepting input. To do this, we
|
||||
* disable the receive line status interrupts, and tell the
|
||||
|
@ -944,31 +949,37 @@ static void rc_close(struct tty_struct *tty, struct file *filp)
|
|||
*/
|
||||
|
||||
spin_lock_irqsave(&riscom_lock, flags);
|
||||
port->IER &= ~IER_RXD;
|
||||
if (port->port.flags & ASYNC_INITIALIZED) {
|
||||
port->IER &= ~IER_TXRDY;
|
||||
port->IER |= IER_TXEMPTY;
|
||||
rc_out(bp, CD180_CAR, port_No(port));
|
||||
rc_out(bp, CD180_IER, port->IER);
|
||||
rp->IER &= ~IER_RXD;
|
||||
if (port->flags & ASYNC_INITIALIZED) {
|
||||
rp->IER &= ~IER_TXRDY;
|
||||
rp->IER |= IER_TXEMPTY;
|
||||
rc_out(bp, CD180_CAR, port_No(rp));
|
||||
rc_out(bp, CD180_IER, rp->IER);
|
||||
/*
|
||||
* Before we drop DTR, make sure the UART transmitter
|
||||
* has completely drained; this is especially
|
||||
* important if there is a transmit FIFO!
|
||||
*/
|
||||
timeout = jiffies + HZ;
|
||||
while (port->IER & IER_TXEMPTY) {
|
||||
while (rp->IER & IER_TXEMPTY) {
|
||||
spin_unlock_irqrestore(&riscom_lock, flags);
|
||||
msleep_interruptible(jiffies_to_msecs(port->timeout));
|
||||
msleep_interruptible(jiffies_to_msecs(rp->timeout));
|
||||
spin_lock_irqsave(&riscom_lock, flags);
|
||||
if (time_after(jiffies, timeout))
|
||||
break;
|
||||
}
|
||||
}
|
||||
rc_shutdown_port(tty, bp, port);
|
||||
rc_flush_buffer(tty);
|
||||
rc_shutdown_port(port->tty, bp, rp);
|
||||
spin_unlock_irqrestore(&riscom_lock, flags);
|
||||
}
|
||||
|
||||
tty_port_close_end(&port->port, tty);
|
||||
static void rc_close(struct tty_struct *tty, struct file *filp)
|
||||
{
|
||||
struct riscom_port *port = tty->driver_data;
|
||||
|
||||
if (!port || rc_paranoia_check(port, tty->name, "close"))
|
||||
return;
|
||||
tty_port_close(&port->port, tty, filp);
|
||||
}
|
||||
|
||||
static int rc_write(struct tty_struct *tty,
|
||||
|
@ -1170,7 +1181,7 @@ static int rc_send_break(struct tty_struct *tty, int length)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int rc_set_serial_info(struct riscom_port *port,
|
||||
static int rc_set_serial_info(struct tty_struct *tty, struct riscom_port *port,
|
||||
struct serial_struct __user *newinfo)
|
||||
{
|
||||
struct serial_struct tmp;
|
||||
|
@ -1180,17 +1191,6 @@ static int rc_set_serial_info(struct riscom_port *port,
|
|||
if (copy_from_user(&tmp, newinfo, sizeof(tmp)))
|
||||
return -EFAULT;
|
||||
|
||||
#if 0
|
||||
if ((tmp.irq != bp->irq) ||
|
||||
(tmp.port != bp->base) ||
|
||||
(tmp.type != PORT_CIRRUS) ||
|
||||
(tmp.baud_base != (RC_OSCFREQ + CD180_TPC/2) / CD180_TPC) ||
|
||||
(tmp.custom_divisor != 0) ||
|
||||
(tmp.xmit_fifo_size != CD180_NFIFO) ||
|
||||
(tmp.flags & ~RISCOM_LEGAL_FLAGS))
|
||||
return -EINVAL;
|
||||
#endif
|
||||
|
||||
change_speed = ((port->port.flags & ASYNC_SPD_MASK) !=
|
||||
(tmp.flags & ASYNC_SPD_MASK));
|
||||
|
||||
|
@ -1212,7 +1212,7 @@ static int rc_set_serial_info(struct riscom_port *port,
|
|||
unsigned long flags;
|
||||
|
||||
spin_lock_irqsave(&riscom_lock, flags);
|
||||
rc_change_speed(bp, port);
|
||||
rc_change_speed(tty, bp, port);
|
||||
spin_unlock_irqrestore(&riscom_lock, flags);
|
||||
}
|
||||
return 0;
|
||||
|
@ -1255,7 +1255,7 @@ static int rc_ioctl(struct tty_struct *tty, struct file *filp,
|
|||
break;
|
||||
case TIOCSSERIAL:
|
||||
lock_kernel();
|
||||
retval = rc_set_serial_info(port, argp);
|
||||
retval = rc_set_serial_info(tty, port, argp);
|
||||
unlock_kernel();
|
||||
break;
|
||||
default:
|
||||
|
@ -1350,21 +1350,12 @@ static void rc_start(struct tty_struct *tty)
|
|||
static void rc_hangup(struct tty_struct *tty)
|
||||
{
|
||||
struct riscom_port *port = tty->driver_data;
|
||||
struct riscom_board *bp;
|
||||
unsigned long flags;
|
||||
|
||||
if (rc_paranoia_check(port, tty->name, "rc_hangup"))
|
||||
return;
|
||||
|
||||
bp = port_Board(port);
|
||||
|
||||
rc_shutdown_port(tty, bp, port);
|
||||
spin_lock_irqsave(&port->port.lock, flags);
|
||||
port->port.count = 0;
|
||||
port->port.flags &= ~ASYNC_NORMAL_ACTIVE;
|
||||
port->port.tty = NULL;
|
||||
wake_up_interruptible(&port->port.open_wait);
|
||||
spin_unlock_irqrestore(&port->port.lock, flags);
|
||||
rc_shutdown_port(tty, port_Board(port), port);
|
||||
tty_port_hangup(&port->port);
|
||||
}
|
||||
|
||||
static void rc_set_termios(struct tty_struct *tty,
|
||||
|
@ -1377,7 +1368,7 @@ static void rc_set_termios(struct tty_struct *tty,
|
|||
return;
|
||||
|
||||
spin_lock_irqsave(&riscom_lock, flags);
|
||||
rc_change_speed(port_Board(port), port);
|
||||
rc_change_speed(tty, port_Board(port), port);
|
||||
spin_unlock_irqrestore(&riscom_lock, flags);
|
||||
|
||||
if ((old_termios->c_cflag & CRTSCTS) &&
|
||||
|
@ -1410,6 +1401,7 @@ static const struct tty_operations riscom_ops = {
|
|||
|
||||
static const struct tty_port_operations riscom_port_ops = {
|
||||
.carrier_raised = carrier_raised,
|
||||
.shutdown = rc_close_port,
|
||||
};
|
||||
|
||||
|
||||
|
|
|
@ -1184,6 +1184,7 @@ int tty_init_termios(struct tty_struct *tty)
|
|||
tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(tty_init_termios);
|
||||
|
||||
/**
|
||||
* tty_driver_install_tty() - install a tty entry in the driver
|
||||
|
@ -1386,10 +1387,14 @@ EXPORT_SYMBOL(tty_shutdown);
|
|||
* tty_mutex - sometimes only
|
||||
* takes the file list lock internally when working on the list
|
||||
* of ttys that the driver keeps.
|
||||
*
|
||||
* This method gets called from a work queue so that the driver private
|
||||
* shutdown ops can sleep (needed for USB at least)
|
||||
*/
|
||||
static void release_one_tty(struct kref *kref)
|
||||
static void release_one_tty(struct work_struct *work)
|
||||
{
|
||||
struct tty_struct *tty = container_of(kref, struct tty_struct, kref);
|
||||
struct tty_struct *tty =
|
||||
container_of(work, struct tty_struct, hangup_work);
|
||||
struct tty_driver *driver = tty->driver;
|
||||
|
||||
if (tty->ops->shutdown)
|
||||
|
@ -1407,6 +1412,15 @@ static void release_one_tty(struct kref *kref)
|
|||
free_tty_struct(tty);
|
||||
}
|
||||
|
||||
static void queue_release_one_tty(struct kref *kref)
|
||||
{
|
||||
struct tty_struct *tty = container_of(kref, struct tty_struct, kref);
|
||||
/* The hangup queue is now free so we can reuse it rather than
|
||||
waste a chunk of memory for each port */
|
||||
INIT_WORK(&tty->hangup_work, release_one_tty);
|
||||
schedule_work(&tty->hangup_work);
|
||||
}
|
||||
|
||||
/**
|
||||
* tty_kref_put - release a tty kref
|
||||
* @tty: tty device
|
||||
|
@ -1418,7 +1432,7 @@ static void release_one_tty(struct kref *kref)
|
|||
void tty_kref_put(struct tty_struct *tty)
|
||||
{
|
||||
if (tty)
|
||||
kref_put(&tty->kref, release_one_tty);
|
||||
kref_put(&tty->kref, queue_release_one_tty);
|
||||
}
|
||||
EXPORT_SYMBOL(tty_kref_put);
|
||||
|
||||
|
@ -2085,7 +2099,7 @@ static int tioccons(struct file *file)
|
|||
* the generic functionality existed. This piece of history is preserved
|
||||
* in the expected tty API of posix OS's.
|
||||
*
|
||||
* Locking: none, the open fle handle ensures it won't go away.
|
||||
* Locking: none, the open file handle ensures it won't go away.
|
||||
*/
|
||||
|
||||
static int fionbio(struct file *file, int __user *p)
|
||||
|
|
|
@ -393,9 +393,7 @@ void tty_termios_encode_baud_rate(struct ktermios *termios,
|
|||
termios->c_cflag |= (BOTHER << IBSHIFT);
|
||||
#else
|
||||
if (ifound == -1 || ofound == -1) {
|
||||
static int warned;
|
||||
if (!warned++)
|
||||
printk(KERN_WARNING "tty: Unable to return correct "
|
||||
printk_once(KERN_WARNING "tty: Unable to return correct "
|
||||
"speed data as your architecture needs updating.\n");
|
||||
}
|
||||
#endif
|
||||
|
|
|
@ -145,48 +145,33 @@ int tty_unregister_ldisc(int disc)
|
|||
}
|
||||
EXPORT_SYMBOL(tty_unregister_ldisc);
|
||||
|
||||
|
||||
/**
|
||||
* tty_ldisc_try_get - try and reference an ldisc
|
||||
* @disc: ldisc number
|
||||
*
|
||||
* Attempt to open and lock a line discipline into place. Return
|
||||
* the line discipline refcounted or an error.
|
||||
*/
|
||||
|
||||
static struct tty_ldisc *tty_ldisc_try_get(int disc)
|
||||
static struct tty_ldisc_ops *get_ldops(int disc)
|
||||
{
|
||||
unsigned long flags;
|
||||
struct tty_ldisc *ld;
|
||||
struct tty_ldisc_ops *ldops;
|
||||
int err = -EINVAL;
|
||||
|
||||
ld = kmalloc(sizeof(struct tty_ldisc), GFP_KERNEL);
|
||||
if (ld == NULL)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
struct tty_ldisc_ops *ldops, *ret;
|
||||
|
||||
spin_lock_irqsave(&tty_ldisc_lock, flags);
|
||||
ld->ops = NULL;
|
||||
ret = ERR_PTR(-EINVAL);
|
||||
ldops = tty_ldiscs[disc];
|
||||
/* Check the entry is defined */
|
||||
if (ldops) {
|
||||
/* If the module is being unloaded we can't use it */
|
||||
if (!try_module_get(ldops->owner))
|
||||
err = -EAGAIN;
|
||||
else {
|
||||
/* lock it */
|
||||
ret = ERR_PTR(-EAGAIN);
|
||||
if (try_module_get(ldops->owner)) {
|
||||
ldops->refcount++;
|
||||
ld->ops = ldops;
|
||||
atomic_set(&ld->users, 1);
|
||||
err = 0;
|
||||
ret = ldops;
|
||||
}
|
||||
}
|
||||
spin_unlock_irqrestore(&tty_ldisc_lock, flags);
|
||||
if (err) {
|
||||
kfree(ld);
|
||||
return ERR_PTR(err);
|
||||
return ret;
|
||||
}
|
||||
return ld;
|
||||
|
||||
static void put_ldops(struct tty_ldisc_ops *ldops)
|
||||
{
|
||||
unsigned long flags;
|
||||
|
||||
spin_lock_irqsave(&tty_ldisc_lock, flags);
|
||||
ldops->refcount--;
|
||||
module_put(ldops->owner);
|
||||
spin_unlock_irqrestore(&tty_ldisc_lock, flags);
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -205,14 +190,31 @@ static struct tty_ldisc *tty_ldisc_try_get(int disc)
|
|||
static struct tty_ldisc *tty_ldisc_get(int disc)
|
||||
{
|
||||
struct tty_ldisc *ld;
|
||||
struct tty_ldisc_ops *ldops;
|
||||
|
||||
if (disc < N_TTY || disc >= NR_LDISCS)
|
||||
return ERR_PTR(-EINVAL);
|
||||
ld = tty_ldisc_try_get(disc);
|
||||
if (IS_ERR(ld)) {
|
||||
|
||||
/*
|
||||
* Get the ldisc ops - we may need to request them to be loaded
|
||||
* dynamically and try again.
|
||||
*/
|
||||
ldops = get_ldops(disc);
|
||||
if (IS_ERR(ldops)) {
|
||||
request_module("tty-ldisc-%d", disc);
|
||||
ld = tty_ldisc_try_get(disc);
|
||||
ldops = get_ldops(disc);
|
||||
if (IS_ERR(ldops))
|
||||
return ERR_CAST(ldops);
|
||||
}
|
||||
|
||||
ld = kmalloc(sizeof(struct tty_ldisc), GFP_KERNEL);
|
||||
if (ld == NULL) {
|
||||
put_ldops(ldops);
|
||||
return ERR_PTR(-ENOMEM);
|
||||
}
|
||||
|
||||
ld->ops = ldops;
|
||||
atomic_set(&ld->users, 1);
|
||||
return ld;
|
||||
}
|
||||
|
||||
|
@ -234,13 +236,13 @@ static void tty_ldiscs_seq_stop(struct seq_file *m, void *v)
|
|||
static int tty_ldiscs_seq_show(struct seq_file *m, void *v)
|
||||
{
|
||||
int i = *(loff_t *)v;
|
||||
struct tty_ldisc *ld;
|
||||
struct tty_ldisc_ops *ldops;
|
||||
|
||||
ld = tty_ldisc_try_get(i);
|
||||
if (IS_ERR(ld))
|
||||
ldops = get_ldops(i);
|
||||
if (IS_ERR(ldops))
|
||||
return 0;
|
||||
seq_printf(m, "%-10s %2d\n", ld->ops->name ? ld->ops->name : "???", i);
|
||||
put_ldisc(ld);
|
||||
seq_printf(m, "%-10s %2d\n", ldops->name ? ldops->name : "???", i);
|
||||
put_ldops(ldops);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -23,6 +23,7 @@ void tty_port_init(struct tty_port *port)
|
|||
memset(port, 0, sizeof(*port));
|
||||
init_waitqueue_head(&port->open_wait);
|
||||
init_waitqueue_head(&port->close_wait);
|
||||
init_waitqueue_head(&port->delta_msr_wait);
|
||||
mutex_init(&port->mutex);
|
||||
spin_lock_init(&port->lock);
|
||||
port->close_delay = (50 * HZ) / 100;
|
||||
|
@ -96,6 +97,14 @@ void tty_port_tty_set(struct tty_port *port, struct tty_struct *tty)
|
|||
}
|
||||
EXPORT_SYMBOL(tty_port_tty_set);
|
||||
|
||||
static void tty_port_shutdown(struct tty_port *port)
|
||||
{
|
||||
if (port->ops->shutdown &&
|
||||
test_and_clear_bit(ASYNCB_INITIALIZED, &port->flags))
|
||||
port->ops->shutdown(port);
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* tty_port_hangup - hangup helper
|
||||
* @port: tty port
|
||||
|
@ -116,6 +125,8 @@ void tty_port_hangup(struct tty_port *port)
|
|||
port->tty = NULL;
|
||||
spin_unlock_irqrestore(&port->lock, flags);
|
||||
wake_up_interruptible(&port->open_wait);
|
||||
wake_up_interruptible(&port->delta_msr_wait);
|
||||
tty_port_shutdown(port);
|
||||
}
|
||||
EXPORT_SYMBOL(tty_port_hangup);
|
||||
|
||||
|
@ -296,15 +307,17 @@ int tty_port_close_start(struct tty_port *port, struct tty_struct *tty, struct f
|
|||
|
||||
if (port->count) {
|
||||
spin_unlock_irqrestore(&port->lock, flags);
|
||||
if (port->ops->drop)
|
||||
port->ops->drop(port);
|
||||
return 0;
|
||||
}
|
||||
port->flags |= ASYNC_CLOSING;
|
||||
set_bit(ASYNCB_CLOSING, &port->flags);
|
||||
tty->closing = 1;
|
||||
spin_unlock_irqrestore(&port->lock, flags);
|
||||
/* Don't block on a stalled port, just pull the chain */
|
||||
if (tty->flow_stopped)
|
||||
tty_driver_flush_buffer(tty);
|
||||
if (port->flags & ASYNC_INITIALIZED &&
|
||||
if (test_bit(ASYNCB_INITIALIZED, &port->flags) &&
|
||||
port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
|
||||
tty_wait_until_sent(tty, port->closing_wait);
|
||||
if (port->drain_delay) {
|
||||
|
@ -318,6 +331,9 @@ int tty_port_close_start(struct tty_port *port, struct tty_struct *tty, struct f
|
|||
timeout = 2 * HZ;
|
||||
schedule_timeout_interruptible(timeout);
|
||||
}
|
||||
/* Don't call port->drop for the last reference. Callers will want
|
||||
to drop the last active reference in ->shutdown() or the tty
|
||||
shutdown path */
|
||||
return 1;
|
||||
}
|
||||
EXPORT_SYMBOL(tty_port_close_start);
|
||||
|
@ -348,3 +364,14 @@ void tty_port_close_end(struct tty_port *port, struct tty_struct *tty)
|
|||
spin_unlock_irqrestore(&port->lock, flags);
|
||||
}
|
||||
EXPORT_SYMBOL(tty_port_close_end);
|
||||
|
||||
void tty_port_close(struct tty_port *port, struct tty_struct *tty,
|
||||
struct file *filp)
|
||||
{
|
||||
if (tty_port_close_start(port, tty, filp) == 0)
|
||||
return;
|
||||
tty_port_shutdown(port);
|
||||
tty_port_close_end(port, tty);
|
||||
tty_port_tty_set(port, NULL);
|
||||
}
|
||||
EXPORT_SYMBOL(tty_port_close);
|
||||
|
|
|
@ -252,7 +252,6 @@ static void notify_update(struct vc_data *vc)
|
|||
struct vt_notifier_param param = { .vc = vc };
|
||||
atomic_notifier_call_chain(&vt_notifier_list, VT_UPDATE, ¶m);
|
||||
}
|
||||
|
||||
/*
|
||||
* Low-Level Functions
|
||||
*/
|
||||
|
@ -935,6 +934,7 @@ static int vc_do_resize(struct tty_struct *tty, struct vc_data *vc,
|
|||
|
||||
if (CON_IS_VISIBLE(vc))
|
||||
update_screen(vc);
|
||||
vt_event_post(VT_EVENT_RESIZE, vc->vc_num, vc->vc_num);
|
||||
return err;
|
||||
}
|
||||
|
||||
|
@ -2129,11 +2129,7 @@ static int do_con_write(struct tty_struct *tty, const unsigned char *buf, int co
|
|||
currcons = vc->vc_num;
|
||||
if (!vc_cons_allocated(currcons)) {
|
||||
/* could this happen? */
|
||||
static int error = 0;
|
||||
if (!error) {
|
||||
error = 1;
|
||||
printk("con_write: tty %d not allocated\n", currcons+1);
|
||||
}
|
||||
printk_once("con_write: tty %d not allocated\n", currcons+1);
|
||||
release_console_sem();
|
||||
return 0;
|
||||
}
|
||||
|
@ -2910,6 +2906,9 @@ static const struct tty_operations con_ops = {
|
|||
.flush_chars = con_flush_chars,
|
||||
.chars_in_buffer = con_chars_in_buffer,
|
||||
.ioctl = vt_ioctl,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.compat_ioctl = vt_compat_ioctl,
|
||||
#endif
|
||||
.stop = con_stop,
|
||||
.start = con_start,
|
||||
.throttle = con_throttle,
|
||||
|
@ -2955,7 +2954,6 @@ int __init vty_init(const struct file_operations *console_fops)
|
|||
}
|
||||
|
||||
#ifndef VT_SINGLE_DRIVER
|
||||
#include <linux/device.h>
|
||||
|
||||
static struct class *vtconsole_class;
|
||||
|
||||
|
@ -3638,6 +3636,7 @@ void do_blank_screen(int entering_gfx)
|
|||
blank_state = blank_vesa_wait;
|
||||
mod_timer(&console_timer, jiffies + vesa_off_interval);
|
||||
}
|
||||
vt_event_post(VT_EVENT_BLANK, vc->vc_num, vc->vc_num);
|
||||
}
|
||||
EXPORT_SYMBOL(do_blank_screen);
|
||||
|
||||
|
@ -3682,6 +3681,7 @@ void do_unblank_screen(int leaving_gfx)
|
|||
console_blank_hook(0);
|
||||
set_palette(vc);
|
||||
set_cursor(vc);
|
||||
vt_event_post(VT_EVENT_UNBLANK, vc->vc_num, vc->vc_num);
|
||||
}
|
||||
EXPORT_SYMBOL(do_unblank_screen);
|
||||
|
||||
|
|
|
@ -16,6 +16,8 @@
|
|||
#include <linux/tty.h>
|
||||
#include <linux/timer.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/compat.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/kd.h>
|
||||
#include <linux/vt.h>
|
||||
#include <linux/string.h>
|
||||
|
@ -61,6 +63,133 @@ extern struct tty_driver *console_driver;
|
|||
|
||||
static void complete_change_console(struct vc_data *vc);
|
||||
|
||||
/*
|
||||
* User space VT_EVENT handlers
|
||||
*/
|
||||
|
||||
struct vt_event_wait {
|
||||
struct list_head list;
|
||||
struct vt_event event;
|
||||
int done;
|
||||
};
|
||||
|
||||
static LIST_HEAD(vt_events);
|
||||
static DEFINE_SPINLOCK(vt_event_lock);
|
||||
static DECLARE_WAIT_QUEUE_HEAD(vt_event_waitqueue);
|
||||
|
||||
/**
|
||||
* vt_event_post
|
||||
* @event: the event that occurred
|
||||
* @old: old console
|
||||
* @new: new console
|
||||
*
|
||||
* Post an VT event to interested VT handlers
|
||||
*/
|
||||
|
||||
void vt_event_post(unsigned int event, unsigned int old, unsigned int new)
|
||||
{
|
||||
struct list_head *pos, *head;
|
||||
unsigned long flags;
|
||||
int wake = 0;
|
||||
|
||||
spin_lock_irqsave(&vt_event_lock, flags);
|
||||
head = &vt_events;
|
||||
|
||||
list_for_each(pos, head) {
|
||||
struct vt_event_wait *ve = list_entry(pos,
|
||||
struct vt_event_wait, list);
|
||||
if (!(ve->event.event & event))
|
||||
continue;
|
||||
ve->event.event = event;
|
||||
/* kernel view is consoles 0..n-1, user space view is
|
||||
console 1..n with 0 meaning current, so we must bias */
|
||||
ve->event.old = old + 1;
|
||||
ve->event.new = new + 1;
|
||||
wake = 1;
|
||||
ve->done = 1;
|
||||
}
|
||||
spin_unlock_irqrestore(&vt_event_lock, flags);
|
||||
if (wake)
|
||||
wake_up_interruptible(&vt_event_waitqueue);
|
||||
}
|
||||
|
||||
/**
|
||||
* vt_event_wait - wait for an event
|
||||
* @vw: our event
|
||||
*
|
||||
* Waits for an event to occur which completes our vt_event_wait
|
||||
* structure. On return the structure has wv->done set to 1 for success
|
||||
* or 0 if some event such as a signal ended the wait.
|
||||
*/
|
||||
|
||||
static void vt_event_wait(struct vt_event_wait *vw)
|
||||
{
|
||||
unsigned long flags;
|
||||
/* Prepare the event */
|
||||
INIT_LIST_HEAD(&vw->list);
|
||||
vw->done = 0;
|
||||
/* Queue our event */
|
||||
spin_lock_irqsave(&vt_event_lock, flags);
|
||||
list_add(&vw->list, &vt_events);
|
||||
spin_unlock_irqrestore(&vt_event_lock, flags);
|
||||
/* Wait for it to pass */
|
||||
wait_event_interruptible(vt_event_waitqueue, vw->done);
|
||||
/* Dequeue it */
|
||||
spin_lock_irqsave(&vt_event_lock, flags);
|
||||
list_del(&vw->list);
|
||||
spin_unlock_irqrestore(&vt_event_lock, flags);
|
||||
}
|
||||
|
||||
/**
|
||||
* vt_event_wait_ioctl - event ioctl handler
|
||||
* @arg: argument to ioctl
|
||||
*
|
||||
* Implement the VT_WAITEVENT ioctl using the VT event interface
|
||||
*/
|
||||
|
||||
static int vt_event_wait_ioctl(struct vt_event __user *event)
|
||||
{
|
||||
struct vt_event_wait vw;
|
||||
|
||||
if (copy_from_user(&vw.event, event, sizeof(struct vt_event)))
|
||||
return -EFAULT;
|
||||
/* Highest supported event for now */
|
||||
if (vw.event.event & ~VT_MAX_EVENT)
|
||||
return -EINVAL;
|
||||
|
||||
vt_event_wait(&vw);
|
||||
/* If it occurred report it */
|
||||
if (vw.done) {
|
||||
if (copy_to_user(event, &vw.event, sizeof(struct vt_event)))
|
||||
return -EFAULT;
|
||||
return 0;
|
||||
}
|
||||
return -EINTR;
|
||||
}
|
||||
|
||||
/**
|
||||
* vt_waitactive - active console wait
|
||||
* @event: event code
|
||||
* @n: new console
|
||||
*
|
||||
* Helper for event waits. Used to implement the legacy
|
||||
* event waiting ioctls in terms of events
|
||||
*/
|
||||
|
||||
int vt_waitactive(int n)
|
||||
{
|
||||
struct vt_event_wait vw;
|
||||
do {
|
||||
if (n == fg_console + 1)
|
||||
break;
|
||||
vw.event.event = VT_EVENT_SWITCH;
|
||||
vt_event_wait(&vw);
|
||||
if (vw.done == 0)
|
||||
return -EINTR;
|
||||
} while (vw.event.new != n);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* these are the valid i/o ports we're allowed to change. they map all the
|
||||
* video ports
|
||||
|
@ -360,6 +489,8 @@ do_unimap_ioctl(int cmd, struct unimapdesc __user *user_ud, int perm, struct vc_
|
|||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* We handle the console-specific ioctl's here. We allow the
|
||||
* capability to modify any console, not just the fg_console.
|
||||
|
@ -842,6 +973,41 @@ int vt_ioctl(struct tty_struct *tty, struct file * file,
|
|||
}
|
||||
break;
|
||||
|
||||
case VT_SETACTIVATE:
|
||||
{
|
||||
struct vt_setactivate vsa;
|
||||
|
||||
if (!perm)
|
||||
goto eperm;
|
||||
|
||||
if (copy_from_user(&vsa, (struct vt_setactivate __user *)arg,
|
||||
sizeof(struct vt_setactivate)))
|
||||
return -EFAULT;
|
||||
if (vsa.console == 0 || vsa.console > MAX_NR_CONSOLES)
|
||||
ret = -ENXIO;
|
||||
else {
|
||||
vsa.console--;
|
||||
acquire_console_sem();
|
||||
ret = vc_allocate(vsa.console);
|
||||
if (ret == 0) {
|
||||
struct vc_data *nvc;
|
||||
/* This is safe providing we don't drop the
|
||||
console sem between vc_allocate and
|
||||
finishing referencing nvc */
|
||||
nvc = vc_cons[vsa.console].d;
|
||||
nvc->vt_mode = vsa.mode;
|
||||
nvc->vt_mode.frsig = 0;
|
||||
put_pid(nvc->vt_pid);
|
||||
nvc->vt_pid = get_pid(task_pid(current));
|
||||
}
|
||||
release_console_sem();
|
||||
if (ret)
|
||||
break;
|
||||
/* Commence switch and lock */
|
||||
set_console(arg);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* wait until the specified VT has been activated
|
||||
*/
|
||||
|
@ -851,7 +1017,7 @@ int vt_ioctl(struct tty_struct *tty, struct file * file,
|
|||
if (arg == 0 || arg > MAX_NR_CONSOLES)
|
||||
ret = -ENXIO;
|
||||
else
|
||||
ret = vt_waitactive(arg - 1);
|
||||
ret = vt_waitactive(arg);
|
||||
break;
|
||||
|
||||
/*
|
||||
|
@ -1159,6 +1325,9 @@ int vt_ioctl(struct tty_struct *tty, struct file * file,
|
|||
ret = put_user(vc->vc_hi_font_mask,
|
||||
(unsigned short __user *)arg);
|
||||
break;
|
||||
case VT_WAITEVENT:
|
||||
ret = vt_event_wait_ioctl((struct vt_event __user *)arg);
|
||||
break;
|
||||
default:
|
||||
ret = -ENOIOCTLCMD;
|
||||
}
|
||||
|
@ -1170,54 +1339,6 @@ eperm:
|
|||
goto out;
|
||||
}
|
||||
|
||||
/*
|
||||
* Sometimes we want to wait until a particular VT has been activated. We
|
||||
* do it in a very simple manner. Everybody waits on a single queue and
|
||||
* get woken up at once. Those that are satisfied go on with their business,
|
||||
* while those not ready go back to sleep. Seems overkill to add a wait
|
||||
* to each vt just for this - usually this does nothing!
|
||||
*/
|
||||
static DECLARE_WAIT_QUEUE_HEAD(vt_activate_queue);
|
||||
|
||||
/*
|
||||
* Sleeps until a vt is activated, or the task is interrupted. Returns
|
||||
* 0 if activation, -EINTR if interrupted by a signal handler.
|
||||
*/
|
||||
int vt_waitactive(int vt)
|
||||
{
|
||||
int retval;
|
||||
DECLARE_WAITQUEUE(wait, current);
|
||||
|
||||
add_wait_queue(&vt_activate_queue, &wait);
|
||||
for (;;) {
|
||||
retval = 0;
|
||||
|
||||
/*
|
||||
* Synchronize with redraw_screen(). By acquiring the console
|
||||
* semaphore we make sure that the console switch is completed
|
||||
* before we return. If we didn't wait for the semaphore, we
|
||||
* could return at a point where fg_console has already been
|
||||
* updated, but the console switch hasn't been completed.
|
||||
*/
|
||||
acquire_console_sem();
|
||||
set_current_state(TASK_INTERRUPTIBLE);
|
||||
if (vt == fg_console) {
|
||||
release_console_sem();
|
||||
break;
|
||||
}
|
||||
release_console_sem();
|
||||
retval = -ERESTARTNOHAND;
|
||||
if (signal_pending(current))
|
||||
break;
|
||||
schedule();
|
||||
}
|
||||
remove_wait_queue(&vt_activate_queue, &wait);
|
||||
__set_current_state(TASK_RUNNING);
|
||||
return retval;
|
||||
}
|
||||
|
||||
#define vt_wake_waitactive() wake_up(&vt_activate_queue)
|
||||
|
||||
void reset_vc(struct vc_data *vc)
|
||||
{
|
||||
vc->vc_mode = KD_TEXT;
|
||||
|
@ -1256,12 +1377,216 @@ void vc_SAK(struct work_struct *work)
|
|||
release_console_sem();
|
||||
}
|
||||
|
||||
#ifdef CONFIG_COMPAT
|
||||
|
||||
struct compat_consolefontdesc {
|
||||
unsigned short charcount; /* characters in font (256 or 512) */
|
||||
unsigned short charheight; /* scan lines per character (1-32) */
|
||||
compat_caddr_t chardata; /* font data in expanded form */
|
||||
};
|
||||
|
||||
static inline int
|
||||
compat_fontx_ioctl(int cmd, struct compat_consolefontdesc __user *user_cfd,
|
||||
int perm, struct console_font_op *op)
|
||||
{
|
||||
struct compat_consolefontdesc cfdarg;
|
||||
int i;
|
||||
|
||||
if (copy_from_user(&cfdarg, user_cfd, sizeof(struct compat_consolefontdesc)))
|
||||
return -EFAULT;
|
||||
|
||||
switch (cmd) {
|
||||
case PIO_FONTX:
|
||||
if (!perm)
|
||||
return -EPERM;
|
||||
op->op = KD_FONT_OP_SET;
|
||||
op->flags = KD_FONT_FLAG_OLD;
|
||||
op->width = 8;
|
||||
op->height = cfdarg.charheight;
|
||||
op->charcount = cfdarg.charcount;
|
||||
op->data = compat_ptr(cfdarg.chardata);
|
||||
return con_font_op(vc_cons[fg_console].d, op);
|
||||
case GIO_FONTX:
|
||||
op->op = KD_FONT_OP_GET;
|
||||
op->flags = KD_FONT_FLAG_OLD;
|
||||
op->width = 8;
|
||||
op->height = cfdarg.charheight;
|
||||
op->charcount = cfdarg.charcount;
|
||||
op->data = compat_ptr(cfdarg.chardata);
|
||||
i = con_font_op(vc_cons[fg_console].d, op);
|
||||
if (i)
|
||||
return i;
|
||||
cfdarg.charheight = op->height;
|
||||
cfdarg.charcount = op->charcount;
|
||||
if (copy_to_user(user_cfd, &cfdarg, sizeof(struct compat_consolefontdesc)))
|
||||
return -EFAULT;
|
||||
return 0;
|
||||
}
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
struct compat_console_font_op {
|
||||
compat_uint_t op; /* operation code KD_FONT_OP_* */
|
||||
compat_uint_t flags; /* KD_FONT_FLAG_* */
|
||||
compat_uint_t width, height; /* font size */
|
||||
compat_uint_t charcount;
|
||||
compat_caddr_t data; /* font data with height fixed to 32 */
|
||||
};
|
||||
|
||||
static inline int
|
||||
compat_kdfontop_ioctl(struct compat_console_font_op __user *fontop,
|
||||
int perm, struct console_font_op *op, struct vc_data *vc)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (copy_from_user(op, fontop, sizeof(struct compat_console_font_op)))
|
||||
return -EFAULT;
|
||||
if (!perm && op->op != KD_FONT_OP_GET)
|
||||
return -EPERM;
|
||||
op->data = compat_ptr(((struct compat_console_font_op *)op)->data);
|
||||
op->flags |= KD_FONT_FLAG_OLD;
|
||||
i = con_font_op(vc, op);
|
||||
if (i)
|
||||
return i;
|
||||
((struct compat_console_font_op *)op)->data = (unsigned long)op->data;
|
||||
if (copy_to_user(fontop, op, sizeof(struct compat_console_font_op)))
|
||||
return -EFAULT;
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct compat_unimapdesc {
|
||||
unsigned short entry_ct;
|
||||
compat_caddr_t entries;
|
||||
};
|
||||
|
||||
static inline int
|
||||
compat_unimap_ioctl(unsigned int cmd, struct compat_unimapdesc __user *user_ud,
|
||||
int perm, struct vc_data *vc)
|
||||
{
|
||||
struct compat_unimapdesc tmp;
|
||||
struct unipair __user *tmp_entries;
|
||||
|
||||
if (copy_from_user(&tmp, user_ud, sizeof tmp))
|
||||
return -EFAULT;
|
||||
tmp_entries = compat_ptr(tmp.entries);
|
||||
if (tmp_entries)
|
||||
if (!access_ok(VERIFY_WRITE, tmp_entries,
|
||||
tmp.entry_ct*sizeof(struct unipair)))
|
||||
return -EFAULT;
|
||||
switch (cmd) {
|
||||
case PIO_UNIMAP:
|
||||
if (!perm)
|
||||
return -EPERM;
|
||||
return con_set_unimap(vc, tmp.entry_ct, tmp_entries);
|
||||
case GIO_UNIMAP:
|
||||
if (!perm && fg_console != vc->vc_num)
|
||||
return -EPERM;
|
||||
return con_get_unimap(vc, tmp.entry_ct, &(user_ud->entry_ct), tmp_entries);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
long vt_compat_ioctl(struct tty_struct *tty, struct file * file,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
struct vc_data *vc = tty->driver_data;
|
||||
struct console_font_op op; /* used in multiple places here */
|
||||
struct kbd_struct *kbd;
|
||||
unsigned int console;
|
||||
void __user *up = (void __user *)arg;
|
||||
int perm;
|
||||
int ret = 0;
|
||||
|
||||
console = vc->vc_num;
|
||||
|
||||
lock_kernel();
|
||||
|
||||
if (!vc_cons_allocated(console)) { /* impossible? */
|
||||
ret = -ENOIOCTLCMD;
|
||||
goto out;
|
||||
}
|
||||
|
||||
/*
|
||||
* Performs the back end of a vt switch
|
||||
* To have permissions to do most of the vt ioctls, we either have
|
||||
* to be the owner of the tty, or have CAP_SYS_TTY_CONFIG.
|
||||
*/
|
||||
perm = 0;
|
||||
if (current->signal->tty == tty || capable(CAP_SYS_TTY_CONFIG))
|
||||
perm = 1;
|
||||
|
||||
kbd = kbd_table + console;
|
||||
switch (cmd) {
|
||||
/*
|
||||
* these need special handlers for incompatible data structures
|
||||
*/
|
||||
case PIO_FONTX:
|
||||
case GIO_FONTX:
|
||||
ret = compat_fontx_ioctl(cmd, up, perm, &op);
|
||||
break;
|
||||
|
||||
case KDFONTOP:
|
||||
ret = compat_kdfontop_ioctl(up, perm, &op, vc);
|
||||
break;
|
||||
|
||||
case PIO_UNIMAP:
|
||||
case GIO_UNIMAP:
|
||||
ret = do_unimap_ioctl(cmd, up, perm, vc);
|
||||
break;
|
||||
|
||||
/*
|
||||
* all these treat 'arg' as an integer
|
||||
*/
|
||||
case KIOCSOUND:
|
||||
case KDMKTONE:
|
||||
#ifdef CONFIG_X86
|
||||
case KDADDIO:
|
||||
case KDDELIO:
|
||||
#endif
|
||||
case KDSETMODE:
|
||||
case KDMAPDISP:
|
||||
case KDUNMAPDISP:
|
||||
case KDSKBMODE:
|
||||
case KDSKBMETA:
|
||||
case KDSKBLED:
|
||||
case KDSETLED:
|
||||
case KDSIGACCEPT:
|
||||
case VT_ACTIVATE:
|
||||
case VT_WAITACTIVE:
|
||||
case VT_RELDISP:
|
||||
case VT_DISALLOCATE:
|
||||
case VT_RESIZE:
|
||||
case VT_RESIZEX:
|
||||
goto fallback;
|
||||
|
||||
/*
|
||||
* the rest has a compatible data structure behind arg,
|
||||
* but we have to convert it to a proper 64 bit pointer.
|
||||
*/
|
||||
default:
|
||||
arg = (unsigned long)compat_ptr(arg);
|
||||
goto fallback;
|
||||
}
|
||||
out:
|
||||
unlock_kernel();
|
||||
return ret;
|
||||
|
||||
fallback:
|
||||
unlock_kernel();
|
||||
return vt_ioctl(tty, file, cmd, arg);
|
||||
}
|
||||
|
||||
|
||||
#endif /* CONFIG_COMPAT */
|
||||
|
||||
|
||||
/*
|
||||
* Performs the back end of a vt switch. Called under the console
|
||||
* semaphore.
|
||||
*/
|
||||
static void complete_change_console(struct vc_data *vc)
|
||||
{
|
||||
unsigned char old_vc_mode;
|
||||
int old = fg_console;
|
||||
|
||||
last_console = fg_console;
|
||||
|
||||
|
@ -1325,7 +1650,7 @@ static void complete_change_console(struct vc_data *vc)
|
|||
/*
|
||||
* Wake anyone waiting for their VT to activate
|
||||
*/
|
||||
vt_wake_waitactive();
|
||||
vt_event_post(VT_EVENT_SWITCH, old, vc->vc_num);
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -1398,3 +1723,58 @@ void change_console(struct vc_data *new_vc)
|
|||
|
||||
complete_change_console(new_vc);
|
||||
}
|
||||
|
||||
/* Perform a kernel triggered VT switch for suspend/resume */
|
||||
|
||||
static int disable_vt_switch;
|
||||
|
||||
int vt_move_to_console(unsigned int vt, int alloc)
|
||||
{
|
||||
int prev;
|
||||
|
||||
acquire_console_sem();
|
||||
/* Graphics mode - up to X */
|
||||
if (disable_vt_switch) {
|
||||
release_console_sem();
|
||||
return 0;
|
||||
}
|
||||
prev = fg_console;
|
||||
|
||||
if (alloc && vc_allocate(vt)) {
|
||||
/* we can't have a free VC for now. Too bad,
|
||||
* we don't want to mess the screen for now. */
|
||||
release_console_sem();
|
||||
return -ENOSPC;
|
||||
}
|
||||
|
||||
if (set_console(vt)) {
|
||||
/*
|
||||
* We're unable to switch to the SUSPEND_CONSOLE.
|
||||
* Let the calling function know so it can decide
|
||||
* what to do.
|
||||
*/
|
||||
release_console_sem();
|
||||
return -EIO;
|
||||
}
|
||||
release_console_sem();
|
||||
if (vt_waitactive(vt + 1)) {
|
||||
pr_debug("Suspend: Can't switch VCs.");
|
||||
return -EINTR;
|
||||
}
|
||||
return prev;
|
||||
}
|
||||
|
||||
/*
|
||||
* Normally during a suspend, we allocate a new console and switch to it.
|
||||
* When we resume, we switch back to the original console. This switch
|
||||
* can be slow, so on systems where the framebuffer can handle restoration
|
||||
* of video registers anyways, there's little point in doing the console
|
||||
* switch. This function allows you to disable it by passing it '0'.
|
||||
*/
|
||||
void pm_set_vt_switch(int do_switch)
|
||||
{
|
||||
acquire_console_sem();
|
||||
disable_vt_switch = !do_switch;
|
||||
release_console_sem();
|
||||
}
|
||||
EXPORT_SYMBOL(pm_set_vt_switch);
|
||||
|
|
|
@ -408,33 +408,28 @@ static int if_write_room(struct tty_struct *tty)
|
|||
return retval;
|
||||
}
|
||||
|
||||
/* FIXME: This function does not have error returns */
|
||||
|
||||
static int if_chars_in_buffer(struct tty_struct *tty)
|
||||
{
|
||||
struct cardstate *cs;
|
||||
int retval = -ENODEV;
|
||||
int retval = 0;
|
||||
|
||||
cs = (struct cardstate *) tty->driver_data;
|
||||
if (!cs) {
|
||||
pr_err("%s: no cardstate\n", __func__);
|
||||
return -ENODEV;
|
||||
return 0;
|
||||
}
|
||||
|
||||
gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
|
||||
|
||||
if (mutex_lock_interruptible(&cs->mutex))
|
||||
return -ERESTARTSYS; // FIXME -EINTR?
|
||||
mutex_lock(&cs->mutex);
|
||||
|
||||
if (!cs->connected) {
|
||||
if (!cs->connected)
|
||||
gig_dbg(DEBUG_IF, "not connected");
|
||||
retval = -ENODEV;
|
||||
} else if (!cs->open_count)
|
||||
else if (!cs->open_count)
|
||||
dev_warn(cs->dev, "%s: device not opened\n", __func__);
|
||||
else if (cs->mstate != MS_LOCKED) {
|
||||
else if (cs->mstate != MS_LOCKED)
|
||||
dev_warn(cs->dev, "can't write to unlocked device\n");
|
||||
retval = -EBUSY;
|
||||
} else
|
||||
else
|
||||
retval = cs->ops->chars_in_buffer(cs);
|
||||
|
||||
mutex_unlock(&cs->mutex);
|
||||
|
|
|
@ -616,6 +616,14 @@ static void sl_uninit(struct net_device *dev)
|
|||
sl_free_bufs(sl);
|
||||
}
|
||||
|
||||
/* Hook the destructor so we can free slip devices at the right point in time */
|
||||
static void sl_free_netdev(struct net_device *dev)
|
||||
{
|
||||
int i = dev->base_addr;
|
||||
free_netdev(dev);
|
||||
slip_devs[i] = NULL;
|
||||
}
|
||||
|
||||
static const struct net_device_ops sl_netdev_ops = {
|
||||
.ndo_init = sl_init,
|
||||
.ndo_uninit = sl_uninit,
|
||||
|
@ -634,7 +642,7 @@ static const struct net_device_ops sl_netdev_ops = {
|
|||
static void sl_setup(struct net_device *dev)
|
||||
{
|
||||
dev->netdev_ops = &sl_netdev_ops;
|
||||
dev->destructor = free_netdev;
|
||||
dev->destructor = sl_free_netdev;
|
||||
|
||||
dev->hard_header_len = 0;
|
||||
dev->addr_len = 0;
|
||||
|
@ -712,8 +720,6 @@ static void sl_sync(void)
|
|||
static struct slip *sl_alloc(dev_t line)
|
||||
{
|
||||
int i;
|
||||
int sel = -1;
|
||||
int score = -1;
|
||||
struct net_device *dev = NULL;
|
||||
struct slip *sl;
|
||||
|
||||
|
@ -724,55 +730,7 @@ static struct slip *sl_alloc(dev_t line)
|
|||
dev = slip_devs[i];
|
||||
if (dev == NULL)
|
||||
break;
|
||||
|
||||
sl = netdev_priv(dev);
|
||||
if (sl->leased) {
|
||||
if (sl->line != line)
|
||||
continue;
|
||||
if (sl->tty)
|
||||
return NULL;
|
||||
|
||||
/* Clear ESCAPE & ERROR flags */
|
||||
sl->flags &= (1 << SLF_INUSE);
|
||||
return sl;
|
||||
}
|
||||
|
||||
if (sl->tty)
|
||||
continue;
|
||||
|
||||
if (current->pid == sl->pid) {
|
||||
if (sl->line == line && score < 3) {
|
||||
sel = i;
|
||||
score = 3;
|
||||
continue;
|
||||
}
|
||||
if (score < 2) {
|
||||
sel = i;
|
||||
score = 2;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
if (sl->line == line && score < 1) {
|
||||
sel = i;
|
||||
score = 1;
|
||||
continue;
|
||||
}
|
||||
if (score < 0) {
|
||||
sel = i;
|
||||
score = 0;
|
||||
}
|
||||
}
|
||||
|
||||
if (sel >= 0) {
|
||||
i = sel;
|
||||
dev = slip_devs[i];
|
||||
if (score > 1) {
|
||||
sl = netdev_priv(dev);
|
||||
sl->flags &= (1 << SLF_INUSE);
|
||||
return sl;
|
||||
}
|
||||
}
|
||||
|
||||
/* Sorry, too many, all slots in use */
|
||||
if (i >= slip_maxdev)
|
||||
return NULL;
|
||||
|
@ -908,31 +866,14 @@ err_exit:
|
|||
return err;
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
FIXME: 1,2 are fixed 3 was never true anyway.
|
||||
|
||||
Let me to blame a bit.
|
||||
1. TTY module calls this funstion on soft interrupt.
|
||||
2. TTY module calls this function WITH MASKED INTERRUPTS!
|
||||
3. TTY module does not notify us about line discipline
|
||||
shutdown,
|
||||
|
||||
Seems, now it is clean. The solution is to consider netdevice and
|
||||
line discipline sides as two independent threads.
|
||||
|
||||
By-product (not desired): sl? does not feel hangups and remains open.
|
||||
It is supposed, that user level program (dip, diald, slattach...)
|
||||
will catch SIGHUP and make the rest of work.
|
||||
|
||||
I see no way to make more with current tty code. --ANK
|
||||
*/
|
||||
|
||||
/*
|
||||
* Close down a SLIP channel.
|
||||
* This means flushing out any pending queues, and then returning. This
|
||||
* call is serialized against other ldisc functions.
|
||||
*
|
||||
* We also use this method fo a hangup event
|
||||
*/
|
||||
|
||||
static void slip_close(struct tty_struct *tty)
|
||||
{
|
||||
struct slip *sl = tty->disc_data;
|
||||
|
@ -951,10 +892,16 @@ static void slip_close(struct tty_struct *tty)
|
|||
del_timer_sync(&sl->keepalive_timer);
|
||||
del_timer_sync(&sl->outfill_timer);
|
||||
#endif
|
||||
|
||||
/* Count references from TTY module */
|
||||
/* Flush network side */
|
||||
unregister_netdev(sl->dev);
|
||||
/* This will complete via sl_free_netdev */
|
||||
}
|
||||
|
||||
static int slip_hangup(struct tty_struct *tty)
|
||||
{
|
||||
slip_close(tty);
|
||||
return 0;
|
||||
}
|
||||
/************************************************************************
|
||||
* STANDARD SLIP ENCAPSULATION *
|
||||
************************************************************************/
|
||||
|
@ -1311,6 +1258,7 @@ static struct tty_ldisc_ops sl_ldisc = {
|
|||
.name = "slip",
|
||||
.open = slip_open,
|
||||
.close = slip_close,
|
||||
.hangup = slip_hangup,
|
||||
.ioctl = slip_ioctl,
|
||||
.receive_buf = slip_receive_buf,
|
||||
.write_wakeup = slip_write_wakeup,
|
||||
|
@ -1384,6 +1332,8 @@ static void __exit slip_exit(void)
|
|||
}
|
||||
} while (busy && time_before(jiffies, timeout));
|
||||
|
||||
/* FIXME: hangup is async so we should wait when doing this second
|
||||
phase */
|
||||
|
||||
for (i = 0; i < slip_maxdev; i++) {
|
||||
dev = slip_devs[i];
|
||||
|
|
|
@ -86,7 +86,7 @@ static void serial21285_enable_ms(struct uart_port *port)
|
|||
static irqreturn_t serial21285_rx_chars(int irq, void *dev_id)
|
||||
{
|
||||
struct uart_port *port = dev_id;
|
||||
struct tty_struct *tty = port->info->port.tty;
|
||||
struct tty_struct *tty = port->state->port.tty;
|
||||
unsigned int status, ch, flag, rxs, max_count = 256;
|
||||
|
||||
status = *CSR_UARTFLG;
|
||||
|
@ -124,7 +124,7 @@ static irqreturn_t serial21285_rx_chars(int irq, void *dev_id)
|
|||
static irqreturn_t serial21285_tx_chars(int irq, void *dev_id)
|
||||
{
|
||||
struct uart_port *port = dev_id;
|
||||
struct circ_buf *xmit = &port->info->xmit;
|
||||
struct circ_buf *xmit = &port->state->xmit;
|
||||
int count = 256;
|
||||
|
||||
if (port->x_char) {
|
||||
|
@ -235,8 +235,8 @@ serial21285_set_termios(struct uart_port *port, struct ktermios *termios,
|
|||
baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16);
|
||||
quot = uart_get_divisor(port, baud);
|
||||
|
||||
if (port->info && port->info->port.tty) {
|
||||
struct tty_struct *tty = port->info->port.tty;
|
||||
if (port->state && port->state->port.tty) {
|
||||
struct tty_struct *tty = port->state->port.tty;
|
||||
unsigned int b = port->uartclk / (16 * quot);
|
||||
tty_encode_baud_rate(tty, b, b);
|
||||
}
|
||||
|
|
|
@ -1382,7 +1382,7 @@ static void serial8250_enable_ms(struct uart_port *port)
|
|||
static void
|
||||
receive_chars(struct uart_8250_port *up, unsigned int *status)
|
||||
{
|
||||
struct tty_struct *tty = up->port.info->port.tty;
|
||||
struct tty_struct *tty = up->port.state->port.tty;
|
||||
unsigned char ch, lsr = *status;
|
||||
int max_count = 256;
|
||||
char flag;
|
||||
|
@ -1457,7 +1457,7 @@ ignore_char:
|
|||
|
||||
static void transmit_chars(struct uart_8250_port *up)
|
||||
{
|
||||
struct circ_buf *xmit = &up->port.info->xmit;
|
||||
struct circ_buf *xmit = &up->port.state->xmit;
|
||||
int count;
|
||||
|
||||
if (up->port.x_char) {
|
||||
|
@ -1500,7 +1500,7 @@ static unsigned int check_modem_status(struct uart_8250_port *up)
|
|||
status |= up->msr_saved_flags;
|
||||
up->msr_saved_flags = 0;
|
||||
if (status & UART_MSR_ANY_DELTA && up->ier & UART_IER_MSI &&
|
||||
up->port.info != NULL) {
|
||||
up->port.state != NULL) {
|
||||
if (status & UART_MSR_TERI)
|
||||
up->port.icount.rng++;
|
||||
if (status & UART_MSR_DDSR)
|
||||
|
@ -1510,7 +1510,7 @@ static unsigned int check_modem_status(struct uart_8250_port *up)
|
|||
if (status & UART_MSR_DCTS)
|
||||
uart_handle_cts_change(&up->port, status & UART_MSR_CTS);
|
||||
|
||||
wake_up_interruptible(&up->port.info->delta_msr_wait);
|
||||
wake_up_interruptible(&up->port.state->port.delta_msr_wait);
|
||||
}
|
||||
|
||||
return status;
|
||||
|
@ -1677,7 +1677,7 @@ static int serial_link_irq_chain(struct uart_8250_port *up)
|
|||
INIT_LIST_HEAD(&up->list);
|
||||
i->head = &up->list;
|
||||
spin_unlock_irq(&i->lock);
|
||||
|
||||
irq_flags |= up->port.irqflags;
|
||||
ret = request_irq(up->port.irq, serial8250_interrupt,
|
||||
irq_flags, "serial", i);
|
||||
if (ret < 0)
|
||||
|
@ -1764,7 +1764,7 @@ static void serial8250_backup_timeout(unsigned long data)
|
|||
up->lsr_saved_flags |= lsr & LSR_SAVE_FLAGS;
|
||||
spin_unlock_irqrestore(&up->port.lock, flags);
|
||||
if ((iir & UART_IIR_NO_INT) && (up->ier & UART_IER_THRI) &&
|
||||
(!uart_circ_empty(&up->port.info->xmit) || up->port.x_char) &&
|
||||
(!uart_circ_empty(&up->port.state->xmit) || up->port.x_char) &&
|
||||
(lsr & UART_LSR_THRE)) {
|
||||
iir &= ~(UART_IIR_ID | UART_IIR_NO_INT);
|
||||
iir |= UART_IIR_THRI;
|
||||
|
@ -2026,7 +2026,7 @@ static int serial8250_startup(struct uart_port *port)
|
|||
* allow register changes to become visible.
|
||||
*/
|
||||
spin_lock_irqsave(&up->port.lock, flags);
|
||||
if (up->port.flags & UPF_SHARE_IRQ)
|
||||
if (up->port.irqflags & IRQF_SHARED)
|
||||
disable_irq_nosync(up->port.irq);
|
||||
|
||||
wait_for_xmitr(up, UART_LSR_THRE);
|
||||
|
@ -2039,7 +2039,7 @@ static int serial8250_startup(struct uart_port *port)
|
|||
iir = serial_in(up, UART_IIR);
|
||||
serial_out(up, UART_IER, 0);
|
||||
|
||||
if (up->port.flags & UPF_SHARE_IRQ)
|
||||
if (up->port.irqflags & IRQF_SHARED)
|
||||
enable_irq(up->port.irq);
|
||||
spin_unlock_irqrestore(&up->port.lock, flags);
|
||||
|
||||
|
@ -2272,7 +2272,9 @@ serial8250_set_termios(struct uart_port *port, struct ktermios *termios,
|
|||
/*
|
||||
* Ask the core to calculate the divisor for us.
|
||||
*/
|
||||
baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16);
|
||||
baud = uart_get_baud_rate(port, termios, old,
|
||||
port->uartclk / 16 / 0xffff,
|
||||
port->uartclk / 16);
|
||||
quot = serial8250_get_divisor(port, baud);
|
||||
|
||||
/*
|
||||
|
@ -2671,6 +2673,7 @@ static void __init serial8250_isa_init_ports(void)
|
|||
i++, up++) {
|
||||
up->port.iobase = old_serial_port[i].port;
|
||||
up->port.irq = irq_canonicalize(old_serial_port[i].irq);
|
||||
up->port.irqflags = old_serial_port[i].irqflags;
|
||||
up->port.uartclk = old_serial_port[i].baud_base * 16;
|
||||
up->port.flags = old_serial_port[i].flags;
|
||||
up->port.hub6 = old_serial_port[i].hub6;
|
||||
|
@ -2679,7 +2682,7 @@ static void __init serial8250_isa_init_ports(void)
|
|||
up->port.regshift = old_serial_port[i].iomem_reg_shift;
|
||||
set_io_from_upio(&up->port);
|
||||
if (share_irqs)
|
||||
up->port.flags |= UPF_SHARE_IRQ;
|
||||
up->port.irqflags |= IRQF_SHARED;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -2869,6 +2872,7 @@ int __init early_serial_setup(struct uart_port *port)
|
|||
p->iobase = port->iobase;
|
||||
p->membase = port->membase;
|
||||
p->irq = port->irq;
|
||||
p->irqflags = port->irqflags;
|
||||
p->uartclk = port->uartclk;
|
||||
p->fifosize = port->fifosize;
|
||||
p->regshift = port->regshift;
|
||||
|
@ -2942,6 +2946,7 @@ static int __devinit serial8250_probe(struct platform_device *dev)
|
|||
port.iobase = p->iobase;
|
||||
port.membase = p->membase;
|
||||
port.irq = p->irq;
|
||||
port.irqflags = p->irqflags;
|
||||
port.uartclk = p->uartclk;
|
||||
port.regshift = p->regshift;
|
||||
port.iotype = p->iotype;
|
||||
|
@ -2954,7 +2959,7 @@ static int __devinit serial8250_probe(struct platform_device *dev)
|
|||
port.serial_out = p->serial_out;
|
||||
port.dev = &dev->dev;
|
||||
if (share_irqs)
|
||||
port.flags |= UPF_SHARE_IRQ;
|
||||
port.irqflags |= IRQF_SHARED;
|
||||
ret = serial8250_register_port(&port);
|
||||
if (ret < 0) {
|
||||
dev_err(&dev->dev, "unable to register port at index %d "
|
||||
|
@ -3096,6 +3101,7 @@ int serial8250_register_port(struct uart_port *port)
|
|||
uart->port.iobase = port->iobase;
|
||||
uart->port.membase = port->membase;
|
||||
uart->port.irq = port->irq;
|
||||
uart->port.irqflags = port->irqflags;
|
||||
uart->port.uartclk = port->uartclk;
|
||||
uart->port.fifosize = port->fifosize;
|
||||
uart->port.regshift = port->regshift;
|
||||
|
|
|
@ -25,6 +25,7 @@ struct old_serial_port {
|
|||
unsigned char io_type;
|
||||
unsigned char *iomem_base;
|
||||
unsigned short iomem_reg_shift;
|
||||
unsigned long irqflags;
|
||||
};
|
||||
|
||||
/*
|
||||
|
|
|
@ -117,7 +117,7 @@ static void pl010_enable_ms(struct uart_port *port)
|
|||
|
||||
static void pl010_rx_chars(struct uart_amba_port *uap)
|
||||
{
|
||||
struct tty_struct *tty = uap->port.info->port.tty;
|
||||
struct tty_struct *tty = uap->port.state->port.tty;
|
||||
unsigned int status, ch, flag, rsr, max_count = 256;
|
||||
|
||||
status = readb(uap->port.membase + UART01x_FR);
|
||||
|
@ -172,7 +172,7 @@ static void pl010_rx_chars(struct uart_amba_port *uap)
|
|||
|
||||
static void pl010_tx_chars(struct uart_amba_port *uap)
|
||||
{
|
||||
struct circ_buf *xmit = &uap->port.info->xmit;
|
||||
struct circ_buf *xmit = &uap->port.state->xmit;
|
||||
int count;
|
||||
|
||||
if (uap->port.x_char) {
|
||||
|
@ -225,7 +225,7 @@ static void pl010_modem_status(struct uart_amba_port *uap)
|
|||
if (delta & UART01x_FR_CTS)
|
||||
uart_handle_cts_change(&uap->port, status & UART01x_FR_CTS);
|
||||
|
||||
wake_up_interruptible(&uap->port.info->delta_msr_wait);
|
||||
wake_up_interruptible(&uap->port.state->port.delta_msr_wait);
|
||||
}
|
||||
|
||||
static irqreturn_t pl010_int(int irq, void *dev_id)
|
||||
|
|
|
@ -124,7 +124,7 @@ static void pl011_enable_ms(struct uart_port *port)
|
|||
|
||||
static void pl011_rx_chars(struct uart_amba_port *uap)
|
||||
{
|
||||
struct tty_struct *tty = uap->port.info->port.tty;
|
||||
struct tty_struct *tty = uap->port.state->port.tty;
|
||||
unsigned int status, ch, flag, max_count = 256;
|
||||
|
||||
status = readw(uap->port.membase + UART01x_FR);
|
||||
|
@ -175,7 +175,7 @@ static void pl011_rx_chars(struct uart_amba_port *uap)
|
|||
|
||||
static void pl011_tx_chars(struct uart_amba_port *uap)
|
||||
{
|
||||
struct circ_buf *xmit = &uap->port.info->xmit;
|
||||
struct circ_buf *xmit = &uap->port.state->xmit;
|
||||
int count;
|
||||
|
||||
if (uap->port.x_char) {
|
||||
|
@ -226,7 +226,7 @@ static void pl011_modem_status(struct uart_amba_port *uap)
|
|||
if (delta & UART01x_FR_CTS)
|
||||
uart_handle_cts_change(&uap->port, status & UART01x_FR_CTS);
|
||||
|
||||
wake_up_interruptible(&uap->port.info->delta_msr_wait);
|
||||
wake_up_interruptible(&uap->port.state->port.delta_msr_wait);
|
||||
}
|
||||
|
||||
static irqreturn_t pl011_int(int irq, void *dev_id)
|
||||
|
|
|
@ -427,7 +427,7 @@ static void atmel_rx_chars(struct uart_port *port)
|
|||
*/
|
||||
static void atmel_tx_chars(struct uart_port *port)
|
||||
{
|
||||
struct circ_buf *xmit = &port->info->xmit;
|
||||
struct circ_buf *xmit = &port->state->xmit;
|
||||
|
||||
if (port->x_char && UART_GET_CSR(port) & ATMEL_US_TXRDY) {
|
||||
UART_PUT_CHAR(port, port->x_char);
|
||||
|
@ -560,7 +560,7 @@ static irqreturn_t atmel_interrupt(int irq, void *dev_id)
|
|||
static void atmel_tx_dma(struct uart_port *port)
|
||||
{
|
||||
struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
|
||||
struct circ_buf *xmit = &port->info->xmit;
|
||||
struct circ_buf *xmit = &port->state->xmit;
|
||||
struct atmel_dma_buffer *pdc = &atmel_port->pdc_tx;
|
||||
int count;
|
||||
|
||||
|
@ -663,14 +663,14 @@ static void atmel_rx_from_ring(struct uart_port *port)
|
|||
* uart_start(), which takes the lock.
|
||||
*/
|
||||
spin_unlock(&port->lock);
|
||||
tty_flip_buffer_push(port->info->port.tty);
|
||||
tty_flip_buffer_push(port->state->port.tty);
|
||||
spin_lock(&port->lock);
|
||||
}
|
||||
|
||||
static void atmel_rx_from_dma(struct uart_port *port)
|
||||
{
|
||||
struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
|
||||
struct tty_struct *tty = port->info->port.tty;
|
||||
struct tty_struct *tty = port->state->port.tty;
|
||||
struct atmel_dma_buffer *pdc;
|
||||
int rx_idx = atmel_port->pdc_rx_idx;
|
||||
unsigned int head;
|
||||
|
@ -776,7 +776,7 @@ static void atmel_tasklet_func(unsigned long data)
|
|||
if (status_change & ATMEL_US_CTS)
|
||||
uart_handle_cts_change(port, !(status & ATMEL_US_CTS));
|
||||
|
||||
wake_up_interruptible(&port->info->delta_msr_wait);
|
||||
wake_up_interruptible(&port->state->port.delta_msr_wait);
|
||||
|
||||
atmel_port->irq_status_prev = status;
|
||||
}
|
||||
|
@ -795,7 +795,7 @@ static void atmel_tasklet_func(unsigned long data)
|
|||
static int atmel_startup(struct uart_port *port)
|
||||
{
|
||||
struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
|
||||
struct tty_struct *tty = port->info->port.tty;
|
||||
struct tty_struct *tty = port->state->port.tty;
|
||||
int retval;
|
||||
|
||||
/*
|
||||
|
@ -854,7 +854,7 @@ static int atmel_startup(struct uart_port *port)
|
|||
}
|
||||
if (atmel_use_dma_tx(port)) {
|
||||
struct atmel_dma_buffer *pdc = &atmel_port->pdc_tx;
|
||||
struct circ_buf *xmit = &port->info->xmit;
|
||||
struct circ_buf *xmit = &port->state->xmit;
|
||||
|
||||
pdc->buf = xmit->buf;
|
||||
pdc->dma_addr = dma_map_single(port->dev,
|
||||
|
|
|
@ -42,6 +42,10 @@
|
|||
# undef CONFIG_EARLY_PRINTK
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_SERIAL_BFIN_MODULE
|
||||
# undef CONFIG_EARLY_PRINTK
|
||||
#endif
|
||||
|
||||
/* UART name and device definitions */
|
||||
#define BFIN_SERIAL_NAME "ttyBF"
|
||||
#define BFIN_SERIAL_MAJOR 204
|
||||
|
@ -140,7 +144,7 @@ static void bfin_serial_stop_tx(struct uart_port *port)
|
|||
{
|
||||
struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
|
||||
#ifdef CONFIG_SERIAL_BFIN_DMA
|
||||
struct circ_buf *xmit = &uart->port.info->xmit;
|
||||
struct circ_buf *xmit = &uart->port.state->xmit;
|
||||
#endif
|
||||
|
||||
while (!(UART_GET_LSR(uart) & TEMT))
|
||||
|
@ -167,7 +171,7 @@ static void bfin_serial_stop_tx(struct uart_port *port)
|
|||
static void bfin_serial_start_tx(struct uart_port *port)
|
||||
{
|
||||
struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
|
||||
struct tty_struct *tty = uart->port.info->port.tty;
|
||||
struct tty_struct *tty = uart->port.state->port.tty;
|
||||
|
||||
#ifdef CONFIG_SERIAL_BFIN_HARD_CTSRTS
|
||||
if (uart->scts && !(bfin_serial_get_mctrl(&uart->port) & TIOCM_CTS)) {
|
||||
|
@ -239,10 +243,10 @@ static void bfin_serial_rx_chars(struct bfin_serial_port *uart)
|
|||
return;
|
||||
}
|
||||
|
||||
if (!uart->port.info || !uart->port.info->port.tty)
|
||||
if (!uart->port.state || !uart->port.state->port.tty)
|
||||
return;
|
||||
#endif
|
||||
tty = uart->port.info->port.tty;
|
||||
tty = uart->port.state->port.tty;
|
||||
|
||||
if (ANOMALY_05000363) {
|
||||
/* The BF533 (and BF561) family of processors have a nice anomaly
|
||||
|
@ -327,7 +331,7 @@ static void bfin_serial_rx_chars(struct bfin_serial_port *uart)
|
|||
|
||||
static void bfin_serial_tx_chars(struct bfin_serial_port *uart)
|
||||
{
|
||||
struct circ_buf *xmit = &uart->port.info->xmit;
|
||||
struct circ_buf *xmit = &uart->port.state->xmit;
|
||||
|
||||
if (uart_circ_empty(xmit) || uart_tx_stopped(&uart->port)) {
|
||||
#ifdef CONFIG_BF54x
|
||||
|
@ -394,7 +398,7 @@ static irqreturn_t bfin_serial_tx_int(int irq, void *dev_id)
|
|||
#ifdef CONFIG_SERIAL_BFIN_DMA
|
||||
static void bfin_serial_dma_tx_chars(struct bfin_serial_port *uart)
|
||||
{
|
||||
struct circ_buf *xmit = &uart->port.info->xmit;
|
||||
struct circ_buf *xmit = &uart->port.state->xmit;
|
||||
|
||||
uart->tx_done = 0;
|
||||
|
||||
|
@ -432,7 +436,7 @@ static void bfin_serial_dma_tx_chars(struct bfin_serial_port *uart)
|
|||
|
||||
static void bfin_serial_dma_rx_chars(struct bfin_serial_port *uart)
|
||||
{
|
||||
struct tty_struct *tty = uart->port.info->port.tty;
|
||||
struct tty_struct *tty = uart->port.state->port.tty;
|
||||
int i, flg, status;
|
||||
|
||||
status = UART_GET_LSR(uart);
|
||||
|
@ -525,7 +529,7 @@ void bfin_serial_rx_dma_timeout(struct bfin_serial_port *uart)
|
|||
static irqreturn_t bfin_serial_dma_tx_int(int irq, void *dev_id)
|
||||
{
|
||||
struct bfin_serial_port *uart = dev_id;
|
||||
struct circ_buf *xmit = &uart->port.info->xmit;
|
||||
struct circ_buf *xmit = &uart->port.state->xmit;
|
||||
|
||||
#ifdef CONFIG_SERIAL_BFIN_HARD_CTSRTS
|
||||
if (uart->scts && !(bfin_serial_get_mctrl(&uart->port)&TIOCM_CTS)) {
|
||||
|
@ -961,10 +965,10 @@ static void bfin_serial_set_ldisc(struct uart_port *port)
|
|||
int line = port->line;
|
||||
unsigned short val;
|
||||
|
||||
if (line >= port->info->port.tty->driver->num)
|
||||
if (line >= port->state->port.tty->driver->num)
|
||||
return;
|
||||
|
||||
switch (port->info->port.tty->termios->c_line) {
|
||||
switch (port->state->port.tty->termios->c_line) {
|
||||
case N_IRDA:
|
||||
val = UART_GET_GCTL(&bfin_serial_ports[line]);
|
||||
val |= (IREN | RPOLC);
|
||||
|
|
|
@ -178,7 +178,7 @@ static int sport_uart_setup(struct sport_uart_port *up, int sclk, int baud_rate)
|
|||
static irqreturn_t sport_uart_rx_irq(int irq, void *dev_id)
|
||||
{
|
||||
struct sport_uart_port *up = dev_id;
|
||||
struct tty_struct *tty = up->port.info->port.tty;
|
||||
struct tty_struct *tty = up->port.state->port.tty;
|
||||
unsigned int ch;
|
||||
|
||||
do {
|
||||
|
@ -205,7 +205,7 @@ static irqreturn_t sport_uart_tx_irq(int irq, void *dev_id)
|
|||
static irqreturn_t sport_uart_err_irq(int irq, void *dev_id)
|
||||
{
|
||||
struct sport_uart_port *up = dev_id;
|
||||
struct tty_struct *tty = up->port.info->port.tty;
|
||||
struct tty_struct *tty = up->port.state->port.tty;
|
||||
unsigned int stat = SPORT_GET_STAT(up);
|
||||
|
||||
/* Overflow in RX FIFO */
|
||||
|
@ -290,7 +290,7 @@ fail1:
|
|||
|
||||
static void sport_uart_tx_chars(struct sport_uart_port *up)
|
||||
{
|
||||
struct circ_buf *xmit = &up->port.info->xmit;
|
||||
struct circ_buf *xmit = &up->port.state->xmit;
|
||||
|
||||
if (SPORT_GET_STAT(up) & TXF)
|
||||
return;
|
||||
|
|
|
@ -93,7 +93,7 @@ static void clps711xuart_enable_ms(struct uart_port *port)
|
|||
static irqreturn_t clps711xuart_int_rx(int irq, void *dev_id)
|
||||
{
|
||||
struct uart_port *port = dev_id;
|
||||
struct tty_struct *tty = port->info->port.tty;
|
||||
struct tty_struct *tty = port->state->port.tty;
|
||||
unsigned int status, ch, flg;
|
||||
|
||||
status = clps_readl(SYSFLG(port));
|
||||
|
@ -147,7 +147,7 @@ static irqreturn_t clps711xuart_int_rx(int irq, void *dev_id)
|
|||
static irqreturn_t clps711xuart_int_tx(int irq, void *dev_id)
|
||||
{
|
||||
struct uart_port *port = dev_id;
|
||||
struct circ_buf *xmit = &port->info->xmit;
|
||||
struct circ_buf *xmit = &port->state->xmit;
|
||||
int count;
|
||||
|
||||
if (port->x_char) {
|
||||
|
|
|
@ -244,7 +244,7 @@ static void cpm_uart_int_rx(struct uart_port *port)
|
|||
int i;
|
||||
unsigned char ch;
|
||||
u8 *cp;
|
||||
struct tty_struct *tty = port->info->port.tty;
|
||||
struct tty_struct *tty = port->state->port.tty;
|
||||
struct uart_cpm_port *pinfo = (struct uart_cpm_port *)port;
|
||||
cbd_t __iomem *bdp;
|
||||
u16 status;
|
||||
|
|
|
@ -197,7 +197,7 @@ static inline void dz_receive_chars(struct dz_mux *mux)
|
|||
while ((status = dz_in(dport, DZ_RBUF)) & DZ_DVAL) {
|
||||
dport = &mux->dport[LINE(status)];
|
||||
uport = &dport->port;
|
||||
tty = uport->info->port.tty; /* point to the proper dev */
|
||||
tty = uport->state->port.tty; /* point to the proper dev */
|
||||
|
||||
ch = UCHAR(status); /* grab the char */
|
||||
flag = TTY_NORMAL;
|
||||
|
@ -249,7 +249,7 @@ static inline void dz_receive_chars(struct dz_mux *mux)
|
|||
}
|
||||
for (i = 0; i < DZ_NB_PORT; i++)
|
||||
if (lines_rx[i])
|
||||
tty_flip_buffer_push(mux->dport[i].port.info->port.tty);
|
||||
tty_flip_buffer_push(mux->dport[i].port.state->port.tty);
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -268,7 +268,7 @@ static inline void dz_transmit_chars(struct dz_mux *mux)
|
|||
|
||||
status = dz_in(dport, DZ_CSR);
|
||||
dport = &mux->dport[LINE(status)];
|
||||
xmit = &dport->port.info->xmit;
|
||||
xmit = &dport->port.state->xmit;
|
||||
|
||||
if (dport->port.x_char) { /* XON/XOFF chars */
|
||||
dz_out(dport, DZ_TDR, dport->port.x_char);
|
||||
|
|
|
@ -617,7 +617,7 @@ static void shutdown(struct icom_port *icom_port)
|
|||
* disable break condition
|
||||
*/
|
||||
cmdReg = readb(&icom_port->dram->CmdReg);
|
||||
if ((cmdReg | CMD_SND_BREAK) == CMD_SND_BREAK) {
|
||||
if (cmdReg & CMD_SND_BREAK) {
|
||||
writeb(cmdReg & ~CMD_SND_BREAK, &icom_port->dram->CmdReg);
|
||||
}
|
||||
}
|
||||
|
@ -627,7 +627,7 @@ static int icom_write(struct uart_port *port)
|
|||
unsigned long data_count;
|
||||
unsigned char cmdReg;
|
||||
unsigned long offset;
|
||||
int temp_tail = port->info->xmit.tail;
|
||||
int temp_tail = port->state->xmit.tail;
|
||||
|
||||
trace(ICOM_PORT, "WRITE", 0);
|
||||
|
||||
|
@ -638,11 +638,11 @@ static int icom_write(struct uart_port *port)
|
|||
}
|
||||
|
||||
data_count = 0;
|
||||
while ((port->info->xmit.head != temp_tail) &&
|
||||
while ((port->state->xmit.head != temp_tail) &&
|
||||
(data_count <= XMIT_BUFF_SZ)) {
|
||||
|
||||
ICOM_PORT->xmit_buf[data_count++] =
|
||||
port->info->xmit.buf[temp_tail];
|
||||
port->state->xmit.buf[temp_tail];
|
||||
|
||||
temp_tail++;
|
||||
temp_tail &= (UART_XMIT_SIZE - 1);
|
||||
|
@ -694,8 +694,8 @@ static inline void check_modem_status(struct icom_port *icom_port)
|
|||
uart_handle_cts_change(&icom_port->uart_port,
|
||||
delta_status & ICOM_CTS);
|
||||
|
||||
wake_up_interruptible(&icom_port->uart_port.info->
|
||||
delta_msr_wait);
|
||||
wake_up_interruptible(&icom_port->uart_port.state->
|
||||
port.delta_msr_wait);
|
||||
old_status = status;
|
||||
}
|
||||
spin_unlock(&icom_port->uart_port.lock);
|
||||
|
@ -718,10 +718,10 @@ static void xmit_interrupt(u16 port_int_reg, struct icom_port *icom_port)
|
|||
icom_port->uart_port.icount.tx += count;
|
||||
|
||||
for (i=0; i<count &&
|
||||
!uart_circ_empty(&icom_port->uart_port.info->xmit); i++) {
|
||||
!uart_circ_empty(&icom_port->uart_port.state->xmit); i++) {
|
||||
|
||||
icom_port->uart_port.info->xmit.tail++;
|
||||
icom_port->uart_port.info->xmit.tail &=
|
||||
icom_port->uart_port.state->xmit.tail++;
|
||||
icom_port->uart_port.state->xmit.tail &=
|
||||
(UART_XMIT_SIZE - 1);
|
||||
}
|
||||
|
||||
|
@ -735,7 +735,7 @@ static void xmit_interrupt(u16 port_int_reg, struct icom_port *icom_port)
|
|||
static void recv_interrupt(u16 port_int_reg, struct icom_port *icom_port)
|
||||
{
|
||||
short int count, rcv_buff;
|
||||
struct tty_struct *tty = icom_port->uart_port.info->port.tty;
|
||||
struct tty_struct *tty = icom_port->uart_port.state->port.tty;
|
||||
unsigned short int status;
|
||||
struct uart_icount *icount;
|
||||
unsigned long offset;
|
||||
|
|
|
@ -224,7 +224,7 @@ static void imx_mctrl_check(struct imx_port *sport)
|
|||
if (changed & TIOCM_CTS)
|
||||
uart_handle_cts_change(&sport->port, status & TIOCM_CTS);
|
||||
|
||||
wake_up_interruptible(&sport->port.info->delta_msr_wait);
|
||||
wake_up_interruptible(&sport->port.state->port.delta_msr_wait);
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -236,7 +236,7 @@ static void imx_timeout(unsigned long data)
|
|||
struct imx_port *sport = (struct imx_port *)data;
|
||||
unsigned long flags;
|
||||
|
||||
if (sport->port.info) {
|
||||
if (sport->port.state) {
|
||||
spin_lock_irqsave(&sport->port.lock, flags);
|
||||
imx_mctrl_check(sport);
|
||||
spin_unlock_irqrestore(&sport->port.lock, flags);
|
||||
|
@ -323,7 +323,7 @@ static void imx_enable_ms(struct uart_port *port)
|
|||
|
||||
static inline void imx_transmit_buffer(struct imx_port *sport)
|
||||
{
|
||||
struct circ_buf *xmit = &sport->port.info->xmit;
|
||||
struct circ_buf *xmit = &sport->port.state->xmit;
|
||||
|
||||
while (!(readl(sport->port.membase + UTS) & UTS_TXFULL)) {
|
||||
/* send xmit->buf[xmit->tail]
|
||||
|
@ -388,7 +388,7 @@ static irqreturn_t imx_rtsint(int irq, void *dev_id)
|
|||
|
||||
writel(USR1_RTSD, sport->port.membase + USR1);
|
||||
uart_handle_cts_change(&sport->port, !!val);
|
||||
wake_up_interruptible(&sport->port.info->delta_msr_wait);
|
||||
wake_up_interruptible(&sport->port.state->port.delta_msr_wait);
|
||||
|
||||
spin_unlock_irqrestore(&sport->port.lock, flags);
|
||||
return IRQ_HANDLED;
|
||||
|
@ -397,7 +397,7 @@ static irqreturn_t imx_rtsint(int irq, void *dev_id)
|
|||
static irqreturn_t imx_txint(int irq, void *dev_id)
|
||||
{
|
||||
struct imx_port *sport = dev_id;
|
||||
struct circ_buf *xmit = &sport->port.info->xmit;
|
||||
struct circ_buf *xmit = &sport->port.state->xmit;
|
||||
unsigned long flags;
|
||||
|
||||
spin_lock_irqsave(&sport->port.lock,flags);
|
||||
|
@ -427,7 +427,7 @@ static irqreturn_t imx_rxint(int irq, void *dev_id)
|
|||
{
|
||||
struct imx_port *sport = dev_id;
|
||||
unsigned int rx,flg,ignored = 0;
|
||||
struct tty_struct *tty = sport->port.info->port.tty;
|
||||
struct tty_struct *tty = sport->port.state->port.tty;
|
||||
unsigned long flags, temp;
|
||||
|
||||
spin_lock_irqsave(&sport->port.lock,flags);
|
||||
|
@ -900,11 +900,11 @@ imx_set_termios(struct uart_port *port, struct ktermios *termios,
|
|||
rational_best_approximation(16 * div * baud, sport->port.uartclk,
|
||||
1 << 16, 1 << 16, &num, &denom);
|
||||
|
||||
if (port->info && port->info->port.tty) {
|
||||
if (port->state && port->state->port.tty) {
|
||||
tdiv64 = sport->port.uartclk;
|
||||
tdiv64 *= num;
|
||||
do_div(tdiv64, denom * 16 * div);
|
||||
tty_encode_baud_rate(sport->port.info->port.tty,
|
||||
tty_encode_baud_rate(sport->port.state->port.tty,
|
||||
(speed_t)tdiv64, (speed_t)tdiv64);
|
||||
}
|
||||
|
||||
|
|
|
@ -897,25 +897,25 @@ static void transmit_chars(struct uart_port *the_port)
|
|||
char *start;
|
||||
struct tty_struct *tty;
|
||||
struct ioc3_port *port = get_ioc3_port(the_port);
|
||||
struct uart_info *info;
|
||||
struct uart_state *state;
|
||||
|
||||
if (!the_port)
|
||||
return;
|
||||
if (!port)
|
||||
return;
|
||||
|
||||
info = the_port->info;
|
||||
tty = info->port.tty;
|
||||
state = the_port->state;
|
||||
tty = state->port.tty;
|
||||
|
||||
if (uart_circ_empty(&info->xmit) || uart_tx_stopped(the_port)) {
|
||||
if (uart_circ_empty(&state->xmit) || uart_tx_stopped(the_port)) {
|
||||
/* Nothing to do or hw stopped */
|
||||
set_notification(port, N_ALL_OUTPUT, 0);
|
||||
return;
|
||||
}
|
||||
|
||||
head = info->xmit.head;
|
||||
tail = info->xmit.tail;
|
||||
start = (char *)&info->xmit.buf[tail];
|
||||
head = state->xmit.head;
|
||||
tail = state->xmit.tail;
|
||||
start = (char *)&state->xmit.buf[tail];
|
||||
|
||||
/* write out all the data or until the end of the buffer */
|
||||
xmit_count = (head < tail) ? (UART_XMIT_SIZE - tail) : (head - tail);
|
||||
|
@ -928,14 +928,14 @@ static void transmit_chars(struct uart_port *the_port)
|
|||
/* advance the pointers */
|
||||
tail += result;
|
||||
tail &= UART_XMIT_SIZE - 1;
|
||||
info->xmit.tail = tail;
|
||||
start = (char *)&info->xmit.buf[tail];
|
||||
state->xmit.tail = tail;
|
||||
start = (char *)&state->xmit.buf[tail];
|
||||
}
|
||||
}
|
||||
if (uart_circ_chars_pending(&info->xmit) < WAKEUP_CHARS)
|
||||
if (uart_circ_chars_pending(&state->xmit) < WAKEUP_CHARS)
|
||||
uart_write_wakeup(the_port);
|
||||
|
||||
if (uart_circ_empty(&info->xmit)) {
|
||||
if (uart_circ_empty(&state->xmit)) {
|
||||
set_notification(port, N_OUTPUT_LOWAT, 0);
|
||||
} else {
|
||||
set_notification(port, N_OUTPUT_LOWAT, 1);
|
||||
|
@ -956,7 +956,7 @@ ioc3_change_speed(struct uart_port *the_port,
|
|||
unsigned int cflag;
|
||||
int baud;
|
||||
int new_parity = 0, new_parity_enable = 0, new_stop = 0, new_data = 8;
|
||||
struct uart_info *info = the_port->info;
|
||||
struct uart_state *state = the_port->state;
|
||||
|
||||
cflag = new_termios->c_cflag;
|
||||
|
||||
|
@ -997,14 +997,14 @@ ioc3_change_speed(struct uart_port *the_port,
|
|||
|
||||
the_port->ignore_status_mask = N_ALL_INPUT;
|
||||
|
||||
info->port.tty->low_latency = 1;
|
||||
state->port.tty->low_latency = 1;
|
||||
|
||||
if (I_IGNPAR(info->port.tty))
|
||||
if (I_IGNPAR(state->port.tty))
|
||||
the_port->ignore_status_mask &= ~(N_PARITY_ERROR
|
||||
| N_FRAMING_ERROR);
|
||||
if (I_IGNBRK(info->port.tty)) {
|
||||
if (I_IGNBRK(state->port.tty)) {
|
||||
the_port->ignore_status_mask &= ~N_BREAK;
|
||||
if (I_IGNPAR(info->port.tty))
|
||||
if (I_IGNPAR(state->port.tty))
|
||||
the_port->ignore_status_mask &= ~N_OVERRUN_ERROR;
|
||||
}
|
||||
if (!(cflag & CREAD)) {
|
||||
|
@ -1286,8 +1286,8 @@ static inline int do_read(struct uart_port *the_port, char *buf, int len)
|
|||
uart_handle_dcd_change
|
||||
(port->ip_port, 0);
|
||||
wake_up_interruptible
|
||||
(&the_port->info->
|
||||
delta_msr_wait);
|
||||
(&the_port->state->
|
||||
port.delta_msr_wait);
|
||||
}
|
||||
|
||||
/* If we had any data to return, we
|
||||
|
@ -1392,21 +1392,21 @@ static int receive_chars(struct uart_port *the_port)
|
|||
struct tty_struct *tty;
|
||||
unsigned char ch[MAX_CHARS];
|
||||
int read_count = 0, read_room, flip = 0;
|
||||
struct uart_info *info = the_port->info;
|
||||
struct uart_state *state = the_port->state;
|
||||
struct ioc3_port *port = get_ioc3_port(the_port);
|
||||
unsigned long pflags;
|
||||
|
||||
/* Make sure all the pointers are "good" ones */
|
||||
if (!info)
|
||||
if (!state)
|
||||
return 0;
|
||||
if (!info->port.tty)
|
||||
if (!state->port.tty)
|
||||
return 0;
|
||||
|
||||
if (!(port->ip_flags & INPUT_ENABLE))
|
||||
return 0;
|
||||
|
||||
spin_lock_irqsave(&the_port->lock, pflags);
|
||||
tty = info->port.tty;
|
||||
tty = state->port.tty;
|
||||
|
||||
read_count = do_read(the_port, ch, MAX_CHARS);
|
||||
if (read_count > 0) {
|
||||
|
@ -1491,7 +1491,7 @@ ioc3uart_intr_one(struct ioc3_submodule *is,
|
|||
uart_handle_dcd_change(the_port,
|
||||
shadow & SHADOW_DCD);
|
||||
wake_up_interruptible
|
||||
(&the_port->info->delta_msr_wait);
|
||||
(&the_port->state->port.delta_msr_wait);
|
||||
} else if ((port->ip_notify & N_DDCD)
|
||||
&& !(shadow & SHADOW_DCD)) {
|
||||
/* Flag delta DCD/no DCD */
|
||||
|
@ -1511,7 +1511,7 @@ ioc3uart_intr_one(struct ioc3_submodule *is,
|
|||
uart_handle_cts_change(the_port, shadow
|
||||
& SHADOW_CTS);
|
||||
wake_up_interruptible
|
||||
(&the_port->info->delta_msr_wait);
|
||||
(&the_port->state->port.delta_msr_wait);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1721,14 +1721,14 @@ static void ic3_shutdown(struct uart_port *the_port)
|
|||
{
|
||||
unsigned long port_flags;
|
||||
struct ioc3_port *port;
|
||||
struct uart_info *info;
|
||||
struct uart_state *state;
|
||||
|
||||
port = get_ioc3_port(the_port);
|
||||
if (!port)
|
||||
return;
|
||||
|
||||
info = the_port->info;
|
||||
wake_up_interruptible(&info->delta_msr_wait);
|
||||
state = the_port->state;
|
||||
wake_up_interruptible(&state->port.delta_msr_wait);
|
||||
|
||||
spin_lock_irqsave(&the_port->lock, port_flags);
|
||||
set_notification(port, N_ALL, 0);
|
||||
|
|
|
@ -1627,25 +1627,25 @@ static void transmit_chars(struct uart_port *the_port)
|
|||
char *start;
|
||||
struct tty_struct *tty;
|
||||
struct ioc4_port *port = get_ioc4_port(the_port, 0);
|
||||
struct uart_info *info;
|
||||
struct uart_state *state;
|
||||
|
||||
if (!the_port)
|
||||
return;
|
||||
if (!port)
|
||||
return;
|
||||
|
||||
info = the_port->info;
|
||||
tty = info->port.tty;
|
||||
state = the_port->state;
|
||||
tty = state->port.tty;
|
||||
|
||||
if (uart_circ_empty(&info->xmit) || uart_tx_stopped(the_port)) {
|
||||
if (uart_circ_empty(&state->xmit) || uart_tx_stopped(the_port)) {
|
||||
/* Nothing to do or hw stopped */
|
||||
set_notification(port, N_ALL_OUTPUT, 0);
|
||||
return;
|
||||
}
|
||||
|
||||
head = info->xmit.head;
|
||||
tail = info->xmit.tail;
|
||||
start = (char *)&info->xmit.buf[tail];
|
||||
head = state->xmit.head;
|
||||
tail = state->xmit.tail;
|
||||
start = (char *)&state->xmit.buf[tail];
|
||||
|
||||
/* write out all the data or until the end of the buffer */
|
||||
xmit_count = (head < tail) ? (UART_XMIT_SIZE - tail) : (head - tail);
|
||||
|
@ -1658,14 +1658,14 @@ static void transmit_chars(struct uart_port *the_port)
|
|||
/* advance the pointers */
|
||||
tail += result;
|
||||
tail &= UART_XMIT_SIZE - 1;
|
||||
info->xmit.tail = tail;
|
||||
start = (char *)&info->xmit.buf[tail];
|
||||
state->xmit.tail = tail;
|
||||
start = (char *)&state->xmit.buf[tail];
|
||||
}
|
||||
}
|
||||
if (uart_circ_chars_pending(&info->xmit) < WAKEUP_CHARS)
|
||||
if (uart_circ_chars_pending(&state->xmit) < WAKEUP_CHARS)
|
||||
uart_write_wakeup(the_port);
|
||||
|
||||
if (uart_circ_empty(&info->xmit)) {
|
||||
if (uart_circ_empty(&state->xmit)) {
|
||||
set_notification(port, N_OUTPUT_LOWAT, 0);
|
||||
} else {
|
||||
set_notification(port, N_OUTPUT_LOWAT, 1);
|
||||
|
@ -1686,7 +1686,7 @@ ioc4_change_speed(struct uart_port *the_port,
|
|||
int baud, bits;
|
||||
unsigned cflag;
|
||||
int new_parity = 0, new_parity_enable = 0, new_stop = 0, new_data = 8;
|
||||
struct uart_info *info = the_port->info;
|
||||
struct uart_state *state = the_port->state;
|
||||
|
||||
cflag = new_termios->c_cflag;
|
||||
|
||||
|
@ -1738,14 +1738,14 @@ ioc4_change_speed(struct uart_port *the_port,
|
|||
|
||||
the_port->ignore_status_mask = N_ALL_INPUT;
|
||||
|
||||
info->port.tty->low_latency = 1;
|
||||
state->port.tty->low_latency = 1;
|
||||
|
||||
if (I_IGNPAR(info->port.tty))
|
||||
if (I_IGNPAR(state->port.tty))
|
||||
the_port->ignore_status_mask &= ~(N_PARITY_ERROR
|
||||
| N_FRAMING_ERROR);
|
||||
if (I_IGNBRK(info->port.tty)) {
|
||||
if (I_IGNBRK(state->port.tty)) {
|
||||
the_port->ignore_status_mask &= ~N_BREAK;
|
||||
if (I_IGNPAR(info->port.tty))
|
||||
if (I_IGNPAR(state->port.tty))
|
||||
the_port->ignore_status_mask &= ~N_OVERRUN_ERROR;
|
||||
}
|
||||
if (!(cflag & CREAD)) {
|
||||
|
@ -1784,7 +1784,7 @@ ioc4_change_speed(struct uart_port *the_port,
|
|||
static inline int ic4_startup_local(struct uart_port *the_port)
|
||||
{
|
||||
struct ioc4_port *port;
|
||||
struct uart_info *info;
|
||||
struct uart_state *state;
|
||||
|
||||
if (!the_port)
|
||||
return -1;
|
||||
|
@ -1793,7 +1793,7 @@ static inline int ic4_startup_local(struct uart_port *the_port)
|
|||
if (!port)
|
||||
return -1;
|
||||
|
||||
info = the_port->info;
|
||||
state = the_port->state;
|
||||
|
||||
local_open(port);
|
||||
|
||||
|
@ -1801,7 +1801,7 @@ static inline int ic4_startup_local(struct uart_port *the_port)
|
|||
ioc4_set_proto(port, the_port->mapbase);
|
||||
|
||||
/* set the speed of the serial port */
|
||||
ioc4_change_speed(the_port, info->port.tty->termios,
|
||||
ioc4_change_speed(the_port, state->port.tty->termios,
|
||||
(struct ktermios *)0);
|
||||
|
||||
return 0;
|
||||
|
@ -1882,7 +1882,7 @@ static void handle_intr(void *arg, uint32_t sio_ir)
|
|||
the_port = port->ip_port;
|
||||
the_port->icount.dcd = 1;
|
||||
wake_up_interruptible
|
||||
(&the_port-> info->delta_msr_wait);
|
||||
(&the_port->state->port.delta_msr_wait);
|
||||
} else if ((port->ip_notify & N_DDCD)
|
||||
&& !(shadow & IOC4_SHADOW_DCD)) {
|
||||
/* Flag delta DCD/no DCD */
|
||||
|
@ -1904,7 +1904,7 @@ static void handle_intr(void *arg, uint32_t sio_ir)
|
|||
the_port->icount.cts =
|
||||
(shadow & IOC4_SHADOW_CTS) ? 1 : 0;
|
||||
wake_up_interruptible
|
||||
(&the_port->info->delta_msr_wait);
|
||||
(&the_port->state->port.delta_msr_wait);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -2236,8 +2236,8 @@ static inline int do_read(struct uart_port *the_port, unsigned char *buf,
|
|||
&& port->ip_port) {
|
||||
the_port->icount.dcd = 0;
|
||||
wake_up_interruptible
|
||||
(&the_port->info->
|
||||
delta_msr_wait);
|
||||
(&the_port->state->
|
||||
port.delta_msr_wait);
|
||||
}
|
||||
|
||||
/* If we had any data to return, we
|
||||
|
@ -2341,17 +2341,17 @@ static void receive_chars(struct uart_port *the_port)
|
|||
unsigned char ch[IOC4_MAX_CHARS];
|
||||
int read_count, request_count = IOC4_MAX_CHARS;
|
||||
struct uart_icount *icount;
|
||||
struct uart_info *info = the_port->info;
|
||||
struct uart_state *state = the_port->state;
|
||||
unsigned long pflags;
|
||||
|
||||
/* Make sure all the pointers are "good" ones */
|
||||
if (!info)
|
||||
if (!state)
|
||||
return;
|
||||
if (!info->port.tty)
|
||||
if (!state->port.tty)
|
||||
return;
|
||||
|
||||
spin_lock_irqsave(&the_port->lock, pflags);
|
||||
tty = info->port.tty;
|
||||
tty = state->port.tty;
|
||||
|
||||
request_count = tty_buffer_request_room(tty, IOC4_MAX_CHARS);
|
||||
|
||||
|
@ -2430,19 +2430,19 @@ static void ic4_shutdown(struct uart_port *the_port)
|
|||
{
|
||||
unsigned long port_flags;
|
||||
struct ioc4_port *port;
|
||||
struct uart_info *info;
|
||||
struct uart_state *state;
|
||||
|
||||
port = get_ioc4_port(the_port, 0);
|
||||
if (!port)
|
||||
return;
|
||||
|
||||
info = the_port->info;
|
||||
state = the_port->state;
|
||||
port->ip_port = NULL;
|
||||
|
||||
wake_up_interruptible(&info->delta_msr_wait);
|
||||
wake_up_interruptible(&state->port.delta_msr_wait);
|
||||
|
||||
if (info->port.tty)
|
||||
set_bit(TTY_IO_ERROR, &info->port.tty->flags);
|
||||
if (state->port.tty)
|
||||
set_bit(TTY_IO_ERROR, &state->port.tty->flags);
|
||||
|
||||
spin_lock_irqsave(&the_port->lock, port_flags);
|
||||
set_notification(port, N_ALL, 0);
|
||||
|
@ -2538,7 +2538,7 @@ static int ic4_startup(struct uart_port *the_port)
|
|||
int retval;
|
||||
struct ioc4_port *port;
|
||||
struct ioc4_control *control;
|
||||
struct uart_info *info;
|
||||
struct uart_state *state;
|
||||
unsigned long port_flags;
|
||||
|
||||
if (!the_port)
|
||||
|
@ -2546,7 +2546,7 @@ static int ic4_startup(struct uart_port *the_port)
|
|||
port = get_ioc4_port(the_port, 1);
|
||||
if (!port)
|
||||
return -ENODEV;
|
||||
info = the_port->info;
|
||||
state = the_port->state;
|
||||
|
||||
control = port->ip_control;
|
||||
if (!control) {
|
||||
|
|
|
@ -256,9 +256,9 @@ static struct tty_struct *ip22zilog_receive_chars(struct uart_ip22zilog_port *up
|
|||
unsigned int r1;
|
||||
|
||||
tty = NULL;
|
||||
if (up->port.info != NULL &&
|
||||
up->port.info->port.tty != NULL)
|
||||
tty = up->port.info->port.tty;
|
||||
if (up->port.state != NULL &&
|
||||
up->port.state->port.tty != NULL)
|
||||
tty = up->port.state->port.tty;
|
||||
|
||||
for (;;) {
|
||||
ch = readb(&channel->control);
|
||||
|
@ -354,7 +354,7 @@ static void ip22zilog_status_handle(struct uart_ip22zilog_port *up,
|
|||
uart_handle_cts_change(&up->port,
|
||||
(status & CTS));
|
||||
|
||||
wake_up_interruptible(&up->port.info->delta_msr_wait);
|
||||
wake_up_interruptible(&up->port.state->port.delta_msr_wait);
|
||||
}
|
||||
|
||||
up->prev_status = status;
|
||||
|
@ -404,9 +404,9 @@ static void ip22zilog_transmit_chars(struct uart_ip22zilog_port *up,
|
|||
return;
|
||||
}
|
||||
|
||||
if (up->port.info == NULL)
|
||||
if (up->port.state == NULL)
|
||||
goto ack_tx_int;
|
||||
xmit = &up->port.info->xmit;
|
||||
xmit = &up->port.state->xmit;
|
||||
if (uart_circ_empty(xmit))
|
||||
goto ack_tx_int;
|
||||
if (uart_tx_stopped(&up->port))
|
||||
|
@ -607,7 +607,7 @@ static void ip22zilog_start_tx(struct uart_port *port)
|
|||
port->icount.tx++;
|
||||
port->x_char = 0;
|
||||
} else {
|
||||
struct circ_buf *xmit = &port->info->xmit;
|
||||
struct circ_buf *xmit = &port->state->xmit;
|
||||
|
||||
writeb(xmit->buf[xmit->tail], &channel->data);
|
||||
ZSDELAY();
|
||||
|
|
|
@ -989,7 +989,7 @@ static void neo_param(struct jsm_channel *ch)
|
|||
{ 50, B50 },
|
||||
};
|
||||
|
||||
cflag = C_BAUD(ch->uart_port.info->port.tty);
|
||||
cflag = C_BAUD(ch->uart_port.state->port.tty);
|
||||
baud = 9600;
|
||||
for (i = 0; i < ARRAY_SIZE(baud_rates); i++) {
|
||||
if (baud_rates[i].cflag == cflag) {
|
||||
|
|
|
@ -147,7 +147,7 @@ static void jsm_tty_send_xchar(struct uart_port *port, char ch)
|
|||
struct ktermios *termios;
|
||||
|
||||
spin_lock_irqsave(&port->lock, lock_flags);
|
||||
termios = port->info->port.tty->termios;
|
||||
termios = port->state->port.tty->termios;
|
||||
if (ch == termios->c_cc[VSTART])
|
||||
channel->ch_bd->bd_ops->send_start_character(channel);
|
||||
|
||||
|
@ -245,7 +245,7 @@ static int jsm_tty_open(struct uart_port *port)
|
|||
channel->ch_cached_lsr = 0;
|
||||
channel->ch_stops_sent = 0;
|
||||
|
||||
termios = port->info->port.tty->termios;
|
||||
termios = port->state->port.tty->termios;
|
||||
channel->ch_c_cflag = termios->c_cflag;
|
||||
channel->ch_c_iflag = termios->c_iflag;
|
||||
channel->ch_c_oflag = termios->c_oflag;
|
||||
|
@ -278,7 +278,7 @@ static void jsm_tty_close(struct uart_port *port)
|
|||
jsm_printk(CLOSE, INFO, &channel->ch_bd->pci_dev, "start\n");
|
||||
|
||||
bd = channel->ch_bd;
|
||||
ts = port->info->port.tty->termios;
|
||||
ts = port->state->port.tty->termios;
|
||||
|
||||
channel->ch_flags &= ~(CH_STOPI);
|
||||
|
||||
|
@ -530,7 +530,7 @@ void jsm_input(struct jsm_channel *ch)
|
|||
if (!ch)
|
||||
return;
|
||||
|
||||
tp = ch->uart_port.info->port.tty;
|
||||
tp = ch->uart_port.state->port.tty;
|
||||
|
||||
bd = ch->ch_bd;
|
||||
if(!bd)
|
||||
|
@ -849,7 +849,7 @@ int jsm_tty_write(struct uart_port *port)
|
|||
u16 tail;
|
||||
u16 tmask;
|
||||
u32 remain;
|
||||
int temp_tail = port->info->xmit.tail;
|
||||
int temp_tail = port->state->xmit.tail;
|
||||
struct jsm_channel *channel = (struct jsm_channel *)port;
|
||||
|
||||
tmask = WQUEUEMASK;
|
||||
|
@ -865,10 +865,10 @@ int jsm_tty_write(struct uart_port *port)
|
|||
data_count = 0;
|
||||
if (bufcount >= remain) {
|
||||
bufcount -= remain;
|
||||
while ((port->info->xmit.head != temp_tail) &&
|
||||
while ((port->state->xmit.head != temp_tail) &&
|
||||
(data_count < remain)) {
|
||||
channel->ch_wqueue[head++] =
|
||||
port->info->xmit.buf[temp_tail];
|
||||
port->state->xmit.buf[temp_tail];
|
||||
|
||||
temp_tail++;
|
||||
temp_tail &= (UART_XMIT_SIZE - 1);
|
||||
|
@ -880,10 +880,10 @@ int jsm_tty_write(struct uart_port *port)
|
|||
data_count1 = 0;
|
||||
if (bufcount > 0) {
|
||||
remain = bufcount;
|
||||
while ((port->info->xmit.head != temp_tail) &&
|
||||
while ((port->state->xmit.head != temp_tail) &&
|
||||
(data_count1 < remain)) {
|
||||
channel->ch_wqueue[head++] =
|
||||
port->info->xmit.buf[temp_tail];
|
||||
port->state->xmit.buf[temp_tail];
|
||||
|
||||
temp_tail++;
|
||||
temp_tail &= (UART_XMIT_SIZE - 1);
|
||||
|
@ -892,7 +892,7 @@ int jsm_tty_write(struct uart_port *port)
|
|||
}
|
||||
}
|
||||
|
||||
port->info->xmit.tail = temp_tail;
|
||||
port->state->xmit.tail = temp_tail;
|
||||
|
||||
data_count += data_count1;
|
||||
if (data_count) {
|
||||
|
|
|
@ -286,7 +286,7 @@ static void m32r_sio_start_tx(struct uart_port *port)
|
|||
{
|
||||
#ifdef CONFIG_SERIAL_M32R_PLDSIO
|
||||
struct uart_sio_port *up = (struct uart_sio_port *)port;
|
||||
struct circ_buf *xmit = &up->port.info->xmit;
|
||||
struct circ_buf *xmit = &up->port.state->xmit;
|
||||
|
||||
if (!(up->ier & UART_IER_THRI)) {
|
||||
up->ier |= UART_IER_THRI;
|
||||
|
@ -325,7 +325,7 @@ static void m32r_sio_enable_ms(struct uart_port *port)
|
|||
|
||||
static void receive_chars(struct uart_sio_port *up, int *status)
|
||||
{
|
||||
struct tty_struct *tty = up->port.info->port.tty;
|
||||
struct tty_struct *tty = up->port.state->port.tty;
|
||||
unsigned char ch;
|
||||
unsigned char flag;
|
||||
int max_count = 256;
|
||||
|
@ -398,7 +398,7 @@ static void receive_chars(struct uart_sio_port *up, int *status)
|
|||
|
||||
static void transmit_chars(struct uart_sio_port *up)
|
||||
{
|
||||
struct circ_buf *xmit = &up->port.info->xmit;
|
||||
struct circ_buf *xmit = &up->port.state->xmit;
|
||||
int count;
|
||||
|
||||
if (up->port.x_char) {
|
||||
|
|
|
@ -184,7 +184,7 @@ static void max3100_timeout(unsigned long data)
|
|||
{
|
||||
struct max3100_port *s = (struct max3100_port *)data;
|
||||
|
||||
if (s->port.info) {
|
||||
if (s->port.state) {
|
||||
max3100_dowork(s);
|
||||
mod_timer(&s->timer, jiffies + s->poll_time);
|
||||
}
|
||||
|
@ -261,7 +261,7 @@ static void max3100_work(struct work_struct *w)
|
|||
int rxchars;
|
||||
u16 tx, rx;
|
||||
int conf, cconf, rts, crts;
|
||||
struct circ_buf *xmit = &s->port.info->xmit;
|
||||
struct circ_buf *xmit = &s->port.state->xmit;
|
||||
|
||||
dev_dbg(&s->spi->dev, "%s\n", __func__);
|
||||
|
||||
|
@ -307,8 +307,8 @@ static void max3100_work(struct work_struct *w)
|
|||
}
|
||||
}
|
||||
|
||||
if (rxchars > 16 && s->port.info->port.tty != NULL) {
|
||||
tty_flip_buffer_push(s->port.info->port.tty);
|
||||
if (rxchars > 16 && s->port.state->port.tty != NULL) {
|
||||
tty_flip_buffer_push(s->port.state->port.tty);
|
||||
rxchars = 0;
|
||||
}
|
||||
if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
|
||||
|
@ -320,8 +320,8 @@ static void max3100_work(struct work_struct *w)
|
|||
(!uart_circ_empty(xmit) &&
|
||||
!uart_tx_stopped(&s->port))));
|
||||
|
||||
if (rxchars > 0 && s->port.info->port.tty != NULL)
|
||||
tty_flip_buffer_push(s->port.info->port.tty);
|
||||
if (rxchars > 0 && s->port.state->port.tty != NULL)
|
||||
tty_flip_buffer_push(s->port.state->port.tty);
|
||||
}
|
||||
|
||||
static irqreturn_t max3100_irq(int irqno, void *dev_id)
|
||||
|
@ -429,7 +429,7 @@ max3100_set_termios(struct uart_port *port, struct ktermios *termios,
|
|||
int baud = 0;
|
||||
unsigned cflag;
|
||||
u32 param_new, param_mask, parity = 0;
|
||||
struct tty_struct *tty = s->port.info->port.tty;
|
||||
struct tty_struct *tty = s->port.state->port.tty;
|
||||
|
||||
dev_dbg(&s->spi->dev, "%s\n", __func__);
|
||||
if (!tty)
|
||||
|
@ -529,7 +529,7 @@ max3100_set_termios(struct uart_port *port, struct ktermios *termios,
|
|||
MAX3100_STATUS_OE;
|
||||
|
||||
/* we are sending char from a workqueue so enable */
|
||||
s->port.info->port.tty->low_latency = 1;
|
||||
s->port.state->port.tty->low_latency = 1;
|
||||
|
||||
if (s->poll_time > 0)
|
||||
del_timer_sync(&s->timer);
|
||||
|
|
|
@ -323,7 +323,7 @@ static void mcf_rx_chars(struct mcf_uart *pp)
|
|||
uart_insert_char(port, status, MCFUART_USR_RXOVERRUN, ch, flag);
|
||||
}
|
||||
|
||||
tty_flip_buffer_push(port->info->port.tty);
|
||||
tty_flip_buffer_push(port->state->port.tty);
|
||||
}
|
||||
|
||||
/****************************************************************************/
|
||||
|
@ -331,7 +331,7 @@ static void mcf_rx_chars(struct mcf_uart *pp)
|
|||
static void mcf_tx_chars(struct mcf_uart *pp)
|
||||
{
|
||||
struct uart_port *port = &pp->port;
|
||||
struct circ_buf *xmit = &port->info->xmit;
|
||||
struct circ_buf *xmit = &port->state->xmit;
|
||||
|
||||
if (port->x_char) {
|
||||
/* Send special char - probably flow control */
|
||||
|
|
|
@ -745,7 +745,7 @@ static struct uart_ops mpc52xx_uart_ops = {
|
|||
static inline int
|
||||
mpc52xx_uart_int_rx_chars(struct uart_port *port)
|
||||
{
|
||||
struct tty_struct *tty = port->info->port.tty;
|
||||
struct tty_struct *tty = port->state->port.tty;
|
||||
unsigned char ch, flag;
|
||||
unsigned short status;
|
||||
|
||||
|
@ -812,7 +812,7 @@ mpc52xx_uart_int_rx_chars(struct uart_port *port)
|
|||
static inline int
|
||||
mpc52xx_uart_int_tx_chars(struct uart_port *port)
|
||||
{
|
||||
struct circ_buf *xmit = &port->info->xmit;
|
||||
struct circ_buf *xmit = &port->state->xmit;
|
||||
|
||||
/* Process out of band chars */
|
||||
if (port->x_char) {
|
||||
|
|
|
@ -936,7 +936,7 @@ static int serial_polled;
|
|||
static int mpsc_rx_intr(struct mpsc_port_info *pi)
|
||||
{
|
||||
struct mpsc_rx_desc *rxre;
|
||||
struct tty_struct *tty = pi->port.info->port.tty;
|
||||
struct tty_struct *tty = pi->port.state->port.tty;
|
||||
u32 cmdstat, bytes_in, i;
|
||||
int rc = 0;
|
||||
u8 *bp;
|
||||
|
@ -1109,7 +1109,7 @@ static void mpsc_setup_tx_desc(struct mpsc_port_info *pi, u32 count, u32 intr)
|
|||
|
||||
static void mpsc_copy_tx_data(struct mpsc_port_info *pi)
|
||||
{
|
||||
struct circ_buf *xmit = &pi->port.info->xmit;
|
||||
struct circ_buf *xmit = &pi->port.state->xmit;
|
||||
u8 *bp;
|
||||
u32 i;
|
||||
|
||||
|
|
|
@ -88,7 +88,7 @@ static void msm_enable_ms(struct uart_port *port)
|
|||
|
||||
static void handle_rx(struct uart_port *port)
|
||||
{
|
||||
struct tty_struct *tty = port->info->port.tty;
|
||||
struct tty_struct *tty = port->state->port.tty;
|
||||
unsigned int sr;
|
||||
|
||||
/*
|
||||
|
@ -136,7 +136,7 @@ static void handle_rx(struct uart_port *port)
|
|||
|
||||
static void handle_tx(struct uart_port *port)
|
||||
{
|
||||
struct circ_buf *xmit = &port->info->xmit;
|
||||
struct circ_buf *xmit = &port->state->xmit;
|
||||
struct msm_port *msm_port = UART_TO_MSM(port);
|
||||
int sent_tx;
|
||||
|
||||
|
@ -169,7 +169,7 @@ static void handle_delta_cts(struct uart_port *port)
|
|||
{
|
||||
msm_write(port, UART_CR_CMD_RESET_CTS, UART_CR);
|
||||
port->icount.cts++;
|
||||
wake_up_interruptible(&port->info->delta_msr_wait);
|
||||
wake_up_interruptible(&port->state->port.delta_msr_wait);
|
||||
}
|
||||
|
||||
static irqreturn_t msm_irq(int irq, void *dev_id)
|
||||
|
|
|
@ -199,7 +199,7 @@ static void mux_break_ctl(struct uart_port *port, int break_state)
|
|||
static void mux_write(struct uart_port *port)
|
||||
{
|
||||
int count;
|
||||
struct circ_buf *xmit = &port->info->xmit;
|
||||
struct circ_buf *xmit = &port->state->xmit;
|
||||
|
||||
if(port->x_char) {
|
||||
UART_PUT_CHAR(port, port->x_char);
|
||||
|
@ -243,7 +243,7 @@ static void mux_write(struct uart_port *port)
|
|||
static void mux_read(struct uart_port *port)
|
||||
{
|
||||
int data;
|
||||
struct tty_struct *tty = port->info->port.tty;
|
||||
struct tty_struct *tty = port->state->port.tty;
|
||||
__u32 start_count = port->icount.rx;
|
||||
|
||||
while(1) {
|
||||
|
|
|
@ -140,7 +140,7 @@ static void netx_enable_ms(struct uart_port *port)
|
|||
|
||||
static inline void netx_transmit_buffer(struct uart_port *port)
|
||||
{
|
||||
struct circ_buf *xmit = &port->info->xmit;
|
||||
struct circ_buf *xmit = &port->state->xmit;
|
||||
|
||||
if (port->x_char) {
|
||||
writel(port->x_char, port->membase + UART_DR);
|
||||
|
@ -185,7 +185,7 @@ static unsigned int netx_tx_empty(struct uart_port *port)
|
|||
|
||||
static void netx_txint(struct uart_port *port)
|
||||
{
|
||||
struct circ_buf *xmit = &port->info->xmit;
|
||||
struct circ_buf *xmit = &port->state->xmit;
|
||||
|
||||
if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {
|
||||
netx_stop_tx(port);
|
||||
|
@ -201,7 +201,7 @@ static void netx_txint(struct uart_port *port)
|
|||
static void netx_rxint(struct uart_port *port)
|
||||
{
|
||||
unsigned char rx, flg, status;
|
||||
struct tty_struct *tty = port->info->port.tty;
|
||||
struct tty_struct *tty = port->state->port.tty;
|
||||
|
||||
while (!(readl(port->membase + UART_FR) & FR_RXFE)) {
|
||||
rx = readl(port->membase + UART_DR);
|
||||
|
|
|
@ -126,7 +126,7 @@ static void nwpserial_config_port(struct uart_port *port, int flags)
|
|||
static irqreturn_t nwpserial_interrupt(int irq, void *dev_id)
|
||||
{
|
||||
struct nwpserial_port *up = dev_id;
|
||||
struct tty_struct *tty = up->port.info->port.tty;
|
||||
struct tty_struct *tty = up->port.state->port.tty;
|
||||
irqreturn_t ret;
|
||||
unsigned int iir;
|
||||
unsigned char ch;
|
||||
|
@ -261,7 +261,7 @@ static void nwpserial_start_tx(struct uart_port *port)
|
|||
struct nwpserial_port *up;
|
||||
struct circ_buf *xmit;
|
||||
up = container_of(port, struct nwpserial_port, port);
|
||||
xmit = &up->port.info->xmit;
|
||||
xmit = &up->port.state->xmit;
|
||||
|
||||
if (port->x_char) {
|
||||
nwpserial_putchar(up, up->port.x_char);
|
||||
|
|
|
@ -242,12 +242,12 @@ static struct tty_struct *pmz_receive_chars(struct uart_pmac_port *uap)
|
|||
}
|
||||
|
||||
/* Sanity check, make sure the old bug is no longer happening */
|
||||
if (uap->port.info == NULL || uap->port.info->port.tty == NULL) {
|
||||
if (uap->port.state == NULL || uap->port.state->port.tty == NULL) {
|
||||
WARN_ON(1);
|
||||
(void)read_zsdata(uap);
|
||||
return NULL;
|
||||
}
|
||||
tty = uap->port.info->port.tty;
|
||||
tty = uap->port.state->port.tty;
|
||||
|
||||
while (1) {
|
||||
error = 0;
|
||||
|
@ -369,7 +369,7 @@ static void pmz_status_handle(struct uart_pmac_port *uap)
|
|||
uart_handle_cts_change(&uap->port,
|
||||
!(status & CTS));
|
||||
|
||||
wake_up_interruptible(&uap->port.info->delta_msr_wait);
|
||||
wake_up_interruptible(&uap->port.state->port.delta_msr_wait);
|
||||
}
|
||||
|
||||
if (status & BRK_ABRT)
|
||||
|
@ -420,9 +420,9 @@ static void pmz_transmit_chars(struct uart_pmac_port *uap)
|
|||
return;
|
||||
}
|
||||
|
||||
if (uap->port.info == NULL)
|
||||
if (uap->port.state == NULL)
|
||||
goto ack_tx_int;
|
||||
xmit = &uap->port.info->xmit;
|
||||
xmit = &uap->port.state->xmit;
|
||||
if (uart_circ_empty(xmit)) {
|
||||
uart_write_wakeup(&uap->port);
|
||||
goto ack_tx_int;
|
||||
|
@ -655,7 +655,7 @@ static void pmz_start_tx(struct uart_port *port)
|
|||
port->icount.tx++;
|
||||
port->x_char = 0;
|
||||
} else {
|
||||
struct circ_buf *xmit = &port->info->xmit;
|
||||
struct circ_buf *xmit = &port->state->xmit;
|
||||
|
||||
write_zsdata(uap, xmit->buf[xmit->tail]);
|
||||
zssync(uap);
|
||||
|
@ -1645,7 +1645,7 @@ static int pmz_suspend(struct macio_dev *mdev, pm_message_t pm_state)
|
|||
state = pmz_uart_reg.state + uap->port.line;
|
||||
|
||||
mutex_lock(&pmz_irq_mutex);
|
||||
mutex_lock(&state->mutex);
|
||||
mutex_lock(&state->port.mutex);
|
||||
|
||||
spin_lock_irqsave(&uap->port.lock, flags);
|
||||
|
||||
|
@ -1676,7 +1676,7 @@ static int pmz_suspend(struct macio_dev *mdev, pm_message_t pm_state)
|
|||
/* Shut the chip down */
|
||||
pmz_set_scc_power(uap, 0);
|
||||
|
||||
mutex_unlock(&state->mutex);
|
||||
mutex_unlock(&state->port.mutex);
|
||||
mutex_unlock(&pmz_irq_mutex);
|
||||
|
||||
pmz_debug("suspend, switching complete\n");
|
||||
|
@ -1705,7 +1705,7 @@ static int pmz_resume(struct macio_dev *mdev)
|
|||
state = pmz_uart_reg.state + uap->port.line;
|
||||
|
||||
mutex_lock(&pmz_irq_mutex);
|
||||
mutex_lock(&state->mutex);
|
||||
mutex_lock(&state->port.mutex);
|
||||
|
||||
spin_lock_irqsave(&uap->port.lock, flags);
|
||||
if (!ZS_IS_OPEN(uap) && !ZS_IS_CONS(uap)) {
|
||||
|
@ -1737,7 +1737,7 @@ static int pmz_resume(struct macio_dev *mdev)
|
|||
}
|
||||
|
||||
bail:
|
||||
mutex_unlock(&state->mutex);
|
||||
mutex_unlock(&state->port.mutex);
|
||||
mutex_unlock(&pmz_irq_mutex);
|
||||
|
||||
/* Right now, we deal with delay by blocking here, I'll be
|
||||
|
|
|
@ -100,7 +100,7 @@ static void pnx8xxx_mctrl_check(struct pnx8xxx_port *sport)
|
|||
if (changed & TIOCM_CTS)
|
||||
uart_handle_cts_change(&sport->port, status & TIOCM_CTS);
|
||||
|
||||
wake_up_interruptible(&sport->port.info->delta_msr_wait);
|
||||
wake_up_interruptible(&sport->port.state->port.delta_msr_wait);
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -112,7 +112,7 @@ static void pnx8xxx_timeout(unsigned long data)
|
|||
struct pnx8xxx_port *sport = (struct pnx8xxx_port *)data;
|
||||
unsigned long flags;
|
||||
|
||||
if (sport->port.info) {
|
||||
if (sport->port.state) {
|
||||
spin_lock_irqsave(&sport->port.lock, flags);
|
||||
pnx8xxx_mctrl_check(sport);
|
||||
spin_unlock_irqrestore(&sport->port.lock, flags);
|
||||
|
@ -181,7 +181,7 @@ static void pnx8xxx_enable_ms(struct uart_port *port)
|
|||
|
||||
static void pnx8xxx_rx_chars(struct pnx8xxx_port *sport)
|
||||
{
|
||||
struct tty_struct *tty = sport->port.info->port.tty;
|
||||
struct tty_struct *tty = sport->port.state->port.tty;
|
||||
unsigned int status, ch, flg;
|
||||
|
||||
status = FIFO_TO_SM(serial_in(sport, PNX8XXX_FIFO)) |
|
||||
|
@ -243,7 +243,7 @@ static void pnx8xxx_rx_chars(struct pnx8xxx_port *sport)
|
|||
|
||||
static void pnx8xxx_tx_chars(struct pnx8xxx_port *sport)
|
||||
{
|
||||
struct circ_buf *xmit = &sport->port.info->xmit;
|
||||
struct circ_buf *xmit = &sport->port.state->xmit;
|
||||
|
||||
if (sport->port.x_char) {
|
||||
serial_out(sport, PNX8XXX_FIFO, sport->port.x_char);
|
||||
|
|
|
@ -96,7 +96,7 @@ static void serial_pxa_stop_rx(struct uart_port *port)
|
|||
|
||||
static inline void receive_chars(struct uart_pxa_port *up, int *status)
|
||||
{
|
||||
struct tty_struct *tty = up->port.info->port.tty;
|
||||
struct tty_struct *tty = up->port.state->port.tty;
|
||||
unsigned int ch, flag;
|
||||
int max_count = 256;
|
||||
|
||||
|
@ -161,7 +161,7 @@ static inline void receive_chars(struct uart_pxa_port *up, int *status)
|
|||
|
||||
static void transmit_chars(struct uart_pxa_port *up)
|
||||
{
|
||||
struct circ_buf *xmit = &up->port.info->xmit;
|
||||
struct circ_buf *xmit = &up->port.state->xmit;
|
||||
int count;
|
||||
|
||||
if (up->port.x_char) {
|
||||
|
@ -220,7 +220,7 @@ static inline void check_modem_status(struct uart_pxa_port *up)
|
|||
if (status & UART_MSR_DCTS)
|
||||
uart_handle_cts_change(&up->port, status & UART_MSR_CTS);
|
||||
|
||||
wake_up_interruptible(&up->port.info->delta_msr_wait);
|
||||
wake_up_interruptible(&up->port.state->port.delta_msr_wait);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
@ -117,7 +117,7 @@ static void sa1100_mctrl_check(struct sa1100_port *sport)
|
|||
if (changed & TIOCM_CTS)
|
||||
uart_handle_cts_change(&sport->port, status & TIOCM_CTS);
|
||||
|
||||
wake_up_interruptible(&sport->port.info->delta_msr_wait);
|
||||
wake_up_interruptible(&sport->port.state->port.delta_msr_wait);
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -129,7 +129,7 @@ static void sa1100_timeout(unsigned long data)
|
|||
struct sa1100_port *sport = (struct sa1100_port *)data;
|
||||
unsigned long flags;
|
||||
|
||||
if (sport->port.info) {
|
||||
if (sport->port.state) {
|
||||
spin_lock_irqsave(&sport->port.lock, flags);
|
||||
sa1100_mctrl_check(sport);
|
||||
spin_unlock_irqrestore(&sport->port.lock, flags);
|
||||
|
@ -189,7 +189,7 @@ static void sa1100_enable_ms(struct uart_port *port)
|
|||
static void
|
||||
sa1100_rx_chars(struct sa1100_port *sport)
|
||||
{
|
||||
struct tty_struct *tty = sport->port.info->port.tty;
|
||||
struct tty_struct *tty = sport->port.state->port.tty;
|
||||
unsigned int status, ch, flg;
|
||||
|
||||
status = UTSR1_TO_SM(UART_GET_UTSR1(sport)) |
|
||||
|
@ -239,7 +239,7 @@ sa1100_rx_chars(struct sa1100_port *sport)
|
|||
|
||||
static void sa1100_tx_chars(struct sa1100_port *sport)
|
||||
{
|
||||
struct circ_buf *xmit = &sport->port.info->xmit;
|
||||
struct circ_buf *xmit = &sport->port.state->xmit;
|
||||
|
||||
if (sport->port.x_char) {
|
||||
UART_PUT_CHAR(sport, sport->port.x_char);
|
||||
|
|
|
@ -196,7 +196,7 @@ s3c24xx_serial_rx_chars(int irq, void *dev_id)
|
|||
{
|
||||
struct s3c24xx_uart_port *ourport = dev_id;
|
||||
struct uart_port *port = &ourport->port;
|
||||
struct tty_struct *tty = port->info->port.tty;
|
||||
struct tty_struct *tty = port->state->port.tty;
|
||||
unsigned int ufcon, ch, flag, ufstat, uerstat;
|
||||
int max_count = 64;
|
||||
|
||||
|
@ -281,7 +281,7 @@ static irqreturn_t s3c24xx_serial_tx_chars(int irq, void *id)
|
|||
{
|
||||
struct s3c24xx_uart_port *ourport = id;
|
||||
struct uart_port *port = &ourport->port;
|
||||
struct circ_buf *xmit = &port->info->xmit;
|
||||
struct circ_buf *xmit = &port->state->xmit;
|
||||
int count = 256;
|
||||
|
||||
if (port->x_char) {
|
||||
|
@ -992,10 +992,10 @@ static int s3c24xx_serial_cpufreq_transition(struct notifier_block *nb,
|
|||
struct ktermios *termios;
|
||||
struct tty_struct *tty;
|
||||
|
||||
if (uport->info == NULL)
|
||||
if (uport->state == NULL)
|
||||
goto exit;
|
||||
|
||||
tty = uport->info->port.tty;
|
||||
tty = uport->state->port.tty;
|
||||
|
||||
if (tty == NULL)
|
||||
goto exit;
|
||||
|
|
|
@ -384,13 +384,13 @@ static void sbd_receive_chars(struct sbd_port *sport)
|
|||
uart_insert_char(uport, status, M_DUART_OVRUN_ERR, ch, flag);
|
||||
}
|
||||
|
||||
tty_flip_buffer_push(uport->info->port.tty);
|
||||
tty_flip_buffer_push(uport->state->port.tty);
|
||||
}
|
||||
|
||||
static void sbd_transmit_chars(struct sbd_port *sport)
|
||||
{
|
||||
struct uart_port *uport = &sport->port;
|
||||
struct circ_buf *xmit = &sport->port.info->xmit;
|
||||
struct circ_buf *xmit = &sport->port.state->xmit;
|
||||
unsigned int mask;
|
||||
int stop_tx;
|
||||
|
||||
|
@ -440,7 +440,7 @@ static void sbd_status_handle(struct sbd_port *sport)
|
|||
|
||||
if (delta & ((M_DUART_IN_PIN2_VAL | M_DUART_IN_PIN0_VAL) <<
|
||||
S_DUART_IN_PIN_CHNG))
|
||||
wake_up_interruptible(&uport->info->delta_msr_wait);
|
||||
wake_up_interruptible(&uport->state->port.delta_msr_wait);
|
||||
}
|
||||
|
||||
static irqreturn_t sbd_interrupt(int irq, void *dev_id)
|
||||
|
|
|
@ -140,8 +140,8 @@ static struct tty_struct *receive_chars(struct uart_port *port)
|
|||
char flag;
|
||||
u8 status;
|
||||
|
||||
if (port->info != NULL) /* Unopened serial console */
|
||||
tty = port->info->port.tty;
|
||||
if (port->state != NULL) /* Unopened serial console */
|
||||
tty = port->state->port.tty;
|
||||
|
||||
while (limit-- > 0) {
|
||||
status = READ_SC_PORT(port, SR);
|
||||
|
@ -190,10 +190,10 @@ static void transmit_chars(struct uart_port *port)
|
|||
{
|
||||
struct circ_buf *xmit;
|
||||
|
||||
if (!port->info)
|
||||
if (!port->state)
|
||||
return;
|
||||
|
||||
xmit = &port->info->xmit;
|
||||
xmit = &port->state->xmit;
|
||||
if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {
|
||||
sc26xx_disable_irq(port, IMR_TXRDY);
|
||||
return;
|
||||
|
@ -316,7 +316,7 @@ static void sc26xx_stop_tx(struct uart_port *port)
|
|||
/* port->lock held by caller. */
|
||||
static void sc26xx_start_tx(struct uart_port *port)
|
||||
{
|
||||
struct circ_buf *xmit = &port->info->xmit;
|
||||
struct circ_buf *xmit = &port->state->xmit;
|
||||
|
||||
while (!uart_circ_empty(xmit)) {
|
||||
if (!(READ_SC_PORT(port, SR) & SR_TXRDY)) {
|
||||
|
|
File diff suppressed because it is too large
Load diff
|
@ -884,6 +884,7 @@ static struct pcmcia_device_id serial_ids[] = {
|
|||
PCMCIA_DEVICE_CIS_MANF_CARD(0x0192, 0xa555, "SW_555_SER.cis"), /* Sierra Aircard 555 CDMA 1xrtt Modem -- pre update */
|
||||
PCMCIA_DEVICE_CIS_MANF_CARD(0x013f, 0xa555, "SW_555_SER.cis"), /* Sierra Aircard 555 CDMA 1xrtt Modem -- post update */
|
||||
PCMCIA_DEVICE_CIS_PROD_ID12("MultiTech", "PCMCIA 56K DataFax", 0x842047ee, 0xc2efcf03, "cis/MT5634ZLX.cis"),
|
||||
PCMCIA_DEVICE_CIS_PROD_ID12("ADVANTECH", "COMpad-32/85B-2", 0x96913a85, 0x27ab5437, "COMpad2.cis"),
|
||||
PCMCIA_DEVICE_CIS_PROD_ID12("ADVANTECH", "COMpad-32/85B-4", 0x96913a85, 0xcec8f102, "COMpad4.cis"),
|
||||
PCMCIA_DEVICE_CIS_PROD_ID123("ADVANTECH", "COMpad-32/85", "1.0", 0x96913a85, 0x8fbe92ae, 0x0877b627, "COMpad2.cis"),
|
||||
PCMCIA_DEVICE_CIS_PROD_ID2("RS-COM 2P", 0xad20b156, "cis/RS-COM-2P.cis"),
|
||||
|
|
|
@ -154,7 +154,7 @@ static void ks8695uart_disable_ms(struct uart_port *port)
|
|||
static irqreturn_t ks8695uart_rx_chars(int irq, void *dev_id)
|
||||
{
|
||||
struct uart_port *port = dev_id;
|
||||
struct tty_struct *tty = port->info->port.tty;
|
||||
struct tty_struct *tty = port->state->port.tty;
|
||||
unsigned int status, ch, lsr, flg, max_count = 256;
|
||||
|
||||
status = UART_GET_LSR(port); /* clears pending LSR interrupts */
|
||||
|
@ -210,7 +210,7 @@ ignore_char:
|
|||
static irqreturn_t ks8695uart_tx_chars(int irq, void *dev_id)
|
||||
{
|
||||
struct uart_port *port = dev_id;
|
||||
struct circ_buf *xmit = &port->info->xmit;
|
||||
struct circ_buf *xmit = &port->state->xmit;
|
||||
unsigned int count;
|
||||
|
||||
if (port->x_char) {
|
||||
|
@ -266,7 +266,7 @@ static irqreturn_t ks8695uart_modem_status(int irq, void *dev_id)
|
|||
if (status & URMS_URTERI)
|
||||
port->icount.rng++;
|
||||
|
||||
wake_up_interruptible(&port->info->delta_msr_wait);
|
||||
wake_up_interruptible(&port->state->port.delta_msr_wait);
|
||||
|
||||
return IRQ_HANDLED;
|
||||
}
|
||||
|
|
|
@ -138,7 +138,7 @@ static void lh7a40xuart_enable_ms (struct uart_port* port)
|
|||
|
||||
static void lh7a40xuart_rx_chars (struct uart_port* port)
|
||||
{
|
||||
struct tty_struct* tty = port->info->port.tty;
|
||||
struct tty_struct* tty = port->state->port.tty;
|
||||
int cbRxMax = 256; /* (Gross) limit on receive */
|
||||
unsigned int data; /* Received data and status */
|
||||
unsigned int flag;
|
||||
|
@ -184,7 +184,7 @@ static void lh7a40xuart_rx_chars (struct uart_port* port)
|
|||
|
||||
static void lh7a40xuart_tx_chars (struct uart_port* port)
|
||||
{
|
||||
struct circ_buf* xmit = &port->info->xmit;
|
||||
struct circ_buf* xmit = &port->state->xmit;
|
||||
int cbTxMax = port->fifosize;
|
||||
|
||||
if (port->x_char) {
|
||||
|
@ -241,7 +241,7 @@ static void lh7a40xuart_modem_status (struct uart_port* port)
|
|||
if (delta & CTS)
|
||||
uart_handle_cts_change (port, status & CTS);
|
||||
|
||||
wake_up_interruptible (&port->info->delta_msr_wait);
|
||||
wake_up_interruptible (&port->state->port.delta_msr_wait);
|
||||
}
|
||||
|
||||
static irqreturn_t lh7a40xuart_int (int irq, void* dev_id)
|
||||
|
|
|
@ -272,7 +272,7 @@ static void serial_txx9_initialize(struct uart_port *port)
|
|||
static inline void
|
||||
receive_chars(struct uart_txx9_port *up, unsigned int *status)
|
||||
{
|
||||
struct tty_struct *tty = up->port.info->port.tty;
|
||||
struct tty_struct *tty = up->port.state->port.tty;
|
||||
unsigned char ch;
|
||||
unsigned int disr = *status;
|
||||
int max_count = 256;
|
||||
|
@ -348,7 +348,7 @@ receive_chars(struct uart_txx9_port *up, unsigned int *status)
|
|||
|
||||
static inline void transmit_chars(struct uart_txx9_port *up)
|
||||
{
|
||||
struct circ_buf *xmit = &up->port.info->xmit;
|
||||
struct circ_buf *xmit = &up->port.state->xmit;
|
||||
int count;
|
||||
|
||||
if (up->port.x_char) {
|
||||
|
|
|
@ -361,7 +361,7 @@ static inline int sci_rxroom(struct uart_port *port)
|
|||
|
||||
static void sci_transmit_chars(struct uart_port *port)
|
||||
{
|
||||
struct circ_buf *xmit = &port->info->xmit;
|
||||
struct circ_buf *xmit = &port->state->xmit;
|
||||
unsigned int stopped = uart_tx_stopped(port);
|
||||
unsigned short status;
|
||||
unsigned short ctrl;
|
||||
|
@ -426,7 +426,7 @@ static void sci_transmit_chars(struct uart_port *port)
|
|||
static inline void sci_receive_chars(struct uart_port *port)
|
||||
{
|
||||
struct sci_port *sci_port = to_sci_port(port);
|
||||
struct tty_struct *tty = port->info->port.tty;
|
||||
struct tty_struct *tty = port->state->port.tty;
|
||||
int i, count, copied = 0;
|
||||
unsigned short status;
|
||||
unsigned char flag;
|
||||
|
@ -546,7 +546,7 @@ static inline int sci_handle_errors(struct uart_port *port)
|
|||
{
|
||||
int copied = 0;
|
||||
unsigned short status = sci_in(port, SCxSR);
|
||||
struct tty_struct *tty = port->info->port.tty;
|
||||
struct tty_struct *tty = port->state->port.tty;
|
||||
|
||||
if (status & SCxSR_ORER(port)) {
|
||||
/* overrun error */
|
||||
|
@ -600,7 +600,7 @@ static inline int sci_handle_errors(struct uart_port *port)
|
|||
|
||||
static inline int sci_handle_fifo_overrun(struct uart_port *port)
|
||||
{
|
||||
struct tty_struct *tty = port->info->port.tty;
|
||||
struct tty_struct *tty = port->state->port.tty;
|
||||
int copied = 0;
|
||||
|
||||
if (port->type != PORT_SCIF)
|
||||
|
@ -623,7 +623,7 @@ static inline int sci_handle_breaks(struct uart_port *port)
|
|||
{
|
||||
int copied = 0;
|
||||
unsigned short status = sci_in(port, SCxSR);
|
||||
struct tty_struct *tty = port->info->port.tty;
|
||||
struct tty_struct *tty = port->state->port.tty;
|
||||
struct sci_port *s = to_sci_port(port);
|
||||
|
||||
if (uart_handle_break(port))
|
||||
|
|
|
@ -469,9 +469,9 @@ sn_receive_chars(struct sn_cons_port *port, unsigned long flags)
|
|||
return;
|
||||
}
|
||||
|
||||
if (port->sc_port.info) {
|
||||
if (port->sc_port.state) {
|
||||
/* The serial_core stuffs are initilized, use them */
|
||||
tty = port->sc_port.info->port.tty;
|
||||
tty = port->sc_port.state->port.tty;
|
||||
}
|
||||
else {
|
||||
/* Not registered yet - can't pass to tty layer. */
|
||||
|
@ -550,9 +550,9 @@ static void sn_transmit_chars(struct sn_cons_port *port, int raw)
|
|||
|
||||
BUG_ON(!port->sc_is_asynch);
|
||||
|
||||
if (port->sc_port.info) {
|
||||
if (port->sc_port.state) {
|
||||
/* We're initilized, using serial core infrastructure */
|
||||
xmit = &port->sc_port.info->xmit;
|
||||
xmit = &port->sc_port.state->xmit;
|
||||
} else {
|
||||
/* Probably sn_sal_switch_to_asynch has been run but serial core isn't
|
||||
* initilized yet. Just return. Writes are going through
|
||||
|
@ -927,7 +927,7 @@ sn_sal_console_write(struct console *co, const char *s, unsigned count)
|
|||
/* We can't look at the xmit buffer if we're not registered with serial core
|
||||
* yet. So only do the fancy recovery after registering
|
||||
*/
|
||||
if (!port->sc_port.info) {
|
||||
if (!port->sc_port.state) {
|
||||
/* Not yet registered with serial core - simple case */
|
||||
puts_raw_fixed(port->sc_ops->sal_puts_raw, s, count);
|
||||
return;
|
||||
|
@ -936,8 +936,8 @@ sn_sal_console_write(struct console *co, const char *s, unsigned count)
|
|||
/* somebody really wants this output, might be an
|
||||
* oops, kdb, panic, etc. make sure they get it. */
|
||||
if (spin_is_locked(&port->sc_port.lock)) {
|
||||
int lhead = port->sc_port.info->xmit.head;
|
||||
int ltail = port->sc_port.info->xmit.tail;
|
||||
int lhead = port->sc_port.state->xmit.head;
|
||||
int ltail = port->sc_port.state->xmit.tail;
|
||||
int counter, got_lock = 0;
|
||||
|
||||
/*
|
||||
|
@ -962,13 +962,13 @@ sn_sal_console_write(struct console *co, const char *s, unsigned count)
|
|||
break;
|
||||
} else {
|
||||
/* still locked */
|
||||
if ((lhead != port->sc_port.info->xmit.head)
|
||||
if ((lhead != port->sc_port.state->xmit.head)
|
||||
|| (ltail !=
|
||||
port->sc_port.info->xmit.tail)) {
|
||||
port->sc_port.state->xmit.tail)) {
|
||||
lhead =
|
||||
port->sc_port.info->xmit.head;
|
||||
port->sc_port.state->xmit.head;
|
||||
ltail =
|
||||
port->sc_port.info->xmit.tail;
|
||||
port->sc_port.state->xmit.tail;
|
||||
counter = 0;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -184,8 +184,8 @@ static struct tty_struct *receive_chars(struct uart_port *port)
|
|||
{
|
||||
struct tty_struct *tty = NULL;
|
||||
|
||||
if (port->info != NULL) /* Unopened serial console */
|
||||
tty = port->info->port.tty;
|
||||
if (port->state != NULL) /* Unopened serial console */
|
||||
tty = port->state->port.tty;
|
||||
|
||||
if (sunhv_ops->receive_chars(port, tty))
|
||||
sun_do_break();
|
||||
|
@ -197,10 +197,10 @@ static void transmit_chars(struct uart_port *port)
|
|||
{
|
||||
struct circ_buf *xmit;
|
||||
|
||||
if (!port->info)
|
||||
if (!port->state)
|
||||
return;
|
||||
|
||||
xmit = &port->info->xmit;
|
||||
xmit = &port->state->xmit;
|
||||
if (uart_circ_empty(xmit) || uart_tx_stopped(port))
|
||||
return;
|
||||
|
||||
|
|
|
@ -117,8 +117,8 @@ receive_chars(struct uart_sunsab_port *up,
|
|||
int count = 0;
|
||||
int i;
|
||||
|
||||
if (up->port.info != NULL) /* Unopened serial console */
|
||||
tty = up->port.info->port.tty;
|
||||
if (up->port.state != NULL) /* Unopened serial console */
|
||||
tty = up->port.state->port.tty;
|
||||
|
||||
/* Read number of BYTES (Character + Status) available. */
|
||||
if (stat->sreg.isr0 & SAB82532_ISR0_RPF) {
|
||||
|
@ -229,7 +229,7 @@ static void sunsab_tx_idle(struct uart_sunsab_port *);
|
|||
static void transmit_chars(struct uart_sunsab_port *up,
|
||||
union sab82532_irq_status *stat)
|
||||
{
|
||||
struct circ_buf *xmit = &up->port.info->xmit;
|
||||
struct circ_buf *xmit = &up->port.state->xmit;
|
||||
int i;
|
||||
|
||||
if (stat->sreg.isr1 & SAB82532_ISR1_ALLS) {
|
||||
|
@ -297,7 +297,7 @@ static void check_status(struct uart_sunsab_port *up,
|
|||
up->port.icount.dsr++;
|
||||
}
|
||||
|
||||
wake_up_interruptible(&up->port.info->delta_msr_wait);
|
||||
wake_up_interruptible(&up->port.state->port.delta_msr_wait);
|
||||
}
|
||||
|
||||
static irqreturn_t sunsab_interrupt(int irq, void *dev_id)
|
||||
|
@ -429,7 +429,7 @@ static void sunsab_tx_idle(struct uart_sunsab_port *up)
|
|||
static void sunsab_start_tx(struct uart_port *port)
|
||||
{
|
||||
struct uart_sunsab_port *up = (struct uart_sunsab_port *) port;
|
||||
struct circ_buf *xmit = &up->port.info->xmit;
|
||||
struct circ_buf *xmit = &up->port.state->xmit;
|
||||
int i;
|
||||
|
||||
up->interrupt_mask1 &= ~(SAB82532_IMR1_ALLS|SAB82532_IMR1_XPR);
|
||||
|
|
|
@ -311,7 +311,7 @@ static void sunsu_enable_ms(struct uart_port *port)
|
|||
static struct tty_struct *
|
||||
receive_chars(struct uart_sunsu_port *up, unsigned char *status)
|
||||
{
|
||||
struct tty_struct *tty = up->port.info->port.tty;
|
||||
struct tty_struct *tty = up->port.state->port.tty;
|
||||
unsigned char ch, flag;
|
||||
int max_count = 256;
|
||||
int saw_console_brk = 0;
|
||||
|
@ -389,7 +389,7 @@ receive_chars(struct uart_sunsu_port *up, unsigned char *status)
|
|||
|
||||
static void transmit_chars(struct uart_sunsu_port *up)
|
||||
{
|
||||
struct circ_buf *xmit = &up->port.info->xmit;
|
||||
struct circ_buf *xmit = &up->port.state->xmit;
|
||||
int count;
|
||||
|
||||
if (up->port.x_char) {
|
||||
|
@ -441,7 +441,7 @@ static void check_modem_status(struct uart_sunsu_port *up)
|
|||
if (status & UART_MSR_DCTS)
|
||||
uart_handle_cts_change(&up->port, status & UART_MSR_CTS);
|
||||
|
||||
wake_up_interruptible(&up->port.info->delta_msr_wait);
|
||||
wake_up_interruptible(&up->port.state->port.delta_msr_wait);
|
||||
}
|
||||
|
||||
static irqreturn_t sunsu_serial_interrupt(int irq, void *dev_id)
|
||||
|
|
|
@ -328,9 +328,9 @@ sunzilog_receive_chars(struct uart_sunzilog_port *up,
|
|||
unsigned char ch, r1, flag;
|
||||
|
||||
tty = NULL;
|
||||
if (up->port.info != NULL && /* Unopened serial console */
|
||||
up->port.info->port.tty != NULL) /* Keyboard || mouse */
|
||||
tty = up->port.info->port.tty;
|
||||
if (up->port.state != NULL && /* Unopened serial console */
|
||||
up->port.state->port.tty != NULL) /* Keyboard || mouse */
|
||||
tty = up->port.state->port.tty;
|
||||
|
||||
for (;;) {
|
||||
|
||||
|
@ -451,7 +451,7 @@ static void sunzilog_status_handle(struct uart_sunzilog_port *up,
|
|||
uart_handle_cts_change(&up->port,
|
||||
(status & CTS));
|
||||
|
||||
wake_up_interruptible(&up->port.info->delta_msr_wait);
|
||||
wake_up_interruptible(&up->port.state->port.delta_msr_wait);
|
||||
}
|
||||
|
||||
up->prev_status = status;
|
||||
|
@ -501,9 +501,9 @@ static void sunzilog_transmit_chars(struct uart_sunzilog_port *up,
|
|||
return;
|
||||
}
|
||||
|
||||
if (up->port.info == NULL)
|
||||
if (up->port.state == NULL)
|
||||
goto ack_tx_int;
|
||||
xmit = &up->port.info->xmit;
|
||||
xmit = &up->port.state->xmit;
|
||||
if (uart_circ_empty(xmit))
|
||||
goto ack_tx_int;
|
||||
|
||||
|
@ -705,7 +705,7 @@ static void sunzilog_start_tx(struct uart_port *port)
|
|||
port->icount.tx++;
|
||||
port->x_char = 0;
|
||||
} else {
|
||||
struct circ_buf *xmit = &port->info->xmit;
|
||||
struct circ_buf *xmit = &port->state->xmit;
|
||||
|
||||
writeb(xmit->buf[xmit->tail], &channel->data);
|
||||
ZSDELAY();
|
||||
|
|
|
@ -77,7 +77,7 @@ static void timbuart_flush_buffer(struct uart_port *port)
|
|||
|
||||
static void timbuart_rx_chars(struct uart_port *port)
|
||||
{
|
||||
struct tty_struct *tty = port->info->port.tty;
|
||||
struct tty_struct *tty = port->state->port.tty;
|
||||
|
||||
while (ioread32(port->membase + TIMBUART_ISR) & RXDP) {
|
||||
u8 ch = ioread8(port->membase + TIMBUART_RXFIFO);
|
||||
|
@ -86,7 +86,7 @@ static void timbuart_rx_chars(struct uart_port *port)
|
|||
}
|
||||
|
||||
spin_unlock(&port->lock);
|
||||
tty_flip_buffer_push(port->info->port.tty);
|
||||
tty_flip_buffer_push(port->state->port.tty);
|
||||
spin_lock(&port->lock);
|
||||
|
||||
dev_dbg(port->dev, "%s - total read %d bytes\n",
|
||||
|
@ -95,7 +95,7 @@ static void timbuart_rx_chars(struct uart_port *port)
|
|||
|
||||
static void timbuart_tx_chars(struct uart_port *port)
|
||||
{
|
||||
struct circ_buf *xmit = &port->info->xmit;
|
||||
struct circ_buf *xmit = &port->state->xmit;
|
||||
|
||||
while (!(ioread32(port->membase + TIMBUART_ISR) & TXBF) &&
|
||||
!uart_circ_empty(xmit)) {
|
||||
|
@ -118,7 +118,7 @@ static void timbuart_handle_tx_port(struct uart_port *port, u32 isr, u32 *ier)
|
|||
{
|
||||
struct timbuart_port *uart =
|
||||
container_of(port, struct timbuart_port, port);
|
||||
struct circ_buf *xmit = &port->info->xmit;
|
||||
struct circ_buf *xmit = &port->state->xmit;
|
||||
|
||||
if (uart_circ_empty(xmit) || uart_tx_stopped(port))
|
||||
return;
|
||||
|
@ -231,7 +231,7 @@ static void timbuart_mctrl_check(struct uart_port *port, u32 isr, u32 *ier)
|
|||
iowrite32(CTS_DELTA, port->membase + TIMBUART_ISR);
|
||||
cts = timbuart_get_mctrl(port);
|
||||
uart_handle_cts_change(port, cts & TIOCM_CTS);
|
||||
wake_up_interruptible(&port->info->delta_msr_wait);
|
||||
wake_up_interruptible(&port->state->port.delta_msr_wait);
|
||||
}
|
||||
|
||||
*ier |= CTS_DELTA;
|
||||
|
|
|
@ -75,7 +75,7 @@ static struct uart_port ulite_ports[ULITE_NR_UARTS];
|
|||
|
||||
static int ulite_receive(struct uart_port *port, int stat)
|
||||
{
|
||||
struct tty_struct *tty = port->info->port.tty;
|
||||
struct tty_struct *tty = port->state->port.tty;
|
||||
unsigned char ch = 0;
|
||||
char flag = TTY_NORMAL;
|
||||
|
||||
|
@ -125,7 +125,7 @@ static int ulite_receive(struct uart_port *port, int stat)
|
|||
|
||||
static int ulite_transmit(struct uart_port *port, int stat)
|
||||
{
|
||||
struct circ_buf *xmit = &port->info->xmit;
|
||||
struct circ_buf *xmit = &port->state->xmit;
|
||||
|
||||
if (stat & ULITE_STATUS_TXFULL)
|
||||
return 0;
|
||||
|
@ -154,17 +154,22 @@ static int ulite_transmit(struct uart_port *port, int stat)
|
|||
static irqreturn_t ulite_isr(int irq, void *dev_id)
|
||||
{
|
||||
struct uart_port *port = dev_id;
|
||||
int busy;
|
||||
int busy, n = 0;
|
||||
|
||||
do {
|
||||
int stat = readb(port->membase + ULITE_STATUS);
|
||||
busy = ulite_receive(port, stat);
|
||||
busy |= ulite_transmit(port, stat);
|
||||
n++;
|
||||
} while (busy);
|
||||
|
||||
tty_flip_buffer_push(port->info->port.tty);
|
||||
|
||||
/* work done? */
|
||||
if (n > 1) {
|
||||
tty_flip_buffer_push(port->state->port.tty);
|
||||
return IRQ_HANDLED;
|
||||
} else {
|
||||
return IRQ_NONE;
|
||||
}
|
||||
}
|
||||
|
||||
static unsigned int ulite_tx_empty(struct uart_port *port)
|
||||
|
@ -221,7 +226,7 @@ static int ulite_startup(struct uart_port *port)
|
|||
int ret;
|
||||
|
||||
ret = request_irq(port->irq, ulite_isr,
|
||||
IRQF_DISABLED | IRQF_SAMPLE_RANDOM, "uartlite", port);
|
||||
IRQF_SHARED | IRQF_SAMPLE_RANDOM, "uartlite", port);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
|
|
|
@ -327,7 +327,7 @@ static int qe_uart_tx_pump(struct uart_qe_port *qe_port)
|
|||
unsigned char *p;
|
||||
unsigned int count;
|
||||
struct uart_port *port = &qe_port->port;
|
||||
struct circ_buf *xmit = &port->info->xmit;
|
||||
struct circ_buf *xmit = &port->state->xmit;
|
||||
|
||||
bdp = qe_port->rx_cur;
|
||||
|
||||
|
@ -466,7 +466,7 @@ static void qe_uart_int_rx(struct uart_qe_port *qe_port)
|
|||
int i;
|
||||
unsigned char ch, *cp;
|
||||
struct uart_port *port = &qe_port->port;
|
||||
struct tty_struct *tty = port->info->port.tty;
|
||||
struct tty_struct *tty = port->state->port.tty;
|
||||
struct qe_bd *bdp;
|
||||
u16 status;
|
||||
unsigned int flg;
|
||||
|
|
|
@ -318,7 +318,7 @@ static inline void receive_chars(struct uart_port *port, uint8_t *status)
|
|||
char flag;
|
||||
int max_count = RX_MAX_COUNT;
|
||||
|
||||
tty = port->info->port.tty;
|
||||
tty = port->state->port.tty;
|
||||
lsr = *status;
|
||||
|
||||
do {
|
||||
|
@ -386,7 +386,7 @@ static inline void check_modem_status(struct uart_port *port)
|
|||
if (msr & UART_MSR_DCTS)
|
||||
uart_handle_cts_change(port, msr & UART_MSR_CTS);
|
||||
|
||||
wake_up_interruptible(&port->info->delta_msr_wait);
|
||||
wake_up_interruptible(&port->state->port.delta_msr_wait);
|
||||
}
|
||||
|
||||
static inline void transmit_chars(struct uart_port *port)
|
||||
|
@ -394,7 +394,7 @@ static inline void transmit_chars(struct uart_port *port)
|
|||
struct circ_buf *xmit;
|
||||
int max_count = TX_MAX_COUNT;
|
||||
|
||||
xmit = &port->info->xmit;
|
||||
xmit = &port->state->xmit;
|
||||
|
||||
if (port->x_char) {
|
||||
siu_write(port, UART_TX, port->x_char);
|
||||
|
|
|
@ -602,12 +602,12 @@ static void zs_receive_chars(struct zs_port *zport)
|
|||
uart_insert_char(uport, status, Rx_OVR, ch, flag);
|
||||
}
|
||||
|
||||
tty_flip_buffer_push(uport->info->port.tty);
|
||||
tty_flip_buffer_push(uport->state->port.tty);
|
||||
}
|
||||
|
||||
static void zs_raw_transmit_chars(struct zs_port *zport)
|
||||
{
|
||||
struct circ_buf *xmit = &zport->port.info->xmit;
|
||||
struct circ_buf *xmit = &zport->port.state->xmit;
|
||||
|
||||
/* XON/XOFF chars. */
|
||||
if (zport->port.x_char) {
|
||||
|
@ -686,7 +686,7 @@ static void zs_status_handle(struct zs_port *zport, struct zs_port *zport_a)
|
|||
uport->icount.rng++;
|
||||
|
||||
if (delta)
|
||||
wake_up_interruptible(&uport->info->delta_msr_wait);
|
||||
wake_up_interruptible(&uport->state->port.delta_msr_wait);
|
||||
|
||||
spin_lock(&scc->zlock);
|
||||
}
|
||||
|
|
|
@ -858,10 +858,7 @@ static void acm_tty_set_termios(struct tty_struct *tty,
|
|||
if (!ACM_READY(acm))
|
||||
return;
|
||||
|
||||
/* FIXME: Needs to support the tty_baud interface */
|
||||
/* FIXME: Broken on sparc */
|
||||
newline.dwDTERate = cpu_to_le32p(acm_tty_speed +
|
||||
(termios->c_cflag & CBAUD & ~CBAUDEX) + (termios->c_cflag & CBAUDEX ? 15 : 0));
|
||||
newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
|
||||
newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
|
||||
newline.bParityType = termios->c_cflag & PARENB ?
|
||||
(termios->c_cflag & PARODD ? 1 : 2) +
|
||||
|
|
|
@ -35,11 +35,6 @@ static struct usb_device_id id_table [] = {
|
|||
};
|
||||
MODULE_DEVICE_TABLE(usb, id_table);
|
||||
|
||||
struct ark3116_private {
|
||||
spinlock_t lock;
|
||||
u8 termios_initialized;
|
||||
};
|
||||
|
||||
static inline void ARK3116_SND(struct usb_serial *serial, int seq,
|
||||
__u8 request, __u8 requesttype,
|
||||
__u16 value, __u16 index)
|
||||
|
@ -82,22 +77,11 @@ static inline void ARK3116_RCV_QUIET(struct usb_serial *serial,
|
|||
static int ark3116_attach(struct usb_serial *serial)
|
||||
{
|
||||
char *buf;
|
||||
struct ark3116_private *priv;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < serial->num_ports; ++i) {
|
||||
priv = kzalloc(sizeof(struct ark3116_private), GFP_KERNEL);
|
||||
if (!priv)
|
||||
goto cleanup;
|
||||
spin_lock_init(&priv->lock);
|
||||
|
||||
usb_set_serial_port_data(serial->port[i], priv);
|
||||
}
|
||||
|
||||
buf = kmalloc(1, GFP_KERNEL);
|
||||
if (!buf) {
|
||||
dbg("error kmalloc -> out of mem?");
|
||||
goto cleanup;
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
/* 3 */
|
||||
|
@ -149,13 +133,16 @@ static int ark3116_attach(struct usb_serial *serial)
|
|||
|
||||
kfree(buf);
|
||||
return 0;
|
||||
|
||||
cleanup:
|
||||
for (--i; i >= 0; --i) {
|
||||
kfree(usb_get_serial_port_data(serial->port[i]));
|
||||
usb_set_serial_port_data(serial->port[i], NULL);
|
||||
}
|
||||
return -ENOMEM;
|
||||
|
||||
static void ark3116_init_termios(struct tty_struct *tty)
|
||||
{
|
||||
struct ktermios *termios = tty->termios;
|
||||
*termios = tty_std_termios;
|
||||
termios->c_cflag = B9600 | CS8
|
||||
| CREAD | HUPCL | CLOCAL;
|
||||
termios->c_ispeed = 9600;
|
||||
termios->c_ospeed = 9600;
|
||||
}
|
||||
|
||||
static void ark3116_set_termios(struct tty_struct *tty,
|
||||
|
@ -163,10 +150,8 @@ static void ark3116_set_termios(struct tty_struct *tty,
|
|||
struct ktermios *old_termios)
|
||||
{
|
||||
struct usb_serial *serial = port->serial;
|
||||
struct ark3116_private *priv = usb_get_serial_port_data(port);
|
||||
struct ktermios *termios = tty->termios;
|
||||
unsigned int cflag = termios->c_cflag;
|
||||
unsigned long flags;
|
||||
int baud;
|
||||
int ark3116_baud;
|
||||
char *buf;
|
||||
|
@ -176,16 +161,6 @@ static void ark3116_set_termios(struct tty_struct *tty,
|
|||
|
||||
dbg("%s - port %d", __func__, port->number);
|
||||
|
||||
spin_lock_irqsave(&priv->lock, flags);
|
||||
if (!priv->termios_initialized) {
|
||||
*termios = tty_std_termios;
|
||||
termios->c_cflag = B9600 | CS8
|
||||
| CREAD | HUPCL | CLOCAL;
|
||||
termios->c_ispeed = 9600;
|
||||
termios->c_ospeed = 9600;
|
||||
priv->termios_initialized = 1;
|
||||
}
|
||||
spin_unlock_irqrestore(&priv->lock, flags);
|
||||
|
||||
cflag = termios->c_cflag;
|
||||
termios->c_cflag &= ~(CMSPAR|CRTSCTS);
|
||||
|
@ -318,8 +293,7 @@ static void ark3116_set_termios(struct tty_struct *tty,
|
|||
return;
|
||||
}
|
||||
|
||||
static int ark3116_open(struct tty_struct *tty, struct usb_serial_port *port,
|
||||
struct file *filp)
|
||||
static int ark3116_open(struct tty_struct *tty, struct usb_serial_port *port)
|
||||
{
|
||||
struct ktermios tmp_termios;
|
||||
struct usb_serial *serial = port->serial;
|
||||
|
@ -334,7 +308,7 @@ static int ark3116_open(struct tty_struct *tty, struct usb_serial_port *port,
|
|||
return -ENOMEM;
|
||||
}
|
||||
|
||||
result = usb_serial_generic_open(tty, port, filp);
|
||||
result = usb_serial_generic_open(tty, port);
|
||||
if (result)
|
||||
goto err_out;
|
||||
|
||||
|
@ -455,6 +429,7 @@ static struct usb_serial_driver ark3116_device = {
|
|||
.num_ports = 1,
|
||||
.attach = ark3116_attach,
|
||||
.set_termios = ark3116_set_termios,
|
||||
.init_termios = ark3116_init_termios,
|
||||
.ioctl = ark3116_ioctl,
|
||||
.tiocmget = ark3116_tiocmget,
|
||||
.open = ark3116_open,
|
||||
|
|
|
@ -92,7 +92,7 @@ static int debug;
|
|||
static int belkin_sa_startup(struct usb_serial *serial);
|
||||
static void belkin_sa_release(struct usb_serial *serial);
|
||||
static int belkin_sa_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp);
|
||||
struct usb_serial_port *port);
|
||||
static void belkin_sa_close(struct usb_serial_port *port);
|
||||
static void belkin_sa_read_int_callback(struct urb *urb);
|
||||
static void belkin_sa_set_termios(struct tty_struct *tty,
|
||||
|
@ -213,7 +213,7 @@ static void belkin_sa_release(struct usb_serial *serial)
|
|||
|
||||
|
||||
static int belkin_sa_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp)
|
||||
struct usb_serial_port *port)
|
||||
{
|
||||
int retval = 0;
|
||||
|
||||
|
|
|
@ -300,8 +300,7 @@ static void ch341_close(struct usb_serial_port *port)
|
|||
|
||||
|
||||
/* open this device, set default parameters */
|
||||
static int ch341_open(struct tty_struct *tty, struct usb_serial_port *port,
|
||||
struct file *filp)
|
||||
static int ch341_open(struct tty_struct *tty, struct usb_serial_port *port)
|
||||
{
|
||||
struct usb_serial *serial = port->serial;
|
||||
struct ch341_private *priv = usb_get_serial_port_data(serial->port[0]);
|
||||
|
@ -333,7 +332,7 @@ static int ch341_open(struct tty_struct *tty, struct usb_serial_port *port,
|
|||
return -EPROTO;
|
||||
}
|
||||
|
||||
r = usb_serial_generic_open(tty, port, filp);
|
||||
r = usb_serial_generic_open(tty, port);
|
||||
|
||||
out: return r;
|
||||
}
|
||||
|
|
|
@ -16,6 +16,7 @@
|
|||
#include <linux/slab.h>
|
||||
#include <linux/tty.h>
|
||||
#include <linux/console.h>
|
||||
#include <linux/serial.h>
|
||||
#include <linux/usb.h>
|
||||
#include <linux/usb/serial.h>
|
||||
|
||||
|
@ -63,7 +64,7 @@ static int usb_console_setup(struct console *co, char *options)
|
|||
char *s;
|
||||
struct usb_serial *serial;
|
||||
struct usb_serial_port *port;
|
||||
int retval = 0;
|
||||
int retval;
|
||||
struct tty_struct *tty = NULL;
|
||||
struct ktermios *termios = NULL, dummy;
|
||||
|
||||
|
@ -116,13 +117,17 @@ static int usb_console_setup(struct console *co, char *options)
|
|||
return -ENODEV;
|
||||
}
|
||||
|
||||
port = serial->port[0];
|
||||
retval = usb_autopm_get_interface(serial->interface);
|
||||
if (retval)
|
||||
goto error_get_interface;
|
||||
|
||||
port = serial->port[co->index - serial->minor];
|
||||
tty_port_tty_set(&port->port, NULL);
|
||||
|
||||
info->port = port;
|
||||
|
||||
++port->port.count;
|
||||
if (port->port.count == 1) {
|
||||
if (!test_bit(ASYNCB_INITIALIZED, &port->port.flags)) {
|
||||
if (serial->type->set_termios) {
|
||||
/*
|
||||
* allocate a fake tty so the driver can initialize
|
||||
|
@ -150,9 +155,9 @@ static int usb_console_setup(struct console *co, char *options)
|
|||
/* only call the device specific open if this
|
||||
* is the first time the port is opened */
|
||||
if (serial->type->open)
|
||||
retval = serial->type->open(NULL, port, NULL);
|
||||
retval = serial->type->open(NULL, port);
|
||||
else
|
||||
retval = usb_serial_generic_open(NULL, port, NULL);
|
||||
retval = usb_serial_generic_open(NULL, port);
|
||||
|
||||
if (retval) {
|
||||
err("could not open USB console port");
|
||||
|
@ -168,6 +173,7 @@ static int usb_console_setup(struct console *co, char *options)
|
|||
kfree(termios);
|
||||
kfree(tty);
|
||||
}
|
||||
set_bit(ASYNCB_INITIALIZED, &port->port.flags);
|
||||
}
|
||||
/* Now that any required fake tty operations are completed restore
|
||||
* the tty port count */
|
||||
|
@ -175,10 +181,10 @@ static int usb_console_setup(struct console *co, char *options)
|
|||
/* The console is special in terms of closing the device so
|
||||
* indicate this port is now acting as a system console. */
|
||||
port->console = 1;
|
||||
retval = 0;
|
||||
|
||||
out:
|
||||
mutex_unlock(&serial->disc_mutex);
|
||||
return retval;
|
||||
|
||||
free_termios:
|
||||
kfree(termios);
|
||||
tty_port_tty_set(&port->port, NULL);
|
||||
|
@ -186,7 +192,11 @@ free_tty:
|
|||
kfree(tty);
|
||||
reset_open_count:
|
||||
port->port.count = 0;
|
||||
goto out;
|
||||
usb_autopm_put_interface(serial->interface);
|
||||
error_get_interface:
|
||||
usb_serial_put(serial);
|
||||
mutex_unlock(&serial->disc_mutex);
|
||||
return retval;
|
||||
}
|
||||
|
||||
static void usb_console_write(struct console *co,
|
||||
|
|
|
@ -33,8 +33,7 @@
|
|||
/*
|
||||
* Function Prototypes
|
||||
*/
|
||||
static int cp210x_open(struct tty_struct *, struct usb_serial_port *,
|
||||
struct file *);
|
||||
static int cp210x_open(struct tty_struct *tty, struct usb_serial_port *);
|
||||
static void cp210x_cleanup(struct usb_serial_port *);
|
||||
static void cp210x_close(struct usb_serial_port *);
|
||||
static void cp210x_get_termios(struct tty_struct *,
|
||||
|
@ -368,8 +367,7 @@ static unsigned int cp210x_quantise_baudrate(unsigned int baud) {
|
|||
return baud;
|
||||
}
|
||||
|
||||
static int cp210x_open(struct tty_struct *tty, struct usb_serial_port *port,
|
||||
struct file *filp)
|
||||
static int cp210x_open(struct tty_struct *tty, struct usb_serial_port *port)
|
||||
{
|
||||
struct usb_serial *serial = port->serial;
|
||||
int result;
|
||||
|
@ -399,12 +397,6 @@ static int cp210x_open(struct tty_struct *tty, struct usb_serial_port *port,
|
|||
|
||||
/* Configure the termios structure */
|
||||
cp210x_get_termios(tty, port);
|
||||
|
||||
/* Set the DTR and RTS pins low */
|
||||
cp210x_tiocmset_port(tty ? (struct usb_serial_port *) tty->driver_data
|
||||
: port,
|
||||
NULL, TIOCM_DTR | TIOCM_RTS, 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -61,7 +61,7 @@ static int cyberjack_startup(struct usb_serial *serial);
|
|||
static void cyberjack_disconnect(struct usb_serial *serial);
|
||||
static void cyberjack_release(struct usb_serial *serial);
|
||||
static int cyberjack_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp);
|
||||
struct usb_serial_port *port);
|
||||
static void cyberjack_close(struct usb_serial_port *port);
|
||||
static int cyberjack_write(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, const unsigned char *buf, int count);
|
||||
|
@ -173,7 +173,7 @@ static void cyberjack_release(struct usb_serial *serial)
|
|||
}
|
||||
|
||||
static int cyberjack_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp)
|
||||
struct usb_serial_port *port)
|
||||
{
|
||||
struct cyberjack_private *priv;
|
||||
unsigned long flags;
|
||||
|
|
|
@ -172,8 +172,7 @@ static int cypress_earthmate_startup(struct usb_serial *serial);
|
|||
static int cypress_hidcom_startup(struct usb_serial *serial);
|
||||
static int cypress_ca42v2_startup(struct usb_serial *serial);
|
||||
static void cypress_release(struct usb_serial *serial);
|
||||
static int cypress_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp);
|
||||
static int cypress_open(struct tty_struct *tty, struct usb_serial_port *port);
|
||||
static void cypress_close(struct usb_serial_port *port);
|
||||
static void cypress_dtr_rts(struct usb_serial_port *port, int on);
|
||||
static int cypress_write(struct tty_struct *tty, struct usb_serial_port *port,
|
||||
|
@ -633,8 +632,7 @@ static void cypress_release(struct usb_serial *serial)
|
|||
}
|
||||
|
||||
|
||||
static int cypress_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp)
|
||||
static int cypress_open(struct tty_struct *tty, struct usb_serial_port *port)
|
||||
{
|
||||
struct cypress_private *priv = usb_get_serial_port_data(port);
|
||||
struct usb_serial *serial = port->serial;
|
||||
|
@ -659,15 +657,7 @@ static int cypress_open(struct tty_struct *tty,
|
|||
spin_unlock_irqrestore(&priv->lock, flags);
|
||||
|
||||
/* Set termios */
|
||||
result = cypress_write(tty, port, NULL, 0);
|
||||
|
||||
if (result) {
|
||||
dev_err(&port->dev,
|
||||
"%s - failed setting the control lines - error %d\n",
|
||||
__func__, result);
|
||||
return result;
|
||||
} else
|
||||
dbg("%s - success setting the control lines", __func__);
|
||||
cypress_send(port);
|
||||
|
||||
if (tty)
|
||||
cypress_set_termios(tty, port, &priv->tmp_termios);
|
||||
|
@ -1005,6 +995,8 @@ static void cypress_set_termios(struct tty_struct *tty,
|
|||
dbg("%s - port %d", __func__, port->number);
|
||||
|
||||
spin_lock_irqsave(&priv->lock, flags);
|
||||
/* We can't clean this one up as we don't know the device type
|
||||
early enough */
|
||||
if (!priv->termios_initialized) {
|
||||
if (priv->chiptype == CT_EARTHMATE) {
|
||||
*(tty->termios) = tty_std_termios;
|
||||
|
|
|
@ -453,8 +453,7 @@ static int digi_write(struct tty_struct *tty, struct usb_serial_port *port,
|
|||
static void digi_write_bulk_callback(struct urb *urb);
|
||||
static int digi_write_room(struct tty_struct *tty);
|
||||
static int digi_chars_in_buffer(struct tty_struct *tty);
|
||||
static int digi_open(struct tty_struct *tty, struct usb_serial_port *port,
|
||||
struct file *filp);
|
||||
static int digi_open(struct tty_struct *tty, struct usb_serial_port *port);
|
||||
static void digi_close(struct usb_serial_port *port);
|
||||
static int digi_carrier_raised(struct usb_serial_port *port);
|
||||
static void digi_dtr_rts(struct usb_serial_port *port, int on);
|
||||
|
@ -1347,8 +1346,7 @@ static int digi_carrier_raised(struct usb_serial_port *port)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int digi_open(struct tty_struct *tty, struct usb_serial_port *port,
|
||||
struct file *filp)
|
||||
static int digi_open(struct tty_struct *tty, struct usb_serial_port *port)
|
||||
{
|
||||
int ret;
|
||||
unsigned char buf[32];
|
||||
|
|
|
@ -79,8 +79,7 @@ static int debug;
|
|||
#define EMPEG_PRODUCT_ID 0x0001
|
||||
|
||||
/* function prototypes for an empeg-car player */
|
||||
static int empeg_open(struct tty_struct *tty, struct usb_serial_port *port,
|
||||
struct file *filp);
|
||||
static int empeg_open(struct tty_struct *tty, struct usb_serial_port *port);
|
||||
static void empeg_close(struct usb_serial_port *port);
|
||||
static int empeg_write(struct tty_struct *tty, struct usb_serial_port *port,
|
||||
const unsigned char *buf,
|
||||
|
@ -90,8 +89,7 @@ static int empeg_chars_in_buffer(struct tty_struct *tty);
|
|||
static void empeg_throttle(struct tty_struct *tty);
|
||||
static void empeg_unthrottle(struct tty_struct *tty);
|
||||
static int empeg_startup(struct usb_serial *serial);
|
||||
static void empeg_set_termios(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct ktermios *old_termios);
|
||||
static void empeg_init_termios(struct tty_struct *tty);
|
||||
static void empeg_write_bulk_callback(struct urb *urb);
|
||||
static void empeg_read_bulk_callback(struct urb *urb);
|
||||
|
||||
|
@ -123,7 +121,7 @@ static struct usb_serial_driver empeg_device = {
|
|||
.throttle = empeg_throttle,
|
||||
.unthrottle = empeg_unthrottle,
|
||||
.attach = empeg_startup,
|
||||
.set_termios = empeg_set_termios,
|
||||
.init_termios = empeg_init_termios,
|
||||
.write = empeg_write,
|
||||
.write_room = empeg_write_room,
|
||||
.chars_in_buffer = empeg_chars_in_buffer,
|
||||
|
@ -142,17 +140,13 @@ static int bytes_out;
|
|||
/******************************************************************************
|
||||
* Empeg specific driver functions
|
||||
******************************************************************************/
|
||||
static int empeg_open(struct tty_struct *tty, struct usb_serial_port *port,
|
||||
struct file *filp)
|
||||
static int empeg_open(struct tty_struct *tty,struct usb_serial_port *port)
|
||||
{
|
||||
struct usb_serial *serial = port->serial;
|
||||
int result = 0;
|
||||
|
||||
dbg("%s - port %d", __func__, port->number);
|
||||
|
||||
/* Force default termio settings */
|
||||
empeg_set_termios(tty, port, NULL) ;
|
||||
|
||||
bytes_in = 0;
|
||||
bytes_out = 0;
|
||||
|
||||
|
@ -425,11 +419,9 @@ static int empeg_startup(struct usb_serial *serial)
|
|||
}
|
||||
|
||||
|
||||
static void empeg_set_termios(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct ktermios *old_termios)
|
||||
static void empeg_init_termios(struct tty_struct *tty)
|
||||
{
|
||||
struct ktermios *termios = tty->termios;
|
||||
dbg("%s - port %d", __func__, port->number);
|
||||
|
||||
/*
|
||||
* The empeg-car player wants these particular tty settings.
|
||||
|
|
|
@ -747,8 +747,7 @@ static int ftdi_sio_probe(struct usb_serial *serial,
|
|||
const struct usb_device_id *id);
|
||||
static int ftdi_sio_port_probe(struct usb_serial_port *port);
|
||||
static int ftdi_sio_port_remove(struct usb_serial_port *port);
|
||||
static int ftdi_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp);
|
||||
static int ftdi_open(struct tty_struct *tty, struct usb_serial_port *port);
|
||||
static void ftdi_close(struct usb_serial_port *port);
|
||||
static void ftdi_dtr_rts(struct usb_serial_port *port, int on);
|
||||
static int ftdi_write(struct tty_struct *tty, struct usb_serial_port *port,
|
||||
|
@ -1680,8 +1679,7 @@ static int ftdi_sio_port_remove(struct usb_serial_port *port)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int ftdi_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp)
|
||||
static int ftdi_open(struct tty_struct *tty, struct usb_serial_port *port)
|
||||
{ /* ftdi_open */
|
||||
struct usb_device *dev = port->serial->dev;
|
||||
struct ftdi_private *priv = usb_get_serial_port_data(port);
|
||||
|
|
|
@ -933,8 +933,7 @@ static int garmin_init_session(struct usb_serial_port *port)
|
|||
|
||||
|
||||
|
||||
static int garmin_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp)
|
||||
static int garmin_open(struct tty_struct *tty, struct usb_serial_port *port)
|
||||
{
|
||||
unsigned long flags;
|
||||
int status = 0;
|
||||
|
|
|
@ -114,8 +114,7 @@ void usb_serial_generic_deregister(void)
|
|||
#endif
|
||||
}
|
||||
|
||||
int usb_serial_generic_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp)
|
||||
int usb_serial_generic_open(struct tty_struct *tty, struct usb_serial_port *port)
|
||||
{
|
||||
struct usb_serial *serial = port->serial;
|
||||
int result = 0;
|
||||
|
|
|
@ -205,8 +205,7 @@ static void edge_bulk_out_data_callback(struct urb *urb);
|
|||
static void edge_bulk_out_cmd_callback(struct urb *urb);
|
||||
|
||||
/* function prototypes for the usbserial callbacks */
|
||||
static int edge_open(struct tty_struct *tty, struct usb_serial_port *port,
|
||||
struct file *filp);
|
||||
static int edge_open(struct tty_struct *tty, struct usb_serial_port *port);
|
||||
static void edge_close(struct usb_serial_port *port);
|
||||
static int edge_write(struct tty_struct *tty, struct usb_serial_port *port,
|
||||
const unsigned char *buf, int count);
|
||||
|
@ -852,8 +851,7 @@ static void edge_bulk_out_cmd_callback(struct urb *urb)
|
|||
* If successful, we return 0
|
||||
* Otherwise we return a negative error number.
|
||||
*****************************************************************************/
|
||||
static int edge_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp)
|
||||
static int edge_open(struct tty_struct *tty, struct usb_serial_port *port)
|
||||
{
|
||||
struct edgeport_port *edge_port = usb_get_serial_port_data(port);
|
||||
struct usb_serial *serial;
|
||||
|
|
|
@ -1831,8 +1831,7 @@ static void edge_bulk_out_callback(struct urb *urb)
|
|||
tty_kref_put(tty);
|
||||
}
|
||||
|
||||
static int edge_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp)
|
||||
static int edge_open(struct tty_struct *tty, struct usb_serial_port *port)
|
||||
{
|
||||
struct edgeport_port *edge_port = usb_get_serial_port_data(port);
|
||||
struct edgeport_serial *edge_serial;
|
||||
|
|
|
@ -75,7 +75,7 @@ static int initial_wait;
|
|||
|
||||
/* Function prototypes for an ipaq */
|
||||
static int ipaq_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp);
|
||||
struct usb_serial_port *port);
|
||||
static void ipaq_close(struct usb_serial_port *port);
|
||||
static int ipaq_calc_num_ports(struct usb_serial *serial);
|
||||
static int ipaq_startup(struct usb_serial *serial);
|
||||
|
@ -587,7 +587,7 @@ static int bytes_in;
|
|||
static int bytes_out;
|
||||
|
||||
static int ipaq_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp)
|
||||
struct usb_serial_port *port)
|
||||
{
|
||||
struct usb_serial *serial = port->serial;
|
||||
struct ipaq_private *priv;
|
||||
|
@ -628,11 +628,6 @@ static int ipaq_open(struct tty_struct *tty,
|
|||
priv->free_len += PACKET_SIZE;
|
||||
}
|
||||
|
||||
if (tty) {
|
||||
/* FIXME: These two are bogus */
|
||||
tty->raw = 1;
|
||||
tty->real_raw = 1;
|
||||
}
|
||||
/*
|
||||
* Lose the small buffers usbserial provides. Make larger ones.
|
||||
*/
|
||||
|
|
|
@ -193,8 +193,7 @@ static void ipw_read_bulk_callback(struct urb *urb)
|
|||
return;
|
||||
}
|
||||
|
||||
static int ipw_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp)
|
||||
static int ipw_open(struct tty_struct *tty, struct usb_serial_port *port)
|
||||
{
|
||||
struct usb_device *dev = port->serial->dev;
|
||||
u8 buf_flow_static[16] = IPW_BYTES_FLOWINIT;
|
||||
|
|
|
@ -86,8 +86,7 @@ static int buffer_size;
|
|||
static int xbof = -1;
|
||||
|
||||
static int ir_startup (struct usb_serial *serial);
|
||||
static int ir_open(struct tty_struct *tty, struct usb_serial_port *port,
|
||||
struct file *filep);
|
||||
static int ir_open(struct tty_struct *tty, struct usb_serial_port *port);
|
||||
static void ir_close(struct usb_serial_port *port);
|
||||
static int ir_write(struct tty_struct *tty, struct usb_serial_port *port,
|
||||
const unsigned char *buf, int count);
|
||||
|
@ -296,8 +295,7 @@ static int ir_startup(struct usb_serial *serial)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int ir_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp)
|
||||
static int ir_open(struct tty_struct *tty, struct usb_serial_port *port)
|
||||
{
|
||||
char *buffer;
|
||||
int result = 0;
|
||||
|
|
|
@ -71,7 +71,6 @@ struct iuu_private {
|
|||
spinlock_t lock; /* store irq state */
|
||||
wait_queue_head_t delta_msr_wait;
|
||||
u8 line_status;
|
||||
u8 termios_initialized;
|
||||
int tiostatus; /* store IUART SIGNAL for tiocmget call */
|
||||
u8 reset; /* if 1 reset is needed */
|
||||
int poll; /* number of poll */
|
||||
|
@ -1018,14 +1017,24 @@ static void iuu_close(struct usb_serial_port *port)
|
|||
}
|
||||
}
|
||||
|
||||
static int iuu_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp)
|
||||
static void iuu_init_termios(struct tty_struct *tty)
|
||||
{
|
||||
*(tty->termios) = tty_std_termios;
|
||||
tty->termios->c_cflag = CLOCAL | CREAD | CS8 | B9600
|
||||
| TIOCM_CTS | CSTOPB | PARENB;
|
||||
tty->termios->c_ispeed = 9600;
|
||||
tty->termios->c_ospeed = 9600;
|
||||
tty->termios->c_lflag = 0;
|
||||
tty->termios->c_oflag = 0;
|
||||
tty->termios->c_iflag = 0;
|
||||
}
|
||||
|
||||
static int iuu_open(struct tty_struct *tty, struct usb_serial_port *port)
|
||||
{
|
||||
struct usb_serial *serial = port->serial;
|
||||
u8 *buf;
|
||||
int result;
|
||||
u32 actual;
|
||||
unsigned long flags;
|
||||
struct iuu_private *priv = usb_get_serial_port_data(port);
|
||||
|
||||
dbg("%s - port %d", __func__, port->number);
|
||||
|
@ -1064,21 +1073,7 @@ static int iuu_open(struct tty_struct *tty,
|
|||
port->bulk_in_buffer, 512,
|
||||
NULL, NULL);
|
||||
|
||||
/* set the termios structure */
|
||||
spin_lock_irqsave(&priv->lock, flags);
|
||||
if (tty && !priv->termios_initialized) {
|
||||
*(tty->termios) = tty_std_termios;
|
||||
tty->termios->c_cflag = CLOCAL | CREAD | CS8 | B9600
|
||||
| TIOCM_CTS | CSTOPB | PARENB;
|
||||
tty->termios->c_ispeed = 9600;
|
||||
tty->termios->c_ospeed = 9600;
|
||||
tty->termios->c_lflag = 0;
|
||||
tty->termios->c_oflag = 0;
|
||||
tty->termios->c_iflag = 0;
|
||||
priv->termios_initialized = 1;
|
||||
priv->poll = 0;
|
||||
}
|
||||
spin_unlock_irqrestore(&priv->lock, flags);
|
||||
|
||||
/* initialize writebuf */
|
||||
#define FISH(a, b, c, d) do { \
|
||||
|
@ -1201,6 +1196,7 @@ static struct usb_serial_driver iuu_device = {
|
|||
.tiocmget = iuu_tiocmget,
|
||||
.tiocmset = iuu_tiocmset,
|
||||
.set_termios = iuu_set_termios,
|
||||
.init_termios = iuu_init_termios,
|
||||
.attach = iuu_startup,
|
||||
.release = iuu_release,
|
||||
};
|
||||
|
|
|
@ -1209,8 +1209,7 @@ static int keyspan_write_room(struct tty_struct *tty)
|
|||
}
|
||||
|
||||
|
||||
static int keyspan_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp)
|
||||
static int keyspan_open(struct tty_struct *tty, struct usb_serial_port *port)
|
||||
{
|
||||
struct keyspan_port_private *p_priv;
|
||||
struct keyspan_serial_private *s_priv;
|
||||
|
|
|
@ -36,8 +36,7 @@
|
|||
|
||||
/* Function prototypes for Keyspan serial converter */
|
||||
static int keyspan_open (struct tty_struct *tty,
|
||||
struct usb_serial_port *port,
|
||||
struct file *filp);
|
||||
struct usb_serial_port *port);
|
||||
static void keyspan_close (struct usb_serial_port *port);
|
||||
static void keyspan_dtr_rts (struct usb_serial_port *port, int on);
|
||||
static int keyspan_startup (struct usb_serial *serial);
|
||||
|
|
|
@ -681,7 +681,7 @@ static int keyspan_pda_carrier_raised(struct usb_serial_port *port)
|
|||
|
||||
|
||||
static int keyspan_pda_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp)
|
||||
struct usb_serial_port *port)
|
||||
{
|
||||
struct usb_serial *serial = port->serial;
|
||||
unsigned char room;
|
||||
|
|
|
@ -75,8 +75,7 @@ static int debug;
|
|||
static int klsi_105_startup(struct usb_serial *serial);
|
||||
static void klsi_105_disconnect(struct usb_serial *serial);
|
||||
static void klsi_105_release(struct usb_serial *serial);
|
||||
static int klsi_105_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp);
|
||||
static int klsi_105_open(struct tty_struct *tty, struct usb_serial_port *port);
|
||||
static void klsi_105_close(struct usb_serial_port *port);
|
||||
static int klsi_105_write(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, const unsigned char *buf, int count);
|
||||
|
@ -358,8 +357,7 @@ static void klsi_105_release(struct usb_serial *serial)
|
|||
}
|
||||
} /* klsi_105_release */
|
||||
|
||||
static int klsi_105_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp)
|
||||
static int klsi_105_open(struct tty_struct *tty, struct usb_serial_port *port)
|
||||
{
|
||||
struct klsi_105_private *priv = usb_get_serial_port_data(port);
|
||||
int retval = 0;
|
||||
|
@ -371,10 +369,6 @@ static int klsi_105_open(struct tty_struct *tty,
|
|||
|
||||
dbg("%s port %d", __func__, port->number);
|
||||
|
||||
/* force low_latency on so that our tty_push actually forces
|
||||
* the data through
|
||||
* tty->low_latency = 1; */
|
||||
|
||||
/* Do a defined restart:
|
||||
* Set up sane default baud rate and send the 'READ_ON'
|
||||
* vendor command.
|
||||
|
|
|
@ -70,8 +70,7 @@ static int debug;
|
|||
/* Function prototypes */
|
||||
static int kobil_startup(struct usb_serial *serial);
|
||||
static void kobil_release(struct usb_serial *serial);
|
||||
static int kobil_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp);
|
||||
static int kobil_open(struct tty_struct *tty, struct usb_serial_port *port);
|
||||
static void kobil_close(struct usb_serial_port *port);
|
||||
static int kobil_write(struct tty_struct *tty, struct usb_serial_port *port,
|
||||
const unsigned char *buf, int count);
|
||||
|
@ -85,7 +84,7 @@ static void kobil_read_int_callback(struct urb *urb);
|
|||
static void kobil_write_callback(struct urb *purb);
|
||||
static void kobil_set_termios(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct ktermios *old);
|
||||
|
||||
static void kobil_init_termios(struct tty_struct *tty);
|
||||
|
||||
static struct usb_device_id id_table [] = {
|
||||
{ USB_DEVICE(KOBIL_VENDOR_ID, KOBIL_ADAPTER_B_PRODUCT_ID) },
|
||||
|
@ -120,6 +119,7 @@ static struct usb_serial_driver kobil_device = {
|
|||
.release = kobil_release,
|
||||
.ioctl = kobil_ioctl,
|
||||
.set_termios = kobil_set_termios,
|
||||
.init_termios = kobil_init_termios,
|
||||
.tiocmget = kobil_tiocmget,
|
||||
.tiocmset = kobil_tiocmset,
|
||||
.open = kobil_open,
|
||||
|
@ -210,9 +210,17 @@ static void kobil_release(struct usb_serial *serial)
|
|||
kfree(usb_get_serial_port_data(serial->port[i]));
|
||||
}
|
||||
|
||||
static void kobil_init_termios(struct tty_struct *tty)
|
||||
{
|
||||
/* Default to echo off and other sane device settings */
|
||||
tty->termios->c_lflag = 0;
|
||||
tty->termios->c_lflag &= ~(ISIG | ICANON | ECHO | IEXTEN | XCASE);
|
||||
tty->termios->c_iflag = IGNBRK | IGNPAR | IXOFF;
|
||||
/* do NOT translate CR to CR-NL (0x0A -> 0x0A 0x0D) */
|
||||
tty->termios->c_oflag &= ~ONLCR;
|
||||
}
|
||||
|
||||
static int kobil_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp)
|
||||
static int kobil_open(struct tty_struct *tty, struct usb_serial_port *port)
|
||||
{
|
||||
int result = 0;
|
||||
struct kobil_private *priv;
|
||||
|
@ -226,16 +234,6 @@ static int kobil_open(struct tty_struct *tty,
|
|||
/* someone sets the dev to 0 if the close method has been called */
|
||||
port->interrupt_in_urb->dev = port->serial->dev;
|
||||
|
||||
if (tty) {
|
||||
|
||||
/* Default to echo off and other sane device settings */
|
||||
tty->termios->c_lflag = 0;
|
||||
tty->termios->c_lflag &= ~(ISIG | ICANON | ECHO | IEXTEN |
|
||||
XCASE);
|
||||
tty->termios->c_iflag = IGNBRK | IGNPAR | IXOFF;
|
||||
/* do NOT translate CR to CR-NL (0x0A -> 0x0A 0x0D) */
|
||||
tty->termios->c_oflag &= ~ONLCR;
|
||||
}
|
||||
/* allocate memory for transfer buffer */
|
||||
transfer_buffer = kzalloc(transfer_buffer_length, GFP_KERNEL);
|
||||
if (!transfer_buffer)
|
||||
|
|
|
@ -93,8 +93,7 @@ static int debug;
|
|||
*/
|
||||
static int mct_u232_startup(struct usb_serial *serial);
|
||||
static void mct_u232_release(struct usb_serial *serial);
|
||||
static int mct_u232_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp);
|
||||
static int mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port);
|
||||
static void mct_u232_close(struct usb_serial_port *port);
|
||||
static void mct_u232_dtr_rts(struct usb_serial_port *port, int on);
|
||||
static void mct_u232_read_int_callback(struct urb *urb);
|
||||
|
@ -421,8 +420,7 @@ static void mct_u232_release(struct usb_serial *serial)
|
|||
}
|
||||
} /* mct_u232_release */
|
||||
|
||||
static int mct_u232_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp)
|
||||
static int mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port)
|
||||
{
|
||||
struct usb_serial *serial = port->serial;
|
||||
struct mct_u232_private *priv = usb_get_serial_port_data(port);
|
||||
|
@ -568,10 +566,13 @@ static void mct_u232_read_int_callback(struct urb *urb)
|
|||
* Work-a-round: handle the 'usual' bulk-in pipe here
|
||||
*/
|
||||
if (urb->transfer_buffer_length > 2) {
|
||||
tty = tty_port_tty_get(&port->port);
|
||||
if (urb->actual_length) {
|
||||
tty_insert_flip_string(tty, data, urb->actual_length);
|
||||
tty = tty_port_tty_get(&port->port);
|
||||
if (tty) {
|
||||
tty_insert_flip_string(tty, data,
|
||||
urb->actual_length);
|
||||
tty_flip_buffer_push(tty);
|
||||
}
|
||||
tty_kref_put(tty);
|
||||
}
|
||||
goto exit;
|
||||
|
|
|
@ -319,8 +319,7 @@ static int send_mos_cmd(struct usb_serial *serial, __u8 request, __u16 value,
|
|||
return status;
|
||||
}
|
||||
|
||||
static int mos7720_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp)
|
||||
static int mos7720_open(struct tty_struct *tty, struct usb_serial_port *port)
|
||||
{
|
||||
struct usb_serial *serial;
|
||||
struct usb_serial_port *port0;
|
||||
|
@ -378,10 +377,14 @@ static int mos7720_open(struct tty_struct *tty,
|
|||
/* Initialize MCS7720 -- Write Init values to corresponding Registers
|
||||
*
|
||||
* Register Index
|
||||
* 0 : THR/RHR
|
||||
* 1 : IER
|
||||
* 2 : FCR
|
||||
* 3 : LCR
|
||||
* 4 : MCR
|
||||
* 5 : LSR
|
||||
* 6 : MSR
|
||||
* 7 : SPR
|
||||
*
|
||||
* 0x08 : SP1/2 Control Reg
|
||||
*/
|
||||
|
@ -1250,20 +1253,88 @@ static void mos7720_set_termios(struct tty_struct *tty,
|
|||
static int get_lsr_info(struct tty_struct *tty,
|
||||
struct moschip_port *mos7720_port, unsigned int __user *value)
|
||||
{
|
||||
int count;
|
||||
struct usb_serial_port *port = tty->driver_data;
|
||||
unsigned int result = 0;
|
||||
unsigned char data = 0;
|
||||
int port_number = port->number - port->serial->minor;
|
||||
int count;
|
||||
|
||||
count = mos7720_chars_in_buffer(tty);
|
||||
if (count == 0) {
|
||||
send_mos_cmd(port->serial, MOS_READ, port_number,
|
||||
UART_LSR, &data);
|
||||
if ((data & (UART_LSR_TEMT | UART_LSR_THRE))
|
||||
== (UART_LSR_TEMT | UART_LSR_THRE)) {
|
||||
dbg("%s -- Empty", __func__);
|
||||
result = TIOCSER_TEMT;
|
||||
}
|
||||
|
||||
}
|
||||
if (copy_to_user(value, &result, sizeof(int)))
|
||||
return -EFAULT;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int mos7720_tiocmget(struct tty_struct *tty, struct file *file)
|
||||
{
|
||||
struct usb_serial_port *port = tty->driver_data;
|
||||
struct moschip_port *mos7720_port = usb_get_serial_port_data(port);
|
||||
unsigned int result = 0;
|
||||
unsigned int mcr ;
|
||||
unsigned int msr ;
|
||||
|
||||
dbg("%s - port %d", __func__, port->number);
|
||||
|
||||
mcr = mos7720_port->shadowMCR;
|
||||
msr = mos7720_port->shadowMSR;
|
||||
|
||||
result = ((mcr & UART_MCR_DTR) ? TIOCM_DTR : 0) /* 0x002 */
|
||||
| ((mcr & UART_MCR_RTS) ? TIOCM_RTS : 0) /* 0x004 */
|
||||
| ((msr & UART_MSR_CTS) ? TIOCM_CTS : 0) /* 0x020 */
|
||||
| ((msr & UART_MSR_DCD) ? TIOCM_CAR : 0) /* 0x040 */
|
||||
| ((msr & UART_MSR_RI) ? TIOCM_RI : 0) /* 0x080 */
|
||||
| ((msr & UART_MSR_DSR) ? TIOCM_DSR : 0); /* 0x100 */
|
||||
|
||||
dbg("%s -- %x", __func__, result);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static int mos7720_tiocmset(struct tty_struct *tty, struct file *file,
|
||||
unsigned int set, unsigned int clear)
|
||||
{
|
||||
struct usb_serial_port *port = tty->driver_data;
|
||||
struct moschip_port *mos7720_port = usb_get_serial_port_data(port);
|
||||
unsigned int mcr ;
|
||||
unsigned char lmcr;
|
||||
|
||||
dbg("%s - port %d", __func__, port->number);
|
||||
dbg("he was at tiocmget");
|
||||
|
||||
mcr = mos7720_port->shadowMCR;
|
||||
|
||||
if (set & TIOCM_RTS)
|
||||
mcr |= UART_MCR_RTS;
|
||||
if (set & TIOCM_DTR)
|
||||
mcr |= UART_MCR_DTR;
|
||||
if (set & TIOCM_LOOP)
|
||||
mcr |= UART_MCR_LOOP;
|
||||
|
||||
if (clear & TIOCM_RTS)
|
||||
mcr &= ~UART_MCR_RTS;
|
||||
if (clear & TIOCM_DTR)
|
||||
mcr &= ~UART_MCR_DTR;
|
||||
if (clear & TIOCM_LOOP)
|
||||
mcr &= ~UART_MCR_LOOP;
|
||||
|
||||
mos7720_port->shadowMCR = mcr;
|
||||
lmcr = mos7720_port->shadowMCR;
|
||||
|
||||
send_mos_cmd(port->serial, MOS_WRITE,
|
||||
port->number - port->serial->minor, UART_MCR, &lmcr);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int set_modem_info(struct moschip_port *mos7720_port, unsigned int cmd,
|
||||
unsigned int __user *value)
|
||||
{
|
||||
|
@ -1301,14 +1372,6 @@ static int set_modem_info(struct moschip_port *mos7720_port, unsigned int cmd,
|
|||
mcr &= ~UART_MCR_LOOP;
|
||||
break;
|
||||
|
||||
case TIOCMSET:
|
||||
/* turn off the RTS and DTR and LOOPBACK
|
||||
* and then only turn on what was asked to */
|
||||
mcr &= ~(UART_MCR_RTS | UART_MCR_DTR | UART_MCR_LOOP);
|
||||
mcr |= ((arg & TIOCM_RTS) ? UART_MCR_RTS : 0);
|
||||
mcr |= ((arg & TIOCM_DTR) ? UART_MCR_DTR : 0);
|
||||
mcr |= ((arg & TIOCM_LOOP) ? UART_MCR_LOOP : 0);
|
||||
break;
|
||||
}
|
||||
|
||||
mos7720_port->shadowMCR = mcr;
|
||||
|
@ -1320,28 +1383,6 @@ static int set_modem_info(struct moschip_port *mos7720_port, unsigned int cmd,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int get_modem_info(struct moschip_port *mos7720_port,
|
||||
unsigned int __user *value)
|
||||
{
|
||||
unsigned int result = 0;
|
||||
unsigned int msr = mos7720_port->shadowMSR;
|
||||
unsigned int mcr = mos7720_port->shadowMCR;
|
||||
|
||||
result = ((mcr & UART_MCR_DTR) ? TIOCM_DTR: 0) /* 0x002 */
|
||||
| ((mcr & UART_MCR_RTS) ? TIOCM_RTS: 0) /* 0x004 */
|
||||
| ((msr & UART_MSR_CTS) ? TIOCM_CTS: 0) /* 0x020 */
|
||||
| ((msr & UART_MSR_DCD) ? TIOCM_CAR: 0) /* 0x040 */
|
||||
| ((msr & UART_MSR_RI) ? TIOCM_RI: 0) /* 0x080 */
|
||||
| ((msr & UART_MSR_DSR) ? TIOCM_DSR: 0); /* 0x100 */
|
||||
|
||||
|
||||
dbg("%s -- %x", __func__, result);
|
||||
|
||||
if (copy_to_user(value, &result, sizeof(int)))
|
||||
return -EFAULT;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int get_serial_info(struct moschip_port *mos7720_port,
|
||||
struct serial_struct __user *retinfo)
|
||||
{
|
||||
|
@ -1392,17 +1433,11 @@ static int mos7720_ioctl(struct tty_struct *tty, struct file *file,
|
|||
/* FIXME: These should be using the mode methods */
|
||||
case TIOCMBIS:
|
||||
case TIOCMBIC:
|
||||
case TIOCMSET:
|
||||
dbg("%s (%d) TIOCMSET/TIOCMBIC/TIOCMSET",
|
||||
__func__, port->number);
|
||||
return set_modem_info(mos7720_port, cmd,
|
||||
(unsigned int __user *)arg);
|
||||
|
||||
case TIOCMGET:
|
||||
dbg("%s (%d) TIOCMGET", __func__, port->number);
|
||||
return get_modem_info(mos7720_port,
|
||||
(unsigned int __user *)arg);
|
||||
|
||||
case TIOCGSERIAL:
|
||||
dbg("%s (%d) TIOCGSERIAL", __func__, port->number);
|
||||
return get_serial_info(mos7720_port,
|
||||
|
@ -1557,6 +1592,8 @@ static struct usb_serial_driver moschip7720_2port_driver = {
|
|||
.attach = mos7720_startup,
|
||||
.release = mos7720_release,
|
||||
.ioctl = mos7720_ioctl,
|
||||
.tiocmget = mos7720_tiocmget,
|
||||
.tiocmset = mos7720_tiocmset,
|
||||
.set_termios = mos7720_set_termios,
|
||||
.write = mos7720_write,
|
||||
.write_room = mos7720_write_room,
|
||||
|
|
|
@ -824,8 +824,7 @@ static int mos7840_serial_probe(struct usb_serial *serial,
|
|||
* Otherwise we return a negative error number.
|
||||
*****************************************************************************/
|
||||
|
||||
static int mos7840_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp)
|
||||
static int mos7840_open(struct tty_struct *tty, struct usb_serial_port *port)
|
||||
{
|
||||
int response;
|
||||
int j;
|
||||
|
@ -2133,106 +2132,6 @@ static int mos7840_get_lsr_info(struct tty_struct *tty,
|
|||
return 0;
|
||||
}
|
||||
|
||||
/*****************************************************************************
|
||||
* mos7840_set_modem_info
|
||||
* function to set modem info
|
||||
*****************************************************************************/
|
||||
|
||||
/* FIXME: Should be using the model control hooks */
|
||||
|
||||
static int mos7840_set_modem_info(struct moschip_port *mos7840_port,
|
||||
unsigned int cmd, unsigned int __user *value)
|
||||
{
|
||||
unsigned int mcr;
|
||||
unsigned int arg;
|
||||
__u16 Data;
|
||||
int status;
|
||||
struct usb_serial_port *port;
|
||||
|
||||
if (mos7840_port == NULL)
|
||||
return -1;
|
||||
|
||||
port = (struct usb_serial_port *)mos7840_port->port;
|
||||
if (mos7840_port_paranoia_check(port, __func__)) {
|
||||
dbg("%s", "Invalid port");
|
||||
return -1;
|
||||
}
|
||||
|
||||
mcr = mos7840_port->shadowMCR;
|
||||
|
||||
if (copy_from_user(&arg, value, sizeof(int)))
|
||||
return -EFAULT;
|
||||
|
||||
switch (cmd) {
|
||||
case TIOCMBIS:
|
||||
if (arg & TIOCM_RTS)
|
||||
mcr |= MCR_RTS;
|
||||
if (arg & TIOCM_DTR)
|
||||
mcr |= MCR_RTS;
|
||||
if (arg & TIOCM_LOOP)
|
||||
mcr |= MCR_LOOPBACK;
|
||||
break;
|
||||
|
||||
case TIOCMBIC:
|
||||
if (arg & TIOCM_RTS)
|
||||
mcr &= ~MCR_RTS;
|
||||
if (arg & TIOCM_DTR)
|
||||
mcr &= ~MCR_RTS;
|
||||
if (arg & TIOCM_LOOP)
|
||||
mcr &= ~MCR_LOOPBACK;
|
||||
break;
|
||||
|
||||
case TIOCMSET:
|
||||
/* turn off the RTS and DTR and LOOPBACK
|
||||
* and then only turn on what was asked to */
|
||||
mcr &= ~(MCR_RTS | MCR_DTR | MCR_LOOPBACK);
|
||||
mcr |= ((arg & TIOCM_RTS) ? MCR_RTS : 0);
|
||||
mcr |= ((arg & TIOCM_DTR) ? MCR_DTR : 0);
|
||||
mcr |= ((arg & TIOCM_LOOP) ? MCR_LOOPBACK : 0);
|
||||
break;
|
||||
}
|
||||
|
||||
lock_kernel();
|
||||
mos7840_port->shadowMCR = mcr;
|
||||
|
||||
Data = mos7840_port->shadowMCR;
|
||||
status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data);
|
||||
unlock_kernel();
|
||||
if (status < 0) {
|
||||
dbg("setting MODEM_CONTROL_REGISTER Failed");
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*****************************************************************************
|
||||
* mos7840_get_modem_info
|
||||
* function to get modem info
|
||||
*****************************************************************************/
|
||||
|
||||
static int mos7840_get_modem_info(struct moschip_port *mos7840_port,
|
||||
unsigned int __user *value)
|
||||
{
|
||||
unsigned int result = 0;
|
||||
__u16 msr;
|
||||
unsigned int mcr = mos7840_port->shadowMCR;
|
||||
mos7840_get_uart_reg(mos7840_port->port,
|
||||
MODEM_STATUS_REGISTER, &msr);
|
||||
result = ((mcr & MCR_DTR) ? TIOCM_DTR : 0) /* 0x002 */
|
||||
|((mcr & MCR_RTS) ? TIOCM_RTS : 0) /* 0x004 */
|
||||
|((msr & MOS7840_MSR_CTS) ? TIOCM_CTS : 0) /* 0x020 */
|
||||
|((msr & MOS7840_MSR_CD) ? TIOCM_CAR : 0) /* 0x040 */
|
||||
|((msr & MOS7840_MSR_RI) ? TIOCM_RI : 0) /* 0x080 */
|
||||
|((msr & MOS7840_MSR_DSR) ? TIOCM_DSR : 0); /* 0x100 */
|
||||
|
||||
dbg("%s -- %x", __func__, result);
|
||||
|
||||
if (copy_to_user(value, &result, sizeof(int)))
|
||||
return -EFAULT;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*****************************************************************************
|
||||
* mos7840_get_serial_info
|
||||
* function to get information about serial port
|
||||
|
@ -2281,7 +2180,6 @@ static int mos7840_ioctl(struct tty_struct *tty, struct file *file,
|
|||
struct async_icount cnow;
|
||||
struct async_icount cprev;
|
||||
struct serial_icounter_struct icount;
|
||||
int mosret = 0;
|
||||
|
||||
if (mos7840_port_paranoia_check(port, __func__)) {
|
||||
dbg("%s", "Invalid port");
|
||||
|
@ -2303,20 +2201,6 @@ static int mos7840_ioctl(struct tty_struct *tty, struct file *file,
|
|||
return mos7840_get_lsr_info(tty, argp);
|
||||
return 0;
|
||||
|
||||
/* FIXME: use the modem hooks and remove this */
|
||||
case TIOCMBIS:
|
||||
case TIOCMBIC:
|
||||
case TIOCMSET:
|
||||
dbg("%s (%d) TIOCMSET/TIOCMBIC/TIOCMSET", __func__,
|
||||
port->number);
|
||||
mosret =
|
||||
mos7840_set_modem_info(mos7840_port, cmd, argp);
|
||||
return mosret;
|
||||
|
||||
case TIOCMGET:
|
||||
dbg("%s (%d) TIOCMGET", __func__, port->number);
|
||||
return mos7840_get_modem_info(mos7840_port, argp);
|
||||
|
||||
case TIOCGSERIAL:
|
||||
dbg("%s (%d) TIOCGSERIAL", __func__, port->number);
|
||||
return mos7840_get_serial_info(mos7840_port, argp);
|
||||
|
|
|
@ -80,8 +80,7 @@ exit:
|
|||
__func__, result);
|
||||
}
|
||||
|
||||
static int navman_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp)
|
||||
static int navman_open(struct tty_struct *tty, struct usb_serial_port *port)
|
||||
{
|
||||
int result = 0;
|
||||
|
||||
|
|
|
@ -64,8 +64,7 @@ static int debug;
|
|||
#define BT_IGNITIONPRO_ID 0x2000
|
||||
|
||||
/* function prototypes */
|
||||
static int omninet_open(struct tty_struct *tty, struct usb_serial_port *port,
|
||||
struct file *filp);
|
||||
static int omninet_open(struct tty_struct *tty, struct usb_serial_port *port);
|
||||
static void omninet_close(struct usb_serial_port *port);
|
||||
static void omninet_read_bulk_callback(struct urb *urb);
|
||||
static void omninet_write_bulk_callback(struct urb *urb);
|
||||
|
@ -163,8 +162,7 @@ static int omninet_attach(struct usb_serial *serial)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int omninet_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp)
|
||||
static int omninet_open(struct tty_struct *tty, struct usb_serial_port *port)
|
||||
{
|
||||
struct usb_serial *serial = port->serial;
|
||||
struct usb_serial_port *wport;
|
||||
|
|
|
@ -144,8 +144,7 @@ exit:
|
|||
spin_unlock(&priv->lock);
|
||||
}
|
||||
|
||||
static int opticon_open(struct tty_struct *tty, struct usb_serial_port *port,
|
||||
struct file *filp)
|
||||
static int opticon_open(struct tty_struct *tty, struct usb_serial_port *port)
|
||||
{
|
||||
struct opticon_private *priv = usb_get_serial_data(port->serial);
|
||||
unsigned long flags;
|
||||
|
|
|
@ -45,8 +45,7 @@
|
|||
/* Function prototypes */
|
||||
static int option_probe(struct usb_serial *serial,
|
||||
const struct usb_device_id *id);
|
||||
static int option_open(struct tty_struct *tty, struct usb_serial_port *port,
|
||||
struct file *filp);
|
||||
static int option_open(struct tty_struct *tty, struct usb_serial_port *port);
|
||||
static void option_close(struct usb_serial_port *port);
|
||||
static void option_dtr_rts(struct usb_serial_port *port, int on);
|
||||
|
||||
|
@ -961,8 +960,7 @@ static int option_chars_in_buffer(struct tty_struct *tty)
|
|||
return data_len;
|
||||
}
|
||||
|
||||
static int option_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp)
|
||||
static int option_open(struct tty_struct *tty, struct usb_serial_port *port)
|
||||
{
|
||||
struct option_port_private *portdata;
|
||||
int i, err;
|
||||
|
|
|
@ -141,11 +141,11 @@ struct oti6858_control_pkt {
|
|||
&& ((a)->frame_fmt == (priv)->pending_setup.frame_fmt))
|
||||
|
||||
/* function prototypes */
|
||||
static int oti6858_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp);
|
||||
static int oti6858_open(struct tty_struct *tty, struct usb_serial_port *port);
|
||||
static void oti6858_close(struct usb_serial_port *port);
|
||||
static void oti6858_set_termios(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct ktermios *old);
|
||||
static void oti6858_init_termios(struct tty_struct *tty);
|
||||
static int oti6858_ioctl(struct tty_struct *tty, struct file *file,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
static void oti6858_read_int_callback(struct urb *urb);
|
||||
|
@ -186,6 +186,7 @@ static struct usb_serial_driver oti6858_device = {
|
|||
.write = oti6858_write,
|
||||
.ioctl = oti6858_ioctl,
|
||||
.set_termios = oti6858_set_termios,
|
||||
.init_termios = oti6858_init_termios,
|
||||
.tiocmget = oti6858_tiocmget,
|
||||
.tiocmset = oti6858_tiocmset,
|
||||
.read_bulk_callback = oti6858_read_bulk_callback,
|
||||
|
@ -206,7 +207,6 @@ struct oti6858_private {
|
|||
struct {
|
||||
u8 read_urb_in_use;
|
||||
u8 write_urb_in_use;
|
||||
u8 termios_initialized;
|
||||
} flags;
|
||||
struct delayed_work delayed_write_work;
|
||||
|
||||
|
@ -447,6 +447,14 @@ static int oti6858_chars_in_buffer(struct tty_struct *tty)
|
|||
return chars;
|
||||
}
|
||||
|
||||
static void oti6858_init_termios(struct tty_struct *tty)
|
||||
{
|
||||
*(tty->termios) = tty_std_termios;
|
||||
tty->termios->c_cflag = B38400 | CS8 | CREAD | HUPCL | CLOCAL;
|
||||
tty->termios->c_ispeed = 38400;
|
||||
tty->termios->c_ospeed = 38400;
|
||||
}
|
||||
|
||||
static void oti6858_set_termios(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct ktermios *old_termios)
|
||||
{
|
||||
|
@ -464,16 +472,6 @@ static void oti6858_set_termios(struct tty_struct *tty,
|
|||
return;
|
||||
}
|
||||
|
||||
spin_lock_irqsave(&priv->lock, flags);
|
||||
if (!priv->flags.termios_initialized) {
|
||||
*(tty->termios) = tty_std_termios;
|
||||
tty->termios->c_cflag = B38400 | CS8 | CREAD | HUPCL | CLOCAL;
|
||||
tty->termios->c_ispeed = 38400;
|
||||
tty->termios->c_ospeed = 38400;
|
||||
priv->flags.termios_initialized = 1;
|
||||
}
|
||||
spin_unlock_irqrestore(&priv->lock, flags);
|
||||
|
||||
cflag = tty->termios->c_cflag;
|
||||
|
||||
spin_lock_irqsave(&priv->lock, flags);
|
||||
|
@ -566,8 +564,7 @@ static void oti6858_set_termios(struct tty_struct *tty,
|
|||
spin_unlock_irqrestore(&priv->lock, flags);
|
||||
}
|
||||
|
||||
static int oti6858_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp)
|
||||
static int oti6858_open(struct tty_struct *tty, struct usb_serial_port *port)
|
||||
{
|
||||
struct oti6858_private *priv = usb_get_serial_port_data(port);
|
||||
struct ktermios tmp_termios;
|
||||
|
|
|
@ -691,8 +691,7 @@ static void pl2303_close(struct usb_serial_port *port)
|
|||
|
||||
}
|
||||
|
||||
static int pl2303_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp)
|
||||
static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
|
||||
{
|
||||
struct ktermios tmp_termios;
|
||||
struct usb_serial *serial = port->serial;
|
||||
|
@ -714,8 +713,6 @@ static int pl2303_open(struct tty_struct *tty,
|
|||
if (tty)
|
||||
pl2303_set_termios(tty, port, &tmp_termios);
|
||||
|
||||
/* FIXME: need to assert RTS and DTR if CRTSCTS off */
|
||||
|
||||
dbg("%s - submitting read urb", __func__);
|
||||
port->read_urb->dev = serial->dev;
|
||||
result = usb_submit_urb(port->read_urb, GFP_KERNEL);
|
||||
|
|
|
@ -734,8 +734,7 @@ static void sierra_close(struct usb_serial_port *port)
|
|||
}
|
||||
}
|
||||
|
||||
static int sierra_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp)
|
||||
static int sierra_open(struct tty_struct *tty, struct usb_serial_port *port)
|
||||
{
|
||||
struct sierra_port_private *portdata;
|
||||
struct usb_serial *serial = port->serial;
|
||||
|
|
|
@ -299,7 +299,6 @@ struct spcp8x5_private {
|
|||
wait_queue_head_t delta_msr_wait;
|
||||
u8 line_control;
|
||||
u8 line_status;
|
||||
u8 termios_initialized;
|
||||
};
|
||||
|
||||
/* desc : when device plug in,this function would be called.
|
||||
|
@ -498,6 +497,15 @@ static void spcp8x5_close(struct usb_serial_port *port)
|
|||
dev_dbg(&port->dev, "usb_unlink_urb(read_urb) = %d\n", result);
|
||||
}
|
||||
|
||||
static void spcp8x5_init_termios(struct tty_struct *tty)
|
||||
{
|
||||
/* for the 1st time call this function */
|
||||
*(tty->termios) = tty_std_termios;
|
||||
tty->termios->c_cflag = B115200 | CS8 | CREAD | HUPCL | CLOCAL;
|
||||
tty->termios->c_ispeed = 115200;
|
||||
tty->termios->c_ospeed = 115200;
|
||||
}
|
||||
|
||||
/* set the serial param for transfer. we should check if we really need to
|
||||
* transfer. if we set flow control we should do this too. */
|
||||
static void spcp8x5_set_termios(struct tty_struct *tty,
|
||||
|
@ -514,16 +522,6 @@ static void spcp8x5_set_termios(struct tty_struct *tty,
|
|||
int i;
|
||||
u8 control;
|
||||
|
||||
/* for the 1st time call this function */
|
||||
spin_lock_irqsave(&priv->lock, flags);
|
||||
if (!priv->termios_initialized) {
|
||||
*(tty->termios) = tty_std_termios;
|
||||
tty->termios->c_cflag = B115200 | CS8 | CREAD | HUPCL | CLOCAL;
|
||||
tty->termios->c_ispeed = 115200;
|
||||
tty->termios->c_ospeed = 115200;
|
||||
priv->termios_initialized = 1;
|
||||
}
|
||||
spin_unlock_irqrestore(&priv->lock, flags);
|
||||
|
||||
/* check that they really want us to change something */
|
||||
if (!tty_termios_hw_change(tty->termios, old_termios))
|
||||
|
@ -623,8 +621,7 @@ static void spcp8x5_set_termios(struct tty_struct *tty,
|
|||
|
||||
/* open the serial port. do some usb system call. set termios and get the line
|
||||
* status of the device. then submit the read urb */
|
||||
static int spcp8x5_open(struct tty_struct *tty,
|
||||
struct usb_serial_port *port, struct file *filp)
|
||||
static int spcp8x5_open(struct tty_struct *tty, struct usb_serial_port *port)
|
||||
{
|
||||
struct ktermios tmp_termios;
|
||||
struct usb_serial *serial = port->serial;
|
||||
|
@ -658,8 +655,6 @@ static int spcp8x5_open(struct tty_struct *tty,
|
|||
priv->line_status = status & 0xf0 ;
|
||||
spin_unlock_irqrestore(&priv->lock, flags);
|
||||
|
||||
/* FIXME: need to assert RTS and DTR if CRTSCTS off */
|
||||
|
||||
dbg("%s - submitting read urb", __func__);
|
||||
port->read_urb->dev = serial->dev;
|
||||
ret = usb_submit_urb(port->read_urb, GFP_KERNEL);
|
||||
|
@ -1011,6 +1006,7 @@ static struct usb_serial_driver spcp8x5_device = {
|
|||
.carrier_raised = spcp8x5_carrier_raised,
|
||||
.write = spcp8x5_write,
|
||||
.set_termios = spcp8x5_set_termios,
|
||||
.init_termios = spcp8x5_init_termios,
|
||||
.ioctl = spcp8x5_ioctl,
|
||||
.tiocmget = spcp8x5_tiocmget,
|
||||
.tiocmset = spcp8x5_tiocmset,
|
||||
|
|
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue