1/*****************************************************************************/ 2 3/* 4 * stallion.c -- stallion multiport serial driver. 5 * 6 * Copyright (C) 1996-1999 Stallion Technologies 7 * Copyright (C) 1994-1996 Greg Ungerer. 8 * 9 * This code is loosely based on the Linux serial driver, written by 10 * Linus Torvalds, Theodore T'so and others. 11 * 12 * This program is free software; you can redistribute it and/or modify 13 * it under the terms of the GNU General Public License as published by 14 * the Free Software Foundation; either version 2 of the License, or 15 * (at your option) any later version. 16 * 17 * This program is distributed in the hope that it will be useful, 18 * but WITHOUT ANY WARRANTY; without even the implied warranty of 19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 20 * GNU General Public License for more details. 21 * 22 * You should have received a copy of the GNU General Public License 23 * along with this program; if not, write to the Free Software 24 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 25 */ 26 27/*****************************************************************************/ 28 29#include <linux/module.h> 30#include <linux/sched.h> 31#include <linux/slab.h> 32#include <linux/interrupt.h> 33#include <linux/tty.h> 34#include <linux/tty_flip.h> 35#include <linux/serial.h> 36#include <linux/seq_file.h> 37#include <linux/cd1400.h> 38#include <linux/sc26198.h> 39#include <linux/comstats.h> 40#include <linux/stallion.h> 41#include <linux/ioport.h> 42#include <linux/init.h> 43#include <linux/smp_lock.h> 44#include <linux/device.h> 45#include <linux/delay.h> 46#include <linux/ctype.h> 47 48#include <asm/io.h> 49#include <asm/uaccess.h> 50 51#include <linux/pci.h> 52 53/*****************************************************************************/ 54 55/* 56 * Define different board types. Use the standard Stallion "assigned" 57 * board numbers. Boards supported in this driver are abbreviated as 58 * EIO = EasyIO and ECH = EasyConnection 8/32. 59 */ 60#define BRD_EASYIO 20 61#define BRD_ECH 21 62#define BRD_ECHMC 22 63#define BRD_ECHPCI 26 64#define BRD_ECH64PCI 27 65#define BRD_EASYIOPCI 28 66 67struct stlconf { 68 unsigned int brdtype; 69 int ioaddr1; 70 int ioaddr2; 71 unsigned long memaddr; 72 int irq; 73 int irqtype; 74}; 75 76static unsigned int stl_nrbrds; 77 78/*****************************************************************************/ 79 80/* 81 * Define some important driver characteristics. Device major numbers 82 * allocated as per Linux Device Registry. 83 */ 84#ifndef STL_SIOMEMMAJOR 85#define STL_SIOMEMMAJOR 28 86#endif 87#ifndef STL_SERIALMAJOR 88#define STL_SERIALMAJOR 24 89#endif 90#ifndef STL_CALLOUTMAJOR 91#define STL_CALLOUTMAJOR 25 92#endif 93 94/* 95 * Set the TX buffer size. Bigger is better, but we don't want 96 * to chew too much memory with buffers! 97 */ 98#define STL_TXBUFLOW 512 99#define STL_TXBUFSIZE 4096 100 101/*****************************************************************************/ 102 103/* 104 * Define our local driver identity first. Set up stuff to deal with 105 * all the local structures required by a serial tty driver. 106 */ 107static char *stl_drvtitle = "Stallion Multiport Serial Driver"; 108static char *stl_drvname = "stallion"; 109static char *stl_drvversion = "5.6.0"; 110 111static struct tty_driver *stl_serial; 112 113/* 114 * Define a local default termios struct. All ports will be created 115 * with this termios initially. Basically all it defines is a raw port 116 * at 9600, 8 data bits, 1 stop bit. 117 */ 118static struct ktermios stl_deftermios = { 119 .c_cflag = (B9600 | CS8 | CREAD | HUPCL | CLOCAL), 120 .c_cc = INIT_C_CC, 121 .c_ispeed = 9600, 122 .c_ospeed = 9600, 123}; 124 125/* 126 * Define global place to put buffer overflow characters. 127 */ 128static char stl_unwanted[SC26198_RXFIFOSIZE]; 129 130/*****************************************************************************/ 131 132static DEFINE_MUTEX(stl_brdslock); 133static struct stlbrd *stl_brds[STL_MAXBRDS]; 134 135static const struct tty_port_operations stl_port_ops; 136 137/* 138 * Per board state flags. Used with the state field of the board struct. 139 * Not really much here! 140 */ 141#define BRD_FOUND 0x1 142#define STL_PROBED 0x2 143 144 145/* 146 * Define the port structure istate flags. These set of flags are 147 * modified at interrupt time - so setting and reseting them needs 148 * to be atomic. Use the bit clear/setting routines for this. 149 */ 150#define ASYI_TXBUSY 1 151#define ASYI_TXLOW 2 152#define ASYI_TXFLOWED 3 153 154/* 155 * Define an array of board names as printable strings. Handy for 156 * referencing boards when printing trace and stuff. 157 */ 158static char *stl_brdnames[] = { 159 NULL, 160 NULL, 161 NULL, 162 NULL, 163 NULL, 164 NULL, 165 NULL, 166 NULL, 167 NULL, 168 NULL, 169 NULL, 170 NULL, 171 NULL, 172 NULL, 173 NULL, 174 NULL, 175 NULL, 176 NULL, 177 NULL, 178 NULL, 179 "EasyIO", 180 "EC8/32-AT", 181 "EC8/32-MC", 182 NULL, 183 NULL, 184 NULL, 185 "EC8/32-PCI", 186 "EC8/64-PCI", 187 "EasyIO-PCI", 188}; 189 190/*****************************************************************************/ 191 192/* 193 * Define some string labels for arguments passed from the module 194 * load line. These allow for easy board definitions, and easy 195 * modification of the io, memory and irq resoucres. 196 */ 197static unsigned int stl_nargs; 198static char *board0[4]; 199static char *board1[4]; 200static char *board2[4]; 201static char *board3[4]; 202 203static char **stl_brdsp[] = { 204 (char **) &board0, 205 (char **) &board1, 206 (char **) &board2, 207 (char **) &board3 208}; 209 210/* 211 * Define a set of common board names, and types. This is used to 212 * parse any module arguments. 213 */ 214 215static struct { 216 char *name; 217 int type; 218} stl_brdstr[] = { 219 { "easyio", BRD_EASYIO }, 220 { "eio", BRD_EASYIO }, 221 { "20", BRD_EASYIO }, 222 { "ec8/32", BRD_ECH }, 223 { "ec8/32-at", BRD_ECH }, 224 { "ec8/32-isa", BRD_ECH }, 225 { "ech", BRD_ECH }, 226 { "echat", BRD_ECH }, 227 { "21", BRD_ECH }, 228 { "ec8/32-mc", BRD_ECHMC }, 229 { "ec8/32-mca", BRD_ECHMC }, 230 { "echmc", BRD_ECHMC }, 231 { "echmca", BRD_ECHMC }, 232 { "22", BRD_ECHMC }, 233 { "ec8/32-pc", BRD_ECHPCI }, 234 { "ec8/32-pci", BRD_ECHPCI }, 235 { "26", BRD_ECHPCI }, 236 { "ec8/64-pc", BRD_ECH64PCI }, 237 { "ec8/64-pci", BRD_ECH64PCI }, 238 { "ech-pci", BRD_ECH64PCI }, 239 { "echpci", BRD_ECH64PCI }, 240 { "echpc", BRD_ECH64PCI }, 241 { "27", BRD_ECH64PCI }, 242 { "easyio-pc", BRD_EASYIOPCI }, 243 { "easyio-pci", BRD_EASYIOPCI }, 244 { "eio-pci", BRD_EASYIOPCI }, 245 { "eiopci", BRD_EASYIOPCI }, 246 { "28", BRD_EASYIOPCI }, 247}; 248 249/* 250 * Define the module agruments. 251 */ 252 253module_param_array(board0, charp, &stl_nargs, 0); 254MODULE_PARM_DESC(board0, "Board 0 config -> name[,ioaddr[,ioaddr2][,irq]]"); 255module_param_array(board1, charp, &stl_nargs, 0); 256MODULE_PARM_DESC(board1, "Board 1 config -> name[,ioaddr[,ioaddr2][,irq]]"); 257module_param_array(board2, charp, &stl_nargs, 0); 258MODULE_PARM_DESC(board2, "Board 2 config -> name[,ioaddr[,ioaddr2][,irq]]"); 259module_param_array(board3, charp, &stl_nargs, 0); 260MODULE_PARM_DESC(board3, "Board 3 config -> name[,ioaddr[,ioaddr2][,irq]]"); 261 262/*****************************************************************************/ 263 264/* 265 * Hardware ID bits for the EasyIO and ECH boards. These defines apply 266 * to the directly accessible io ports of these boards (not the uarts - 267 * they are in cd1400.h and sc26198.h). 268 */ 269#define EIO_8PORTRS 0x04 270#define EIO_4PORTRS 0x05 271#define EIO_8PORTDI 0x00 272#define EIO_8PORTM 0x06 273#define EIO_MK3 0x03 274#define EIO_IDBITMASK 0x07 275 276#define EIO_BRDMASK 0xf0 277#define ID_BRD4 0x10 278#define ID_BRD8 0x20 279#define ID_BRD16 0x30 280 281#define EIO_INTRPEND 0x08 282#define EIO_INTEDGE 0x00 283#define EIO_INTLEVEL 0x08 284#define EIO_0WS 0x10 285 286#define ECH_ID 0xa0 287#define ECH_IDBITMASK 0xe0 288#define ECH_BRDENABLE 0x08 289#define ECH_BRDDISABLE 0x00 290#define ECH_INTENABLE 0x01 291#define ECH_INTDISABLE 0x00 292#define ECH_INTLEVEL 0x02 293#define ECH_INTEDGE 0x00 294#define ECH_INTRPEND 0x01 295#define ECH_BRDRESET 0x01 296 297#define ECHMC_INTENABLE 0x01 298#define ECHMC_BRDRESET 0x02 299 300#define ECH_PNLSTATUS 2 301#define ECH_PNL16PORT 0x20 302#define ECH_PNLIDMASK 0x07 303#define ECH_PNLXPID 0x40 304#define ECH_PNLINTRPEND 0x80 305 306#define ECH_ADDR2MASK 0x1e0 307 308/* 309 * Define the vector mapping bits for the programmable interrupt board 310 * hardware. These bits encode the interrupt for the board to use - it 311 * is software selectable (except the EIO-8M). 312 */ 313static unsigned char stl_vecmap[] = { 314 0xff, 0xff, 0xff, 0x04, 0x06, 0x05, 0xff, 0x07, 315 0xff, 0xff, 0x00, 0x02, 0x01, 0xff, 0xff, 0x03 316}; 317 318/* 319 * Lock ordering is that you may not take stallion_lock holding 320 * brd_lock. 321 */ 322 323static spinlock_t brd_lock; /* Guard the board mapping */ 324static spinlock_t stallion_lock; /* Guard the tty driver */ 325 326/* 327 * Set up enable and disable macros for the ECH boards. They require 328 * the secondary io address space to be activated and deactivated. 329 * This way all ECH boards can share their secondary io region. 330 * If this is an ECH-PCI board then also need to set the page pointer 331 * to point to the correct page. 332 */ 333#define BRDENABLE(brdnr,pagenr) \ 334 if (stl_brds[(brdnr)]->brdtype == BRD_ECH) \ 335 outb((stl_brds[(brdnr)]->ioctrlval | ECH_BRDENABLE), \ 336 stl_brds[(brdnr)]->ioctrl); \ 337 else if (stl_brds[(brdnr)]->brdtype == BRD_ECHPCI) \ 338 outb((pagenr), stl_brds[(brdnr)]->ioctrl); 339 340#define BRDDISABLE(brdnr) \ 341 if (stl_brds[(brdnr)]->brdtype == BRD_ECH) \ 342 outb((stl_brds[(brdnr)]->ioctrlval | ECH_BRDDISABLE), \ 343 stl_brds[(brdnr)]->ioctrl); 344 345#define STL_CD1400MAXBAUD 230400 346#define STL_SC26198MAXBAUD 460800 347 348#define STL_BAUDBASE 115200 349#define STL_CLOSEDELAY (5 * HZ / 10) 350 351/*****************************************************************************/ 352 353/* 354 * Define the Stallion PCI vendor and device IDs. 355 */ 356#ifndef PCI_VENDOR_ID_STALLION 357#define PCI_VENDOR_ID_STALLION 0x124d 358#endif 359#ifndef PCI_DEVICE_ID_ECHPCI832 360#define PCI_DEVICE_ID_ECHPCI832 0x0000 361#endif 362#ifndef PCI_DEVICE_ID_ECHPCI864 363#define PCI_DEVICE_ID_ECHPCI864 0x0002 364#endif 365#ifndef PCI_DEVICE_ID_EIOPCI 366#define PCI_DEVICE_ID_EIOPCI 0x0003 367#endif 368 369/* 370 * Define structure to hold all Stallion PCI boards. 371 */ 372 373static struct pci_device_id stl_pcibrds[] = { 374 { PCI_DEVICE(PCI_VENDOR_ID_STALLION, PCI_DEVICE_ID_ECHPCI864), 375 .driver_data = BRD_ECH64PCI }, 376 { PCI_DEVICE(PCI_VENDOR_ID_STALLION, PCI_DEVICE_ID_EIOPCI), 377 .driver_data = BRD_EASYIOPCI }, 378 { PCI_DEVICE(PCI_VENDOR_ID_STALLION, PCI_DEVICE_ID_ECHPCI832), 379 .driver_data = BRD_ECHPCI }, 380 { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_87410), 381 .driver_data = BRD_ECHPCI }, 382 { } 383}; 384MODULE_DEVICE_TABLE(pci, stl_pcibrds); 385 386/*****************************************************************************/ 387 388/* 389 * Define macros to extract a brd/port number from a minor number. 390 */ 391#define MINOR2BRD(min) (((min) & 0xc0) >> 6) 392#define MINOR2PORT(min) ((min) & 0x3f) 393 394/* 395 * Define a baud rate table that converts termios baud rate selector 396 * into the actual baud rate value. All baud rate calculations are 397 * based on the actual baud rate required. 398 */ 399static unsigned int stl_baudrates[] = { 400 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800, 401 9600, 19200, 38400, 57600, 115200, 230400, 460800, 921600 402}; 403 404/*****************************************************************************/ 405 406/* 407 * Declare all those functions in this driver! 408 */ 409 410static long stl_memioctl(struct file *fp, unsigned int cmd, unsigned long arg); 411static int stl_brdinit(struct stlbrd *brdp); 412static int stl_getportstats(struct tty_struct *tty, struct stlport *portp, comstats_t __user *cp); 413static int stl_clrportstats(struct stlport *portp, comstats_t __user *cp); 414 415/* 416 * CD1400 uart specific handling functions. 417 */ 418static void stl_cd1400setreg(struct stlport *portp, int regnr, int value); 419static int stl_cd1400getreg(struct stlport *portp, int regnr); 420static int stl_cd1400updatereg(struct stlport *portp, int regnr, int value); 421static int stl_cd1400panelinit(struct stlbrd *brdp, struct stlpanel *panelp); 422static void stl_cd1400portinit(struct stlbrd *brdp, struct stlpanel *panelp, struct stlport *portp); 423static void stl_cd1400setport(struct stlport *portp, struct ktermios *tiosp); 424static int stl_cd1400getsignals(struct stlport *portp); 425static void stl_cd1400setsignals(struct stlport *portp, int dtr, int rts); 426static void stl_cd1400ccrwait(struct stlport *portp); 427static void stl_cd1400enablerxtx(struct stlport *portp, int rx, int tx); 428static void stl_cd1400startrxtx(struct stlport *portp, int rx, int tx); 429static void stl_cd1400disableintrs(struct stlport *portp); 430static void stl_cd1400sendbreak(struct stlport *portp, int len); 431static void stl_cd1400flowctrl(struct stlport *portp, int state); 432static void stl_cd1400sendflow(struct stlport *portp, int state); 433static void stl_cd1400flush(struct stlport *portp); 434static int stl_cd1400datastate(struct stlport *portp); 435static void stl_cd1400eiointr(struct stlpanel *panelp, unsigned int iobase); 436static void stl_cd1400echintr(struct stlpanel *panelp, unsigned int iobase); 437static void stl_cd1400txisr(struct stlpanel *panelp, int ioaddr); 438static void stl_cd1400rxisr(struct stlpanel *panelp, int ioaddr); 439static void stl_cd1400mdmisr(struct stlpanel *panelp, int ioaddr); 440 441static inline int stl_cd1400breakisr(struct stlport *portp, int ioaddr); 442 443/* 444 * SC26198 uart specific handling functions. 445 */ 446static void stl_sc26198setreg(struct stlport *portp, int regnr, int value); 447static int stl_sc26198getreg(struct stlport *portp, int regnr); 448static int stl_sc26198updatereg(struct stlport *portp, int regnr, int value); 449static int stl_sc26198getglobreg(struct stlport *portp, int regnr); 450static int stl_sc26198panelinit(struct stlbrd *brdp, struct stlpanel *panelp); 451static void stl_sc26198portinit(struct stlbrd *brdp, struct stlpanel *panelp, struct stlport *portp); 452static void stl_sc26198setport(struct stlport *portp, struct ktermios *tiosp); 453static int stl_sc26198getsignals(struct stlport *portp); 454static void stl_sc26198setsignals(struct stlport *portp, int dtr, int rts); 455static void stl_sc26198enablerxtx(struct stlport *portp, int rx, int tx); 456static void stl_sc26198startrxtx(struct stlport *portp, int rx, int tx); 457static void stl_sc26198disableintrs(struct stlport *portp); 458static void stl_sc26198sendbreak(struct stlport *portp, int len); 459static void stl_sc26198flowctrl(struct stlport *portp, int state); 460static void stl_sc26198sendflow(struct stlport *portp, int state); 461static void stl_sc26198flush(struct stlport *portp); 462static int stl_sc26198datastate(struct stlport *portp); 463static void stl_sc26198wait(struct stlport *portp); 464static void stl_sc26198txunflow(struct stlport *portp, struct tty_struct *tty); 465static void stl_sc26198intr(struct stlpanel *panelp, unsigned int iobase); 466static void stl_sc26198txisr(struct stlport *port); 467static void stl_sc26198rxisr(struct stlport *port, unsigned int iack); 468static void stl_sc26198rxbadch(struct stlport *portp, unsigned char status, char ch); 469static void stl_sc26198rxbadchars(struct stlport *portp); 470static void stl_sc26198otherisr(struct stlport *port, unsigned int iack); 471 472/*****************************************************************************/ 473 474/* 475 * Generic UART support structure. 476 */ 477typedef struct uart { 478 int (*panelinit)(struct stlbrd *brdp, struct stlpanel *panelp); 479 void (*portinit)(struct stlbrd *brdp, struct stlpanel *panelp, struct stlport *portp); 480 void (*setport)(struct stlport *portp, struct ktermios *tiosp); 481 int (*getsignals)(struct stlport *portp); 482 void (*setsignals)(struct stlport *portp, int dtr, int rts); 483 void (*enablerxtx)(struct stlport *portp, int rx, int tx); 484 void (*startrxtx)(struct stlport *portp, int rx, int tx); 485 void (*disableintrs)(struct stlport *portp); 486 void (*sendbreak)(struct stlport *portp, int len); 487 void (*flowctrl)(struct stlport *portp, int state); 488 void (*sendflow)(struct stlport *portp, int state); 489 void (*flush)(struct stlport *portp); 490 int (*datastate)(struct stlport *portp); 491 void (*intr)(struct stlpanel *panelp, unsigned int iobase); 492} uart_t; 493 494/* 495 * Define some macros to make calling these functions nice and clean. 496 */ 497#define stl_panelinit (* ((uart_t *) panelp->uartp)->panelinit) 498#define stl_portinit (* ((uart_t *) portp->uartp)->portinit) 499#define stl_setport (* ((uart_t *) portp->uartp)->setport) 500#define stl_getsignals (* ((uart_t *) portp->uartp)->getsignals) 501#define stl_setsignals (* ((uart_t *) portp->uartp)->setsignals) 502#define stl_enablerxtx (* ((uart_t *) portp->uartp)->enablerxtx) 503#define stl_startrxtx (* ((uart_t *) portp->uartp)->startrxtx) 504#define stl_disableintrs (* ((uart_t *) portp->uartp)->disableintrs) 505#define stl_sendbreak (* ((uart_t *) portp->uartp)->sendbreak) 506#define stl_flowctrl (* ((uart_t *) portp->uartp)->flowctrl) 507#define stl_sendflow (* ((uart_t *) portp->uartp)->sendflow) 508#define stl_flush (* ((uart_t *) portp->uartp)->flush) 509#define stl_datastate (* ((uart_t *) portp->uartp)->datastate) 510 511/*****************************************************************************/ 512 513/* 514 * CD1400 UART specific data initialization. 515 */ 516static uart_t stl_cd1400uart = { 517 stl_cd1400panelinit, 518 stl_cd1400portinit, 519 stl_cd1400setport, 520 stl_cd1400getsignals, 521 stl_cd1400setsignals, 522 stl_cd1400enablerxtx, 523 stl_cd1400startrxtx, 524 stl_cd1400disableintrs, 525 stl_cd1400sendbreak, 526 stl_cd1400flowctrl, 527 stl_cd1400sendflow, 528 stl_cd1400flush, 529 stl_cd1400datastate, 530 stl_cd1400eiointr 531}; 532 533/* 534 * Define the offsets within the register bank of a cd1400 based panel. 535 * These io address offsets are common to the EasyIO board as well. 536 */ 537#define EREG_ADDR 0 538#define EREG_DATA 4 539#define EREG_RXACK 5 540#define EREG_TXACK 6 541#define EREG_MDACK 7 542 543#define EREG_BANKSIZE 8 544 545#define CD1400_CLK 25000000 546#define CD1400_CLK8M 20000000 547 548/* 549 * Define the cd1400 baud rate clocks. These are used when calculating 550 * what clock and divisor to use for the required baud rate. Also 551 * define the maximum baud rate allowed, and the default base baud. 552 */ 553static int stl_cd1400clkdivs[] = { 554 CD1400_CLK0, CD1400_CLK1, CD1400_CLK2, CD1400_CLK3, CD1400_CLK4 555}; 556 557/*****************************************************************************/ 558 559/* 560 * SC26198 UART specific data initization. 561 */ 562static uart_t stl_sc26198uart = { 563 stl_sc26198panelinit, 564 stl_sc26198portinit, 565 stl_sc26198setport, 566 stl_sc26198getsignals, 567 stl_sc26198setsignals, 568 stl_sc26198enablerxtx, 569 stl_sc26198startrxtx, 570 stl_sc26198disableintrs, 571 stl_sc26198sendbreak, 572 stl_sc26198flowctrl, 573 stl_sc26198sendflow, 574 stl_sc26198flush, 575 stl_sc26198datastate, 576 stl_sc26198intr 577}; 578 579/* 580 * Define the offsets within the register bank of a sc26198 based panel. 581 */ 582#define XP_DATA 0 583#define XP_ADDR 1 584#define XP_MODID 2 585#define XP_STATUS 2 586#define XP_IACK 3 587 588#define XP_BANKSIZE 4 589 590/* 591 * Define the sc26198 baud rate table. Offsets within the table 592 * represent the actual baud rate selector of sc26198 registers. 593 */ 594static unsigned int sc26198_baudtable[] = { 595 50, 75, 150, 200, 300, 450, 600, 900, 1200, 1800, 2400, 3600, 596 4800, 7200, 9600, 14400, 19200, 28800, 38400, 57600, 115200, 597 230400, 460800, 921600 598}; 599 600#define SC26198_NRBAUDS ARRAY_SIZE(sc26198_baudtable) 601 602/*****************************************************************************/ 603 604/* 605 * Define the driver info for a user level control device. Used mainly 606 * to get at port stats - only not using the port device itself. 607 */ 608static const struct file_operations stl_fsiomem = { 609 .owner = THIS_MODULE, 610 .unlocked_ioctl = stl_memioctl, 611}; 612 613static struct class *stallion_class; 614 615static void stl_cd_change(struct stlport *portp) 616{ 617 unsigned int oldsigs = portp->sigs; 618 struct tty_struct *tty = tty_port_tty_get(&portp->port); 619 620 if (!tty) 621 return; 622 623 portp->sigs = stl_getsignals(portp); 624 625 if ((portp->sigs & TIOCM_CD) && ((oldsigs & TIOCM_CD) == 0)) 626 wake_up_interruptible(&portp->port.open_wait); 627 628 if ((oldsigs & TIOCM_CD) && ((portp->sigs & TIOCM_CD) == 0)) 629 if (portp->port.flags & ASYNC_CHECK_CD) 630 tty_hangup(tty); 631 tty_kref_put(tty); 632} 633 634/* 635 * Check for any arguments passed in on the module load command line. 636 */ 637 638/*****************************************************************************/ 639 640/* 641 * Parse the supplied argument string, into the board conf struct. 642 */ 643 644static int __init stl_parsebrd(struct stlconf *confp, char **argp) 645{ 646 char *sp; 647 unsigned int i; 648 649 pr_debug("stl_parsebrd(confp=%p,argp=%p)\n", confp, argp); 650 651 if ((argp[0] == NULL) || (*argp[0] == 0)) 652 return 0; 653 654 for (sp = argp[0], i = 0; (*sp != 0) && (i < 25); sp++, i++) 655 *sp = tolower(*sp); 656 657 for (i = 0; i < ARRAY_SIZE(stl_brdstr); i++) 658 if (strcmp(stl_brdstr[i].name, argp[0]) == 0) 659 break; 660 661 if (i == ARRAY_SIZE(stl_brdstr)) { 662 printk("STALLION: unknown board name, %s?\n", argp[0]); 663 return 0; 664 } 665 666 confp->brdtype = stl_brdstr[i].type; 667 668 i = 1; 669 if ((argp[i] != NULL) && (*argp[i] != 0)) 670 confp->ioaddr1 = simple_strtoul(argp[i], NULL, 0); 671 i++; 672 if (confp->brdtype == BRD_ECH) { 673 if ((argp[i] != NULL) && (*argp[i] != 0)) 674 confp->ioaddr2 = simple_strtoul(argp[i], NULL, 0); 675 i++; 676 } 677 if ((argp[i] != NULL) && (*argp[i] != 0)) 678 confp->irq = simple_strtoul(argp[i], NULL, 0); 679 return 1; 680} 681 682/*****************************************************************************/ 683 684/* 685 * Allocate a new board structure. Fill out the basic info in it. 686 */ 687 688static struct stlbrd *stl_allocbrd(void) 689{ 690 struct stlbrd *brdp; 691 692 brdp = kzalloc(sizeof(struct stlbrd), GFP_KERNEL); 693 if (!brdp) { 694 printk("STALLION: failed to allocate memory (size=%Zd)\n", 695 sizeof(struct stlbrd)); 696 return NULL; 697 } 698 699 brdp->magic = STL_BOARDMAGIC; 700 return brdp; 701} 702 703/*****************************************************************************/ 704 705static int stl_activate(struct tty_port *port, struct tty_struct *tty) 706{ 707 struct stlport *portp = container_of(port, struct stlport, port); 708 if (!portp->tx.buf) { 709 portp->tx.buf = kmalloc(STL_TXBUFSIZE, GFP_KERNEL); 710 if (!portp->tx.buf) 711 return -ENOMEM; 712 portp->tx.head = portp->tx.buf; 713 portp->tx.tail = portp->tx.buf; 714 } 715 stl_setport(portp, tty->termios); 716 portp->sigs = stl_getsignals(portp); 717 stl_setsignals(portp, 1, 1); 718 stl_enablerxtx(portp, 1, 1); 719 stl_startrxtx(portp, 1, 0); 720 return 0; 721} 722 723static int stl_open(struct tty_struct *tty, struct file *filp) 724{ 725 struct stlport *portp; 726 struct stlbrd *brdp; 727 unsigned int minordev, brdnr, panelnr; 728 int portnr; 729 730 pr_debug("stl_open(tty=%p,filp=%p): device=%s\n", tty, filp, tty->name); 731 732 minordev = tty->index; 733 brdnr = MINOR2BRD(minordev); 734 if (brdnr >= stl_nrbrds) 735 return -ENODEV; 736 brdp = stl_brds[brdnr]; 737 if (brdp == NULL) 738 return -ENODEV; 739 740 minordev = MINOR2PORT(minordev); 741 for (portnr = -1, panelnr = 0; panelnr < STL_MAXPANELS; panelnr++) { 742 if (brdp->panels[panelnr] == NULL) 743 break; 744 if (minordev < brdp->panels[panelnr]->nrports) { 745 portnr = minordev; 746 break; 747 } 748 minordev -= brdp->panels[panelnr]->nrports; 749 } 750 if (portnr < 0) 751 return -ENODEV; 752 753 portp = brdp->panels[panelnr]->ports[portnr]; 754 if (portp == NULL) 755 return -ENODEV; 756 757 tty->driver_data = portp; 758 return tty_port_open(&portp->port, tty, filp); 759 760} 761 762/*****************************************************************************/ 763 764static int stl_carrier_raised(struct tty_port *port) 765{ 766 struct stlport *portp = container_of(port, struct stlport, port); 767 return (portp->sigs & TIOCM_CD) ? 1 : 0; 768} 769 770static void stl_dtr_rts(struct tty_port *port, int on) 771{ 772 struct stlport *portp = container_of(port, struct stlport, port); 773 /* Takes brd_lock internally */ 774 stl_setsignals(portp, on, on); 775} 776 777/*****************************************************************************/ 778 779static void stl_flushbuffer(struct tty_struct *tty) 780{ 781 struct stlport *portp; 782 783 pr_debug("stl_flushbuffer(tty=%p)\n", tty); 784 785 portp = tty->driver_data; 786 if (portp == NULL) 787 return; 788 789 stl_flush(portp); 790 tty_wakeup(tty); 791} 792 793/*****************************************************************************/ 794 795static void stl_waituntilsent(struct tty_struct *tty, int timeout) 796{ 797 struct stlport *portp; 798 unsigned long tend; 799 800 pr_debug("stl_waituntilsent(tty=%p,timeout=%d)\n", tty, timeout); 801 802 portp = tty->driver_data; 803 if (portp == NULL) 804 return; 805 806 if (timeout == 0) 807 timeout = HZ; 808 tend = jiffies + timeout; 809 810 while (stl_datastate(portp)) { 811 if (signal_pending(current)) 812 break; 813 msleep_interruptible(20); 814 if (time_after_eq(jiffies, tend)) 815 break; 816 } 817} 818 819/*****************************************************************************/ 820 821static void stl_shutdown(struct tty_port *port) 822{ 823 struct stlport *portp = container_of(port, struct stlport, port); 824 stl_disableintrs(portp); 825 stl_enablerxtx(portp, 0, 0); 826 stl_flush(portp); 827 portp->istate = 0; 828 if (portp->tx.buf != NULL) { 829 kfree(portp->tx.buf); 830 portp->tx.buf = NULL; 831 portp->tx.head = NULL; 832 portp->tx.tail = NULL; 833 } 834} 835 836static void stl_close(struct tty_struct *tty, struct file *filp) 837{ 838 struct stlport*portp; 839 pr_debug("stl_close(tty=%p,filp=%p)\n", tty, filp); 840 841 portp = tty->driver_data; 842 if(portp == NULL) 843 return; 844 tty_port_close(&portp->port, tty, filp); 845} 846 847/*****************************************************************************/ 848 849/* 850 * Write routine. Take data and stuff it in to the TX ring queue. 851 * If transmit interrupts are not running then start them. 852 */ 853 854static int stl_write(struct tty_struct *tty, const unsigned char *buf, int count) 855{ 856 struct stlport *portp; 857 unsigned int len, stlen; 858 unsigned char *chbuf; 859 char *head, *tail; 860 861 pr_debug("stl_write(tty=%p,buf=%p,count=%d)\n", tty, buf, count); 862 863 portp = tty->driver_data; 864 if (portp == NULL) 865 return 0; 866 if (portp->tx.buf == NULL) 867 return 0; 868 869/* 870 * If copying direct from user space we must cater for page faults, 871 * causing us to "sleep" here for a while. To handle this copy in all 872 * the data we need now, into a local buffer. Then when we got it all 873 * copy it into the TX buffer. 874 */ 875 chbuf = (unsigned char *) buf; 876 877 head = portp->tx.head; 878 tail = portp->tx.tail; 879 if (head >= tail) { 880 len = STL_TXBUFSIZE - (head - tail) - 1; 881 stlen = STL_TXBUFSIZE - (head - portp->tx.buf); 882 } else { 883 len = tail - head - 1; 884 stlen = len; 885 } 886 887 len = min(len, (unsigned int)count); 888 count = 0; 889 while (len > 0) { 890 stlen = min(len, stlen); 891 memcpy(head, chbuf, stlen); 892 len -= stlen; 893 chbuf += stlen; 894 count += stlen; 895 head += stlen; 896 if (head >= (portp->tx.buf + STL_TXBUFSIZE)) { 897 head = portp->tx.buf; 898 stlen = tail - head; 899 } 900 } 901 portp->tx.head = head; 902 903 clear_bit(ASYI_TXLOW, &portp->istate); 904 stl_startrxtx(portp, -1, 1); 905 906 return count; 907} 908 909/*****************************************************************************/ 910 911static int stl_putchar(struct tty_struct *tty, unsigned char ch) 912{ 913 struct stlport *portp; 914 unsigned int len; 915 char *head, *tail; 916 917 pr_debug("stl_putchar(tty=%p,ch=%x)\n", tty, ch); 918 919 portp = tty->driver_data; 920 if (portp == NULL) 921 return -EINVAL; 922 if (portp->tx.buf == NULL) 923 return -EINVAL; 924 925 head = portp->tx.head; 926 tail = portp->tx.tail; 927 928 len = (head >= tail) ? (STL_TXBUFSIZE - (head - tail)) : (tail - head); 929 len--; 930 931 if (len > 0) { 932 *head++ = ch; 933 if (head >= (portp->tx.buf + STL_TXBUFSIZE)) 934 head = portp->tx.buf; 935 } 936 portp->tx.head = head; 937 return 0; 938} 939 940/*****************************************************************************/ 941 942/* 943 * If there are any characters in the buffer then make sure that TX 944 * interrupts are on and get'em out. Normally used after the putchar 945 * routine has been called. 946 */ 947 948static void stl_flushchars(struct tty_struct *tty) 949{ 950 struct stlport *portp; 951 952 pr_debug("stl_flushchars(tty=%p)\n", tty); 953 954 portp = tty->driver_data; 955 if (portp == NULL) 956 return; 957 if (portp->tx.buf == NULL) 958 return; 959 960 stl_startrxtx(portp, -1, 1); 961} 962 963/*****************************************************************************/ 964 965static int stl_writeroom(struct tty_struct *tty) 966{ 967 struct stlport *portp; 968 char *head, *tail; 969 970 pr_debug("stl_writeroom(tty=%p)\n", tty); 971 972 portp = tty->driver_data; 973 if (portp == NULL) 974 return 0; 975 if (portp->tx.buf == NULL) 976 return 0; 977 978 head = portp->tx.head; 979 tail = portp->tx.tail; 980 return (head >= tail) ? (STL_TXBUFSIZE - (head - tail) - 1) : (tail - head - 1); 981} 982 983/*****************************************************************************/ 984 985/* 986 * Return number of chars in the TX buffer. Normally we would just 987 * calculate the number of chars in the buffer and return that, but if 988 * the buffer is empty and TX interrupts are still on then we return 989 * that the buffer still has 1 char in it. This way whoever called us 990 * will not think that ALL chars have drained - since the UART still 991 * must have some chars in it (we are busy after all). 992 */ 993 994static int stl_charsinbuffer(struct tty_struct *tty) 995{ 996 struct stlport *portp; 997 unsigned int size; 998 char *head, *tail; 999 1000 pr_debug("stl_charsinbuffer(tty=%p)\n", tty); 1001 1002 portp = tty->driver_data; 1003 if (portp == NULL) 1004 return 0; 1005 if (portp->tx.buf == NULL) 1006 return 0; 1007 1008 head = portp->tx.head; 1009 tail = portp->tx.tail; 1010 size = (head >= tail) ? (head - tail) : (STL_TXBUFSIZE - (tail - head)); 1011 if ((size == 0) && test_bit(ASYI_TXBUSY, &portp->istate)) 1012 size = 1; 1013 return size; 1014} 1015 1016/*****************************************************************************/ 1017 1018/* 1019 * Generate the serial struct info. 1020 */ 1021 1022static int stl_getserial(struct stlport *portp, struct serial_struct __user *sp) 1023{ 1024 struct serial_struct sio; 1025 struct stlbrd *brdp; 1026 1027 pr_debug("stl_getserial(portp=%p,sp=%p)\n", portp, sp); 1028 1029 memset(&sio, 0, sizeof(struct serial_struct)); 1030 1031 mutex_lock(&portp->port.mutex); 1032 sio.line = portp->portnr; 1033 sio.port = portp->ioaddr; 1034 sio.flags = portp->port.flags; 1035 sio.baud_base = portp->baud_base; 1036 sio.close_delay = portp->close_delay; 1037 sio.closing_wait = portp->closing_wait; 1038 sio.custom_divisor = portp->custom_divisor; 1039 sio.hub6 = 0; 1040 if (portp->uartp == &stl_cd1400uart) { 1041 sio.type = PORT_CIRRUS; 1042 sio.xmit_fifo_size = CD1400_TXFIFOSIZE; 1043 } else { 1044 sio.type = PORT_UNKNOWN; 1045 sio.xmit_fifo_size = SC26198_TXFIFOSIZE; 1046 } 1047 1048 brdp = stl_brds[portp->brdnr]; 1049 if (brdp != NULL) 1050 sio.irq = brdp->irq; 1051 mutex_unlock(&portp->port.mutex); 1052 1053 return copy_to_user(sp, &sio, sizeof(struct serial_struct)) ? -EFAULT : 0; 1054} 1055 1056/*****************************************************************************/ 1057 1058/* 1059 * Set port according to the serial struct info. 1060 * At this point we do not do any auto-configure stuff, so we will 1061 * just quietly ignore any requests to change irq, etc. 1062 */ 1063 1064static int stl_setserial(struct tty_struct *tty, struct serial_struct __user *sp) 1065{ 1066 struct stlport * portp = tty->driver_data; 1067 struct serial_struct sio; 1068 1069 pr_debug("stl_setserial(portp=%p,sp=%p)\n", portp, sp); 1070 1071 if (copy_from_user(&sio, sp, sizeof(struct serial_struct))) 1072 return -EFAULT; 1073 mutex_lock(&portp->port.mutex); 1074 if (!capable(CAP_SYS_ADMIN)) { 1075 if ((sio.baud_base != portp->baud_base) || 1076 (sio.close_delay != portp->close_delay) || 1077 ((sio.flags & ~ASYNC_USR_MASK) != 1078 (portp->port.flags & ~ASYNC_USR_MASK))) { 1079 mutex_unlock(&portp->port.mutex); 1080 return -EPERM; 1081 } 1082 } 1083 1084 portp->port.flags = (portp->port.flags & ~ASYNC_USR_MASK) | 1085 (sio.flags & ASYNC_USR_MASK); 1086 portp->baud_base = sio.baud_base; 1087 portp->close_delay = sio.close_delay; 1088 portp->closing_wait = sio.closing_wait; 1089 portp->custom_divisor = sio.custom_divisor; 1090 mutex_unlock(&portp->port.mutex); 1091 stl_setport(portp, tty->termios); 1092 return 0; 1093} 1094 1095/*****************************************************************************/ 1096 1097static int stl_tiocmget(struct tty_struct *tty, struct file *file) 1098{ 1099 struct stlport *portp; 1100 1101 portp = tty->driver_data; 1102 if (portp == NULL) 1103 return -ENODEV; 1104 if (tty->flags & (1 << TTY_IO_ERROR)) 1105 return -EIO; 1106 1107 return stl_getsignals(portp); 1108} 1109 1110static int stl_tiocmset(struct tty_struct *tty, struct file *file, 1111 unsigned int set, unsigned int clear) 1112{ 1113 struct stlport *portp; 1114 int rts = -1, dtr = -1; 1115 1116 portp = tty->driver_data; 1117 if (portp == NULL) 1118 return -ENODEV; 1119 if (tty->flags & (1 << TTY_IO_ERROR)) 1120 return -EIO; 1121 1122 if (set & TIOCM_RTS) 1123 rts = 1; 1124 if (set & TIOCM_DTR) 1125 dtr = 1; 1126 if (clear & TIOCM_RTS) 1127 rts = 0; 1128 if (clear & TIOCM_DTR) 1129 dtr = 0; 1130 1131 stl_setsignals(portp, dtr, rts); 1132 return 0; 1133} 1134 1135static int stl_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg) 1136{ 1137 struct stlport *portp; 1138 int rc; 1139 void __user *argp = (void __user *)arg; 1140 1141 pr_debug("stl_ioctl(tty=%p,file=%p,cmd=%x,arg=%lx)\n", tty, file, cmd, 1142 arg); 1143 1144 portp = tty->driver_data; 1145 if (portp == NULL) 1146 return -ENODEV; 1147 1148 if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) && 1149 (cmd != COM_GETPORTSTATS) && (cmd != COM_CLRPORTSTATS)) 1150 if (tty->flags & (1 << TTY_IO_ERROR)) 1151 return -EIO; 1152 1153 rc = 0; 1154 1155 switch (cmd) { 1156 case TIOCGSERIAL: 1157 rc = stl_getserial(portp, argp); 1158 break; 1159 case TIOCSSERIAL: 1160 rc = stl_setserial(tty, argp); 1161 break; 1162 case COM_GETPORTSTATS: 1163 rc = stl_getportstats(tty, portp, argp); 1164 break; 1165 case COM_CLRPORTSTATS: 1166 rc = stl_clrportstats(portp, argp); 1167 break; 1168 case TIOCSERCONFIG: 1169 case TIOCSERGWILD: 1170 case TIOCSERSWILD: 1171 case TIOCSERGETLSR: 1172 case TIOCSERGSTRUCT: 1173 case TIOCSERGETMULTI: 1174 case TIOCSERSETMULTI: 1175 default: 1176 rc = -ENOIOCTLCMD; 1177 break; 1178 } 1179 return rc; 1180} 1181 1182/*****************************************************************************/ 1183 1184/* 1185 * Start the transmitter again. Just turn TX interrupts back on. 1186 */ 1187 1188static void stl_start(struct tty_struct *tty) 1189{ 1190 struct stlport *portp; 1191 1192 pr_debug("stl_start(tty=%p)\n", tty); 1193 1194 portp = tty->driver_data; 1195 if (portp == NULL) 1196 return; 1197 stl_startrxtx(portp, -1, 1); 1198} 1199 1200/*****************************************************************************/ 1201 1202static void stl_settermios(struct tty_struct *tty, struct ktermios *old) 1203{ 1204 struct stlport *portp; 1205 struct ktermios *tiosp; 1206 1207 pr_debug("stl_settermios(tty=%p,old=%p)\n", tty, old); 1208 1209 portp = tty->driver_data; 1210 if (portp == NULL) 1211 return; 1212 1213 tiosp = tty->termios; 1214 if ((tiosp->c_cflag == old->c_cflag) && 1215 (tiosp->c_iflag == old->c_iflag)) 1216 return; 1217 1218 stl_setport(portp, tiosp); 1219 stl_setsignals(portp, ((tiosp->c_cflag & (CBAUD & ~CBAUDEX)) ? 1 : 0), 1220 -1); 1221 if ((old->c_cflag & CRTSCTS) && ((tiosp->c_cflag & CRTSCTS) == 0)) { 1222 tty->hw_stopped = 0; 1223 stl_start(tty); 1224 } 1225 if (((old->c_cflag & CLOCAL) == 0) && (tiosp->c_cflag & CLOCAL)) 1226 wake_up_interruptible(&portp->port.open_wait); 1227} 1228 1229/*****************************************************************************/ 1230 1231/* 1232 * Attempt to flow control who ever is sending us data. Based on termios 1233 * settings use software or/and hardware flow control. 1234 */ 1235 1236static void stl_throttle(struct tty_struct *tty) 1237{ 1238 struct stlport *portp; 1239 1240 pr_debug("stl_throttle(tty=%p)\n", tty); 1241 1242 portp = tty->driver_data; 1243 if (portp == NULL) 1244 return; 1245 stl_flowctrl(portp, 0); 1246} 1247 1248/*****************************************************************************/ 1249 1250/* 1251 * Unflow control the device sending us data... 1252 */ 1253 1254static void stl_unthrottle(struct tty_struct *tty) 1255{ 1256 struct stlport *portp; 1257 1258 pr_debug("stl_unthrottle(tty=%p)\n", tty); 1259 1260 portp = tty->driver_data; 1261 if (portp == NULL) 1262 return; 1263 stl_flowctrl(portp, 1); 1264} 1265 1266/*****************************************************************************/ 1267 1268/* 1269 * Stop the transmitter. Basically to do this we will just turn TX 1270 * interrupts off. 1271 */ 1272 1273static void stl_stop(struct tty_struct *tty) 1274{ 1275 struct stlport *portp; 1276 1277 pr_debug("stl_stop(tty=%p)\n", tty); 1278 1279 portp = tty->driver_data; 1280 if (portp == NULL) 1281 return; 1282 stl_startrxtx(portp, -1, 0); 1283} 1284 1285/*****************************************************************************/ 1286 1287/* 1288 * Hangup this port. This is pretty much like closing the port, only 1289 * a little more brutal. No waiting for data to drain. Shutdown the 1290 * port and maybe drop signals. 1291 */ 1292 1293static void stl_hangup(struct tty_struct *tty) 1294{ 1295 struct stlport *portp = tty->driver_data; 1296 pr_debug("stl_hangup(tty=%p)\n", tty); 1297 1298 if (portp == NULL) 1299 return; 1300 tty_port_hangup(&portp->port); 1301} 1302 1303/*****************************************************************************/ 1304 1305static int stl_breakctl(struct tty_struct *tty, int state) 1306{ 1307 struct stlport *portp; 1308 1309 pr_debug("stl_breakctl(tty=%p,state=%d)\n", tty, state); 1310 1311 portp = tty->driver_data; 1312 if (portp == NULL) 1313 return -EINVAL; 1314 1315 stl_sendbreak(portp, ((state == -1) ? 1 : 2)); 1316 return 0; 1317} 1318 1319/*****************************************************************************/ 1320 1321static void stl_sendxchar(struct tty_struct *tty, char ch) 1322{ 1323 struct stlport *portp; 1324 1325 pr_debug("stl_sendxchar(tty=%p,ch=%x)\n", tty, ch); 1326 1327 portp = tty->driver_data; 1328 if (portp == NULL) 1329 return; 1330 1331 if (ch == STOP_CHAR(tty)) 1332 stl_sendflow(portp, 0); 1333 else if (ch == START_CHAR(tty)) 1334 stl_sendflow(portp, 1); 1335 else 1336 stl_putchar(tty, ch); 1337} 1338 1339static void stl_portinfo(struct seq_file *m, struct stlport *portp, int portnr) 1340{ 1341 int sigs; 1342 char sep; 1343 1344 seq_printf(m, "%d: uart:%s tx:%d rx:%d", 1345 portnr, (portp->hwid == 1) ? "SC26198" : "CD1400", 1346 (int) portp->stats.txtotal, (int) portp->stats.rxtotal); 1347 1348 if (portp->stats.rxframing) 1349 seq_printf(m, " fe:%d", (int) portp->stats.rxframing); 1350 if (portp->stats.rxparity) 1351 seq_printf(m, " pe:%d", (int) portp->stats.rxparity); 1352 if (portp->stats.rxbreaks) 1353 seq_printf(m, " brk:%d", (int) portp->stats.rxbreaks); 1354 if (portp->stats.rxoverrun) 1355 seq_printf(m, " oe:%d", (int) portp->stats.rxoverrun); 1356 1357 sigs = stl_getsignals(portp); 1358 sep = ' '; 1359 if (sigs & TIOCM_RTS) { 1360 seq_printf(m, "%c%s", sep, "RTS"); 1361 sep = '|'; 1362 } 1363 if (sigs & TIOCM_CTS) { 1364 seq_printf(m, "%c%s", sep, "CTS"); 1365 sep = '|'; 1366 } 1367 if (sigs & TIOCM_DTR) { 1368 seq_printf(m, "%c%s", sep, "DTR"); 1369 sep = '|'; 1370 } 1371 if (sigs & TIOCM_CD) { 1372 seq_printf(m, "%c%s", sep, "DCD"); 1373 sep = '|'; 1374 } 1375 if (sigs & TIOCM_DSR) { 1376 seq_printf(m, "%c%s", sep, "DSR"); 1377 sep = '|'; 1378 } 1379 seq_putc(m, '\n'); 1380} 1381 1382/*****************************************************************************/ 1383 1384/* 1385 * Port info, read from the /proc file system. 1386 */ 1387 1388static int stl_proc_show(struct seq_file *m, void *v) 1389{ 1390 struct stlbrd *brdp; 1391 struct stlpanel *panelp; 1392 struct stlport *portp; 1393 unsigned int brdnr, panelnr, portnr; 1394 int totalport; 1395 1396 totalport = 0; 1397 1398 seq_printf(m, "%s: version %s\n", stl_drvtitle, stl_drvversion); 1399 1400/* 1401 * We scan through for each board, panel and port. The offset is 1402 * calculated on the fly, and irrelevant ports are skipped. 1403 */ 1404 for (brdnr = 0; brdnr < stl_nrbrds; brdnr++) { 1405 brdp = stl_brds[brdnr]; 1406 if (brdp == NULL) 1407 continue; 1408 if (brdp->state == 0) 1409 continue; 1410 1411 totalport = brdnr * STL_MAXPORTS; 1412 for (panelnr = 0; panelnr < brdp->nrpanels; panelnr++) { 1413 panelp = brdp->panels[panelnr]; 1414 if (panelp == NULL) 1415 continue; 1416 1417 for (portnr = 0; portnr < panelp->nrports; portnr++, 1418 totalport++) { 1419 portp = panelp->ports[portnr]; 1420 if (portp == NULL) 1421 continue; 1422 stl_portinfo(m, portp, totalport); 1423 } 1424 } 1425 } 1426 return 0; 1427} 1428 1429static int stl_proc_open(struct inode *inode, struct file *file) 1430{ 1431 return single_open(file, stl_proc_show, NULL); 1432} 1433 1434static const struct file_operations stl_proc_fops = { 1435 .owner = THIS_MODULE, 1436 .open = stl_proc_open, 1437 .read = seq_read, 1438 .llseek = seq_lseek, 1439 .release = single_release, 1440}; 1441 1442/*****************************************************************************/ 1443 1444/* 1445 * All board interrupts are vectored through here first. This code then 1446 * calls off to the approrpriate board interrupt handlers. 1447 */ 1448 1449static irqreturn_t stl_intr(int irq, void *dev_id) 1450{ 1451 struct stlbrd *brdp = dev_id; 1452 1453 pr_debug("stl_intr(brdp=%p,irq=%d)\n", brdp, brdp->irq); 1454 1455 return IRQ_RETVAL((* brdp->isr)(brdp)); 1456} 1457 1458/*****************************************************************************/ 1459 1460/* 1461 * Interrupt service routine for EasyIO board types. 1462 */ 1463 1464static int stl_eiointr(struct stlbrd *brdp) 1465{ 1466 struct stlpanel *panelp; 1467 unsigned int iobase; 1468 int handled = 0; 1469 1470 spin_lock(&brd_lock); 1471 panelp = brdp->panels[0]; 1472 iobase = panelp->iobase; 1473 while (inb(brdp->iostatus) & EIO_INTRPEND) { 1474 handled = 1; 1475 (* panelp->isr)(panelp, iobase); 1476 } 1477 spin_unlock(&brd_lock); 1478 return handled; 1479} 1480 1481/*****************************************************************************/ 1482 1483/* 1484 * Interrupt service routine for ECH-AT board types. 1485 */ 1486 1487static int stl_echatintr(struct stlbrd *brdp) 1488{ 1489 struct stlpanel *panelp; 1490 unsigned int ioaddr, bnknr; 1491 int handled = 0; 1492 1493 outb((brdp->ioctrlval | ECH_BRDENABLE), brdp->ioctrl); 1494 1495 while (inb(brdp->iostatus) & ECH_INTRPEND) { 1496 handled = 1; 1497 for (bnknr = 0; bnknr < brdp->nrbnks; bnknr++) { 1498 ioaddr = brdp->bnkstataddr[bnknr]; 1499 if (inb(ioaddr) & ECH_PNLINTRPEND) { 1500 panelp = brdp->bnk2panel[bnknr]; 1501 (* panelp->isr)(panelp, (ioaddr & 0xfffc)); 1502 } 1503 } 1504 } 1505 1506 outb((brdp->ioctrlval | ECH_BRDDISABLE), brdp->ioctrl); 1507 1508 return handled; 1509} 1510 1511/*****************************************************************************/ 1512 1513/* 1514 * Interrupt service routine for ECH-MCA board types. 1515 */ 1516 1517static int stl_echmcaintr(struct stlbrd *brdp) 1518{ 1519 struct stlpanel *panelp; 1520 unsigned int ioaddr, bnknr; 1521 int handled = 0; 1522 1523 while (inb(brdp->iostatus) & ECH_INTRPEND) { 1524 handled = 1; 1525 for (bnknr = 0; bnknr < brdp->nrbnks; bnknr++) { 1526 ioaddr = brdp->bnkstataddr[bnknr]; 1527 if (inb(ioaddr) & ECH_PNLINTRPEND) { 1528 panelp = brdp->bnk2panel[bnknr]; 1529 (* panelp->isr)(panelp, (ioaddr & 0xfffc)); 1530 } 1531 } 1532 } 1533 return handled; 1534} 1535 1536/*****************************************************************************/ 1537 1538/* 1539 * Interrupt service routine for ECH-PCI board types. 1540 */ 1541 1542static int stl_echpciintr(struct stlbrd *brdp) 1543{ 1544 struct stlpanel *panelp; 1545 unsigned int ioaddr, bnknr, recheck; 1546 int handled = 0; 1547 1548 while (1) { 1549 recheck = 0; 1550 for (bnknr = 0; bnknr < brdp->nrbnks; bnknr++) { 1551 outb(brdp->bnkpageaddr[bnknr], brdp->ioctrl); 1552 ioaddr = brdp->bnkstataddr[bnknr]; 1553 if (inb(ioaddr) & ECH_PNLINTRPEND) { 1554 panelp = brdp->bnk2panel[bnknr]; 1555 (* panelp->isr)(panelp, (ioaddr & 0xfffc)); 1556 recheck++; 1557 handled = 1; 1558 } 1559 } 1560 if (! recheck) 1561 break; 1562 } 1563 return handled; 1564} 1565 1566/*****************************************************************************/ 1567 1568/* 1569 * Interrupt service routine for ECH-8/64-PCI board types. 1570 */ 1571 1572static int stl_echpci64intr(struct stlbrd *brdp) 1573{ 1574 struct stlpanel *panelp; 1575 unsigned int ioaddr, bnknr; 1576 int handled = 0; 1577 1578 while (inb(brdp->ioctrl) & 0x1) { 1579 handled = 1; 1580 for (bnknr = 0; bnknr < brdp->nrbnks; bnknr++) { 1581 ioaddr = brdp->bnkstataddr[bnknr]; 1582 if (inb(ioaddr) & ECH_PNLINTRPEND) { 1583 panelp = brdp->bnk2panel[bnknr]; 1584 (* panelp->isr)(panelp, (ioaddr & 0xfffc)); 1585 } 1586 } 1587 } 1588 1589 return handled; 1590} 1591 1592/*****************************************************************************/ 1593 1594/* 1595 * Initialize all the ports on a panel. 1596 */ 1597 1598static int __devinit stl_initports(struct stlbrd *brdp, struct stlpanel *panelp) 1599{ 1600 struct stlport *portp; 1601 unsigned int i; 1602 int chipmask; 1603 1604 pr_debug("stl_initports(brdp=%p,panelp=%p)\n", brdp, panelp); 1605 1606 chipmask = stl_panelinit(brdp, panelp); 1607 1608/* 1609 * All UART's are initialized (if found!). Now go through and setup 1610 * each ports data structures. 1611 */ 1612 for (i = 0; i < panelp->nrports; i++) { 1613 portp = kzalloc(sizeof(struct stlport), GFP_KERNEL); 1614 if (!portp) { 1615 printk("STALLION: failed to allocate memory " 1616 "(size=%Zd)\n", sizeof(struct stlport)); 1617 break; 1618 } 1619 tty_port_init(&portp->port); 1620 portp->port.ops = &stl_port_ops; 1621 portp->magic = STL_PORTMAGIC; 1622 portp->portnr = i; 1623 portp->brdnr = panelp->brdnr; 1624 portp->panelnr = panelp->panelnr; 1625 portp->uartp = panelp->uartp; 1626 portp->clk = brdp->clk; 1627 portp->baud_base = STL_BAUDBASE; 1628 portp->close_delay = STL_CLOSEDELAY; 1629 portp->closing_wait = 30 * HZ; 1630 init_waitqueue_head(&portp->port.open_wait); 1631 init_waitqueue_head(&portp->port.close_wait); 1632 portp->stats.brd = portp->brdnr; 1633 portp->stats.panel = portp->panelnr; 1634 portp->stats.port = portp->portnr; 1635 panelp->ports[i] = portp; 1636 stl_portinit(brdp, panelp, portp); 1637 } 1638 1639 return 0; 1640} 1641 1642static void stl_cleanup_panels(struct stlbrd *brdp) 1643{ 1644 struct stlpanel *panelp; 1645 struct stlport *portp; 1646 unsigned int j, k; 1647 struct tty_struct *tty; 1648 1649 for (j = 0; j < STL_MAXPANELS; j++) { 1650 panelp = brdp->panels[j]; 1651 if (panelp == NULL) 1652 continue; 1653 for (k = 0; k < STL_PORTSPERPANEL; k++) { 1654 portp = panelp->ports[k]; 1655 if (portp == NULL) 1656 continue; 1657 tty = tty_port_tty_get(&portp->port); 1658 if (tty != NULL) { 1659 stl_hangup(tty); 1660 tty_kref_put(tty); 1661 } 1662 kfree(portp->tx.buf); 1663 kfree(portp); 1664 } 1665 kfree(panelp); 1666 } 1667} 1668 1669/*****************************************************************************/ 1670 1671/* 1672 * Try to find and initialize an EasyIO board. 1673 */ 1674 1675static int __devinit stl_initeio(struct stlbrd *brdp) 1676{ 1677 struct stlpanel *panelp; 1678 unsigned int status; 1679 char *name; 1680 int retval; 1681 1682 pr_debug("stl_initeio(brdp=%p)\n", brdp); 1683 1684 brdp->ioctrl = brdp->ioaddr1 + 1; 1685 brdp->iostatus = brdp->ioaddr1 + 2; 1686 1687 status = inb(brdp->iostatus); 1688 if ((status & EIO_IDBITMASK) == EIO_MK3) 1689 brdp->ioctrl++; 1690 1691/* 1692 * Handle board specific stuff now. The real difference is PCI 1693 * or not PCI. 1694 */ 1695 if (brdp->brdtype == BRD_EASYIOPCI) { 1696 brdp->iosize1 = 0x80; 1697 brdp->iosize2 = 0x80; 1698 name = "serial(EIO-PCI)"; 1699 outb(0x41, (brdp->ioaddr2 + 0x4c)); 1700 } else { 1701 brdp->iosize1 = 8; 1702 name = "serial(EIO)"; 1703 if ((brdp->irq < 0) || (brdp->irq > 15) || 1704 (stl_vecmap[brdp->irq] == (unsigned char) 0xff)) { 1705 printk("STALLION: invalid irq=%d for brd=%d\n", 1706 brdp->irq, brdp->brdnr); 1707 retval = -EINVAL; 1708 goto err; 1709 } 1710 outb((stl_vecmap[brdp->irq] | EIO_0WS | 1711 ((brdp->irqtype) ? EIO_INTLEVEL : EIO_INTEDGE)), 1712 brdp->ioctrl); 1713 } 1714 1715 retval = -EBUSY; 1716 if (!request_region(brdp->ioaddr1, brdp->iosize1, name)) { 1717 printk(KERN_WARNING "STALLION: Warning, board %d I/O address " 1718 "%x conflicts with another device\n", brdp->brdnr, 1719 brdp->ioaddr1); 1720 goto err; 1721 } 1722 1723 if (brdp->iosize2 > 0) 1724 if (!request_region(brdp->ioaddr2, brdp->iosize2, name)) { 1725 printk(KERN_WARNING "STALLION: Warning, board %d I/O " 1726 "address %x conflicts with another device\n", 1727 brdp->brdnr, brdp->ioaddr2); 1728 printk(KERN_WARNING "STALLION: Warning, also " 1729 "releasing board %d I/O address %x \n", 1730 brdp->brdnr, brdp->ioaddr1); 1731 goto err_rel1; 1732 } 1733 1734/* 1735 * Everything looks OK, so let's go ahead and probe for the hardware. 1736 */ 1737 brdp->clk = CD1400_CLK; 1738 brdp->isr = stl_eiointr; 1739 1740 retval = -ENODEV; 1741 switch (status & EIO_IDBITMASK) { 1742 case EIO_8PORTM: 1743 brdp->clk = CD1400_CLK8M; 1744 /* fall thru */ 1745 case EIO_8PORTRS: 1746 case EIO_8PORTDI: 1747 brdp->nrports = 8; 1748 break; 1749 case EIO_4PORTRS: 1750 brdp->nrports = 4; 1751 break; 1752 case EIO_MK3: 1753 switch (status & EIO_BRDMASK) { 1754 case ID_BRD4: 1755 brdp->nrports = 4; 1756 break; 1757 case ID_BRD8: 1758 brdp->nrports = 8; 1759 break; 1760 case ID_BRD16: 1761 brdp->nrports = 16; 1762 break; 1763 default: 1764 goto err_rel2; 1765 } 1766 break; 1767 default: 1768 goto err_rel2; 1769 } 1770 1771/* 1772 * We have verified that the board is actually present, so now we 1773 * can complete the setup. 1774 */ 1775 1776 panelp = kzalloc(sizeof(struct stlpanel), GFP_KERNEL); 1777 if (!panelp) { 1778 printk(KERN_WARNING "STALLION: failed to allocate memory " 1779 "(size=%Zd)\n", sizeof(struct stlpanel)); 1780 retval = -ENOMEM; 1781 goto err_rel2; 1782 } 1783 1784 panelp->magic = STL_PANELMAGIC; 1785 panelp->brdnr = brdp->brdnr; 1786 panelp->panelnr = 0; 1787 panelp->nrports = brdp->nrports; 1788 panelp->iobase = brdp->ioaddr1; 1789 panelp->hwid = status; 1790 if ((status & EIO_IDBITMASK) == EIO_MK3) { 1791 panelp->uartp = &stl_sc26198uart; 1792 panelp->isr = stl_sc26198intr; 1793 } else { 1794 panelp->uartp = &stl_cd1400uart; 1795 panelp->isr = stl_cd1400eiointr; 1796 } 1797 1798 brdp->panels[0] = panelp; 1799 brdp->nrpanels = 1; 1800 brdp->state |= BRD_FOUND; 1801 brdp->hwid = status; 1802 if (request_irq(brdp->irq, stl_intr, IRQF_SHARED, name, brdp) != 0) { 1803 printk("STALLION: failed to register interrupt " 1804 "routine for %s irq=%d\n", name, brdp->irq); 1805 retval = -ENODEV; 1806 goto err_fr; 1807 } 1808 1809 return 0; 1810err_fr: 1811 stl_cleanup_panels(brdp); 1812err_rel2: 1813 if (brdp->iosize2 > 0) 1814 release_region(brdp->ioaddr2, brdp->iosize2); 1815err_rel1: 1816 release_region(brdp->ioaddr1, brdp->iosize1); 1817err: 1818 return retval; 1819} 1820 1821/*****************************************************************************/ 1822 1823/* 1824 * Try to find an ECH board and initialize it. This code is capable of 1825 * dealing with all types of ECH board. 1826 */ 1827 1828static int __devinit stl_initech(struct stlbrd *brdp) 1829{ 1830 struct stlpanel *panelp; 1831 unsigned int status, nxtid, ioaddr, conflict, panelnr, banknr, i; 1832 int retval; 1833 char *name; 1834 1835 pr_debug("stl_initech(brdp=%p)\n", brdp); 1836 1837 status = 0; 1838 conflict = 0; 1839 1840/* 1841 * Set up the initial board register contents for boards. This varies a 1842 * bit between the different board types. So we need to handle each 1843 * separately. Also do a check that the supplied IRQ is good. 1844 */ 1845 switch (brdp->brdtype) { 1846 1847 case BRD_ECH: 1848 brdp->isr = stl_echatintr; 1849 brdp->ioctrl = brdp->ioaddr1 + 1; 1850 brdp->iostatus = brdp->ioaddr1 + 1; 1851 status = inb(brdp->iostatus); 1852 if ((status & ECH_IDBITMASK) != ECH_ID) { 1853 retval = -ENODEV; 1854 goto err; 1855 } 1856 if ((brdp->irq < 0) || (brdp->irq > 15) || 1857 (stl_vecmap[brdp->irq] == (unsigned char) 0xff)) { 1858 printk("STALLION: invalid irq=%d for brd=%d\n", 1859 brdp->irq, brdp->brdnr); 1860 retval = -EINVAL; 1861 goto err; 1862 } 1863 status = ((brdp->ioaddr2 & ECH_ADDR2MASK) >> 1); 1864 status |= (stl_vecmap[brdp->irq] << 1); 1865 outb((status | ECH_BRDRESET), brdp->ioaddr1); 1866 brdp->ioctrlval = ECH_INTENABLE | 1867 ((brdp->irqtype) ? ECH_INTLEVEL : ECH_INTEDGE); 1868 for (i = 0; i < 10; i++) 1869 outb((brdp->ioctrlval | ECH_BRDENABLE), brdp->ioctrl); 1870 brdp->iosize1 = 2; 1871 brdp->iosize2 = 32; 1872 name = "serial(EC8/32)"; 1873 outb(status, brdp->ioaddr1); 1874 break; 1875 1876 case BRD_ECHMC: 1877 brdp->isr = stl_echmcaintr; 1878 brdp->ioctrl = brdp->ioaddr1 + 0x20; 1879 brdp->iostatus = brdp->ioctrl; 1880 status = inb(brdp->iostatus); 1881 if ((status & ECH_IDBITMASK) != ECH_ID) { 1882 retval = -ENODEV; 1883 goto err; 1884 } 1885 if ((brdp->irq < 0) || (brdp->irq > 15) || 1886 (stl_vecmap[brdp->irq] == (unsigned char) 0xff)) { 1887 printk("STALLION: invalid irq=%d for brd=%d\n", 1888 brdp->irq, brdp->brdnr); 1889 retval = -EINVAL; 1890 goto err; 1891 } 1892 outb(ECHMC_BRDRESET, brdp->ioctrl); 1893 outb(ECHMC_INTENABLE, brdp->ioctrl); 1894 brdp->iosize1 = 64; 1895 name = "serial(EC8/32-MC)"; 1896 break; 1897 1898 case BRD_ECHPCI: 1899 brdp->isr = stl_echpciintr; 1900 brdp->ioctrl = brdp->ioaddr1 + 2; 1901 brdp->iosize1 = 4; 1902 brdp->iosize2 = 8; 1903 name = "serial(EC8/32-PCI)"; 1904 break; 1905 1906 case BRD_ECH64PCI: 1907 brdp->isr = stl_echpci64intr; 1908 brdp->ioctrl = brdp->ioaddr2 + 0x40; 1909 outb(0x43, (brdp->ioaddr1 + 0x4c)); 1910 brdp->iosize1 = 0x80; 1911 brdp->iosize2 = 0x80; 1912 name = "serial(EC8/64-PCI)"; 1913 break; 1914 1915 default: 1916 printk("STALLION: unknown board type=%d\n", brdp->brdtype); 1917 retval = -EINVAL; 1918 goto err; 1919 } 1920 1921/* 1922 * Check boards for possible IO address conflicts and return fail status 1923 * if an IO conflict found. 1924 */ 1925 retval = -EBUSY; 1926 if (!request_region(brdp->ioaddr1, brdp->iosize1, name)) { 1927 printk(KERN_WARNING "STALLION: Warning, board %d I/O address " 1928 "%x conflicts with another device\n", brdp->brdnr, 1929 brdp->ioaddr1); 1930 goto err; 1931 } 1932 1933 if (brdp->iosize2 > 0) 1934 if (!request_region(brdp->ioaddr2, brdp->iosize2, name)) { 1935 printk(KERN_WARNING "STALLION: Warning, board %d I/O " 1936 "address %x conflicts with another device\n", 1937 brdp->brdnr, brdp->ioaddr2); 1938 printk(KERN_WARNING "STALLION: Warning, also " 1939 "releasing board %d I/O address %x \n", 1940 brdp->brdnr, brdp->ioaddr1); 1941 goto err_rel1; 1942 } 1943 1944/* 1945 * Scan through the secondary io address space looking for panels. 1946 * As we find'em allocate and initialize panel structures for each. 1947 */ 1948 brdp->clk = CD1400_CLK; 1949 brdp->hwid = status; 1950 1951 ioaddr = brdp->ioaddr2; 1952 banknr = 0; 1953 panelnr = 0; 1954 nxtid = 0; 1955 1956 for (i = 0; i < STL_MAXPANELS; i++) { 1957 if (brdp->brdtype == BRD_ECHPCI) { 1958 outb(nxtid, brdp->ioctrl); 1959 ioaddr = brdp->ioaddr2; 1960 } 1961 status = inb(ioaddr + ECH_PNLSTATUS); 1962 if ((status & ECH_PNLIDMASK) != nxtid) 1963 break; 1964 panelp = kzalloc(sizeof(struct stlpanel), GFP_KERNEL); 1965 if (!panelp) { 1966 printk("STALLION: failed to allocate memory " 1967 "(size=%Zd)\n", sizeof(struct stlpanel)); 1968 retval = -ENOMEM; 1969 goto err_fr; 1970 } 1971 panelp->magic = STL_PANELMAGIC; 1972 panelp->brdnr = brdp->brdnr; 1973 panelp->panelnr = panelnr; 1974 panelp->iobase = ioaddr; 1975 panelp->pagenr = nxtid; 1976 panelp->hwid = status; 1977 brdp->bnk2panel[banknr] = panelp; 1978 brdp->bnkpageaddr[banknr] = nxtid; 1979 brdp->bnkstataddr[banknr++] = ioaddr + ECH_PNLSTATUS; 1980 1981 if (status & ECH_PNLXPID) { 1982 panelp->uartp = &stl_sc26198uart; 1983 panelp->isr = stl_sc26198intr; 1984 if (status & ECH_PNL16PORT) { 1985 panelp->nrports = 16; 1986 brdp->bnk2panel[banknr] = panelp; 1987 brdp->bnkpageaddr[banknr] = nxtid; 1988 brdp->bnkstataddr[banknr++] = ioaddr + 4 + 1989 ECH_PNLSTATUS; 1990 } else 1991 panelp->nrports = 8; 1992 } else { 1993 panelp->uartp = &stl_cd1400uart; 1994 panelp->isr = stl_cd1400echintr; 1995 if (status & ECH_PNL16PORT) { 1996 panelp->nrports = 16; 1997 panelp->ackmask = 0x80; 1998 if (brdp->brdtype != BRD_ECHPCI) 1999 ioaddr += EREG_BANKSIZE; 2000 brdp->bnk2panel[banknr] = panelp; 2001 brdp->bnkpageaddr[banknr] = ++nxtid; 2002 brdp->bnkstataddr[banknr++] = ioaddr + 2003 ECH_PNLSTATUS; 2004 } else { 2005 panelp->nrports = 8; 2006 panelp->ackmask = 0xc0; 2007 } 2008 } 2009 2010 nxtid++; 2011 ioaddr += EREG_BANKSIZE; 2012 brdp->nrports += panelp->nrports; 2013 brdp->panels[panelnr++] = panelp; 2014 if ((brdp->brdtype != BRD_ECHPCI) && 2015 (ioaddr >= (brdp->ioaddr2 + brdp->iosize2))) { 2016 retval = -EINVAL; 2017 goto err_fr; 2018 } 2019 } 2020 2021 brdp->nrpanels = panelnr; 2022 brdp->nrbnks = banknr; 2023 if (brdp->brdtype == BRD_ECH) 2024 outb((brdp->ioctrlval | ECH_BRDDISABLE), brdp->ioctrl); 2025 2026 brdp->state |= BRD_FOUND; 2027 if (request_irq(brdp->irq, stl_intr, IRQF_SHARED, name, brdp) != 0) { 2028 printk("STALLION: failed to register interrupt " 2029 "routine for %s irq=%d\n", name, brdp->irq); 2030 retval = -ENODEV; 2031 goto err_fr; 2032 } 2033 2034 return 0; 2035err_fr: 2036 stl_cleanup_panels(brdp); 2037 if (brdp->iosize2 > 0) 2038 release_region(brdp->ioaddr2, brdp->iosize2); 2039err_rel1: 2040 release_region(brdp->ioaddr1, brdp->iosize1); 2041err: 2042 return retval; 2043} 2044 2045/*****************************************************************************/ 2046 2047/* 2048 * Initialize and configure the specified board. 2049 * Scan through all the boards in the configuration and see what we 2050 * can find. Handle EIO and the ECH boards a little differently here 2051 * since the initial search and setup is very different. 2052 */ 2053 2054static int __devinit stl_brdinit(struct stlbrd *brdp) 2055{ 2056 int i, retval; 2057 2058 pr_debug("stl_brdinit(brdp=%p)\n", brdp); 2059 2060 switch (brdp->brdtype) { 2061 case BRD_EASYIO: 2062 case BRD_EASYIOPCI: 2063 retval = stl_initeio(brdp); 2064 if (retval) 2065 goto err; 2066 break; 2067 case BRD_ECH: 2068 case BRD_ECHMC: 2069 case BRD_ECHPCI: 2070 case BRD_ECH64PCI: 2071 retval = stl_initech(brdp); 2072 if (retval) 2073 goto err; 2074 break; 2075 default: 2076 printk("STALLION: board=%d is unknown board type=%d\n", 2077 brdp->brdnr, brdp->brdtype); 2078 retval = -ENODEV; 2079 goto err; 2080 } 2081 2082 if ((brdp->state & BRD_FOUND) == 0) { 2083 printk("STALLION: %s board not found, board=%d io=%x irq=%d\n", 2084 stl_brdnames[brdp->brdtype], brdp->brdnr, 2085 brdp->ioaddr1, brdp->irq); 2086 goto err_free; 2087 } 2088 2089 for (i = 0; i < STL_MAXPANELS; i++) 2090 if (brdp->panels[i] != NULL) 2091 stl_initports(brdp, brdp->panels[i]); 2092 2093 printk("STALLION: %s found, board=%d io=%x irq=%d " 2094 "nrpanels=%d nrports=%d\n", stl_brdnames[brdp->brdtype], 2095 brdp->brdnr, brdp->ioaddr1, brdp->irq, brdp->nrpanels, 2096 brdp->nrports); 2097 2098 return 0; 2099err_free: 2100 free_irq(brdp->irq, brdp); 2101 2102 stl_cleanup_panels(brdp); 2103 2104 release_region(brdp->ioaddr1, brdp->iosize1); 2105 if (brdp->iosize2 > 0) 2106 release_region(brdp->ioaddr2, brdp->iosize2); 2107err: 2108 return retval; 2109} 2110 2111/*****************************************************************************/ 2112 2113/* 2114 * Find the next available board number that is free. 2115 */ 2116 2117static int __devinit stl_getbrdnr(void) 2118{ 2119 unsigned int i; 2120 2121 for (i = 0; i < STL_MAXBRDS; i++) 2122 if (stl_brds[i] == NULL) { 2123 if (i >= stl_nrbrds) 2124 stl_nrbrds = i + 1; 2125 return i; 2126 } 2127 2128 return -1; 2129} 2130 2131/*****************************************************************************/ 2132/* 2133 * We have a Stallion board. Allocate a board structure and 2134 * initialize it. Read its IO and IRQ resources from PCI 2135 * configuration space. 2136 */ 2137 2138static int __devinit stl_pciprobe(struct pci_dev *pdev, 2139 const struct pci_device_id *ent) 2140{ 2141 struct stlbrd *brdp; 2142 unsigned int i, brdtype = ent->driver_data; 2143 int brdnr, retval = -ENODEV; 2144 2145 if ((pdev->class >> 8) == PCI_CLASS_STORAGE_IDE) 2146 goto err; 2147 2148 retval = pci_enable_device(pdev); 2149 if (retval) 2150 goto err; 2151 brdp = stl_allocbrd(); 2152 if (brdp == NULL) { 2153 retval = -ENOMEM; 2154 goto err; 2155 } 2156 mutex_lock(&stl_brdslock); 2157 brdnr = stl_getbrdnr(); 2158 if (brdnr < 0) { 2159 dev_err(&pdev->dev, "too many boards found, " 2160 "maximum supported %d\n", STL_MAXBRDS); 2161 mutex_unlock(&stl_brdslock); 2162 retval = -ENODEV; 2163 goto err_fr; 2164 } 2165 brdp->brdnr = (unsigned int)brdnr; 2166 stl_brds[brdp->brdnr] = brdp; 2167 mutex_unlock(&stl_brdslock); 2168 2169 brdp->brdtype = brdtype; 2170 brdp->state |= STL_PROBED; 2171 2172/* 2173 * We have all resources from the board, so let's setup the actual 2174 * board structure now. 2175 */ 2176 switch (brdtype) { 2177 case BRD_ECHPCI: 2178 brdp->ioaddr2 = pci_resource_start(pdev, 0); 2179 brdp->ioaddr1 = pci_resource_start(pdev, 1); 2180 break; 2181 case BRD_ECH64PCI: 2182 brdp->ioaddr2 = pci_resource_start(pdev, 2); 2183 brdp->ioaddr1 = pci_resource_start(pdev, 1); 2184 break; 2185 case BRD_EASYIOPCI: 2186 brdp->ioaddr1 = pci_resource_start(pdev, 2); 2187 brdp->ioaddr2 = pci_resource_start(pdev, 1); 2188 break; 2189 default: 2190 dev_err(&pdev->dev, "unknown PCI board type=%u\n", brdtype); 2191 break; 2192 } 2193 2194 brdp->irq = pdev->irq; 2195 retval = stl_brdinit(brdp); 2196 if (retval) 2197 goto err_null; 2198 2199 pci_set_drvdata(pdev, brdp); 2200 2201 for (i = 0; i < brdp->nrports; i++) 2202 tty_register_device(stl_serial, 2203 brdp->brdnr * STL_MAXPORTS + i, &pdev->dev); 2204 2205 return 0; 2206err_null: 2207 stl_brds[brdp->brdnr] = NULL; 2208err_fr: 2209 kfree(brdp); 2210err: 2211 return retval; 2212} 2213 2214static void __devexit stl_pciremove(struct pci_dev *pdev) 2215{ 2216 struct stlbrd *brdp = pci_get_drvdata(pdev); 2217 unsigned int i; 2218 2219 free_irq(brdp->irq, brdp); 2220 2221 stl_cleanup_panels(brdp); 2222 2223 release_region(brdp->ioaddr1, brdp->iosize1); 2224 if (brdp->iosize2 > 0) 2225 release_region(brdp->ioaddr2, brdp->iosize2); 2226 2227 for (i = 0; i < brdp->nrports; i++) 2228 tty_unregister_device(stl_serial, 2229 brdp->brdnr * STL_MAXPORTS + i); 2230 2231 stl_brds[brdp->brdnr] = NULL; 2232 kfree(brdp); 2233} 2234 2235static struct pci_driver stl_pcidriver = { 2236 .name = "stallion", 2237 .id_table = stl_pcibrds, 2238 .probe = stl_pciprobe, 2239 .remove = __devexit_p(stl_pciremove) 2240}; 2241 2242/*****************************************************************************/ 2243 2244/* 2245 * Return the board stats structure to user app. 2246 */ 2247 2248static int stl_getbrdstats(combrd_t __user *bp) 2249{ 2250 combrd_t stl_brdstats; 2251 struct stlbrd *brdp; 2252 struct stlpanel *panelp; 2253 unsigned int i; 2254 2255 if (copy_from_user(&stl_brdstats, bp, sizeof(combrd_t))) 2256 return -EFAULT; 2257 if (stl_brdstats.brd >= STL_MAXBRDS) 2258 return -ENODEV; 2259 brdp = stl_brds[stl_brdstats.brd]; 2260 if (brdp == NULL) 2261 return -ENODEV; 2262 2263 memset(&stl_brdstats, 0, sizeof(combrd_t)); 2264 stl_brdstats.brd = brdp->brdnr; 2265 stl_brdstats.type = brdp->brdtype; 2266 stl_brdstats.hwid = brdp->hwid; 2267 stl_brdstats.state = brdp->state; 2268 stl_brdstats.ioaddr = brdp->ioaddr1; 2269 stl_brdstats.ioaddr2 = brdp->ioaddr2; 2270 stl_brdstats.irq = brdp->irq; 2271 stl_brdstats.nrpanels = brdp->nrpanels; 2272 stl_brdstats.nrports = brdp->nrports; 2273 for (i = 0; i < brdp->nrpanels; i++) { 2274 panelp = brdp->panels[i]; 2275 stl_brdstats.panels[i].panel = i; 2276 stl_brdstats.panels[i].hwid = panelp->hwid; 2277 stl_brdstats.panels[i].nrports = panelp->nrports; 2278 } 2279 2280 return copy_to_user(bp, &stl_brdstats, sizeof(combrd_t)) ? -EFAULT : 0; 2281} 2282 2283/*****************************************************************************/ 2284 2285/* 2286 * Resolve the referenced port number into a port struct pointer. 2287 */ 2288 2289static struct stlport *stl_getport(int brdnr, int panelnr, int portnr) 2290{ 2291 struct stlbrd *brdp; 2292 struct stlpanel *panelp; 2293 2294 if (brdnr < 0 || brdnr >= STL_MAXBRDS) 2295 return NULL; 2296 brdp = stl_brds[brdnr]; 2297 if (brdp == NULL) 2298 return NULL; 2299 if (panelnr < 0 || (unsigned int)panelnr >= brdp->nrpanels) 2300 return NULL; 2301 panelp = brdp->panels[panelnr]; 2302 if (panelp == NULL) 2303 return NULL; 2304 if (portnr < 0 || (unsigned int)portnr >= panelp->nrports) 2305 return NULL; 2306 return panelp->ports[portnr]; 2307} 2308 2309/*****************************************************************************/ 2310 2311/* 2312 * Return the port stats structure to user app. A NULL port struct 2313 * pointer passed in means that we need to find out from the app 2314 * what port to get stats for (used through board control device). 2315 */ 2316 2317static int stl_getportstats(struct tty_struct *tty, struct stlport *portp, comstats_t __user *cp) 2318{ 2319 comstats_t stl_comstats; 2320 unsigned char *head, *tail; 2321 unsigned long flags; 2322 2323 if (!portp) { 2324 if (copy_from_user(&stl_comstats, cp, sizeof(comstats_t))) 2325 return -EFAULT; 2326 portp = stl_getport(stl_comstats.brd, stl_comstats.panel, 2327 stl_comstats.port); 2328 if (portp == NULL) 2329 return -ENODEV; 2330 } 2331 2332 mutex_lock(&portp->port.mutex); 2333 portp->stats.state = portp->istate; 2334 portp->stats.flags = portp->port.flags; 2335 portp->stats.hwid = portp->hwid; 2336 2337 portp->stats.ttystate = 0; 2338 portp->stats.cflags = 0; 2339 portp->stats.iflags = 0; 2340 portp->stats.oflags = 0; 2341 portp->stats.lflags = 0; 2342 portp->stats.rxbuffered = 0; 2343 2344 spin_lock_irqsave(&stallion_lock, flags); 2345 if (tty != NULL && portp->port.tty == tty) { 2346 portp->stats.ttystate = tty->flags; 2347 /* No longer available as a statistic */ 2348 portp->stats.rxbuffered = 1; /*tty->flip.count; */ 2349 if (tty->termios != NULL) { 2350 portp->stats.cflags = tty->termios->c_cflag; 2351 portp->stats.iflags = tty->termios->c_iflag; 2352 portp->stats.oflags = tty->termios->c_oflag; 2353 portp->stats.lflags = tty->termios->c_lflag; 2354 } 2355 } 2356 spin_unlock_irqrestore(&stallion_lock, flags); 2357 2358 head = portp->tx.head; 2359 tail = portp->tx.tail; 2360 portp->stats.txbuffered = (head >= tail) ? (head - tail) : 2361 (STL_TXBUFSIZE - (tail - head)); 2362 2363 portp->stats.signals = (unsigned long) stl_getsignals(portp); 2364 mutex_unlock(&portp->port.mutex); 2365 2366 return copy_to_user(cp, &portp->stats, 2367 sizeof(comstats_t)) ? -EFAULT : 0; 2368} 2369 2370/*****************************************************************************/ 2371 2372/* 2373 * Clear the port stats structure. We also return it zeroed out... 2374 */ 2375 2376static int stl_clrportstats(struct stlport *portp, comstats_t __user *cp) 2377{ 2378 comstats_t stl_comstats; 2379 2380 if (!portp) { 2381 if (copy_from_user(&stl_comstats, cp, sizeof(comstats_t))) 2382 return -EFAULT; 2383 portp = stl_getport(stl_comstats.brd, stl_comstats.panel, 2384 stl_comstats.port); 2385 if (portp == NULL) 2386 return -ENODEV; 2387 } 2388 2389 mutex_lock(&portp->port.mutex); 2390 memset(&portp->stats, 0, sizeof(comstats_t)); 2391 portp->stats.brd = portp->brdnr; 2392 portp->stats.panel = portp->panelnr; 2393 portp->stats.port = portp->portnr; 2394 mutex_unlock(&portp->port.mutex); 2395 return copy_to_user(cp, &portp->stats, 2396 sizeof(comstats_t)) ? -EFAULT : 0; 2397} 2398 2399/*****************************************************************************/ 2400 2401/* 2402 * Return the entire driver ports structure to a user app. 2403 */ 2404 2405static int stl_getportstruct(struct stlport __user *arg) 2406{ 2407 struct stlport stl_dummyport; 2408 struct stlport *portp; 2409 2410 if (copy_from_user(&stl_dummyport, arg, sizeof(struct stlport))) 2411 return -EFAULT; 2412 portp = stl_getport(stl_dummyport.brdnr, stl_dummyport.panelnr, 2413 stl_dummyport.portnr); 2414 if (!portp) 2415 return -ENODEV; 2416 return copy_to_user(arg, portp, sizeof(struct stlport)) ? -EFAULT : 0; 2417} 2418 2419/*****************************************************************************/ 2420 2421/* 2422 * Return the entire driver board structure to a user app. 2423 */ 2424 2425static int stl_getbrdstruct(struct stlbrd __user *arg) 2426{ 2427 struct stlbrd stl_dummybrd; 2428 struct stlbrd *brdp; 2429 2430 if (copy_from_user(&stl_dummybrd, arg, sizeof(struct stlbrd))) 2431 return -EFAULT; 2432 if (stl_dummybrd.brdnr >= STL_MAXBRDS) 2433 return -ENODEV; 2434 brdp = stl_brds[stl_dummybrd.brdnr]; 2435 if (!brdp) 2436 return -ENODEV; 2437 return copy_to_user(arg, brdp, sizeof(struct stlbrd)) ? -EFAULT : 0; 2438} 2439 2440/*****************************************************************************/ 2441 2442/* 2443 * The "staliomem" device is also required to do some special operations 2444 * on the board and/or ports. In this driver it is mostly used for stats 2445 * collection. 2446 */ 2447 2448static long stl_memioctl(struct file *fp, unsigned int cmd, unsigned long arg) 2449{ 2450 int brdnr, rc; 2451 void __user *argp = (void __user *)arg; 2452 2453 pr_debug("stl_memioctl(fp=%p,cmd=%x,arg=%lx)\n", fp, cmd,arg); 2454 2455 brdnr = iminor(fp->f_dentry->d_inode); 2456 if (brdnr >= STL_MAXBRDS) 2457 return -ENODEV; 2458 rc = 0; 2459 2460 switch (cmd) { 2461 case COM_GETPORTSTATS: 2462 rc = stl_getportstats(NULL, NULL, argp); 2463 break; 2464 case COM_CLRPORTSTATS: 2465 rc = stl_clrportstats(NULL, argp); 2466 break; 2467 case COM_GETBRDSTATS: 2468 rc = stl_getbrdstats(argp); 2469 break; 2470 case COM_READPORT: 2471 rc = stl_getportstruct(argp); 2472 break; 2473 case COM_READBOARD: 2474 rc = stl_getbrdstruct(argp); 2475 break; 2476 default: 2477 rc = -ENOIOCTLCMD; 2478 break; 2479 } 2480 return rc; 2481} 2482 2483static const struct tty_operations stl_ops = { 2484 .open = stl_open, 2485 .close = stl_close, 2486 .write = stl_write, 2487 .put_char = stl_putchar, 2488 .flush_chars = stl_flushchars, 2489 .write_room = stl_writeroom, 2490 .chars_in_buffer = stl_charsinbuffer, 2491 .ioctl = stl_ioctl, 2492 .set_termios = stl_settermios, 2493 .throttle = stl_throttle, 2494 .unthrottle = stl_unthrottle, 2495 .stop = stl_stop, 2496 .start = stl_start, 2497 .hangup = stl_hangup, 2498 .flush_buffer = stl_flushbuffer, 2499 .break_ctl = stl_breakctl, 2500 .wait_until_sent = stl_waituntilsent, 2501 .send_xchar = stl_sendxchar, 2502 .tiocmget = stl_tiocmget, 2503 .tiocmset = stl_tiocmset, 2504 .proc_fops = &stl_proc_fops, 2505}; 2506 2507static const struct tty_port_operations stl_port_ops = { 2508 .carrier_raised = stl_carrier_raised, 2509 .dtr_rts = stl_dtr_rts, 2510 .activate = stl_activate, 2511 .shutdown = stl_shutdown, 2512}; 2513 2514/*****************************************************************************/ 2515/* CD1400 HARDWARE FUNCTIONS */ 2516/*****************************************************************************/ 2517 2518/* 2519 * These functions get/set/update the registers of the cd1400 UARTs. 2520 * Access to the cd1400 registers is via an address/data io port pair. 2521 * (Maybe should make this inline...) 2522 */ 2523 2524static int stl_cd1400getreg(struct stlport *portp, int regnr) 2525{ 2526 outb((regnr + portp->uartaddr), portp->ioaddr); 2527 return inb(portp->ioaddr + EREG_DATA); 2528} 2529 2530static void stl_cd1400setreg(struct stlport *portp, int regnr, int value) 2531{ 2532 outb(regnr + portp->uartaddr, portp->ioaddr); 2533 outb(value, portp->ioaddr + EREG_DATA); 2534} 2535 2536static int stl_cd1400updatereg(struct stlport *portp, int regnr, int value) 2537{ 2538 outb(regnr + portp->uartaddr, portp->ioaddr); 2539 if (inb(portp->ioaddr + EREG_DATA) != value) { 2540 outb(value, portp->ioaddr + EREG_DATA); 2541 return 1; 2542 } 2543 return 0; 2544} 2545 2546/*****************************************************************************/ 2547 2548/* 2549 * Inbitialize the UARTs in a panel. We don't care what sort of board 2550 * these ports are on - since the port io registers are almost 2551 * identical when dealing with ports. 2552 */ 2553 2554static int stl_cd1400panelinit(struct stlbrd *brdp, struct stlpanel *panelp) 2555{ 2556 unsigned int gfrcr; 2557 int chipmask, i, j; 2558 int nrchips, uartaddr, ioaddr; 2559 unsigned long flags; 2560 2561 pr_debug("stl_panelinit(brdp=%p,panelp=%p)\n", brdp, panelp); 2562 2563 spin_lock_irqsave(&brd_lock, flags); 2564 BRDENABLE(panelp->brdnr, panelp->pagenr); 2565 2566/* 2567 * Check that each chip is present and started up OK. 2568 */ 2569 chipmask = 0; 2570 nrchips = panelp->nrports / CD1400_PORTS; 2571 for (i = 0; i < nrchips; i++) { 2572 if (brdp->brdtype == BRD_ECHPCI) { 2573 outb((panelp->pagenr + (i >> 1)), brdp->ioctrl); 2574 ioaddr = panelp->iobase; 2575 } else 2576 ioaddr = panelp->iobase + (EREG_BANKSIZE * (i >> 1)); 2577 uartaddr = (i & 0x01) ? 0x080 : 0; 2578 outb((GFRCR + uartaddr), ioaddr); 2579 outb(0, (ioaddr + EREG_DATA)); 2580 outb((CCR + uartaddr), ioaddr); 2581 outb(CCR_RESETFULL, (ioaddr + EREG_DATA)); 2582 outb(CCR_RESETFULL, (ioaddr + EREG_DATA)); 2583 outb((GFRCR + uartaddr), ioaddr); 2584 for (j = 0; j < CCR_MAXWAIT; j++) 2585 if ((gfrcr = inb(ioaddr + EREG_DATA)) != 0) 2586 break; 2587 2588 if ((j >= CCR_MAXWAIT) || (gfrcr < 0x40) || (gfrcr > 0x60)) { 2589 printk("STALLION: cd1400 not responding, " 2590 "brd=%d panel=%d chip=%d\n", 2591 panelp->brdnr, panelp->panelnr, i); 2592 continue; 2593 } 2594 chipmask |= (0x1 << i); 2595 outb((PPR + uartaddr), ioaddr); 2596 outb(PPR_SCALAR, (ioaddr + EREG_DATA)); 2597 } 2598 2599 BRDDISABLE(panelp->brdnr); 2600 spin_unlock_irqrestore(&brd_lock, flags); 2601 return chipmask; 2602} 2603 2604/*****************************************************************************/ 2605 2606/* 2607 * Initialize hardware specific port registers. 2608 */ 2609 2610static void stl_cd1400portinit(struct stlbrd *brdp, struct stlpanel *panelp, struct stlport *portp) 2611{ 2612 unsigned long flags; 2613 pr_debug("stl_cd1400portinit(brdp=%p,panelp=%p,portp=%p)\n", brdp, 2614 panelp, portp); 2615 2616 if ((brdp == NULL) || (panelp == NULL) || 2617 (portp == NULL)) 2618 return; 2619 2620 spin_lock_irqsave(&brd_lock, flags); 2621 portp->ioaddr = panelp->iobase + (((brdp->brdtype == BRD_ECHPCI) || 2622 (portp->portnr < 8)) ? 0 : EREG_BANKSIZE); 2623 portp->uartaddr = (portp->portnr & 0x04) << 5; 2624 portp->pagenr = panelp->pagenr + (portp->portnr >> 3); 2625 2626 BRDENABLE(portp->brdnr, portp->pagenr); 2627 stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03)); 2628 stl_cd1400setreg(portp, LIVR, (portp->portnr << 3)); 2629 portp->hwid = stl_cd1400getreg(portp, GFRCR); 2630 BRDDISABLE(portp->brdnr); 2631 spin_unlock_irqrestore(&brd_lock, flags); 2632} 2633 2634/*****************************************************************************/ 2635 2636/* 2637 * Wait for the command register to be ready. We will poll this, 2638 * since it won't usually take too long to be ready. 2639 */ 2640 2641static void stl_cd1400ccrwait(struct stlport *portp) 2642{ 2643 int i; 2644 2645 for (i = 0; i < CCR_MAXWAIT; i++) 2646 if (stl_cd1400getreg(portp, CCR) == 0) 2647 return; 2648 2649 printk("STALLION: cd1400 not responding, port=%d panel=%d brd=%d\n", 2650 portp->portnr, portp->panelnr, portp->brdnr); 2651} 2652 2653/*****************************************************************************/ 2654 2655/* 2656 * Set up the cd1400 registers for a port based on the termios port 2657 * settings. 2658 */ 2659 2660static void stl_cd1400setport(struct stlport *portp, struct ktermios *tiosp) 2661{ 2662 struct stlbrd *brdp; 2663 unsigned long flags; 2664 unsigned int clkdiv, baudrate; 2665 unsigned char cor1, cor2, cor3; 2666 unsigned char cor4, cor5, ccr; 2667 unsigned char srer, sreron, sreroff; 2668 unsigned char mcor1, mcor2, rtpr; 2669 unsigned char clk, div; 2670 2671 cor1 = 0; 2672 cor2 = 0; 2673 cor3 = 0; 2674 cor4 = 0; 2675 cor5 = 0; 2676 ccr = 0; 2677 rtpr = 0; 2678 clk = 0; 2679 div = 0; 2680 mcor1 = 0; 2681 mcor2 = 0; 2682 sreron = 0; 2683 sreroff = 0; 2684 2685 brdp = stl_brds[portp->brdnr]; 2686 if (brdp == NULL) 2687 return; 2688 2689/* 2690 * Set up the RX char ignore mask with those RX error types we 2691 * can ignore. We can get the cd1400 to help us out a little here, 2692 * it will ignore parity errors and breaks for us. 2693 */ 2694 portp->rxignoremsk = 0; 2695 if (tiosp->c_iflag & IGNPAR) { 2696 portp->rxignoremsk |= (ST_PARITY | ST_FRAMING | ST_OVERRUN); 2697 cor1 |= COR1_PARIGNORE; 2698 } 2699 if (tiosp->c_iflag & IGNBRK) { 2700 portp->rxignoremsk |= ST_BREAK; 2701 cor4 |= COR4_IGNBRK; 2702 } 2703 2704 portp->rxmarkmsk = ST_OVERRUN; 2705 if (tiosp->c_iflag & (INPCK | PARMRK)) 2706 portp->rxmarkmsk |= (ST_PARITY | ST_FRAMING); 2707 if (tiosp->c_iflag & BRKINT) 2708 portp->rxmarkmsk |= ST_BREAK; 2709 2710/* 2711 * Go through the char size, parity and stop bits and set all the 2712 * option register appropriately. 2713 */ 2714 switch (tiosp->c_cflag & CSIZE) { 2715 case CS5: 2716 cor1 |= COR1_CHL5; 2717 break; 2718 case CS6: 2719 cor1 |= COR1_CHL6; 2720 break; 2721 case CS7: 2722 cor1 |= COR1_CHL7; 2723 break; 2724 default: 2725 cor1 |= COR1_CHL8; 2726 break; 2727 } 2728 2729 if (tiosp->c_cflag & CSTOPB) 2730 cor1 |= COR1_STOP2; 2731 else 2732 cor1 |= COR1_STOP1; 2733 2734 if (tiosp->c_cflag & PARENB) { 2735 if (tiosp->c_cflag & PARODD) 2736 cor1 |= (COR1_PARENB | COR1_PARODD); 2737 else 2738 cor1 |= (COR1_PARENB | COR1_PAREVEN); 2739 } else { 2740 cor1 |= COR1_PARNONE; 2741 } 2742 2743/* 2744 * Set the RX FIFO threshold at 6 chars. This gives a bit of breathing 2745 * space for hardware flow control and the like. This should be set to 2746 * VMIN. Also here we will set the RX data timeout to 10ms - this should 2747 * really be based on VTIME. 2748 */ 2749 cor3 |= FIFO_RXTHRESHOLD; 2750 rtpr = 2; 2751 2752/* 2753 * Calculate the baud rate timers. For now we will just assume that 2754 * the input and output baud are the same. Could have used a baud 2755 * table here, but this way we can generate virtually any baud rate 2756 * we like! 2757 */ 2758 baudrate = tiosp->c_cflag & CBAUD; 2759 if (baudrate & CBAUDEX) { 2760 baudrate &= ~CBAUDEX; 2761 if ((baudrate < 1) || (baudrate > 4)) 2762 tiosp->c_cflag &= ~CBAUDEX; 2763 else 2764 baudrate += 15; 2765 } 2766 baudrate = stl_baudrates[baudrate]; 2767 if ((tiosp->c_cflag & CBAUD) == B38400) { 2768 if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI) 2769 baudrate = 57600; 2770 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI) 2771 baudrate = 115200; 2772 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI) 2773 baudrate = 230400; 2774 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP) 2775 baudrate = 460800; 2776 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST) 2777 baudrate = (portp->baud_base / portp->custom_divisor); 2778 } 2779 if (baudrate > STL_CD1400MAXBAUD) 2780 baudrate = STL_CD1400MAXBAUD; 2781 2782 if (baudrate > 0) { 2783 for (clk = 0; clk < CD1400_NUMCLKS; clk++) { 2784 clkdiv = (portp->clk / stl_cd1400clkdivs[clk]) / baudrate; 2785 if (clkdiv < 0x100) 2786 break; 2787 } 2788 div = (unsigned char) clkdiv; 2789 } 2790 2791/* 2792 * Check what form of modem signaling is required and set it up. 2793 */ 2794 if ((tiosp->c_cflag & CLOCAL) == 0) { 2795 mcor1 |= MCOR1_DCD; 2796 mcor2 |= MCOR2_DCD; 2797 sreron |= SRER_MODEM; 2798 portp->port.flags |= ASYNC_CHECK_CD; 2799 } else 2800 portp->port.flags &= ~ASYNC_CHECK_CD; 2801 2802/* 2803 * Setup cd1400 enhanced modes if we can. In particular we want to 2804 * handle as much of the flow control as possible automatically. As 2805 * well as saving a few CPU cycles it will also greatly improve flow 2806 * control reliability. 2807 */ 2808 if (tiosp->c_iflag & IXON) { 2809 cor2 |= COR2_TXIBE; 2810 cor3 |= COR3_SCD12; 2811 if (tiosp->c_iflag & IXANY) 2812 cor2 |= COR2_IXM; 2813 } 2814 2815 if (tiosp->c_cflag & CRTSCTS) { 2816 cor2 |= COR2_CTSAE; 2817 mcor1 |= FIFO_RTSTHRESHOLD; 2818 } 2819 2820/* 2821 * All cd1400 register values calculated so go through and set 2822 * them all up. 2823 */ 2824 2825 pr_debug("SETPORT: portnr=%d panelnr=%d brdnr=%d\n", 2826 portp->portnr, portp->panelnr, portp->brdnr); 2827 pr_debug(" cor1=%x cor2=%x cor3=%x cor4=%x cor5=%x\n", 2828 cor1, cor2, cor3, cor4, cor5); 2829 pr_debug(" mcor1=%x mcor2=%x rtpr=%x sreron=%x sreroff=%x\n", 2830 mcor1, mcor2, rtpr, sreron, sreroff); 2831 pr_debug(" tcor=%x tbpr=%x rcor=%x rbpr=%x\n", clk, div, clk, div); 2832 pr_debug(" schr1=%x schr2=%x schr3=%x schr4=%x\n", 2833 tiosp->c_cc[VSTART], tiosp->c_cc[VSTOP], 2834 tiosp->c_cc[VSTART], tiosp->c_cc[VSTOP]); 2835 2836 spin_lock_irqsave(&brd_lock, flags); 2837 BRDENABLE(portp->brdnr, portp->pagenr); 2838 stl_cd1400setreg(portp, CAR, (portp->portnr & 0x3)); 2839 srer = stl_cd1400getreg(portp, SRER); 2840 stl_cd1400setreg(portp, SRER, 0); 2841 if (stl_cd1400updatereg(portp, COR1, cor1)) 2842 ccr = 1; 2843 if (stl_cd1400updatereg(portp, COR2, cor2)) 2844 ccr = 1; 2845 if (stl_cd1400updatereg(portp, COR3, cor3)) 2846 ccr = 1; 2847 if (ccr) { 2848 stl_cd1400ccrwait(portp); 2849 stl_cd1400setreg(portp, CCR, CCR_CORCHANGE); 2850 } 2851 stl_cd1400setreg(portp, COR4, cor4); 2852 stl_cd1400setreg(portp, COR5, cor5); 2853 stl_cd1400setreg(portp, MCOR1, mcor1); 2854 stl_cd1400setreg(portp, MCOR2, mcor2); 2855 if (baudrate > 0) { 2856 stl_cd1400setreg(portp, TCOR, clk); 2857 stl_cd1400setreg(portp, TBPR, div); 2858 stl_cd1400setreg(portp, RCOR, clk); 2859 stl_cd1400setreg(portp, RBPR, div); 2860 } 2861 stl_cd1400setreg(portp, SCHR1, tiosp->c_cc[VSTART]); 2862 stl_cd1400setreg(portp, SCHR2, tiosp->c_cc[VSTOP]); 2863 stl_cd1400setreg(portp, SCHR3, tiosp->c_cc[VSTART]); 2864 stl_cd1400setreg(portp, SCHR4, tiosp->c_cc[VSTOP]); 2865 stl_cd1400setreg(portp, RTPR, rtpr); 2866 mcor1 = stl_cd1400getreg(portp, MSVR1); 2867 if (mcor1 & MSVR1_DCD) 2868 portp->sigs |= TIOCM_CD; 2869 else 2870 portp->sigs &= ~TIOCM_CD; 2871 stl_cd1400setreg(portp, SRER, ((srer & ~sreroff) | sreron)); 2872 BRDDISABLE(portp->brdnr); 2873 spin_unlock_irqrestore(&brd_lock, flags); 2874} 2875 2876/*****************************************************************************/ 2877 2878/* 2879 * Set the state of the DTR and RTS signals. 2880 */ 2881 2882static void stl_cd1400setsignals(struct stlport *portp, int dtr, int rts) 2883{ 2884 unsigned char msvr1, msvr2; 2885 unsigned long flags; 2886 2887 pr_debug("stl_cd1400setsignals(portp=%p,dtr=%d,rts=%d)\n", 2888 portp, dtr, rts); 2889 2890 msvr1 = 0; 2891 msvr2 = 0; 2892 if (dtr > 0) 2893 msvr1 = MSVR1_DTR; 2894 if (rts > 0) 2895 msvr2 = MSVR2_RTS; 2896 2897 spin_lock_irqsave(&brd_lock, flags); 2898 BRDENABLE(portp->brdnr, portp->pagenr); 2899 stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03)); 2900 if (rts >= 0) 2901 stl_cd1400setreg(portp, MSVR2, msvr2); 2902 if (dtr >= 0) 2903 stl_cd1400setreg(portp, MSVR1, msvr1); 2904 BRDDISABLE(portp->brdnr); 2905 spin_unlock_irqrestore(&brd_lock, flags); 2906} 2907 2908/*****************************************************************************/ 2909 2910/* 2911 * Return the state of the signals. 2912 */ 2913 2914static int stl_cd1400getsignals(struct stlport *portp) 2915{ 2916 unsigned char msvr1, msvr2; 2917 unsigned long flags; 2918 int sigs; 2919 2920 pr_debug("stl_cd1400getsignals(portp=%p)\n", portp); 2921 2922 spin_lock_irqsave(&brd_lock, flags); 2923 BRDENABLE(portp->brdnr, portp->pagenr); 2924 stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03)); 2925 msvr1 = stl_cd1400getreg(portp, MSVR1); 2926 msvr2 = stl_cd1400getreg(portp, MSVR2); 2927 BRDDISABLE(portp->brdnr); 2928 spin_unlock_irqrestore(&brd_lock, flags); 2929 2930 sigs = 0; 2931 sigs |= (msvr1 & MSVR1_DCD) ? TIOCM_CD : 0; 2932 sigs |= (msvr1 & MSVR1_CTS) ? TIOCM_CTS : 0; 2933 sigs |= (msvr1 & MSVR1_DTR) ? TIOCM_DTR : 0; 2934 sigs |= (msvr2 & MSVR2_RTS) ? TIOCM_RTS : 0; 2935 sigs |= TIOCM_DSR; 2936 return sigs; 2937} 2938 2939/*****************************************************************************/ 2940 2941/* 2942 * Enable/Disable the Transmitter and/or Receiver. 2943 */ 2944 2945static void stl_cd1400enablerxtx(struct stlport *portp, int rx, int tx) 2946{ 2947 unsigned char ccr; 2948 unsigned long flags; 2949 2950 pr_debug("stl_cd1400enablerxtx(portp=%p,rx=%d,tx=%d)\n", portp, rx, tx); 2951 2952 ccr = 0; 2953 2954 if (tx == 0) 2955 ccr |= CCR_TXDISABLE; 2956 else if (tx > 0) 2957 ccr |= CCR_TXENABLE; 2958 if (rx == 0) 2959 ccr |= CCR_RXDISABLE; 2960 else if (rx > 0) 2961 ccr |= CCR_RXENABLE; 2962 2963 spin_lock_irqsave(&brd_lock, flags); 2964 BRDENABLE(portp->brdnr, portp->pagenr); 2965 stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03)); 2966 stl_cd1400ccrwait(portp); 2967 stl_cd1400setreg(portp, CCR, ccr); 2968 stl_cd1400ccrwait(portp); 2969 BRDDISABLE(portp->brdnr); 2970 spin_unlock_irqrestore(&brd_lock, flags); 2971} 2972 2973/*****************************************************************************/ 2974 2975/* 2976 * Start/stop the Transmitter and/or Receiver. 2977 */ 2978 2979static void stl_cd1400startrxtx(struct stlport *portp, int rx, int tx) 2980{ 2981 unsigned char sreron, sreroff; 2982 unsigned long flags; 2983 2984 pr_debug("stl_cd1400startrxtx(portp=%p,rx=%d,tx=%d)\n", portp, rx, tx); 2985 2986 sreron = 0; 2987 sreroff = 0; 2988 if (tx == 0) 2989 sreroff |= (SRER_TXDATA | SRER_TXEMPTY); 2990 else if (tx == 1) 2991 sreron |= SRER_TXDATA; 2992 else if (tx >= 2) 2993 sreron |= SRER_TXEMPTY; 2994 if (rx == 0) 2995 sreroff |= SRER_RXDATA; 2996 else if (rx > 0) 2997 sreron |= SRER_RXDATA; 2998 2999 spin_lock_irqsave(&brd_lock, flags); 3000 BRDENABLE(portp->brdnr, portp->pagenr); 3001 stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03)); 3002 stl_cd1400setreg(portp, SRER, 3003 ((stl_cd1400getreg(portp, SRER) & ~sreroff) | sreron)); 3004 BRDDISABLE(portp->brdnr); 3005 if (tx > 0) 3006 set_bit(ASYI_TXBUSY, &portp->istate); 3007 spin_unlock_irqrestore(&brd_lock, flags); 3008} 3009 3010/*****************************************************************************/ 3011 3012/* 3013 * Disable all interrupts from this port. 3014 */ 3015 3016static void stl_cd1400disableintrs(struct stlport *portp) 3017{ 3018 unsigned long flags; 3019 3020 pr_debug("stl_cd1400disableintrs(portp=%p)\n", portp); 3021 3022 spin_lock_irqsave(&brd_lock, flags); 3023 BRDENABLE(portp->brdnr, portp->pagenr); 3024 stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03)); 3025 stl_cd1400setreg(portp, SRER, 0); 3026 BRDDISABLE(portp->brdnr); 3027 spin_unlock_irqrestore(&brd_lock, flags); 3028} 3029 3030/*****************************************************************************/ 3031 3032static void stl_cd1400sendbreak(struct stlport *portp, int len) 3033{ 3034 unsigned long flags; 3035 3036 pr_debug("stl_cd1400sendbreak(portp=%p,len=%d)\n", portp, len); 3037 3038 spin_lock_irqsave(&brd_lock, flags); 3039 BRDENABLE(portp->brdnr, portp->pagenr); 3040 stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03)); 3041 stl_cd1400setreg(portp, SRER, 3042 ((stl_cd1400getreg(portp, SRER) & ~SRER_TXDATA) | 3043 SRER_TXEMPTY)); 3044 BRDDISABLE(portp->brdnr); 3045 portp->brklen = len; 3046 if (len == 1) 3047 portp->stats.txbreaks++; 3048 spin_unlock_irqrestore(&brd_lock, flags); 3049} 3050 3051/*****************************************************************************/ 3052 3053/* 3054 * Take flow control actions... 3055 */ 3056 3057static void stl_cd1400flowctrl(struct stlport *portp, int state) 3058{ 3059 struct tty_struct *tty; 3060 unsigned long flags; 3061 3062 pr_debug("stl_cd1400flowctrl(portp=%p,state=%x)\n", portp, state); 3063 3064 if (portp == NULL) 3065 return; 3066 tty = tty_port_tty_get(&portp->port); 3067 if (tty == NULL) 3068 return; 3069 3070 spin_lock_irqsave(&brd_lock, flags); 3071 BRDENABLE(portp->brdnr, portp->pagenr); 3072 stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03)); 3073 3074 if (state) { 3075 if (tty->termios->c_iflag & IXOFF) { 3076 stl_cd1400ccrwait(portp); 3077 stl_cd1400setreg(portp, CCR, CCR_SENDSCHR1); 3078 portp->stats.rxxon++; 3079 stl_cd1400ccrwait(portp); 3080 } 3081/* 3082 * Question: should we return RTS to what it was before? It may 3083 * have been set by an ioctl... Suppose not, since if you have 3084 * hardware flow control set then it is pretty silly to go and 3085 * set the RTS line by hand. 3086 */ 3087 if (tty->termios->c_cflag & CRTSCTS) { 3088 stl_cd1400setreg(portp, MCOR1, 3089 (stl_cd1400getreg(portp, MCOR1) | 3090 FIFO_RTSTHRESHOLD)); 3091 stl_cd1400setreg(portp, MSVR2, MSVR2_RTS); 3092 portp->stats.rxrtson++; 3093 } 3094 } else { 3095 if (tty->termios->c_iflag & IXOFF) { 3096 stl_cd1400ccrwait(portp); 3097 stl_cd1400setreg(portp, CCR, CCR_SENDSCHR2); 3098 portp->stats.rxxoff++; 3099 stl_cd1400ccrwait(portp); 3100 } 3101 if (tty->termios->c_cflag & CRTSCTS) { 3102 stl_cd1400setreg(portp, MCOR1, 3103 (stl_cd1400getreg(portp, MCOR1) & 0xf0)); 3104 stl_cd1400setreg(portp, MSVR2, 0); 3105 portp->stats.rxrtsoff++; 3106 } 3107 } 3108 3109 BRDDISABLE(portp->brdnr); 3110 spin_unlock_irqrestore(&brd_lock, flags); 3111 tty_kref_put(tty); 3112} 3113 3114/*****************************************************************************/ 3115 3116/* 3117 * Send a flow control character... 3118 */ 3119 3120static void stl_cd1400sendflow(struct stlport *portp, int state) 3121{ 3122 struct tty_struct *tty; 3123 unsigned long flags; 3124 3125 pr_debug("stl_cd1400sendflow(portp=%p,state=%x)\n", portp, state); 3126 3127 if (portp == NULL) 3128 return; 3129 tty = tty_port_tty_get(&portp->port); 3130 if (tty == NULL) 3131 return; 3132 3133 spin_lock_irqsave(&brd_lock, flags); 3134 BRDENABLE(portp->brdnr, portp->pagenr); 3135 stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03)); 3136 if (state) { 3137 stl_cd1400ccrwait(portp); 3138 stl_cd1400setreg(portp, CCR, CCR_SENDSCHR1); 3139 portp->stats.rxxon++; 3140 stl_cd1400ccrwait(portp); 3141 } else { 3142 stl_cd1400ccrwait(portp); 3143 stl_cd1400setreg(portp, CCR, CCR_SENDSCHR2); 3144 portp->stats.rxxoff++; 3145 stl_cd1400ccrwait(portp); 3146 } 3147 BRDDISABLE(portp->brdnr); 3148 spin_unlock_irqrestore(&brd_lock, flags); 3149 tty_kref_put(tty); 3150} 3151 3152/*****************************************************************************/ 3153 3154static void stl_cd1400flush(struct stlport *portp) 3155{ 3156 unsigned long flags; 3157 3158 pr_debug("stl_cd1400flush(portp=%p)\n", portp); 3159 3160 if (portp == NULL) 3161 return; 3162 3163 spin_lock_irqsave(&brd_lock, flags); 3164 BRDENABLE(portp->brdnr, portp->pagenr); 3165 stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03)); 3166 stl_cd1400ccrwait(portp); 3167 stl_cd1400setreg(portp, CCR, CCR_TXFLUSHFIFO); 3168 stl_cd1400ccrwait(portp); 3169 portp->tx.tail = portp->tx.head; 3170 BRDDISABLE(portp->brdnr); 3171 spin_unlock_irqrestore(&brd_lock, flags); 3172} 3173 3174/*****************************************************************************/ 3175 3176/* 3177 * Return the current state of data flow on this port. This is only 3178 * really interresting when determining if data has fully completed 3179 * transmission or not... This is easy for the cd1400, it accurately 3180 * maintains the busy port flag. 3181 */ 3182 3183static int stl_cd1400datastate(struct stlport *portp) 3184{ 3185 pr_debug("stl_cd1400datastate(portp=%p)\n", portp); 3186 3187 if (portp == NULL) 3188 return 0; 3189 3190 return test_bit(ASYI_TXBUSY, &portp->istate) ? 1 : 0; 3191} 3192 3193/*****************************************************************************/ 3194 3195/* 3196 * Interrupt service routine for cd1400 EasyIO boards. 3197 */ 3198 3199static void stl_cd1400eiointr(struct stlpanel *panelp, unsigned int iobase) 3200{ 3201 unsigned char svrtype; 3202 3203 pr_debug("stl_cd1400eiointr(panelp=%p,iobase=%x)\n", panelp, iobase); 3204 3205 spin_lock(&brd_lock); 3206 outb(SVRR, iobase); 3207 svrtype = inb(iobase + EREG_DATA); 3208 if (panelp->nrports > 4) { 3209 outb((SVRR + 0x80), iobase); 3210 svrtype |= inb(iobase + EREG_DATA); 3211 } 3212 3213 if (svrtype & SVRR_RX) 3214 stl_cd1400rxisr(panelp, iobase); 3215 else if (svrtype & SVRR_TX) 3216 stl_cd1400txisr(panelp, iobase); 3217 else if (svrtype & SVRR_MDM) 3218 stl_cd1400mdmisr(panelp, iobase); 3219 3220 spin_unlock(&brd_lock); 3221} 3222 3223/*****************************************************************************/ 3224 3225/* 3226 * Interrupt service routine for cd1400 panels. 3227 */ 3228 3229static void stl_cd1400echintr(struct stlpanel *panelp, unsigned int iobase) 3230{ 3231 unsigned char svrtype; 3232 3233 pr_debug("stl_cd1400echintr(panelp=%p,iobase=%x)\n", panelp, iobase); 3234 3235 outb(SVRR, iobase); 3236 svrtype = inb(iobase + EREG_DATA); 3237 outb((SVRR + 0x80), iobase); 3238 svrtype |= inb(iobase + EREG_DATA); 3239 if (svrtype & SVRR_RX) 3240 stl_cd1400rxisr(panelp, iobase); 3241 else if (svrtype & SVRR_TX) 3242 stl_cd1400txisr(panelp, iobase); 3243 else if (svrtype & SVRR_MDM) 3244 stl_cd1400mdmisr(panelp, iobase); 3245} 3246 3247 3248/*****************************************************************************/ 3249 3250/* 3251 * Unfortunately we need to handle breaks in the TX data stream, since 3252 * this is the only way to generate them on the cd1400. 3253 */ 3254 3255static int stl_cd1400breakisr(struct stlport *portp, int ioaddr) 3256{ 3257 if (portp->brklen == 1) { 3258 outb((COR2 + portp->uartaddr), ioaddr); 3259 outb((inb(ioaddr + EREG_DATA) | COR2_ETC), 3260 (ioaddr + EREG_DATA)); 3261 outb((TDR + portp->uartaddr), ioaddr); 3262 outb(ETC_CMD, (ioaddr + EREG_DATA)); 3263 outb(ETC_STARTBREAK, (ioaddr + EREG_DATA)); 3264 outb((SRER + portp->uartaddr), ioaddr); 3265 outb((inb(ioaddr + EREG_DATA) & ~(SRER_TXDATA | SRER_TXEMPTY)), 3266 (ioaddr + EREG_DATA)); 3267 return 1; 3268 } else if (portp->brklen > 1) { 3269 outb((TDR + portp->uartaddr), ioaddr); 3270 outb(ETC_CMD, (ioaddr + EREG_DATA)); 3271 outb(ETC_STOPBREAK, (ioaddr + EREG_DATA)); 3272 portp->brklen = -1; 3273 return 1; 3274 } else { 3275 outb((COR2 + portp->uartaddr), ioaddr); 3276 outb((inb(ioaddr + EREG_DATA) & ~COR2_ETC), 3277 (ioaddr + EREG_DATA)); 3278 portp->brklen = 0; 3279 } 3280 return 0; 3281} 3282 3283/*****************************************************************************/ 3284 3285/* 3286 * Transmit interrupt handler. This has gotta be fast! Handling TX 3287 * chars is pretty simple, stuff as many as possible from the TX buffer 3288 * into the cd1400 FIFO. Must also handle TX breaks here, since they 3289 * are embedded as commands in the data stream. Oh no, had to use a goto! 3290 * This could be optimized more, will do when I get time... 3291 * In practice it is possible that interrupts are enabled but that the 3292 * port has been hung up. Need to handle not having any TX buffer here, 3293 * this is done by using the side effect that head and tail will also 3294 * be NULL if the buffer has been freed. 3295 */ 3296 3297static void stl_cd1400txisr(struct stlpanel *panelp, int ioaddr) 3298{ 3299 struct stlport *portp; 3300 int len, stlen; 3301 char *head, *tail; 3302 unsigned char ioack, srer; 3303 struct tty_struct *tty; 3304 3305 pr_debug("stl_cd1400txisr(panelp=%p,ioaddr=%x)\n", panelp, ioaddr); 3306 3307 ioack = inb(ioaddr + EREG_TXACK); 3308 if (((ioack & panelp->ackmask) != 0) || 3309 ((ioack & ACK_TYPMASK) != ACK_TYPTX)) { 3310 printk("STALLION: bad TX interrupt ack value=%x\n", ioack); 3311 return; 3312 } 3313 portp = panelp->ports[(ioack >> 3)]; 3314 3315/* 3316 * Unfortunately we need to handle breaks in the data stream, since 3317 * this is the only way to generate them on the cd1400. Do it now if 3318 * a break is to be sent. 3319 */ 3320 if (portp->brklen != 0) 3321 if (stl_cd1400breakisr(portp, ioaddr)) 3322 goto stl_txalldone; 3323 3324 head = portp->tx.head; 3325 tail = portp->tx.tail; 3326 len = (head >= tail) ? (head - tail) : (STL_TXBUFSIZE - (tail - head)); 3327 if ((len == 0) || ((len < STL_TXBUFLOW) && 3328 (test_bit(ASYI_TXLOW, &portp->istate) == 0))) { 3329 set_bit(ASYI_TXLOW, &portp->istate); 3330 tty = tty_port_tty_get(&portp->port); 3331 if (tty) { 3332 tty_wakeup(tty); 3333 tty_kref_put(tty); 3334 } 3335 } 3336 3337 if (len == 0) { 3338 outb((SRER + portp->uartaddr), ioaddr); 3339 srer = inb(ioaddr + EREG_DATA); 3340 if (srer & SRER_TXDATA) { 3341 srer = (srer & ~SRER_TXDATA) | SRER_TXEMPTY; 3342 } else { 3343 srer &= ~(SRER_TXDATA | SRER_TXEMPTY); 3344 clear_bit(ASYI_TXBUSY, &portp->istate); 3345 } 3346 outb(srer, (ioaddr + EREG_DATA)); 3347 } else { 3348 len = min(len, CD1400_TXFIFOSIZE); 3349 portp->stats.txtotal += len; 3350 stlen = min_t(unsigned int, len, 3351 (portp->tx.buf + STL_TXBUFSIZE) - tail); 3352 outb((TDR + portp->uartaddr), ioaddr); 3353 outsb((ioaddr + EREG_DATA), tail, stlen); 3354 len -= stlen; 3355 tail += stlen; 3356 if (tail >= (portp->tx.buf + STL_TXBUFSIZE)) 3357 tail = portp->tx.buf; 3358 if (len > 0) { 3359 outsb((ioaddr + EREG_DATA), tail, len); 3360 tail += len; 3361 } 3362 portp->tx.tail = tail; 3363 } 3364 3365stl_txalldone: 3366 outb((EOSRR + portp->uartaddr), ioaddr); 3367 outb(0, (ioaddr + EREG_DATA)); 3368} 3369 3370/*****************************************************************************/ 3371 3372/* 3373 * Receive character interrupt handler. Determine if we have good chars 3374 * or bad chars and then process appropriately. Good chars are easy 3375 * just shove the lot into the RX buffer and set all status byte to 0. 3376 * If a bad RX char then process as required. This routine needs to be 3377 * fast! In practice it is possible that we get an interrupt on a port 3378 * that is closed. This can happen on hangups - since they completely 3379 * shutdown a port not in user context. Need to handle this case. 3380 */ 3381 3382static void stl_cd1400rxisr(struct stlpanel *panelp, int ioaddr) 3383{ 3384 struct stlport *portp; 3385 struct tty_struct *tty; 3386 unsigned int ioack, len, buflen; 3387 unsigned char status; 3388 char ch; 3389 3390 pr_debug("stl_cd1400rxisr(panelp=%p,ioaddr=%x)\n", panelp, ioaddr); 3391 3392 ioack = inb(ioaddr + EREG_RXACK); 3393 if ((ioack & panelp->ackmask) != 0) { 3394 printk("STALLION: bad RX interrupt ack value=%x\n", ioack); 3395 return; 3396 } 3397 portp = panelp->ports[(ioack >> 3)]; 3398 tty = tty_port_tty_get(&portp->port); 3399 3400 if ((ioack & ACK_TYPMASK) == ACK_TYPRXGOOD) { 3401 outb((RDCR + portp->uartaddr), ioaddr); 3402 len = inb(ioaddr + EREG_DATA); 3403 if (tty == NULL || (buflen = tty_buffer_request_room(tty, len)) == 0) { 3404 len = min_t(unsigned int, len, sizeof(stl_unwanted)); 3405 outb((RDSR + portp->uartaddr), ioaddr); 3406 insb((ioaddr + EREG_DATA), &stl_unwanted[0], len); 3407 portp->stats.rxlost += len; 3408 portp->stats.rxtotal += len; 3409 } else { 3410 len = min(len, buflen); 3411 if (len > 0) { 3412 unsigned char *ptr; 3413 outb((RDSR + portp->uartaddr), ioaddr); 3414 tty_prepare_flip_string(tty, &ptr, len); 3415 insb((ioaddr + EREG_DATA), ptr, len); 3416 tty_schedule_flip(tty); 3417 portp->stats.rxtotal += len; 3418 } 3419 } 3420 } else if ((ioack & ACK_TYPMASK) == ACK_TYPRXBAD) { 3421 outb((RDSR + portp->uartaddr), ioaddr); 3422 status = inb(ioaddr + EREG_DATA); 3423 ch = inb(ioaddr + EREG_DATA); 3424 if (status & ST_PARITY) 3425 portp->stats.rxparity++; 3426 if (status & ST_FRAMING) 3427 portp->stats.rxframing++; 3428 if (status & ST_OVERRUN) 3429 portp->stats.rxoverrun++; 3430 if (status & ST_BREAK) 3431 portp->stats.rxbreaks++; 3432 if (status & ST_SCHARMASK) { 3433 if ((status & ST_SCHARMASK) == ST_SCHAR1) 3434 portp->stats.txxon++; 3435 if ((status & ST_SCHARMASK) == ST_SCHAR2) 3436 portp->stats.txxoff++; 3437 goto stl_rxalldone; 3438 } 3439 if (tty != NULL && (portp->rxignoremsk & status) == 0) { 3440 if (portp->rxmarkmsk & status) { 3441 if (status & ST_BREAK) { 3442 status = TTY_BREAK; 3443 if (portp->port.flags & ASYNC_SAK) { 3444 do_SAK(tty); 3445 BRDENABLE(portp->brdnr, portp->pagenr); 3446 } 3447 } else if (status & ST_PARITY) 3448 status = TTY_PARITY; 3449 else if (status & ST_FRAMING) 3450 status = TTY_FRAME; 3451 else if(status & ST_OVERRUN) 3452 status = TTY_OVERRUN; 3453 else 3454 status = 0; 3455 } else 3456 status = 0; 3457 tty_insert_flip_char(tty, ch, status); 3458 tty_schedule_flip(tty); 3459 } 3460 } else { 3461 printk("STALLION: bad RX interrupt ack value=%x\n", ioack); 3462 tty_kref_put(tty); 3463 return; 3464 } 3465 3466stl_rxalldone: 3467 tty_kref_put(tty); 3468 outb((EOSRR + portp->uartaddr), ioaddr); 3469 outb(0, (ioaddr + EREG_DATA)); 3470} 3471 3472/*****************************************************************************/ 3473 3474/* 3475 * Modem interrupt handler. The is called when the modem signal line 3476 * (DCD) has changed state. Leave most of the work to the off-level 3477 * processing routine. 3478 */ 3479 3480static void stl_cd1400mdmisr(struct stlpanel *panelp, int ioaddr) 3481{ 3482 struct stlport *portp; 3483 unsigned int ioack; 3484 unsigned char misr; 3485 3486 pr_debug("stl_cd1400mdmisr(panelp=%p)\n", panelp); 3487 3488 ioack = inb(ioaddr + EREG_MDACK); 3489 if (((ioack & panelp->ackmask) != 0) || 3490 ((ioack & ACK_TYPMASK) != ACK_TYPMDM)) { 3491 printk("STALLION: bad MODEM interrupt ack value=%x\n", ioack); 3492 return; 3493 } 3494 portp = panelp->ports[(ioack >> 3)]; 3495 3496 outb((MISR + portp->uartaddr), ioaddr); 3497 misr = inb(ioaddr + EREG_DATA); 3498 if (misr & MISR_DCD) { 3499 stl_cd_change(portp); 3500 portp->stats.modem++; 3501 } 3502 3503 outb((EOSRR + portp->uartaddr), ioaddr); 3504 outb(0, (ioaddr + EREG_DATA)); 3505} 3506 3507/*****************************************************************************/ 3508/* SC26198 HARDWARE FUNCTIONS */ 3509/*****************************************************************************/ 3510 3511/* 3512 * These functions get/set/update the registers of the sc26198 UARTs. 3513 * Access to the sc26198 registers is via an address/data io port pair. 3514 * (Maybe should make this inline...) 3515 */ 3516 3517static int stl_sc26198getreg(struct stlport *portp, int regnr) 3518{ 3519 outb((regnr | portp->uartaddr), (portp->ioaddr + XP_ADDR)); 3520 return inb(portp->ioaddr + XP_DATA); 3521} 3522 3523static void stl_sc26198setreg(struct stlport *portp, int regnr, int value) 3524{ 3525 outb((regnr | portp->uartaddr), (portp->ioaddr + XP_ADDR)); 3526 outb(value, (portp->ioaddr + XP_DATA)); 3527} 3528 3529static int stl_sc26198updatereg(struct stlport *portp, int regnr, int value) 3530{ 3531 outb((regnr | portp->uartaddr), (portp->ioaddr + XP_ADDR)); 3532 if (inb(portp->ioaddr + XP_DATA) != value) { 3533 outb(value, (portp->ioaddr + XP_DATA)); 3534 return 1; 3535 } 3536 return 0; 3537} 3538 3539/*****************************************************************************/ 3540 3541/* 3542 * Functions to get and set the sc26198 global registers. 3543 */ 3544 3545static int stl_sc26198getglobreg(struct stlport *portp, int regnr) 3546{ 3547 outb(regnr, (portp->ioaddr + XP_ADDR)); 3548 return inb(portp->ioaddr + XP_DATA); 3549} 3550 3551 3552/*****************************************************************************/ 3553 3554/* 3555 * Inbitialize the UARTs in a panel. We don't care what sort of board 3556 * these ports are on - since the port io registers are almost 3557 * identical when dealing with ports. 3558 */ 3559 3560static int stl_sc26198panelinit(struct stlbrd *brdp, struct stlpanel *panelp) 3561{ 3562 int chipmask, i; 3563 int nrchips, ioaddr; 3564 3565 pr_debug("stl_sc26198panelinit(brdp=%p,panelp=%p)\n", brdp, panelp); 3566 3567 BRDENABLE(panelp->brdnr, panelp->pagenr); 3568 3569/* 3570 * Check that each chip is present and started up OK. 3571 */ 3572 chipmask = 0; 3573 nrchips = (panelp->nrports + 4) / SC26198_PORTS; 3574 if (brdp->brdtype == BRD_ECHPCI) 3575 outb(panelp->pagenr, brdp->ioctrl); 3576 3577 for (i = 0; i < nrchips; i++) { 3578 ioaddr = panelp->iobase + (i * 4); 3579 outb(SCCR, (ioaddr + XP_ADDR)); 3580 outb(CR_RESETALL, (ioaddr + XP_DATA)); 3581 outb(TSTR, (ioaddr + XP_ADDR)); 3582 if (inb(ioaddr + XP_DATA) != 0) { 3583 printk("STALLION: sc26198 not responding, " 3584 "brd=%d panel=%d chip=%d\n", 3585 panelp->brdnr, panelp->panelnr, i); 3586 continue; 3587 } 3588 chipmask |= (0x1 << i); 3589 outb(GCCR, (ioaddr + XP_ADDR)); 3590 outb(GCCR_IVRTYPCHANACK, (ioaddr + XP_DATA)); 3591 outb(WDTRCR, (ioaddr + XP_ADDR)); 3592 outb(0xff, (ioaddr + XP_DATA)); 3593 } 3594 3595 BRDDISABLE(panelp->brdnr); 3596 return chipmask; 3597} 3598 3599/*****************************************************************************/ 3600 3601/* 3602 * Initialize hardware specific port registers. 3603 */ 3604 3605static void stl_sc26198portinit(struct stlbrd *brdp, struct stlpanel *panelp, struct stlport *portp) 3606{ 3607 pr_debug("stl_sc26198portinit(brdp=%p,panelp=%p,portp=%p)\n", brdp, 3608 panelp, portp); 3609 3610 if ((brdp == NULL) || (panelp == NULL) || 3611 (portp == NULL)) 3612 return; 3613 3614 portp->ioaddr = panelp->iobase + ((portp->portnr < 8) ? 0 : 4); 3615 portp->uartaddr = (portp->portnr & 0x07) << 4; 3616 portp->pagenr = panelp->pagenr; 3617 portp->hwid = 0x1; 3618 3619 BRDENABLE(portp->brdnr, portp->pagenr); 3620 stl_sc26198setreg(portp, IOPCR, IOPCR_SETSIGS); 3621 BRDDISABLE(portp->brdnr); 3622} 3623 3624/*****************************************************************************/ 3625 3626/* 3627 * Set up the sc26198 registers for a port based on the termios port 3628 * settings. 3629 */ 3630 3631static void stl_sc26198setport(struct stlport *portp, struct ktermios *tiosp) 3632{ 3633 struct stlbrd *brdp; 3634 unsigned long flags; 3635 unsigned int baudrate; 3636 unsigned char mr0, mr1, mr2, clk; 3637 unsigned char imron, imroff, iopr, ipr; 3638 3639 mr0 = 0; 3640 mr1 = 0; 3641 mr2 = 0; 3642 clk = 0; 3643 iopr = 0; 3644 imron = 0; 3645 imroff = 0; 3646 3647 brdp = stl_brds[portp->brdnr]; 3648 if (brdp == NULL) 3649 return; 3650 3651/* 3652 * Set up the RX char ignore mask with those RX error types we 3653 * can ignore. 3654 */ 3655 portp->rxignoremsk = 0; 3656 if (tiosp->c_iflag & IGNPAR) 3657 portp->rxignoremsk |= (SR_RXPARITY | SR_RXFRAMING | 3658 SR_RXOVERRUN); 3659 if (tiosp->c_iflag & IGNBRK) 3660 portp->rxignoremsk |= SR_RXBREAK; 3661 3662 portp->rxmarkmsk = SR_RXOVERRUN; 3663 if (tiosp->c_iflag & (INPCK | PARMRK)) 3664 portp->rxmarkmsk |= (SR_RXPARITY | SR_RXFRAMING); 3665 if (tiosp->c_iflag & BRKINT) 3666 portp->rxmarkmsk |= SR_RXBREAK; 3667 3668/* 3669 * Go through the char size, parity and stop bits and set all the 3670 * option register appropriately. 3671 */ 3672 switch (tiosp->c_cflag & CSIZE) { 3673 case CS5: 3674 mr1 |= MR1_CS5; 3675 break; 3676 case CS6: 3677 mr1 |= MR1_CS6; 3678 break; 3679 case CS7: 3680 mr1 |= MR1_CS7; 3681 break; 3682 default: 3683 mr1 |= MR1_CS8; 3684 break; 3685 } 3686 3687 if (tiosp->c_cflag & CSTOPB) 3688 mr2 |= MR2_STOP2; 3689 else 3690 mr2 |= MR2_STOP1; 3691 3692 if (tiosp->c_cflag & PARENB) { 3693 if (tiosp->c_cflag & PARODD) 3694 mr1 |= (MR1_PARENB | MR1_PARODD); 3695 else 3696 mr1 |= (MR1_PARENB | MR1_PAREVEN); 3697 } else 3698 mr1 |= MR1_PARNONE; 3699 3700 mr1 |= MR1_ERRBLOCK; 3701 3702/* 3703 * Set the RX FIFO threshold at 8 chars. This gives a bit of breathing 3704 * space for hardware flow control and the like. This should be set to 3705 * VMIN. 3706 */ 3707 mr2 |= MR2_RXFIFOHALF; 3708 3709/* 3710 * Calculate the baud rate timers. For now we will just assume that 3711 * the input and output baud are the same. The sc26198 has a fixed 3712 * baud rate table, so only discrete baud rates possible. 3713 */ 3714 baudrate = tiosp->c_cflag & CBAUD; 3715 if (baudrate & CBAUDEX) { 3716 baudrate &= ~CBAUDEX; 3717 if ((baudrate < 1) || (baudrate > 4)) 3718 tiosp->c_cflag &= ~CBAUDEX; 3719 else 3720 baudrate += 15; 3721 } 3722 baudrate = stl_baudrates[baudrate]; 3723 if ((tiosp->c_cflag & CBAUD) == B38400) { 3724 if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI) 3725 baudrate = 57600; 3726 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI) 3727 baudrate = 115200; 3728 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI) 3729 baudrate = 230400; 3730 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP) 3731 baudrate = 460800; 3732 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST) 3733 baudrate = (portp->baud_base / portp->custom_divisor); 3734 } 3735 if (baudrate > STL_SC26198MAXBAUD) 3736 baudrate = STL_SC26198MAXBAUD; 3737 3738 if (baudrate > 0) 3739 for (clk = 0; clk < SC26198_NRBAUDS; clk++) 3740 if (baudrate <= sc26198_baudtable[clk]) 3741 break; 3742 3743/* 3744 * Check what form of modem signaling is required and set it up. 3745 */ 3746 if (tiosp->c_cflag & CLOCAL) { 3747 portp->port.flags &= ~ASYNC_CHECK_CD; 3748 } else { 3749 iopr |= IOPR_DCDCOS; 3750 imron |= IR_IOPORT; 3751 portp->port.flags |= ASYNC_CHECK_CD; 3752 } 3753 3754/* 3755 * Setup sc26198 enhanced modes if we can. In particular we want to 3756 * handle as much of the flow control as possible automatically. As 3757 * well as saving a few CPU cycles it will also greatly improve flow 3758 * control reliability. 3759 */ 3760 if (tiosp->c_iflag & IXON) { 3761 mr0 |= MR0_SWFTX | MR0_SWFT; 3762 imron |= IR_XONXOFF; 3763 } else 3764 imroff |= IR_XONXOFF; 3765 3766 if (tiosp->c_iflag & IXOFF) 3767 mr0 |= MR0_SWFRX; 3768 3769 if (tiosp->c_cflag & CRTSCTS) { 3770 mr2 |= MR2_AUTOCTS; 3771 mr1 |= MR1_AUTORTS; 3772 } 3773 3774/* 3775 * All sc26198 register values calculated so go through and set 3776 * them all up. 3777 */ 3778 3779 pr_debug("SETPORT: portnr=%d panelnr=%d brdnr=%d\n", 3780 portp->portnr, portp->panelnr, portp->brdnr); 3781 pr_debug(" mr0=%x mr1=%x mr2=%x clk=%x\n", mr0, mr1, mr2, clk); 3782 pr_debug(" iopr=%x imron=%x imroff=%x\n", iopr, imron, imroff); 3783 pr_debug(" schr1=%x schr2=%x schr3=%x schr4=%x\n", 3784 tiosp->c_cc[VSTART], tiosp->c_cc[VSTOP], 3785 tiosp->c_cc[VSTART], tiosp->c_cc[VSTOP]); 3786 3787 spin_lock_irqsave(&brd_lock, flags); 3788 BRDENABLE(portp->brdnr, portp->pagenr); 3789 stl_sc26198setreg(portp, IMR, 0); 3790 stl_sc26198updatereg(portp, MR0, mr0); 3791 stl_sc26198updatereg(portp, MR1, mr1); 3792 stl_sc26198setreg(portp, SCCR, CR_RXERRBLOCK); 3793 stl_sc26198updatereg(portp, MR2, mr2); 3794 stl_sc26198updatereg(portp, IOPIOR, 3795 ((stl_sc26198getreg(portp, IOPIOR) & ~IPR_CHANGEMASK) | iopr)); 3796 3797 if (baudrate > 0) { 3798 stl_sc26198setreg(portp, TXCSR, clk); 3799 stl_sc26198setreg(portp, RXCSR, clk); 3800 } 3801 3802 stl_sc26198setreg(portp, XONCR, tiosp->c_cc[VSTART]); 3803 stl_sc26198setreg(portp, XOFFCR, tiosp->c_cc[VSTOP]); 3804 3805 ipr = stl_sc26198getreg(portp, IPR); 3806 if (ipr & IPR_DCD) 3807 portp->sigs &= ~TIOCM_CD; 3808 else 3809 portp->sigs |= TIOCM_CD; 3810 3811 portp->imr = (portp->imr & ~imroff) | imron; 3812 stl_sc26198setreg(portp, IMR, portp->imr); 3813 BRDDISABLE(portp->brdnr); 3814 spin_unlock_irqrestore(&brd_lock, flags); 3815} 3816 3817/*****************************************************************************/ 3818 3819/* 3820 * Set the state of the DTR and RTS signals. 3821 */ 3822 3823static void stl_sc26198setsignals(struct stlport *portp, int dtr, int rts) 3824{ 3825 unsigned char iopioron, iopioroff; 3826 unsigned long flags; 3827 3828 pr_debug("stl_sc26198setsignals(portp=%p,dtr=%d,rts=%d)\n", portp, 3829 dtr, rts); 3830 3831 iopioron = 0; 3832 iopioroff = 0; 3833 if (dtr == 0) 3834 iopioroff |= IPR_DTR; 3835 else if (dtr > 0) 3836 iopioron |= IPR_DTR; 3837 if (rts == 0) 3838 iopioroff |= IPR_RTS; 3839 else if (rts > 0) 3840 iopioron |= IPR_RTS; 3841 3842 spin_lock_irqsave(&brd_lock, flags); 3843 BRDENABLE(portp->brdnr, portp->pagenr); 3844 stl_sc26198setreg(portp, IOPIOR, 3845 ((stl_sc26198getreg(portp, IOPIOR) & ~iopioroff) | iopioron)); 3846 BRDDISABLE(portp->brdnr); 3847 spin_unlock_irqrestore(&brd_lock, flags); 3848} 3849 3850/*****************************************************************************/ 3851 3852/* 3853 * Return the state of the signals. 3854 */ 3855 3856static int stl_sc26198getsignals(struct stlport *portp) 3857{ 3858 unsigned char ipr; 3859 unsigned long flags; 3860 int sigs; 3861 3862 pr_debug("stl_sc26198getsignals(portp=%p)\n", portp); 3863 3864 spin_lock_irqsave(&brd_lock, flags); 3865 BRDENABLE(portp->brdnr, portp->pagenr); 3866 ipr = stl_sc26198getreg(portp, IPR); 3867 BRDDISABLE(portp->brdnr); 3868 spin_unlock_irqrestore(&brd_lock, flags); 3869 3870 sigs = 0; 3871 sigs |= (ipr & IPR_DCD) ? 0 : TIOCM_CD; 3872 sigs |= (ipr & IPR_CTS) ? 0 : TIOCM_CTS; 3873 sigs |= (ipr & IPR_DTR) ? 0: TIOCM_DTR; 3874 sigs |= (ipr & IPR_RTS) ? 0: TIOCM_RTS; 3875 sigs |= TIOCM_DSR; 3876 return sigs; 3877} 3878 3879/*****************************************************************************/ 3880 3881/* 3882 * Enable/Disable the Transmitter and/or Receiver. 3883 */ 3884 3885static void stl_sc26198enablerxtx(struct stlport *portp, int rx, int tx) 3886{ 3887 unsigned char ccr; 3888 unsigned long flags; 3889 3890 pr_debug("stl_sc26198enablerxtx(portp=%p,rx=%d,tx=%d)\n", portp, rx,tx); 3891 3892 ccr = portp->crenable; 3893 if (tx == 0) 3894 ccr &= ~CR_TXENABLE; 3895 else if (tx > 0) 3896 ccr |= CR_TXENABLE; 3897 if (rx == 0) 3898 ccr &= ~CR_RXENABLE; 3899 else if (rx > 0) 3900 ccr |= CR_RXENABLE; 3901 3902 spin_lock_irqsave(&brd_lock, flags); 3903 BRDENABLE(portp->brdnr, portp->pagenr); 3904 stl_sc26198setreg(portp, SCCR, ccr); 3905 BRDDISABLE(portp->brdnr); 3906 portp->crenable = ccr; 3907 spin_unlock_irqrestore(&brd_lock, flags); 3908} 3909 3910/*****************************************************************************/ 3911 3912/* 3913 * Start/stop the Transmitter and/or Receiver. 3914 */ 3915 3916static void stl_sc26198startrxtx(struct stlport *portp, int rx, int tx) 3917{ 3918 unsigned char imr; 3919 unsigned long flags; 3920 3921 pr_debug("stl_sc26198startrxtx(portp=%p,rx=%d,tx=%d)\n", portp, rx, tx); 3922 3923 imr = portp->imr; 3924 if (tx == 0) 3925 imr &= ~IR_TXRDY; 3926 else if (tx == 1) 3927 imr |= IR_TXRDY; 3928 if (rx == 0) 3929 imr &= ~(IR_RXRDY | IR_RXBREAK | IR_RXWATCHDOG); 3930 else if (rx > 0) 3931 imr |= IR_RXRDY | IR_RXBREAK | IR_RXWATCHDOG; 3932 3933 spin_lock_irqsave(&brd_lock, flags); 3934 BRDENABLE(portp->brdnr, portp->pagenr); 3935 stl_sc26198setreg(portp, IMR, imr); 3936 BRDDISABLE(portp->brdnr); 3937 portp->imr = imr; 3938 if (tx > 0) 3939 set_bit(ASYI_TXBUSY, &portp->istate); 3940 spin_unlock_irqrestore(&brd_lock, flags); 3941} 3942 3943/*****************************************************************************/ 3944 3945/* 3946 * Disable all interrupts from this port. 3947 */ 3948 3949static void stl_sc26198disableintrs(struct stlport *portp) 3950{ 3951 unsigned long flags; 3952 3953 pr_debug("stl_sc26198disableintrs(portp=%p)\n", portp); 3954 3955 spin_lock_irqsave(&brd_lock, flags); 3956 BRDENABLE(portp->brdnr, portp->pagenr); 3957 portp->imr = 0; 3958 stl_sc26198setreg(portp, IMR, 0); 3959 BRDDISABLE(portp->brdnr); 3960 spin_unlock_irqrestore(&brd_lock, flags); 3961} 3962 3963/*****************************************************************************/ 3964 3965static void stl_sc26198sendbreak(struct stlport *portp, int len) 3966{ 3967 unsigned long flags; 3968 3969 pr_debug("stl_sc26198sendbreak(portp=%p,len=%d)\n", portp, len); 3970 3971 spin_lock_irqsave(&brd_lock, flags); 3972 BRDENABLE(portp->brdnr, portp->pagenr); 3973 if (len == 1) { 3974 stl_sc26198setreg(portp, SCCR, CR_TXSTARTBREAK); 3975 portp->stats.txbreaks++; 3976 } else 3977 stl_sc26198setreg(portp, SCCR, CR_TXSTOPBREAK); 3978 3979 BRDDISABLE(portp->brdnr); 3980 spin_unlock_irqrestore(&brd_lock, flags); 3981} 3982 3983/*****************************************************************************/ 3984 3985/* 3986 * Take flow control actions... 3987 */ 3988 3989static void stl_sc26198flowctrl(struct stlport *portp, int state) 3990{ 3991 struct tty_struct *tty; 3992 unsigned long flags; 3993 unsigned char mr0; 3994 3995 pr_debug("stl_sc26198flowctrl(portp=%p,state=%x)\n", portp, state); 3996 3997 if (portp == NULL) 3998 return; 3999 tty = tty_port_tty_get(&portp->port); 4000 if (tty == NULL) 4001 return; 4002 4003 spin_lock_irqsave(&brd_lock, flags); 4004 BRDENABLE(portp->brdnr, portp->pagenr); 4005 4006 if (state) { 4007 if (tty->termios->c_iflag & IXOFF) { 4008 mr0 = stl_sc26198getreg(portp, MR0); 4009 stl_sc26198setreg(portp, MR0, (mr0 & ~MR0_SWFRXTX)); 4010 stl_sc26198setreg(portp, SCCR, CR_TXSENDXON); 4011 mr0 |= MR0_SWFRX; 4012 portp->stats.rxxon++; 4013 stl_sc26198wait(portp); 4014 stl_sc26198setreg(portp, MR0, mr0); 4015 } 4016/* 4017 * Question: should we return RTS to what it was before? It may 4018 * have been set by an ioctl... Suppose not, since if you have 4019 * hardware flow control set then it is pretty silly to go and 4020 * set the RTS line by hand. 4021 */ 4022 if (tty->termios->c_cflag & CRTSCTS) { 4023 stl_sc26198setreg(portp, MR1, 4024 (stl_sc26198getreg(portp, MR1) | MR1_AUTORTS)); 4025 stl_sc26198setreg(portp, IOPIOR, 4026 (stl_sc26198getreg(portp, IOPIOR) | IOPR_RTS)); 4027 portp->stats.rxrtson++; 4028 } 4029 } else { 4030 if (tty->termios->c_iflag & IXOFF) { 4031 mr0 = stl_sc26198getreg(portp, MR0); 4032 stl_sc26198setreg(portp, MR0, (mr0 & ~MR0_SWFRXTX)); 4033 stl_sc26198setreg(portp, SCCR, CR_TXSENDXOFF); 4034 mr0 &= ~MR0_SWFRX; 4035 portp->stats.rxxoff++; 4036 stl_sc26198wait(portp); 4037 stl_sc26198setreg(portp, MR0, mr0); 4038 } 4039 if (tty->termios->c_cflag & CRTSCTS) { 4040 stl_sc26198setreg(portp, MR1, 4041 (stl_sc26198getreg(portp, MR1) & ~MR1_AUTORTS)); 4042 stl_sc26198setreg(portp, IOPIOR, 4043 (stl_sc26198getreg(portp, IOPIOR) & ~IOPR_RTS)); 4044 portp->stats.rxrtsoff++; 4045 } 4046 } 4047 4048 BRDDISABLE(portp->brdnr); 4049 spin_unlock_irqrestore(&brd_lock, flags); 4050 tty_kref_put(tty); 4051} 4052 4053/*****************************************************************************/ 4054 4055/* 4056 * Send a flow control character. 4057 */ 4058 4059static void stl_sc26198sendflow(struct stlport *portp, int state) 4060{ 4061 struct tty_struct *tty; 4062 unsigned long flags; 4063 unsigned char mr0; 4064 4065 pr_debug("stl_sc26198sendflow(portp=%p,state=%x)\n", portp, state); 4066 4067 if (portp == NULL) 4068 return; 4069 tty = tty_port_tty_get(&portp->port); 4070 if (tty == NULL) 4071 return; 4072 4073 spin_lock_irqsave(&brd_lock, flags); 4074 BRDENABLE(portp->brdnr, portp->pagenr); 4075 if (state) { 4076 mr0 = stl_sc26198getreg(portp, MR0); 4077 stl_sc26198setreg(portp, MR0, (mr0 & ~MR0_SWFRXTX)); 4078 stl_sc26198setreg(portp, SCCR, CR_TXSENDXON); 4079 mr0 |= MR0_SWFRX; 4080 portp->stats.rxxon++; 4081 stl_sc26198wait(portp); 4082 stl_sc26198setreg(portp, MR0, mr0); 4083 } else { 4084 mr0 = stl_sc26198getreg(portp, MR0); 4085 stl_sc26198setreg(portp, MR0, (mr0 & ~MR0_SWFRXTX)); 4086 stl_sc26198setreg(portp, SCCR, CR_TXSENDXOFF); 4087 mr0 &= ~MR0_SWFRX; 4088 portp->stats.rxxoff++; 4089 stl_sc26198wait(portp); 4090 stl_sc26198setreg(portp, MR0, mr0); 4091 } 4092 BRDDISABLE(portp->brdnr); 4093 spin_unlock_irqrestore(&brd_lock, flags); 4094 tty_kref_put(tty); 4095} 4096 4097/*****************************************************************************/ 4098 4099static void stl_sc26198flush(struct stlport *portp) 4100{ 4101 unsigned long flags; 4102 4103 pr_debug("stl_sc26198flush(portp=%p)\n", portp); 4104 4105 if (portp == NULL) 4106 return; 4107 4108 spin_lock_irqsave(&brd_lock, flags); 4109 BRDENABLE(portp->brdnr, portp->pagenr); 4110 stl_sc26198setreg(portp, SCCR, CR_TXRESET); 4111 stl_sc26198setreg(portp, SCCR, portp->crenable); 4112 BRDDISABLE(portp->brdnr); 4113 portp->tx.tail = portp->tx.head; 4114 spin_unlock_irqrestore(&brd_lock, flags); 4115} 4116 4117/*****************************************************************************/ 4118 4119/* 4120 * Return the current state of data flow on this port. This is only 4121 * really interresting when determining if data has fully completed 4122 * transmission or not... The sc26198 interrupt scheme cannot 4123 * determine when all data has actually drained, so we need to 4124 * check the port statusy register to be sure. 4125 */ 4126 4127static int stl_sc26198datastate(struct stlport *portp) 4128{ 4129 unsigned long flags; 4130 unsigned char sr; 4131 4132 pr_debug("stl_sc26198datastate(portp=%p)\n", portp); 4133 4134 if (portp == NULL) 4135 return 0; 4136 if (test_bit(ASYI_TXBUSY, &portp->istate)) 4137 return 1; 4138 4139 spin_lock_irqsave(&brd_lock, flags); 4140 BRDENABLE(portp->brdnr, portp->pagenr); 4141 sr = stl_sc26198getreg(portp, SR); 4142 BRDDISABLE(portp->brdnr); 4143 spin_unlock_irqrestore(&brd_lock, flags); 4144 4145 return (sr & SR_TXEMPTY) ? 0 : 1; 4146} 4147 4148/*****************************************************************************/ 4149 4150/* 4151 * Delay for a small amount of time, to give the sc26198 a chance 4152 * to process a command... 4153 */ 4154 4155static void stl_sc26198wait(struct stlport *portp) 4156{ 4157 int i; 4158 4159 pr_debug("stl_sc26198wait(portp=%p)\n", portp); 4160 4161 if (portp == NULL) 4162 return; 4163 4164 for (i = 0; i < 20; i++) 4165 stl_sc26198getglobreg(portp, TSTR); 4166} 4167 4168/*****************************************************************************/ 4169 4170/* 4171 * If we are TX flow controlled and in IXANY mode then we may 4172 * need to unflow control here. We gotta do this because of the 4173 * automatic flow control modes of the sc26198. 4174 */ 4175 4176static void stl_sc26198txunflow(struct stlport *portp, struct tty_struct *tty) 4177{ 4178 unsigned char mr0; 4179 4180 mr0 = stl_sc26198getreg(portp, MR0); 4181 stl_sc26198setreg(portp, MR0, (mr0 & ~MR0_SWFRXTX)); 4182 stl_sc26198setreg(portp, SCCR, CR_HOSTXON); 4183 stl_sc26198wait(portp); 4184 stl_sc26198setreg(portp, MR0, mr0); 4185 clear_bit(ASYI_TXFLOWED, &portp->istate); 4186} 4187 4188/*****************************************************************************/ 4189 4190/* 4191 * Interrupt service routine for sc26198 panels. 4192 */ 4193 4194static void stl_sc26198intr(struct stlpanel *panelp, unsigned int iobase) 4195{ 4196 struct stlport *portp; 4197 unsigned int iack; 4198 4199 spin_lock(&brd_lock); 4200 4201 outb(0, (iobase + 1)); 4202 4203 iack = inb(iobase + XP_IACK); 4204 portp = panelp->ports[(iack & IVR_CHANMASK) + ((iobase & 0x4) << 1)]; 4205 4206 if (iack & IVR_RXDATA) 4207 stl_sc26198rxisr(portp, iack); 4208 else if (iack & IVR_TXDATA) 4209 stl_sc26198txisr(portp); 4210 else 4211 stl_sc26198otherisr(portp, iack); 4212 4213 spin_unlock(&brd_lock); 4214} 4215 4216/*****************************************************************************/ 4217 4218/* 4219 * Transmit interrupt handler. This has gotta be fast! Handling TX 4220 * chars is pretty simple, stuff as many as possible from the TX buffer 4221 * into the sc26198 FIFO. 4222 * In practice it is possible that interrupts are enabled but that the 4223 * port has been hung up. Need to handle not having any TX buffer here, 4224 * this is done by using the side effect that head and tail will also 4225 * be NULL if the buffer has been freed. 4226 */ 4227 4228static void stl_sc26198txisr(struct stlport *portp) 4229{ 4230 struct tty_struct *tty; 4231 unsigned int ioaddr; 4232 unsigned char mr0; 4233 int len, stlen; 4234 char *head, *tail; 4235 4236 pr_debug("stl_sc26198txisr(portp=%p)\n", portp); 4237 4238 ioaddr = portp->ioaddr; 4239 head = portp->tx.head; 4240 tail = portp->tx.tail; 4241 len = (head >= tail) ? (head - tail) : (STL_TXBUFSIZE - (tail - head)); 4242 if ((len == 0) || ((len < STL_TXBUFLOW) && 4243 (test_bit(ASYI_TXLOW, &portp->istate) == 0))) { 4244 set_bit(ASYI_TXLOW, &portp->istate); 4245 tty = tty_port_tty_get(&portp->port); 4246 if (tty) { 4247 tty_wakeup(tty); 4248 tty_kref_put(tty); 4249 } 4250 } 4251 4252 if (len == 0) { 4253 outb((MR0 | portp->uartaddr), (ioaddr + XP_ADDR)); 4254 mr0 = inb(ioaddr + XP_DATA); 4255 if ((mr0 & MR0_TXMASK) == MR0_TXEMPTY) { 4256 portp->imr &= ~IR_TXRDY; 4257 outb((IMR | portp->uartaddr), (ioaddr + XP_ADDR)); 4258 outb(portp->imr, (ioaddr + XP_DATA)); 4259 clear_bit(ASYI_TXBUSY, &portp->istate); 4260 } else { 4261 mr0 |= ((mr0 & ~MR0_TXMASK) | MR0_TXEMPTY); 4262 outb(mr0, (ioaddr + XP_DATA)); 4263 } 4264 } else { 4265 len = min(len, SC26198_TXFIFOSIZE); 4266 portp->stats.txtotal += len; 4267 stlen = min_t(unsigned int, len, 4268 (portp->tx.buf + STL_TXBUFSIZE) - tail); 4269 outb(GTXFIFO, (ioaddr + XP_ADDR)); 4270 outsb((ioaddr + XP_DATA), tail, stlen); 4271 len -= stlen; 4272 tail += stlen; 4273 if (tail >= (portp->tx.buf + STL_TXBUFSIZE)) 4274 tail = portp->tx.buf; 4275 if (len > 0) { 4276 outsb((ioaddr + XP_DATA), tail, len); 4277 tail += len; 4278 } 4279 portp->tx.tail = tail; 4280 } 4281} 4282 4283/*****************************************************************************/ 4284 4285/* 4286 * Receive character interrupt handler. Determine if we have good chars 4287 * or bad chars and then process appropriately. Good chars are easy 4288 * just shove the lot into the RX buffer and set all status byte to 0. 4289 * If a bad RX char then process as required. This routine needs to be 4290 * fast! In practice it is possible that we get an interrupt on a port 4291 * that is closed. This can happen on hangups - since they completely 4292 * shutdown a port not in user context. Need to handle this case. 4293 */ 4294 4295static void stl_sc26198rxisr(struct stlport *portp, unsigned int iack) 4296{ 4297 struct tty_struct *tty; 4298 unsigned int len, buflen, ioaddr; 4299 4300 pr_debug("stl_sc26198rxisr(portp=%p,iack=%x)\n", portp, iack); 4301 4302 tty = tty_port_tty_get(&portp->port); 4303 ioaddr = portp->ioaddr; 4304 outb(GIBCR, (ioaddr + XP_ADDR)); 4305 len = inb(ioaddr + XP_DATA) + 1; 4306 4307 if ((iack & IVR_TYPEMASK) == IVR_RXDATA) { 4308 if (tty == NULL || (buflen = tty_buffer_request_room(tty, len)) == 0) { 4309 len = min_t(unsigned int, len, sizeof(stl_unwanted)); 4310 outb(GRXFIFO, (ioaddr + XP_ADDR)); 4311 insb((ioaddr + XP_DATA), &stl_unwanted[0], len); 4312 portp->stats.rxlost += len; 4313 portp->stats.rxtotal += len; 4314 } else { 4315 len = min(len, buflen); 4316 if (len > 0) { 4317 unsigned char *ptr; 4318 outb(GRXFIFO, (ioaddr + XP_ADDR)); 4319 tty_prepare_flip_string(tty, &ptr, len); 4320 insb((ioaddr + XP_DATA), ptr, len); 4321 tty_schedule_flip(tty); 4322 portp->stats.rxtotal += len; 4323 } 4324 } 4325 } else { 4326 stl_sc26198rxbadchars(portp); 4327 } 4328 4329/* 4330 * If we are TX flow controlled and in IXANY mode then we may need 4331 * to unflow control here. We gotta do this because of the automatic 4332 * flow control modes of the sc26198. 4333 */ 4334 if (test_bit(ASYI_TXFLOWED, &portp->istate)) { 4335 if ((tty != NULL) && 4336 (tty->termios != NULL) && 4337 (tty->termios->c_iflag & IXANY)) { 4338 stl_sc26198txunflow(portp, tty); 4339 } 4340 } 4341 tty_kref_put(tty); 4342} 4343 4344/*****************************************************************************/ 4345 4346/* 4347 * Process an RX bad character. 4348 */ 4349 4350static void stl_sc26198rxbadch(struct stlport *portp, unsigned char status, char ch) 4351{ 4352 struct tty_struct *tty; 4353 unsigned int ioaddr; 4354 4355 tty = tty_port_tty_get(&portp->port); 4356 ioaddr = portp->ioaddr; 4357 4358 if (status & SR_RXPARITY) 4359 portp->stats.rxparity++; 4360 if (status & SR_RXFRAMING) 4361 portp->stats.rxframing++; 4362 if (status & SR_RXOVERRUN) 4363 portp->stats.rxoverrun++; 4364 if (status & SR_RXBREAK) 4365 portp->stats.rxbreaks++; 4366 4367 if ((tty != NULL) && 4368 ((portp->rxignoremsk & status) == 0)) { 4369 if (portp->rxmarkmsk & status) { 4370 if (status & SR_RXBREAK) { 4371 status = TTY_BREAK; 4372 if (portp->port.flags & ASYNC_SAK) { 4373 do_SAK(tty); 4374 BRDENABLE(portp->brdnr, portp->pagenr); 4375 } 4376 } else if (status & SR_RXPARITY) 4377 status = TTY_PARITY; 4378 else if (status & SR_RXFRAMING) 4379 status = TTY_FRAME; 4380 else if(status & SR_RXOVERRUN) 4381 status = TTY_OVERRUN; 4382 else 4383 status = 0; 4384 } else 4385 status = 0; 4386 4387 tty_insert_flip_char(tty, ch, status); 4388 tty_schedule_flip(tty); 4389 4390 if (status == 0) 4391 portp->stats.rxtotal++; 4392 } 4393 tty_kref_put(tty); 4394} 4395 4396/*****************************************************************************/ 4397 4398/* 4399 * Process all characters in the RX FIFO of the UART. Check all char 4400 * status bytes as well, and process as required. We need to check 4401 * all bytes in the FIFO, in case some more enter the FIFO while we 4402 * are here. To get the exact character error type we need to switch 4403 * into CHAR error mode (that is why we need to make sure we empty 4404 * the FIFO). 4405 */ 4406 4407static void stl_sc26198rxbadchars(struct stlport *portp) 4408{ 4409 unsigned char status, mr1; 4410 char ch; 4411 4412/* 4413 * To get the precise error type for each character we must switch 4414 * back into CHAR error mode. 4415 */ 4416 mr1 = stl_sc26198getreg(portp, MR1); 4417 stl_sc26198setreg(portp, MR1, (mr1 & ~MR1_ERRBLOCK)); 4418 4419 while ((status = stl_sc26198getreg(portp, SR)) & SR_RXRDY) { 4420 stl_sc26198setreg(portp, SCCR, CR_CLEARRXERR); 4421 ch = stl_sc26198getreg(portp, RXFIFO); 4422 stl_sc26198rxbadch(portp, status, ch); 4423 } 4424 4425/* 4426 * To get correct interrupt class we must switch back into BLOCK 4427 * error mode. 4428 */ 4429 stl_sc26198setreg(portp, MR1, mr1); 4430} 4431 4432/*****************************************************************************/ 4433 4434/* 4435 * Other interrupt handler. This includes modem signals, flow 4436 * control actions, etc. Most stuff is left to off-level interrupt 4437 * processing time. 4438 */ 4439 4440static void stl_sc26198otherisr(struct stlport *portp, unsigned int iack) 4441{ 4442 unsigned char cir, ipr, xisr; 4443 4444 pr_debug("stl_sc26198otherisr(portp=%p,iack=%x)\n", portp, iack); 4445 4446 cir = stl_sc26198getglobreg(portp, CIR); 4447 4448 switch (cir & CIR_SUBTYPEMASK) { 4449 case CIR_SUBCOS: 4450 ipr = stl_sc26198getreg(portp, IPR); 4451 if (ipr & IPR_DCDCHANGE) { 4452 stl_cd_change(portp); 4453 portp->stats.modem++; 4454 } 4455 break; 4456 case CIR_SUBXONXOFF: 4457 xisr = stl_sc26198getreg(portp, XISR); 4458 if (xisr & XISR_RXXONGOT) { 4459 set_bit(ASYI_TXFLOWED, &portp->istate); 4460 portp->stats.txxoff++; 4461 } 4462 if (xisr & XISR_RXXOFFGOT) { 4463 clear_bit(ASYI_TXFLOWED, &portp->istate); 4464 portp->stats.txxon++; 4465 } 4466 break; 4467 case CIR_SUBBREAK: 4468 stl_sc26198setreg(portp, SCCR, CR_BREAKRESET); 4469 stl_sc26198rxbadchars(portp); 4470 break; 4471 default: 4472 break; 4473 } 4474} 4475 4476static void stl_free_isabrds(void) 4477{ 4478 struct stlbrd *brdp; 4479 unsigned int i; 4480 4481 for (i = 0; i < stl_nrbrds; i++) { 4482 if ((brdp = stl_brds[i]) == NULL || (brdp->state & STL_PROBED)) 4483 continue; 4484 4485 free_irq(brdp->irq, brdp); 4486 4487 stl_cleanup_panels(brdp); 4488 4489 release_region(brdp->ioaddr1, brdp->iosize1); 4490 if (brdp->iosize2 > 0) 4491 release_region(brdp->ioaddr2, brdp->iosize2); 4492 4493 kfree(brdp); 4494 stl_brds[i] = NULL; 4495 } 4496} 4497 4498/* 4499 * Loadable module initialization stuff. 4500 */ 4501static int __init stallion_module_init(void) 4502{ 4503 struct stlbrd *brdp; 4504 struct stlconf conf; 4505 unsigned int i, j; 4506 int retval; 4507 4508 printk(KERN_INFO "%s: version %s\n", stl_drvtitle, stl_drvversion); 4509 4510 spin_lock_init(&stallion_lock); 4511 spin_lock_init(&brd_lock); 4512 4513 stl_serial = alloc_tty_driver(STL_MAXBRDS * STL_MAXPORTS); 4514 if (!stl_serial) { 4515 retval = -ENOMEM; 4516 goto err; 4517 } 4518 4519 stl_serial->owner = THIS_MODULE; 4520 stl_serial->driver_name = stl_drvname; 4521 stl_serial->name = "ttyE"; 4522 stl_serial->major = STL_SERIALMAJOR; 4523 stl_serial->minor_start = 0; 4524 stl_serial->type = TTY_DRIVER_TYPE_SERIAL; 4525 stl_serial->subtype = SERIAL_TYPE_NORMAL; 4526 stl_serial->init_termios = stl_deftermios; 4527 stl_serial->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; 4528 tty_set_operations(stl_serial, &stl_ops); 4529 4530 retval = tty_register_driver(stl_serial); 4531 if (retval) { 4532 printk("STALLION: failed to register serial driver\n"); 4533 goto err_frtty; 4534 } 4535 4536/* 4537 * Find any dynamically supported boards. That is via module load 4538 * line options. 4539 */ 4540 for (i = stl_nrbrds; i < stl_nargs; i++) { 4541 memset(&conf, 0, sizeof(conf)); 4542 if (stl_parsebrd(&conf, stl_brdsp[i]) == 0) 4543 continue; 4544 if ((brdp = stl_allocbrd()) == NULL) 4545 continue; 4546 brdp->brdnr = i; 4547 brdp->brdtype = conf.brdtype; 4548 brdp->ioaddr1 = conf.ioaddr1; 4549 brdp->ioaddr2 = conf.ioaddr2; 4550 brdp->irq = conf.irq; 4551 brdp->irqtype = conf.irqtype; 4552 stl_brds[brdp->brdnr] = brdp; 4553 if (stl_brdinit(brdp)) { 4554 stl_brds[brdp->brdnr] = NULL; 4555 kfree(brdp); 4556 } else { 4557 for (j = 0; j < brdp->nrports; j++) 4558 tty_register_device(stl_serial, 4559 brdp->brdnr * STL_MAXPORTS + j, NULL); 4560 stl_nrbrds = i + 1; 4561 } 4562 } 4563 4564 /* this has to be _after_ isa finding because of locking */ 4565 retval = pci_register_driver(&stl_pcidriver); 4566 if (retval && stl_nrbrds == 0) { 4567 printk(KERN_ERR "STALLION: can't register pci driver\n"); 4568 goto err_unrtty; 4569 } 4570 4571/* 4572 * Set up a character driver for per board stuff. This is mainly used 4573 * to do stats ioctls on the ports. 4574 */ 4575 if (register_chrdev(STL_SIOMEMMAJOR, "staliomem", &stl_fsiomem)) 4576 printk("STALLION: failed to register serial board device\n"); 4577 4578 stallion_class = class_create(THIS_MODULE, "staliomem"); 4579 if (IS_ERR(stallion_class)) 4580 printk("STALLION: failed to create class\n"); 4581 for (i = 0; i < 4; i++) 4582 device_create(stallion_class, NULL, MKDEV(STL_SIOMEMMAJOR, i), 4583 NULL, "staliomem%d", i); 4584 4585 return 0; 4586err_unrtty: 4587 tty_unregister_driver(stl_serial); 4588err_frtty: 4589 put_tty_driver(stl_serial); 4590err: 4591 return retval; 4592} 4593 4594static void __exit stallion_module_exit(void) 4595{ 4596 struct stlbrd *brdp; 4597 unsigned int i, j; 4598 4599 pr_debug("cleanup_module()\n"); 4600 4601 printk(KERN_INFO "Unloading %s: version %s\n", stl_drvtitle, 4602 stl_drvversion); 4603 4604/* 4605 * Free up all allocated resources used by the ports. This includes 4606 * memory and interrupts. As part of this process we will also do 4607 * a hangup on every open port - to try to flush out any processes 4608 * hanging onto ports. 4609 */ 4610 for (i = 0; i < stl_nrbrds; i++) { 4611 if ((brdp = stl_brds[i]) == NULL || (brdp->state & STL_PROBED)) 4612 continue; 4613 for (j = 0; j < brdp->nrports; j++) 4614 tty_unregister_device(stl_serial, 4615 brdp->brdnr * STL_MAXPORTS + j); 4616 } 4617 4618 for (i = 0; i < 4; i++) 4619 device_destroy(stallion_class, MKDEV(STL_SIOMEMMAJOR, i)); 4620 unregister_chrdev(STL_SIOMEMMAJOR, "staliomem"); 4621 class_destroy(stallion_class); 4622 4623 pci_unregister_driver(&stl_pcidriver); 4624 4625 stl_free_isabrds(); 4626 4627 tty_unregister_driver(stl_serial); 4628 put_tty_driver(stl_serial); 4629} 4630 4631module_init(stallion_module_init); 4632module_exit(stallion_module_exit); 4633 4634MODULE_AUTHOR("Greg Ungerer"); 4635MODULE_DESCRIPTION("Stallion Multiport Serial Driver"); 4636MODULE_LICENSE("GPL"); 4637