Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-09-25 01:13:04 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/tty-2.6

Browse Source 
* git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/tty-2.6: (36 commits)
  jsm: fixing error if the driver fails to load
  jsm: removing the uart structure and filename on error
  tty: Add a new VT mode which is like VT_PROCESS but doesn't require a VT_RELDISP ioctl call
  tty: Keep the default buffering to sub-page units
  tty: Fix up char drivers request_room usage
  tty: Fix the ldisc hangup race
  serial: timberdale: Remove dependancies
  nozomi: Tidy up the PCI table
  nozomi: Fix mutex handling
  nozomi: Add tty_port usage
  sdio_uart: Use kfifo instead of the messy circ stuff
  serial: bcm63xx_uart: allow more than one uart to be registered.
  serial: bcm63xx_uart: don't use kfree() on non kmalloced area.
  serial: bfin_5xx: pull in linux/io.h for ioremap prototypes
  serial: bfin_5xx: kgdboc should accept gdb break only when it is active
  serial: bfin_5xx: need to disable DMA TX interrupt too
  serial: bfin_5xx: remove useless gpio handling with hard flow control
  Char: synclink, remove unnecessary checks
  tty: declare MODULE_FIRMWARE in various drivers
  ip2: Add module parameter.
  ...
This commit is contained in:
Linus Torvalds 2010-03-03 08:47:22 -08:00
commit 9446808022
36 changed files with 984 additions and 658 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
drivers/char/cyclades.c
View File

