1/*****************************************************************************/ 2 3/* 4 * istallion.c -- stallion intelligent 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 */ 18 19/*****************************************************************************/ 20 21#include <linux/module.h> 22#include <linux/sched.h> 23#include <linux/slab.h> 24#include <linux/smp_lock.h> 25#include <linux/interrupt.h> 26#include <linux/tty.h> 27#include <linux/tty_flip.h> 28#include <linux/serial.h> 29#include <linux/seq_file.h> 30#include <linux/cdk.h> 31#include <linux/comstats.h> 32#include <linux/istallion.h> 33#include <linux/ioport.h> 34#include <linux/delay.h> 35#include <linux/init.h> 36#include <linux/device.h> 37#include <linux/wait.h> 38#include <linux/eisa.h> 39#include <linux/ctype.h> 40 41#include <asm/io.h> 42#include <asm/uaccess.h> 43 44#include <linux/pci.h> 45 46/*****************************************************************************/ 47 48/* 49 * Define different board types. Not all of the following board types 50 * are supported by this driver. But I will use the standard "assigned" 51 * board numbers. Currently supported boards are abbreviated as: 52 * ECP = EasyConnection 8/64, ONB = ONboard, BBY = Brumby and 53 * STAL = Stallion. 54 */ 55#define BRD_UNKNOWN 0 56#define BRD_STALLION 1 57#define BRD_BRUMBY4 2 58#define BRD_ONBOARD2 3 59#define BRD_ONBOARD 4 60#define BRD_ONBOARDE 7 61#define BRD_ECP 23 62#define BRD_ECPE 24 63#define BRD_ECPMC 25 64#define BRD_ECPPCI 29 65 66#define BRD_BRUMBY BRD_BRUMBY4 67 68/* 69 * Define a configuration structure to hold the board configuration. 70 * Need to set this up in the code (for now) with the boards that are 71 * to be configured into the system. This is what needs to be modified 72 * when adding/removing/modifying boards. Each line entry in the 73 * stli_brdconf[] array is a board. Each line contains io/irq/memory 74 * ranges for that board (as well as what type of board it is). 75 * Some examples: 76 * { BRD_ECP, 0x2a0, 0, 0xcc000, 0, 0 }, 77 * This line will configure an EasyConnection 8/64 at io address 2a0, 78 * and shared memory address of cc000. Multiple EasyConnection 8/64 79 * boards can share the same shared memory address space. No interrupt 80 * is required for this board type. 81 * Another example: 82 * { BRD_ECPE, 0x5000, 0, 0x80000000, 0, 0 }, 83 * This line will configure an EasyConnection 8/64 EISA in slot 5 and 84 * shared memory address of 0x80000000 (2 GByte). Multiple 85 * EasyConnection 8/64 EISA boards can share the same shared memory 86 * address space. No interrupt is required for this board type. 87 * Another example: 88 * { BRD_ONBOARD, 0x240, 0, 0xd0000, 0, 0 }, 89 * This line will configure an ONboard (ISA type) at io address 240, 90 * and shared memory address of d0000. Multiple ONboards can share 91 * the same shared memory address space. No interrupt required. 92 * Another example: 93 * { BRD_BRUMBY4, 0x360, 0, 0xc8000, 0, 0 }, 94 * This line will configure a Brumby board (any number of ports!) at 95 * io address 360 and shared memory address of c8000. All Brumby boards 96 * configured into a system must have their own separate io and memory 97 * addresses. No interrupt is required. 98 * Another example: 99 * { BRD_STALLION, 0x330, 0, 0xd0000, 0, 0 }, 100 * This line will configure an original Stallion board at io address 330 101 * and shared memory address d0000 (this would only be valid for a "V4.0" 102 * or Rev.O Stallion board). All Stallion boards configured into the 103 * system must have their own separate io and memory addresses. No 104 * interrupt is required. 105 */ 106 107struct stlconf { 108 int brdtype; 109 int ioaddr1; 110 int ioaddr2; 111 unsigned long memaddr; 112 int irq; 113 int irqtype; 114}; 115 116static unsigned int stli_nrbrds; 117 118/* stli_lock must NOT be taken holding brd_lock */ 119static spinlock_t stli_lock; /* TTY logic lock */ 120static spinlock_t brd_lock; /* Board logic lock */ 121 122/* 123 * There is some experimental EISA board detection code in this driver. 124 * By default it is disabled, but for those that want to try it out, 125 * then set the define below to be 1. 126 */ 127#define STLI_EISAPROBE 0 128 129/*****************************************************************************/ 130 131/* 132 * Define some important driver characteristics. Device major numbers 133 * allocated as per Linux Device Registry. 134 */ 135#ifndef STL_SIOMEMMAJOR 136#define STL_SIOMEMMAJOR 28 137#endif 138#ifndef STL_SERIALMAJOR 139#define STL_SERIALMAJOR 24 140#endif 141#ifndef STL_CALLOUTMAJOR 142#define STL_CALLOUTMAJOR 25 143#endif 144 145/*****************************************************************************/ 146 147/* 148 * Define our local driver identity first. Set up stuff to deal with 149 * all the local structures required by a serial tty driver. 150 */ 151static char *stli_drvtitle = "Stallion Intelligent Multiport Serial Driver"; 152static char *stli_drvname = "istallion"; 153static char *stli_drvversion = "5.6.0"; 154static char *stli_serialname = "ttyE"; 155 156static struct tty_driver *stli_serial; 157static const struct tty_port_operations stli_port_ops; 158 159#define STLI_TXBUFSIZE 4096 160 161/* 162 * Use a fast local buffer for cooked characters. Typically a whole 163 * bunch of cooked characters come in for a port, 1 at a time. So we 164 * save those up into a local buffer, then write out the whole lot 165 * with a large memcpy. Just use 1 buffer for all ports, since its 166 * use it is only need for short periods of time by each port. 167 */ 168static char *stli_txcookbuf; 169static int stli_txcooksize; 170static int stli_txcookrealsize; 171static struct tty_struct *stli_txcooktty; 172 173/* 174 * Define a local default termios struct. All ports will be created 175 * with this termios initially. Basically all it defines is a raw port 176 * at 9600 baud, 8 data bits, no parity, 1 stop bit. 177 */ 178static struct ktermios stli_deftermios = { 179 .c_cflag = (B9600 | CS8 | CREAD | HUPCL | CLOCAL), 180 .c_cc = INIT_C_CC, 181 .c_ispeed = 9600, 182 .c_ospeed = 9600, 183}; 184 185/* 186 * Define global stats structures. Not used often, and can be 187 * re-used for each stats call. 188 */ 189static comstats_t stli_comstats; 190static combrd_t stli_brdstats; 191static struct asystats stli_cdkstats; 192 193/*****************************************************************************/ 194 195static DEFINE_MUTEX(stli_brdslock); 196static struct stlibrd *stli_brds[STL_MAXBRDS]; 197 198static int stli_shared; 199 200/* 201 * Per board state flags. Used with the state field of the board struct. 202 * Not really much here... All we need to do is keep track of whether 203 * the board has been detected, and whether it is actually running a slave 204 * or not. 205 */ 206#define BST_FOUND 0 207#define BST_STARTED 1 208#define BST_PROBED 2 209 210/* 211 * Define the set of port state flags. These are marked for internal 212 * state purposes only, usually to do with the state of communications 213 * with the slave. Most of them need to be updated atomically, so always 214 * use the bit setting operations (unless protected by cli/sti). 215 */ 216#define ST_OPENING 2 217#define ST_CLOSING 3 218#define ST_CMDING 4 219#define ST_TXBUSY 5 220#define ST_RXING 6 221#define ST_DOFLUSHRX 7 222#define ST_DOFLUSHTX 8 223#define ST_DOSIGS 9 224#define ST_RXSTOP 10 225#define ST_GETSIGS 11 226 227/* 228 * Define an array of board names as printable strings. Handy for 229 * referencing boards when printing trace and stuff. 230 */ 231static char *stli_brdnames[] = { 232 "Unknown", 233 "Stallion", 234 "Brumby", 235 "ONboard-MC", 236 "ONboard", 237 "Brumby", 238 "Brumby", 239 "ONboard-EI", 240 NULL, 241 "ONboard", 242 "ONboard-MC", 243 "ONboard-MC", 244 NULL, 245 NULL, 246 NULL, 247 NULL, 248 NULL, 249 NULL, 250 NULL, 251 NULL, 252 "EasyIO", 253 "EC8/32-AT", 254 "EC8/32-MC", 255 "EC8/64-AT", 256 "EC8/64-EI", 257 "EC8/64-MC", 258 "EC8/32-PCI", 259 "EC8/64-PCI", 260 "EasyIO-PCI", 261 "EC/RA-PCI", 262}; 263 264/*****************************************************************************/ 265 266/* 267 * Define some string labels for arguments passed from the module 268 * load line. These allow for easy board definitions, and easy 269 * modification of the io, memory and irq resoucres. 270 */ 271 272static char *board0[8]; 273static char *board1[8]; 274static char *board2[8]; 275static char *board3[8]; 276 277static char **stli_brdsp[] = { 278 (char **) &board0, 279 (char **) &board1, 280 (char **) &board2, 281 (char **) &board3 282}; 283 284/* 285 * Define a set of common board names, and types. This is used to 286 * parse any module arguments. 287 */ 288 289static struct stlibrdtype { 290 char *name; 291 int type; 292} stli_brdstr[] = { 293 { "stallion", BRD_STALLION }, 294 { "1", BRD_STALLION }, 295 { "brumby", BRD_BRUMBY }, 296 { "brumby4", BRD_BRUMBY }, 297 { "brumby/4", BRD_BRUMBY }, 298 { "brumby-4", BRD_BRUMBY }, 299 { "brumby8", BRD_BRUMBY }, 300 { "brumby/8", BRD_BRUMBY }, 301 { "brumby-8", BRD_BRUMBY }, 302 { "brumby16", BRD_BRUMBY }, 303 { "brumby/16", BRD_BRUMBY }, 304 { "brumby-16", BRD_BRUMBY }, 305 { "2", BRD_BRUMBY }, 306 { "onboard2", BRD_ONBOARD2 }, 307 { "onboard-2", BRD_ONBOARD2 }, 308 { "onboard/2", BRD_ONBOARD2 }, 309 { "onboard-mc", BRD_ONBOARD2 }, 310 { "onboard/mc", BRD_ONBOARD2 }, 311 { "onboard-mca", BRD_ONBOARD2 }, 312 { "onboard/mca", BRD_ONBOARD2 }, 313 { "3", BRD_ONBOARD2 }, 314 { "onboard", BRD_ONBOARD }, 315 { "onboardat", BRD_ONBOARD }, 316 { "4", BRD_ONBOARD }, 317 { "onboarde", BRD_ONBOARDE }, 318 { "onboard-e", BRD_ONBOARDE }, 319 { "onboard/e", BRD_ONBOARDE }, 320 { "onboard-ei", BRD_ONBOARDE }, 321 { "onboard/ei", BRD_ONBOARDE }, 322 { "7", BRD_ONBOARDE }, 323 { "ecp", BRD_ECP }, 324 { "ecpat", BRD_ECP }, 325 { "ec8/64", BRD_ECP }, 326 { "ec8/64-at", BRD_ECP }, 327 { "ec8/64-isa", BRD_ECP }, 328 { "23", BRD_ECP }, 329 { "ecpe", BRD_ECPE }, 330 { "ecpei", BRD_ECPE }, 331 { "ec8/64-e", BRD_ECPE }, 332 { "ec8/64-ei", BRD_ECPE }, 333 { "24", BRD_ECPE }, 334 { "ecpmc", BRD_ECPMC }, 335 { "ec8/64-mc", BRD_ECPMC }, 336 { "ec8/64-mca", BRD_ECPMC }, 337 { "25", BRD_ECPMC }, 338 { "ecppci", BRD_ECPPCI }, 339 { "ec/ra", BRD_ECPPCI }, 340 { "ec/ra-pc", BRD_ECPPCI }, 341 { "ec/ra-pci", BRD_ECPPCI }, 342 { "29", BRD_ECPPCI }, 343}; 344 345/* 346 * Define the module agruments. 347 */ 348MODULE_AUTHOR("Greg Ungerer"); 349MODULE_DESCRIPTION("Stallion Intelligent Multiport Serial Driver"); 350MODULE_LICENSE("GPL"); 351 352 353module_param_array(board0, charp, NULL, 0); 354MODULE_PARM_DESC(board0, "Board 0 config -> name[,ioaddr[,memaddr]"); 355module_param_array(board1, charp, NULL, 0); 356MODULE_PARM_DESC(board1, "Board 1 config -> name[,ioaddr[,memaddr]"); 357module_param_array(board2, charp, NULL, 0); 358MODULE_PARM_DESC(board2, "Board 2 config -> name[,ioaddr[,memaddr]"); 359module_param_array(board3, charp, NULL, 0); 360MODULE_PARM_DESC(board3, "Board 3 config -> name[,ioaddr[,memaddr]"); 361 362#if STLI_EISAPROBE != 0 363/* 364 * Set up a default memory address table for EISA board probing. 365 * The default addresses are all bellow 1Mbyte, which has to be the 366 * case anyway. They should be safe, since we only read values from 367 * them, and interrupts are disabled while we do it. If the higher 368 * memory support is compiled in then we also try probing around 369 * the 1Gb, 2Gb and 3Gb areas as well... 370 */ 371static unsigned long stli_eisamemprobeaddrs[] = { 372 0xc0000, 0xd0000, 0xe0000, 0xf0000, 373 0x80000000, 0x80010000, 0x80020000, 0x80030000, 374 0x40000000, 0x40010000, 0x40020000, 0x40030000, 375 0xc0000000, 0xc0010000, 0xc0020000, 0xc0030000, 376 0xff000000, 0xff010000, 0xff020000, 0xff030000, 377}; 378 379static int stli_eisamempsize = ARRAY_SIZE(stli_eisamemprobeaddrs); 380#endif 381 382/* 383 * Define the Stallion PCI vendor and device IDs. 384 */ 385#ifndef PCI_DEVICE_ID_ECRA 386#define PCI_DEVICE_ID_ECRA 0x0004 387#endif 388 389static struct pci_device_id istallion_pci_tbl[] = { 390 { PCI_DEVICE(PCI_VENDOR_ID_STALLION, PCI_DEVICE_ID_ECRA), }, 391 { 0 } 392}; 393MODULE_DEVICE_TABLE(pci, istallion_pci_tbl); 394 395static struct pci_driver stli_pcidriver; 396 397/*****************************************************************************/ 398 399/* 400 * Hardware configuration info for ECP boards. These defines apply 401 * to the directly accessible io ports of the ECP. There is a set of 402 * defines for each ECP board type, ISA, EISA, MCA and PCI. 403 */ 404#define ECP_IOSIZE 4 405 406#define ECP_MEMSIZE (128 * 1024) 407#define ECP_PCIMEMSIZE (256 * 1024) 408 409#define ECP_ATPAGESIZE (4 * 1024) 410#define ECP_MCPAGESIZE (4 * 1024) 411#define ECP_EIPAGESIZE (64 * 1024) 412#define ECP_PCIPAGESIZE (64 * 1024) 413 414#define STL_EISAID 0x8c4e 415 416/* 417 * Important defines for the ISA class of ECP board. 418 */ 419#define ECP_ATIREG 0 420#define ECP_ATCONFR 1 421#define ECP_ATMEMAR 2 422#define ECP_ATMEMPR 3 423#define ECP_ATSTOP 0x1 424#define ECP_ATINTENAB 0x10 425#define ECP_ATENABLE 0x20 426#define ECP_ATDISABLE 0x00 427#define ECP_ATADDRMASK 0x3f000 428#define ECP_ATADDRSHFT 12 429 430/* 431 * Important defines for the EISA class of ECP board. 432 */ 433#define ECP_EIIREG 0 434#define ECP_EIMEMARL 1 435#define ECP_EICONFR 2 436#define ECP_EIMEMARH 3 437#define ECP_EIENABLE 0x1 438#define ECP_EIDISABLE 0x0 439#define ECP_EISTOP 0x4 440#define ECP_EIEDGE 0x00 441#define ECP_EILEVEL 0x80 442#define ECP_EIADDRMASKL 0x00ff0000 443#define ECP_EIADDRSHFTL 16 444#define ECP_EIADDRMASKH 0xff000000 445#define ECP_EIADDRSHFTH 24 446#define ECP_EIBRDENAB 0xc84 447 448#define ECP_EISAID 0x4 449 450/* 451 * Important defines for the Micro-channel class of ECP board. 452 * (It has a lot in common with the ISA boards.) 453 */ 454#define ECP_MCIREG 0 455#define ECP_MCCONFR 1 456#define ECP_MCSTOP 0x20 457#define ECP_MCENABLE 0x80 458#define ECP_MCDISABLE 0x00 459 460/* 461 * Important defines for the PCI class of ECP board. 462 * (It has a lot in common with the other ECP boards.) 463 */ 464#define ECP_PCIIREG 0 465#define ECP_PCICONFR 1 466#define ECP_PCISTOP 0x01 467 468/* 469 * Hardware configuration info for ONboard and Brumby boards. These 470 * defines apply to the directly accessible io ports of these boards. 471 */ 472#define ONB_IOSIZE 16 473#define ONB_MEMSIZE (64 * 1024) 474#define ONB_ATPAGESIZE (64 * 1024) 475#define ONB_MCPAGESIZE (64 * 1024) 476#define ONB_EIMEMSIZE (128 * 1024) 477#define ONB_EIPAGESIZE (64 * 1024) 478 479/* 480 * Important defines for the ISA class of ONboard board. 481 */ 482#define ONB_ATIREG 0 483#define ONB_ATMEMAR 1 484#define ONB_ATCONFR 2 485#define ONB_ATSTOP 0x4 486#define ONB_ATENABLE 0x01 487#define ONB_ATDISABLE 0x00 488#define ONB_ATADDRMASK 0xff0000 489#define ONB_ATADDRSHFT 16 490 491#define ONB_MEMENABLO 0 492#define ONB_MEMENABHI 0x02 493 494/* 495 * Important defines for the EISA class of ONboard board. 496 */ 497#define ONB_EIIREG 0 498#define ONB_EIMEMARL 1 499#define ONB_EICONFR 2 500#define ONB_EIMEMARH 3 501#define ONB_EIENABLE 0x1 502#define ONB_EIDISABLE 0x0 503#define ONB_EISTOP 0x4 504#define ONB_EIEDGE 0x00 505#define ONB_EILEVEL 0x80 506#define ONB_EIADDRMASKL 0x00ff0000 507#define ONB_EIADDRSHFTL 16 508#define ONB_EIADDRMASKH 0xff000000 509#define ONB_EIADDRSHFTH 24 510#define ONB_EIBRDENAB 0xc84 511 512#define ONB_EISAID 0x1 513 514/* 515 * Important defines for the Brumby boards. They are pretty simple, 516 * there is not much that is programmably configurable. 517 */ 518#define BBY_IOSIZE 16 519#define BBY_MEMSIZE (64 * 1024) 520#define BBY_PAGESIZE (16 * 1024) 521 522#define BBY_ATIREG 0 523#define BBY_ATCONFR 1 524#define BBY_ATSTOP 0x4 525 526/* 527 * Important defines for the Stallion boards. They are pretty simple, 528 * there is not much that is programmably configurable. 529 */ 530#define STAL_IOSIZE 16 531#define STAL_MEMSIZE (64 * 1024) 532#define STAL_PAGESIZE (64 * 1024) 533 534/* 535 * Define the set of status register values for EasyConnection panels. 536 * The signature will return with the status value for each panel. From 537 * this we can determine what is attached to the board - before we have 538 * actually down loaded any code to it. 539 */ 540#define ECH_PNLSTATUS 2 541#define ECH_PNL16PORT 0x20 542#define ECH_PNLIDMASK 0x07 543#define ECH_PNLXPID 0x40 544#define ECH_PNLINTRPEND 0x80 545 546/* 547 * Define some macros to do things to the board. Even those these boards 548 * are somewhat related there is often significantly different ways of 549 * doing some operation on it (like enable, paging, reset, etc). So each 550 * board class has a set of functions which do the commonly required 551 * operations. The macros below basically just call these functions, 552 * generally checking for a NULL function - which means that the board 553 * needs nothing done to it to achieve this operation! 554 */ 555#define EBRDINIT(brdp) \ 556 if (brdp->init != NULL) \ 557 (* brdp->init)(brdp) 558 559#define EBRDENABLE(brdp) \ 560 if (brdp->enable != NULL) \ 561 (* brdp->enable)(brdp); 562 563#define EBRDDISABLE(brdp) \ 564 if (brdp->disable != NULL) \ 565 (* brdp->disable)(brdp); 566 567#define EBRDINTR(brdp) \ 568 if (brdp->intr != NULL) \ 569 (* brdp->intr)(brdp); 570 571#define EBRDRESET(brdp) \ 572 if (brdp->reset != NULL) \ 573 (* brdp->reset)(brdp); 574 575#define EBRDGETMEMPTR(brdp,offset) \ 576 (* brdp->getmemptr)(brdp, offset, __LINE__) 577 578/* 579 * Define the maximal baud rate, and the default baud base for ports. 580 */ 581#define STL_MAXBAUD 460800 582#define STL_BAUDBASE 115200 583#define STL_CLOSEDELAY (5 * HZ / 10) 584 585/*****************************************************************************/ 586 587/* 588 * Define macros to extract a brd or port number from a minor number. 589 */ 590#define MINOR2BRD(min) (((min) & 0xc0) >> 6) 591#define MINOR2PORT(min) ((min) & 0x3f) 592 593/*****************************************************************************/ 594 595/* 596 * Prototype all functions in this driver! 597 */ 598 599static int stli_parsebrd(struct stlconf *confp, char **argp); 600static int stli_open(struct tty_struct *tty, struct file *filp); 601static void stli_close(struct tty_struct *tty, struct file *filp); 602static int stli_write(struct tty_struct *tty, const unsigned char *buf, int count); 603static int stli_putchar(struct tty_struct *tty, unsigned char ch); 604static void stli_flushchars(struct tty_struct *tty); 605static int stli_writeroom(struct tty_struct *tty); 606static int stli_charsinbuffer(struct tty_struct *tty); 607static int stli_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg); 608static void stli_settermios(struct tty_struct *tty, struct ktermios *old); 609static void stli_throttle(struct tty_struct *tty); 610static void stli_unthrottle(struct tty_struct *tty); 611static void stli_stop(struct tty_struct *tty); 612static void stli_start(struct tty_struct *tty); 613static void stli_flushbuffer(struct tty_struct *tty); 614static int stli_breakctl(struct tty_struct *tty, int state); 615static void stli_waituntilsent(struct tty_struct *tty, int timeout); 616static void stli_sendxchar(struct tty_struct *tty, char ch); 617static void stli_hangup(struct tty_struct *tty); 618 619static int stli_brdinit(struct stlibrd *brdp); 620static int stli_startbrd(struct stlibrd *brdp); 621static ssize_t stli_memread(struct file *fp, char __user *buf, size_t count, loff_t *offp); 622static ssize_t stli_memwrite(struct file *fp, const char __user *buf, size_t count, loff_t *offp); 623static long stli_memioctl(struct file *fp, unsigned int cmd, unsigned long arg); 624static void stli_brdpoll(struct stlibrd *brdp, cdkhdr_t __iomem *hdrp); 625static void stli_poll(unsigned long arg); 626static int stli_hostcmd(struct stlibrd *brdp, struct stliport *portp); 627static int stli_initopen(struct tty_struct *tty, struct stlibrd *brdp, struct stliport *portp); 628static int stli_rawopen(struct stlibrd *brdp, struct stliport *portp, unsigned long arg, int wait); 629static int stli_rawclose(struct stlibrd *brdp, struct stliport *portp, unsigned long arg, int wait); 630static int stli_setport(struct tty_struct *tty); 631static int stli_cmdwait(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback); 632static void stli_sendcmd(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback); 633static void __stli_sendcmd(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback); 634static void stli_dodelaycmd(struct stliport *portp, cdkctrl_t __iomem *cp); 635static void stli_mkasyport(struct tty_struct *tty, struct stliport *portp, asyport_t *pp, struct ktermios *tiosp); 636static void stli_mkasysigs(asysigs_t *sp, int dtr, int rts); 637static long stli_mktiocm(unsigned long sigvalue); 638static void stli_read(struct stlibrd *brdp, struct stliport *portp); 639static int stli_getserial(struct stliport *portp, struct serial_struct __user *sp); 640static int stli_setserial(struct tty_struct *tty, struct serial_struct __user *sp); 641static int stli_getbrdstats(combrd_t __user *bp); 642static int stli_getportstats(struct tty_struct *tty, struct stliport *portp, comstats_t __user *cp); 643static int stli_portcmdstats(struct tty_struct *tty, struct stliport *portp); 644static int stli_clrportstats(struct stliport *portp, comstats_t __user *cp); 645static int stli_getportstruct(struct stliport __user *arg); 646static int stli_getbrdstruct(struct stlibrd __user *arg); 647static struct stlibrd *stli_allocbrd(void); 648 649static void stli_ecpinit(struct stlibrd *brdp); 650static void stli_ecpenable(struct stlibrd *brdp); 651static void stli_ecpdisable(struct stlibrd *brdp); 652static void __iomem *stli_ecpgetmemptr(struct stlibrd *brdp, unsigned long offset, int line); 653static void stli_ecpreset(struct stlibrd *brdp); 654static void stli_ecpintr(struct stlibrd *brdp); 655static void stli_ecpeiinit(struct stlibrd *brdp); 656static void stli_ecpeienable(struct stlibrd *brdp); 657static void stli_ecpeidisable(struct stlibrd *brdp); 658static void __iomem *stli_ecpeigetmemptr(struct stlibrd *brdp, unsigned long offset, int line); 659static void stli_ecpeireset(struct stlibrd *brdp); 660static void stli_ecpmcenable(struct stlibrd *brdp); 661static void stli_ecpmcdisable(struct stlibrd *brdp); 662static void __iomem *stli_ecpmcgetmemptr(struct stlibrd *brdp, unsigned long offset, int line); 663static void stli_ecpmcreset(struct stlibrd *brdp); 664static void stli_ecppciinit(struct stlibrd *brdp); 665static void __iomem *stli_ecppcigetmemptr(struct stlibrd *brdp, unsigned long offset, int line); 666static void stli_ecppcireset(struct stlibrd *brdp); 667 668static void stli_onbinit(struct stlibrd *brdp); 669static void stli_onbenable(struct stlibrd *brdp); 670static void stli_onbdisable(struct stlibrd *brdp); 671static void __iomem *stli_onbgetmemptr(struct stlibrd *brdp, unsigned long offset, int line); 672static void stli_onbreset(struct stlibrd *brdp); 673static void stli_onbeinit(struct stlibrd *brdp); 674static void stli_onbeenable(struct stlibrd *brdp); 675static void stli_onbedisable(struct stlibrd *brdp); 676static void __iomem *stli_onbegetmemptr(struct stlibrd *brdp, unsigned long offset, int line); 677static void stli_onbereset(struct stlibrd *brdp); 678static void stli_bbyinit(struct stlibrd *brdp); 679static void __iomem *stli_bbygetmemptr(struct stlibrd *brdp, unsigned long offset, int line); 680static void stli_bbyreset(struct stlibrd *brdp); 681static void stli_stalinit(struct stlibrd *brdp); 682static void __iomem *stli_stalgetmemptr(struct stlibrd *brdp, unsigned long offset, int line); 683static void stli_stalreset(struct stlibrd *brdp); 684 685static struct stliport *stli_getport(unsigned int brdnr, unsigned int panelnr, unsigned int portnr); 686 687static int stli_initecp(struct stlibrd *brdp); 688static int stli_initonb(struct stlibrd *brdp); 689#if STLI_EISAPROBE != 0 690static int stli_eisamemprobe(struct stlibrd *brdp); 691#endif 692static int stli_initports(struct stlibrd *brdp); 693 694/*****************************************************************************/ 695 696/* 697 * Define the driver info for a user level shared memory device. This 698 * device will work sort of like the /dev/kmem device - except that it 699 * will give access to the shared memory on the Stallion intelligent 700 * board. This is also a very useful debugging tool. 701 */ 702static const struct file_operations stli_fsiomem = { 703 .owner = THIS_MODULE, 704 .read = stli_memread, 705 .write = stli_memwrite, 706 .unlocked_ioctl = stli_memioctl, 707}; 708 709/*****************************************************************************/ 710 711/* 712 * Define a timer_list entry for our poll routine. The slave board 713 * is polled every so often to see if anything needs doing. This is 714 * much cheaper on host cpu than using interrupts. It turns out to 715 * not increase character latency by much either... 716 */ 717static DEFINE_TIMER(stli_timerlist, stli_poll, 0, 0); 718 719static int stli_timeron; 720 721/* 722 * Define the calculation for the timeout routine. 723 */ 724#define STLI_TIMEOUT (jiffies + 1) 725 726/*****************************************************************************/ 727 728static struct class *istallion_class; 729 730static void stli_cleanup_ports(struct stlibrd *brdp) 731{ 732 struct stliport *portp; 733 unsigned int j; 734 struct tty_struct *tty; 735 736 for (j = 0; j < STL_MAXPORTS; j++) { 737 portp = brdp->ports[j]; 738 if (portp != NULL) { 739 tty = tty_port_tty_get(&portp->port); 740 if (tty != NULL) { 741 tty_hangup(tty); 742 tty_kref_put(tty); 743 } 744 kfree(portp); 745 } 746 } 747} 748 749/*****************************************************************************/ 750 751/* 752 * Parse the supplied argument string, into the board conf struct. 753 */ 754 755static int stli_parsebrd(struct stlconf *confp, char **argp) 756{ 757 unsigned int i; 758 char *sp; 759 760 if (argp[0] == NULL || *argp[0] == 0) 761 return 0; 762 763 for (sp = argp[0], i = 0; ((*sp != 0) && (i < 25)); sp++, i++) 764 *sp = tolower(*sp); 765 766 for (i = 0; i < ARRAY_SIZE(stli_brdstr); i++) { 767 if (strcmp(stli_brdstr[i].name, argp[0]) == 0) 768 break; 769 } 770 if (i == ARRAY_SIZE(stli_brdstr)) { 771 printk(KERN_WARNING "istallion: unknown board name, %s?\n", argp[0]); 772 return 0; 773 } 774 775 confp->brdtype = stli_brdstr[i].type; 776 if (argp[1] != NULL && *argp[1] != 0) 777 confp->ioaddr1 = simple_strtoul(argp[1], NULL, 0); 778 if (argp[2] != NULL && *argp[2] != 0) 779 confp->memaddr = simple_strtoul(argp[2], NULL, 0); 780 return(1); 781} 782 783/*****************************************************************************/ 784 785/* 786 * On the first open of the device setup the port hardware, and 787 * initialize the per port data structure. Since initializing the port 788 * requires several commands to the board we will need to wait for any 789 * other open that is already initializing the port. 790 * 791 * Locking: protected by the port mutex. 792 */ 793 794static int stli_activate(struct tty_port *port, struct tty_struct *tty) 795{ 796 struct stliport *portp = container_of(port, struct stliport, port); 797 struct stlibrd *brdp = stli_brds[portp->brdnr]; 798 int rc; 799 800 if ((rc = stli_initopen(tty, brdp, portp)) >= 0) 801 clear_bit(TTY_IO_ERROR, &tty->flags); 802 wake_up_interruptible(&portp->raw_wait); 803 return rc; 804} 805 806static int stli_open(struct tty_struct *tty, struct file *filp) 807{ 808 struct stlibrd *brdp; 809 struct stliport *portp; 810 unsigned int minordev, brdnr, portnr; 811 812 minordev = tty->index; 813 brdnr = MINOR2BRD(minordev); 814 if (brdnr >= stli_nrbrds) 815 return -ENODEV; 816 brdp = stli_brds[brdnr]; 817 if (brdp == NULL) 818 return -ENODEV; 819 if (!test_bit(BST_STARTED, &brdp->state)) 820 return -ENODEV; 821 portnr = MINOR2PORT(minordev); 822 if (portnr > brdp->nrports) 823 return -ENODEV; 824 825 portp = brdp->ports[portnr]; 826 if (portp == NULL) 827 return -ENODEV; 828 if (portp->devnr < 1) 829 return -ENODEV; 830 831 tty->driver_data = portp; 832 return tty_port_open(&portp->port, tty, filp); 833} 834 835 836/*****************************************************************************/ 837 838static void stli_shutdown(struct tty_port *port) 839{ 840 struct stlibrd *brdp; 841 unsigned long ftype; 842 unsigned long flags; 843 struct stliport *portp = container_of(port, struct stliport, port); 844 845 if (portp->brdnr >= stli_nrbrds) 846 return; 847 brdp = stli_brds[portp->brdnr]; 848 if (brdp == NULL) 849 return; 850 851 /* 852 * May want to wait for data to drain before closing. The BUSY 853 * flag keeps track of whether we are still transmitting or not. 854 * It is updated by messages from the slave - indicating when all 855 * chars really have drained. 856 */ 857 858 if (!test_bit(ST_CLOSING, &portp->state)) 859 stli_rawclose(brdp, portp, 0, 0); 860 861 spin_lock_irqsave(&stli_lock, flags); 862 clear_bit(ST_TXBUSY, &portp->state); 863 clear_bit(ST_RXSTOP, &portp->state); 864 spin_unlock_irqrestore(&stli_lock, flags); 865 866 ftype = FLUSHTX | FLUSHRX; 867 stli_cmdwait(brdp, portp, A_FLUSH, &ftype, sizeof(u32), 0); 868} 869 870static void stli_close(struct tty_struct *tty, struct file *filp) 871{ 872 struct stliport *portp = tty->driver_data; 873 unsigned long flags; 874 if (portp == NULL) 875 return; 876 spin_lock_irqsave(&stli_lock, flags); 877 /* Flush any internal buffering out first */ 878 if (tty == stli_txcooktty) 879 stli_flushchars(tty); 880 spin_unlock_irqrestore(&stli_lock, flags); 881 tty_port_close(&portp->port, tty, filp); 882} 883 884/*****************************************************************************/ 885 886/* 887 * Carry out first open operations on a port. This involves a number of 888 * commands to be sent to the slave. We need to open the port, set the 889 * notification events, set the initial port settings, get and set the 890 * initial signal values. We sleep and wait in between each one. But 891 * this still all happens pretty quickly. 892 */ 893 894static int stli_initopen(struct tty_struct *tty, 895 struct stlibrd *brdp, struct stliport *portp) 896{ 897 asynotify_t nt; 898 asyport_t aport; 899 int rc; 900 901 if ((rc = stli_rawopen(brdp, portp, 0, 1)) < 0) 902 return rc; 903 904 memset(&nt, 0, sizeof(asynotify_t)); 905 nt.data = (DT_TXLOW | DT_TXEMPTY | DT_RXBUSY | DT_RXBREAK); 906 nt.signal = SG_DCD; 907 if ((rc = stli_cmdwait(brdp, portp, A_SETNOTIFY, &nt, 908 sizeof(asynotify_t), 0)) < 0) 909 return rc; 910 911 stli_mkasyport(tty, portp, &aport, tty->termios); 912 if ((rc = stli_cmdwait(brdp, portp, A_SETPORT, &aport, 913 sizeof(asyport_t), 0)) < 0) 914 return rc; 915 916 set_bit(ST_GETSIGS, &portp->state); 917 if ((rc = stli_cmdwait(brdp, portp, A_GETSIGNALS, &portp->asig, 918 sizeof(asysigs_t), 1)) < 0) 919 return rc; 920 if (test_and_clear_bit(ST_GETSIGS, &portp->state)) 921 portp->sigs = stli_mktiocm(portp->asig.sigvalue); 922 stli_mkasysigs(&portp->asig, 1, 1); 923 if ((rc = stli_cmdwait(brdp, portp, A_SETSIGNALS, &portp->asig, 924 sizeof(asysigs_t), 0)) < 0) 925 return rc; 926 927 return 0; 928} 929 930/*****************************************************************************/ 931 932/* 933 * Send an open message to the slave. This will sleep waiting for the 934 * acknowledgement, so must have user context. We need to co-ordinate 935 * with close events here, since we don't want open and close events 936 * to overlap. 937 */ 938 939static int stli_rawopen(struct stlibrd *brdp, struct stliport *portp, unsigned long arg, int wait) 940{ 941 cdkhdr_t __iomem *hdrp; 942 cdkctrl_t __iomem *cp; 943 unsigned char __iomem *bits; 944 unsigned long flags; 945 int rc; 946 947/* 948 * Send a message to the slave to open this port. 949 */ 950 951/* 952 * Slave is already closing this port. This can happen if a hangup 953 * occurs on this port. So we must wait until it is complete. The 954 * order of opens and closes may not be preserved across shared 955 * memory, so we must wait until it is complete. 956 */ 957 wait_event_interruptible_tty(portp->raw_wait, 958 !test_bit(ST_CLOSING, &portp->state)); 959 if (signal_pending(current)) { 960 return -ERESTARTSYS; 961 } 962 963/* 964 * Everything is ready now, so write the open message into shared 965 * memory. Once the message is in set the service bits to say that 966 * this port wants service. 967 */ 968 spin_lock_irqsave(&brd_lock, flags); 969 EBRDENABLE(brdp); 970 cp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->ctrl; 971 writel(arg, &cp->openarg); 972 writeb(1, &cp->open); 973 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR); 974 bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset + 975 portp->portidx; 976 writeb(readb(bits) | portp->portbit, bits); 977 EBRDDISABLE(brdp); 978 979 if (wait == 0) { 980 spin_unlock_irqrestore(&brd_lock, flags); 981 return 0; 982 } 983 984/* 985 * Slave is in action, so now we must wait for the open acknowledgment 986 * to come back. 987 */ 988 rc = 0; 989 set_bit(ST_OPENING, &portp->state); 990 spin_unlock_irqrestore(&brd_lock, flags); 991 992 wait_event_interruptible_tty(portp->raw_wait, 993 !test_bit(ST_OPENING, &portp->state)); 994 if (signal_pending(current)) 995 rc = -ERESTARTSYS; 996 997 if ((rc == 0) && (portp->rc != 0)) 998 rc = -EIO; 999 return rc; 1000} 1001 1002/*****************************************************************************/ 1003 1004/* 1005 * Send a close message to the slave. Normally this will sleep waiting 1006 * for the acknowledgement, but if wait parameter is 0 it will not. If 1007 * wait is true then must have user context (to sleep). 1008 */ 1009 1010static int stli_rawclose(struct stlibrd *brdp, struct stliport *portp, unsigned long arg, int wait) 1011{ 1012 cdkhdr_t __iomem *hdrp; 1013 cdkctrl_t __iomem *cp; 1014 unsigned char __iomem *bits; 1015 unsigned long flags; 1016 int rc; 1017 1018/* 1019 * Slave is already closing this port. This can happen if a hangup 1020 * occurs on this port. 1021 */ 1022 if (wait) { 1023 wait_event_interruptible_tty(portp->raw_wait, 1024 !test_bit(ST_CLOSING, &portp->state)); 1025 if (signal_pending(current)) { 1026 return -ERESTARTSYS; 1027 } 1028 } 1029 1030/* 1031 * Write the close command into shared memory. 1032 */ 1033 spin_lock_irqsave(&brd_lock, flags); 1034 EBRDENABLE(brdp); 1035 cp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->ctrl; 1036 writel(arg, &cp->closearg); 1037 writeb(1, &cp->close); 1038 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR); 1039 bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset + 1040 portp->portidx; 1041 writeb(readb(bits) |portp->portbit, bits); 1042 EBRDDISABLE(brdp); 1043 1044 set_bit(ST_CLOSING, &portp->state); 1045 spin_unlock_irqrestore(&brd_lock, flags); 1046 1047 if (wait == 0) 1048 return 0; 1049 1050/* 1051 * Slave is in action, so now we must wait for the open acknowledgment 1052 * to come back. 1053 */ 1054 rc = 0; 1055 wait_event_interruptible_tty(portp->raw_wait, 1056 !test_bit(ST_CLOSING, &portp->state)); 1057 if (signal_pending(current)) 1058 rc = -ERESTARTSYS; 1059 1060 if ((rc == 0) && (portp->rc != 0)) 1061 rc = -EIO; 1062 return rc; 1063} 1064 1065/*****************************************************************************/ 1066 1067/* 1068 * Send a command to the slave and wait for the response. This must 1069 * have user context (it sleeps). This routine is generic in that it 1070 * can send any type of command. Its purpose is to wait for that command 1071 * to complete (as opposed to initiating the command then returning). 1072 */ 1073 1074static int stli_cmdwait(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback) 1075{ 1076 /* 1077 * no need for wait_event_tty because clearing ST_CMDING cannot block 1078 * on BTM 1079 */ 1080 wait_event_interruptible(portp->raw_wait, 1081 !test_bit(ST_CMDING, &portp->state)); 1082 if (signal_pending(current)) 1083 return -ERESTARTSYS; 1084 1085 stli_sendcmd(brdp, portp, cmd, arg, size, copyback); 1086 1087 wait_event_interruptible(portp->raw_wait, 1088 !test_bit(ST_CMDING, &portp->state)); 1089 if (signal_pending(current)) 1090 return -ERESTARTSYS; 1091 1092 if (portp->rc != 0) 1093 return -EIO; 1094 return 0; 1095} 1096 1097/*****************************************************************************/ 1098 1099/* 1100 * Send the termios settings for this port to the slave. This sleeps 1101 * waiting for the command to complete - so must have user context. 1102 */ 1103 1104static int stli_setport(struct tty_struct *tty) 1105{ 1106 struct stliport *portp = tty->driver_data; 1107 struct stlibrd *brdp; 1108 asyport_t aport; 1109 1110 if (portp == NULL) 1111 return -ENODEV; 1112 if (portp->brdnr >= stli_nrbrds) 1113 return -ENODEV; 1114 brdp = stli_brds[portp->brdnr]; 1115 if (brdp == NULL) 1116 return -ENODEV; 1117 1118 stli_mkasyport(tty, portp, &aport, tty->termios); 1119 return(stli_cmdwait(brdp, portp, A_SETPORT, &aport, sizeof(asyport_t), 0)); 1120} 1121 1122/*****************************************************************************/ 1123 1124static int stli_carrier_raised(struct tty_port *port) 1125{ 1126 struct stliport *portp = container_of(port, struct stliport, port); 1127 return (portp->sigs & TIOCM_CD) ? 1 : 0; 1128} 1129 1130static void stli_dtr_rts(struct tty_port *port, int on) 1131{ 1132 struct stliport *portp = container_of(port, struct stliport, port); 1133 struct stlibrd *brdp = stli_brds[portp->brdnr]; 1134 stli_mkasysigs(&portp->asig, on, on); 1135 if (stli_cmdwait(brdp, portp, A_SETSIGNALS, &portp->asig, 1136 sizeof(asysigs_t), 0) < 0) 1137 printk(KERN_WARNING "istallion: dtr set failed.\n"); 1138} 1139 1140 1141/*****************************************************************************/ 1142 1143/* 1144 * Write routine. Take the data and put it in the shared memory ring 1145 * queue. If port is not already sending chars then need to mark the 1146 * service bits for this port. 1147 */ 1148 1149static int stli_write(struct tty_struct *tty, const unsigned char *buf, int count) 1150{ 1151 cdkasy_t __iomem *ap; 1152 cdkhdr_t __iomem *hdrp; 1153 unsigned char __iomem *bits; 1154 unsigned char __iomem *shbuf; 1155 unsigned char *chbuf; 1156 struct stliport *portp; 1157 struct stlibrd *brdp; 1158 unsigned int len, stlen, head, tail, size; 1159 unsigned long flags; 1160 1161 if (tty == stli_txcooktty) 1162 stli_flushchars(tty); 1163 portp = tty->driver_data; 1164 if (portp == NULL) 1165 return 0; 1166 if (portp->brdnr >= stli_nrbrds) 1167 return 0; 1168 brdp = stli_brds[portp->brdnr]; 1169 if (brdp == NULL) 1170 return 0; 1171 chbuf = (unsigned char *) buf; 1172 1173/* 1174 * All data is now local, shove as much as possible into shared memory. 1175 */ 1176 spin_lock_irqsave(&brd_lock, flags); 1177 EBRDENABLE(brdp); 1178 ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr); 1179 head = (unsigned int) readw(&ap->txq.head); 1180 tail = (unsigned int) readw(&ap->txq.tail); 1181 if (tail != ((unsigned int) readw(&ap->txq.tail))) 1182 tail = (unsigned int) readw(&ap->txq.tail); 1183 size = portp->txsize; 1184 if (head >= tail) { 1185 len = size - (head - tail) - 1; 1186 stlen = size - head; 1187 } else { 1188 len = tail - head - 1; 1189 stlen = len; 1190 } 1191 1192 len = min(len, (unsigned int)count); 1193 count = 0; 1194 shbuf = (char __iomem *) EBRDGETMEMPTR(brdp, portp->txoffset); 1195 1196 while (len > 0) { 1197 stlen = min(len, stlen); 1198 memcpy_toio(shbuf + head, chbuf, stlen); 1199 chbuf += stlen; 1200 len -= stlen; 1201 count += stlen; 1202 head += stlen; 1203 if (head >= size) { 1204 head = 0; 1205 stlen = tail; 1206 } 1207 } 1208 1209 ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr); 1210 writew(head, &ap->txq.head); 1211 if (test_bit(ST_TXBUSY, &portp->state)) { 1212 if (readl(&ap->changed.data) & DT_TXEMPTY) 1213 writel(readl(&ap->changed.data) & ~DT_TXEMPTY, &ap->changed.data); 1214 } 1215 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR); 1216 bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset + 1217 portp->portidx; 1218 writeb(readb(bits) | portp->portbit, bits); 1219 set_bit(ST_TXBUSY, &portp->state); 1220 EBRDDISABLE(brdp); 1221 spin_unlock_irqrestore(&brd_lock, flags); 1222 1223 return(count); 1224} 1225 1226/*****************************************************************************/ 1227 1228/* 1229 * Output a single character. We put it into a temporary local buffer 1230 * (for speed) then write out that buffer when the flushchars routine 1231 * is called. There is a safety catch here so that if some other port 1232 * writes chars before the current buffer has been, then we write them 1233 * first them do the new ports. 1234 */ 1235 1236static int stli_putchar(struct tty_struct *tty, unsigned char ch) 1237{ 1238 if (tty != stli_txcooktty) { 1239 if (stli_txcooktty != NULL) 1240 stli_flushchars(stli_txcooktty); 1241 stli_txcooktty = tty; 1242 } 1243 1244 stli_txcookbuf[stli_txcooksize++] = ch; 1245 return 0; 1246} 1247 1248/*****************************************************************************/ 1249 1250/* 1251 * Transfer characters from the local TX cooking buffer to the board. 1252 * We sort of ignore the tty that gets passed in here. We rely on the 1253 * info stored with the TX cook buffer to tell us which port to flush 1254 * the data on. In any case we clean out the TX cook buffer, for re-use 1255 * by someone else. 1256 */ 1257 1258static void stli_flushchars(struct tty_struct *tty) 1259{ 1260 cdkhdr_t __iomem *hdrp; 1261 unsigned char __iomem *bits; 1262 cdkasy_t __iomem *ap; 1263 struct tty_struct *cooktty; 1264 struct stliport *portp; 1265 struct stlibrd *brdp; 1266 unsigned int len, stlen, head, tail, size, count, cooksize; 1267 unsigned char *buf; 1268 unsigned char __iomem *shbuf; 1269 unsigned long flags; 1270 1271 cooksize = stli_txcooksize; 1272 cooktty = stli_txcooktty; 1273 stli_txcooksize = 0; 1274 stli_txcookrealsize = 0; 1275 stli_txcooktty = NULL; 1276 1277 if (cooktty == NULL) 1278 return; 1279 if (tty != cooktty) 1280 tty = cooktty; 1281 if (cooksize == 0) 1282 return; 1283 1284 portp = tty->driver_data; 1285 if (portp == NULL) 1286 return; 1287 if (portp->brdnr >= stli_nrbrds) 1288 return; 1289 brdp = stli_brds[portp->brdnr]; 1290 if (brdp == NULL) 1291 return; 1292 1293 spin_lock_irqsave(&brd_lock, flags); 1294 EBRDENABLE(brdp); 1295 1296 ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr); 1297 head = (unsigned int) readw(&ap->txq.head); 1298 tail = (unsigned int) readw(&ap->txq.tail); 1299 if (tail != ((unsigned int) readw(&ap->txq.tail))) 1300 tail = (unsigned int) readw(&ap->txq.tail); 1301 size = portp->txsize; 1302 if (head >= tail) { 1303 len = size - (head - tail) - 1; 1304 stlen = size - head; 1305 } else { 1306 len = tail - head - 1; 1307 stlen = len; 1308 } 1309 1310 len = min(len, cooksize); 1311 count = 0; 1312 shbuf = EBRDGETMEMPTR(brdp, portp->txoffset); 1313 buf = stli_txcookbuf; 1314 1315 while (len > 0) { 1316 stlen = min(len, stlen); 1317 memcpy_toio(shbuf + head, buf, stlen); 1318 buf += stlen; 1319 len -= stlen; 1320 count += stlen; 1321 head += stlen; 1322 if (head >= size) { 1323 head = 0; 1324 stlen = tail; 1325 } 1326 } 1327 1328 ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr); 1329 writew(head, &ap->txq.head); 1330 1331 if (test_bit(ST_TXBUSY, &portp->state)) { 1332 if (readl(&ap->changed.data) & DT_TXEMPTY) 1333 writel(readl(&ap->changed.data) & ~DT_TXEMPTY, &ap->changed.data); 1334 } 1335 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR); 1336 bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset + 1337 portp->portidx; 1338 writeb(readb(bits) | portp->portbit, bits); 1339 set_bit(ST_TXBUSY, &portp->state); 1340 1341 EBRDDISABLE(brdp); 1342 spin_unlock_irqrestore(&brd_lock, flags); 1343} 1344 1345/*****************************************************************************/ 1346 1347static int stli_writeroom(struct tty_struct *tty) 1348{ 1349 cdkasyrq_t __iomem *rp; 1350 struct stliport *portp; 1351 struct stlibrd *brdp; 1352 unsigned int head, tail, len; 1353 unsigned long flags; 1354 1355 if (tty == stli_txcooktty) { 1356 if (stli_txcookrealsize != 0) { 1357 len = stli_txcookrealsize - stli_txcooksize; 1358 return len; 1359 } 1360 } 1361 1362 portp = tty->driver_data; 1363 if (portp == NULL) 1364 return 0; 1365 if (portp->brdnr >= stli_nrbrds) 1366 return 0; 1367 brdp = stli_brds[portp->brdnr]; 1368 if (brdp == NULL) 1369 return 0; 1370 1371 spin_lock_irqsave(&brd_lock, flags); 1372 EBRDENABLE(brdp); 1373 rp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->txq; 1374 head = (unsigned int) readw(&rp->head); 1375 tail = (unsigned int) readw(&rp->tail); 1376 if (tail != ((unsigned int) readw(&rp->tail))) 1377 tail = (unsigned int) readw(&rp->tail); 1378 len = (head >= tail) ? (portp->txsize - (head - tail)) : (tail - head); 1379 len--; 1380 EBRDDISABLE(brdp); 1381 spin_unlock_irqrestore(&brd_lock, flags); 1382 1383 if (tty == stli_txcooktty) { 1384 stli_txcookrealsize = len; 1385 len -= stli_txcooksize; 1386 } 1387 return len; 1388} 1389 1390/*****************************************************************************/ 1391 1392/* 1393 * Return the number of characters in the transmit buffer. Normally we 1394 * will return the number of chars in the shared memory ring queue. 1395 * We need to kludge around the case where the shared memory buffer is 1396 * empty but not all characters have drained yet, for this case just 1397 * return that there is 1 character in the buffer! 1398 */ 1399 1400static int stli_charsinbuffer(struct tty_struct *tty) 1401{ 1402 cdkasyrq_t __iomem *rp; 1403 struct stliport *portp; 1404 struct stlibrd *brdp; 1405 unsigned int head, tail, len; 1406 unsigned long flags; 1407 1408 if (tty == stli_txcooktty) 1409 stli_flushchars(tty); 1410 portp = tty->driver_data; 1411 if (portp == NULL) 1412 return 0; 1413 if (portp->brdnr >= stli_nrbrds) 1414 return 0; 1415 brdp = stli_brds[portp->brdnr]; 1416 if (brdp == NULL) 1417 return 0; 1418 1419 spin_lock_irqsave(&brd_lock, flags); 1420 EBRDENABLE(brdp); 1421 rp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->txq; 1422 head = (unsigned int) readw(&rp->head); 1423 tail = (unsigned int) readw(&rp->tail); 1424 if (tail != ((unsigned int) readw(&rp->tail))) 1425 tail = (unsigned int) readw(&rp->tail); 1426 len = (head >= tail) ? (head - tail) : (portp->txsize - (tail - head)); 1427 if ((len == 0) && test_bit(ST_TXBUSY, &portp->state)) 1428 len = 1; 1429 EBRDDISABLE(brdp); 1430 spin_unlock_irqrestore(&brd_lock, flags); 1431 1432 return len; 1433} 1434 1435/*****************************************************************************/ 1436 1437/* 1438 * Generate the serial struct info. 1439 */ 1440 1441static int stli_getserial(struct stliport *portp, struct serial_struct __user *sp) 1442{ 1443 struct serial_struct sio; 1444 struct stlibrd *brdp; 1445 1446 memset(&sio, 0, sizeof(struct serial_struct)); 1447 sio.type = PORT_UNKNOWN; 1448 sio.line = portp->portnr; 1449 sio.irq = 0; 1450 sio.flags = portp->port.flags; 1451 sio.baud_base = portp->baud_base; 1452 sio.close_delay = portp->port.close_delay; 1453 sio.closing_wait = portp->closing_wait; 1454 sio.custom_divisor = portp->custom_divisor; 1455 sio.xmit_fifo_size = 0; 1456 sio.hub6 = 0; 1457 1458 brdp = stli_brds[portp->brdnr]; 1459 if (brdp != NULL) 1460 sio.port = brdp->iobase; 1461 1462 return copy_to_user(sp, &sio, sizeof(struct serial_struct)) ? 1463 -EFAULT : 0; 1464} 1465 1466/*****************************************************************************/ 1467 1468/* 1469 * Set port according to the serial struct info. 1470 * At this point we do not do any auto-configure stuff, so we will 1471 * just quietly ignore any requests to change irq, etc. 1472 */ 1473 1474static int stli_setserial(struct tty_struct *tty, struct serial_struct __user *sp) 1475{ 1476 struct serial_struct sio; 1477 int rc; 1478 struct stliport *portp = tty->driver_data; 1479 1480 if (copy_from_user(&sio, sp, sizeof(struct serial_struct))) 1481 return -EFAULT; 1482 if (!capable(CAP_SYS_ADMIN)) { 1483 if ((sio.baud_base != portp->baud_base) || 1484 (sio.close_delay != portp->port.close_delay) || 1485 ((sio.flags & ~ASYNC_USR_MASK) != 1486 (portp->port.flags & ~ASYNC_USR_MASK))) 1487 return -EPERM; 1488 } 1489 1490 portp->port.flags = (portp->port.flags & ~ASYNC_USR_MASK) | 1491 (sio.flags & ASYNC_USR_MASK); 1492 portp->baud_base = sio.baud_base; 1493 portp->port.close_delay = sio.close_delay; 1494 portp->closing_wait = sio.closing_wait; 1495 portp->custom_divisor = sio.custom_divisor; 1496 1497 if ((rc = stli_setport(tty)) < 0) 1498 return rc; 1499 return 0; 1500} 1501 1502/*****************************************************************************/ 1503 1504static int stli_tiocmget(struct tty_struct *tty, struct file *file) 1505{ 1506 struct stliport *portp = tty->driver_data; 1507 struct stlibrd *brdp; 1508 int rc; 1509 1510 if (portp == NULL) 1511 return -ENODEV; 1512 if (portp->brdnr >= stli_nrbrds) 1513 return 0; 1514 brdp = stli_brds[portp->brdnr]; 1515 if (brdp == NULL) 1516 return 0; 1517 if (tty->flags & (1 << TTY_IO_ERROR)) 1518 return -EIO; 1519 1520 if ((rc = stli_cmdwait(brdp, portp, A_GETSIGNALS, 1521 &portp->asig, sizeof(asysigs_t), 1)) < 0) 1522 return rc; 1523 1524 return stli_mktiocm(portp->asig.sigvalue); 1525} 1526 1527static int stli_tiocmset(struct tty_struct *tty, struct file *file, 1528 unsigned int set, unsigned int clear) 1529{ 1530 struct stliport *portp = tty->driver_data; 1531 struct stlibrd *brdp; 1532 int rts = -1, dtr = -1; 1533 1534 if (portp == NULL) 1535 return -ENODEV; 1536 if (portp->brdnr >= stli_nrbrds) 1537 return 0; 1538 brdp = stli_brds[portp->brdnr]; 1539 if (brdp == NULL) 1540 return 0; 1541 if (tty->flags & (1 << TTY_IO_ERROR)) 1542 return -EIO; 1543 1544 if (set & TIOCM_RTS) 1545 rts = 1; 1546 if (set & TIOCM_DTR) 1547 dtr = 1; 1548 if (clear & TIOCM_RTS) 1549 rts = 0; 1550 if (clear & TIOCM_DTR) 1551 dtr = 0; 1552 1553 stli_mkasysigs(&portp->asig, dtr, rts); 1554 1555 return stli_cmdwait(brdp, portp, A_SETSIGNALS, &portp->asig, 1556 sizeof(asysigs_t), 0); 1557} 1558 1559static int stli_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg) 1560{ 1561 struct stliport *portp; 1562 struct stlibrd *brdp; 1563 int rc; 1564 void __user *argp = (void __user *)arg; 1565 1566 portp = tty->driver_data; 1567 if (portp == NULL) 1568 return -ENODEV; 1569 if (portp->brdnr >= stli_nrbrds) 1570 return 0; 1571 brdp = stli_brds[portp->brdnr]; 1572 if (brdp == NULL) 1573 return 0; 1574 1575 if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) && 1576 (cmd != COM_GETPORTSTATS) && (cmd != COM_CLRPORTSTATS)) { 1577 if (tty->flags & (1 << TTY_IO_ERROR)) 1578 return -EIO; 1579 } 1580 1581 rc = 0; 1582 1583 switch (cmd) { 1584 case TIOCGSERIAL: 1585 rc = stli_getserial(portp, argp); 1586 break; 1587 case TIOCSSERIAL: 1588 rc = stli_setserial(tty, argp); 1589 break; 1590 case STL_GETPFLAG: 1591 rc = put_user(portp->pflag, (unsigned __user *)argp); 1592 break; 1593 case STL_SETPFLAG: 1594 if ((rc = get_user(portp->pflag, (unsigned __user *)argp)) == 0) 1595 stli_setport(tty); 1596 break; 1597 case COM_GETPORTSTATS: 1598 rc = stli_getportstats(tty, portp, argp); 1599 break; 1600 case COM_CLRPORTSTATS: 1601 rc = stli_clrportstats(portp, argp); 1602 break; 1603 case TIOCSERCONFIG: 1604 case TIOCSERGWILD: 1605 case TIOCSERSWILD: 1606 case TIOCSERGETLSR: 1607 case TIOCSERGSTRUCT: 1608 case TIOCSERGETMULTI: 1609 case TIOCSERSETMULTI: 1610 default: 1611 rc = -ENOIOCTLCMD; 1612 break; 1613 } 1614 1615 return rc; 1616} 1617 1618/*****************************************************************************/ 1619 1620/* 1621 * This routine assumes that we have user context and can sleep. 1622 * Looks like it is true for the current ttys implementation..!! 1623 */ 1624 1625static void stli_settermios(struct tty_struct *tty, struct ktermios *old) 1626{ 1627 struct stliport *portp; 1628 struct stlibrd *brdp; 1629 struct ktermios *tiosp; 1630 asyport_t aport; 1631 1632 portp = tty->driver_data; 1633 if (portp == NULL) 1634 return; 1635 if (portp->brdnr >= stli_nrbrds) 1636 return; 1637 brdp = stli_brds[portp->brdnr]; 1638 if (brdp == NULL) 1639 return; 1640 1641 tiosp = tty->termios; 1642 1643 stli_mkasyport(tty, portp, &aport, tiosp); 1644 stli_cmdwait(brdp, portp, A_SETPORT, &aport, sizeof(asyport_t), 0); 1645 stli_mkasysigs(&portp->asig, ((tiosp->c_cflag & CBAUD) ? 1 : 0), -1); 1646 stli_cmdwait(brdp, portp, A_SETSIGNALS, &portp->asig, 1647 sizeof(asysigs_t), 0); 1648 if ((old->c_cflag & CRTSCTS) && ((tiosp->c_cflag & CRTSCTS) == 0)) 1649 tty->hw_stopped = 0; 1650 if (((old->c_cflag & CLOCAL) == 0) && (tiosp->c_cflag & CLOCAL)) 1651 wake_up_interruptible(&portp->port.open_wait); 1652} 1653 1654/*****************************************************************************/ 1655 1656/* 1657 * Attempt to flow control who ever is sending us data. We won't really 1658 * do any flow control action here. We can't directly, and even if we 1659 * wanted to we would have to send a command to the slave. The slave 1660 * knows how to flow control, and will do so when its buffers reach its 1661 * internal high water marks. So what we will do is set a local state 1662 * bit that will stop us sending any RX data up from the poll routine 1663 * (which is the place where RX data from the slave is handled). 1664 */ 1665 1666static void stli_throttle(struct tty_struct *tty) 1667{ 1668 struct stliport *portp = tty->driver_data; 1669 if (portp == NULL) 1670 return; 1671 set_bit(ST_RXSTOP, &portp->state); 1672} 1673 1674/*****************************************************************************/ 1675 1676/* 1677 * Unflow control the device sending us data... That means that all 1678 * we have to do is clear the RXSTOP state bit. The next poll call 1679 * will then be able to pass the RX data back up. 1680 */ 1681 1682static void stli_unthrottle(struct tty_struct *tty) 1683{ 1684 struct stliport *portp = tty->driver_data; 1685 if (portp == NULL) 1686 return; 1687 clear_bit(ST_RXSTOP, &portp->state); 1688} 1689 1690/*****************************************************************************/ 1691 1692/* 1693 * Stop the transmitter. 1694 */ 1695 1696static void stli_stop(struct tty_struct *tty) 1697{ 1698} 1699 1700/*****************************************************************************/ 1701 1702/* 1703 * Start the transmitter again. 1704 */ 1705 1706static void stli_start(struct tty_struct *tty) 1707{ 1708} 1709 1710/*****************************************************************************/ 1711 1712 1713/* 1714 * Hangup this port. This is pretty much like closing the port, only 1715 * a little more brutal. No waiting for data to drain. Shutdown the 1716 * port and maybe drop signals. This is rather tricky really. We want 1717 * to close the port as well. 1718 */ 1719 1720static void stli_hangup(struct tty_struct *tty) 1721{ 1722 struct stliport *portp = tty->driver_data; 1723 tty_port_hangup(&portp->port); 1724} 1725 1726/*****************************************************************************/ 1727 1728/* 1729 * Flush characters from the lower buffer. We may not have user context 1730 * so we cannot sleep waiting for it to complete. Also we need to check 1731 * if there is chars for this port in the TX cook buffer, and flush them 1732 * as well. 1733 */ 1734 1735static void stli_flushbuffer(struct tty_struct *tty) 1736{ 1737 struct stliport *portp; 1738 struct stlibrd *brdp; 1739 unsigned long ftype, flags; 1740 1741 portp = tty->driver_data; 1742 if (portp == NULL) 1743 return; 1744 if (portp->brdnr >= stli_nrbrds) 1745 return; 1746 brdp = stli_brds[portp->brdnr]; 1747 if (brdp == NULL) 1748 return; 1749 1750 spin_lock_irqsave(&brd_lock, flags); 1751 if (tty == stli_txcooktty) { 1752 stli_txcooktty = NULL; 1753 stli_txcooksize = 0; 1754 stli_txcookrealsize = 0; 1755 } 1756 if (test_bit(ST_CMDING, &portp->state)) { 1757 set_bit(ST_DOFLUSHTX, &portp->state); 1758 } else { 1759 ftype = FLUSHTX; 1760 if (test_bit(ST_DOFLUSHRX, &portp->state)) { 1761 ftype |= FLUSHRX; 1762 clear_bit(ST_DOFLUSHRX, &portp->state); 1763 } 1764 __stli_sendcmd(brdp, portp, A_FLUSH, &ftype, sizeof(u32), 0); 1765 } 1766 spin_unlock_irqrestore(&brd_lock, flags); 1767 tty_wakeup(tty); 1768} 1769 1770/*****************************************************************************/ 1771 1772static int stli_breakctl(struct tty_struct *tty, int state) 1773{ 1774 struct stlibrd *brdp; 1775 struct stliport *portp; 1776 long arg; 1777 1778 portp = tty->driver_data; 1779 if (portp == NULL) 1780 return -EINVAL; 1781 if (portp->brdnr >= stli_nrbrds) 1782 return -EINVAL; 1783 brdp = stli_brds[portp->brdnr]; 1784 if (brdp == NULL) 1785 return -EINVAL; 1786 1787 arg = (state == -1) ? BREAKON : BREAKOFF; 1788 stli_cmdwait(brdp, portp, A_BREAK, &arg, sizeof(long), 0); 1789 return 0; 1790} 1791 1792/*****************************************************************************/ 1793 1794static void stli_waituntilsent(struct tty_struct *tty, int timeout) 1795{ 1796 struct stliport *portp; 1797 unsigned long tend; 1798 1799 portp = tty->driver_data; 1800 if (portp == NULL) 1801 return; 1802 1803 if (timeout == 0) 1804 timeout = HZ; 1805 tend = jiffies + timeout; 1806 1807 while (test_bit(ST_TXBUSY, &portp->state)) { 1808 if (signal_pending(current)) 1809 break; 1810 msleep_interruptible(20); 1811 if (time_after_eq(jiffies, tend)) 1812 break; 1813 } 1814} 1815 1816/*****************************************************************************/ 1817 1818static void stli_sendxchar(struct tty_struct *tty, char ch) 1819{ 1820 struct stlibrd *brdp; 1821 struct stliport *portp; 1822 asyctrl_t actrl; 1823 1824 portp = tty->driver_data; 1825 if (portp == NULL) 1826 return; 1827 if (portp->brdnr >= stli_nrbrds) 1828 return; 1829 brdp = stli_brds[portp->brdnr]; 1830 if (brdp == NULL) 1831 return; 1832 1833 memset(&actrl, 0, sizeof(asyctrl_t)); 1834 if (ch == STOP_CHAR(tty)) { 1835 actrl.rxctrl = CT_STOPFLOW; 1836 } else if (ch == START_CHAR(tty)) { 1837 actrl.rxctrl = CT_STARTFLOW; 1838 } else { 1839 actrl.txctrl = CT_SENDCHR; 1840 actrl.tximdch = ch; 1841 } 1842 stli_cmdwait(brdp, portp, A_PORTCTRL, &actrl, sizeof(asyctrl_t), 0); 1843} 1844 1845static void stli_portinfo(struct seq_file *m, struct stlibrd *brdp, struct stliport *portp, int portnr) 1846{ 1847 char *uart; 1848 int rc; 1849 1850 rc = stli_portcmdstats(NULL, portp); 1851 1852 uart = "UNKNOWN"; 1853 if (test_bit(BST_STARTED, &brdp->state)) { 1854 switch (stli_comstats.hwid) { 1855 case 0: uart = "2681"; break; 1856 case 1: uart = "SC26198"; break; 1857 default:uart = "CD1400"; break; 1858 } 1859 } 1860 seq_printf(m, "%d: uart:%s ", portnr, uart); 1861 1862 if (test_bit(BST_STARTED, &brdp->state) && rc >= 0) { 1863 char sep; 1864 1865 seq_printf(m, "tx:%d rx:%d", (int) stli_comstats.txtotal, 1866 (int) stli_comstats.rxtotal); 1867 1868 if (stli_comstats.rxframing) 1869 seq_printf(m, " fe:%d", 1870 (int) stli_comstats.rxframing); 1871 if (stli_comstats.rxparity) 1872 seq_printf(m, " pe:%d", 1873 (int) stli_comstats.rxparity); 1874 if (stli_comstats.rxbreaks) 1875 seq_printf(m, " brk:%d", 1876 (int) stli_comstats.rxbreaks); 1877 if (stli_comstats.rxoverrun) 1878 seq_printf(m, " oe:%d", 1879 (int) stli_comstats.rxoverrun); 1880 1881 sep = ' '; 1882 if (stli_comstats.signals & TIOCM_RTS) { 1883 seq_printf(m, "%c%s", sep, "RTS"); 1884 sep = '|'; 1885 } 1886 if (stli_comstats.signals & TIOCM_CTS) { 1887 seq_printf(m, "%c%s", sep, "CTS"); 1888 sep = '|'; 1889 } 1890 if (stli_comstats.signals & TIOCM_DTR) { 1891 seq_printf(m, "%c%s", sep, "DTR"); 1892 sep = '|'; 1893 } 1894 if (stli_comstats.signals & TIOCM_CD) { 1895 seq_printf(m, "%c%s", sep, "DCD"); 1896 sep = '|'; 1897 } 1898 if (stli_comstats.signals & TIOCM_DSR) { 1899 seq_printf(m, "%c%s", sep, "DSR"); 1900 sep = '|'; 1901 } 1902 } 1903 seq_putc(m, '\n'); 1904} 1905 1906/*****************************************************************************/ 1907 1908/* 1909 * Port info, read from the /proc file system. 1910 */ 1911 1912static int stli_proc_show(struct seq_file *m, void *v) 1913{ 1914 struct stlibrd *brdp; 1915 struct stliport *portp; 1916 unsigned int brdnr, portnr, totalport; 1917 1918 totalport = 0; 1919 1920 seq_printf(m, "%s: version %s\n", stli_drvtitle, stli_drvversion); 1921 1922/* 1923 * We scan through for each board, panel and port. The offset is 1924 * calculated on the fly, and irrelevant ports are skipped. 1925 */ 1926 for (brdnr = 0; (brdnr < stli_nrbrds); brdnr++) { 1927 brdp = stli_brds[brdnr]; 1928 if (brdp == NULL) 1929 continue; 1930 if (brdp->state == 0) 1931 continue; 1932 1933 totalport = brdnr * STL_MAXPORTS; 1934 for (portnr = 0; (portnr < brdp->nrports); portnr++, 1935 totalport++) { 1936 portp = brdp->ports[portnr]; 1937 if (portp == NULL) 1938 continue; 1939 stli_portinfo(m, brdp, portp, totalport); 1940 } 1941 } 1942 return 0; 1943} 1944 1945static int stli_proc_open(struct inode *inode, struct file *file) 1946{ 1947 return single_open(file, stli_proc_show, NULL); 1948} 1949 1950static const struct file_operations stli_proc_fops = { 1951 .owner = THIS_MODULE, 1952 .open = stli_proc_open, 1953 .read = seq_read, 1954 .llseek = seq_lseek, 1955 .release = single_release, 1956}; 1957 1958/*****************************************************************************/ 1959 1960/* 1961 * Generic send command routine. This will send a message to the slave, 1962 * of the specified type with the specified argument. Must be very 1963 * careful of data that will be copied out from shared memory - 1964 * containing command results. The command completion is all done from 1965 * a poll routine that does not have user context. Therefore you cannot 1966 * copy back directly into user space, or to the kernel stack of a 1967 * process. This routine does not sleep, so can be called from anywhere. 1968 * 1969 * The caller must hold the brd_lock (see also stli_sendcmd the usual 1970 * entry point) 1971 */ 1972 1973static void __stli_sendcmd(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback) 1974{ 1975 cdkhdr_t __iomem *hdrp; 1976 cdkctrl_t __iomem *cp; 1977 unsigned char __iomem *bits; 1978 1979 if (test_bit(ST_CMDING, &portp->state)) { 1980 printk(KERN_ERR "istallion: command already busy, cmd=%x!\n", 1981 (int) cmd); 1982 return; 1983 } 1984 1985 EBRDENABLE(brdp); 1986 cp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->ctrl; 1987 if (size > 0) { 1988 memcpy_toio((void __iomem *) &(cp->args[0]), arg, size); 1989 if (copyback) { 1990 portp->argp = arg; 1991 portp->argsize = size; 1992 } 1993 } 1994 writel(0, &cp->status); 1995 writel(cmd, &cp->cmd); 1996 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR); 1997 bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset + 1998 portp->portidx; 1999 writeb(readb(bits) | portp->portbit, bits); 2000 set_bit(ST_CMDING, &portp->state); 2001 EBRDDISABLE(brdp); 2002} 2003 2004static void stli_sendcmd(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback) 2005{ 2006 unsigned long flags; 2007 2008 spin_lock_irqsave(&brd_lock, flags); 2009 __stli_sendcmd(brdp, portp, cmd, arg, size, copyback); 2010 spin_unlock_irqrestore(&brd_lock, flags); 2011} 2012 2013/*****************************************************************************/ 2014 2015/* 2016 * Read data from shared memory. This assumes that the shared memory 2017 * is enabled and that interrupts are off. Basically we just empty out 2018 * the shared memory buffer into the tty buffer. Must be careful to 2019 * handle the case where we fill up the tty buffer, but still have 2020 * more chars to unload. 2021 */ 2022 2023static void stli_read(struct stlibrd *brdp, struct stliport *portp) 2024{ 2025 cdkasyrq_t __iomem *rp; 2026 char __iomem *shbuf; 2027 struct tty_struct *tty; 2028 unsigned int head, tail, size; 2029 unsigned int len, stlen; 2030 2031 if (test_bit(ST_RXSTOP, &portp->state)) 2032 return; 2033 tty = tty_port_tty_get(&portp->port); 2034 if (tty == NULL) 2035 return; 2036 2037 rp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->rxq; 2038 head = (unsigned int) readw(&rp->head); 2039 if (head != ((unsigned int) readw(&rp->head))) 2040 head = (unsigned int) readw(&rp->head); 2041 tail = (unsigned int) readw(&rp->tail); 2042 size = portp->rxsize; 2043 if (head >= tail) { 2044 len = head - tail; 2045 stlen = len; 2046 } else { 2047 len = size - (tail - head); 2048 stlen = size - tail; 2049 } 2050 2051 len = tty_buffer_request_room(tty, len); 2052 2053 shbuf = (char __iomem *) EBRDGETMEMPTR(brdp, portp->rxoffset); 2054 2055 while (len > 0) { 2056 unsigned char *cptr; 2057 2058 stlen = min(len, stlen); 2059 tty_prepare_flip_string(tty, &cptr, stlen); 2060 memcpy_fromio(cptr, shbuf + tail, stlen); 2061 len -= stlen; 2062 tail += stlen; 2063 if (tail >= size) { 2064 tail = 0; 2065 stlen = head; 2066 } 2067 } 2068 rp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->rxq; 2069 writew(tail, &rp->tail); 2070 2071 if (head != tail) 2072 set_bit(ST_RXING, &portp->state); 2073 2074 tty_schedule_flip(tty); 2075 tty_kref_put(tty); 2076} 2077 2078/*****************************************************************************/ 2079 2080/* 2081 * Set up and carry out any delayed commands. There is only a small set 2082 * of slave commands that can be done "off-level". So it is not too 2083 * difficult to deal with them here. 2084 */ 2085 2086static void stli_dodelaycmd(struct stliport *portp, cdkctrl_t __iomem *cp) 2087{ 2088 int cmd; 2089 2090 if (test_bit(ST_DOSIGS, &portp->state)) { 2091 if (test_bit(ST_DOFLUSHTX, &portp->state) && 2092 test_bit(ST_DOFLUSHRX, &portp->state)) 2093 cmd = A_SETSIGNALSF; 2094 else if (test_bit(ST_DOFLUSHTX, &portp->state)) 2095 cmd = A_SETSIGNALSFTX; 2096 else if (test_bit(ST_DOFLUSHRX, &portp->state)) 2097 cmd = A_SETSIGNALSFRX; 2098 else 2099 cmd = A_SETSIGNALS; 2100 clear_bit(ST_DOFLUSHTX, &portp->state); 2101 clear_bit(ST_DOFLUSHRX, &portp->state); 2102 clear_bit(ST_DOSIGS, &portp->state); 2103 memcpy_toio((void __iomem *) &(cp->args[0]), (void *) &portp->asig, 2104 sizeof(asysigs_t)); 2105 writel(0, &cp->status); 2106 writel(cmd, &cp->cmd); 2107 set_bit(ST_CMDING, &portp->state); 2108 } else if (test_bit(ST_DOFLUSHTX, &portp->state) || 2109 test_bit(ST_DOFLUSHRX, &portp->state)) { 2110 cmd = ((test_bit(ST_DOFLUSHTX, &portp->state)) ? FLUSHTX : 0); 2111 cmd |= ((test_bit(ST_DOFLUSHRX, &portp->state)) ? FLUSHRX : 0); 2112 clear_bit(ST_DOFLUSHTX, &portp->state); 2113 clear_bit(ST_DOFLUSHRX, &portp->state); 2114 memcpy_toio((void __iomem *) &(cp->args[0]), (void *) &cmd, sizeof(int)); 2115 writel(0, &cp->status); 2116 writel(A_FLUSH, &cp->cmd); 2117 set_bit(ST_CMDING, &portp->state); 2118 } 2119} 2120 2121/*****************************************************************************/ 2122 2123/* 2124 * Host command service checking. This handles commands or messages 2125 * coming from the slave to the host. Must have board shared memory 2126 * enabled and interrupts off when called. Notice that by servicing the 2127 * read data last we don't need to change the shared memory pointer 2128 * during processing (which is a slow IO operation). 2129 * Return value indicates if this port is still awaiting actions from 2130 * the slave (like open, command, or even TX data being sent). If 0 2131 * then port is still busy, otherwise no longer busy. 2132 */ 2133 2134static int stli_hostcmd(struct stlibrd *brdp, struct stliport *portp) 2135{ 2136 cdkasy_t __iomem *ap; 2137 cdkctrl_t __iomem *cp; 2138 struct tty_struct *tty; 2139 asynotify_t nt; 2140 unsigned long oldsigs; 2141 int rc, donerx; 2142 2143 ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr); 2144 cp = &ap->ctrl; 2145 2146/* 2147 * Check if we are waiting for an open completion message. 2148 */ 2149 if (test_bit(ST_OPENING, &portp->state)) { 2150 rc = readl(&cp->openarg); 2151 if (readb(&cp->open) == 0 && rc != 0) { 2152 if (rc > 0) 2153 rc--; 2154 writel(0, &cp->openarg); 2155 portp->rc = rc; 2156 clear_bit(ST_OPENING, &portp->state); 2157 wake_up_interruptible(&portp->raw_wait); 2158 } 2159 } 2160 2161/* 2162 * Check if we are waiting for a close completion message. 2163 */ 2164 if (test_bit(ST_CLOSING, &portp->state)) { 2165 rc = (int) readl(&cp->closearg); 2166 if (readb(&cp->close) == 0 && rc != 0) { 2167 if (rc > 0) 2168 rc--; 2169 writel(0, &cp->closearg); 2170 portp->rc = rc; 2171 clear_bit(ST_CLOSING, &portp->state); 2172 wake_up_interruptible(&portp->raw_wait); 2173 } 2174 } 2175 2176/* 2177 * Check if we are waiting for a command completion message. We may 2178 * need to copy out the command results associated with this command. 2179 */ 2180 if (test_bit(ST_CMDING, &portp->state)) { 2181 rc = readl(&cp->status); 2182 if (readl(&cp->cmd) == 0 && rc != 0) { 2183 if (rc > 0) 2184 rc--; 2185 if (portp->argp != NULL) { 2186 memcpy_fromio(portp->argp, (void __iomem *) &(cp->args[0]), 2187 portp->argsize); 2188 portp->argp = NULL; 2189 } 2190 writel(0, &cp->status); 2191 portp->rc = rc; 2192 clear_bit(ST_CMDING, &portp->state); 2193 stli_dodelaycmd(portp, cp); 2194 wake_up_interruptible(&portp->raw_wait); 2195 } 2196 } 2197 2198/* 2199 * Check for any notification messages ready. This includes lots of 2200 * different types of events - RX chars ready, RX break received, 2201 * TX data low or empty in the slave, modem signals changed state. 2202 */ 2203 donerx = 0; 2204 2205 if (ap->notify) { 2206 nt = ap->changed; 2207 ap->notify = 0; 2208 tty = tty_port_tty_get(&portp->port); 2209 2210 if (nt.signal & SG_DCD) { 2211 oldsigs = portp->sigs; 2212 portp->sigs = stli_mktiocm(nt.sigvalue); 2213 clear_bit(ST_GETSIGS, &portp->state); 2214 if ((portp->sigs & TIOCM_CD) && 2215 ((oldsigs & TIOCM_CD) == 0)) 2216 wake_up_interruptible(&portp->port.open_wait); 2217 if ((oldsigs & TIOCM_CD) && 2218 ((portp->sigs & TIOCM_CD) == 0)) { 2219 if (portp->port.flags & ASYNC_CHECK_CD) { 2220 if (tty) 2221 tty_hangup(tty); 2222 } 2223 } 2224 } 2225 2226 if (nt.data & DT_TXEMPTY) 2227 clear_bit(ST_TXBUSY, &portp->state); 2228 if (nt.data & (DT_TXEMPTY | DT_TXLOW)) { 2229 if (tty != NULL) { 2230 tty_wakeup(tty); 2231 EBRDENABLE(brdp); 2232 } 2233 } 2234 2235 if ((nt.data & DT_RXBREAK) && (portp->rxmarkmsk & BRKINT)) { 2236 if (tty != NULL) { 2237 tty_insert_flip_char(tty, 0, TTY_BREAK); 2238 if (portp->port.flags & ASYNC_SAK) { 2239 do_SAK(tty); 2240 EBRDENABLE(brdp); 2241 } 2242 tty_schedule_flip(tty); 2243 } 2244 } 2245 tty_kref_put(tty); 2246 2247 if (nt.data & DT_RXBUSY) { 2248 donerx++; 2249 stli_read(brdp, portp); 2250 } 2251 } 2252 2253/* 2254 * It might seem odd that we are checking for more RX chars here. 2255 * But, we need to handle the case where the tty buffer was previously 2256 * filled, but we had more characters to pass up. The slave will not 2257 * send any more RX notify messages until the RX buffer has been emptied. 2258 * But it will leave the service bits on (since the buffer is not empty). 2259 * So from here we can try to process more RX chars. 2260 */ 2261 if ((!donerx) && test_bit(ST_RXING, &portp->state)) { 2262 clear_bit(ST_RXING, &portp->state); 2263 stli_read(brdp, portp); 2264 } 2265 2266 return((test_bit(ST_OPENING, &portp->state) || 2267 test_bit(ST_CLOSING, &portp->state) || 2268 test_bit(ST_CMDING, &portp->state) || 2269 test_bit(ST_TXBUSY, &portp->state) || 2270 test_bit(ST_RXING, &portp->state)) ? 0 : 1); 2271} 2272 2273/*****************************************************************************/ 2274 2275/* 2276 * Service all ports on a particular board. Assumes that the boards 2277 * shared memory is enabled, and that the page pointer is pointed 2278 * at the cdk header structure. 2279 */ 2280 2281static void stli_brdpoll(struct stlibrd *brdp, cdkhdr_t __iomem *hdrp) 2282{ 2283 struct stliport *portp; 2284 unsigned char hostbits[(STL_MAXCHANS / 8) + 1]; 2285 unsigned char slavebits[(STL_MAXCHANS / 8) + 1]; 2286 unsigned char __iomem *slavep; 2287 int bitpos, bitat, bitsize; 2288 int channr, nrdevs, slavebitchange; 2289 2290 bitsize = brdp->bitsize; 2291 nrdevs = brdp->nrdevs; 2292 2293/* 2294 * Check if slave wants any service. Basically we try to do as 2295 * little work as possible here. There are 2 levels of service 2296 * bits. So if there is nothing to do we bail early. We check 2297 * 8 service bits at a time in the inner loop, so we can bypass 2298 * the lot if none of them want service. 2299 */ 2300 memcpy_fromio(&hostbits[0], (((unsigned char __iomem *) hdrp) + brdp->hostoffset), 2301 bitsize); 2302 2303 memset(&slavebits[0], 0, bitsize); 2304 slavebitchange = 0; 2305 2306 for (bitpos = 0; (bitpos < bitsize); bitpos++) { 2307 if (hostbits[bitpos] == 0) 2308 continue; 2309 channr = bitpos * 8; 2310 for (bitat = 0x1; (channr < nrdevs); channr++, bitat <<= 1) { 2311 if (hostbits[bitpos] & bitat) { 2312 portp = brdp->ports[(channr - 1)]; 2313 if (stli_hostcmd(brdp, portp)) { 2314 slavebitchange++; 2315 slavebits[bitpos] |= bitat; 2316 } 2317 } 2318 } 2319 } 2320 2321/* 2322 * If any of the ports are no longer busy then update them in the 2323 * slave request bits. We need to do this after, since a host port 2324 * service may initiate more slave requests. 2325 */ 2326 if (slavebitchange) { 2327 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR); 2328 slavep = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset; 2329 for (bitpos = 0; (bitpos < bitsize); bitpos++) { 2330 if (readb(slavebits + bitpos)) 2331 writeb(readb(slavep + bitpos) & ~slavebits[bitpos], slavebits + bitpos); 2332 } 2333 } 2334} 2335 2336/*****************************************************************************/ 2337 2338/* 2339 * Driver poll routine. This routine polls the boards in use and passes 2340 * messages back up to host when necessary. This is actually very 2341 * CPU efficient, since we will always have the kernel poll clock, it 2342 * adds only a few cycles when idle (since board service can be 2343 * determined very easily), but when loaded generates no interrupts 2344 * (with their expensive associated context change). 2345 */ 2346 2347static void stli_poll(unsigned long arg) 2348{ 2349 cdkhdr_t __iomem *hdrp; 2350 struct stlibrd *brdp; 2351 unsigned int brdnr; 2352 2353 mod_timer(&stli_timerlist, STLI_TIMEOUT); 2354 2355/* 2356 * Check each board and do any servicing required. 2357 */ 2358 for (brdnr = 0; (brdnr < stli_nrbrds); brdnr++) { 2359 brdp = stli_brds[brdnr]; 2360 if (brdp == NULL) 2361 continue; 2362 if (!test_bit(BST_STARTED, &brdp->state)) 2363 continue; 2364 2365 spin_lock(&brd_lock); 2366 EBRDENABLE(brdp); 2367 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR); 2368 if (readb(&hdrp->hostreq)) 2369 stli_brdpoll(brdp, hdrp); 2370 EBRDDISABLE(brdp); 2371 spin_unlock(&brd_lock); 2372 } 2373} 2374 2375/*****************************************************************************/ 2376 2377/* 2378 * Translate the termios settings into the port setting structure of 2379 * the slave. 2380 */ 2381 2382static void stli_mkasyport(struct tty_struct *tty, struct stliport *portp, 2383 asyport_t *pp, struct ktermios *tiosp) 2384{ 2385 memset(pp, 0, sizeof(asyport_t)); 2386 2387/* 2388 * Start of by setting the baud, char size, parity and stop bit info. 2389 */ 2390 pp->baudout = tty_get_baud_rate(tty); 2391 if ((tiosp->c_cflag & CBAUD) == B38400) { 2392 if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI) 2393 pp->baudout = 57600; 2394 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI) 2395 pp->baudout = 115200; 2396 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI) 2397 pp->baudout = 230400; 2398 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP) 2399 pp->baudout = 460800; 2400 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST) 2401 pp->baudout = (portp->baud_base / portp->custom_divisor); 2402 } 2403 if (pp->baudout > STL_MAXBAUD) 2404 pp->baudout = STL_MAXBAUD; 2405 pp->baudin = pp->baudout; 2406 2407 switch (tiosp->c_cflag & CSIZE) { 2408 case CS5: 2409 pp->csize = 5; 2410 break; 2411 case CS6: 2412 pp->csize = 6; 2413 break; 2414 case CS7: 2415 pp->csize = 7; 2416 break; 2417 default: 2418 pp->csize = 8; 2419 break; 2420 } 2421 2422 if (tiosp->c_cflag & CSTOPB) 2423 pp->stopbs = PT_STOP2; 2424 else 2425 pp->stopbs = PT_STOP1; 2426 2427 if (tiosp->c_cflag & PARENB) { 2428 if (tiosp->c_cflag & PARODD) 2429 pp->parity = PT_ODDPARITY; 2430 else 2431 pp->parity = PT_EVENPARITY; 2432 } else { 2433 pp->parity = PT_NOPARITY; 2434 } 2435 2436/* 2437 * Set up any flow control options enabled. 2438 */ 2439 if (tiosp->c_iflag & IXON) { 2440 pp->flow |= F_IXON; 2441 if (tiosp->c_iflag & IXANY) 2442 pp->flow |= F_IXANY; 2443 } 2444 if (tiosp->c_cflag & CRTSCTS) 2445 pp->flow |= (F_RTSFLOW | F_CTSFLOW); 2446 2447 pp->startin = tiosp->c_cc[VSTART]; 2448 pp->stopin = tiosp->c_cc[VSTOP]; 2449 pp->startout = tiosp->c_cc[VSTART]; 2450 pp->stopout = tiosp->c_cc[VSTOP]; 2451 2452/* 2453 * Set up the RX char marking mask with those RX error types we must 2454 * catch. We can get the slave to help us out a little here, it will 2455 * ignore parity errors and breaks for us, and mark parity errors in 2456 * the data stream. 2457 */ 2458 if (tiosp->c_iflag & IGNPAR) 2459 pp->iflag |= FI_IGNRXERRS; 2460 if (tiosp->c_iflag & IGNBRK) 2461 pp->iflag |= FI_IGNBREAK; 2462 2463 portp->rxmarkmsk = 0; 2464 if (tiosp->c_iflag & (INPCK | PARMRK)) 2465 pp->iflag |= FI_1MARKRXERRS; 2466 if (tiosp->c_iflag & BRKINT) 2467 portp->rxmarkmsk |= BRKINT; 2468 2469/* 2470 * Set up clocal processing as required. 2471 */ 2472 if (tiosp->c_cflag & CLOCAL) 2473 portp->port.flags &= ~ASYNC_CHECK_CD; 2474 else 2475 portp->port.flags |= ASYNC_CHECK_CD; 2476 2477/* 2478 * Transfer any persistent flags into the asyport structure. 2479 */ 2480 pp->pflag = (portp->pflag & 0xffff); 2481 pp->vmin = (portp->pflag & P_RXIMIN) ? 1 : 0; 2482 pp->vtime = (portp->pflag & P_RXITIME) ? 1 : 0; 2483 pp->cc[1] = (portp->pflag & P_RXTHOLD) ? 1 : 0; 2484} 2485 2486/*****************************************************************************/ 2487 2488/* 2489 * Construct a slave signals structure for setting the DTR and RTS 2490 * signals as specified. 2491 */ 2492 2493static void stli_mkasysigs(asysigs_t *sp, int dtr, int rts) 2494{ 2495 memset(sp, 0, sizeof(asysigs_t)); 2496 if (dtr >= 0) { 2497 sp->signal |= SG_DTR; 2498 sp->sigvalue |= ((dtr > 0) ? SG_DTR : 0); 2499 } 2500 if (rts >= 0) { 2501 sp->signal |= SG_RTS; 2502 sp->sigvalue |= ((rts > 0) ? SG_RTS : 0); 2503 } 2504} 2505 2506/*****************************************************************************/ 2507 2508/* 2509 * Convert the signals returned from the slave into a local TIOCM type 2510 * signals value. We keep them locally in TIOCM format. 2511 */ 2512 2513static long stli_mktiocm(unsigned long sigvalue) 2514{ 2515 long tiocm = 0; 2516 tiocm |= ((sigvalue & SG_DCD) ? TIOCM_CD : 0); 2517 tiocm |= ((sigvalue & SG_CTS) ? TIOCM_CTS : 0); 2518 tiocm |= ((sigvalue & SG_RI) ? TIOCM_RI : 0); 2519 tiocm |= ((sigvalue & SG_DSR) ? TIOCM_DSR : 0); 2520 tiocm |= ((sigvalue & SG_DTR) ? TIOCM_DTR : 0); 2521 tiocm |= ((sigvalue & SG_RTS) ? TIOCM_RTS : 0); 2522 return(tiocm); 2523} 2524 2525/*****************************************************************************/ 2526 2527/* 2528 * All panels and ports actually attached have been worked out. All 2529 * we need to do here is set up the appropriate per port data structures. 2530 */ 2531 2532static int stli_initports(struct stlibrd *brdp) 2533{ 2534 struct stliport *portp; 2535 unsigned int i, panelnr, panelport; 2536 2537 for (i = 0, panelnr = 0, panelport = 0; (i < brdp->nrports); i++) { 2538 portp = kzalloc(sizeof(struct stliport), GFP_KERNEL); 2539 if (!portp) { 2540 printk(KERN_WARNING "istallion: failed to allocate port structure\n"); 2541 continue; 2542 } 2543 tty_port_init(&portp->port); 2544 portp->port.ops = &stli_port_ops; 2545 portp->magic = STLI_PORTMAGIC; 2546 portp->portnr = i; 2547 portp->brdnr = brdp->brdnr; 2548 portp->panelnr = panelnr; 2549 portp->baud_base = STL_BAUDBASE; 2550 portp->port.close_delay = STL_CLOSEDELAY; 2551 portp->closing_wait = 30 * HZ; 2552 init_waitqueue_head(&portp->port.open_wait); 2553 init_waitqueue_head(&portp->port.close_wait); 2554 init_waitqueue_head(&portp->raw_wait); 2555 panelport++; 2556 if (panelport >= brdp->panels[panelnr]) { 2557 panelport = 0; 2558 panelnr++; 2559 } 2560 brdp->ports[i] = portp; 2561 } 2562 2563 return 0; 2564} 2565 2566/*****************************************************************************/ 2567 2568/* 2569 * All the following routines are board specific hardware operations. 2570 */ 2571 2572static void stli_ecpinit(struct stlibrd *brdp) 2573{ 2574 unsigned long memconf; 2575 2576 outb(ECP_ATSTOP, (brdp->iobase + ECP_ATCONFR)); 2577 udelay(10); 2578 outb(ECP_ATDISABLE, (brdp->iobase + ECP_ATCONFR)); 2579 udelay(100); 2580 2581 memconf = (brdp->memaddr & ECP_ATADDRMASK) >> ECP_ATADDRSHFT; 2582 outb(memconf, (brdp->iobase + ECP_ATMEMAR)); 2583} 2584 2585/*****************************************************************************/ 2586 2587static void stli_ecpenable(struct stlibrd *brdp) 2588{ 2589 outb(ECP_ATENABLE, (brdp->iobase + ECP_ATCONFR)); 2590} 2591 2592/*****************************************************************************/ 2593 2594static void stli_ecpdisable(struct stlibrd *brdp) 2595{ 2596 outb(ECP_ATDISABLE, (brdp->iobase + ECP_ATCONFR)); 2597} 2598 2599/*****************************************************************************/ 2600 2601static void __iomem *stli_ecpgetmemptr(struct stlibrd *brdp, unsigned long offset, int line) 2602{ 2603 void __iomem *ptr; 2604 unsigned char val; 2605 2606 if (offset > brdp->memsize) { 2607 printk(KERN_ERR "istallion: shared memory pointer=%x out of " 2608 "range at line=%d(%d), brd=%d\n", 2609 (int) offset, line, __LINE__, brdp->brdnr); 2610 ptr = NULL; 2611 val = 0; 2612 } else { 2613 ptr = brdp->membase + (offset % ECP_ATPAGESIZE); 2614 val = (unsigned char) (offset / ECP_ATPAGESIZE); 2615 } 2616 outb(val, (brdp->iobase + ECP_ATMEMPR)); 2617 return(ptr); 2618} 2619 2620/*****************************************************************************/ 2621 2622static void stli_ecpreset(struct stlibrd *brdp) 2623{ 2624 outb(ECP_ATSTOP, (brdp->iobase + ECP_ATCONFR)); 2625 udelay(10); 2626 outb(ECP_ATDISABLE, (brdp->iobase + ECP_ATCONFR)); 2627 udelay(500); 2628} 2629 2630/*****************************************************************************/ 2631 2632static void stli_ecpintr(struct stlibrd *brdp) 2633{ 2634 outb(0x1, brdp->iobase); 2635} 2636 2637/*****************************************************************************/ 2638 2639/* 2640 * The following set of functions act on ECP EISA boards. 2641 */ 2642 2643static void stli_ecpeiinit(struct stlibrd *brdp) 2644{ 2645 unsigned long memconf; 2646 2647 outb(0x1, (brdp->iobase + ECP_EIBRDENAB)); 2648 outb(ECP_EISTOP, (brdp->iobase + ECP_EICONFR)); 2649 udelay(10); 2650 outb(ECP_EIDISABLE, (brdp->iobase + ECP_EICONFR)); 2651 udelay(500); 2652 2653 memconf = (brdp->memaddr & ECP_EIADDRMASKL) >> ECP_EIADDRSHFTL; 2654 outb(memconf, (brdp->iobase + ECP_EIMEMARL)); 2655 memconf = (brdp->memaddr & ECP_EIADDRMASKH) >> ECP_EIADDRSHFTH; 2656 outb(memconf, (brdp->iobase + ECP_EIMEMARH)); 2657} 2658 2659/*****************************************************************************/ 2660 2661static void stli_ecpeienable(struct stlibrd *brdp) 2662{ 2663 outb(ECP_EIENABLE, (brdp->iobase + ECP_EICONFR)); 2664} 2665 2666/*****************************************************************************/ 2667 2668static void stli_ecpeidisable(struct stlibrd *brdp) 2669{ 2670 outb(ECP_EIDISABLE, (brdp->iobase + ECP_EICONFR)); 2671} 2672 2673/*****************************************************************************/ 2674 2675static void __iomem *stli_ecpeigetmemptr(struct stlibrd *brdp, unsigned long offset, int line) 2676{ 2677 void __iomem *ptr; 2678 unsigned char val; 2679 2680 if (offset > brdp->memsize) { 2681 printk(KERN_ERR "istallion: shared memory pointer=%x out of " 2682 "range at line=%d(%d), brd=%d\n", 2683 (int) offset, line, __LINE__, brdp->brdnr); 2684 ptr = NULL; 2685 val = 0; 2686 } else { 2687 ptr = brdp->membase + (offset % ECP_EIPAGESIZE); 2688 if (offset < ECP_EIPAGESIZE) 2689 val = ECP_EIENABLE; 2690 else 2691 val = ECP_EIENABLE | 0x40; 2692 } 2693 outb(val, (brdp->iobase + ECP_EICONFR)); 2694 return(ptr); 2695} 2696 2697/*****************************************************************************/ 2698 2699static void stli_ecpeireset(struct stlibrd *brdp) 2700{ 2701 outb(ECP_EISTOP, (brdp->iobase + ECP_EICONFR)); 2702 udelay(10); 2703 outb(ECP_EIDISABLE, (brdp->iobase + ECP_EICONFR)); 2704 udelay(500); 2705} 2706 2707/*****************************************************************************/ 2708 2709/* 2710 * The following set of functions act on ECP MCA boards. 2711 */ 2712 2713static void stli_ecpmcenable(struct stlibrd *brdp) 2714{ 2715 outb(ECP_MCENABLE, (brdp->iobase + ECP_MCCONFR)); 2716} 2717 2718/*****************************************************************************/ 2719 2720static void stli_ecpmcdisable(struct stlibrd *brdp) 2721{ 2722 outb(ECP_MCDISABLE, (brdp->iobase + ECP_MCCONFR)); 2723} 2724 2725/*****************************************************************************/ 2726 2727static void __iomem *stli_ecpmcgetmemptr(struct stlibrd *brdp, unsigned long offset, int line) 2728{ 2729 void __iomem *ptr; 2730 unsigned char val; 2731 2732 if (offset > brdp->memsize) { 2733 printk(KERN_ERR "istallion: shared memory pointer=%x out of " 2734 "range at line=%d(%d), brd=%d\n", 2735 (int) offset, line, __LINE__, brdp->brdnr); 2736 ptr = NULL; 2737 val = 0; 2738 } else { 2739 ptr = brdp->membase + (offset % ECP_MCPAGESIZE); 2740 val = ((unsigned char) (offset / ECP_MCPAGESIZE)) | ECP_MCENABLE; 2741 } 2742 outb(val, (brdp->iobase + ECP_MCCONFR)); 2743 return(ptr); 2744} 2745 2746/*****************************************************************************/ 2747 2748static void stli_ecpmcreset(struct stlibrd *brdp) 2749{ 2750 outb(ECP_MCSTOP, (brdp->iobase + ECP_MCCONFR)); 2751 udelay(10); 2752 outb(ECP_MCDISABLE, (brdp->iobase + ECP_MCCONFR)); 2753 udelay(500); 2754} 2755 2756/*****************************************************************************/ 2757 2758/* 2759 * The following set of functions act on ECP PCI boards. 2760 */ 2761 2762static void stli_ecppciinit(struct stlibrd *brdp) 2763{ 2764 outb(ECP_PCISTOP, (brdp->iobase + ECP_PCICONFR)); 2765 udelay(10); 2766 outb(0, (brdp->iobase + ECP_PCICONFR)); 2767 udelay(500); 2768} 2769 2770/*****************************************************************************/ 2771 2772static void __iomem *stli_ecppcigetmemptr(struct stlibrd *brdp, unsigned long offset, int line) 2773{ 2774 void __iomem *ptr; 2775 unsigned char val; 2776 2777 if (offset > brdp->memsize) { 2778 printk(KERN_ERR "istallion: shared memory pointer=%x out of " 2779 "range at line=%d(%d), board=%d\n", 2780 (int) offset, line, __LINE__, brdp->brdnr); 2781 ptr = NULL; 2782 val = 0; 2783 } else { 2784 ptr = brdp->membase + (offset % ECP_PCIPAGESIZE); 2785 val = (offset / ECP_PCIPAGESIZE) << 1; 2786 } 2787 outb(val, (brdp->iobase + ECP_PCICONFR)); 2788 return(ptr); 2789} 2790 2791/*****************************************************************************/ 2792 2793static void stli_ecppcireset(struct stlibrd *brdp) 2794{ 2795 outb(ECP_PCISTOP, (brdp->iobase + ECP_PCICONFR)); 2796 udelay(10); 2797 outb(0, (brdp->iobase + ECP_PCICONFR)); 2798 udelay(500); 2799} 2800 2801/*****************************************************************************/ 2802 2803/* 2804 * The following routines act on ONboards. 2805 */ 2806 2807static void stli_onbinit(struct stlibrd *brdp) 2808{ 2809 unsigned long memconf; 2810 2811 outb(ONB_ATSTOP, (brdp->iobase + ONB_ATCONFR)); 2812 udelay(10); 2813 outb(ONB_ATDISABLE, (brdp->iobase + ONB_ATCONFR)); 2814 mdelay(1000); 2815 2816 memconf = (brdp->memaddr & ONB_ATADDRMASK) >> ONB_ATADDRSHFT; 2817 outb(memconf, (brdp->iobase + ONB_ATMEMAR)); 2818 outb(0x1, brdp->iobase); 2819 mdelay(1); 2820} 2821 2822/*****************************************************************************/ 2823 2824static void stli_onbenable(struct stlibrd *brdp) 2825{ 2826 outb((brdp->enabval | ONB_ATENABLE), (brdp->iobase + ONB_ATCONFR)); 2827} 2828 2829/*****************************************************************************/ 2830 2831static void stli_onbdisable(struct stlibrd *brdp) 2832{ 2833 outb((brdp->enabval | ONB_ATDISABLE), (brdp->iobase + ONB_ATCONFR)); 2834} 2835 2836/*****************************************************************************/ 2837 2838static void __iomem *stli_onbgetmemptr(struct stlibrd *brdp, unsigned long offset, int line) 2839{ 2840 void __iomem *ptr; 2841 2842 if (offset > brdp->memsize) { 2843 printk(KERN_ERR "istallion: shared memory pointer=%x out of " 2844 "range at line=%d(%d), brd=%d\n", 2845 (int) offset, line, __LINE__, brdp->brdnr); 2846 ptr = NULL; 2847 } else { 2848 ptr = brdp->membase + (offset % ONB_ATPAGESIZE); 2849 } 2850 return(ptr); 2851} 2852 2853/*****************************************************************************/ 2854 2855static void stli_onbreset(struct stlibrd *brdp) 2856{ 2857 outb(ONB_ATSTOP, (brdp->iobase + ONB_ATCONFR)); 2858 udelay(10); 2859 outb(ONB_ATDISABLE, (brdp->iobase + ONB_ATCONFR)); 2860 mdelay(1000); 2861} 2862 2863/*****************************************************************************/ 2864 2865/* 2866 * The following routines act on ONboard EISA. 2867 */ 2868 2869static void stli_onbeinit(struct stlibrd *brdp) 2870{ 2871 unsigned long memconf; 2872 2873 outb(0x1, (brdp->iobase + ONB_EIBRDENAB)); 2874 outb(ONB_EISTOP, (brdp->iobase + ONB_EICONFR)); 2875 udelay(10); 2876 outb(ONB_EIDISABLE, (brdp->iobase + ONB_EICONFR)); 2877 mdelay(1000); 2878 2879 memconf = (brdp->memaddr & ONB_EIADDRMASKL) >> ONB_EIADDRSHFTL; 2880 outb(memconf, (brdp->iobase + ONB_EIMEMARL)); 2881 memconf = (brdp->memaddr & ONB_EIADDRMASKH) >> ONB_EIADDRSHFTH; 2882 outb(memconf, (brdp->iobase + ONB_EIMEMARH)); 2883 outb(0x1, brdp->iobase); 2884 mdelay(1); 2885} 2886 2887/*****************************************************************************/ 2888 2889static void stli_onbeenable(struct stlibrd *brdp) 2890{ 2891 outb(ONB_EIENABLE, (brdp->iobase + ONB_EICONFR)); 2892} 2893 2894/*****************************************************************************/ 2895 2896static void stli_onbedisable(struct stlibrd *brdp) 2897{ 2898 outb(ONB_EIDISABLE, (brdp->iobase + ONB_EICONFR)); 2899} 2900 2901/*****************************************************************************/ 2902 2903static void __iomem *stli_onbegetmemptr(struct stlibrd *brdp, unsigned long offset, int line) 2904{ 2905 void __iomem *ptr; 2906 unsigned char val; 2907 2908 if (offset > brdp->memsize) { 2909 printk(KERN_ERR "istallion: shared memory pointer=%x out of " 2910 "range at line=%d(%d), brd=%d\n", 2911 (int) offset, line, __LINE__, brdp->brdnr); 2912 ptr = NULL; 2913 val = 0; 2914 } else { 2915 ptr = brdp->membase + (offset % ONB_EIPAGESIZE); 2916 if (offset < ONB_EIPAGESIZE) 2917 val = ONB_EIENABLE; 2918 else 2919 val = ONB_EIENABLE | 0x40; 2920 } 2921 outb(val, (brdp->iobase + ONB_EICONFR)); 2922 return(ptr); 2923} 2924 2925/*****************************************************************************/ 2926 2927static void stli_onbereset(struct stlibrd *brdp) 2928{ 2929 outb(ONB_EISTOP, (brdp->iobase + ONB_EICONFR)); 2930 udelay(10); 2931 outb(ONB_EIDISABLE, (brdp->iobase + ONB_EICONFR)); 2932 mdelay(1000); 2933} 2934 2935/*****************************************************************************/ 2936 2937/* 2938 * The following routines act on Brumby boards. 2939 */ 2940 2941static void stli_bbyinit(struct stlibrd *brdp) 2942{ 2943 outb(BBY_ATSTOP, (brdp->iobase + BBY_ATCONFR)); 2944 udelay(10); 2945 outb(0, (brdp->iobase + BBY_ATCONFR)); 2946 mdelay(1000); 2947 outb(0x1, brdp->iobase); 2948 mdelay(1); 2949} 2950 2951/*****************************************************************************/ 2952 2953static void __iomem *stli_bbygetmemptr(struct stlibrd *brdp, unsigned long offset, int line) 2954{ 2955 void __iomem *ptr; 2956 unsigned char val; 2957 2958 BUG_ON(offset > brdp->memsize); 2959 2960 ptr = brdp->membase + (offset % BBY_PAGESIZE); 2961 val = (unsigned char) (offset / BBY_PAGESIZE); 2962 outb(val, (brdp->iobase + BBY_ATCONFR)); 2963 return(ptr); 2964} 2965 2966/*****************************************************************************/ 2967 2968static void stli_bbyreset(struct stlibrd *brdp) 2969{ 2970 outb(BBY_ATSTOP, (brdp->iobase + BBY_ATCONFR)); 2971 udelay(10); 2972 outb(0, (brdp->iobase + BBY_ATCONFR)); 2973 mdelay(1000); 2974} 2975 2976/*****************************************************************************/ 2977 2978/* 2979 * The following routines act on original old Stallion boards. 2980 */ 2981 2982static void stli_stalinit(struct stlibrd *brdp) 2983{ 2984 outb(0x1, brdp->iobase); 2985 mdelay(1000); 2986} 2987 2988/*****************************************************************************/ 2989 2990static void __iomem *stli_stalgetmemptr(struct stlibrd *brdp, unsigned long offset, int line) 2991{ 2992 BUG_ON(offset > brdp->memsize); 2993 return brdp->membase + (offset % STAL_PAGESIZE); 2994} 2995 2996/*****************************************************************************/ 2997 2998static void stli_stalreset(struct stlibrd *brdp) 2999{ 3000 u32 __iomem *vecp; 3001 3002 vecp = (u32 __iomem *) (brdp->membase + 0x30); 3003 writel(0xffff0000, vecp); 3004 outb(0, brdp->iobase); 3005 mdelay(1000); 3006} 3007 3008/*****************************************************************************/ 3009 3010/* 3011 * Try to find an ECP board and initialize it. This handles only ECP 3012 * board types. 3013 */ 3014 3015static int stli_initecp(struct stlibrd *brdp) 3016{ 3017 cdkecpsig_t sig; 3018 cdkecpsig_t __iomem *sigsp; 3019 unsigned int status, nxtid; 3020 char *name; 3021 int retval, panelnr, nrports; 3022 3023 if ((brdp->iobase == 0) || (brdp->memaddr == 0)) { 3024 retval = -ENODEV; 3025 goto err; 3026 } 3027 3028 brdp->iosize = ECP_IOSIZE; 3029 3030 if (!request_region(brdp->iobase, brdp->iosize, "istallion")) { 3031 retval = -EIO; 3032 goto err; 3033 } 3034 3035/* 3036 * Based on the specific board type setup the common vars to access 3037 * and enable shared memory. Set all board specific information now 3038 * as well. 3039 */ 3040 switch (brdp->brdtype) { 3041 case BRD_ECP: 3042 brdp->memsize = ECP_MEMSIZE; 3043 brdp->pagesize = ECP_ATPAGESIZE; 3044 brdp->init = stli_ecpinit; 3045 brdp->enable = stli_ecpenable; 3046 brdp->reenable = stli_ecpenable; 3047 brdp->disable = stli_ecpdisable; 3048 brdp->getmemptr = stli_ecpgetmemptr; 3049 brdp->intr = stli_ecpintr; 3050 brdp->reset = stli_ecpreset; 3051 name = "serial(EC8/64)"; 3052 break; 3053 3054 case BRD_ECPE: 3055 brdp->memsize = ECP_MEMSIZE; 3056 brdp->pagesize = ECP_EIPAGESIZE; 3057 brdp->init = stli_ecpeiinit; 3058 brdp->enable = stli_ecpeienable; 3059 brdp->reenable = stli_ecpeienable; 3060 brdp->disable = stli_ecpeidisable; 3061 brdp->getmemptr = stli_ecpeigetmemptr; 3062 brdp->intr = stli_ecpintr; 3063 brdp->reset = stli_ecpeireset; 3064 name = "serial(EC8/64-EI)"; 3065 break; 3066 3067 case BRD_ECPMC: 3068 brdp->memsize = ECP_MEMSIZE; 3069 brdp->pagesize = ECP_MCPAGESIZE; 3070 brdp->init = NULL; 3071 brdp->enable = stli_ecpmcenable; 3072 brdp->reenable = stli_ecpmcenable; 3073 brdp->disable = stli_ecpmcdisable; 3074 brdp->getmemptr = stli_ecpmcgetmemptr; 3075 brdp->intr = stli_ecpintr; 3076 brdp->reset = stli_ecpmcreset; 3077 name = "serial(EC8/64-MCA)"; 3078 break; 3079 3080 case BRD_ECPPCI: 3081 brdp->memsize = ECP_PCIMEMSIZE; 3082 brdp->pagesize = ECP_PCIPAGESIZE; 3083 brdp->init = stli_ecppciinit; 3084 brdp->enable = NULL; 3085 brdp->reenable = NULL; 3086 brdp->disable = NULL; 3087 brdp->getmemptr = stli_ecppcigetmemptr; 3088 brdp->intr = stli_ecpintr; 3089 brdp->reset = stli_ecppcireset; 3090 name = "serial(EC/RA-PCI)"; 3091 break; 3092 3093 default: 3094 retval = -EINVAL; 3095 goto err_reg; 3096 } 3097 3098/* 3099 * The per-board operations structure is all set up, so now let's go 3100 * and get the board operational. Firstly initialize board configuration 3101 * registers. Set the memory mapping info so we can get at the boards 3102 * shared memory. 3103 */ 3104 EBRDINIT(brdp); 3105 3106 brdp->membase = ioremap_nocache(brdp->memaddr, brdp->memsize); 3107 if (brdp->membase == NULL) { 3108 retval = -ENOMEM; 3109 goto err_reg; 3110 } 3111 3112/* 3113 * Now that all specific code is set up, enable the shared memory and 3114 * look for the a signature area that will tell us exactly what board 3115 * this is, and what it is connected to it. 3116 */ 3117 EBRDENABLE(brdp); 3118 sigsp = (cdkecpsig_t __iomem *) EBRDGETMEMPTR(brdp, CDK_SIGADDR); 3119 memcpy_fromio(&sig, sigsp, sizeof(cdkecpsig_t)); 3120 EBRDDISABLE(brdp); 3121 3122 if (sig.magic != cpu_to_le32(ECP_MAGIC)) { 3123 retval = -ENODEV; 3124 goto err_unmap; 3125 } 3126 3127/* 3128 * Scan through the signature looking at the panels connected to the 3129 * board. Calculate the total number of ports as we go. 3130 */ 3131 for (panelnr = 0, nxtid = 0; (panelnr < STL_MAXPANELS); panelnr++) { 3132 status = sig.panelid[nxtid]; 3133 if ((status & ECH_PNLIDMASK) != nxtid) 3134 break; 3135 3136 brdp->panelids[panelnr] = status; 3137 nrports = (status & ECH_PNL16PORT) ? 16 : 8; 3138 if ((nrports == 16) && ((status & ECH_PNLXPID) == 0)) 3139 nxtid++; 3140 brdp->panels[panelnr] = nrports; 3141 brdp->nrports += nrports; 3142 nxtid++; 3143 brdp->nrpanels++; 3144 } 3145 3146 3147 set_bit(BST_FOUND, &brdp->state); 3148 return 0; 3149err_unmap: 3150 iounmap(brdp->membase); 3151 brdp->membase = NULL; 3152err_reg: 3153 release_region(brdp->iobase, brdp->iosize); 3154err: 3155 return retval; 3156} 3157 3158/*****************************************************************************/ 3159 3160/* 3161 * Try to find an ONboard, Brumby or Stallion board and initialize it. 3162 * This handles only these board types. 3163 */ 3164 3165static int stli_initonb(struct stlibrd *brdp) 3166{ 3167 cdkonbsig_t sig; 3168 cdkonbsig_t __iomem *sigsp; 3169 char *name; 3170 int i, retval; 3171 3172/* 3173 * Do a basic sanity check on the IO and memory addresses. 3174 */ 3175 if (brdp->iobase == 0 || brdp->memaddr == 0) { 3176 retval = -ENODEV; 3177 goto err; 3178 } 3179 3180 brdp->iosize = ONB_IOSIZE; 3181 3182 if (!request_region(brdp->iobase, brdp->iosize, "istallion")) { 3183 retval = -EIO; 3184 goto err; 3185 } 3186 3187/* 3188 * Based on the specific board type setup the common vars to access 3189 * and enable shared memory. Set all board specific information now 3190 * as well. 3191 */ 3192 switch (brdp->brdtype) { 3193 case BRD_ONBOARD: 3194 case BRD_ONBOARD2: 3195 brdp->memsize = ONB_MEMSIZE; 3196 brdp->pagesize = ONB_ATPAGESIZE; 3197 brdp->init = stli_onbinit; 3198 brdp->enable = stli_onbenable; 3199 brdp->reenable = stli_onbenable; 3200 brdp->disable = stli_onbdisable; 3201 brdp->getmemptr = stli_onbgetmemptr; 3202 brdp->intr = stli_ecpintr; 3203 brdp->reset = stli_onbreset; 3204 if (brdp->memaddr > 0x100000) 3205 brdp->enabval = ONB_MEMENABHI; 3206 else 3207 brdp->enabval = ONB_MEMENABLO; 3208 name = "serial(ONBoard)"; 3209 break; 3210 3211 case BRD_ONBOARDE: 3212 brdp->memsize = ONB_EIMEMSIZE; 3213 brdp->pagesize = ONB_EIPAGESIZE; 3214 brdp->init = stli_onbeinit; 3215 brdp->enable = stli_onbeenable; 3216 brdp->reenable = stli_onbeenable; 3217 brdp->disable = stli_onbedisable; 3218 brdp->getmemptr = stli_onbegetmemptr; 3219 brdp->intr = stli_ecpintr; 3220 brdp->reset = stli_onbereset; 3221 name = "serial(ONBoard/E)"; 3222 break; 3223 3224 case BRD_BRUMBY4: 3225 brdp->memsize = BBY_MEMSIZE; 3226 brdp->pagesize = BBY_PAGESIZE; 3227 brdp->init = stli_bbyinit; 3228 brdp->enable = NULL; 3229 brdp->reenable = NULL; 3230 brdp->disable = NULL; 3231 brdp->getmemptr = stli_bbygetmemptr; 3232 brdp->intr = stli_ecpintr; 3233 brdp->reset = stli_bbyreset; 3234 name = "serial(Brumby)"; 3235 break; 3236 3237 case BRD_STALLION: 3238 brdp->memsize = STAL_MEMSIZE; 3239 brdp->pagesize = STAL_PAGESIZE; 3240 brdp->init = stli_stalinit; 3241 brdp->enable = NULL; 3242 brdp->reenable = NULL; 3243 brdp->disable = NULL; 3244 brdp->getmemptr = stli_stalgetmemptr; 3245 brdp->intr = stli_ecpintr; 3246 brdp->reset = stli_stalreset; 3247 name = "serial(Stallion)"; 3248 break; 3249 3250 default: 3251 retval = -EINVAL; 3252 goto err_reg; 3253 } 3254 3255/* 3256 * The per-board operations structure is all set up, so now let's go 3257 * and get the board operational. Firstly initialize board configuration 3258 * registers. Set the memory mapping info so we can get at the boards 3259 * shared memory. 3260 */ 3261 EBRDINIT(brdp); 3262 3263 brdp->membase = ioremap_nocache(brdp->memaddr, brdp->memsize); 3264 if (brdp->membase == NULL) { 3265 retval = -ENOMEM; 3266 goto err_reg; 3267 } 3268 3269/* 3270 * Now that all specific code is set up, enable the shared memory and 3271 * look for the a signature area that will tell us exactly what board 3272 * this is, and how many ports. 3273 */ 3274 EBRDENABLE(brdp); 3275 sigsp = (cdkonbsig_t __iomem *) EBRDGETMEMPTR(brdp, CDK_SIGADDR); 3276 memcpy_fromio(&sig, sigsp, sizeof(cdkonbsig_t)); 3277 EBRDDISABLE(brdp); 3278 3279 if (sig.magic0 != cpu_to_le16(ONB_MAGIC0) || 3280 sig.magic1 != cpu_to_le16(ONB_MAGIC1) || 3281 sig.magic2 != cpu_to_le16(ONB_MAGIC2) || 3282 sig.magic3 != cpu_to_le16(ONB_MAGIC3)) { 3283 retval = -ENODEV; 3284 goto err_unmap; 3285 } 3286 3287/* 3288 * Scan through the signature alive mask and calculate how many ports 3289 * there are on this board. 3290 */ 3291 brdp->nrpanels = 1; 3292 if (sig.amask1) { 3293 brdp->nrports = 32; 3294 } else { 3295 for (i = 0; (i < 16); i++) { 3296 if (((sig.amask0 << i) & 0x8000) == 0) 3297 break; 3298 } 3299 brdp->nrports = i; 3300 } 3301 brdp->panels[0] = brdp->nrports; 3302 3303 3304 set_bit(BST_FOUND, &brdp->state); 3305 return 0; 3306err_unmap: 3307 iounmap(brdp->membase); 3308 brdp->membase = NULL; 3309err_reg: 3310 release_region(brdp->iobase, brdp->iosize); 3311err: 3312 return retval; 3313} 3314 3315/*****************************************************************************/ 3316 3317/* 3318 * Start up a running board. This routine is only called after the 3319 * code has been down loaded to the board and is operational. It will 3320 * read in the memory map, and get the show on the road... 3321 */ 3322 3323static int stli_startbrd(struct stlibrd *brdp) 3324{ 3325 cdkhdr_t __iomem *hdrp; 3326 cdkmem_t __iomem *memp; 3327 cdkasy_t __iomem *ap; 3328 unsigned long flags; 3329 unsigned int portnr, nrdevs, i; 3330 struct stliport *portp; 3331 int rc = 0; 3332 u32 memoff; 3333 3334 spin_lock_irqsave(&brd_lock, flags); 3335 EBRDENABLE(brdp); 3336 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR); 3337 nrdevs = hdrp->nrdevs; 3338 3339 3340 if (nrdevs < (brdp->nrports + 1)) { 3341 printk(KERN_ERR "istallion: slave failed to allocate memory for " 3342 "all devices, devices=%d\n", nrdevs); 3343 brdp->nrports = nrdevs - 1; 3344 } 3345 brdp->nrdevs = nrdevs; 3346 brdp->hostoffset = hdrp->hostp - CDK_CDKADDR; 3347 brdp->slaveoffset = hdrp->slavep - CDK_CDKADDR; 3348 brdp->bitsize = (nrdevs + 7) / 8; 3349 memoff = readl(&hdrp->memp); 3350 if (memoff > brdp->memsize) { 3351 printk(KERN_ERR "istallion: corrupted shared memory region?\n"); 3352 rc = -EIO; 3353 goto stli_donestartup; 3354 } 3355 memp = (cdkmem_t __iomem *) EBRDGETMEMPTR(brdp, memoff); 3356 if (readw(&memp->dtype) != TYP_ASYNCTRL) { 3357 printk(KERN_ERR "istallion: no slave control device found\n"); 3358 goto stli_donestartup; 3359 } 3360 memp++; 3361 3362/* 3363 * Cycle through memory allocation of each port. We are guaranteed to 3364 * have all ports inside the first page of slave window, so no need to 3365 * change pages while reading memory map. 3366 */ 3367 for (i = 1, portnr = 0; (i < nrdevs); i++, portnr++, memp++) { 3368 if (readw(&memp->dtype) != TYP_ASYNC) 3369 break; 3370 portp = brdp->ports[portnr]; 3371 if (portp == NULL) 3372 break; 3373 portp->devnr = i; 3374 portp->addr = readl(&memp->offset); 3375 portp->reqbit = (unsigned char) (0x1 << (i * 8 / nrdevs)); 3376 portp->portidx = (unsigned char) (i / 8); 3377 portp->portbit = (unsigned char) (0x1 << (i % 8)); 3378 } 3379 3380 writeb(0xff, &hdrp->slavereq); 3381 3382/* 3383 * For each port setup a local copy of the RX and TX buffer offsets 3384 * and sizes. We do this separate from the above, because we need to 3385 * move the shared memory page... 3386 */ 3387 for (i = 1, portnr = 0; (i < nrdevs); i++, portnr++) { 3388 portp = brdp->ports[portnr]; 3389 if (portp == NULL) 3390 break; 3391 if (portp->addr == 0) 3392 break; 3393 ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr); 3394 if (ap != NULL) { 3395 portp->rxsize = readw(&ap->rxq.size); 3396 portp->txsize = readw(&ap->txq.size); 3397 portp->rxoffset = readl(&ap->rxq.offset); 3398 portp->txoffset = readl(&ap->txq.offset); 3399 } 3400 } 3401 3402stli_donestartup: 3403 EBRDDISABLE(brdp); 3404 spin_unlock_irqrestore(&brd_lock, flags); 3405 3406 if (rc == 0) 3407 set_bit(BST_STARTED, &brdp->state); 3408 3409 if (! stli_timeron) { 3410 stli_timeron++; 3411 mod_timer(&stli_timerlist, STLI_TIMEOUT); 3412 } 3413 3414 return rc; 3415} 3416 3417/*****************************************************************************/ 3418 3419/* 3420 * Probe and initialize the specified board. 3421 */ 3422 3423static int __devinit stli_brdinit(struct stlibrd *brdp) 3424{ 3425 int retval; 3426 3427 switch (brdp->brdtype) { 3428 case BRD_ECP: 3429 case BRD_ECPE: 3430 case BRD_ECPMC: 3431 case BRD_ECPPCI: 3432 retval = stli_initecp(brdp); 3433 break; 3434 case BRD_ONBOARD: 3435 case BRD_ONBOARDE: 3436 case BRD_ONBOARD2: 3437 case BRD_BRUMBY4: 3438 case BRD_STALLION: 3439 retval = stli_initonb(brdp); 3440 break; 3441 default: 3442 printk(KERN_ERR "istallion: board=%d is unknown board " 3443 "type=%d\n", brdp->brdnr, brdp->brdtype); 3444 retval = -ENODEV; 3445 } 3446 3447 if (retval) 3448 return retval; 3449 3450 stli_initports(brdp); 3451 printk(KERN_INFO "istallion: %s found, board=%d io=%x mem=%x " 3452 "nrpanels=%d nrports=%d\n", stli_brdnames[brdp->brdtype], 3453 brdp->brdnr, brdp->iobase, (int) brdp->memaddr, 3454 brdp->nrpanels, brdp->nrports); 3455 return 0; 3456} 3457 3458#if STLI_EISAPROBE != 0 3459/*****************************************************************************/ 3460 3461/* 3462 * Probe around trying to find where the EISA boards shared memory 3463 * might be. This is a bit if hack, but it is the best we can do. 3464 */ 3465 3466static int stli_eisamemprobe(struct stlibrd *brdp) 3467{ 3468 cdkecpsig_t ecpsig, __iomem *ecpsigp; 3469 cdkonbsig_t onbsig, __iomem *onbsigp; 3470 int i, foundit; 3471 3472/* 3473 * First up we reset the board, to get it into a known state. There 3474 * is only 2 board types here we need to worry about. Don;t use the 3475 * standard board init routine here, it programs up the shared 3476 * memory address, and we don't know it yet... 3477 */ 3478 if (brdp->brdtype == BRD_ECPE) { 3479 outb(0x1, (brdp->iobase + ECP_EIBRDENAB)); 3480 outb(ECP_EISTOP, (brdp->iobase + ECP_EICONFR)); 3481 udelay(10); 3482 outb(ECP_EIDISABLE, (brdp->iobase + ECP_EICONFR)); 3483 udelay(500); 3484 stli_ecpeienable(brdp); 3485 } else if (brdp->brdtype == BRD_ONBOARDE) { 3486 outb(0x1, (brdp->iobase + ONB_EIBRDENAB)); 3487 outb(ONB_EISTOP, (brdp->iobase + ONB_EICONFR)); 3488 udelay(10); 3489 outb(ONB_EIDISABLE, (brdp->iobase + ONB_EICONFR)); 3490 mdelay(100); 3491 outb(0x1, brdp->iobase); 3492 mdelay(1); 3493 stli_onbeenable(brdp); 3494 } else { 3495 return -ENODEV; 3496 } 3497 3498 foundit = 0; 3499 brdp->memsize = ECP_MEMSIZE; 3500 3501/* 3502 * Board shared memory is enabled, so now we have a poke around and 3503 * see if we can find it. 3504 */ 3505 for (i = 0; (i < stli_eisamempsize); i++) { 3506 brdp->memaddr = stli_eisamemprobeaddrs[i]; 3507 brdp->membase = ioremap_nocache(brdp->memaddr, brdp->memsize); 3508 if (brdp->membase == NULL) 3509 continue; 3510 3511 if (brdp->brdtype == BRD_ECPE) { 3512 ecpsigp = stli_ecpeigetmemptr(brdp, 3513 CDK_SIGADDR, __LINE__); 3514 memcpy_fromio(&ecpsig, ecpsigp, sizeof(cdkecpsig_t)); 3515 if (ecpsig.magic == cpu_to_le32(ECP_MAGIC)) 3516 foundit = 1; 3517 } else { 3518 onbsigp = (cdkonbsig_t __iomem *) stli_onbegetmemptr(brdp, 3519 CDK_SIGADDR, __LINE__); 3520 memcpy_fromio(&onbsig, onbsigp, sizeof(cdkonbsig_t)); 3521 if ((onbsig.magic0 == cpu_to_le16(ONB_MAGIC0)) && 3522 (onbsig.magic1 == cpu_to_le16(ONB_MAGIC1)) && 3523 (onbsig.magic2 == cpu_to_le16(ONB_MAGIC2)) && 3524 (onbsig.magic3 == cpu_to_le16(ONB_MAGIC3))) 3525 foundit = 1; 3526 } 3527 3528 iounmap(brdp->membase); 3529 if (foundit) 3530 break; 3531 } 3532 3533/* 3534 * Regardless of whether we found the shared memory or not we must 3535 * disable the region. After that return success or failure. 3536 */ 3537 if (brdp->brdtype == BRD_ECPE) 3538 stli_ecpeidisable(brdp); 3539 else 3540 stli_onbedisable(brdp); 3541 3542 if (! foundit) { 3543 brdp->memaddr = 0; 3544 brdp->membase = NULL; 3545 printk(KERN_ERR "istallion: failed to probe shared memory " 3546 "region for %s in EISA slot=%d\n", 3547 stli_brdnames[brdp->brdtype], (brdp->iobase >> 12)); 3548 return -ENODEV; 3549 } 3550 return 0; 3551} 3552#endif 3553 3554static int stli_getbrdnr(void) 3555{ 3556 unsigned int i; 3557 3558 for (i = 0; i < STL_MAXBRDS; i++) { 3559 if (!stli_brds[i]) { 3560 if (i >= stli_nrbrds) 3561 stli_nrbrds = i + 1; 3562 return i; 3563 } 3564 } 3565 return -1; 3566} 3567 3568#if STLI_EISAPROBE != 0 3569/*****************************************************************************/ 3570 3571/* 3572 * Probe around and try to find any EISA boards in system. The biggest 3573 * problem here is finding out what memory address is associated with 3574 * an EISA board after it is found. The registers of the ECPE and 3575 * ONboardE are not readable - so we can't read them from there. We 3576 * don't have access to the EISA CMOS (or EISA BIOS) so we don't 3577 * actually have any way to find out the real value. The best we can 3578 * do is go probing around in the usual places hoping we can find it. 3579 */ 3580 3581static int __init stli_findeisabrds(void) 3582{ 3583 struct stlibrd *brdp; 3584 unsigned int iobase, eid, i; 3585 int brdnr, found = 0; 3586 3587/* 3588 * Firstly check if this is an EISA system. If this is not an EISA system then 3589 * don't bother going any further! 3590 */ 3591 if (EISA_bus) 3592 return 0; 3593 3594/* 3595 * Looks like an EISA system, so go searching for EISA boards. 3596 */ 3597 for (iobase = 0x1000; (iobase <= 0xc000); iobase += 0x1000) { 3598 outb(0xff, (iobase + 0xc80)); 3599 eid = inb(iobase + 0xc80); 3600 eid |= inb(iobase + 0xc81) << 8; 3601 if (eid != STL_EISAID) 3602 continue; 3603 3604/* 3605 * We have found a board. Need to check if this board was 3606 * statically configured already (just in case!). 3607 */ 3608 for (i = 0; (i < STL_MAXBRDS); i++) { 3609 brdp = stli_brds[i]; 3610 if (brdp == NULL) 3611 continue; 3612 if (brdp->iobase == iobase) 3613 break; 3614 } 3615 if (i < STL_MAXBRDS) 3616 continue; 3617 3618/* 3619 * We have found a Stallion board and it is not configured already. 3620 * Allocate a board structure and initialize it. 3621 */ 3622 if ((brdp = stli_allocbrd()) == NULL) 3623 return found ? : -ENOMEM; 3624 brdnr = stli_getbrdnr(); 3625 if (brdnr < 0) 3626 return found ? : -ENOMEM; 3627 brdp->brdnr = (unsigned int)brdnr; 3628 eid = inb(iobase + 0xc82); 3629 if (eid == ECP_EISAID) 3630 brdp->brdtype = BRD_ECPE; 3631 else if (eid == ONB_EISAID) 3632 brdp->brdtype = BRD_ONBOARDE; 3633 else 3634 brdp->brdtype = BRD_UNKNOWN; 3635 brdp->iobase = iobase; 3636 outb(0x1, (iobase + 0xc84)); 3637 if (stli_eisamemprobe(brdp)) 3638 outb(0, (iobase + 0xc84)); 3639 if (stli_brdinit(brdp) < 0) { 3640 kfree(brdp); 3641 continue; 3642 } 3643 3644 stli_brds[brdp->brdnr] = brdp; 3645 found++; 3646 3647 for (i = 0; i < brdp->nrports; i++) 3648 tty_register_device(stli_serial, 3649 brdp->brdnr * STL_MAXPORTS + i, NULL); 3650 } 3651 3652 return found; 3653} 3654#else 3655static inline int stli_findeisabrds(void) { return 0; } 3656#endif 3657 3658/*****************************************************************************/ 3659 3660/* 3661 * Find the next available board number that is free. 3662 */ 3663 3664/*****************************************************************************/ 3665 3666/* 3667 * We have a Stallion board. Allocate a board structure and 3668 * initialize it. Read its IO and MEMORY resources from PCI 3669 * configuration space. 3670 */ 3671 3672static int __devinit stli_pciprobe(struct pci_dev *pdev, 3673 const struct pci_device_id *ent) 3674{ 3675 struct stlibrd *brdp; 3676 unsigned int i; 3677 int brdnr, retval = -EIO; 3678 3679 retval = pci_enable_device(pdev); 3680 if (retval) 3681 goto err; 3682 brdp = stli_allocbrd(); 3683 if (brdp == NULL) { 3684 retval = -ENOMEM; 3685 goto err; 3686 } 3687 mutex_lock(&stli_brdslock); 3688 brdnr = stli_getbrdnr(); 3689 if (brdnr < 0) { 3690 printk(KERN_INFO "istallion: too many boards found, " 3691 "maximum supported %d\n", STL_MAXBRDS); 3692 mutex_unlock(&stli_brdslock); 3693 retval = -EIO; 3694 goto err_fr; 3695 } 3696 brdp->brdnr = (unsigned int)brdnr; 3697 stli_brds[brdp->brdnr] = brdp; 3698 mutex_unlock(&stli_brdslock); 3699 brdp->brdtype = BRD_ECPPCI; 3700/* 3701 * We have all resources from the board, so lets setup the actual 3702 * board structure now. 3703 */ 3704 brdp->iobase = pci_resource_start(pdev, 3); 3705 brdp->memaddr = pci_resource_start(pdev, 2); 3706 retval = stli_brdinit(brdp); 3707 if (retval) 3708 goto err_null; 3709 3710 set_bit(BST_PROBED, &brdp->state); 3711 pci_set_drvdata(pdev, brdp); 3712 3713 EBRDENABLE(brdp); 3714 brdp->enable = NULL; 3715 brdp->disable = NULL; 3716 3717 for (i = 0; i < brdp->nrports; i++) 3718 tty_register_device(stli_serial, brdp->brdnr * STL_MAXPORTS + i, 3719 &pdev->dev); 3720 3721 return 0; 3722err_null: 3723 stli_brds[brdp->brdnr] = NULL; 3724err_fr: 3725 kfree(brdp); 3726err: 3727 return retval; 3728} 3729 3730static void __devexit stli_pciremove(struct pci_dev *pdev) 3731{ 3732 struct stlibrd *brdp = pci_get_drvdata(pdev); 3733 3734 stli_cleanup_ports(brdp); 3735 3736 iounmap(brdp->membase); 3737 if (brdp->iosize > 0) 3738 release_region(brdp->iobase, brdp->iosize); 3739 3740 stli_brds[brdp->brdnr] = NULL; 3741 kfree(brdp); 3742} 3743 3744static struct pci_driver stli_pcidriver = { 3745 .name = "istallion", 3746 .id_table = istallion_pci_tbl, 3747 .probe = stli_pciprobe, 3748 .remove = __devexit_p(stli_pciremove) 3749}; 3750/*****************************************************************************/ 3751 3752/* 3753 * Allocate a new board structure. Fill out the basic info in it. 3754 */ 3755 3756static struct stlibrd *stli_allocbrd(void) 3757{ 3758 struct stlibrd *brdp; 3759 3760 brdp = kzalloc(sizeof(struct stlibrd), GFP_KERNEL); 3761 if (!brdp) { 3762 printk(KERN_ERR "istallion: failed to allocate memory " 3763 "(size=%Zd)\n", sizeof(struct stlibrd)); 3764 return NULL; 3765 } 3766 brdp->magic = STLI_BOARDMAGIC; 3767 return brdp; 3768} 3769 3770/*****************************************************************************/ 3771 3772/* 3773 * Scan through all the boards in the configuration and see what we 3774 * can find. 3775 */ 3776 3777static int __init stli_initbrds(void) 3778{ 3779 struct stlibrd *brdp, *nxtbrdp; 3780 struct stlconf conf; 3781 unsigned int i, j, found = 0; 3782 int retval; 3783 3784 for (stli_nrbrds = 0; stli_nrbrds < ARRAY_SIZE(stli_brdsp); 3785 stli_nrbrds++) { 3786 memset(&conf, 0, sizeof(conf)); 3787 if (stli_parsebrd(&conf, stli_brdsp[stli_nrbrds]) == 0) 3788 continue; 3789 if ((brdp = stli_allocbrd()) == NULL) 3790 continue; 3791 brdp->brdnr = stli_nrbrds; 3792 brdp->brdtype = conf.brdtype; 3793 brdp->iobase = conf.ioaddr1; 3794 brdp->memaddr = conf.memaddr; 3795 if (stli_brdinit(brdp) < 0) { 3796 kfree(brdp); 3797 continue; 3798 } 3799 stli_brds[brdp->brdnr] = brdp; 3800 found++; 3801 3802 for (i = 0; i < brdp->nrports; i++) 3803 tty_register_device(stli_serial, 3804 brdp->brdnr * STL_MAXPORTS + i, NULL); 3805 } 3806 3807 retval = stli_findeisabrds(); 3808 if (retval > 0) 3809 found += retval; 3810 3811/* 3812 * All found boards are initialized. Now for a little optimization, if 3813 * no boards are sharing the "shared memory" regions then we can just 3814 * leave them all enabled. This is in fact the usual case. 3815 */ 3816 stli_shared = 0; 3817 if (stli_nrbrds > 1) { 3818 for (i = 0; (i < stli_nrbrds); i++) { 3819 brdp = stli_brds[i]; 3820 if (brdp == NULL) 3821 continue; 3822 for (j = i + 1; (j < stli_nrbrds); j++) { 3823 nxtbrdp = stli_brds[j]; 3824 if (nxtbrdp == NULL) 3825 continue; 3826 if ((brdp->membase >= nxtbrdp->membase) && 3827 (brdp->membase <= (nxtbrdp->membase + 3828 nxtbrdp->memsize - 1))) { 3829 stli_shared++; 3830 break; 3831 } 3832 } 3833 } 3834 } 3835 3836 if (stli_shared == 0) { 3837 for (i = 0; (i < stli_nrbrds); i++) { 3838 brdp = stli_brds[i]; 3839 if (brdp == NULL) 3840 continue; 3841 if (test_bit(BST_FOUND, &brdp->state)) { 3842 EBRDENABLE(brdp); 3843 brdp->enable = NULL; 3844 brdp->disable = NULL; 3845 } 3846 } 3847 } 3848 3849 retval = pci_register_driver(&stli_pcidriver); 3850 if (retval && found == 0) { 3851 printk(KERN_ERR "Neither isa nor eisa cards found nor pci " 3852 "driver can be registered!\n"); 3853 goto err; 3854 } 3855 3856 return 0; 3857err: 3858 return retval; 3859} 3860 3861/*****************************************************************************/ 3862 3863/* 3864 * Code to handle an "staliomem" read operation. This device is the 3865 * contents of the board shared memory. It is used for down loading 3866 * the slave image (and debugging :-) 3867 */ 3868 3869static ssize_t stli_memread(struct file *fp, char __user *buf, size_t count, loff_t *offp) 3870{ 3871 unsigned long flags; 3872 void __iomem *memptr; 3873 struct stlibrd *brdp; 3874 unsigned int brdnr; 3875 int size, n; 3876 void *p; 3877 loff_t off = *offp; 3878 3879 brdnr = iminor(fp->f_path.dentry->d_inode); 3880 if (brdnr >= stli_nrbrds) 3881 return -ENODEV; 3882 brdp = stli_brds[brdnr]; 3883 if (brdp == NULL) 3884 return -ENODEV; 3885 if (brdp->state == 0) 3886 return -ENODEV; 3887 if (off >= brdp->memsize || off + count < off) 3888 return 0; 3889 3890 size = min(count, (size_t)(brdp->memsize - off)); 3891 3892 /* 3893 * Copy the data a page at a time 3894 */ 3895 3896 p = (void *)__get_free_page(GFP_KERNEL); 3897 if(p == NULL) 3898 return -ENOMEM; 3899 3900 while (size > 0) { 3901 spin_lock_irqsave(&brd_lock, flags); 3902 EBRDENABLE(brdp); 3903 memptr = EBRDGETMEMPTR(brdp, off); 3904 n = min(size, (int)(brdp->pagesize - (((unsigned long) off) % brdp->pagesize))); 3905 n = min(n, (int)PAGE_SIZE); 3906 memcpy_fromio(p, memptr, n); 3907 EBRDDISABLE(brdp); 3908 spin_unlock_irqrestore(&brd_lock, flags); 3909 if (copy_to_user(buf, p, n)) { 3910 count = -EFAULT; 3911 goto out; 3912 } 3913 off += n; 3914 buf += n; 3915 size -= n; 3916 } 3917out: 3918 *offp = off; 3919 free_page((unsigned long)p); 3920 return count; 3921} 3922 3923/*****************************************************************************/ 3924 3925 3926static ssize_t stli_memwrite(struct file *fp, const char __user *buf, size_t count, loff_t *offp) 3927{ 3928 unsigned long flags; 3929 void __iomem *memptr; 3930 struct stlibrd *brdp; 3931 char __user *chbuf; 3932 unsigned int brdnr; 3933 int size, n; 3934 void *p; 3935 loff_t off = *offp; 3936 3937 brdnr = iminor(fp->f_path.dentry->d_inode); 3938 3939 if (brdnr >= stli_nrbrds) 3940 return -ENODEV; 3941 brdp = stli_brds[brdnr]; 3942 if (brdp == NULL) 3943 return -ENODEV; 3944 if (brdp->state == 0) 3945 return -ENODEV; 3946 if (off >= brdp->memsize || off + count < off) 3947 return 0; 3948 3949 chbuf = (char __user *) buf; 3950 size = min(count, (size_t)(brdp->memsize - off)); 3951 3952 /* 3953 * Copy the data a page at a time 3954 */ 3955 3956 p = (void *)__get_free_page(GFP_KERNEL); 3957 if(p == NULL) 3958 return -ENOMEM; 3959 3960 while (size > 0) { 3961 n = min(size, (int)(brdp->pagesize - (((unsigned long) off) % brdp->pagesize))); 3962 n = min(n, (int)PAGE_SIZE); 3963 if (copy_from_user(p, chbuf, n)) { 3964 if (count == 0) 3965 count = -EFAULT; 3966 goto out; 3967 } 3968 spin_lock_irqsave(&brd_lock, flags); 3969 EBRDENABLE(brdp); 3970 memptr = EBRDGETMEMPTR(brdp, off); 3971 memcpy_toio(memptr, p, n); 3972 EBRDDISABLE(brdp); 3973 spin_unlock_irqrestore(&brd_lock, flags); 3974 off += n; 3975 chbuf += n; 3976 size -= n; 3977 } 3978out: 3979 free_page((unsigned long) p); 3980 *offp = off; 3981 return count; 3982} 3983 3984/*****************************************************************************/ 3985 3986/* 3987 * Return the board stats structure to user app. 3988 */ 3989 3990static int stli_getbrdstats(combrd_t __user *bp) 3991{ 3992 struct stlibrd *brdp; 3993 unsigned int i; 3994 3995 if (copy_from_user(&stli_brdstats, bp, sizeof(combrd_t))) 3996 return -EFAULT; 3997 if (stli_brdstats.brd >= STL_MAXBRDS) 3998 return -ENODEV; 3999 brdp = stli_brds[stli_brdstats.brd]; 4000 if (brdp == NULL) 4001 return -ENODEV; 4002 4003 memset(&stli_brdstats, 0, sizeof(combrd_t)); 4004 4005 stli_brdstats.brd = brdp->brdnr; 4006 stli_brdstats.type = brdp->brdtype; 4007 stli_brdstats.hwid = 0; 4008 stli_brdstats.state = brdp->state; 4009 stli_brdstats.ioaddr = brdp->iobase; 4010 stli_brdstats.memaddr = brdp->memaddr; 4011 stli_brdstats.nrpanels = brdp->nrpanels; 4012 stli_brdstats.nrports = brdp->nrports; 4013 for (i = 0; (i < brdp->nrpanels); i++) { 4014 stli_brdstats.panels[i].panel = i; 4015 stli_brdstats.panels[i].hwid = brdp->panelids[i]; 4016 stli_brdstats.panels[i].nrports = brdp->panels[i]; 4017 } 4018 4019 if (copy_to_user(bp, &stli_brdstats, sizeof(combrd_t))) 4020 return -EFAULT; 4021 return 0; 4022} 4023 4024/*****************************************************************************/ 4025 4026/* 4027 * Resolve the referenced port number into a port struct pointer. 4028 */ 4029 4030static struct stliport *stli_getport(unsigned int brdnr, unsigned int panelnr, 4031 unsigned int portnr) 4032{ 4033 struct stlibrd *brdp; 4034 unsigned int i; 4035 4036 if (brdnr >= STL_MAXBRDS) 4037 return NULL; 4038 brdp = stli_brds[brdnr]; 4039 if (brdp == NULL) 4040 return NULL; 4041 for (i = 0; (i < panelnr); i++) 4042 portnr += brdp->panels[i]; 4043 if (portnr >= brdp->nrports) 4044 return NULL; 4045 return brdp->ports[portnr]; 4046} 4047 4048/*****************************************************************************/ 4049 4050/* 4051 * Return the port stats structure to user app. A NULL port struct 4052 * pointer passed in means that we need to find out from the app 4053 * what port to get stats for (used through board control device). 4054 */ 4055 4056static int stli_portcmdstats(struct tty_struct *tty, struct stliport *portp) 4057{ 4058 unsigned long flags; 4059 struct stlibrd *brdp; 4060 int rc; 4061 4062 memset(&stli_comstats, 0, sizeof(comstats_t)); 4063 4064 if (portp == NULL) 4065 return -ENODEV; 4066 brdp = stli_brds[portp->brdnr]; 4067 if (brdp == NULL) 4068 return -ENODEV; 4069 4070 mutex_lock(&portp->port.mutex); 4071 if (test_bit(BST_STARTED, &brdp->state)) { 4072 if ((rc = stli_cmdwait(brdp, portp, A_GETSTATS, 4073 &stli_cdkstats, sizeof(asystats_t), 1)) < 0) { 4074 mutex_unlock(&portp->port.mutex); 4075 return rc; 4076 } 4077 } else { 4078 memset(&stli_cdkstats, 0, sizeof(asystats_t)); 4079 } 4080 4081 stli_comstats.brd = portp->brdnr; 4082 stli_comstats.panel = portp->panelnr; 4083 stli_comstats.port = portp->portnr; 4084 stli_comstats.state = portp->state; 4085 stli_comstats.flags = portp->port.flags; 4086 4087 spin_lock_irqsave(&brd_lock, flags); 4088 if (tty != NULL) { 4089 if (portp->port.tty == tty) { 4090 stli_comstats.ttystate = tty->flags; 4091 stli_comstats.rxbuffered = -1; 4092 if (tty->termios != NULL) { 4093 stli_comstats.cflags = tty->termios->c_cflag; 4094 stli_comstats.iflags = tty->termios->c_iflag; 4095 stli_comstats.oflags = tty->termios->c_oflag; 4096 stli_comstats.lflags = tty->termios->c_lflag; 4097 } 4098 } 4099 } 4100 spin_unlock_irqrestore(&brd_lock, flags); 4101 4102 stli_comstats.txtotal = stli_cdkstats.txchars; 4103 stli_comstats.rxtotal = stli_cdkstats.rxchars + stli_cdkstats.ringover; 4104 stli_comstats.txbuffered = stli_cdkstats.txringq; 4105 stli_comstats.rxbuffered += stli_cdkstats.rxringq; 4106 stli_comstats.rxoverrun = stli_cdkstats.overruns; 4107 stli_comstats.rxparity = stli_cdkstats.parity; 4108 stli_comstats.rxframing = stli_cdkstats.framing; 4109 stli_comstats.rxlost = stli_cdkstats.ringover; 4110 stli_comstats.rxbreaks = stli_cdkstats.rxbreaks; 4111 stli_comstats.txbreaks = stli_cdkstats.txbreaks; 4112 stli_comstats.txxon = stli_cdkstats.txstart; 4113 stli_comstats.txxoff = stli_cdkstats.txstop; 4114 stli_comstats.rxxon = stli_cdkstats.rxstart; 4115 stli_comstats.rxxoff = stli_cdkstats.rxstop; 4116 stli_comstats.rxrtsoff = stli_cdkstats.rtscnt / 2; 4117 stli_comstats.rxrtson = stli_cdkstats.rtscnt - stli_comstats.rxrtsoff; 4118 stli_comstats.modem = stli_cdkstats.dcdcnt; 4119 stli_comstats.hwid = stli_cdkstats.hwid; 4120 stli_comstats.signals = stli_mktiocm(stli_cdkstats.signals); 4121 mutex_unlock(&portp->port.mutex); 4122 4123 return 0; 4124} 4125 4126/*****************************************************************************/ 4127 4128/* 4129 * Return the port stats structure to user app. A NULL port struct 4130 * pointer passed in means that we need to find out from the app 4131 * what port to get stats for (used through board control device). 4132 */ 4133 4134static int stli_getportstats(struct tty_struct *tty, struct stliport *portp, 4135 comstats_t __user *cp) 4136{ 4137 struct stlibrd *brdp; 4138 int rc; 4139 4140 if (!portp) { 4141 if (copy_from_user(&stli_comstats, cp, sizeof(comstats_t))) 4142 return -EFAULT; 4143 portp = stli_getport(stli_comstats.brd, stli_comstats.panel, 4144 stli_comstats.port); 4145 if (!portp) 4146 return -ENODEV; 4147 } 4148 4149 brdp = stli_brds[portp->brdnr]; 4150 if (!brdp) 4151 return -ENODEV; 4152 4153 if ((rc = stli_portcmdstats(tty, portp)) < 0) 4154 return rc; 4155 4156 return copy_to_user(cp, &stli_comstats, sizeof(comstats_t)) ? 4157 -EFAULT : 0; 4158} 4159 4160/*****************************************************************************/ 4161 4162/* 4163 * Clear the port stats structure. We also return it zeroed out... 4164 */ 4165 4166static int stli_clrportstats(struct stliport *portp, comstats_t __user *cp) 4167{ 4168 struct stlibrd *brdp; 4169 int rc; 4170 4171 if (!portp) { 4172 if (copy_from_user(&stli_comstats, cp, sizeof(comstats_t))) 4173 return -EFAULT; 4174 portp = stli_getport(stli_comstats.brd, stli_comstats.panel, 4175 stli_comstats.port); 4176 if (!portp) 4177 return -ENODEV; 4178 } 4179 4180 brdp = stli_brds[portp->brdnr]; 4181 if (!brdp) 4182 return -ENODEV; 4183 4184 mutex_lock(&portp->port.mutex); 4185 4186 if (test_bit(BST_STARTED, &brdp->state)) { 4187 if ((rc = stli_cmdwait(brdp, portp, A_CLEARSTATS, NULL, 0, 0)) < 0) { 4188 mutex_unlock(&portp->port.mutex); 4189 return rc; 4190 } 4191 } 4192 4193 memset(&stli_comstats, 0, sizeof(comstats_t)); 4194 stli_comstats.brd = portp->brdnr; 4195 stli_comstats.panel = portp->panelnr; 4196 stli_comstats.port = portp->portnr; 4197 mutex_unlock(&portp->port.mutex); 4198 4199 if (copy_to_user(cp, &stli_comstats, sizeof(comstats_t))) 4200 return -EFAULT; 4201 return 0; 4202} 4203 4204/*****************************************************************************/ 4205 4206/* 4207 * Return the entire driver ports structure to a user app. 4208 */ 4209 4210static int stli_getportstruct(struct stliport __user *arg) 4211{ 4212 struct stliport stli_dummyport; 4213 struct stliport *portp; 4214 4215 if (copy_from_user(&stli_dummyport, arg, sizeof(struct stliport))) 4216 return -EFAULT; 4217 portp = stli_getport(stli_dummyport.brdnr, stli_dummyport.panelnr, 4218 stli_dummyport.portnr); 4219 if (!portp) 4220 return -ENODEV; 4221 if (copy_to_user(arg, portp, sizeof(struct stliport))) 4222 return -EFAULT; 4223 return 0; 4224} 4225 4226/*****************************************************************************/ 4227 4228/* 4229 * Return the entire driver board structure to a user app. 4230 */ 4231 4232static int stli_getbrdstruct(struct stlibrd __user *arg) 4233{ 4234 struct stlibrd stli_dummybrd; 4235 struct stlibrd *brdp; 4236 4237 if (copy_from_user(&stli_dummybrd, arg, sizeof(struct stlibrd))) 4238 return -EFAULT; 4239 if (stli_dummybrd.brdnr >= STL_MAXBRDS) 4240 return -ENODEV; 4241 brdp = stli_brds[stli_dummybrd.brdnr]; 4242 if (!brdp) 4243 return -ENODEV; 4244 if (copy_to_user(arg, brdp, sizeof(struct stlibrd))) 4245 return -EFAULT; 4246 return 0; 4247} 4248 4249/*****************************************************************************/ 4250 4251/* 4252 * The "staliomem" device is also required to do some special operations on 4253 * the board. We need to be able to send an interrupt to the board, 4254 * reset it, and start/stop it. 4255 */ 4256 4257static long stli_memioctl(struct file *fp, unsigned int cmd, unsigned long arg) 4258{ 4259 struct stlibrd *brdp; 4260 int brdnr, rc, done; 4261 void __user *argp = (void __user *)arg; 4262 4263/* 4264 * First up handle the board independent ioctls. 4265 */ 4266 done = 0; 4267 rc = 0; 4268 4269 switch (cmd) { 4270 case COM_GETPORTSTATS: 4271 rc = stli_getportstats(NULL, NULL, argp); 4272 done++; 4273 break; 4274 case COM_CLRPORTSTATS: 4275 rc = stli_clrportstats(NULL, argp); 4276 done++; 4277 break; 4278 case COM_GETBRDSTATS: 4279 rc = stli_getbrdstats(argp); 4280 done++; 4281 break; 4282 case COM_READPORT: 4283 rc = stli_getportstruct(argp); 4284 done++; 4285 break; 4286 case COM_READBOARD: 4287 rc = stli_getbrdstruct(argp); 4288 done++; 4289 break; 4290 } 4291 if (done) 4292 return rc; 4293 4294/* 4295 * Now handle the board specific ioctls. These all depend on the 4296 * minor number of the device they were called from. 4297 */ 4298 brdnr = iminor(fp->f_dentry->d_inode); 4299 if (brdnr >= STL_MAXBRDS) 4300 return -ENODEV; 4301 brdp = stli_brds[brdnr]; 4302 if (!brdp) 4303 return -ENODEV; 4304 if (brdp->state == 0) 4305 return -ENODEV; 4306 4307 switch (cmd) { 4308 case STL_BINTR: 4309 EBRDINTR(brdp); 4310 break; 4311 case STL_BSTART: 4312 rc = stli_startbrd(brdp); 4313 break; 4314 case STL_BSTOP: 4315 clear_bit(BST_STARTED, &brdp->state); 4316 break; 4317 case STL_BRESET: 4318 clear_bit(BST_STARTED, &brdp->state); 4319 EBRDRESET(brdp); 4320 if (stli_shared == 0) { 4321 if (brdp->reenable != NULL) 4322 (* brdp->reenable)(brdp); 4323 } 4324 break; 4325 default: 4326 rc = -ENOIOCTLCMD; 4327 break; 4328 } 4329 return rc; 4330} 4331 4332static const struct tty_operations stli_ops = { 4333 .open = stli_open, 4334 .close = stli_close, 4335 .write = stli_write, 4336 .put_char = stli_putchar, 4337 .flush_chars = stli_flushchars, 4338 .write_room = stli_writeroom, 4339 .chars_in_buffer = stli_charsinbuffer, 4340 .ioctl = stli_ioctl, 4341 .set_termios = stli_settermios, 4342 .throttle = stli_throttle, 4343 .unthrottle = stli_unthrottle, 4344 .stop = stli_stop, 4345 .start = stli_start, 4346 .hangup = stli_hangup, 4347 .flush_buffer = stli_flushbuffer, 4348 .break_ctl = stli_breakctl, 4349 .wait_until_sent = stli_waituntilsent, 4350 .send_xchar = stli_sendxchar, 4351 .tiocmget = stli_tiocmget, 4352 .tiocmset = stli_tiocmset, 4353 .proc_fops = &stli_proc_fops, 4354}; 4355 4356static const struct tty_port_operations stli_port_ops = { 4357 .carrier_raised = stli_carrier_raised, 4358 .dtr_rts = stli_dtr_rts, 4359 .activate = stli_activate, 4360 .shutdown = stli_shutdown, 4361}; 4362 4363/*****************************************************************************/ 4364/* 4365 * Loadable module initialization stuff. 4366 */ 4367 4368static void istallion_cleanup_isa(void) 4369{ 4370 struct stlibrd *brdp; 4371 unsigned int j; 4372 4373 for (j = 0; (j < stli_nrbrds); j++) { 4374 if ((brdp = stli_brds[j]) == NULL || 4375 test_bit(BST_PROBED, &brdp->state)) 4376 continue; 4377 4378 stli_cleanup_ports(brdp); 4379 4380 iounmap(brdp->membase); 4381 if (brdp->iosize > 0) 4382 release_region(brdp->iobase, brdp->iosize); 4383 kfree(brdp); 4384 stli_brds[j] = NULL; 4385 } 4386} 4387 4388static int __init istallion_module_init(void) 4389{ 4390 unsigned int i; 4391 int retval; 4392 4393 printk(KERN_INFO "%s: version %s\n", stli_drvtitle, stli_drvversion); 4394 4395 spin_lock_init(&stli_lock); 4396 spin_lock_init(&brd_lock); 4397 4398 stli_txcookbuf = kmalloc(STLI_TXBUFSIZE, GFP_KERNEL); 4399 if (!stli_txcookbuf) { 4400 printk(KERN_ERR "istallion: failed to allocate memory " 4401 "(size=%d)\n", STLI_TXBUFSIZE); 4402 retval = -ENOMEM; 4403 goto err; 4404 } 4405 4406 stli_serial = alloc_tty_driver(STL_MAXBRDS * STL_MAXPORTS); 4407 if (!stli_serial) { 4408 retval = -ENOMEM; 4409 goto err_free; 4410 } 4411 4412 stli_serial->owner = THIS_MODULE; 4413 stli_serial->driver_name = stli_drvname; 4414 stli_serial->name = stli_serialname; 4415 stli_serial->major = STL_SERIALMAJOR; 4416 stli_serial->minor_start = 0; 4417 stli_serial->type = TTY_DRIVER_TYPE_SERIAL; 4418 stli_serial->subtype = SERIAL_TYPE_NORMAL; 4419 stli_serial->init_termios = stli_deftermios; 4420 stli_serial->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; 4421 tty_set_operations(stli_serial, &stli_ops); 4422 4423 retval = tty_register_driver(stli_serial); 4424 if (retval) { 4425 printk(KERN_ERR "istallion: failed to register serial driver\n"); 4426 goto err_ttyput; 4427 } 4428 4429 retval = stli_initbrds(); 4430 if (retval) 4431 goto err_ttyunr; 4432 4433/* 4434 * Set up a character driver for the shared memory region. We need this 4435 * to down load the slave code image. Also it is a useful debugging tool. 4436 */ 4437 retval = register_chrdev(STL_SIOMEMMAJOR, "staliomem", &stli_fsiomem); 4438 if (retval) { 4439 printk(KERN_ERR "istallion: failed to register serial memory " 4440 "device\n"); 4441 goto err_deinit; 4442 } 4443 4444 istallion_class = class_create(THIS_MODULE, "staliomem"); 4445 for (i = 0; i < 4; i++) 4446 device_create(istallion_class, NULL, MKDEV(STL_SIOMEMMAJOR, i), 4447 NULL, "staliomem%d", i); 4448 4449 return 0; 4450err_deinit: 4451 pci_unregister_driver(&stli_pcidriver); 4452 istallion_cleanup_isa(); 4453err_ttyunr: 4454 tty_unregister_driver(stli_serial); 4455err_ttyput: 4456 put_tty_driver(stli_serial); 4457err_free: 4458 kfree(stli_txcookbuf); 4459err: 4460 return retval; 4461} 4462 4463/*****************************************************************************/ 4464 4465static void __exit istallion_module_exit(void) 4466{ 4467 unsigned int j; 4468 4469 printk(KERN_INFO "Unloading %s: version %s\n", stli_drvtitle, 4470 stli_drvversion); 4471 4472 if (stli_timeron) { 4473 stli_timeron = 0; 4474 del_timer_sync(&stli_timerlist); 4475 } 4476 4477 unregister_chrdev(STL_SIOMEMMAJOR, "staliomem"); 4478 4479 for (j = 0; j < 4; j++) 4480 device_destroy(istallion_class, MKDEV(STL_SIOMEMMAJOR, j)); 4481 class_destroy(istallion_class); 4482 4483 pci_unregister_driver(&stli_pcidriver); 4484 istallion_cleanup_isa(); 4485 4486 tty_unregister_driver(stli_serial); 4487 put_tty_driver(stli_serial); 4488 4489 kfree(stli_txcookbuf); 4490} 4491 4492module_init(istallion_module_init); 4493module_exit(istallion_module_exit); 4494