@ -158,13 +158,11 @@ static unsigned int cy_isa_addresses[] = {
#define NR_ISA_ADDRS ARRAY_SIZE(cy_isa_addresses) #define NR_ISA_ADDRS ARRAY_SIZE(cy_isa_addresses)
#ifdef MODULE
static long maddr[NR_CARDS]; static long maddr[NR_CARDS];
static int irq[NR_CARDS]; static int irq[NR_CARDS];
module_param_array(maddr, long, NULL, 0); module_param_array(maddr, long, NULL, 0);
module_param_array(irq, int, NULL, 0); module_param_array(irq, int, NULL, 0);
#endif
#endif /* CONFIG_ISA */ #endif /* CONFIG_ISA */
@ -598,12 +596,6 @@ static void cyy_chip_tx(struct cyclades_card *cinfo, unsigned int chip,
save_car = readb(base_addr + (CyCAR << index)); save_car = readb(base_addr + (CyCAR << index));
cy_writeb(base_addr + (CyCAR << index), save_xir); cy_writeb(base_addr + (CyCAR << index), save_xir);
/* validate the port# (as configured and open) */
if (channel + chip * 4 >= cinfo->nports) {
cy_writeb(base_addr + (CySRER << index),
readb(base_addr + (CySRER << index)) & ~CyTxRdy);
goto end;
}
info = &cinfo->ports[channel + chip * 4]; info = &cinfo->ports[channel + chip * 4];
tty = tty_port_tty_get(&info->port); tty = tty_port_tty_get(&info->port);
if (tty == NULL) { if (tty == NULL) {
@ -3316,13 +3308,10 @@ static int __init cy_detect_isa(void)
unsigned short cy_isa_irq, nboard; unsigned short cy_isa_irq, nboard;
void __iomem *cy_isa_address; void __iomem *cy_isa_address;
unsigned short i, j, cy_isa_nchan; unsigned short i, j, cy_isa_nchan;
#ifdef MODULE
int isparam = 0; int isparam = 0;
#endif
nboard = 0; nboard = 0;
#ifdef MODULE
/* Check for module parameters */ /* Check for module parameters */
for (i = 0; i < NR_CARDS; i++) { for (i = 0; i < NR_CARDS; i++) {
if (maddr[i] || i) { if (maddr[i] || i) {
@ -3332,7 +3321,6 @@ static int __init cy_detect_isa(void)
if (!maddr[i]) if (!maddr[i])
break; break;
} }
#endif
/* scan the address table probing for Cyclom-Y/ISA boards */ /* scan the address table probing for Cyclom-Y/ISA boards */
for (i = 0; i < NR_ISA_ADDRS; i++) { for (i = 0; i < NR_ISA_ADDRS; i++) {
@ -3353,11 +3341,10 @@ static int __init cy_detect_isa(void)
iounmap(cy_isa_address); iounmap(cy_isa_address);
continue; continue;
} }
#ifdef MODULE
if (isparam && i < NR_CARDS && irq[i]) if (isparam && i < NR_CARDS && irq[i])
cy_isa_irq = irq[i]; cy_isa_irq = irq[i];
else else
#endif
/* find out the board's irq by probing */ /* find out the board's irq by probing */
cy_isa_irq = detect_isa_irq(cy_isa_address); cy_isa_irq = detect_isa_irq(cy_isa_address);
if (cy_isa_irq == 0) { if (cy_isa_irq == 0) {
@ -4208,3 +4195,4 @@ module_exit(cy_cleanup_module);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
MODULE_VERSION(CY_VERSION); MODULE_VERSION(CY_VERSION);
MODULE_ALIAS_CHARDEV_MAJOR(CYCLADES_MAJOR); MODULE_ALIAS_CHARDEV_MAJOR(CYCLADES_MAJOR);
MODULE_FIRMWARE("cyzfirm.bin");

2
drivers/char/hvc_console.c
View File

@ -146,7 +146,7 @@ static void hvc_console_print(struct console *co, const char *b,
return; return;
/* This console adapter was removed so it is not usable. */ /* This console adapter was removed so it is not usable. */
if (vtermnos[index] < 0) if (vtermnos[index] == -1)
return; return;
while (count > 0 || i > 0) { while (count > 0 || i > 0) {

26
drivers/char/ip2/ip2main.c
View File

@ -208,6 +208,7 @@ static int DumpFifoBuffer( char __user *, int);
static void ip2_init_board(int, const struct firmware *); static void ip2_init_board(int, const struct firmware *);
static unsigned short find_eisa_board(int); static unsigned short find_eisa_board(int);
static int ip2_setup(char *str);
/***************/ /***************/
/* Static Data */ /* Static Data */
@ -263,7 +264,7 @@ static int tracewrap;
/* Macros */ /* Macros */
/**********/ /**********/
#if defined(MODULE) && defined(IP2DEBUG_OPEN) #ifdef IP2DEBUG_OPEN
#define DBG_CNT(s) printk(KERN_DEBUG "(%s): [%x] ttyc=%d, modc=%x -> %s\n", \ #define DBG_CNT(s) printk(KERN_DEBUG "(%s): [%x] ttyc=%d, modc=%x -> %s\n", \
tty->name,(pCh->flags), \ tty->name,(pCh->flags), \
tty->count,/*GET_USE_COUNT(module)*/0,s) tty->count,/*GET_USE_COUNT(module)*/0,s)
@ -285,7 +286,10 @@ MODULE_AUTHOR("Doug McNash");
MODULE_DESCRIPTION("Computone IntelliPort Plus Driver"); MODULE_DESCRIPTION("Computone IntelliPort Plus Driver");
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
#define MAX_CMD_STR 50
static int poll_only; static int poll_only;
static char cmd[MAX_CMD_STR];
static int Eisa_irq; static int Eisa_irq;
static int Eisa_slot; static int Eisa_slot;
@ -309,6 +313,8 @@ module_param_array(io, int, NULL, 0);
MODULE_PARM_DESC(io, "I/O ports for IntelliPort Cards"); MODULE_PARM_DESC(io, "I/O ports for IntelliPort Cards");
module_param(poll_only, bool, 0); module_param(poll_only, bool, 0);
MODULE_PARM_DESC(poll_only, "Do not use card interrupts"); MODULE_PARM_DESC(poll_only, "Do not use card interrupts");
module_param_string(ip2, cmd, MAX_CMD_STR, 0);
MODULE_PARM_DESC(ip2, "Contains module parameter passed with 'ip2='");
/* for sysfs class support */ /* for sysfs class support */
static struct class *ip2_class; static struct class *ip2_class;
@ -487,7 +493,6 @@ static const struct firmware *ip2_request_firmware(void)
return fw; return fw;
} }
#ifndef MODULE
/****************************************************************************** /******************************************************************************
* ip2_setup: * ip2_setup:
* str: kernel command line string * str: kernel command line string
@ -531,7 +536,6 @@ static int __init ip2_setup(char *str)
return 1; return 1;
} }
__setup("ip2=", ip2_setup); __setup("ip2=", ip2_setup);
#endif /* !MODULE */
static int __init ip2_loadmain(void) static int __init ip2_loadmain(void)
{ {
@ -539,14 +543,20 @@ static int __init ip2_loadmain(void)
int err = 0; int err = 0;
i2eBordStrPtr pB = NULL; i2eBordStrPtr pB = NULL;
int rc = -1; int rc = -1;
struct pci_dev *pdev = NULL;
const struct firmware *fw = NULL; const struct firmware *fw = NULL;
char *str;
str = cmd;
if (poll_only) { if (poll_only) {
/* Hard lock the interrupts to zero */ /* Hard lock the interrupts to zero */
irq[0] = irq[1] = irq[2] = irq[3] = poll_only = 0; irq[0] = irq[1] = irq[2] = irq[3] = poll_only = 0;
} }
/* Check module parameter with 'ip2=' has been passed or not */
if (!poll_only && (!strncmp(str, "ip2=", 4)))
ip2_setup(str);
ip2trace(ITRC_NO_PORT, ITRC_INIT, ITRC_ENTER, 0); ip2trace(ITRC_NO_PORT, ITRC_INIT, ITRC_ENTER, 0);
/* process command line arguments to modprobe or /* process command line arguments to modprobe or
@ -612,6 +622,7 @@ static int __init ip2_loadmain(void)
case PCI: case PCI:
#ifdef CONFIG_PCI #ifdef CONFIG_PCI
{ {
struct pci_dev *pdev = NULL;
u32 addr; u32 addr;
int status; int status;
@ -626,7 +637,7 @@ static int __init ip2_loadmain(void)
if (pci_enable_device(pdev)) { if (pci_enable_device(pdev)) {
dev_err(&pdev->dev, "can't enable device\n"); dev_err(&pdev->dev, "can't enable device\n");
break; goto out;
} }
ip2config.type[i] = PCI; ip2config.type[i] = PCI;
ip2config.pci_dev[i] = pci_dev_get(pdev); ip2config.pci_dev[i] = pci_dev_get(pdev);
@ -638,6 +649,8 @@ static int __init ip2_loadmain(void)
dev_err(&pdev->dev, "I/O address error\n"); dev_err(&pdev->dev, "I/O address error\n");
ip2config.irq[i] = pdev->irq; ip2config.irq[i] = pdev->irq;
out:
pci_dev_put(pdev);
} }
#else #else
printk(KERN_ERR "IP2: PCI card specified but PCI " printk(KERN_ERR "IP2: PCI card specified but PCI "
@ -656,7 +669,6 @@ static int __init ip2_loadmain(void)
break; break;
} /* switch */ } /* switch */
} /* for */ } /* for */
pci_dev_put(pdev);
for (i = 0; i < IP2_MAX_BOARDS; ++i) { for (i = 0; i < IP2_MAX_BOARDS; ++i) {
if (ip2config.addr[i]) { if (ip2config.addr[i]) {
@ -3197,3 +3209,5 @@ static struct pci_device_id ip2main_pci_tbl[] __devinitdata = {
}; };
MODULE_DEVICE_TABLE(pci, ip2main_pci_tbl); MODULE_DEVICE_TABLE(pci, ip2main_pci_tbl);
MODULE_FIRMWARE("intelliport2.bin");

54
drivers/char/isicom.c
View File

@ -113,6 +113,8 @@
* 64-bit verification * 64-bit verification
*/ */
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include <linux/module.h> #include <linux/module.h>
#include <linux/firmware.h> #include <linux/firmware.h>
#include <linux/kernel.h> #include <linux/kernel.h>
@ -140,7 +142,6 @@
#define InterruptTheCard(base) outw(0, (base) + 0xc) #define InterruptTheCard(base) outw(0, (base) + 0xc)
#define ClearInterrupt(base) inw((base) + 0x0a) #define ClearInterrupt(base) inw((base) + 0x0a)
#define pr_dbg(str...) pr_debug("ISICOM: " str)
#ifdef DEBUG #ifdef DEBUG
#define isicom_paranoia_check(a, b, c) __isicom_paranoia_check((a), (b), (c)) #define isicom_paranoia_check(a, b, c) __isicom_paranoia_check((a), (b), (c))
#else #else
@ -249,8 +250,7 @@ static int lock_card(struct isi_board *card)
spin_unlock_irqrestore(&card->card_lock, card->flags); spin_unlock_irqrestore(&card->card_lock, card->flags);
msleep(10); msleep(10);
} }
printk(KERN_WARNING "ISICOM: Failed to lock Card (0x%lx)\n", pr_warning("Failed to lock Card (0x%lx)\n", card->base);
card->base);
return 0; /* Failed to acquire the card! */ return 0; /* Failed to acquire the card! */
} }
@ -379,13 +379,13 @@ static inline int __isicom_paranoia_check(struct isi_port const *port,
char *name, const char *routine) char *name, const char *routine)
{ {
if (!port) { if (!port) {
printk(KERN_WARNING "ISICOM: Warning: bad isicom magic for " pr_warning("Warning: bad isicom magic for dev %s in %s.\n",
"dev %s in %s.\n", name, routine); name, routine);
return 1; return 1;
} }
if (port->magic != ISICOM_MAGIC) { if (port->magic != ISICOM_MAGIC) {
printk(KERN_WARNING "ISICOM: Warning: NULL isicom port for " pr_warning("Warning: NULL isicom port for dev %s in %s.\n",
"dev %s in %s.\n", name, routine); name, routine);
return 1; return 1;
} }
@ -450,8 +450,8 @@ static void isicom_tx(unsigned long _data)
if (!(inw(base + 0x02) & (1 << port->channel))) if (!(inw(base + 0x02) & (1 << port->channel)))
continue; continue;
pr_dbg("txing %d bytes, port%d.\n", txcount, pr_debug("txing %d bytes, port%d.\n",
port->channel + 1); txcount, port->channel + 1);
outw((port->channel << isi_card[card].shift_count) | txcount, outw((port->channel << isi_card[card].shift_count) | txcount,
base); base);
residue = NO; residue = NO;
@ -547,8 +547,8 @@ static irqreturn_t isicom_interrupt(int irq, void *dev_id)
byte_count = header & 0xff; byte_count = header & 0xff;
if (channel + 1 > card->port_count) { if (channel + 1 > card->port_count) {
printk(KERN_WARNING "ISICOM: isicom_interrupt(0x%lx): " pr_warning("%s(0x%lx): %d(channel) > port_count.\n",
"%d(channel) > port_count.\n", base, channel+1); __func__, base, channel+1);
outw(0x0000, base+0x04); /* enable interrupts */ outw(0x0000, base+0x04); /* enable interrupts */
spin_unlock(&card->card_lock); spin_unlock(&card->card_lock);
return IRQ_HANDLED; return IRQ_HANDLED;
@ -582,14 +582,15 @@ static irqreturn_t isicom_interrupt(int irq, void *dev_id)
if (port->status & ISI_DCD) { if (port->status & ISI_DCD) {
if (!(header & ISI_DCD)) { if (!(header & ISI_DCD)) {
/* Carrier has been lost */ /* Carrier has been lost */
pr_dbg("interrupt: DCD->low.\n" pr_debug("%s: DCD->low.\n",
); __func__);
port->status &= ~ISI_DCD; port->status &= ~ISI_DCD;
tty_hangup(tty); tty_hangup(tty);
} }
} else if (header & ISI_DCD) { } else if (header & ISI_DCD) {
/* Carrier has been detected */ /* Carrier has been detected */
pr_dbg("interrupt: DCD->high.\n"); pr_debug("%s: DCD->high.\n",
__func__);
port->status |= ISI_DCD; port->status |= ISI_DCD;
wake_up_interruptible(&port->port.open_wait); wake_up_interruptible(&port->port.open_wait);
} }
@ -641,17 +642,19 @@ static irqreturn_t isicom_interrupt(int irq, void *dev_id)
break; break;
case 2: /* Statistics */ case 2: /* Statistics */
pr_dbg("isicom_interrupt: stats!!!.\n"); pr_debug("%s: stats!!!\n", __func__);
break; break;
default: default:
pr_dbg("Intr: Unknown code in status packet.\n"); pr_debug("%s: Unknown code in status packet.\n",
__func__);
break; break;
} }
} else { /* Data Packet */ } else { /* Data Packet */
count = tty_prepare_flip_string(tty, &rp, byte_count & ~1); count = tty_prepare_flip_string(tty, &rp, byte_count & ~1);
pr_dbg("Intr: Can rx %d of %d bytes.\n", count, byte_count); pr_debug("%s: Can rx %d of %d bytes.\n",
__func__, count, byte_count);
word_count = count >> 1; word_count = count >> 1;
insw(base, rp, word_count); insw(base, rp, word_count);
byte_count -= (word_count << 1); byte_count -= (word_count << 1);
@ -661,8 +664,8 @@ static irqreturn_t isicom_interrupt(int irq, void *dev_id)
byte_count -= 2; byte_count -= 2;
} }
if (byte_count > 0) { if (byte_count > 0) {
pr_dbg("Intr(0x%lx:%d): Flip buffer overflow! dropping " pr_debug("%s(0x%lx:%d): Flip buffer overflow! dropping bytes...\n",
"bytes...\n", base, channel + 1); __func__, base, channel + 1);
/* drain out unread xtra data */ /* drain out unread xtra data */
while (byte_count > 0) { while (byte_count > 0) {
inw(base); inw(base);
@ -888,8 +891,8 @@ static void isicom_shutdown_port(struct isi_port *port)
struct isi_board *card = port->card; struct isi_board *card = port->card;
if (--card->count < 0) { if (--card->count < 0) {
pr_dbg("isicom_shutdown_port: bad board(0x%lx) count %d.\n", pr_debug("%s: bad board(0x%lx) count %d.\n",
card->base, card->count); __func__, card->base, card->count);
card->count = 0; card->count = 0;
} }
/* last port was closed, shutdown that board too */ /* last port was closed, shutdown that board too */
@ -1681,13 +1684,13 @@ static int __init isicom_init(void)
retval = tty_register_driver(isicom_normal); retval = tty_register_driver(isicom_normal);
if (retval) { if (retval) {
pr_dbg("Couldn't register the dialin driver\n"); pr_debug("Couldn't register the dialin driver\n");
goto err_puttty; goto err_puttty;
} }
retval = pci_register_driver(&isicom_driver); retval = pci_register_driver(&isicom_driver);
if (retval < 0) { if (retval < 0) {
printk(KERN_ERR "ISICOM: Unable to register pci driver.\n"); pr_err("Unable to register pci driver.\n");
goto err_unrtty; goto err_unrtty;
} }
@ -1717,3 +1720,8 @@ module_exit(isicom_exit);
MODULE_AUTHOR("MultiTech"); MODULE_AUTHOR("MultiTech");
MODULE_DESCRIPTION("Driver for the ISI series of cards by MultiTech"); MODULE_DESCRIPTION("Driver for the ISI series of cards by MultiTech");
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
MODULE_FIRMWARE("isi608.bin");
MODULE_FIRMWARE("isi608em.bin");
MODULE_FIRMWARE("isi616em.bin");
MODULE_FIRMWARE("isi4608.bin");
MODULE_FIRMWARE("isi4616.bin");

20
drivers/char/moxa.c
View File

@ -164,24 +164,25 @@ static unsigned int moxaFuncTout = HZ / 2;
static unsigned int moxaLowWaterChk; static unsigned int moxaLowWaterChk;
static DEFINE_MUTEX(moxa_openlock); static DEFINE_MUTEX(moxa_openlock);
static DEFINE_SPINLOCK(moxa_lock); static DEFINE_SPINLOCK(moxa_lock);
/* Variables for insmod */
#ifdef MODULE
static unsigned long baseaddr[MAX_BOARDS]; static unsigned long baseaddr[MAX_BOARDS];
static unsigned int type[MAX_BOARDS]; static unsigned int type[MAX_BOARDS];
static unsigned int numports[MAX_BOARDS]; static unsigned int numports[MAX_BOARDS];
#endif
MODULE_AUTHOR("William Chen"); MODULE_AUTHOR("William Chen");
MODULE_DESCRIPTION("MOXA Intellio Family Multiport Board Device Driver"); MODULE_DESCRIPTION("MOXA Intellio Family Multiport Board Device Driver");
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
#ifdef MODULE MODULE_FIRMWARE("c218tunx.cod");
MODULE_FIRMWARE("cp204unx.cod");
MODULE_FIRMWARE("c320tunx.cod");
module_param_array(type, uint, NULL, 0); module_param_array(type, uint, NULL, 0);
MODULE_PARM_DESC(type, "card type: C218=2, C320=4"); MODULE_PARM_DESC(type, "card type: C218=2, C320=4");
module_param_array(baseaddr, ulong, NULL, 0); module_param_array(baseaddr, ulong, NULL, 0);
MODULE_PARM_DESC(baseaddr, "base address"); MODULE_PARM_DESC(baseaddr, "base address");
module_param_array(numports, uint, NULL, 0); module_param_array(numports, uint, NULL, 0);
MODULE_PARM_DESC(numports, "numports (ignored for C218)"); MODULE_PARM_DESC(numports, "numports (ignored for C218)");
#endif
module_param(ttymajor, int, 0); module_param(ttymajor, int, 0);
/* /*
@ -1024,6 +1025,8 @@ static int __init moxa_init(void)
{ {
unsigned int isabrds = 0; unsigned int isabrds = 0;
int retval = 0; int retval = 0;
struct moxa_board_conf *brd = moxa_boards;
unsigned int i;
printk(KERN_INFO "MOXA Intellio family driver version %s\n", printk(KERN_INFO "MOXA Intellio family driver version %s\n",
MOXA_VERSION); MOXA_VERSION);
@ -1051,10 +1054,7 @@ static int __init moxa_init(void)
} }
/* Find the boards defined from module args. */ /* Find the boards defined from module args. */
#ifdef MODULE
{
struct moxa_board_conf *brd = moxa_boards;
unsigned int i;
for (i = 0; i < MAX_BOARDS; i++) { for (i = 0; i < MAX_BOARDS; i++) {
if (!baseaddr[i]) if (!baseaddr[i])
break; break;
@ -1087,8 +1087,6 @@ static int __init moxa_init(void)
isabrds++; isabrds++;
} }
} }
}
#endif
#ifdef CONFIG_PCI #ifdef CONFIG_PCI
retval = pci_register_driver(&moxa_pci_driver); retval = pci_register_driver(&moxa_pci_driver);

3
drivers/char/mxser.c
View File

@ -895,8 +895,7 @@ static int mxser_activate(struct tty_port *port, struct tty_struct *tty)
if (inb(info->ioaddr + UART_LSR) == 0xff) { if (inb(info->ioaddr + UART_LSR) == 0xff) {
spin_unlock_irqrestore(&info->slock, flags); spin_unlock_irqrestore(&info->slock, flags);
if (capable(CAP_SYS_ADMIN)) { if (capable(CAP_SYS_ADMIN)) {
if (tty) set_bit(TTY_IO_ERROR, &tty->flags);
set_bit(TTY_IO_ERROR, &tty->flags);
return 0; return 0;
} else } else
return -ENODEV; return -ENODEV;

163
drivers/char/nozomi.c
View File

@ -136,10 +136,6 @@ static int debug;
#define RECEIVE_BUF_MAX 4 #define RECEIVE_BUF_MAX 4
/* Define all types of vendors and devices to support */
#define VENDOR1 0x1931 /* Vendor Option */
#define DEVICE1 0x000c /* HSDPA card */
#define R_IIR 0x0000 /* Interrupt Identity Register */ #define R_IIR 0x0000 /* Interrupt Identity Register */
#define R_FCR 0x0000 /* Flow Control Register */ #define R_FCR 0x0000 /* Flow Control Register */
#define R_IER 0x0004 /* Interrupt Enable Register */ #define R_IER 0x0004 /* Interrupt Enable Register */
@ -371,6 +367,8 @@ struct port {
struct mutex tty_sem; struct mutex tty_sem;
wait_queue_head_t tty_wait; wait_queue_head_t tty_wait;
struct async_icount tty_icount; struct async_icount tty_icount;
struct nozomi *dc;
}; };
/* Private data one for each card in the system */ /* Private data one for each card in the system */
@ -405,7 +403,7 @@ struct buffer {
/* Global variables */ /* Global variables */
static const struct pci_device_id nozomi_pci_tbl[] __devinitconst = { static const struct pci_device_id nozomi_pci_tbl[] __devinitconst = {
{PCI_DEVICE(VENDOR1, DEVICE1)}, {PCI_DEVICE(0x1931, 0x000c)}, /* Nozomi HSDPA */
{}, {},
}; };
@ -414,6 +412,8 @@ MODULE_DEVICE_TABLE(pci, nozomi_pci_tbl);
static struct nozomi *ndevs[NOZOMI_MAX_CARDS]; static struct nozomi *ndevs[NOZOMI_MAX_CARDS];
static struct tty_driver *ntty_driver; static struct tty_driver *ntty_driver;
static const struct tty_port_operations noz_tty_port_ops;
/* /*
* find card by tty_index * find card by tty_index
*/ */
@ -853,8 +853,6 @@ static int receive_data(enum port_type index, struct nozomi *dc)
goto put; goto put;
} }
tty_buffer_request_room(tty, size);
while (size > 0) { while (size > 0) {
read_mem32((u32 *) buf, addr + offset, RECEIVE_BUF_MAX); read_mem32((u32 *) buf, addr + offset, RECEIVE_BUF_MAX);
@ -1473,9 +1471,11 @@ static int __devinit nozomi_card_init(struct pci_dev *pdev,
for (i = 0; i < MAX_PORT; i++) { for (i = 0; i < MAX_PORT; i++) {
struct device *tty_dev; struct device *tty_dev;
struct port *port = &dc->port[i];
mutex_init(&dc->port[i].tty_sem); port->dc = dc;
tty_port_init(&dc->port[i].port); mutex_init(&port->tty_sem);
tty_port_init(&port->port);
port->port.ops = &noz_tty_port_ops;
tty_dev = tty_register_device(ntty_driver, dc->index_start + i, tty_dev = tty_register_device(ntty_driver, dc->index_start + i,
&pdev->dev); &pdev->dev);
@ -1600,67 +1600,74 @@ static void set_dtr(const struct tty_struct *tty, int dtr)
* ---------------------------------------------------------------------------- * ----------------------------------------------------------------------------
*/ */
/* Called when the userspace process opens the tty, /dev/noz*. */ static int ntty_install(struct tty_driver *driver, struct tty_struct *tty)
static int ntty_open(struct tty_struct *tty, struct file *file)
{ {
struct port *port = get_port_by_tty(tty); struct port *port = get_port_by_tty(tty);
struct nozomi *dc = get_dc_by_tty(tty); struct nozomi *dc = get_dc_by_tty(tty);
unsigned long flags; int ret;
if (!port || !dc || dc->state != NOZOMI_STATE_READY) if (!port || !dc || dc->state != NOZOMI_STATE_READY)
return -ENODEV; return -ENODEV;
ret = tty_init_termios(tty);
if (mutex_lock_interruptible(&port->tty_sem)) if (ret == 0) {
return -ERESTARTSYS; tty_driver_kref_get(driver);
driver->ttys[tty->index] = tty;
port->port.count++;
dc->open_ttys++;
/* Enable interrupt downlink for channel */
if (port->port.count == 1) {
tty->driver_data = port;
tty_port_tty_set(&port->port, tty);
DBG1("open: %d", port->token_dl);
spin_lock_irqsave(&dc->spin_mutex, flags);
dc->last_ier = dc->last_ier | port->token_dl;
writew(dc->last_ier, dc->reg_ier);
spin_unlock_irqrestore(&dc->spin_mutex, flags);
} }
mutex_unlock(&port->tty_sem); return ret;
}
static void ntty_cleanup(struct tty_struct *tty)
{
tty->driver_data = NULL;
}
static int ntty_activate(struct tty_port *tport, struct tty_struct *tty)
{
struct port *port = container_of(tport, struct port, port);
struct nozomi *dc = port->dc;
unsigned long flags;
DBG1("open: %d", port->token_dl);
spin_lock_irqsave(&dc->spin_mutex, flags);
dc->last_ier = dc->last_ier | port->token_dl;
writew(dc->last_ier, dc->reg_ier);
dc->open_ttys++;
spin_unlock_irqrestore(&dc->spin_mutex, flags);
printk("noz: activated %d: %p\n", tty->index, tport);
return 0; return 0;
} }
/* Called when the userspace process close the tty, /dev/noz*. Also static int ntty_open(struct tty_struct *tty, struct file *filp)
called immediately if ntty_open fails in which case tty->driver_data
will be NULL an we exit by the first return */
static void ntty_close(struct tty_struct *tty, struct file *file)
{ {
struct nozomi *dc = get_dc_by_tty(tty); struct port *port = get_port_by_tty(tty);
struct port *nport = tty->driver_data; return tty_port_open(&port->port, tty, filp);
struct tty_port *port = &nport->port; }
static void ntty_shutdown(struct tty_port *tport)
{
struct port *port = container_of(tport, struct port, port);
struct nozomi *dc = port->dc;
unsigned long flags; unsigned long flags;
if (!dc || !nport) DBG1("close: %d", port->token_dl);
return; spin_lock_irqsave(&dc->spin_mutex, flags);
dc->last_ier &= ~(port->token_dl);
/* Users cannot interrupt a close */ writew(dc->last_ier, dc->reg_ier);
mutex_lock(&nport->tty_sem);
WARN_ON(!port->count);
dc->open_ttys--; dc->open_ttys--;
port->count--; spin_unlock_irqrestore(&dc->spin_mutex, flags);
printk("noz: shutdown %p\n", tport);
}
if (port->count == 0) { static void ntty_close(struct tty_struct *tty, struct file *filp)
DBG1("close: %d", nport->token_dl); {
tty_port_tty_set(port, NULL); struct port *port = tty->driver_data;
spin_lock_irqsave(&dc->spin_mutex, flags); if (port)
dc->last_ier &= ~(nport->token_dl); tty_port_close(&port->port, tty, filp);
writew(dc->last_ier, dc->reg_ier); }
spin_unlock_irqrestore(&dc->spin_mutex, flags);
} static void ntty_hangup(struct tty_struct *tty)
mutex_unlock(&nport->tty_sem); {
struct port *port = tty->driver_data;
tty_port_hangup(&port->port);
} }
/* /*
@ -1680,15 +1687,7 @@ static int ntty_write(struct tty_struct *tty, const unsigned char *buffer,
if (!dc || !port) if (!dc || !port)
return -ENODEV; return -ENODEV;
if (unlikely(!mutex_trylock(&port->tty_sem))) { mutex_lock(&port->tty_sem);
/*
* must test lock as tty layer wraps calls
* to this function with BKL
*/
dev_err(&dc->pdev->dev, "Would have deadlocked - "
"return EAGAIN\n");
return -EAGAIN;
}
if (unlikely(!port->port.count)) { if (unlikely(!port->port.count)) {
DBG1(" "); DBG1(" ");
@ -1728,25 +1727,23 @@ exit:
* This method is called by the upper tty layer. * This method is called by the upper tty layer.
* #according to sources N_TTY.c it expects a value >= 0 and * #according to sources N_TTY.c it expects a value >= 0 and
* does not check for negative values. * does not check for negative values.
*
* If the port is unplugged report lots of room and let the bits
* dribble away so we don't block anything.
*/ */
static int ntty_write_room(struct tty_struct *tty) static int ntty_write_room(struct tty_struct *tty)
{ {
struct port *port = tty->driver_data; struct port *port = tty->driver_data;
int room = 0; int room = 4096;
const struct nozomi *dc = get_dc_by_tty(tty); const struct nozomi *dc = get_dc_by_tty(tty);
if (!dc || !port) if (dc) {
return 0; mutex_lock(&port->tty_sem);
if (!mutex_trylock(&port->tty_sem)) if (port->port.count)
return 0; room = port->fifo_ul.size -
kfifo_len(&port->fifo_ul);
if (!port->port.count) mutex_unlock(&port->tty_sem);
goto exit; }
room = port->fifo_ul.size - kfifo_len(&port->fifo_ul);
exit:
mutex_unlock(&port->tty_sem);
return room; return room;
} }
@ -1906,10 +1903,16 @@ exit_in_buffer:
return rval; return rval;
} }
static const struct tty_port_operations noz_tty_port_ops = {
.activate = ntty_activate,
.shutdown = ntty_shutdown,
};
static const struct tty_operations tty_ops = { static const struct tty_operations tty_ops = {
.ioctl = ntty_ioctl, .ioctl = ntty_ioctl,
.open = ntty_open, .open = ntty_open,
.close = ntty_close, .close = ntty_close,
.hangup = ntty_hangup,
.write = ntty_write, .write = ntty_write,
.write_room = ntty_write_room, .write_room = ntty_write_room,
.unthrottle = ntty_unthrottle, .unthrottle = ntty_unthrottle,
@ -1917,6 +1920,8 @@ static const struct tty_operations tty_ops = {
.chars_in_buffer = ntty_chars_in_buffer, .chars_in_buffer = ntty_chars_in_buffer,
.tiocmget = ntty_tiocmget, .tiocmget = ntty_tiocmget,
.tiocmset = ntty_tiocmset, .tiocmset = ntty_tiocmset,
.install = ntty_install,
.cleanup = ntty_cleanup,
}; };
/* Module initialization */ /* Module initialization */

3
drivers/char/serial167.c
View File

@ -658,8 +658,7 @@ static irqreturn_t cd2401_rx_interrupt(int irq, void *dev_id)
info->mon.char_max = char_count; info->mon.char_max = char_count;
info->mon.char_last = char_count; info->mon.char_last = char_count;
#endif #endif
len = tty_buffer_request_room(tty, char_count); while (char_count--) {
while (len--) {
data = base_addr[CyRDR]; data = base_addr[CyRDR];
tty_insert_flip_char(tty, data, TTY_NORMAL); tty_insert_flip_char(tty, data, TTY_NORMAL);
#ifdef CYCLOM_16Y_HACK #ifdef CYCLOM_16Y_HACK

2
drivers/char/specialix.c
View File

@ -646,8 +646,6 @@ static void sx_receive(struct specialix_board *bp)
dprintk(SX_DEBUG_RX, "port: %p: count: %d\n", port, count); dprintk(SX_DEBUG_RX, "port: %p: count: %d\n", port, count);
port->hits[count > 8 ? 9 : count]++; port->hits[count > 8 ? 9 : count]++;
tty_buffer_request_room(tty, count);
while (count--) while (count--)
tty_insert_flip_char(tty, sx_in(bp, CD186x_RDR), TTY_NORMAL); tty_insert_flip_char(tty, sx_in(bp, CD186x_RDR), TTY_NORMAL);
tty_flip_buffer_push(tty); tty_flip_buffer_push(tty);

4
drivers/char/synclink.c
View File

@ -2031,7 +2031,7 @@ static int mgsl_put_char(struct tty_struct *tty, unsigned char ch)
if (mgsl_paranoia_check(info, tty->name, "mgsl_put_char")) if (mgsl_paranoia_check(info, tty->name, "mgsl_put_char"))
return 0; return 0;
if (!tty || !info->xmit_buf) if (!info->xmit_buf)
return 0; return 0;
spin_lock_irqsave(&info->irq_spinlock, flags); spin_lock_irqsave(&info->irq_spinlock, flags);
@ -2121,7 +2121,7 @@ static int mgsl_write(struct tty_struct * tty,
if (mgsl_paranoia_check(info, tty->name, "mgsl_write")) if (mgsl_paranoia_check(info, tty->name, "mgsl_write"))
goto cleanup; goto cleanup;
if (!tty || !info->xmit_buf) if (!info->xmit_buf)
goto cleanup; goto cleanup;
if ( info->params.mode == MGSL_MODE_HDLC || if ( info->params.mode == MGSL_MODE_HDLC ||

186
drivers/char/synclink_gt.c
View File

@ -468,7 +468,7 @@ static unsigned int free_tbuf_count(struct slgt_info *info);
static unsigned int tbuf_bytes(struct slgt_info *info); static unsigned int tbuf_bytes(struct slgt_info *info);
static void reset_tbufs(struct slgt_info *info); static void reset_tbufs(struct slgt_info *info);
static void tdma_reset(struct slgt_info *info); static void tdma_reset(struct slgt_info *info);
static void tx_load(struct slgt_info *info, const char *buf, unsigned int count); static bool tx_load(struct slgt_info *info, const char *buf, unsigned int count);
static void get_signals(struct slgt_info *info); static void get_signals(struct slgt_info *info);
static void set_signals(struct slgt_info *info); static void set_signals(struct slgt_info *info);
@ -813,59 +813,32 @@ static int write(struct tty_struct *tty,
int ret = 0; int ret = 0;
struct slgt_info *info = tty->driver_data; struct slgt_info *info = tty->driver_data;
unsigned long flags; unsigned long flags;
unsigned int bufs_needed;
if (sanity_check(info, tty->name, "write")) if (sanity_check(info, tty->name, "write"))
goto cleanup; return -EIO;
DBGINFO(("%s write count=%d\n", info->device_name, count)); DBGINFO(("%s write count=%d\n", info->device_name, count));
if (!info->tx_buf) if (!info->tx_buf || (count > info->max_frame_size))
goto cleanup; return -EIO;
if (count > info->max_frame_size) { if (!count || tty->stopped || tty->hw_stopped)
ret = -EIO; return 0;
goto cleanup;
}
if (!count) spin_lock_irqsave(&info->lock, flags);
goto cleanup;
if (!info->tx_active && info->tx_count) { if (info->tx_count) {
/* send accumulated data from send_char() */ /* send accumulated data from send_char() */
tx_load(info, info->tx_buf, info->tx_count); if (!tx_load(info, info->tx_buf, info->tx_count))
goto start; goto cleanup;
info->tx_count = 0;
} }
bufs_needed = (count/DMABUFSIZE);
if (count % DMABUFSIZE)
++bufs_needed;
if (bufs_needed > free_tbuf_count(info))
goto cleanup;
ret = info->tx_count = count; if (tx_load(info, buf, count))
tx_load(info, buf, count); ret = count;
goto start;
start:
if (info->tx_count && !tty->stopped && !tty->hw_stopped) {
spin_lock_irqsave(&info->lock,flags);
if (!info->tx_active)
tx_start(info);
else if (!(rd_reg32(info, TDCSR) & BIT0)) {
/* transmit still active but transmit DMA stopped */
unsigned int i = info->tbuf_current;
if (!i)
i = info->tbuf_count;
i--;
/* if DMA buf unsent must try later after tx idle */
if (desc_count(info->tbufs[i]))
ret = 0;
}
if (ret > 0)
update_tx_timer(info);
spin_unlock_irqrestore(&info->lock,flags);
}
cleanup: cleanup:
spin_unlock_irqrestore(&info->lock, flags);
DBGINFO(("%s write rc=%d\n", info->device_name, ret)); DBGINFO(("%s write rc=%d\n", info->device_name, ret));
return ret; return ret;
} }
@ -882,7 +855,7 @@ static int put_char(struct tty_struct *tty, unsigned char ch)
if (!info->tx_buf) if (!info->tx_buf)
return 0; return 0;
spin_lock_irqsave(&info->lock,flags); spin_lock_irqsave(&info->lock,flags);
if (!info->tx_active && (info->tx_count < info->max_frame_size)) { if (info->tx_count < info->max_frame_size) {
info->tx_buf[info->tx_count++] = ch; info->tx_buf[info->tx_count++] = ch;
ret = 1; ret = 1;
} }
@ -981,10 +954,8 @@ static void flush_chars(struct tty_struct *tty)
DBGINFO(("%s flush_chars start transmit\n", info->device_name)); DBGINFO(("%s flush_chars start transmit\n", info->device_name));
spin_lock_irqsave(&info->lock,flags); spin_lock_irqsave(&info->lock,flags);
if (!info->tx_active && info->tx_count) { if (info->tx_count && tx_load(info, info->tx_buf, info->tx_count))
tx_load(info, info->tx_buf,info->tx_count); info->tx_count = 0;
tx_start(info);
}
spin_unlock_irqrestore(&info->lock,flags); spin_unlock_irqrestore(&info->lock,flags);
} }
@ -997,10 +968,9 @@ static void flush_buffer(struct tty_struct *tty)
return; return;
DBGINFO(("%s flush_buffer\n", info->device_name)); DBGINFO(("%s flush_buffer\n", info->device_name));
spin_lock_irqsave(&info->lock,flags); spin_lock_irqsave(&info->lock, flags);
if (!info->tx_active) info->tx_count = 0;
info->tx_count = 0; spin_unlock_irqrestore(&info->lock, flags);
spin_unlock_irqrestore(&info->lock,flags);
tty_wakeup(tty); tty_wakeup(tty);
} }
@ -1033,12 +1003,10 @@ static void tx_release(struct tty_struct *tty)
if (sanity_check(info, tty->name, "tx_release")) if (sanity_check(info, tty->name, "tx_release"))
return; return;
DBGINFO(("%s tx_release\n", info->device_name)); DBGINFO(("%s tx_release\n", info->device_name));
spin_lock_irqsave(&info->lock,flags); spin_lock_irqsave(&info->lock, flags);
if (!info->tx_active && info->tx_count) { if (info->tx_count && tx_load(info, info->tx_buf, info->tx_count))
tx_load(info, info->tx_buf, info->tx_count); info->tx_count = 0;
tx_start(info); spin_unlock_irqrestore(&info->lock, flags);
}
spin_unlock_irqrestore(&info->lock,flags);
} }
/* /*
@ -1506,27 +1474,25 @@ static netdev_tx_t hdlcdev_xmit(struct sk_buff *skb,
DBGINFO(("%s hdlc_xmit\n", dev->name)); DBGINFO(("%s hdlc_xmit\n", dev->name));
if (!skb->len)
return NETDEV_TX_OK;
/* stop sending until this frame completes */ /* stop sending until this frame completes */
netif_stop_queue(dev); netif_stop_queue(dev);
/* copy data to device buffers */
info->tx_count = skb->len;
tx_load(info, skb->data, skb->len);
/* update network statistics */ /* update network statistics */
dev->stats.tx_packets++; dev->stats.tx_packets++;
dev->stats.tx_bytes += skb->len; dev->stats.tx_bytes += skb->len;
/* done with socket buffer, so free it */
dev_kfree_skb(skb);
/* save start time for transmit timeout detection */ /* save start time for transmit timeout detection */
dev->trans_start = jiffies; dev->trans_start = jiffies;
spin_lock_irqsave(&info->lock,flags); spin_lock_irqsave(&info->lock, flags);
tx_start(info); tx_load(info, skb->data, skb->len);
update_tx_timer(info); spin_unlock_irqrestore(&info->lock, flags);
spin_unlock_irqrestore(&info->lock,flags);
/* done with socket buffer, so free it */
dev_kfree_skb(skb);
return NETDEV_TX_OK; return NETDEV_TX_OK;
} }
@ -2180,7 +2146,7 @@ static void isr_serial(struct slgt_info *info)
if (info->params.mode == MGSL_MODE_ASYNC) { if (info->params.mode == MGSL_MODE_ASYNC) {
if (status & IRQ_TXIDLE) { if (status & IRQ_TXIDLE) {
if (info->tx_count) if (info->tx_active)
isr_txeom(info, status); isr_txeom(info, status);
} }
if (info->rx_pio && (status & IRQ_RXDATA)) if (info->rx_pio && (status & IRQ_RXDATA))
@ -2276,13 +2242,42 @@ static void isr_tdma(struct slgt_info *info)
} }
} }
/*
* return true if there are unsent tx DMA buffers, otherwise false
*
* if there are unsent buffers then info->tbuf_start
* is set to index of first unsent buffer
*/
static bool unsent_tbufs(struct slgt_info *info)
{
unsigned int i = info->tbuf_current;
bool rc = false;
/*
* search backwards from last loaded buffer (precedes tbuf_current)
* for first unsent buffer (desc_count > 0)
*/
do {
if (i)
i--;
else
i = info->tbuf_count - 1;
if (!desc_count(info->tbufs[i]))
break;
info->tbuf_start = i;
rc = true;
} while (i != info->tbuf_current);
return rc;
}
static void isr_txeom(struct slgt_info *info, unsigned short status) static void isr_txeom(struct slgt_info *info, unsigned short status)
{ {
DBGISR(("%s txeom status=%04x\n", info->device_name, status)); DBGISR(("%s txeom status=%04x\n", info->device_name, status));
slgt_irq_off(info, IRQ_TXDATA + IRQ_TXIDLE + IRQ_TXUNDER); slgt_irq_off(info, IRQ_TXDATA + IRQ_TXIDLE + IRQ_TXUNDER);
tdma_reset(info); tdma_reset(info);
reset_tbufs(info);
if (status & IRQ_TXUNDER) { if (status & IRQ_TXUNDER) {
unsigned short val = rd_reg16(info, TCR); unsigned short val = rd_reg16(info, TCR);
wr_reg16(info, TCR, (unsigned short)(val | BIT2)); /* set reset bit */ wr_reg16(info, TCR, (unsigned short)(val | BIT2)); /* set reset bit */
@ -2297,8 +2292,12 @@ static void isr_txeom(struct slgt_info *info, unsigned short status)
info->icount.txok++; info->icount.txok++;
} }
if (unsent_tbufs(info)) {
tx_start(info);
update_tx_timer(info);
return;
}
info->tx_active = false; info->tx_active = false;
info->tx_count = 0;
del_timer(&info->tx_timer); del_timer(&info->tx_timer);
@ -3949,7 +3948,7 @@ static void tx_start(struct slgt_info *info)
info->tx_enabled = true; info->tx_enabled = true;
} }
if (info->tx_count) { if (desc_count(info->tbufs[info->tbuf_start])) {
info->drop_rts_on_tx_done = false; info->drop_rts_on_tx_done = false;
if (info->params.mode != MGSL_MODE_ASYNC) { if (info->params.mode != MGSL_MODE_ASYNC) {
@ -4772,25 +4771,36 @@ static unsigned int tbuf_bytes(struct slgt_info *info)
} }
/* /*
* load transmit DMA buffer(s) with data * load data into transmit DMA buffer ring and start transmitter if needed
* return true if data accepted, otherwise false (buffers full)
*/ */
static void tx_load(struct slgt_info *info, const char *buf, unsigned int size) static bool tx_load(struct slgt_info *info, const char *buf, unsigned int size)
{ {
unsigned short count; unsigned short count;
unsigned int i; unsigned int i;
struct slgt_desc *d; struct slgt_desc *d;
if (size == 0) /* check required buffer space */
return; if (DIV_ROUND_UP(size, DMABUFSIZE) > free_tbuf_count(info))
return false;
DBGDATA(info, buf, size, "tx"); DBGDATA(info, buf, size, "tx");
/*
* copy data to one or more DMA buffers in circular ring
* tbuf_start = first buffer for this data
* tbuf_current = next free buffer
*
* Copy all data before making data visible to DMA controller by
* setting descriptor count of the first buffer.
* This prevents an active DMA controller from reading the first DMA
* buffers of a frame and stopping before the final buffers are filled.
*/
info->tbuf_start = i = info->tbuf_current; info->tbuf_start = i = info->tbuf_current;
while (size) { while (size) {
d = &info->tbufs[i]; d = &info->tbufs[i];
if (++i == info->tbuf_count)
i = 0;
count = (unsigned short)((size > DMABUFSIZE) ? DMABUFSIZE : size); count = (unsigned short)((size > DMABUFSIZE) ? DMABUFSIZE : size);
memcpy(d->buf, buf, count); memcpy(d->buf, buf, count);
@ -4808,11 +4818,27 @@ static void tx_load(struct slgt_info *info, const char *buf, unsigned int size)
else else
set_desc_eof(*d, 0); set_desc_eof(*d, 0);
set_desc_count(*d, count); /* set descriptor count for all but first buffer */
if (i != info->tbuf_start)
set_desc_count(*d, count);
d->buf_count = count; d->buf_count = count;
if (++i == info->tbuf_count)
i = 0;
} }
info->tbuf_current = i; info->tbuf_current = i;
/* set first buffer count to make new data visible to DMA controller */
d = &info->tbufs[info->tbuf_start];
set_desc_count(*d, d->buf_count);
/* start transmitter if needed and update transmit timeout */
if (!info->tx_active)
tx_start(info);
update_tx_timer(info);
return true;
} }
static int register_test(struct slgt_info *info) static int register_test(struct slgt_info *info)
@ -4934,9 +4960,7 @@ static int loopback_test(struct slgt_info *info)
spin_lock_irqsave(&info->lock,flags); spin_lock_irqsave(&info->lock,flags);
async_mode(info); async_mode(info);
rx_start(info); rx_start(info);
info->tx_count = count;
tx_load(info, buf, count); tx_load(info, buf, count);
tx_start(info);
spin_unlock_irqrestore(&info->lock, flags); spin_unlock_irqrestore(&info->lock, flags);
/* wait for receive complete */ /* wait for receive complete */

6
drivers/char/tty_buffer.c
View File

@ -247,7 +247,8 @@ int tty_insert_flip_string(struct tty_struct *tty, const unsigned char *chars,
{ {
int copied = 0; int copied = 0;
do { do {
int space = tty_buffer_request_room(tty, size - copied); int goal = min(size - copied, TTY_BUFFER_PAGE);
int space = tty_buffer_request_room(tty, goal);
struct tty_buffer *tb = tty->buf.tail; struct tty_buffer *tb = tty->buf.tail;
/* If there is no space then tb may be NULL */ /* If there is no space then tb may be NULL */
if (unlikely(space == 0)) if (unlikely(space == 0))
@ -283,7 +284,8 @@ int tty_insert_flip_string_flags(struct tty_struct *tty,
{ {
int copied = 0; int copied = 0;
do { do {
int space = tty_buffer_request_room(tty, size - copied); int goal = min(size - copied, TTY_BUFFER_PAGE);
int space = tty_buffer_request_room(tty, goal);
struct tty_buffer *tb = tty->buf.tail; struct tty_buffer *tb = tty->buf.tail;
/* If there is no space then tb may be NULL */ /* If there is no space then tb may be NULL */
if (unlikely(space == 0)) if (unlikely(space == 0))

52
drivers/char/tty_ldisc.c
View File

@ -706,12 +706,13 @@ static void tty_reset_termios(struct tty_struct *tty)
/** /**
* tty_ldisc_reinit - reinitialise the tty ldisc * tty_ldisc_reinit - reinitialise the tty ldisc
* @tty: tty to reinit * @tty: tty to reinit
* @ldisc: line discipline to reinitialize
* *
* Switch the tty back to N_TTY line discipline and leave the * Switch the tty to a line discipline and leave the ldisc
* ldisc state closed * state closed
*/ */
static void tty_ldisc_reinit(struct tty_struct *tty) static void tty_ldisc_reinit(struct tty_struct *tty, int ldisc)
{ {
struct tty_ldisc *ld; struct tty_ldisc *ld;
@ -721,10 +722,10 @@ static void tty_ldisc_reinit(struct tty_struct *tty)
/* /*
* Switch the line discipline back * Switch the line discipline back
*/ */
ld = tty_ldisc_get(N_TTY); ld = tty_ldisc_get(ldisc);
BUG_ON(IS_ERR(ld)); BUG_ON(IS_ERR(ld));
tty_ldisc_assign(tty, ld); tty_ldisc_assign(tty, ld);
tty_set_termios_ldisc(tty, N_TTY); tty_set_termios_ldisc(tty, ldisc);
} }
/** /**
@ -745,6 +746,8 @@ static void tty_ldisc_reinit(struct tty_struct *tty)
void tty_ldisc_hangup(struct tty_struct *tty) void tty_ldisc_hangup(struct tty_struct *tty)
{ {
struct tty_ldisc *ld; struct tty_ldisc *ld;
int reset = tty->driver->flags & TTY_DRIVER_RESET_TERMIOS;
int err = 0;
/* /*
* FIXME! What are the locking issues here? This may me overdoing * FIXME! What are the locking issues here? This may me overdoing
@ -772,25 +775,32 @@ void tty_ldisc_hangup(struct tty_struct *tty)
wake_up_interruptible_poll(&tty->read_wait, POLLIN); wake_up_interruptible_poll(&tty->read_wait, POLLIN);
/* /*
* Shutdown the current line discipline, and reset it to * Shutdown the current line discipline, and reset it to
* N_TTY. * N_TTY if need be.
*
* Avoid racing set_ldisc or tty_ldisc_release
*/ */
if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) { mutex_lock(&tty->ldisc_mutex);
/* Avoid racing set_ldisc or tty_ldisc_release */ tty_ldisc_halt(tty);
mutex_lock(&tty->ldisc_mutex); /* At this point we have a closed ldisc and we want to
tty_ldisc_halt(tty); reopen it. We could defer this to the next open but
if (tty->ldisc) { /* Not yet closed */ it means auditing a lot of other paths so this is
/* Switch back to N_TTY */ a FIXME */
tty_ldisc_reinit(tty); if (tty->ldisc) { /* Not yet closed */
/* At this point we have a closed ldisc and we want to if (reset == 0) {
reopen it. We could defer this to the next open but tty_ldisc_reinit(tty, tty->termios->c_line);
it means auditing a lot of other paths so this is err = tty_ldisc_open(tty, tty->ldisc);
a FIXME */
WARN_ON(tty_ldisc_open(tty, tty->ldisc));
tty_ldisc_enable(tty);
} }
mutex_unlock(&tty->ldisc_mutex); /* If the re-open fails or we reset then go to N_TTY. The
tty_reset_termios(tty); N_TTY open cannot fail */
if (reset || err) {
tty_ldisc_reinit(tty, N_TTY);
WARN_ON(tty_ldisc_open(tty, tty->ldisc));
}
tty_ldisc_enable(tty);
} }
mutex_unlock(&tty->ldisc_mutex);
if (reset)
tty_reset_termios(tty);
} }
/** /**

39
drivers/char/vt_ioctl.c
View File

@ -888,7 +888,7 @@ int vt_ioctl(struct tty_struct *tty, struct file * file,
ret = -EFAULT; ret = -EFAULT;
goto out; goto out;
} }
if (tmp.mode != VT_AUTO && tmp.mode != VT_PROCESS) { if (tmp.mode != VT_AUTO && tmp.mode != VT_PROCESS && tmp.mode != VT_PROCESS_AUTO) {
ret = -EINVAL; ret = -EINVAL;
goto out; goto out;
} }
@ -1622,7 +1622,7 @@ static void complete_change_console(struct vc_data *vc)
* telling it that it has acquired. Also check if it has died and * telling it that it has acquired. Also check if it has died and
* clean up (similar to logic employed in change_console()) * clean up (similar to logic employed in change_console())
*/ */
if (vc->vt_mode.mode == VT_PROCESS) { if (vc->vt_mode.mode == VT_PROCESS || vc->vt_mode.mode == VT_PROCESS_AUTO) {
/* /*
* Send the signal as privileged - kill_pid() will * Send the signal as privileged - kill_pid() will
* tell us if the process has gone or something else * tell us if the process has gone or something else
@ -1682,7 +1682,7 @@ void change_console(struct vc_data *new_vc)
* vt to auto control. * vt to auto control.
*/ */
vc = vc_cons[fg_console].d; vc = vc_cons[fg_console].d;
if (vc->vt_mode.mode == VT_PROCESS) { if (vc->vt_mode.mode == VT_PROCESS || vc->vt_mode.mode == VT_PROCESS_AUTO) {
/* /*
* Send the signal as privileged - kill_pid() will * Send the signal as privileged - kill_pid() will
* tell us if the process has gone or something else * tell us if the process has gone or something else
@ -1693,27 +1693,28 @@ void change_console(struct vc_data *new_vc)
*/ */
vc->vt_newvt = new_vc->vc_num; vc->vt_newvt = new_vc->vc_num;
if (kill_pid(vc->vt_pid, vc->vt_mode.relsig, 1) == 0) { if (kill_pid(vc->vt_pid, vc->vt_mode.relsig, 1) == 0) {
if(vc->vt_mode.mode == VT_PROCESS)
/*
* It worked. Mark the vt to switch to and
* return. The process needs to send us a
* VT_RELDISP ioctl to complete the switch.
*/
return;
} else {
/* /*
* It worked. Mark the vt to switch to and * The controlling process has died, so we revert back to
* return. The process needs to send us a * normal operation. In this case, we'll also change back
* VT_RELDISP ioctl to complete the switch. * to KD_TEXT mode. I'm not sure if this is strictly correct
* but it saves the agony when the X server dies and the screen
* remains blanked due to KD_GRAPHICS! It would be nice to do
* this outside of VT_PROCESS but there is no single process
* to account for and tracking tty count may be undesirable.
*/ */
return; reset_vc(vc);
} }
/* /*
* The controlling process has died, so we revert back to * Fall through to normal (VT_AUTO and VT_PROCESS_AUTO) handling of the switch...
* normal operation. In this case, we'll also change back
* to KD_TEXT mode. I'm not sure if this is strictly correct
* but it saves the agony when the X server dies and the screen
* remains blanked due to KD_GRAPHICS! It would be nice to do
* this outside of VT_PROCESS but there is no single process
* to account for and tracking tty count may be undesirable.
*/
reset_vc(vc);
/*
* Fall through to normal (VT_AUTO) handling of the switch...
*/ */
} }

93
drivers/mmc/card/sdio_uart.c
View File

@ -37,6 +37,7 @@
#include <linux/gfp.h> #include <linux/gfp.h>
#include <linux/tty.h> #include <linux/tty.h>
#include <linux/tty_flip.h> #include <linux/tty_flip.h>
#include <linux/kfifo.h>
#include <linux/mmc/core.h> #include <linux/mmc/core.h>
#include <linux/mmc/card.h> #include <linux/mmc/card.h>
@ -47,19 +48,9 @@
#define UART_NR 8 /* Number of UARTs this driver can handle */ #define UART_NR 8 /* Number of UARTs this driver can handle */
#define UART_XMIT_SIZE PAGE_SIZE #define FIFO_SIZE PAGE_SIZE
#define WAKEUP_CHARS 256 #define WAKEUP_CHARS 256
#define circ_empty(circ) ((circ)->head == (circ)->tail)
#define circ_clear(circ) ((circ)->head = (circ)->tail = 0)
#define circ_chars_pending(circ) \
(CIRC_CNT((circ)->head, (circ)->tail, UART_XMIT_SIZE))
#define circ_chars_free(circ) \
(CIRC_SPACE((circ)->head, (circ)->tail, UART_XMIT_SIZE))
struct uart_icount { struct uart_icount {
__u32 cts; __u32 cts;
__u32 dsr; __u32 dsr;
@ -82,7 +73,7 @@ struct sdio_uart_port {
struct mutex func_lock; struct mutex func_lock;
struct task_struct *in_sdio_uart_irq; struct task_struct *in_sdio_uart_irq;
unsigned int regs_offset; unsigned int regs_offset;
struct circ_buf xmit; struct kfifo xmit_fifo;
spinlock_t write_lock; spinlock_t write_lock;
struct uart_icount icount; struct uart_icount icount;
unsigned int uartclk; unsigned int uartclk;
@ -105,6 +96,8 @@ static int sdio_uart_add_port(struct sdio_uart_port *port)
kref_init(&port->kref); kref_init(&port->kref);
mutex_init(&port->func_lock); mutex_init(&port->func_lock);
spin_lock_init(&port->write_lock); spin_lock_init(&port->write_lock);
if (kfifo_alloc(&port->xmit_fifo, FIFO_SIZE, GFP_KERNEL))
return -ENOMEM;
spin_lock(&sdio_uart_table_lock); spin_lock(&sdio_uart_table_lock);
for (index = 0; index < UART_NR; index++) { for (index = 0; index < UART_NR; index++) {
@ -140,6 +133,7 @@ static void sdio_uart_port_destroy(struct kref *kref)
{ {
struct sdio_uart_port *port = struct sdio_uart_port *port =
container_of(kref, struct sdio_uart_port, kref); container_of(kref, struct sdio_uart_port, kref);
kfifo_free(&port->xmit_fifo);
kfree(port); kfree(port);
} }
@ -456,9 +450,11 @@ static void sdio_uart_receive_chars(struct sdio_uart_port *port,
static void sdio_uart_transmit_chars(struct sdio_uart_port *port) static void sdio_uart_transmit_chars(struct sdio_uart_port *port)
{ {
struct circ_buf *xmit = &port->xmit; struct kfifo *xmit = &port->xmit_fifo;
int count; int count;
struct tty_struct *tty; struct tty_struct *tty;
u8 iobuf[16];
int len;
if (port->x_char) { if (port->x_char) {
sdio_out(port, UART_TX, port->x_char); sdio_out(port, UART_TX, port->x_char);
@ -469,27 +465,25 @@ static void sdio_uart_transmit_chars(struct sdio_uart_port *port)
tty = tty_port_tty_get(&port->port); tty = tty_port_tty_get(&port->port);
if (tty == NULL || circ_empty(xmit) || if (tty == NULL || !kfifo_len(xmit) ||
tty->stopped || tty->hw_stopped) { tty->stopped || tty->hw_stopped) {
sdio_uart_stop_tx(port); sdio_uart_stop_tx(port);
tty_kref_put(tty); tty_kref_put(tty);
return; return;
} }
count = 16; len = kfifo_out_locked(xmit, iobuf, 16, &port->write_lock);
do { for (count = 0; count < len; count++) {
sdio_out(port, UART_TX, xmit->buf[xmit->tail]); sdio_out(port, UART_TX, iobuf[count]);
xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
port->icount.tx++; port->icount.tx++;
if (circ_empty(xmit)) }
break;
} while (--count > 0);
if (circ_chars_pending(xmit) < WAKEUP_CHARS) len = kfifo_len(xmit);
if (len < WAKEUP_CHARS) {
tty_wakeup(tty); tty_wakeup(tty);
if (len == 0)
if (circ_empty(xmit)) sdio_uart_stop_tx(port);
sdio_uart_stop_tx(port); }
tty_kref_put(tty); tty_kref_put(tty);
} }
@ -632,7 +626,6 @@ static int sdio_uart_activate(struct tty_port *tport, struct tty_struct *tty)
{ {
struct sdio_uart_port *port = struct sdio_uart_port *port =
container_of(tport, struct sdio_uart_port, port); container_of(tport, struct sdio_uart_port, port);
unsigned long page;
int ret; int ret;
/* /*
@ -641,22 +634,17 @@ static int sdio_uart_activate(struct tty_port *tport, struct tty_struct *tty)
*/ */
set_bit(TTY_IO_ERROR, &tty->flags); set_bit(TTY_IO_ERROR, &tty->flags);
/* Initialise and allocate the transmit buffer. */ kfifo_reset(&port->xmit_fifo);
page = __get_free_page(GFP_KERNEL);
if (!page)
return -ENOMEM;
port->xmit.buf = (unsigned char *)page;
circ_clear(&port->xmit);
ret = sdio_uart_claim_func(port); ret = sdio_uart_claim_func(port);
if (ret) if (ret)
goto err1; return ret;
ret = sdio_enable_func(port->func); ret = sdio_enable_func(port->func);
if (ret) if (ret)
goto err2; goto err1;
ret = sdio_claim_irq(port->func, sdio_uart_irq); ret = sdio_claim_irq(port->func, sdio_uart_irq);
if (ret) if (ret)
goto err3; goto err2;
/* /*
* Clear the FIFO buffers and disable them. * Clear the FIFO buffers and disable them.
@ -700,12 +688,10 @@ static int sdio_uart_activate(struct tty_port *tport, struct tty_struct *tty)
sdio_uart_release_func(port); sdio_uart_release_func(port);
return 0; return 0;
err3:
sdio_disable_func(port->func);
err2: err2:
sdio_uart_release_func(port); sdio_disable_func(port->func);
err1: err1:
free_page((unsigned long)port->xmit.buf); sdio_uart_release_func(port);
return ret; return ret;
} }
@ -727,7 +713,7 @@ static void sdio_uart_shutdown(struct tty_port *tport)
ret = sdio_uart_claim_func(port); ret = sdio_uart_claim_func(port);
if (ret) if (ret)
goto skip; return;
sdio_uart_stop_rx(port); sdio_uart_stop_rx(port);
@ -749,10 +735,6 @@ static void sdio_uart_shutdown(struct tty_port *tport)
sdio_disable_func(port->func); sdio_disable_func(port->func);
sdio_uart_release_func(port); sdio_uart_release_func(port);
skip:
/* Free the transmit buffer page. */
free_page((unsigned long)port->xmit.buf);
} }
/** /**
@ -822,27 +804,12 @@ static int sdio_uart_write(struct tty_struct *tty, const unsigned char *buf,
int count) int count)
{ {
struct sdio_uart_port *port = tty->driver_data; struct sdio_uart_port *port = tty->driver_data;
struct circ_buf *circ = &port->xmit; int ret;
int c, ret = 0;
if (!port->func) if (!port->func)
return -ENODEV; return -ENODEV;
spin_lock(&port->write_lock); ret = kfifo_in_locked(&port->xmit_fifo, buf, count, &port->write_lock);
while (1) {
c = CIRC_SPACE_TO_END(circ->head, circ->tail, UART_XMIT_SIZE);
if (count < c)
c = count;
if (c <= 0)
break;
memcpy(circ->buf + circ->head, buf, c);
circ->head = (circ->head + c) & (UART_XMIT_SIZE - 1);
buf += c;
count -= c;
ret += c;
}
spin_unlock(&port->write_lock);
if (!(port->ier & UART_IER_THRI)) { if (!(port->ier & UART_IER_THRI)) {
int err = sdio_uart_claim_func(port); int err = sdio_uart_claim_func(port);
if (!err) { if (!err) {
@ -859,13 +826,13 @@ static int sdio_uart_write(struct tty_struct *tty, const unsigned char *buf,
static int sdio_uart_write_room(struct tty_struct *tty) static int sdio_uart_write_room(struct tty_struct *tty)
{ {
struct sdio_uart_port *port = tty->driver_data; struct sdio_uart_port *port = tty->driver_data;
return port ? circ_chars_free(&port->xmit) : 0; return FIFO_SIZE - kfifo_len(&port->xmit_fifo);
} }
static int sdio_uart_chars_in_buffer(struct tty_struct *tty) static int sdio_uart_chars_in_buffer(struct tty_struct *tty)
{ {
struct sdio_uart_port *port = tty->driver_data; struct sdio_uart_port *port = tty->driver_data;
return port ? circ_chars_pending(&port->xmit) : 0; return kfifo_len(&port->xmit_fifo);
} }
static void sdio_uart_send_xchar(struct tty_struct *tty, char ch) static void sdio_uart_send_xchar(struct tty_struct *tty, char ch)

6
drivers/parport/parport_pc.c
View File

@ -2908,6 +2908,7 @@ enum parport_pc_pci_cards {
netmos_9805, netmos_9805,
netmos_9815, netmos_9815,
netmos_9901, netmos_9901,
netmos_9865,
quatech_sppxp100, quatech_sppxp100,
}; };
@ -2989,6 +2990,7 @@ static struct parport_pc_pci {
/* netmos_9805 */ { 1, { { 0, -1 }, } }, /* netmos_9805 */ { 1, { { 0, -1 }, } },
/* netmos_9815 */ { 2, { { 0, -1 }, { 2, -1 }, } }, /* netmos_9815 */ { 2, { { 0, -1 }, { 2, -1 }, } },
/* netmos_9901 */ { 1, { { 0, -1 }, } }, /* netmos_9901 */ { 1, { { 0, -1 }, } },
/* netmos_9865 */ { 1, { { 0, -1 }, } },
/* quatech_sppxp100 */ { 1, { { 0, 1 }, } }, /* quatech_sppxp100 */ { 1, { { 0, 1 }, } },
}; };
@ -3092,6 +3094,10 @@ static const struct pci_device_id parport_pc_pci_tbl[] = {
PCI_ANY_ID, PCI_ANY_ID, 0, 0, netmos_9815 }, PCI_ANY_ID, PCI_ANY_ID, 0, 0, netmos_9815 },
{ PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9901, { PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9901,
0xA000, 0x2000, 0, 0, netmos_9901 }, 0xA000, 0x2000, 0, 0, netmos_9901 },
{ PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9865,
0xA000, 0x1000, 0, 0, netmos_9865 },
{ PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9865,
0xA000, 0x2000, 0, 0, netmos_9865 },
/* Quatech SPPXP-100 Parallel port PCI ExpressCard */ /* Quatech SPPXP-100 Parallel port PCI ExpressCard */
{ PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_SPPXP_100, { PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_SPPXP_100,
PCI_ANY_ID, PCI_ANY_ID, 0, 0, quatech_sppxp100 }, PCI_ANY_ID, PCI_ANY_ID, 0, 0, quatech_sppxp100 },

8
drivers/serial/68328serial.c
View File

@ -153,8 +153,6 @@ static int baud_table[] = {
0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800, 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
9600, 19200, 38400, 57600, 115200, 0 }; 9600, 19200, 38400, 57600, 115200, 0 };
#define BAUD_TABLE_SIZE (sizeof(baud_table)/sizeof(baud_table[0]))
/* Sets or clears DTR/RTS on the requested line */ /* Sets or clears DTR/RTS on the requested line */
static inline void m68k_rtsdtr(struct m68k_serial *ss, int set) static inline void m68k_rtsdtr(struct m68k_serial *ss, int set)
{ {
@ -1406,10 +1404,10 @@ static void m68328_set_baud(void)
USTCNT = ustcnt & ~USTCNT_TXEN; USTCNT = ustcnt & ~USTCNT_TXEN;
again: again:
for (i = 0; i < sizeof(baud_table) / sizeof(baud_table[0]); i++) for (i = 0; i < ARRAY_SIZE(baud_table); i++)
if (baud_table[i] == m68328_console_baud) if (baud_table[i] == m68328_console_baud)
break; break;
if (i >= sizeof(baud_table) / sizeof(baud_table[0])) { if (i >= ARRAY_SIZE(baud_table)) {
m68328_console_baud = 9600; m68328_console_baud = 9600;
goto again; goto again;
} }
@ -1435,7 +1433,7 @@ int m68328_console_setup(struct console *cp, char *arg)
if (arg) if (arg)
n = simple_strtoul(arg,NULL,0); n = simple_strtoul(arg,NULL,0);
for (i = 0; i < BAUD_TABLE_SIZE; i++) for (i = 0; i < ARRAY_SIZE(baud_table); i++)
if (baud_table[i] == n) if (baud_table[i] == n)
break; break;
if (i < BAUD_TABLE_SIZE) { if (i < BAUD_TABLE_SIZE) {

21
drivers/serial/8250.c
View File

@ -2690,6 +2690,15 @@ static void __init serial8250_isa_init_ports(void)
} }
} }
static void
serial8250_init_fixed_type_port(struct uart_8250_port *up, unsigned int type)
{
up->port.type = type;
up->port.fifosize = uart_config[type].fifo_size;
up->capabilities = uart_config[type].flags;
up->tx_loadsz = uart_config[type].tx_loadsz;
}
static void __init static void __init
serial8250_register_ports(struct uart_driver *drv, struct device *dev) serial8250_register_ports(struct uart_driver *drv, struct device *dev)
{ {
@ -2706,6 +2715,10 @@ serial8250_register_ports(struct uart_driver *drv, struct device *dev)
struct uart_8250_port *up = &serial8250_ports[i]; struct uart_8250_port *up = &serial8250_ports[i];
up->port.dev = dev; up->port.dev = dev;
if (up->port.flags & UPF_FIXED_TYPE)
serial8250_init_fixed_type_port(up, up->port.type);
uart_add_one_port(drv, &up->port); uart_add_one_port(drv, &up->port);
} }
} }
@ -3118,12 +3131,8 @@ int serial8250_register_port(struct uart_port *port)
if (port->dev) if (port->dev)
uart->port.dev = port->dev; uart->port.dev = port->dev;
if (port->flags & UPF_FIXED_TYPE) { if (port->flags & UPF_FIXED_TYPE)
uart->port.type = port->type; serial8250_init_fixed_type_port(uart, port->type);
uart->port.fifosize = uart_config[port->type].fifo_size;
uart->capabilities = uart_config[port->type].flags;
uart->tx_loadsz = uart_config[port->type].tx_loadsz;
}
set_io_from_upio(&uart->port); set_io_from_upio(&uart->port);
/* Possibly override default I/O functions. */ /* Possibly override default I/O functions. */

31
drivers/serial/8250_pci.c
View File

@ -760,7 +760,8 @@ static int pci_netmos_init(struct pci_dev *dev)
/* subdevice 0x00PS means <P> parallel, <S> serial */ /* subdevice 0x00PS means <P> parallel, <S> serial */
unsigned int num_serial = dev->subsystem_device & 0xf; unsigned int num_serial = dev->subsystem_device & 0xf;
if (dev->device == PCI_DEVICE_ID_NETMOS_9901) if ((dev->device == PCI_DEVICE_ID_NETMOS_9901) ||
(dev->device == PCI_DEVICE_ID_NETMOS_9865))
return 0; return 0;
if (dev->subsystem_vendor == PCI_VENDOR_ID_IBM && if (dev->subsystem_vendor == PCI_VENDOR_ID_IBM &&
dev->subsystem_device == 0x0299) dev->subsystem_device == 0x0299)
@ -1479,6 +1480,7 @@ enum pci_board_num_t {
pbn_b0_bt_1_115200, pbn_b0_bt_1_115200,
pbn_b0_bt_2_115200, pbn_b0_bt_2_115200,
pbn_b0_bt_4_115200,
pbn_b0_bt_8_115200, pbn_b0_bt_8_115200,
pbn_b0_bt_1_460800, pbn_b0_bt_1_460800,
@ -1703,6 +1705,12 @@ static struct pciserial_board pci_boards[] __devinitdata = {
.base_baud = 115200, .base_baud = 115200,
.uart_offset = 8, .uart_offset = 8,
}, },
[pbn_b0_bt_4_115200] = {
.flags = FL_BASE0|FL_BASE_BARS,
.num_ports = 4,
.base_baud = 115200,
.uart_offset = 8,
},
[pbn_b0_bt_8_115200] = { [pbn_b0_bt_8_115200] = {
.flags = FL_BASE0|FL_BASE_BARS, .flags = FL_BASE0|FL_BASE_BARS,
.num_ports = 8, .num_ports = 8,
@ -3191,6 +3199,15 @@ static struct pci_device_id serial_pci_tbl[] = {
0x1208, 0x0004, 0, 0, 0x1208, 0x0004, 0, 0,
pbn_b0_4_921600 }, pbn_b0_4_921600 },
{ PCI_VENDOR_ID_KORENIX, PCI_DEVICE_ID_KORENIX_JETCARDF2,
0x1204, 0x0004, 0, 0,
pbn_b0_4_921600 },
{ PCI_VENDOR_ID_KORENIX, PCI_DEVICE_ID_KORENIX_JETCARDF2,
0x1208, 0x0004, 0, 0,
pbn_b0_4_921600 },
{ PCI_VENDOR_ID_KORENIX, PCI_DEVICE_ID_KORENIX_JETCARDF3,
0x1208, 0x0004, 0, 0,
pbn_b0_4_921600 },
/* /*
* Dell Remote Access Card 4 - Tim_T_Murphy@Dell.com * Dell Remote Access Card 4 - Tim_T_Murphy@Dell.com
*/ */
@ -3648,6 +3665,18 @@ static struct pci_device_id serial_pci_tbl[] = {
0xA000, 0x1000, 0xA000, 0x1000,
0, 0, pbn_b0_1_115200 }, 0, 0, pbn_b0_1_115200 },
/*
* Best Connectivity PCI Multi I/O cards
*/
{ PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9865,
0xA000, 0x1000,
0, 0, pbn_b0_1_115200 },
{ PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9865,
0xA000, 0x3004,
0, 0, pbn_b0_bt_4_115200 },
/* /*
* These entries match devices with class COMMUNICATION_SERIAL, * These entries match devices with class COMMUNICATION_SERIAL,
* COMMUNICATION_MODEM or COMMUNICATION_MULTISERIAL * COMMUNICATION_MODEM or COMMUNICATION_MULTISERIAL

55
drivers/serial/Kconfig
View File

@ -1418,42 +1418,37 @@ config SERIAL_BFIN_SPORT
To compile this driver as a module, choose M here: the To compile this driver as a module, choose M here: the
module will be called bfin_sport_uart. module will be called bfin_sport_uart.
choice config SERIAL_BFIN_SPORT_CONSOLE
prompt "Baud rate for Blackfin SPORT UART" bool "Console on Blackfin sport emulated uart"
depends on SERIAL_BFIN_SPORT depends on SERIAL_BFIN_SPORT=y
default SERIAL_SPORT_BAUD_RATE_57600 select SERIAL_CORE_CONSOLE
config SERIAL_BFIN_SPORT0_UART
bool "Enable UART over SPORT0"
depends on SERIAL_BFIN_SPORT && !(BF542 || BF542M || BF544 || BF544M)
help help
Choose a baud rate for the SPORT UART, other uart settings are Enable UART over SPORT0
8 bit, 1 stop bit, no parity, no flow control.
config SERIAL_SPORT_BAUD_RATE_115200 config SERIAL_BFIN_SPORT1_UART
bool "115200" bool "Enable UART over SPORT1"
config SERIAL_SPORT_BAUD_RATE_57600
bool "57600"
config SERIAL_SPORT_BAUD_RATE_38400
bool "38400"
config SERIAL_SPORT_BAUD_RATE_19200
bool "19200"
config SERIAL_SPORT_BAUD_RATE_9600
bool "9600"
endchoice
config SPORT_BAUD_RATE
int
depends on SERIAL_BFIN_SPORT depends on SERIAL_BFIN_SPORT
default 115200 if (SERIAL_SPORT_BAUD_RATE_115200) help
default 57600 if (SERIAL_SPORT_BAUD_RATE_57600) Enable UART over SPORT1
default 38400 if (SERIAL_SPORT_BAUD_RATE_38400)
default 19200 if (SERIAL_SPORT_BAUD_RATE_19200) config SERIAL_BFIN_SPORT2_UART
default 9600 if (SERIAL_SPORT_BAUD_RATE_9600) bool "Enable UART over SPORT2"
depends on SERIAL_BFIN_SPORT && (BF54x || BF538 || BF539)
help
Enable UART over SPORT2
config SERIAL_BFIN_SPORT3_UART
bool "Enable UART over SPORT3"
depends on SERIAL_BFIN_SPORT && (BF54x || BF538 || BF539)
help
Enable UART over SPORT3
config SERIAL_TIMBERDALE config SERIAL_TIMBERDALE
tristate "Support for timberdale UART" tristate "Support for timberdale UART"
depends on MFD_TIMBERDALE
select SERIAL_CORE select SERIAL_CORE
---help--- ---help---
Add support for UART controller on timberdale. Add support for UART controller on timberdale.

22
drivers/serial/atmel_serial.c
View File

@ -1213,6 +1213,24 @@ static int atmel_verify_port(struct uart_port *port, struct serial_struct *ser)
return ret; return ret;
} }
#ifdef CONFIG_CONSOLE_POLL
static int atmel_poll_get_char(struct uart_port *port)
{
while (!(UART_GET_CSR(port) & ATMEL_US_RXRDY))
cpu_relax();
return UART_GET_CHAR(port);
}
static void atmel_poll_put_char(struct uart_port *port, unsigned char ch)
{
while (!(UART_GET_CSR(port) & ATMEL_US_TXRDY))
cpu_relax();
UART_PUT_CHAR(port, ch);
}
#endif
static struct uart_ops atmel_pops = { static struct uart_ops atmel_pops = {
.tx_empty = atmel_tx_empty, .tx_empty = atmel_tx_empty,
.set_mctrl = atmel_set_mctrl, .set_mctrl = atmel_set_mctrl,
@ -1232,6 +1250,10 @@ static struct uart_ops atmel_pops = {
.config_port = atmel_config_port, .config_port = atmel_config_port,
.verify_port = atmel_verify_port, .verify_port = atmel_verify_port,
.pm = atmel_serial_pm, .pm = atmel_serial_pm,
#ifdef CONFIG_CONSOLE_POLL
.poll_get_char = atmel_poll_get_char,
.poll_put_char = atmel_poll_put_char,
#endif
}; };
/* /*

7
drivers/serial/bcm63xx_uart.c
View File

@ -35,7 +35,7 @@
#include <bcm63xx_regs.h> #include <bcm63xx_regs.h>
#include <bcm63xx_io.h> #include <bcm63xx_io.h>
#define BCM63XX_NR_UARTS 1 #define BCM63XX_NR_UARTS 2
static struct uart_port ports[BCM63XX_NR_UARTS]; static struct uart_port ports[BCM63XX_NR_UARTS];
@ -784,7 +784,7 @@ static struct uart_driver bcm_uart_driver = {
.dev_name = "ttyS", .dev_name = "ttyS",
.major = TTY_MAJOR, .major = TTY_MAJOR,
.minor = 64, .minor = 64,
.nr = 1, .nr = BCM63XX_NR_UARTS,
.cons = BCM63XX_CONSOLE, .cons = BCM63XX_CONSOLE,
}; };
@ -826,11 +826,12 @@ static int __devinit bcm_uart_probe(struct platform_device *pdev)
port->dev = &pdev->dev; port->dev = &pdev->dev;
port->fifosize = 16; port->fifosize = 16;
port->uartclk = clk_get_rate(clk) / 2; port->uartclk = clk_get_rate(clk) / 2;
port->line = pdev->id;
clk_put(clk); clk_put(clk);
ret = uart_add_one_port(&bcm_uart_driver, port); ret = uart_add_one_port(&bcm_uart_driver, port);
if (ret) { if (ret) {
kfree(port); ports[pdev->id].membase = 0;
return ret; return ret;
} }
platform_set_drvdata(pdev, port); platform_set_drvdata(pdev, port);

22
drivers/serial/bfin_5xx.c
View File

@ -14,6 +14,7 @@
#include <linux/module.h> #include <linux/module.h>
#include <linux/ioport.h> #include <linux/ioport.h>
#include <linux/io.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/console.h> #include <linux/console.h>
#include <linux/sysrq.h> #include <linux/sysrq.h>
@ -237,7 +238,8 @@ static void bfin_serial_rx_chars(struct bfin_serial_port *uart)
#if defined(CONFIG_KGDB_SERIAL_CONSOLE) || \ #if defined(CONFIG_KGDB_SERIAL_CONSOLE) || \
defined(CONFIG_KGDB_SERIAL_CONSOLE_MODULE) defined(CONFIG_KGDB_SERIAL_CONSOLE_MODULE)
if (kgdb_connected && kgdboc_port_line == uart->port.line) if (kgdb_connected && kgdboc_port_line == uart->port.line
&& kgdboc_break_enabled)
if (ch == 0x3) {/* Ctrl + C */ if (ch == 0x3) {/* Ctrl + C */
kgdb_breakpoint(); kgdb_breakpoint();
return; return;
@ -488,6 +490,7 @@ void bfin_serial_rx_dma_timeout(struct bfin_serial_port *uart)
{ {
int x_pos, pos; int x_pos, pos;
dma_disable_irq(uart->tx_dma_channel);
dma_disable_irq(uart->rx_dma_channel); dma_disable_irq(uart->rx_dma_channel);
spin_lock_bh(&uart->port.lock); spin_lock_bh(&uart->port.lock);
@ -521,6 +524,7 @@ void bfin_serial_rx_dma_timeout(struct bfin_serial_port *uart)
} }
spin_unlock_bh(&uart->port.lock); spin_unlock_bh(&uart->port.lock);
dma_enable_irq(uart->tx_dma_channel);
dma_enable_irq(uart->rx_dma_channel); dma_enable_irq(uart->rx_dma_channel);
mod_timer(&(uart->rx_dma_timer), jiffies + DMA_RX_FLUSH_JIFFIES); mod_timer(&(uart->rx_dma_timer), jiffies + DMA_RX_FLUSH_JIFFIES);
@ -746,15 +750,6 @@ static int bfin_serial_startup(struct uart_port *port)
Status interrupt.\n"); Status interrupt.\n");
} }
if (uart->cts_pin >= 0) {
gpio_request(uart->cts_pin, DRIVER_NAME);
gpio_direction_output(uart->cts_pin, 1);
}
if (uart->rts_pin >= 0) {
gpio_request(uart->rts_pin, DRIVER_NAME);
gpio_direction_output(uart->rts_pin, 0);
}
/* CTS RTS PINs are negative assertive. */ /* CTS RTS PINs are negative assertive. */
UART_PUT_MCR(uart, ACTS); UART_PUT_MCR(uart, ACTS);
UART_SET_IER(uart, EDSSI); UART_SET_IER(uart, EDSSI);
@ -801,10 +796,6 @@ static void bfin_serial_shutdown(struct uart_port *port)
gpio_free(uart->rts_pin); gpio_free(uart->rts_pin);
#endif #endif
#ifdef CONFIG_SERIAL_BFIN_HARD_CTSRTS #ifdef CONFIG_SERIAL_BFIN_HARD_CTSRTS
if (uart->cts_pin >= 0)
gpio_free(uart->cts_pin);
if (uart->rts_pin >= 0)
gpio_free(uart->rts_pin);
if (UART_GET_IER(uart) && EDSSI) if (UART_GET_IER(uart) && EDSSI)
free_irq(uart->status_irq, uart); free_irq(uart->status_irq, uart);
#endif #endif
@ -1409,8 +1400,7 @@ static int bfin_serial_remove(struct platform_device *dev)
continue; continue;
uart_remove_one_port(&bfin_serial_reg, &bfin_serial_ports[i].port); uart_remove_one_port(&bfin_serial_reg, &bfin_serial_ports[i].port);
bfin_serial_ports[i].port.dev = NULL; bfin_serial_ports[i].port.dev = NULL;
#if defined(CONFIG_SERIAL_BFIN_CTSRTS) || \ #if defined(CONFIG_SERIAL_BFIN_CTSRTS)
defined(CONFIG_SERIAL_BFIN_HARD_CTSRTS)
gpio_free(bfin_serial_ports[i].cts_pin); gpio_free(bfin_serial_ports[i].cts_pin);
gpio_free(bfin_serial_ports[i].rts_pin); gpio_free(bfin_serial_ports[i].rts_pin);
#endif #endif

703
drivers/serial/bfin_sport_uart.c
View File

@ -1,27 +1,11 @@
/* /*
* File: linux/drivers/serial/bfin_sport_uart.c * Blackfin On-Chip Sport Emulated UART Driver
* *
* Based on: drivers/serial/bfin_5xx.c by Aubrey Li. * Copyright 2006-2009 Analog Devices Inc.
* Author: Roy Huang <roy.huang@analog.com>
* *
* Created: Nov 22, 2006 * Enter bugs at http://blackfin.uclinux.org/
* Copyright: (c) 2006-2007 Analog Devices Inc.
* Description: this driver enable SPORTs on Blackfin emulate UART.
* *
* This program is free software; you can redistribute it and/or modify * Licensed under the GPL-2 or later.
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see the file COPYING, or write
* to the Free Software Foundation, Inc.,
* 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
/* /*
@ -29,39 +13,18 @@
* http://www.analog.com/UploadedFiles/Application_Notes/399447663EE191.pdf * http://www.analog.com/UploadedFiles/Application_Notes/399447663EE191.pdf
* This application note describe how to implement a UART on a Sharc DSP, * This application note describe how to implement a UART on a Sharc DSP,
* but this driver is implemented on Blackfin Processor. * but this driver is implemented on Blackfin Processor.
* Transmit Frame Sync is not used by this driver to transfer data out.
*/ */
/* After reset, there is a prelude of low level pulse when transmit data first /* #define DEBUG */
* time. No addtional pulse in following transmit.
* According to document:
* The SPORTs are ready to start transmitting or receiving data no later than
* three serial clock cycles after they are enabled in the SPORTx_TCR1 or
* SPORTx_RCR1 register. No serial clock cycles are lost from this point on.
* The first internal frame sync will occur one frame sync delay after the
* SPORTs are ready. External frame syncs can occur as soon as the SPORT is
* ready.
*/
/* Thanks to Axel Alatalo <axel@rubico.se> for fixing sport rx bug. Sometimes #define DRV_NAME "bfin-sport-uart"
* sport receives data incorrectly. The following is Axel's words. #define DEVICE_NAME "ttySS"
* As EE-191, sport rx samples 3 times of the UART baudrate and takes the #define pr_fmt(fmt) DRV_NAME ": " fmt
* middle smaple of every 3 samples as the data bit. For a 8-N-1 UART setting,
* 30 samples will be required for a byte. If transmitter sends a 1/3 bit short
* byte due to buadrate drift, then the 30th sample of a byte, this sample is
* also the third sample of the stop bit, will happens on the immediately
* following start bit which will be thrown away and missed. Thus since parts
* of the startbit will be missed and the receiver will begin to drift, the
* effect accumulates over time until synchronization is lost.
* If only require 2 samples of the stopbit (by sampling in total 29 samples),
* then a to short byte as in the case above will be tolerated. Then the 1/3
* early startbit will trigger a framesync since the last read is complete
* after only 2/3 stopbit and framesync is active during the last 1/3 looking
* for a possible early startbit. */
//#define DEBUG
#include <linux/module.h> #include <linux/module.h>
#include <linux/ioport.h> #include <linux/ioport.h>
#include <linux/io.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/console.h> #include <linux/console.h>
#include <linux/sysrq.h> #include <linux/sysrq.h>
@ -75,23 +38,36 @@
#include "bfin_sport_uart.h" #include "bfin_sport_uart.h"
#ifdef CONFIG_SERIAL_BFIN_SPORT0_UART
unsigned short bfin_uart_pin_req_sport0[] = unsigned short bfin_uart_pin_req_sport0[] =
{P_SPORT0_TFS, P_SPORT0_DTPRI, P_SPORT0_TSCLK, P_SPORT0_RFS, \ {P_SPORT0_TFS, P_SPORT0_DTPRI, P_SPORT0_TSCLK, P_SPORT0_RFS, \
P_SPORT0_DRPRI, P_SPORT0_RSCLK, P_SPORT0_DRSEC, P_SPORT0_DTSEC, 0}; P_SPORT0_DRPRI, P_SPORT0_RSCLK, P_SPORT0_DRSEC, P_SPORT0_DTSEC, 0};
#endif
#ifdef CONFIG_SERIAL_BFIN_SPORT1_UART
unsigned short bfin_uart_pin_req_sport1[] = unsigned short bfin_uart_pin_req_sport1[] =
{P_SPORT1_TFS, P_SPORT1_DTPRI, P_SPORT1_TSCLK, P_SPORT1_RFS, \ {P_SPORT1_TFS, P_SPORT1_DTPRI, P_SPORT1_TSCLK, P_SPORT1_RFS, \
P_SPORT1_DRPRI, P_SPORT1_RSCLK, P_SPORT1_DRSEC, P_SPORT1_DTSEC, 0}; P_SPORT1_DRPRI, P_SPORT1_RSCLK, P_SPORT1_DRSEC, P_SPORT1_DTSEC, 0};
#endif
#define DRV_NAME "bfin-sport-uart" #ifdef CONFIG_SERIAL_BFIN_SPORT2_UART
unsigned short bfin_uart_pin_req_sport2[] =
{P_SPORT2_TFS, P_SPORT2_DTPRI, P_SPORT2_TSCLK, P_SPORT2_RFS, \
P_SPORT2_DRPRI, P_SPORT2_RSCLK, P_SPORT2_DRSEC, P_SPORT2_DTSEC, 0};
#endif
#ifdef CONFIG_SERIAL_BFIN_SPORT3_UART
unsigned short bfin_uart_pin_req_sport3[] =
{P_SPORT3_TFS, P_SPORT3_DTPRI, P_SPORT3_TSCLK, P_SPORT3_RFS, \
P_SPORT3_DRPRI, P_SPORT3_RSCLK, P_SPORT3_DRSEC, P_SPORT3_DTSEC, 0};
#endif
struct sport_uart_port { struct sport_uart_port {
struct uart_port port; struct uart_port port;
char *name;
int tx_irq;
int rx_irq;
int err_irq; int err_irq;
unsigned short csize;
unsigned short rxmask;
unsigned short txmask1;
unsigned short txmask2;
unsigned char stopb;
/* unsigned char parib; */
}; };
static void sport_uart_tx_chars(struct sport_uart_port *up); static void sport_uart_tx_chars(struct sport_uart_port *up);
@ -99,36 +75,42 @@ static void sport_stop_tx(struct uart_port *port);
static inline void tx_one_byte(struct sport_uart_port *up, unsigned int value) static inline void tx_one_byte(struct sport_uart_port *up, unsigned int value)
{ {
pr_debug("%s value:%x\n", __func__, value); pr_debug("%s value:%x, mask1=0x%x, mask2=0x%x\n", __func__, value,
/* Place a Start and Stop bit */ up->txmask1, up->txmask2);
/* Place Start and Stop bits */
__asm__ __volatile__ ( __asm__ __volatile__ (
"R2 = b#01111111100;" "%[val] <<= 1;"
"R3 = b#10000000001;" "%[val] = %[val] & %[mask1];"
"%0 <<= 2;" "%[val] = %[val] | %[mask2];"
"%0 = %0 & R2;" : [val]"+d"(value)
"%0 = %0 | R3;" : [mask1]"d"(up->txmask1), [mask2]"d"(up->txmask2)
: "=d"(value) : "ASTAT"
: "d"(value)
: "ASTAT", "R2", "R3"
); );
pr_debug("%s value:%x\n", __func__, value); pr_debug("%s value:%x\n", __func__, value);
SPORT_PUT_TX(up, value); SPORT_PUT_TX(up, value);
} }
static inline unsigned int rx_one_byte(struct sport_uart_port *up) static inline unsigned char rx_one_byte(struct sport_uart_port *up)
{ {
unsigned int value, extract; unsigned int value;
unsigned char extract;
u32 tmp_mask1, tmp_mask2, tmp_shift, tmp; u32 tmp_mask1, tmp_mask2, tmp_shift, tmp;
value = SPORT_GET_RX32(up); if ((up->csize + up->stopb) > 7)
pr_debug("%s value:%x\n", __func__, value); value = SPORT_GET_RX32(up);
else
value = SPORT_GET_RX(up);
/* Extract 8 bits data */ pr_debug("%s value:%x, cs=%d, mask=0x%x\n", __func__, value,
up->csize, up->rxmask);
/* Extract data */
__asm__ __volatile__ ( __asm__ __volatile__ (
"%[extr] = 0;" "%[extr] = 0;"
"%[mask1] = 0x1801(Z);" "%[mask1] = %[rxmask];"
"%[mask2] = 0x0300(Z);" "%[mask2] = 0x0200(Z);"
"%[shift] = 0;" "%[shift] = 0;"
"LSETUP(.Lloop_s, .Lloop_e) LC0 = %[lc];" "LSETUP(.Lloop_s, .Lloop_e) LC0 = %[lc];"
".Lloop_s:" ".Lloop_s:"
@ -138,9 +120,9 @@ static inline unsigned int rx_one_byte(struct sport_uart_port *up)
"%[mask1] = %[mask1] - %[mask2];" "%[mask1] = %[mask1] - %[mask2];"
".Lloop_e:" ".Lloop_e:"
"%[shift] += 1;" "%[shift] += 1;"
: [val]"=d"(value), [extr]"=d"(extract), [shift]"=d"(tmp_shift), [tmp]"=d"(tmp), : [extr]"=&d"(extract), [shift]"=&d"(tmp_shift), [tmp]"=&d"(tmp),
[mask1]"=d"(tmp_mask1), [mask2]"=d"(tmp_mask2) [mask1]"=&d"(tmp_mask1), [mask2]"=&d"(tmp_mask2)
: "d"(value), [lc]"a"(8) : [val]"d"(value), [rxmask]"d"(up->rxmask), [lc]"a"(up->csize)
: "ASTAT", "LB0", "LC0", "LT0" : "ASTAT", "LB0", "LC0", "LT0"
); );
@ -148,29 +130,28 @@ static inline unsigned int rx_one_byte(struct sport_uart_port *up)
return extract; return extract;
} }
static int sport_uart_setup(struct sport_uart_port *up, int sclk, int baud_rate) static int sport_uart_setup(struct sport_uart_port *up, int size, int baud_rate)
{ {
int tclkdiv, tfsdiv, rclkdiv; int tclkdiv, rclkdiv;
unsigned int sclk = get_sclk();
/* Set TCR1 and TCR2 */ /* Set TCR1 and TCR2, TFSR is not enabled for uart */
SPORT_PUT_TCR1(up, (LATFS | ITFS | TFSR | TLSBIT | ITCLK)); SPORT_PUT_TCR1(up, (ITFS | TLSBIT | ITCLK));
SPORT_PUT_TCR2(up, 10); SPORT_PUT_TCR2(up, size + 1);
pr_debug("%s TCR1:%x, TCR2:%x\n", __func__, SPORT_GET_TCR1(up), SPORT_GET_TCR2(up)); pr_debug("%s TCR1:%x, TCR2:%x\n", __func__, SPORT_GET_TCR1(up), SPORT_GET_TCR2(up));
/* Set RCR1 and RCR2 */ /* Set RCR1 and RCR2 */
SPORT_PUT_RCR1(up, (RCKFE | LARFS | LRFS | RFSR | IRCLK)); SPORT_PUT_RCR1(up, (RCKFE | LARFS | LRFS | RFSR | IRCLK));
SPORT_PUT_RCR2(up, 28); SPORT_PUT_RCR2(up, (size + 1) * 2 - 1);
pr_debug("%s RCR1:%x, RCR2:%x\n", __func__, SPORT_GET_RCR1(up), SPORT_GET_RCR2(up)); pr_debug("%s RCR1:%x, RCR2:%x\n", __func__, SPORT_GET_RCR1(up), SPORT_GET_RCR2(up));
tclkdiv = sclk/(2 * baud_rate) - 1; tclkdiv = sclk / (2 * baud_rate) - 1;
tfsdiv = 12; rclkdiv = sclk / (2 * baud_rate * 2) - 1;
rclkdiv = sclk/(2 * baud_rate * 3) - 1;
SPORT_PUT_TCLKDIV(up, tclkdiv); SPORT_PUT_TCLKDIV(up, tclkdiv);
SPORT_PUT_TFSDIV(up, tfsdiv);
SPORT_PUT_RCLKDIV(up, rclkdiv); SPORT_PUT_RCLKDIV(up, rclkdiv);
SSYNC(); SSYNC();
pr_debug("%s sclk:%d, baud_rate:%d, tclkdiv:%d, tfsdiv:%d, rclkdiv:%d\n", pr_debug("%s sclk:%d, baud_rate:%d, tclkdiv:%d, rclkdiv:%d\n",
__func__, sclk, baud_rate, tclkdiv, tfsdiv, rclkdiv); __func__, sclk, baud_rate, tclkdiv, rclkdiv);
return 0; return 0;
} }
@ -181,23 +162,29 @@ static irqreturn_t sport_uart_rx_irq(int irq, void *dev_id)
struct tty_struct *tty = up->port.state->port.tty; struct tty_struct *tty = up->port.state->port.tty;
unsigned int ch; unsigned int ch;
do { spin_lock(&up->port.lock);
while (SPORT_GET_STAT(up) & RXNE) {
ch = rx_one_byte(up); ch = rx_one_byte(up);
up->port.icount.rx++; up->port.icount.rx++;
if (uart_handle_sysrq_char(&up->port, ch)) if (!uart_handle_sysrq_char(&up->port, ch))
;
else
tty_insert_flip_char(tty, ch, TTY_NORMAL); tty_insert_flip_char(tty, ch, TTY_NORMAL);
} while (SPORT_GET_STAT(up) & RXNE); }
tty_flip_buffer_push(tty); tty_flip_buffer_push(tty);
spin_unlock(&up->port.lock);
return IRQ_HANDLED; return IRQ_HANDLED;
} }
static irqreturn_t sport_uart_tx_irq(int irq, void *dev_id) static irqreturn_t sport_uart_tx_irq(int irq, void *dev_id)
{ {
sport_uart_tx_chars(dev_id); struct sport_uart_port *up = dev_id;
spin_lock(&up->port.lock);
sport_uart_tx_chars(up);
spin_unlock(&up->port.lock);
return IRQ_HANDLED; return IRQ_HANDLED;
} }
@ -208,6 +195,8 @@ static irqreturn_t sport_uart_err_irq(int irq, void *dev_id)
struct tty_struct *tty = up->port.state->port.tty; struct tty_struct *tty = up->port.state->port.tty;
unsigned int stat = SPORT_GET_STAT(up); unsigned int stat = SPORT_GET_STAT(up);
spin_lock(&up->port.lock);
/* Overflow in RX FIFO */ /* Overflow in RX FIFO */
if (stat & ROVF) { if (stat & ROVF) {
up->port.icount.overrun++; up->port.icount.overrun++;
@ -216,15 +205,16 @@ static irqreturn_t sport_uart_err_irq(int irq, void *dev_id)
} }
/* These should not happen */ /* These should not happen */
if (stat & (TOVF | TUVF | RUVF)) { if (stat & (TOVF | TUVF | RUVF)) {
printk(KERN_ERR "SPORT Error:%s %s %s\n", pr_err("SPORT Error:%s %s %s\n",
(stat & TOVF)?"TX overflow":"", (stat & TOVF) ? "TX overflow" : "",
(stat & TUVF)?"TX underflow":"", (stat & TUVF) ? "TX underflow" : "",
(stat & RUVF)?"RX underflow":""); (stat & RUVF) ? "RX underflow" : "");
SPORT_PUT_TCR1(up, SPORT_GET_TCR1(up) & ~TSPEN); SPORT_PUT_TCR1(up, SPORT_GET_TCR1(up) & ~TSPEN);
SPORT_PUT_RCR1(up, SPORT_GET_RCR1(up) & ~RSPEN); SPORT_PUT_RCR1(up, SPORT_GET_RCR1(up) & ~RSPEN);
} }
SSYNC(); SSYNC();
spin_unlock(&up->port.lock);
return IRQ_HANDLED; return IRQ_HANDLED;
} }
@ -232,60 +222,37 @@ static irqreturn_t sport_uart_err_irq(int irq, void *dev_id)
static int sport_startup(struct uart_port *port) static int sport_startup(struct uart_port *port)
{ {
struct sport_uart_port *up = (struct sport_uart_port *)port; struct sport_uart_port *up = (struct sport_uart_port *)port;
char buffer[20]; int ret;
int retval;
pr_debug("%s enter\n", __func__); pr_debug("%s enter\n", __func__);
snprintf(buffer, 20, "%s rx", up->name); ret = request_irq(up->port.irq, sport_uart_rx_irq, 0,
retval = request_irq(up->rx_irq, sport_uart_rx_irq, IRQF_SAMPLE_RANDOM, buffer, up); "SPORT_UART_RX", up);
if (retval) { if (ret) {
printk(KERN_ERR "Unable to request interrupt %s\n", buffer); dev_err(port->dev, "unable to request SPORT RX interrupt\n");
return retval; return ret;
} }
snprintf(buffer, 20, "%s tx", up->name); ret = request_irq(up->port.irq+1, sport_uart_tx_irq, 0,
retval = request_irq(up->tx_irq, sport_uart_tx_irq, IRQF_SAMPLE_RANDOM, buffer, up); "SPORT_UART_TX", up);
if (retval) { if (ret) {
printk(KERN_ERR "Unable to request interrupt %s\n", buffer); dev_err(port->dev, "unable to request SPORT TX interrupt\n");
goto fail1; goto fail1;
} }
snprintf(buffer, 20, "%s err", up->name); ret = request_irq(up->err_irq, sport_uart_err_irq, 0,
retval = request_irq(up->err_irq, sport_uart_err_irq, IRQF_SAMPLE_RANDOM, buffer, up); "SPORT_UART_STATUS", up);
if (retval) { if (ret) {
printk(KERN_ERR "Unable to request interrupt %s\n", buffer); dev_err(port->dev, "unable to request SPORT status interrupt\n");
goto fail2; goto fail2;
} }
if (port->line) {
if (peripheral_request_list(bfin_uart_pin_req_sport1, DRV_NAME))
goto fail3;
} else {
if (peripheral_request_list(bfin_uart_pin_req_sport0, DRV_NAME))
goto fail3;
}
sport_uart_setup(up, get_sclk(), port->uartclk);
/* Enable receive interrupt */
SPORT_PUT_RCR1(up, (SPORT_GET_RCR1(up) | RSPEN));
SSYNC();
return 0; return 0;
fail2:
free_irq(up->port.irq+1, up);
fail1:
free_irq(up->port.irq, up);
return ret;
fail3:
printk(KERN_ERR DRV_NAME
": Requesting Peripherals failed\n");
free_irq(up->err_irq, up);
fail2:
free_irq(up->tx_irq, up);
fail1:
free_irq(up->rx_irq, up);
return retval;
} }
static void sport_uart_tx_chars(struct sport_uart_port *up) static void sport_uart_tx_chars(struct sport_uart_port *up)
@ -344,20 +311,17 @@ static void sport_set_mctrl(struct uart_port *port, unsigned int mctrl)
static void sport_stop_tx(struct uart_port *port) static void sport_stop_tx(struct uart_port *port)
{ {
struct sport_uart_port *up = (struct sport_uart_port *)port; struct sport_uart_port *up = (struct sport_uart_port *)port;
unsigned int stat;
pr_debug("%s enter\n", __func__); pr_debug("%s enter\n", __func__);
stat = SPORT_GET_STAT(up);
while(!(stat & TXHRE)) {
udelay(1);
stat = SPORT_GET_STAT(up);
}
/* Although the hold register is empty, last byte is still in shift /* Although the hold register is empty, last byte is still in shift
* register and not sent out yet. If baud rate is lower than default, * register and not sent out yet. So, put a dummy data into TX FIFO.
* delay should be longer. For example, if the baud rate is 9600, * Then, sport tx stops when last byte is shift out and the dummy
* the delay must be at least 2ms by experience */ * data is moved into the shift register.
udelay(500); */
SPORT_PUT_TX(up, 0xffff);
while (!(SPORT_GET_STAT(up) & TXHRE))
cpu_relax();
SPORT_PUT_TCR1(up, (SPORT_GET_TCR1(up) & ~TSPEN)); SPORT_PUT_TCR1(up, (SPORT_GET_TCR1(up) & ~TSPEN));
SSYNC(); SSYNC();
@ -370,6 +334,7 @@ static void sport_start_tx(struct uart_port *port)
struct sport_uart_port *up = (struct sport_uart_port *)port; struct sport_uart_port *up = (struct sport_uart_port *)port;
pr_debug("%s enter\n", __func__); pr_debug("%s enter\n", __func__);
/* Write data into SPORT FIFO before enable SPROT to transmit */ /* Write data into SPORT FIFO before enable SPROT to transmit */
sport_uart_tx_chars(up); sport_uart_tx_chars(up);
@ -403,37 +368,24 @@ static void sport_shutdown(struct uart_port *port)
{ {
struct sport_uart_port *up = (struct sport_uart_port *)port; struct sport_uart_port *up = (struct sport_uart_port *)port;
pr_debug("%s enter\n", __func__); dev_dbg(port->dev, "%s enter\n", __func__);
/* Disable sport */ /* Disable sport */
SPORT_PUT_TCR1(up, (SPORT_GET_TCR1(up) & ~TSPEN)); SPORT_PUT_TCR1(up, (SPORT_GET_TCR1(up) & ~TSPEN));
SPORT_PUT_RCR1(up, (SPORT_GET_RCR1(up) & ~RSPEN)); SPORT_PUT_RCR1(up, (SPORT_GET_RCR1(up) & ~RSPEN));
SSYNC(); SSYNC();
if (port->line) { free_irq(up->port.irq, up);
peripheral_free_list(bfin_uart_pin_req_sport1); free_irq(up->port.irq+1, up);
} else {
peripheral_free_list(bfin_uart_pin_req_sport0);
}
free_irq(up->rx_irq, up);
free_irq(up->tx_irq, up);
free_irq(up->err_irq, up); free_irq(up->err_irq, up);
} }
static void sport_set_termios(struct uart_port *port,
struct ktermios *termios, struct ktermios *old)
{
pr_debug("%s enter, c_cflag:%08x\n", __func__, termios->c_cflag);
uart_update_timeout(port, CS8 ,port->uartclk);
}
static const char *sport_type(struct uart_port *port) static const char *sport_type(struct uart_port *port)
{ {
struct sport_uart_port *up = (struct sport_uart_port *)port; struct sport_uart_port *up = (struct sport_uart_port *)port;
pr_debug("%s enter\n", __func__); pr_debug("%s enter\n", __func__);
return up->name; return up->port.type == PORT_BFIN_SPORT ? "BFIN-SPORT-UART" : NULL;
} }
static void sport_release_port(struct uart_port *port) static void sport_release_port(struct uart_port *port)
@ -461,6 +413,110 @@ static int sport_verify_port(struct uart_port *port, struct serial_struct *ser)
return 0; return 0;
} }
static void sport_set_termios(struct uart_port *port,
struct ktermios *termios, struct ktermios *old)
{
struct sport_uart_port *up = (struct sport_uart_port *)port;
unsigned long flags;
int i;
pr_debug("%s enter, c_cflag:%08x\n", __func__, termios->c_cflag);
switch (termios->c_cflag & CSIZE) {
case CS8:
up->csize = 8;
break;
case CS7:
up->csize = 7;
break;
case CS6:
up->csize = 6;
break;
case CS5:
up->csize = 5;
break;
default:
pr_warning("requested word length not supported\n");
}
if (termios->c_cflag & CSTOPB) {
up->stopb = 1;
}
if (termios->c_cflag & PARENB) {
pr_warning("PAREN bits is not supported yet\n");
/* up->parib = 1; */
}
port->read_status_mask = OE;
if (termios->c_iflag & INPCK)
port->read_status_mask |= (FE | PE);
if (termios->c_iflag & (BRKINT | PARMRK))
port->read_status_mask |= BI;
/*
* Characters to ignore
*/
port->ignore_status_mask = 0;
if (termios->c_iflag & IGNPAR)
port->ignore_status_mask |= FE | PE;
if (termios->c_iflag & IGNBRK) {
port->ignore_status_mask |= BI;
/*
* If we're ignoring parity and break indicators,
* ignore overruns too (for real raw support).
*/
if (termios->c_iflag & IGNPAR)
port->ignore_status_mask |= OE;
}
/* RX extract mask */
up->rxmask = 0x01 | (((up->csize + up->stopb) * 2 - 1) << 0x8);
/* TX masks, 8 bit data and 1 bit stop for example:
* mask1 = b#0111111110
* mask2 = b#1000000000
*/
for (i = 0, up->txmask1 = 0; i < up->csize; i++)
up->txmask1 |= (1<<i);
up->txmask2 = (1<<i);
if (up->stopb) {
++i;
up->txmask2 |= (1<<i);
}
up->txmask1 <<= 1;
up->txmask2 <<= 1;
/* uart baud rate */
port->uartclk = uart_get_baud_rate(port, termios, old, 0, get_sclk()/16);
spin_lock_irqsave(&up->port.lock, flags);
/* Disable UART */
SPORT_PUT_TCR1(up, SPORT_GET_TCR1(up) & ~TSPEN);
SPORT_PUT_RCR1(up, SPORT_GET_RCR1(up) & ~RSPEN);
sport_uart_setup(up, up->csize + up->stopb, port->uartclk);
/* driver TX line high after config, one dummy data is
* necessary to stop sport after shift one byte
*/
SPORT_PUT_TX(up, 0xffff);
SPORT_PUT_TX(up, 0xffff);
SPORT_PUT_TCR1(up, (SPORT_GET_TCR1(up) | TSPEN));
SSYNC();
while (!(SPORT_GET_STAT(up) & TXHRE))
cpu_relax();
SPORT_PUT_TCR1(up, SPORT_GET_TCR1(up) & ~TSPEN);
SSYNC();
/* Port speed changed, update the per-port timeout. */
uart_update_timeout(port, termios->c_cflag, port->uartclk);
/* Enable sport rx */
SPORT_PUT_RCR1(up, SPORT_GET_RCR1(up) | RSPEN);
SSYNC();
spin_unlock_irqrestore(&up->port.lock, flags);
}
struct uart_ops sport_uart_ops = { struct uart_ops sport_uart_ops = {
.tx_empty = sport_tx_empty, .tx_empty = sport_tx_empty,
.set_mctrl = sport_set_mctrl, .set_mctrl = sport_set_mctrl,
@ -480,138 +536,319 @@ struct uart_ops sport_uart_ops = {
.verify_port = sport_verify_port, .verify_port = sport_verify_port,
}; };
static struct sport_uart_port sport_uart_ports[] = { #define BFIN_SPORT_UART_MAX_PORTS 4
{ /* SPORT 0 */
.name = "SPORT0", static struct sport_uart_port *bfin_sport_uart_ports[BFIN_SPORT_UART_MAX_PORTS];
.tx_irq = IRQ_SPORT0_TX,
.rx_irq = IRQ_SPORT0_RX, #ifdef CONFIG_SERIAL_BFIN_SPORT_CONSOLE
.err_irq= IRQ_SPORT0_ERROR, static int __init
.port = { sport_uart_console_setup(struct console *co, char *options)
.type = PORT_BFIN_SPORT, {
.iotype = UPIO_MEM, struct sport_uart_port *up;
.membase = (void __iomem *)SPORT0_TCR1, int baud = 57600;
.mapbase = SPORT0_TCR1, int bits = 8;
.irq = IRQ_SPORT0_RX, int parity = 'n';
.uartclk = CONFIG_SPORT_BAUD_RATE, int flow = 'n';
.fifosize = 8,
.ops = &sport_uart_ops, /* Check whether an invalid uart number has been specified */
.line = 0, if (co->index < 0 || co->index >= BFIN_SPORT_UART_MAX_PORTS)
}, return -ENODEV;
}, { /* SPORT 1 */
.name = "SPORT1", up = bfin_sport_uart_ports[co->index];
.tx_irq = IRQ_SPORT1_TX, if (!up)
.rx_irq = IRQ_SPORT1_RX, return -ENODEV;
.err_irq= IRQ_SPORT1_ERROR,
.port = { if (options)
.type = PORT_BFIN_SPORT, uart_parse_options(options, &baud, &parity, &bits, &flow);
.iotype = UPIO_MEM,
.membase = (void __iomem *)SPORT1_TCR1, return uart_set_options(&up->port, co, baud, parity, bits, flow);
.mapbase = SPORT1_TCR1, }
.irq = IRQ_SPORT1_RX,
.uartclk = CONFIG_SPORT_BAUD_RATE, static void sport_uart_console_putchar(struct uart_port *port, int ch)
.fifosize = 8, {
.ops = &sport_uart_ops, struct sport_uart_port *up = (struct sport_uart_port *)port;
.line = 1,
}, while (SPORT_GET_STAT(up) & TXF)
barrier();
tx_one_byte(up, ch);
}
/*
* Interrupts are disabled on entering
*/
static void
sport_uart_console_write(struct console *co, const char *s, unsigned int count)
{
struct sport_uart_port *up = bfin_sport_uart_ports[co->index];
unsigned long flags;
spin_lock_irqsave(&up->port.lock, flags);
if (SPORT_GET_TCR1(up) & TSPEN)
uart_console_write(&up->port, s, count, sport_uart_console_putchar);
else {
/* dummy data to start sport */
while (SPORT_GET_STAT(up) & TXF)
barrier();
SPORT_PUT_TX(up, 0xffff);
/* Enable transmit, then an interrupt will generated */
SPORT_PUT_TCR1(up, (SPORT_GET_TCR1(up) | TSPEN));
SSYNC();
uart_console_write(&up->port, s, count, sport_uart_console_putchar);
/* Although the hold register is empty, last byte is still in shift
* register and not sent out yet. So, put a dummy data into TX FIFO.
* Then, sport tx stops when last byte is shift out and the dummy
* data is moved into the shift register.
*/
while (SPORT_GET_STAT(up) & TXF)
barrier();
SPORT_PUT_TX(up, 0xffff);
while (!(SPORT_GET_STAT(up) & TXHRE))
barrier();
/* Stop sport tx transfer */
SPORT_PUT_TCR1(up, (SPORT_GET_TCR1(up) & ~TSPEN));
SSYNC();
} }
spin_unlock_irqrestore(&up->port.lock, flags);
}
static struct uart_driver sport_uart_reg;
static struct console sport_uart_console = {
.name = DEVICE_NAME,
.write = sport_uart_console_write,
.device = uart_console_device,
.setup = sport_uart_console_setup,
.flags = CON_PRINTBUFFER,
.index = -1,
.data = &sport_uart_reg,
}; };
#define SPORT_UART_CONSOLE (&sport_uart_console)
#else
#define SPORT_UART_CONSOLE NULL
#endif /* CONFIG_SERIAL_BFIN_SPORT_CONSOLE */
static struct uart_driver sport_uart_reg = { static struct uart_driver sport_uart_reg = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
.driver_name = "SPORT-UART", .driver_name = DRV_NAME,
.dev_name = "ttySS", .dev_name = DEVICE_NAME,
.major = 204, .major = 204,
.minor = 84, .minor = 84,
.nr = ARRAY_SIZE(sport_uart_ports), .nr = BFIN_SPORT_UART_MAX_PORTS,
.cons = NULL, .cons = SPORT_UART_CONSOLE,
}; };
static int sport_uart_suspend(struct platform_device *dev, pm_message_t state) #ifdef CONFIG_PM
static int sport_uart_suspend(struct device *dev)
{ {
struct sport_uart_port *sport = platform_get_drvdata(dev); struct sport_uart_port *sport = dev_get_drvdata(dev);
pr_debug("%s enter\n", __func__); dev_dbg(dev, "%s enter\n", __func__);
if (sport) if (sport)
uart_suspend_port(&sport_uart_reg, &sport->port); uart_suspend_port(&sport_uart_reg, &sport->port);
return 0; return 0;
} }
static int sport_uart_resume(struct platform_device *dev) static int sport_uart_resume(struct device *dev)
{ {
struct sport_uart_port *sport = platform_get_drvdata(dev); struct sport_uart_port *sport = dev_get_drvdata(dev);
pr_debug("%s enter\n", __func__); dev_dbg(dev, "%s enter\n", __func__);
if (sport) if (sport)
uart_resume_port(&sport_uart_reg, &sport->port); uart_resume_port(&sport_uart_reg, &sport->port);
return 0; return 0;
} }
static int sport_uart_probe(struct platform_device *dev) static struct dev_pm_ops bfin_sport_uart_dev_pm_ops = {
{ .suspend = sport_uart_suspend,
pr_debug("%s enter\n", __func__); .resume = sport_uart_resume,
sport_uart_ports[dev->id].port.dev = &dev->dev; };
uart_add_one_port(&sport_uart_reg, &sport_uart_ports[dev->id].port); #endif
platform_set_drvdata(dev, &sport_uart_ports[dev->id]);
return 0; static int __devinit sport_uart_probe(struct platform_device *pdev)
{
struct resource *res;
struct sport_uart_port *sport;
int ret = 0;
dev_dbg(&pdev->dev, "%s enter\n", __func__);
if (pdev->id < 0 || pdev->id >= BFIN_SPORT_UART_MAX_PORTS) {
dev_err(&pdev->dev, "Wrong sport uart platform device id.\n");
return -ENOENT;
}
if (bfin_sport_uart_ports[pdev->id] == NULL) {
bfin_sport_uart_ports[pdev->id] =
kmalloc(sizeof(struct sport_uart_port), GFP_KERNEL);
sport = bfin_sport_uart_ports[pdev->id];
if (!sport) {
dev_err(&pdev->dev,
"Fail to kmalloc sport_uart_port\n");
return -ENOMEM;
}
ret = peripheral_request_list(
(unsigned short *)pdev->dev.platform_data, DRV_NAME);
if (ret) {
dev_err(&pdev->dev,
"Fail to request SPORT peripherals\n");
goto out_error_free_mem;
}
spin_lock_init(&sport->port.lock);
sport->port.fifosize = SPORT_TX_FIFO_SIZE,
sport->port.ops = &sport_uart_ops;
sport->port.line = pdev->id;
sport->port.iotype = UPIO_MEM;
sport->port.flags = UPF_BOOT_AUTOCONF;
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (res == NULL) {
dev_err(&pdev->dev, "Cannot get IORESOURCE_MEM\n");
ret = -ENOENT;
goto out_error_free_peripherals;
}
sport->port.membase = ioremap(res->start,
res->end - res->start);
if (!sport->port.membase) {
dev_err(&pdev->dev, "Cannot map sport IO\n");
ret = -ENXIO;
goto out_error_free_peripherals;
}
sport->port.irq = platform_get_irq(pdev, 0);
if (sport->port.irq < 0) {
dev_err(&pdev->dev, "No sport RX/TX IRQ specified\n");
ret = -ENOENT;
goto out_error_unmap;
}
sport->err_irq = platform_get_irq(pdev, 1);
if (sport->err_irq < 0) {
dev_err(&pdev->dev, "No sport status IRQ specified\n");
ret = -ENOENT;
goto out_error_unmap;
}
}
#ifdef CONFIG_SERIAL_BFIN_SPORT_CONSOLE
if (!is_early_platform_device(pdev)) {
#endif
sport = bfin_sport_uart_ports[pdev->id];
sport->port.dev = &pdev->dev;
dev_set_drvdata(&pdev->dev, sport);
ret = uart_add_one_port(&sport_uart_reg, &sport->port);
#ifdef CONFIG_SERIAL_BFIN_SPORT_CONSOLE
}
#endif
if (!ret)
return 0;
if (sport) {
out_error_unmap:
iounmap(sport->port.membase);
out_error_free_peripherals:
peripheral_free_list(
(unsigned short *)pdev->dev.platform_data);
out_error_free_mem:
kfree(sport);
bfin_sport_uart_ports[pdev->id] = NULL;
}
return ret;
} }
static int sport_uart_remove(struct platform_device *dev) static int __devexit sport_uart_remove(struct platform_device *pdev)
{ {
struct sport_uart_port *sport = platform_get_drvdata(dev); struct sport_uart_port *sport = platform_get_drvdata(pdev);
pr_debug("%s enter\n", __func__); dev_dbg(&pdev->dev, "%s enter\n", __func__);
platform_set_drvdata(dev, NULL); dev_set_drvdata(&pdev->dev, NULL);
if (sport) if (sport) {
uart_remove_one_port(&sport_uart_reg, &sport->port); uart_remove_one_port(&sport_uart_reg, &sport->port);
iounmap(sport->port.membase);
peripheral_free_list(
(unsigned short *)pdev->dev.platform_data);
kfree(sport);
bfin_sport_uart_ports[pdev->id] = NULL;
}
return 0; return 0;
} }
static struct platform_driver sport_uart_driver = { static struct platform_driver sport_uart_driver = {
.probe = sport_uart_probe, .probe = sport_uart_probe,
.remove = sport_uart_remove, .remove = __devexit_p(sport_uart_remove),
.suspend = sport_uart_suspend,
.resume = sport_uart_resume,
.driver = { .driver = {
.name = DRV_NAME, .name = DRV_NAME,
#ifdef CONFIG_PM
.pm = &bfin_sport_uart_dev_pm_ops,
#endif
}, },
}; };
#ifdef CONFIG_SERIAL_BFIN_SPORT_CONSOLE
static __initdata struct early_platform_driver early_sport_uart_driver = {
.class_str = DRV_NAME,
.pdrv = &sport_uart_driver,
.requested_id = EARLY_PLATFORM_ID_UNSET,
};
static int __init sport_uart_rs_console_init(void)
{
early_platform_driver_register(&early_sport_uart_driver, DRV_NAME);
early_platform_driver_probe(DRV_NAME, BFIN_SPORT_UART_MAX_PORTS, 0);
register_console(&sport_uart_console);
return 0;
}
console_initcall(sport_uart_rs_console_init);
#endif
static int __init sport_uart_init(void) static int __init sport_uart_init(void)
{ {
int ret; int ret;
pr_debug("%s enter\n", __func__); pr_info("Serial: Blackfin uart over sport driver\n");
ret = uart_register_driver(&sport_uart_reg); ret = uart_register_driver(&sport_uart_reg);
if (ret != 0) { if (ret) {
printk(KERN_ERR "Failed to register %s:%d\n", pr_err("failed to register %s:%d\n",
sport_uart_reg.driver_name, ret); sport_uart_reg.driver_name, ret);
return ret; return ret;
} }
ret = platform_driver_register(&sport_uart_driver); ret = platform_driver_register(&sport_uart_driver);
if (ret != 0) { if (ret) {
printk(KERN_ERR "Failed to register sport uart driver:%d\n", ret); pr_err("failed to register sport uart driver:%d\n", ret);
uart_unregister_driver(&sport_uart_reg); uart_unregister_driver(&sport_uart_reg);
} }
pr_debug("%s exit\n", __func__);
return ret; return ret;
} }
module_init(sport_uart_init);
static void __exit sport_uart_exit(void) static void __exit sport_uart_exit(void)
{ {
pr_debug("%s enter\n", __func__);
platform_driver_unregister(&sport_uart_driver); platform_driver_unregister(&sport_uart_driver);
uart_unregister_driver(&sport_uart_reg); uart_unregister_driver(&sport_uart_reg);
} }
module_init(sport_uart_init);
module_exit(sport_uart_exit); module_exit(sport_uart_exit);
MODULE_AUTHOR("Sonic Zhang, Roy Huang");
MODULE_DESCRIPTION("Blackfin serial over SPORT driver");
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

38
drivers/serial/bfin_sport_uart.h
View File

@ -1,29 +1,23 @@
/* /*
* File: linux/drivers/serial/bfin_sport_uart.h * Blackfin On-Chip Sport Emulated UART Driver
* *
* Based on: include/asm-blackfin/mach-533/bfin_serial_5xx.h * Copyright 2006-2008 Analog Devices Inc.
* Author: Roy Huang <roy.huang>analog.com>
* *
* Created: Nov 22, 2006 * Enter bugs at http://blackfin.uclinux.org/
* Copyright: (C) Analog Device Inc.
* Description: this driver enable SPORTs on Blackfin emulate UART.
* *
* This program is free software; you can redistribute it and/or modify * Licensed under the GPL-2 or later.
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see the file COPYING, or write
* to the Free Software Foundation, Inc.,
* 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
/*
* This driver and the hardware supported are in term of EE-191 of ADI.
* http://www.analog.com/UploadedFiles/Application_Notes/399447663EE191.pdf
* This application note describe how to implement a UART on a Sharc DSP,
* but this driver is implemented on Blackfin Processor.
* Transmit Frame Sync is not used by this driver to transfer data out.
*/
#ifndef _BFIN_SPORT_UART_H
#define _BFIN_SPORT_UART_H
#define OFFSET_TCR1 0x00 /* Transmit Configuration 1 Register */ #define OFFSET_TCR1 0x00 /* Transmit Configuration 1 Register */
#define OFFSET_TCR2 0x04 /* Transmit Configuration 2 Register */ #define OFFSET_TCR2 0x04 /* Transmit Configuration 2 Register */
@ -61,3 +55,7 @@
#define SPORT_PUT_RCLKDIV(sport, v) bfin_write16(((sport)->port.membase + OFFSET_RCLKDIV), v) #define SPORT_PUT_RCLKDIV(sport, v) bfin_write16(((sport)->port.membase + OFFSET_RCLKDIV), v)
#define SPORT_PUT_RFSDIV(sport, v) bfin_write16(((sport)->port.membase + OFFSET_RFSDIV), v) #define SPORT_PUT_RFSDIV(sport, v) bfin_write16(((sport)->port.membase + OFFSET_RFSDIV), v)
#define SPORT_PUT_STAT(sport, v) bfin_write16(((sport)->port.membase + OFFSET_STAT), v) #define SPORT_PUT_STAT(sport, v) bfin_write16(((sport)->port.membase + OFFSET_STAT), v)
#define SPORT_TX_FIFO_SIZE 8
#endif /* _BFIN_SPORT_UART_H */

5
drivers/serial/icom.c
View File

@ -751,7 +751,6 @@ static void recv_interrupt(u16 port_int_reg, struct icom_port *icom_port)
trace(icom_port, "FID_STATUS", status); trace(icom_port, "FID_STATUS", status);
count = cpu_to_le16(icom_port->statStg->rcv[rcv_buff].leLength); count = cpu_to_le16(icom_port->statStg->rcv[rcv_buff].leLength);
count = tty_buffer_request_room(tty, count);
trace(icom_port, "RCV_COUNT", count); trace(icom_port, "RCV_COUNT", count);
trace(icom_port, "REAL_COUNT", count); trace(icom_port, "REAL_COUNT", count);
@ -1654,4 +1653,6 @@ MODULE_DESCRIPTION("IBM iSeries Serial IOA driver");
MODULE_SUPPORTED_DEVICE MODULE_SUPPORTED_DEVICE
("IBM iSeries 2745, 2771, 2772, 2742, 2793 and 2805 Communications adapters"); ("IBM iSeries 2745, 2771, 2772, 2742, 2793 and 2805 Communications adapters");
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
MODULE_FIRMWARE("icom_call_setup.bin");
MODULE_FIRMWARE("icom_res_dce.bin");
MODULE_FIRMWARE("icom_asc.bin");

6
drivers/serial/imx.c
View File

@ -1279,7 +1279,7 @@ static int serial_imx_probe(struct platform_device *pdev)
sport->use_irda = 1; sport->use_irda = 1;
#endif #endif
if (pdata->init) { if (pdata && pdata->init) {
ret = pdata->init(pdev); ret = pdata->init(pdev);
if (ret) if (ret)
goto clkput; goto clkput;
@ -1292,7 +1292,7 @@ static int serial_imx_probe(struct platform_device *pdev)
return 0; return 0;
deinit: deinit:
if (pdata->exit) if (pdata && pdata->exit)
pdata->exit(pdev); pdata->exit(pdev);
clkput: clkput:
clk_put(sport->clk); clk_put(sport->clk);
@ -1321,7 +1321,7 @@ static int serial_imx_remove(struct platform_device *pdev)
clk_disable(sport->clk); clk_disable(sport->clk);
if (pdata->exit) if (pdata && pdata->exit)
pdata->exit(pdev); pdata->exit(pdev);
iounmap(sport->port.membase); iounmap(sport->port.membase);

3
drivers/serial/ioc3_serial.c
View File

@ -1411,8 +1411,7 @@ static int receive_chars(struct uart_port *the_port)
read_count = do_read(the_port, ch, MAX_CHARS); read_count = do_read(the_port, ch, MAX_CHARS);
if (read_count > 0) { if (read_count > 0) {
flip = 1; flip = 1;
read_room = tty_buffer_request_room(tty, read_count); read_room = tty_insert_flip_string(tty, ch, read_count);
tty_insert_flip_string(tty, ch, read_room);
the_port->icount.rx += read_count; the_port->icount.rx += read_count;
} }
spin_unlock_irqrestore(&the_port->lock, pflags); spin_unlock_irqrestore(&the_port->lock, pflags);

1
drivers/serial/jsm/jsm_driver.c
View File

@ -179,6 +179,7 @@ static int __devinit jsm_probe_one(struct pci_dev *pdev, const struct pci_device
return 0; return 0;
out_free_irq: out_free_irq:
jsm_remove_uart_port(brd);
free_irq(brd->irq, brd); free_irq(brd->irq, brd);
out_iounmap: out_iounmap:
iounmap(brd->re_map_membase); iounmap(brd->re_map_membase);

9
drivers/serial/jsm/jsm_tty.c
View File

@ -432,7 +432,7 @@ int __devinit jsm_tty_init(struct jsm_board *brd)
int jsm_uart_port_init(struct jsm_board *brd) int jsm_uart_port_init(struct jsm_board *brd)
{ {
int i; int i, rc;
unsigned int line; unsigned int line;
struct jsm_channel *ch; struct jsm_channel *ch;
@ -467,8 +467,11 @@ int jsm_uart_port_init(struct jsm_board *brd)
} else } else
set_bit(line, linemap); set_bit(line, linemap);
brd->channels[i]->uart_port.line = line; brd->channels[i]->uart_port.line = line;
if (uart_add_one_port (&jsm_uart_driver, &brd->channels[i]->uart_port)) rc = uart_add_one_port (&jsm_uart_driver, &brd->channels[i]->uart_port);
printk(KERN_INFO "jsm: add device failed\n"); if (rc){
printk(KERN_INFO "jsm: Port %d failed. Aborting...\n", i);
return rc;
}
else else
printk(KERN_INFO "jsm: Port %d added\n", i); printk(KERN_INFO "jsm: Port %d added\n", i);
} }

6
drivers/serial/msm_serial.c
View File

@ -691,6 +691,7 @@ static int __init msm_serial_probe(struct platform_device *pdev)
struct msm_port *msm_port; struct msm_port *msm_port;
struct resource *resource; struct resource *resource;
struct uart_port *port; struct uart_port *port;
int irq;
if (unlikely(pdev->id < 0 || pdev->id >= UART_NR)) if (unlikely(pdev->id < 0 || pdev->id >= UART_NR))
return -ENXIO; return -ENXIO;
@ -711,9 +712,10 @@ static int __init msm_serial_probe(struct platform_device *pdev)
return -ENXIO; return -ENXIO;
port->mapbase = resource->start; port->mapbase = resource->start;
port->irq = platform_get_irq(pdev, 0); irq = platform_get_irq(pdev, 0);
if (unlikely(port->irq < 0)) if (unlikely(irq < 0))
return -ENXIO; return -ENXIO;
port->irq = irq;
platform_set_drvdata(pdev, port); platform_set_drvdata(pdev, port);

7
drivers/serial/timbuart.c
View File

@ -421,7 +421,7 @@ static struct uart_driver timbuart_driver = {
static int timbuart_probe(struct platform_device *dev) static int timbuart_probe(struct platform_device *dev)
{ {
int err; int err, irq;
struct timbuart_port *uart; struct timbuart_port *uart;
struct resource *iomem; struct resource *iomem;
@ -453,11 +453,12 @@ static int timbuart_probe(struct platform_device *dev)
uart->port.mapbase = iomem->start; uart->port.mapbase = iomem->start;
uart->port.membase = NULL; uart->port.membase = NULL;
uart->port.irq = platform_get_irq(dev, 0); irq = platform_get_irq(dev, 0);
if (uart->port.irq < 0) { if (irq < 0) {
err = -EINVAL; err = -EINVAL;
goto err_register; goto err_register;
} }
uart->port.irq = irq;
tasklet_init(&uart->tasklet, timbuart_tasklet, (unsigned long)uart); tasklet_init(&uart->tasklet, timbuart_tasklet, (unsigned long)uart);

7
drivers/usb/serial/keyspan_pda.c
View File

@ -789,6 +789,13 @@ static int keyspan_pda_fake_startup(struct usb_serial *serial)
return 1; return 1;
} }
#ifdef KEYSPAN
MODULE_FIRMWARE("keyspan_pda/keyspan_pda.fw");
#endif
#ifdef XIRCOM
MODULE_FIRMWARE("keyspan_pda/xircom_pgs.fw");
#endif
static int keyspan_pda_startup(struct usb_serial *serial) static int keyspan_pda_startup(struct usb_serial *serial)
{ {

3
include/linux/pci_ids.h
View File

@ -2332,6 +2332,8 @@
#define PCI_VENDOR_ID_KORENIX 0x1982 #define PCI_VENDOR_ID_KORENIX 0x1982
#define PCI_DEVICE_ID_KORENIX_JETCARDF0 0x1600 #define PCI_DEVICE_ID_KORENIX_JETCARDF0 0x1600
#define PCI_DEVICE_ID_KORENIX_JETCARDF1 0x16ff #define PCI_DEVICE_ID_KORENIX_JETCARDF1 0x16ff
#define PCI_DEVICE_ID_KORENIX_JETCARDF2 0x1700
#define PCI_DEVICE_ID_KORENIX_JETCARDF3 0x17ff
#define PCI_VENDOR_ID_QMI 0x1a32 #define PCI_VENDOR_ID_QMI 0x1a32
@ -2696,6 +2698,7 @@
#define PCI_DEVICE_ID_NETMOS_9835 0x9835 #define PCI_DEVICE_ID_NETMOS_9835 0x9835
#define PCI_DEVICE_ID_NETMOS_9845 0x9845 #define PCI_DEVICE_ID_NETMOS_9845 0x9845
#define PCI_DEVICE_ID_NETMOS_9855 0x9855 #define PCI_DEVICE_ID_NETMOS_9855 0x9855
#define PCI_DEVICE_ID_NETMOS_9865 0x9865
#define PCI_DEVICE_ID_NETMOS_9901 0x9901 #define PCI_DEVICE_ID_NETMOS_9901 0x9901
#define PCI_VENDOR_ID_3COM_2 0xa727 #define PCI_VENDOR_ID_3COM_2 0xa727

10
include/linux/tty.h
View File

@ -68,6 +68,16 @@ struct tty_buffer {
unsigned long data[0]; unsigned long data[0];
}; };
/*
* We default to dicing tty buffer allocations to this many characters
* in order to avoid multiple page allocations. We assume tty_buffer itself
* is under 256 bytes. See tty_buffer_find for the allocation logic this
* must match
*/
#define TTY_BUFFER_PAGE ((PAGE_SIZE - 256) / 2)
struct tty_bufhead { struct tty_bufhead {
struct delayed_work work; struct delayed_work work;
spinlock_t lock; spinlock_t lock;

3
include/linux/vt.h
View File

@ -27,7 +27,7 @@ struct vt_mode {
#define VT_SETMODE 0x5602 /* set mode of active vt */ #define VT_SETMODE 0x5602 /* set mode of active vt */
#define VT_AUTO 0x00 /* auto vt switching */ #define VT_AUTO 0x00 /* auto vt switching */
#define VT_PROCESS 0x01 /* process controls switching */ #define VT_PROCESS 0x01 /* process controls switching */
#define VT_ACKACQ 0x02 /* acknowledge switch */ #define VT_PROCESS_AUTO 0x02 /* process is notified of switching */
struct vt_stat { struct vt_stat {
unsigned short v_active; /* active vt */ unsigned short v_active; /* active vt */
@ -38,6 +38,7 @@ struct vt_stat {
#define VT_SENDSIG 0x5604 /* signal to send to bitmask of vts */ #define VT_SENDSIG 0x5604 /* signal to send to bitmask of vts */
#define VT_RELDISP 0x5605 /* release display */ #define VT_RELDISP 0x5605 /* release display */
#define VT_ACKACQ 0x02 /* acknowledge switch */
#define VT_ACTIVATE 0x5606 /* make vt active */ #define VT_ACTIVATE 0x5606 /* make vt active */
#define VT_WAITACTIVE 0x5607 /* wait for vt active */ #define VT_WAITACTIVE 0x5607 /* wait for vt active */