blob: 3c66f402f9d7b177bc42687ce08711184e45bc3a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*****************************************************************************/
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 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 */
18
19/*****************************************************************************/
20
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <linux/module.h>
22#include <linux/slab.h>
23#include <linux/interrupt.h>
24#include <linux/tty.h>
25#include <linux/tty_flip.h>
26#include <linux/serial.h>
27#include <linux/cdk.h>
28#include <linux/comstats.h>
29#include <linux/istallion.h>
30#include <linux/ioport.h>
31#include <linux/delay.h>
32#include <linux/init.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <linux/device.h>
34#include <linux/wait.h>
Alan Cox4ac43602006-06-28 04:26:52 -070035#include <linux/eisa.h>
Jiri Slabya3f8d9d2006-12-08 02:39:18 -080036#include <linux/ctype.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
38#include <asm/io.h>
39#include <asm/uaccess.h>
40
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#include <linux/pci.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
43/*****************************************************************************/
44
45/*
46 * Define different board types. Not all of the following board types
47 * are supported by this driver. But I will use the standard "assigned"
48 * board numbers. Currently supported boards are abbreviated as:
49 * ECP = EasyConnection 8/64, ONB = ONboard, BBY = Brumby and
50 * STAL = Stallion.
51 */
52#define BRD_UNKNOWN 0
53#define BRD_STALLION 1
54#define BRD_BRUMBY4 2
55#define BRD_ONBOARD2 3
56#define BRD_ONBOARD 4
Linus Torvalds1da177e2005-04-16 15:20:36 -070057#define BRD_ONBOARDE 7
Linus Torvalds1da177e2005-04-16 15:20:36 -070058#define BRD_ECP 23
59#define BRD_ECPE 24
60#define BRD_ECPMC 25
Linus Torvalds1da177e2005-04-16 15:20:36 -070061#define BRD_ECPPCI 29
62
63#define BRD_BRUMBY BRD_BRUMBY4
64
65/*
66 * Define a configuration structure to hold the board configuration.
67 * Need to set this up in the code (for now) with the boards that are
68 * to be configured into the system. This is what needs to be modified
69 * when adding/removing/modifying boards. Each line entry in the
70 * stli_brdconf[] array is a board. Each line contains io/irq/memory
71 * ranges for that board (as well as what type of board it is).
72 * Some examples:
73 * { BRD_ECP, 0x2a0, 0, 0xcc000, 0, 0 },
74 * This line will configure an EasyConnection 8/64 at io address 2a0,
75 * and shared memory address of cc000. Multiple EasyConnection 8/64
76 * boards can share the same shared memory address space. No interrupt
77 * is required for this board type.
78 * Another example:
79 * { BRD_ECPE, 0x5000, 0, 0x80000000, 0, 0 },
80 * This line will configure an EasyConnection 8/64 EISA in slot 5 and
81 * shared memory address of 0x80000000 (2 GByte). Multiple
82 * EasyConnection 8/64 EISA boards can share the same shared memory
83 * address space. No interrupt is required for this board type.
84 * Another example:
85 * { BRD_ONBOARD, 0x240, 0, 0xd0000, 0, 0 },
86 * This line will configure an ONboard (ISA type) at io address 240,
87 * and shared memory address of d0000. Multiple ONboards can share
88 * the same shared memory address space. No interrupt required.
89 * Another example:
90 * { BRD_BRUMBY4, 0x360, 0, 0xc8000, 0, 0 },
91 * This line will configure a Brumby board (any number of ports!) at
92 * io address 360 and shared memory address of c8000. All Brumby boards
93 * configured into a system must have their own separate io and memory
94 * addresses. No interrupt is required.
95 * Another example:
96 * { BRD_STALLION, 0x330, 0, 0xd0000, 0, 0 },
97 * This line will configure an original Stallion board at io address 330
98 * and shared memory address d0000 (this would only be valid for a "V4.0"
99 * or Rev.O Stallion board). All Stallion boards configured into the
100 * system must have their own separate io and memory addresses. No
101 * interrupt is required.
102 */
103
Jiri Slaby1f8ec432006-12-08 02:39:18 -0800104struct stlconf {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 int brdtype;
106 int ioaddr1;
107 int ioaddr2;
108 unsigned long memaddr;
109 int irq;
110 int irqtype;
Jiri Slaby1f8ec432006-12-08 02:39:18 -0800111};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112
Jiri Slaby1328d732006-12-08 02:39:19 -0800113static unsigned int stli_nrbrds;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114
Alan Cox4ac43602006-06-28 04:26:52 -0700115/* stli_lock must NOT be taken holding brd_lock */
116static spinlock_t stli_lock; /* TTY logic lock */
117static spinlock_t brd_lock; /* Board logic lock */
118
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119/*
120 * There is some experimental EISA board detection code in this driver.
121 * By default it is disabled, but for those that want to try it out,
122 * then set the define below to be 1.
123 */
124#define STLI_EISAPROBE 0
125
126/*****************************************************************************/
127
128/*
129 * Define some important driver characteristics. Device major numbers
130 * allocated as per Linux Device Registry.
131 */
132#ifndef STL_SIOMEMMAJOR
133#define STL_SIOMEMMAJOR 28
134#endif
135#ifndef STL_SERIALMAJOR
136#define STL_SERIALMAJOR 24
137#endif
138#ifndef STL_CALLOUTMAJOR
139#define STL_CALLOUTMAJOR 25
140#endif
141
142/*****************************************************************************/
143
144/*
145 * Define our local driver identity first. Set up stuff to deal with
146 * all the local structures required by a serial tty driver.
147 */
148static char *stli_drvtitle = "Stallion Intelligent Multiport Serial Driver";
149static char *stli_drvname = "istallion";
150static char *stli_drvversion = "5.6.0";
151static char *stli_serialname = "ttyE";
152
153static struct tty_driver *stli_serial;
154
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155
156#define STLI_TXBUFSIZE 4096
157
158/*
159 * Use a fast local buffer for cooked characters. Typically a whole
160 * bunch of cooked characters come in for a port, 1 at a time. So we
161 * save those up into a local buffer, then write out the whole lot
162 * with a large memcpy. Just use 1 buffer for all ports, since its
163 * use it is only need for short periods of time by each port.
164 */
165static char *stli_txcookbuf;
166static int stli_txcooksize;
167static int stli_txcookrealsize;
168static struct tty_struct *stli_txcooktty;
169
170/*
171 * Define a local default termios struct. All ports will be created
172 * with this termios initially. Basically all it defines is a raw port
173 * at 9600 baud, 8 data bits, no parity, 1 stop bit.
174 */
Alan Cox606d0992006-12-08 02:38:45 -0800175static struct ktermios stli_deftermios = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 .c_cflag = (B9600 | CS8 | CREAD | HUPCL | CLOCAL),
177 .c_cc = INIT_C_CC,
Alan Cox606d0992006-12-08 02:38:45 -0800178 .c_ispeed = 9600,
179 .c_ospeed = 9600,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180};
181
182/*
183 * Define global stats structures. Not used often, and can be
184 * re-used for each stats call.
185 */
186static comstats_t stli_comstats;
187static combrd_t stli_brdstats;
Jiri Slaby1f8ec432006-12-08 02:39:18 -0800188static struct asystats stli_cdkstats;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189
190/*****************************************************************************/
191
Jiri Slabyb103b5c2006-12-08 02:39:21 -0800192static DEFINE_MUTEX(stli_brdslock);
Jiri Slaby1f8ec432006-12-08 02:39:18 -0800193static struct stlibrd *stli_brds[STL_MAXBRDS];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194
195static int stli_shared;
196
197/*
198 * Per board state flags. Used with the state field of the board struct.
199 * Not really much here... All we need to do is keep track of whether
200 * the board has been detected, and whether it is actually running a slave
201 * or not.
202 */
203#define BST_FOUND 0x1
204#define BST_STARTED 0x2
Jiri Slaby39014172006-12-08 02:39:22 -0800205#define BST_PROBED 0x4
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206
207/*
208 * Define the set of port state flags. These are marked for internal
209 * state purposes only, usually to do with the state of communications
210 * with the slave. Most of them need to be updated atomically, so always
211 * use the bit setting operations (unless protected by cli/sti).
212 */
213#define ST_INITIALIZING 1
214#define ST_OPENING 2
215#define ST_CLOSING 3
216#define ST_CMDING 4
217#define ST_TXBUSY 5
218#define ST_RXING 6
219#define ST_DOFLUSHRX 7
220#define ST_DOFLUSHTX 8
221#define ST_DOSIGS 9
222#define ST_RXSTOP 10
223#define ST_GETSIGS 11
224
225/*
226 * Define an array of board names as printable strings. Handy for
227 * referencing boards when printing trace and stuff.
228 */
229static char *stli_brdnames[] = {
230 "Unknown",
231 "Stallion",
232 "Brumby",
233 "ONboard-MC",
234 "ONboard",
235 "Brumby",
236 "Brumby",
237 "ONboard-EI",
Jiri Slabya3f8d9d2006-12-08 02:39:18 -0800238 NULL,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 "ONboard",
240 "ONboard-MC",
241 "ONboard-MC",
Jiri Slabya3f8d9d2006-12-08 02:39:18 -0800242 NULL,
243 NULL,
244 NULL,
245 NULL,
246 NULL,
247 NULL,
248 NULL,
249 NULL,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 "EasyIO",
251 "EC8/32-AT",
252 "EC8/32-MC",
253 "EC8/64-AT",
254 "EC8/64-EI",
255 "EC8/64-MC",
256 "EC8/32-PCI",
257 "EC8/64-PCI",
258 "EasyIO-PCI",
259 "EC/RA-PCI",
260};
261
262/*****************************************************************************/
263
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264/*
265 * Define some string labels for arguments passed from the module
266 * load line. These allow for easy board definitions, and easy
267 * modification of the io, memory and irq resoucres.
268 */
269
270static char *board0[8];
271static char *board1[8];
272static char *board2[8];
273static char *board3[8];
274
275static char **stli_brdsp[] = {
276 (char **) &board0,
277 (char **) &board1,
278 (char **) &board2,
279 (char **) &board3
280};
281
282/*
283 * Define a set of common board names, and types. This is used to
284 * parse any module arguments.
285 */
286
Jiri Slaby1f8ec432006-12-08 02:39:18 -0800287static struct stlibrdtype {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 char *name;
289 int type;
Jiri Slaby1f8ec432006-12-08 02:39:18 -0800290} stli_brdstr[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 { "stallion", BRD_STALLION },
292 { "1", BRD_STALLION },
293 { "brumby", BRD_BRUMBY },
294 { "brumby4", BRD_BRUMBY },
295 { "brumby/4", BRD_BRUMBY },
296 { "brumby-4", BRD_BRUMBY },
297 { "brumby8", BRD_BRUMBY },
298 { "brumby/8", BRD_BRUMBY },
299 { "brumby-8", BRD_BRUMBY },
300 { "brumby16", BRD_BRUMBY },
301 { "brumby/16", BRD_BRUMBY },
302 { "brumby-16", BRD_BRUMBY },
303 { "2", BRD_BRUMBY },
304 { "onboard2", BRD_ONBOARD2 },
305 { "onboard-2", BRD_ONBOARD2 },
306 { "onboard/2", BRD_ONBOARD2 },
307 { "onboard-mc", BRD_ONBOARD2 },
308 { "onboard/mc", BRD_ONBOARD2 },
309 { "onboard-mca", BRD_ONBOARD2 },
310 { "onboard/mca", BRD_ONBOARD2 },
311 { "3", BRD_ONBOARD2 },
312 { "onboard", BRD_ONBOARD },
313 { "onboardat", BRD_ONBOARD },
314 { "4", BRD_ONBOARD },
315 { "onboarde", BRD_ONBOARDE },
316 { "onboard-e", BRD_ONBOARDE },
317 { "onboard/e", BRD_ONBOARDE },
318 { "onboard-ei", BRD_ONBOARDE },
319 { "onboard/ei", BRD_ONBOARDE },
320 { "7", BRD_ONBOARDE },
321 { "ecp", BRD_ECP },
322 { "ecpat", BRD_ECP },
323 { "ec8/64", BRD_ECP },
324 { "ec8/64-at", BRD_ECP },
325 { "ec8/64-isa", BRD_ECP },
326 { "23", BRD_ECP },
327 { "ecpe", BRD_ECPE },
328 { "ecpei", BRD_ECPE },
329 { "ec8/64-e", BRD_ECPE },
330 { "ec8/64-ei", BRD_ECPE },
331 { "24", BRD_ECPE },
332 { "ecpmc", BRD_ECPMC },
333 { "ec8/64-mc", BRD_ECPMC },
334 { "ec8/64-mca", BRD_ECPMC },
335 { "25", BRD_ECPMC },
336 { "ecppci", BRD_ECPPCI },
337 { "ec/ra", BRD_ECPPCI },
338 { "ec/ra-pc", BRD_ECPPCI },
339 { "ec/ra-pci", BRD_ECPPCI },
340 { "29", BRD_ECPPCI },
341};
342
343/*
344 * Define the module agruments.
345 */
346MODULE_AUTHOR("Greg Ungerer");
347MODULE_DESCRIPTION("Stallion Intelligent Multiport Serial Driver");
348MODULE_LICENSE("GPL");
349
350
Rusty Russell8d3b33f2006-03-25 03:07:05 -0800351module_param_array(board0, charp, NULL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352MODULE_PARM_DESC(board0, "Board 0 config -> name[,ioaddr[,memaddr]");
Rusty Russell8d3b33f2006-03-25 03:07:05 -0800353module_param_array(board1, charp, NULL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354MODULE_PARM_DESC(board1, "Board 1 config -> name[,ioaddr[,memaddr]");
Rusty Russell8d3b33f2006-03-25 03:07:05 -0800355module_param_array(board2, charp, NULL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356MODULE_PARM_DESC(board2, "Board 2 config -> name[,ioaddr[,memaddr]");
Rusty Russell8d3b33f2006-03-25 03:07:05 -0800357module_param_array(board3, charp, NULL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358MODULE_PARM_DESC(board3, "Board 3 config -> name[,ioaddr[,memaddr]");
359
Jiri Slabya00f33f2006-12-08 02:39:20 -0800360#if STLI_EISAPROBE != 0
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361/*
362 * Set up a default memory address table for EISA board probing.
363 * The default addresses are all bellow 1Mbyte, which has to be the
364 * case anyway. They should be safe, since we only read values from
365 * them, and interrupts are disabled while we do it. If the higher
366 * memory support is compiled in then we also try probing around
367 * the 1Gb, 2Gb and 3Gb areas as well...
368 */
369static unsigned long stli_eisamemprobeaddrs[] = {
370 0xc0000, 0xd0000, 0xe0000, 0xf0000,
371 0x80000000, 0x80010000, 0x80020000, 0x80030000,
372 0x40000000, 0x40010000, 0x40020000, 0x40030000,
373 0xc0000000, 0xc0010000, 0xc0020000, 0xc0030000,
374 0xff000000, 0xff010000, 0xff020000, 0xff030000,
375};
376
Tobias Klauserfe971072006-01-09 20:54:02 -0800377static int stli_eisamempsize = ARRAY_SIZE(stli_eisamemprobeaddrs);
Jiri Slabya00f33f2006-12-08 02:39:20 -0800378#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379
380/*
381 * Define the Stallion PCI vendor and device IDs.
382 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383#ifndef PCI_DEVICE_ID_ECRA
384#define PCI_DEVICE_ID_ECRA 0x0004
385#endif
386
387static struct pci_device_id istallion_pci_tbl[] = {
Alan Cox4ac43602006-06-28 04:26:52 -0700388 { PCI_DEVICE(PCI_VENDOR_ID_STALLION, PCI_DEVICE_ID_ECRA), },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 { 0 }
390};
391MODULE_DEVICE_TABLE(pci, istallion_pci_tbl);
392
Jiri Slaby845bead2006-12-08 02:39:17 -0800393static struct pci_driver stli_pcidriver;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394
395/*****************************************************************************/
396
397/*
398 * Hardware configuration info for ECP boards. These defines apply
399 * to the directly accessible io ports of the ECP. There is a set of
400 * defines for each ECP board type, ISA, EISA, MCA and PCI.
401 */
402#define ECP_IOSIZE 4
403
404#define ECP_MEMSIZE (128 * 1024)
405#define ECP_PCIMEMSIZE (256 * 1024)
406
407#define ECP_ATPAGESIZE (4 * 1024)
408#define ECP_MCPAGESIZE (4 * 1024)
409#define ECP_EIPAGESIZE (64 * 1024)
410#define ECP_PCIPAGESIZE (64 * 1024)
411
412#define STL_EISAID 0x8c4e
413
414/*
415 * Important defines for the ISA class of ECP board.
416 */
417#define ECP_ATIREG 0
418#define ECP_ATCONFR 1
419#define ECP_ATMEMAR 2
420#define ECP_ATMEMPR 3
421#define ECP_ATSTOP 0x1
422#define ECP_ATINTENAB 0x10
423#define ECP_ATENABLE 0x20
424#define ECP_ATDISABLE 0x00
425#define ECP_ATADDRMASK 0x3f000
426#define ECP_ATADDRSHFT 12
427
428/*
429 * Important defines for the EISA class of ECP board.
430 */
431#define ECP_EIIREG 0
432#define ECP_EIMEMARL 1
433#define ECP_EICONFR 2
434#define ECP_EIMEMARH 3
435#define ECP_EIENABLE 0x1
436#define ECP_EIDISABLE 0x0
437#define ECP_EISTOP 0x4
438#define ECP_EIEDGE 0x00
439#define ECP_EILEVEL 0x80
440#define ECP_EIADDRMASKL 0x00ff0000
441#define ECP_EIADDRSHFTL 16
442#define ECP_EIADDRMASKH 0xff000000
443#define ECP_EIADDRSHFTH 24
444#define ECP_EIBRDENAB 0xc84
445
446#define ECP_EISAID 0x4
447
448/*
449 * Important defines for the Micro-channel class of ECP board.
450 * (It has a lot in common with the ISA boards.)
451 */
452#define ECP_MCIREG 0
453#define ECP_MCCONFR 1
454#define ECP_MCSTOP 0x20
455#define ECP_MCENABLE 0x80
456#define ECP_MCDISABLE 0x00
457
458/*
459 * Important defines for the PCI class of ECP board.
460 * (It has a lot in common with the other ECP boards.)
461 */
462#define ECP_PCIIREG 0
463#define ECP_PCICONFR 1
464#define ECP_PCISTOP 0x01
465
466/*
467 * Hardware configuration info for ONboard and Brumby boards. These
468 * defines apply to the directly accessible io ports of these boards.
469 */
470#define ONB_IOSIZE 16
471#define ONB_MEMSIZE (64 * 1024)
472#define ONB_ATPAGESIZE (64 * 1024)
473#define ONB_MCPAGESIZE (64 * 1024)
474#define ONB_EIMEMSIZE (128 * 1024)
475#define ONB_EIPAGESIZE (64 * 1024)
476
477/*
478 * Important defines for the ISA class of ONboard board.
479 */
480#define ONB_ATIREG 0
481#define ONB_ATMEMAR 1
482#define ONB_ATCONFR 2
483#define ONB_ATSTOP 0x4
484#define ONB_ATENABLE 0x01
485#define ONB_ATDISABLE 0x00
486#define ONB_ATADDRMASK 0xff0000
487#define ONB_ATADDRSHFT 16
488
489#define ONB_MEMENABLO 0
490#define ONB_MEMENABHI 0x02
491
492/*
493 * Important defines for the EISA class of ONboard board.
494 */
495#define ONB_EIIREG 0
496#define ONB_EIMEMARL 1
497#define ONB_EICONFR 2
498#define ONB_EIMEMARH 3
499#define ONB_EIENABLE 0x1
500#define ONB_EIDISABLE 0x0
501#define ONB_EISTOP 0x4
502#define ONB_EIEDGE 0x00
503#define ONB_EILEVEL 0x80
504#define ONB_EIADDRMASKL 0x00ff0000
505#define ONB_EIADDRSHFTL 16
506#define ONB_EIADDRMASKH 0xff000000
507#define ONB_EIADDRSHFTH 24
508#define ONB_EIBRDENAB 0xc84
509
510#define ONB_EISAID 0x1
511
512/*
513 * Important defines for the Brumby boards. They are pretty simple,
514 * there is not much that is programmably configurable.
515 */
516#define BBY_IOSIZE 16
517#define BBY_MEMSIZE (64 * 1024)
518#define BBY_PAGESIZE (16 * 1024)
519
520#define BBY_ATIREG 0
521#define BBY_ATCONFR 1
522#define BBY_ATSTOP 0x4
523
524/*
525 * Important defines for the Stallion boards. They are pretty simple,
526 * there is not much that is programmably configurable.
527 */
528#define STAL_IOSIZE 16
529#define STAL_MEMSIZE (64 * 1024)
530#define STAL_PAGESIZE (64 * 1024)
531
532/*
533 * Define the set of status register values for EasyConnection panels.
534 * The signature will return with the status value for each panel. From
535 * this we can determine what is attached to the board - before we have
536 * actually down loaded any code to it.
537 */
538#define ECH_PNLSTATUS 2
539#define ECH_PNL16PORT 0x20
540#define ECH_PNLIDMASK 0x07
541#define ECH_PNLXPID 0x40
542#define ECH_PNLINTRPEND 0x80
543
544/*
545 * Define some macros to do things to the board. Even those these boards
546 * are somewhat related there is often significantly different ways of
547 * doing some operation on it (like enable, paging, reset, etc). So each
548 * board class has a set of functions which do the commonly required
549 * operations. The macros below basically just call these functions,
550 * generally checking for a NULL function - which means that the board
551 * needs nothing done to it to achieve this operation!
552 */
553#define EBRDINIT(brdp) \
554 if (brdp->init != NULL) \
555 (* brdp->init)(brdp)
556
557#define EBRDENABLE(brdp) \
558 if (brdp->enable != NULL) \
559 (* brdp->enable)(brdp);
560
561#define EBRDDISABLE(brdp) \
562 if (brdp->disable != NULL) \
563 (* brdp->disable)(brdp);
564
565#define EBRDINTR(brdp) \
566 if (brdp->intr != NULL) \
567 (* brdp->intr)(brdp);
568
569#define EBRDRESET(brdp) \
570 if (brdp->reset != NULL) \
571 (* brdp->reset)(brdp);
572
573#define EBRDGETMEMPTR(brdp,offset) \
574 (* brdp->getmemptr)(brdp, offset, __LINE__)
575
576/*
577 * Define the maximal baud rate, and the default baud base for ports.
578 */
579#define STL_MAXBAUD 460800
580#define STL_BAUDBASE 115200
581#define STL_CLOSEDELAY (5 * HZ / 10)
582
583/*****************************************************************************/
584
585/*
586 * Define macros to extract a brd or port number from a minor number.
587 */
588#define MINOR2BRD(min) (((min) & 0xc0) >> 6)
589#define MINOR2PORT(min) ((min) & 0x3f)
590
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591/*****************************************************************************/
592
593/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 * Prototype all functions in this driver!
595 */
596
Jiri Slaby1f8ec432006-12-08 02:39:18 -0800597static int stli_parsebrd(struct stlconf *confp, char **argp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598static int stli_open(struct tty_struct *tty, struct file *filp);
599static void stli_close(struct tty_struct *tty, struct file *filp);
600static int stli_write(struct tty_struct *tty, const unsigned char *buf, int count);
601static void stli_putchar(struct tty_struct *tty, unsigned char ch);
602static void stli_flushchars(struct tty_struct *tty);
603static int stli_writeroom(struct tty_struct *tty);
604static int stli_charsinbuffer(struct tty_struct *tty);
605static int stli_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg);
Alan Cox606d0992006-12-08 02:38:45 -0800606static void stli_settermios(struct tty_struct *tty, struct ktermios *old);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607static void stli_throttle(struct tty_struct *tty);
608static void stli_unthrottle(struct tty_struct *tty);
609static void stli_stop(struct tty_struct *tty);
610static void stli_start(struct tty_struct *tty);
611static void stli_flushbuffer(struct tty_struct *tty);
612static void stli_breakctl(struct tty_struct *tty, int state);
613static void stli_waituntilsent(struct tty_struct *tty, int timeout);
614static void stli_sendxchar(struct tty_struct *tty, char ch);
615static void stli_hangup(struct tty_struct *tty);
Jiri Slaby1f8ec432006-12-08 02:39:18 -0800616static int stli_portinfo(struct stlibrd *brdp, struct stliport *portp, int portnr, char *pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617
Jiri Slaby1f8ec432006-12-08 02:39:18 -0800618static int stli_brdinit(struct stlibrd *brdp);
619static int stli_startbrd(struct stlibrd *brdp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620static ssize_t stli_memread(struct file *fp, char __user *buf, size_t count, loff_t *offp);
621static ssize_t stli_memwrite(struct file *fp, const char __user *buf, size_t count, loff_t *offp);
622static int stli_memioctl(struct inode *ip, struct file *fp, unsigned int cmd, unsigned long arg);
Jiri Slaby1f8ec432006-12-08 02:39:18 -0800623static void stli_brdpoll(struct stlibrd *brdp, cdkhdr_t __iomem *hdrp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624static void stli_poll(unsigned long arg);
Jiri Slaby1f8ec432006-12-08 02:39:18 -0800625static int stli_hostcmd(struct stlibrd *brdp, struct stliport *portp);
626static int stli_initopen(struct stlibrd *brdp, struct stliport *portp);
627static int stli_rawopen(struct stlibrd *brdp, struct stliport *portp, unsigned long arg, int wait);
628static int stli_rawclose(struct stlibrd *brdp, struct stliport *portp, unsigned long arg, int wait);
629static int stli_waitcarrier(struct stlibrd *brdp, struct stliport *portp, struct file *filp);
Al Viro3e577a82006-12-06 18:41:45 +0000630static void stli_dohangup(struct work_struct *);
Jiri Slaby1f8ec432006-12-08 02:39:18 -0800631static int stli_setport(struct stliport *portp);
632static int stli_cmdwait(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_sendcmd(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback);
635static void stli_dodelaycmd(struct stliport *portp, cdkctrl_t __iomem *cp);
636static void stli_mkasyport(struct stliport *portp, asyport_t *pp, struct ktermios *tiosp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637static void stli_mkasysigs(asysigs_t *sp, int dtr, int rts);
638static long stli_mktiocm(unsigned long sigvalue);
Jiri Slaby1f8ec432006-12-08 02:39:18 -0800639static void stli_read(struct stlibrd *brdp, struct stliport *portp);
640static int stli_getserial(struct stliport *portp, struct serial_struct __user *sp);
641static int stli_setserial(struct stliport *portp, struct serial_struct __user *sp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642static int stli_getbrdstats(combrd_t __user *bp);
Jiri Slaby1f8ec432006-12-08 02:39:18 -0800643static int stli_getportstats(struct stliport *portp, comstats_t __user *cp);
644static int stli_portcmdstats(struct stliport *portp);
645static int stli_clrportstats(struct stliport *portp, comstats_t __user *cp);
646static int stli_getportstruct(struct stliport __user *arg);
647static int stli_getbrdstruct(struct stlibrd __user *arg);
648static struct stlibrd *stli_allocbrd(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649
Jiri Slaby1f8ec432006-12-08 02:39:18 -0800650static void stli_ecpinit(struct stlibrd *brdp);
651static void stli_ecpenable(struct stlibrd *brdp);
652static void stli_ecpdisable(struct stlibrd *brdp);
653static void __iomem *stli_ecpgetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
654static void stli_ecpreset(struct stlibrd *brdp);
655static void stli_ecpintr(struct stlibrd *brdp);
656static void stli_ecpeiinit(struct stlibrd *brdp);
657static void stli_ecpeienable(struct stlibrd *brdp);
658static void stli_ecpeidisable(struct stlibrd *brdp);
659static void __iomem *stli_ecpeigetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
660static void stli_ecpeireset(struct stlibrd *brdp);
661static void stli_ecpmcenable(struct stlibrd *brdp);
662static void stli_ecpmcdisable(struct stlibrd *brdp);
663static void __iomem *stli_ecpmcgetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
664static void stli_ecpmcreset(struct stlibrd *brdp);
665static void stli_ecppciinit(struct stlibrd *brdp);
666static void __iomem *stli_ecppcigetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
667static void stli_ecppcireset(struct stlibrd *brdp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668
Jiri Slaby1f8ec432006-12-08 02:39:18 -0800669static void stli_onbinit(struct stlibrd *brdp);
670static void stli_onbenable(struct stlibrd *brdp);
671static void stli_onbdisable(struct stlibrd *brdp);
672static void __iomem *stli_onbgetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
673static void stli_onbreset(struct stlibrd *brdp);
674static void stli_onbeinit(struct stlibrd *brdp);
675static void stli_onbeenable(struct stlibrd *brdp);
676static void stli_onbedisable(struct stlibrd *brdp);
677static void __iomem *stli_onbegetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
678static void stli_onbereset(struct stlibrd *brdp);
679static void stli_bbyinit(struct stlibrd *brdp);
680static void __iomem *stli_bbygetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
681static void stli_bbyreset(struct stlibrd *brdp);
682static void stli_stalinit(struct stlibrd *brdp);
683static void __iomem *stli_stalgetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
684static void stli_stalreset(struct stlibrd *brdp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685
Jiri Slaby1328d732006-12-08 02:39:19 -0800686static struct stliport *stli_getport(unsigned int brdnr, unsigned int panelnr, unsigned int portnr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687
Jiri Slaby1f8ec432006-12-08 02:39:18 -0800688static int stli_initecp(struct stlibrd *brdp);
689static int stli_initonb(struct stlibrd *brdp);
Jiri Slabya00f33f2006-12-08 02:39:20 -0800690#if STLI_EISAPROBE != 0
Jiri Slaby1f8ec432006-12-08 02:39:18 -0800691static int stli_eisamemprobe(struct stlibrd *brdp);
Jiri Slabya00f33f2006-12-08 02:39:20 -0800692#endif
Jiri Slaby1f8ec432006-12-08 02:39:18 -0800693static int stli_initports(struct stlibrd *brdp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695/*****************************************************************************/
696
697/*
698 * Define the driver info for a user level shared memory device. This
699 * device will work sort of like the /dev/kmem device - except that it
700 * will give access to the shared memory on the Stallion intelligent
701 * board. This is also a very useful debugging tool.
702 */
Arjan van de Ven62322d22006-07-03 00:24:21 -0700703static const struct file_operations stli_fsiomem = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 .owner = THIS_MODULE,
705 .read = stli_memread,
706 .write = stli_memwrite,
707 .ioctl = stli_memioctl,
708};
709
710/*****************************************************************************/
711
712/*
713 * Define a timer_list entry for our poll routine. The slave board
714 * is polled every so often to see if anything needs doing. This is
715 * much cheaper on host cpu than using interrupts. It turns out to
716 * not increase character latency by much either...
717 */
Ingo Molnar8d06afa2005-09-09 13:10:40 -0700718static DEFINE_TIMER(stli_timerlist, stli_poll, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719
720static int stli_timeron;
721
722/*
723 * Define the calculation for the timeout routine.
724 */
725#define STLI_TIMEOUT (jiffies + 1)
726
727/*****************************************************************************/
728
gregkh@suse.deca8eca62005-03-23 09:53:09 -0800729static struct class *istallion_class;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730
Jiri Slaby1f8ec432006-12-08 02:39:18 -0800731static void stli_cleanup_ports(struct stlibrd *brdp)
Jiri Slaby845bead2006-12-08 02:39:17 -0800732{
Jiri Slaby1f8ec432006-12-08 02:39:18 -0800733 struct stliport *portp;
Jiri Slaby845bead2006-12-08 02:39:17 -0800734 unsigned int j;
735
736 for (j = 0; j < STL_MAXPORTS; j++) {
737 portp = brdp->ports[j];
738 if (portp != NULL) {
739 if (portp->tty != NULL)
740 tty_hangup(portp->tty);
741 kfree(portp);
742 }
743 }
744}
745
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746/*****************************************************************************/
747
748/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 * Parse the supplied argument string, into the board conf struct.
750 */
751
Jiri Slaby1f8ec432006-12-08 02:39:18 -0800752static int stli_parsebrd(struct stlconf *confp, char **argp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753{
Jiri Slaby1328d732006-12-08 02:39:19 -0800754 unsigned int i;
Alan Cox4ac43602006-06-28 04:26:52 -0700755 char *sp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756
Alan Cox4ac43602006-06-28 04:26:52 -0700757 if (argp[0] == NULL || *argp[0] == 0)
758 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759
760 for (sp = argp[0], i = 0; ((*sp != 0) && (i < 25)); sp++, i++)
Jiri Slabya3f8d9d2006-12-08 02:39:18 -0800761 *sp = tolower(*sp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762
Tobias Klauserfe971072006-01-09 20:54:02 -0800763 for (i = 0; i < ARRAY_SIZE(stli_brdstr); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 if (strcmp(stli_brdstr[i].name, argp[0]) == 0)
765 break;
766 }
Tobias Klauserfe971072006-01-09 20:54:02 -0800767 if (i == ARRAY_SIZE(stli_brdstr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 printk("STALLION: unknown board name, %s?\n", argp[0]);
Tobias Klauserfe971072006-01-09 20:54:02 -0800769 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 }
771
772 confp->brdtype = stli_brdstr[i].type;
Alan Cox4ac43602006-06-28 04:26:52 -0700773 if (argp[1] != NULL && *argp[1] != 0)
Jiri Slabya3f8d9d2006-12-08 02:39:18 -0800774 confp->ioaddr1 = simple_strtoul(argp[1], NULL, 0);
Alan Cox4ac43602006-06-28 04:26:52 -0700775 if (argp[2] != NULL && *argp[2] != 0)
Jiri Slabya3f8d9d2006-12-08 02:39:18 -0800776 confp->memaddr = simple_strtoul(argp[2], NULL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 return(1);
778}
779
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780/*****************************************************************************/
781
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782static int stli_open(struct tty_struct *tty, struct file *filp)
783{
Jiri Slaby1f8ec432006-12-08 02:39:18 -0800784 struct stlibrd *brdp;
785 struct stliport *portp;
Jiri Slaby1328d732006-12-08 02:39:19 -0800786 unsigned int minordev, brdnr, portnr;
787 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788
789 minordev = tty->index;
790 brdnr = MINOR2BRD(minordev);
791 if (brdnr >= stli_nrbrds)
Alan Cox4ac43602006-06-28 04:26:52 -0700792 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 brdp = stli_brds[brdnr];
Alan Cox4ac43602006-06-28 04:26:52 -0700794 if (brdp == NULL)
795 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 if ((brdp->state & BST_STARTED) == 0)
Alan Cox4ac43602006-06-28 04:26:52 -0700797 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 portnr = MINOR2PORT(minordev);
Jiri Slaby1328d732006-12-08 02:39:19 -0800799 if (portnr > brdp->nrports)
Alan Cox4ac43602006-06-28 04:26:52 -0700800 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801
802 portp = brdp->ports[portnr];
Alan Cox4ac43602006-06-28 04:26:52 -0700803 if (portp == NULL)
804 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 if (portp->devnr < 1)
Alan Cox4ac43602006-06-28 04:26:52 -0700806 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807
808
809/*
810 * Check if this port is in the middle of closing. If so then wait
811 * until it is closed then return error status based on flag settings.
812 * The sleep here does not need interrupt protection since the wakeup
813 * for it is done with the same context.
814 */
815 if (portp->flags & ASYNC_CLOSING) {
816 interruptible_sleep_on(&portp->close_wait);
817 if (portp->flags & ASYNC_HUP_NOTIFY)
Alan Cox4ac43602006-06-28 04:26:52 -0700818 return -EAGAIN;
819 return -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 }
821
822/*
823 * On the first open of the device setup the port hardware, and
824 * initialize the per port data structure. Since initializing the port
825 * requires several commands to the board we will need to wait for any
826 * other open that is already initializing the port.
827 */
828 portp->tty = tty;
829 tty->driver_data = portp;
830 portp->refcount++;
831
832 wait_event_interruptible(portp->raw_wait,
833 !test_bit(ST_INITIALIZING, &portp->state));
834 if (signal_pending(current))
Alan Cox4ac43602006-06-28 04:26:52 -0700835 return -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836
837 if ((portp->flags & ASYNC_INITIALIZED) == 0) {
838 set_bit(ST_INITIALIZING, &portp->state);
839 if ((rc = stli_initopen(brdp, portp)) >= 0) {
840 portp->flags |= ASYNC_INITIALIZED;
841 clear_bit(TTY_IO_ERROR, &tty->flags);
842 }
843 clear_bit(ST_INITIALIZING, &portp->state);
844 wake_up_interruptible(&portp->raw_wait);
845 if (rc < 0)
Alan Cox4ac43602006-06-28 04:26:52 -0700846 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 }
848
849/*
850 * Check if this port is in the middle of closing. If so then wait
851 * until it is closed then return error status, based on flag settings.
852 * The sleep here does not need interrupt protection since the wakeup
853 * for it is done with the same context.
854 */
855 if (portp->flags & ASYNC_CLOSING) {
856 interruptible_sleep_on(&portp->close_wait);
857 if (portp->flags & ASYNC_HUP_NOTIFY)
Alan Cox4ac43602006-06-28 04:26:52 -0700858 return -EAGAIN;
859 return -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 }
861
862/*
863 * Based on type of open being done check if it can overlap with any
864 * previous opens still in effect. If we are a normal serial device
865 * then also we might have to wait for carrier.
866 */
867 if (!(filp->f_flags & O_NONBLOCK)) {
868 if ((rc = stli_waitcarrier(brdp, portp, filp)) != 0)
Alan Cox4ac43602006-06-28 04:26:52 -0700869 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 }
871 portp->flags |= ASYNC_NORMAL_ACTIVE;
Alan Cox4ac43602006-06-28 04:26:52 -0700872 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873}
874
875/*****************************************************************************/
876
877static void stli_close(struct tty_struct *tty, struct file *filp)
878{
Jiri Slaby1f8ec432006-12-08 02:39:18 -0800879 struct stlibrd *brdp;
880 struct stliport *portp;
Alan Cox4ac43602006-06-28 04:26:52 -0700881 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882
883 portp = tty->driver_data;
Alan Cox4ac43602006-06-28 04:26:52 -0700884 if (portp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 return;
886
Alan Cox4ac43602006-06-28 04:26:52 -0700887 spin_lock_irqsave(&stli_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888 if (tty_hung_up_p(filp)) {
Alan Cox4ac43602006-06-28 04:26:52 -0700889 spin_unlock_irqrestore(&stli_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890 return;
891 }
892 if ((tty->count == 1) && (portp->refcount != 1))
893 portp->refcount = 1;
894 if (portp->refcount-- > 1) {
Alan Cox4ac43602006-06-28 04:26:52 -0700895 spin_unlock_irqrestore(&stli_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 return;
897 }
898
899 portp->flags |= ASYNC_CLOSING;
900
901/*
902 * May want to wait for data to drain before closing. The BUSY flag
903 * keeps track of whether we are still transmitting or not. It is
904 * updated by messages from the slave - indicating when all chars
905 * really have drained.
906 */
907 if (tty == stli_txcooktty)
908 stli_flushchars(tty);
909 tty->closing = 1;
Alan Cox4ac43602006-06-28 04:26:52 -0700910 spin_unlock_irqrestore(&stli_lock, flags);
911
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 if (portp->closing_wait != ASYNC_CLOSING_WAIT_NONE)
913 tty_wait_until_sent(tty, portp->closing_wait);
914
915 portp->flags &= ~ASYNC_INITIALIZED;
916 brdp = stli_brds[portp->brdnr];
917 stli_rawclose(brdp, portp, 0, 0);
918 if (tty->termios->c_cflag & HUPCL) {
919 stli_mkasysigs(&portp->asig, 0, 0);
920 if (test_bit(ST_CMDING, &portp->state))
921 set_bit(ST_DOSIGS, &portp->state);
922 else
923 stli_sendcmd(brdp, portp, A_SETSIGNALS, &portp->asig,
924 sizeof(asysigs_t), 0);
925 }
926 clear_bit(ST_TXBUSY, &portp->state);
927 clear_bit(ST_RXSTOP, &portp->state);
928 set_bit(TTY_IO_ERROR, &tty->flags);
929 if (tty->ldisc.flush_buffer)
930 (tty->ldisc.flush_buffer)(tty);
931 set_bit(ST_DOFLUSHRX, &portp->state);
932 stli_flushbuffer(tty);
933
934 tty->closing = 0;
Alan Cox4ac43602006-06-28 04:26:52 -0700935 portp->tty = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936
937 if (portp->openwaitcnt) {
938 if (portp->close_delay)
939 msleep_interruptible(jiffies_to_msecs(portp->close_delay));
940 wake_up_interruptible(&portp->open_wait);
941 }
942
943 portp->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING);
944 wake_up_interruptible(&portp->close_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945}
946
947/*****************************************************************************/
948
949/*
950 * Carry out first open operations on a port. This involves a number of
951 * commands to be sent to the slave. We need to open the port, set the
952 * notification events, set the initial port settings, get and set the
953 * initial signal values. We sleep and wait in between each one. But
954 * this still all happens pretty quickly.
955 */
956
Jiri Slaby1f8ec432006-12-08 02:39:18 -0800957static int stli_initopen(struct stlibrd *brdp, struct stliport *portp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958{
Alan Cox4ac43602006-06-28 04:26:52 -0700959 struct tty_struct *tty;
960 asynotify_t nt;
961 asyport_t aport;
962 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963
964 if ((rc = stli_rawopen(brdp, portp, 0, 1)) < 0)
Alan Cox4ac43602006-06-28 04:26:52 -0700965 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966
967 memset(&nt, 0, sizeof(asynotify_t));
968 nt.data = (DT_TXLOW | DT_TXEMPTY | DT_RXBUSY | DT_RXBREAK);
969 nt.signal = SG_DCD;
970 if ((rc = stli_cmdwait(brdp, portp, A_SETNOTIFY, &nt,
971 sizeof(asynotify_t), 0)) < 0)
Alan Cox4ac43602006-06-28 04:26:52 -0700972 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973
974 tty = portp->tty;
Alan Cox4ac43602006-06-28 04:26:52 -0700975 if (tty == NULL)
976 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977 stli_mkasyport(portp, &aport, tty->termios);
978 if ((rc = stli_cmdwait(brdp, portp, A_SETPORT, &aport,
979 sizeof(asyport_t), 0)) < 0)
Alan Cox4ac43602006-06-28 04:26:52 -0700980 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981
982 set_bit(ST_GETSIGS, &portp->state);
983 if ((rc = stli_cmdwait(brdp, portp, A_GETSIGNALS, &portp->asig,
984 sizeof(asysigs_t), 1)) < 0)
Alan Cox4ac43602006-06-28 04:26:52 -0700985 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986 if (test_and_clear_bit(ST_GETSIGS, &portp->state))
987 portp->sigs = stli_mktiocm(portp->asig.sigvalue);
988 stli_mkasysigs(&portp->asig, 1, 1);
989 if ((rc = stli_cmdwait(brdp, portp, A_SETSIGNALS, &portp->asig,
990 sizeof(asysigs_t), 0)) < 0)
Alan Cox4ac43602006-06-28 04:26:52 -0700991 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992
Alan Cox4ac43602006-06-28 04:26:52 -0700993 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994}
995
996/*****************************************************************************/
997
998/*
999 * Send an open message to the slave. This will sleep waiting for the
1000 * acknowledgement, so must have user context. We need to co-ordinate
1001 * with close events here, since we don't want open and close events
1002 * to overlap.
1003 */
1004
Jiri Slaby1f8ec432006-12-08 02:39:18 -08001005static int stli_rawopen(struct stlibrd *brdp, struct stliport *portp, unsigned long arg, int wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006{
Alan Cox4ac43602006-06-28 04:26:52 -07001007 cdkhdr_t __iomem *hdrp;
1008 cdkctrl_t __iomem *cp;
1009 unsigned char __iomem *bits;
1010 unsigned long flags;
1011 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012
1013/*
1014 * Send a message to the slave to open this port.
1015 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016
1017/*
1018 * Slave is already closing this port. This can happen if a hangup
1019 * occurs on this port. So we must wait until it is complete. The
1020 * order of opens and closes may not be preserved across shared
1021 * memory, so we must wait until it is complete.
1022 */
1023 wait_event_interruptible(portp->raw_wait,
1024 !test_bit(ST_CLOSING, &portp->state));
1025 if (signal_pending(current)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026 return -ERESTARTSYS;
1027 }
1028
1029/*
1030 * Everything is ready now, so write the open message into shared
1031 * memory. Once the message is in set the service bits to say that
1032 * this port wants service.
1033 */
Alan Cox4ac43602006-06-28 04:26:52 -07001034 spin_lock_irqsave(&brd_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035 EBRDENABLE(brdp);
Alan Cox4ac43602006-06-28 04:26:52 -07001036 cp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->ctrl;
1037 writel(arg, &cp->openarg);
1038 writeb(1, &cp->open);
1039 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
1040 bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset +
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041 portp->portidx;
Alan Cox4ac43602006-06-28 04:26:52 -07001042 writeb(readb(bits) | portp->portbit, bits);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043 EBRDDISABLE(brdp);
1044
1045 if (wait == 0) {
Alan Cox4ac43602006-06-28 04:26:52 -07001046 spin_unlock_irqrestore(&brd_lock, flags);
1047 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048 }
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 set_bit(ST_OPENING, &portp->state);
Alan Cox4ac43602006-06-28 04:26:52 -07001056 spin_unlock_irqrestore(&brd_lock, flags);
1057
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058 wait_event_interruptible(portp->raw_wait,
1059 !test_bit(ST_OPENING, &portp->state));
1060 if (signal_pending(current))
1061 rc = -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062
1063 if ((rc == 0) && (portp->rc != 0))
1064 rc = -EIO;
Alan Cox4ac43602006-06-28 04:26:52 -07001065 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066}
1067
1068/*****************************************************************************/
1069
1070/*
1071 * Send a close message to the slave. Normally this will sleep waiting
1072 * for the acknowledgement, but if wait parameter is 0 it will not. If
1073 * wait is true then must have user context (to sleep).
1074 */
1075
Jiri Slaby1f8ec432006-12-08 02:39:18 -08001076static int stli_rawclose(struct stlibrd *brdp, struct stliport *portp, unsigned long arg, int wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077{
Alan Cox4ac43602006-06-28 04:26:52 -07001078 cdkhdr_t __iomem *hdrp;
1079 cdkctrl_t __iomem *cp;
1080 unsigned char __iomem *bits;
1081 unsigned long flags;
1082 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083
1084/*
1085 * Slave is already closing this port. This can happen if a hangup
1086 * occurs on this port.
1087 */
1088 if (wait) {
1089 wait_event_interruptible(portp->raw_wait,
1090 !test_bit(ST_CLOSING, &portp->state));
1091 if (signal_pending(current)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092 return -ERESTARTSYS;
1093 }
1094 }
1095
1096/*
1097 * Write the close command into shared memory.
1098 */
Alan Cox4ac43602006-06-28 04:26:52 -07001099 spin_lock_irqsave(&brd_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100 EBRDENABLE(brdp);
Alan Cox4ac43602006-06-28 04:26:52 -07001101 cp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->ctrl;
1102 writel(arg, &cp->closearg);
1103 writeb(1, &cp->close);
1104 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
1105 bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset +
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106 portp->portidx;
Alan Cox4ac43602006-06-28 04:26:52 -07001107 writeb(readb(bits) |portp->portbit, bits);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108 EBRDDISABLE(brdp);
1109
1110 set_bit(ST_CLOSING, &portp->state);
Alan Cox4ac43602006-06-28 04:26:52 -07001111 spin_unlock_irqrestore(&brd_lock, flags);
1112
1113 if (wait == 0)
1114 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115
1116/*
1117 * Slave is in action, so now we must wait for the open acknowledgment
1118 * to come back.
1119 */
1120 rc = 0;
1121 wait_event_interruptible(portp->raw_wait,
1122 !test_bit(ST_CLOSING, &portp->state));
1123 if (signal_pending(current))
1124 rc = -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125
1126 if ((rc == 0) && (portp->rc != 0))
1127 rc = -EIO;
Alan Cox4ac43602006-06-28 04:26:52 -07001128 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129}
1130
1131/*****************************************************************************/
1132
1133/*
1134 * Send a command to the slave and wait for the response. This must
1135 * have user context (it sleeps). This routine is generic in that it
1136 * can send any type of command. Its purpose is to wait for that command
1137 * to complete (as opposed to initiating the command then returning).
1138 */
1139
Jiri Slaby1f8ec432006-12-08 02:39:18 -08001140static int stli_cmdwait(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142 wait_event_interruptible(portp->raw_wait,
1143 !test_bit(ST_CMDING, &portp->state));
Alan Cox4ac43602006-06-28 04:26:52 -07001144 if (signal_pending(current))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145 return -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146
1147 stli_sendcmd(brdp, portp, cmd, arg, size, copyback);
1148
1149 wait_event_interruptible(portp->raw_wait,
1150 !test_bit(ST_CMDING, &portp->state));
Alan Cox4ac43602006-06-28 04:26:52 -07001151 if (signal_pending(current))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152 return -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153
1154 if (portp->rc != 0)
Alan Cox4ac43602006-06-28 04:26:52 -07001155 return -EIO;
1156 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157}
1158
1159/*****************************************************************************/
1160
1161/*
1162 * Send the termios settings for this port to the slave. This sleeps
1163 * waiting for the command to complete - so must have user context.
1164 */
1165
Jiri Slaby1f8ec432006-12-08 02:39:18 -08001166static int stli_setport(struct stliport *portp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167{
Jiri Slaby1f8ec432006-12-08 02:39:18 -08001168 struct stlibrd *brdp;
Alan Cox4ac43602006-06-28 04:26:52 -07001169 asyport_t aport;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170
Alan Cox4ac43602006-06-28 04:26:52 -07001171 if (portp == NULL)
1172 return -ENODEV;
1173 if (portp->tty == NULL)
1174 return -ENODEV;
Jiri Slaby1328d732006-12-08 02:39:19 -08001175 if (portp->brdnr >= stli_nrbrds)
Alan Cox4ac43602006-06-28 04:26:52 -07001176 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 brdp = stli_brds[portp->brdnr];
Alan Cox4ac43602006-06-28 04:26:52 -07001178 if (brdp == NULL)
1179 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180
1181 stli_mkasyport(portp, &aport, portp->tty->termios);
1182 return(stli_cmdwait(brdp, portp, A_SETPORT, &aport, sizeof(asyport_t), 0));
1183}
1184
1185/*****************************************************************************/
1186
1187/*
1188 * Possibly need to wait for carrier (DCD signal) to come high. Say
1189 * maybe because if we are clocal then we don't need to wait...
1190 */
1191
Jiri Slaby1f8ec432006-12-08 02:39:18 -08001192static int stli_waitcarrier(struct stlibrd *brdp, struct stliport *portp, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193{
Alan Cox4ac43602006-06-28 04:26:52 -07001194 unsigned long flags;
1195 int rc, doclocal;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196
1197 rc = 0;
1198 doclocal = 0;
1199
1200 if (portp->tty->termios->c_cflag & CLOCAL)
1201 doclocal++;
1202
Alan Cox4ac43602006-06-28 04:26:52 -07001203 spin_lock_irqsave(&stli_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204 portp->openwaitcnt++;
1205 if (! tty_hung_up_p(filp))
1206 portp->refcount--;
Alan Cox4ac43602006-06-28 04:26:52 -07001207 spin_unlock_irqrestore(&stli_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208
1209 for (;;) {
1210 stli_mkasysigs(&portp->asig, 1, 1);
1211 if ((rc = stli_cmdwait(brdp, portp, A_SETSIGNALS,
1212 &portp->asig, sizeof(asysigs_t), 0)) < 0)
1213 break;
1214 if (tty_hung_up_p(filp) ||
1215 ((portp->flags & ASYNC_INITIALIZED) == 0)) {
1216 if (portp->flags & ASYNC_HUP_NOTIFY)
1217 rc = -EBUSY;
1218 else
1219 rc = -ERESTARTSYS;
1220 break;
1221 }
1222 if (((portp->flags & ASYNC_CLOSING) == 0) &&
1223 (doclocal || (portp->sigs & TIOCM_CD))) {
1224 break;
1225 }
1226 if (signal_pending(current)) {
1227 rc = -ERESTARTSYS;
1228 break;
1229 }
1230 interruptible_sleep_on(&portp->open_wait);
1231 }
1232
Alan Cox4ac43602006-06-28 04:26:52 -07001233 spin_lock_irqsave(&stli_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234 if (! tty_hung_up_p(filp))
1235 portp->refcount++;
1236 portp->openwaitcnt--;
Alan Cox4ac43602006-06-28 04:26:52 -07001237 spin_unlock_irqrestore(&stli_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238
Alan Cox4ac43602006-06-28 04:26:52 -07001239 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240}
1241
1242/*****************************************************************************/
1243
1244/*
1245 * Write routine. Take the data and put it in the shared memory ring
1246 * queue. If port is not already sending chars then need to mark the
1247 * service bits for this port.
1248 */
1249
1250static int stli_write(struct tty_struct *tty, const unsigned char *buf, int count)
1251{
Alan Cox4ac43602006-06-28 04:26:52 -07001252 cdkasy_t __iomem *ap;
1253 cdkhdr_t __iomem *hdrp;
1254 unsigned char __iomem *bits;
1255 unsigned char __iomem *shbuf;
1256 unsigned char *chbuf;
Jiri Slaby1f8ec432006-12-08 02:39:18 -08001257 struct stliport *portp;
1258 struct stlibrd *brdp;
Alan Cox4ac43602006-06-28 04:26:52 -07001259 unsigned int len, stlen, head, tail, size;
1260 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262 if (tty == stli_txcooktty)
1263 stli_flushchars(tty);
1264 portp = tty->driver_data;
Alan Cox4ac43602006-06-28 04:26:52 -07001265 if (portp == NULL)
1266 return 0;
Jiri Slaby1328d732006-12-08 02:39:19 -08001267 if (portp->brdnr >= stli_nrbrds)
Alan Cox4ac43602006-06-28 04:26:52 -07001268 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269 brdp = stli_brds[portp->brdnr];
Alan Cox4ac43602006-06-28 04:26:52 -07001270 if (brdp == NULL)
1271 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272 chbuf = (unsigned char *) buf;
1273
1274/*
1275 * All data is now local, shove as much as possible into shared memory.
1276 */
Alan Cox4ac43602006-06-28 04:26:52 -07001277 spin_lock_irqsave(&brd_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278 EBRDENABLE(brdp);
Alan Cox4ac43602006-06-28 04:26:52 -07001279 ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
1280 head = (unsigned int) readw(&ap->txq.head);
1281 tail = (unsigned int) readw(&ap->txq.tail);
1282 if (tail != ((unsigned int) readw(&ap->txq.tail)))
1283 tail = (unsigned int) readw(&ap->txq.tail);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 size = portp->txsize;
1285 if (head >= tail) {
1286 len = size - (head - tail) - 1;
1287 stlen = size - head;
1288 } else {
1289 len = tail - head - 1;
1290 stlen = len;
1291 }
1292
Jiri Slabya3f8d9d2006-12-08 02:39:18 -08001293 len = min(len, (unsigned int)count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294 count = 0;
Alan Cox4ac43602006-06-28 04:26:52 -07001295 shbuf = (char __iomem *) EBRDGETMEMPTR(brdp, portp->txoffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296
1297 while (len > 0) {
Jiri Slabya3f8d9d2006-12-08 02:39:18 -08001298 stlen = min(len, stlen);
Alan Cox4ac43602006-06-28 04:26:52 -07001299 memcpy_toio(shbuf + head, chbuf, stlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300 chbuf += stlen;
1301 len -= stlen;
1302 count += stlen;
1303 head += stlen;
1304 if (head >= size) {
1305 head = 0;
1306 stlen = tail;
1307 }
1308 }
1309
Alan Cox4ac43602006-06-28 04:26:52 -07001310 ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
1311 writew(head, &ap->txq.head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 if (test_bit(ST_TXBUSY, &portp->state)) {
Alan Cox4ac43602006-06-28 04:26:52 -07001313 if (readl(&ap->changed.data) & DT_TXEMPTY)
1314 writel(readl(&ap->changed.data) & ~DT_TXEMPTY, &ap->changed.data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315 }
Alan Cox4ac43602006-06-28 04:26:52 -07001316 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
1317 bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset +
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318 portp->portidx;
Alan Cox4ac43602006-06-28 04:26:52 -07001319 writeb(readb(bits) | portp->portbit, bits);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320 set_bit(ST_TXBUSY, &portp->state);
1321 EBRDDISABLE(brdp);
Alan Cox4ac43602006-06-28 04:26:52 -07001322 spin_unlock_irqrestore(&brd_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323
1324 return(count);
1325}
1326
1327/*****************************************************************************/
1328
1329/*
1330 * Output a single character. We put it into a temporary local buffer
1331 * (for speed) then write out that buffer when the flushchars routine
1332 * is called. There is a safety catch here so that if some other port
1333 * writes chars before the current buffer has been, then we write them
1334 * first them do the new ports.
1335 */
1336
1337static void stli_putchar(struct tty_struct *tty, unsigned char ch)
1338{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339 if (tty != stli_txcooktty) {
Alan Cox4ac43602006-06-28 04:26:52 -07001340 if (stli_txcooktty != NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 stli_flushchars(stli_txcooktty);
1342 stli_txcooktty = tty;
1343 }
1344
1345 stli_txcookbuf[stli_txcooksize++] = ch;
1346}
1347
1348/*****************************************************************************/
1349
1350/*
1351 * Transfer characters from the local TX cooking buffer to the board.
1352 * We sort of ignore the tty that gets passed in here. We rely on the
1353 * info stored with the TX cook buffer to tell us which port to flush
1354 * the data on. In any case we clean out the TX cook buffer, for re-use
1355 * by someone else.
1356 */
1357
1358static void stli_flushchars(struct tty_struct *tty)
1359{
Alan Cox4ac43602006-06-28 04:26:52 -07001360 cdkhdr_t __iomem *hdrp;
1361 unsigned char __iomem *bits;
1362 cdkasy_t __iomem *ap;
1363 struct tty_struct *cooktty;
Jiri Slaby1f8ec432006-12-08 02:39:18 -08001364 struct stliport *portp;
1365 struct stlibrd *brdp;
Alan Cox4ac43602006-06-28 04:26:52 -07001366 unsigned int len, stlen, head, tail, size, count, cooksize;
1367 unsigned char *buf;
1368 unsigned char __iomem *shbuf;
1369 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370
1371 cooksize = stli_txcooksize;
1372 cooktty = stli_txcooktty;
1373 stli_txcooksize = 0;
1374 stli_txcookrealsize = 0;
Alan Cox4ac43602006-06-28 04:26:52 -07001375 stli_txcooktty = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376
Alan Cox4ac43602006-06-28 04:26:52 -07001377 if (tty == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378 return;
Alan Cox4ac43602006-06-28 04:26:52 -07001379 if (cooktty == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380 return;
1381 if (tty != cooktty)
1382 tty = cooktty;
1383 if (cooksize == 0)
1384 return;
1385
1386 portp = tty->driver_data;
Alan Cox4ac43602006-06-28 04:26:52 -07001387 if (portp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388 return;
Jiri Slaby1328d732006-12-08 02:39:19 -08001389 if (portp->brdnr >= stli_nrbrds)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390 return;
1391 brdp = stli_brds[portp->brdnr];
Alan Cox4ac43602006-06-28 04:26:52 -07001392 if (brdp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393 return;
1394
Alan Cox4ac43602006-06-28 04:26:52 -07001395 spin_lock_irqsave(&brd_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396 EBRDENABLE(brdp);
1397
Alan Cox4ac43602006-06-28 04:26:52 -07001398 ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
1399 head = (unsigned int) readw(&ap->txq.head);
1400 tail = (unsigned int) readw(&ap->txq.tail);
1401 if (tail != ((unsigned int) readw(&ap->txq.tail)))
1402 tail = (unsigned int) readw(&ap->txq.tail);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403 size = portp->txsize;
1404 if (head >= tail) {
1405 len = size - (head - tail) - 1;
1406 stlen = size - head;
1407 } else {
1408 len = tail - head - 1;
1409 stlen = len;
1410 }
1411
Jiri Slabya3f8d9d2006-12-08 02:39:18 -08001412 len = min(len, cooksize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 count = 0;
Al Viro29756fa2006-10-10 22:47:27 +01001414 shbuf = EBRDGETMEMPTR(brdp, portp->txoffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415 buf = stli_txcookbuf;
1416
1417 while (len > 0) {
Jiri Slabya3f8d9d2006-12-08 02:39:18 -08001418 stlen = min(len, stlen);
Alan Cox4ac43602006-06-28 04:26:52 -07001419 memcpy_toio(shbuf + head, buf, stlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420 buf += stlen;
1421 len -= stlen;
1422 count += stlen;
1423 head += stlen;
1424 if (head >= size) {
1425 head = 0;
1426 stlen = tail;
1427 }
1428 }
1429
Alan Cox4ac43602006-06-28 04:26:52 -07001430 ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
1431 writew(head, &ap->txq.head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432
1433 if (test_bit(ST_TXBUSY, &portp->state)) {
Alan Cox4ac43602006-06-28 04:26:52 -07001434 if (readl(&ap->changed.data) & DT_TXEMPTY)
1435 writel(readl(&ap->changed.data) & ~DT_TXEMPTY, &ap->changed.data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436 }
Alan Cox4ac43602006-06-28 04:26:52 -07001437 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
1438 bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset +
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439 portp->portidx;
Alan Cox4ac43602006-06-28 04:26:52 -07001440 writeb(readb(bits) | portp->portbit, bits);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441 set_bit(ST_TXBUSY, &portp->state);
1442
1443 EBRDDISABLE(brdp);
Alan Cox4ac43602006-06-28 04:26:52 -07001444 spin_unlock_irqrestore(&brd_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445}
1446
1447/*****************************************************************************/
1448
1449static int stli_writeroom(struct tty_struct *tty)
1450{
Alan Cox4ac43602006-06-28 04:26:52 -07001451 cdkasyrq_t __iomem *rp;
Jiri Slaby1f8ec432006-12-08 02:39:18 -08001452 struct stliport *portp;
1453 struct stlibrd *brdp;
Alan Cox4ac43602006-06-28 04:26:52 -07001454 unsigned int head, tail, len;
1455 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457 if (tty == stli_txcooktty) {
1458 if (stli_txcookrealsize != 0) {
1459 len = stli_txcookrealsize - stli_txcooksize;
Alan Cox4ac43602006-06-28 04:26:52 -07001460 return len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461 }
1462 }
1463
1464 portp = tty->driver_data;
Alan Cox4ac43602006-06-28 04:26:52 -07001465 if (portp == NULL)
1466 return 0;
Jiri Slaby1328d732006-12-08 02:39:19 -08001467 if (portp->brdnr >= stli_nrbrds)
Alan Cox4ac43602006-06-28 04:26:52 -07001468 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469 brdp = stli_brds[portp->brdnr];
Alan Cox4ac43602006-06-28 04:26:52 -07001470 if (brdp == NULL)
1471 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472
Alan Cox4ac43602006-06-28 04:26:52 -07001473 spin_lock_irqsave(&brd_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474 EBRDENABLE(brdp);
Alan Cox4ac43602006-06-28 04:26:52 -07001475 rp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->txq;
1476 head = (unsigned int) readw(&rp->head);
1477 tail = (unsigned int) readw(&rp->tail);
1478 if (tail != ((unsigned int) readw(&rp->tail)))
1479 tail = (unsigned int) readw(&rp->tail);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480 len = (head >= tail) ? (portp->txsize - (head - tail)) : (tail - head);
1481 len--;
1482 EBRDDISABLE(brdp);
Alan Cox4ac43602006-06-28 04:26:52 -07001483 spin_unlock_irqrestore(&brd_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484
1485 if (tty == stli_txcooktty) {
1486 stli_txcookrealsize = len;
1487 len -= stli_txcooksize;
1488 }
Alan Cox4ac43602006-06-28 04:26:52 -07001489 return len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490}
1491
1492/*****************************************************************************/
1493
1494/*
1495 * Return the number of characters in the transmit buffer. Normally we
1496 * will return the number of chars in the shared memory ring queue.
1497 * We need to kludge around the case where the shared memory buffer is
1498 * empty but not all characters have drained yet, for this case just
1499 * return that there is 1 character in the buffer!
1500 */
1501
1502static int stli_charsinbuffer(struct tty_struct *tty)
1503{
Alan Cox4ac43602006-06-28 04:26:52 -07001504 cdkasyrq_t __iomem *rp;
Jiri Slaby1f8ec432006-12-08 02:39:18 -08001505 struct stliport *portp;
1506 struct stlibrd *brdp;
Alan Cox4ac43602006-06-28 04:26:52 -07001507 unsigned int head, tail, len;
1508 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510 if (tty == stli_txcooktty)
1511 stli_flushchars(tty);
1512 portp = tty->driver_data;
Alan Cox4ac43602006-06-28 04:26:52 -07001513 if (portp == NULL)
1514 return 0;
Jiri Slaby1328d732006-12-08 02:39:19 -08001515 if (portp->brdnr >= stli_nrbrds)
Alan Cox4ac43602006-06-28 04:26:52 -07001516 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517 brdp = stli_brds[portp->brdnr];
Alan Cox4ac43602006-06-28 04:26:52 -07001518 if (brdp == NULL)
1519 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520
Alan Cox4ac43602006-06-28 04:26:52 -07001521 spin_lock_irqsave(&brd_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522 EBRDENABLE(brdp);
Alan Cox4ac43602006-06-28 04:26:52 -07001523 rp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->txq;
1524 head = (unsigned int) readw(&rp->head);
1525 tail = (unsigned int) readw(&rp->tail);
1526 if (tail != ((unsigned int) readw(&rp->tail)))
1527 tail = (unsigned int) readw(&rp->tail);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528 len = (head >= tail) ? (head - tail) : (portp->txsize - (tail - head));
1529 if ((len == 0) && test_bit(ST_TXBUSY, &portp->state))
1530 len = 1;
1531 EBRDDISABLE(brdp);
Alan Cox4ac43602006-06-28 04:26:52 -07001532 spin_unlock_irqrestore(&brd_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533
Alan Cox4ac43602006-06-28 04:26:52 -07001534 return len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535}
1536
1537/*****************************************************************************/
1538
1539/*
1540 * Generate the serial struct info.
1541 */
1542
Jiri Slaby1f8ec432006-12-08 02:39:18 -08001543static int stli_getserial(struct stliport *portp, struct serial_struct __user *sp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544{
Alan Cox4ac43602006-06-28 04:26:52 -07001545 struct serial_struct sio;
Jiri Slaby1f8ec432006-12-08 02:39:18 -08001546 struct stlibrd *brdp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547
1548 memset(&sio, 0, sizeof(struct serial_struct));
1549 sio.type = PORT_UNKNOWN;
1550 sio.line = portp->portnr;
1551 sio.irq = 0;
1552 sio.flags = portp->flags;
1553 sio.baud_base = portp->baud_base;
1554 sio.close_delay = portp->close_delay;
1555 sio.closing_wait = portp->closing_wait;
1556 sio.custom_divisor = portp->custom_divisor;
1557 sio.xmit_fifo_size = 0;
1558 sio.hub6 = 0;
1559
1560 brdp = stli_brds[portp->brdnr];
Alan Cox4ac43602006-06-28 04:26:52 -07001561 if (brdp != NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562 sio.port = brdp->iobase;
1563
1564 return copy_to_user(sp, &sio, sizeof(struct serial_struct)) ?
1565 -EFAULT : 0;
1566}
1567
1568/*****************************************************************************/
1569
1570/*
1571 * Set port according to the serial struct info.
1572 * At this point we do not do any auto-configure stuff, so we will
1573 * just quietly ignore any requests to change irq, etc.
1574 */
1575
Jiri Slaby1f8ec432006-12-08 02:39:18 -08001576static int stli_setserial(struct stliport *portp, struct serial_struct __user *sp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577{
Alan Cox4ac43602006-06-28 04:26:52 -07001578 struct serial_struct sio;
1579 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580
1581 if (copy_from_user(&sio, sp, sizeof(struct serial_struct)))
1582 return -EFAULT;
1583 if (!capable(CAP_SYS_ADMIN)) {
1584 if ((sio.baud_base != portp->baud_base) ||
1585 (sio.close_delay != portp->close_delay) ||
1586 ((sio.flags & ~ASYNC_USR_MASK) !=
1587 (portp->flags & ~ASYNC_USR_MASK)))
Alan Cox4ac43602006-06-28 04:26:52 -07001588 return -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589 }
1590
1591 portp->flags = (portp->flags & ~ASYNC_USR_MASK) |
1592 (sio.flags & ASYNC_USR_MASK);
1593 portp->baud_base = sio.baud_base;
1594 portp->close_delay = sio.close_delay;
1595 portp->closing_wait = sio.closing_wait;
1596 portp->custom_divisor = sio.custom_divisor;
1597
1598 if ((rc = stli_setport(portp)) < 0)
Alan Cox4ac43602006-06-28 04:26:52 -07001599 return rc;
1600 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601}
1602
1603/*****************************************************************************/
1604
1605static int stli_tiocmget(struct tty_struct *tty, struct file *file)
1606{
Jiri Slaby1f8ec432006-12-08 02:39:18 -08001607 struct stliport *portp = tty->driver_data;
1608 struct stlibrd *brdp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609 int rc;
1610
Alan Cox4ac43602006-06-28 04:26:52 -07001611 if (portp == NULL)
1612 return -ENODEV;
Jiri Slaby1328d732006-12-08 02:39:19 -08001613 if (portp->brdnr >= stli_nrbrds)
Alan Cox4ac43602006-06-28 04:26:52 -07001614 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615 brdp = stli_brds[portp->brdnr];
Alan Cox4ac43602006-06-28 04:26:52 -07001616 if (brdp == NULL)
1617 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001618 if (tty->flags & (1 << TTY_IO_ERROR))
Alan Cox4ac43602006-06-28 04:26:52 -07001619 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620
1621 if ((rc = stli_cmdwait(brdp, portp, A_GETSIGNALS,
1622 &portp->asig, sizeof(asysigs_t), 1)) < 0)
Alan Cox4ac43602006-06-28 04:26:52 -07001623 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001624
1625 return stli_mktiocm(portp->asig.sigvalue);
1626}
1627
1628static int stli_tiocmset(struct tty_struct *tty, struct file *file,
1629 unsigned int set, unsigned int clear)
1630{
Jiri Slaby1f8ec432006-12-08 02:39:18 -08001631 struct stliport *portp = tty->driver_data;
1632 struct stlibrd *brdp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633 int rts = -1, dtr = -1;
1634
Alan Cox4ac43602006-06-28 04:26:52 -07001635 if (portp == NULL)
1636 return -ENODEV;
Jiri Slaby1328d732006-12-08 02:39:19 -08001637 if (portp->brdnr >= stli_nrbrds)
Alan Cox4ac43602006-06-28 04:26:52 -07001638 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001639 brdp = stli_brds[portp->brdnr];
Alan Cox4ac43602006-06-28 04:26:52 -07001640 if (brdp == NULL)
1641 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642 if (tty->flags & (1 << TTY_IO_ERROR))
Alan Cox4ac43602006-06-28 04:26:52 -07001643 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644
1645 if (set & TIOCM_RTS)
1646 rts = 1;
1647 if (set & TIOCM_DTR)
1648 dtr = 1;
1649 if (clear & TIOCM_RTS)
1650 rts = 0;
1651 if (clear & TIOCM_DTR)
1652 dtr = 0;
1653
1654 stli_mkasysigs(&portp->asig, dtr, rts);
1655
1656 return stli_cmdwait(brdp, portp, A_SETSIGNALS, &portp->asig,
1657 sizeof(asysigs_t), 0);
1658}
1659
1660static int stli_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
1661{
Jiri Slaby1f8ec432006-12-08 02:39:18 -08001662 struct stliport *portp;
1663 struct stlibrd *brdp;
Alan Cox4ac43602006-06-28 04:26:52 -07001664 unsigned int ival;
1665 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666 void __user *argp = (void __user *)arg;
1667
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 portp = tty->driver_data;
Alan Cox4ac43602006-06-28 04:26:52 -07001669 if (portp == NULL)
1670 return -ENODEV;
Jiri Slaby1328d732006-12-08 02:39:19 -08001671 if (portp->brdnr >= stli_nrbrds)
Alan Cox4ac43602006-06-28 04:26:52 -07001672 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673 brdp = stli_brds[portp->brdnr];
Alan Cox4ac43602006-06-28 04:26:52 -07001674 if (brdp == NULL)
1675 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676
1677 if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
1678 (cmd != COM_GETPORTSTATS) && (cmd != COM_CLRPORTSTATS)) {
1679 if (tty->flags & (1 << TTY_IO_ERROR))
Alan Cox4ac43602006-06-28 04:26:52 -07001680 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681 }
1682
1683 rc = 0;
1684
1685 switch (cmd) {
1686 case TIOCGSOFTCAR:
1687 rc = put_user(((tty->termios->c_cflag & CLOCAL) ? 1 : 0),
1688 (unsigned __user *) arg);
1689 break;
1690 case TIOCSSOFTCAR:
1691 if ((rc = get_user(ival, (unsigned __user *) arg)) == 0)
1692 tty->termios->c_cflag =
1693 (tty->termios->c_cflag & ~CLOCAL) |
1694 (ival ? CLOCAL : 0);
1695 break;
1696 case TIOCGSERIAL:
1697 rc = stli_getserial(portp, argp);
1698 break;
1699 case TIOCSSERIAL:
1700 rc = stli_setserial(portp, argp);
1701 break;
1702 case STL_GETPFLAG:
1703 rc = put_user(portp->pflag, (unsigned __user *)argp);
1704 break;
1705 case STL_SETPFLAG:
1706 if ((rc = get_user(portp->pflag, (unsigned __user *)argp)) == 0)
1707 stli_setport(portp);
1708 break;
1709 case COM_GETPORTSTATS:
1710 rc = stli_getportstats(portp, argp);
1711 break;
1712 case COM_CLRPORTSTATS:
1713 rc = stli_clrportstats(portp, argp);
1714 break;
1715 case TIOCSERCONFIG:
1716 case TIOCSERGWILD:
1717 case TIOCSERSWILD:
1718 case TIOCSERGETLSR:
1719 case TIOCSERGSTRUCT:
1720 case TIOCSERGETMULTI:
1721 case TIOCSERSETMULTI:
1722 default:
1723 rc = -ENOIOCTLCMD;
1724 break;
1725 }
1726
Alan Cox4ac43602006-06-28 04:26:52 -07001727 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728}
1729
1730/*****************************************************************************/
1731
1732/*
1733 * This routine assumes that we have user context and can sleep.
1734 * Looks like it is true for the current ttys implementation..!!
1735 */
1736
Alan Cox606d0992006-12-08 02:38:45 -08001737static void stli_settermios(struct tty_struct *tty, struct ktermios *old)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738{
Jiri Slaby1f8ec432006-12-08 02:39:18 -08001739 struct stliport *portp;
1740 struct stlibrd *brdp;
Alan Cox606d0992006-12-08 02:38:45 -08001741 struct ktermios *tiosp;
Alan Cox4ac43602006-06-28 04:26:52 -07001742 asyport_t aport;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743
Alan Cox4ac43602006-06-28 04:26:52 -07001744 if (tty == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745 return;
1746 portp = tty->driver_data;
Alan Cox4ac43602006-06-28 04:26:52 -07001747 if (portp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001748 return;
Jiri Slaby1328d732006-12-08 02:39:19 -08001749 if (portp->brdnr >= stli_nrbrds)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750 return;
1751 brdp = stli_brds[portp->brdnr];
Alan Cox4ac43602006-06-28 04:26:52 -07001752 if (brdp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001753 return;
1754
1755 tiosp = tty->termios;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001756
1757 stli_mkasyport(portp, &aport, tiosp);
1758 stli_cmdwait(brdp, portp, A_SETPORT, &aport, sizeof(asyport_t), 0);
1759 stli_mkasysigs(&portp->asig, ((tiosp->c_cflag & CBAUD) ? 1 : 0), -1);
1760 stli_cmdwait(brdp, portp, A_SETSIGNALS, &portp->asig,
1761 sizeof(asysigs_t), 0);
1762 if ((old->c_cflag & CRTSCTS) && ((tiosp->c_cflag & CRTSCTS) == 0))
1763 tty->hw_stopped = 0;
1764 if (((old->c_cflag & CLOCAL) == 0) && (tiosp->c_cflag & CLOCAL))
1765 wake_up_interruptible(&portp->open_wait);
1766}
1767
1768/*****************************************************************************/
1769
1770/*
1771 * Attempt to flow control who ever is sending us data. We won't really
1772 * do any flow control action here. We can't directly, and even if we
1773 * wanted to we would have to send a command to the slave. The slave
1774 * knows how to flow control, and will do so when its buffers reach its
1775 * internal high water marks. So what we will do is set a local state
1776 * bit that will stop us sending any RX data up from the poll routine
1777 * (which is the place where RX data from the slave is handled).
1778 */
1779
1780static void stli_throttle(struct tty_struct *tty)
1781{
Jiri Slaby1f8ec432006-12-08 02:39:18 -08001782 struct stliport *portp = tty->driver_data;
Alan Cox4ac43602006-06-28 04:26:52 -07001783 if (portp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785 set_bit(ST_RXSTOP, &portp->state);
1786}
1787
1788/*****************************************************************************/
1789
1790/*
1791 * Unflow control the device sending us data... That means that all
1792 * we have to do is clear the RXSTOP state bit. The next poll call
1793 * will then be able to pass the RX data back up.
1794 */
1795
1796static void stli_unthrottle(struct tty_struct *tty)
1797{
Jiri Slaby1f8ec432006-12-08 02:39:18 -08001798 struct stliport *portp = tty->driver_data;
Alan Cox4ac43602006-06-28 04:26:52 -07001799 if (portp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001800 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801 clear_bit(ST_RXSTOP, &portp->state);
1802}
1803
1804/*****************************************************************************/
1805
1806/*
Alan Cox4ac43602006-06-28 04:26:52 -07001807 * Stop the transmitter.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808 */
1809
1810static void stli_stop(struct tty_struct *tty)
1811{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001812}
1813
1814/*****************************************************************************/
1815
1816/*
Alan Cox4ac43602006-06-28 04:26:52 -07001817 * Start the transmitter again.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001818 */
1819
1820static void stli_start(struct tty_struct *tty)
1821{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001822}
1823
1824/*****************************************************************************/
1825
1826/*
1827 * Scheduler called hang up routine. This is called from the scheduler,
1828 * not direct from the driver "poll" routine. We can't call it there
1829 * since the real local hangup code will enable/disable the board and
1830 * other things that we can't do while handling the poll. Much easier
1831 * to deal with it some time later (don't really care when, hangups
1832 * aren't that time critical).
1833 */
1834
Al Viro3e577a82006-12-06 18:41:45 +00001835static void stli_dohangup(struct work_struct *ugly_api)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001836{
Jiri Slaby1f8ec432006-12-08 02:39:18 -08001837 struct stliport *portp = container_of(ugly_api, struct stliport, tqhangup);
Alan Cox4ac43602006-06-28 04:26:52 -07001838 if (portp->tty != NULL) {
1839 tty_hangup(portp->tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001840 }
1841}
1842
1843/*****************************************************************************/
1844
1845/*
1846 * Hangup this port. This is pretty much like closing the port, only
1847 * a little more brutal. No waiting for data to drain. Shutdown the
1848 * port and maybe drop signals. This is rather tricky really. We want
1849 * to close the port as well.
1850 */
1851
1852static void stli_hangup(struct tty_struct *tty)
1853{
Jiri Slaby1f8ec432006-12-08 02:39:18 -08001854 struct stliport *portp;
1855 struct stlibrd *brdp;
Alan Cox4ac43602006-06-28 04:26:52 -07001856 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001857
Linus Torvalds1da177e2005-04-16 15:20:36 -07001858 portp = tty->driver_data;
Alan Cox4ac43602006-06-28 04:26:52 -07001859 if (portp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860 return;
Jiri Slaby1328d732006-12-08 02:39:19 -08001861 if (portp->brdnr >= stli_nrbrds)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862 return;
1863 brdp = stli_brds[portp->brdnr];
Alan Cox4ac43602006-06-28 04:26:52 -07001864 if (brdp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865 return;
1866
1867 portp->flags &= ~ASYNC_INITIALIZED;
1868
Alan Cox4ac43602006-06-28 04:26:52 -07001869 if (!test_bit(ST_CLOSING, &portp->state))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870 stli_rawclose(brdp, portp, 0, 0);
Alan Cox4ac43602006-06-28 04:26:52 -07001871
1872 spin_lock_irqsave(&stli_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873 if (tty->termios->c_cflag & HUPCL) {
1874 stli_mkasysigs(&portp->asig, 0, 0);
1875 if (test_bit(ST_CMDING, &portp->state)) {
1876 set_bit(ST_DOSIGS, &portp->state);
1877 set_bit(ST_DOFLUSHTX, &portp->state);
1878 set_bit(ST_DOFLUSHRX, &portp->state);
1879 } else {
1880 stli_sendcmd(brdp, portp, A_SETSIGNALSF,
1881 &portp->asig, sizeof(asysigs_t), 0);
1882 }
1883 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001884
1885 clear_bit(ST_TXBUSY, &portp->state);
1886 clear_bit(ST_RXSTOP, &portp->state);
1887 set_bit(TTY_IO_ERROR, &tty->flags);
Alan Cox4ac43602006-06-28 04:26:52 -07001888 portp->tty = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889 portp->flags &= ~ASYNC_NORMAL_ACTIVE;
1890 portp->refcount = 0;
Alan Cox4ac43602006-06-28 04:26:52 -07001891 spin_unlock_irqrestore(&stli_lock, flags);
1892
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893 wake_up_interruptible(&portp->open_wait);
1894}
1895
1896/*****************************************************************************/
1897
1898/*
1899 * Flush characters from the lower buffer. We may not have user context
1900 * so we cannot sleep waiting for it to complete. Also we need to check
1901 * if there is chars for this port in the TX cook buffer, and flush them
1902 * as well.
1903 */
1904
1905static void stli_flushbuffer(struct tty_struct *tty)
1906{
Jiri Slaby1f8ec432006-12-08 02:39:18 -08001907 struct stliport *portp;
1908 struct stlibrd *brdp;
Alan Cox4ac43602006-06-28 04:26:52 -07001909 unsigned long ftype, flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910
Linus Torvalds1da177e2005-04-16 15:20:36 -07001911 portp = tty->driver_data;
Alan Cox4ac43602006-06-28 04:26:52 -07001912 if (portp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913 return;
Jiri Slaby1328d732006-12-08 02:39:19 -08001914 if (portp->brdnr >= stli_nrbrds)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915 return;
1916 brdp = stli_brds[portp->brdnr];
Alan Cox4ac43602006-06-28 04:26:52 -07001917 if (brdp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918 return;
1919
Alan Cox4ac43602006-06-28 04:26:52 -07001920 spin_lock_irqsave(&brd_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921 if (tty == stli_txcooktty) {
Alan Cox4ac43602006-06-28 04:26:52 -07001922 stli_txcooktty = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923 stli_txcooksize = 0;
1924 stli_txcookrealsize = 0;
1925 }
1926 if (test_bit(ST_CMDING, &portp->state)) {
1927 set_bit(ST_DOFLUSHTX, &portp->state);
1928 } else {
1929 ftype = FLUSHTX;
1930 if (test_bit(ST_DOFLUSHRX, &portp->state)) {
1931 ftype |= FLUSHRX;
1932 clear_bit(ST_DOFLUSHRX, &portp->state);
1933 }
Alan Cox4ac43602006-06-28 04:26:52 -07001934 __stli_sendcmd(brdp, portp, A_FLUSH, &ftype, sizeof(u32), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935 }
Alan Cox4ac43602006-06-28 04:26:52 -07001936 spin_unlock_irqrestore(&brd_lock, flags);
1937 tty_wakeup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001938}
1939
1940/*****************************************************************************/
1941
1942static void stli_breakctl(struct tty_struct *tty, int state)
1943{
Jiri Slaby1f8ec432006-12-08 02:39:18 -08001944 struct stlibrd *brdp;
1945 struct stliport *portp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946 long arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001947
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948 portp = tty->driver_data;
Alan Cox4ac43602006-06-28 04:26:52 -07001949 if (portp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001950 return;
Jiri Slaby1328d732006-12-08 02:39:19 -08001951 if (portp->brdnr >= stli_nrbrds)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001952 return;
1953 brdp = stli_brds[portp->brdnr];
Alan Cox4ac43602006-06-28 04:26:52 -07001954 if (brdp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001955 return;
1956
Linus Torvalds1da177e2005-04-16 15:20:36 -07001957 arg = (state == -1) ? BREAKON : BREAKOFF;
1958 stli_cmdwait(brdp, portp, A_BREAK, &arg, sizeof(long), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001959}
1960
1961/*****************************************************************************/
1962
1963static void stli_waituntilsent(struct tty_struct *tty, int timeout)
1964{
Jiri Slaby1f8ec432006-12-08 02:39:18 -08001965 struct stliport *portp;
Alan Cox4ac43602006-06-28 04:26:52 -07001966 unsigned long tend;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967
Alan Cox4ac43602006-06-28 04:26:52 -07001968 if (tty == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001969 return;
1970 portp = tty->driver_data;
Alan Cox4ac43602006-06-28 04:26:52 -07001971 if (portp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972 return;
1973
1974 if (timeout == 0)
1975 timeout = HZ;
1976 tend = jiffies + timeout;
1977
1978 while (test_bit(ST_TXBUSY, &portp->state)) {
1979 if (signal_pending(current))
1980 break;
1981 msleep_interruptible(20);
1982 if (time_after_eq(jiffies, tend))
1983 break;
1984 }
1985}
1986
1987/*****************************************************************************/
1988
1989static void stli_sendxchar(struct tty_struct *tty, char ch)
1990{
Jiri Slaby1f8ec432006-12-08 02:39:18 -08001991 struct stlibrd *brdp;
1992 struct stliport *portp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001993 asyctrl_t actrl;
1994
Linus Torvalds1da177e2005-04-16 15:20:36 -07001995 portp = tty->driver_data;
Alan Cox4ac43602006-06-28 04:26:52 -07001996 if (portp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001997 return;
Jiri Slaby1328d732006-12-08 02:39:19 -08001998 if (portp->brdnr >= stli_nrbrds)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001999 return;
2000 brdp = stli_brds[portp->brdnr];
Alan Cox4ac43602006-06-28 04:26:52 -07002001 if (brdp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002002 return;
2003
2004 memset(&actrl, 0, sizeof(asyctrl_t));
2005 if (ch == STOP_CHAR(tty)) {
2006 actrl.rxctrl = CT_STOPFLOW;
2007 } else if (ch == START_CHAR(tty)) {
2008 actrl.rxctrl = CT_STARTFLOW;
2009 } else {
2010 actrl.txctrl = CT_SENDCHR;
2011 actrl.tximdch = ch;
2012 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002013 stli_cmdwait(brdp, portp, A_PORTCTRL, &actrl, sizeof(asyctrl_t), 0);
2014}
2015
2016/*****************************************************************************/
2017
2018#define MAXLINE 80
2019
2020/*
2021 * Format info for a specified port. The line is deliberately limited
2022 * to 80 characters. (If it is too long it will be truncated, if too
2023 * short then padded with spaces).
2024 */
2025
Jiri Slaby1f8ec432006-12-08 02:39:18 -08002026static int stli_portinfo(struct stlibrd *brdp, struct stliport *portp, int portnr, char *pos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002027{
Alan Cox4ac43602006-06-28 04:26:52 -07002028 char *sp, *uart;
2029 int rc, cnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002030
2031 rc = stli_portcmdstats(portp);
2032
2033 uart = "UNKNOWN";
2034 if (brdp->state & BST_STARTED) {
2035 switch (stli_comstats.hwid) {
Alan Cox4ac43602006-06-28 04:26:52 -07002036 case 0: uart = "2681"; break;
2037 case 1: uart = "SC26198"; break;
2038 default:uart = "CD1400"; break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002039 }
2040 }
2041
2042 sp = pos;
2043 sp += sprintf(sp, "%d: uart:%s ", portnr, uart);
2044
2045 if ((brdp->state & BST_STARTED) && (rc >= 0)) {
2046 sp += sprintf(sp, "tx:%d rx:%d", (int) stli_comstats.txtotal,
2047 (int) stli_comstats.rxtotal);
2048
2049 if (stli_comstats.rxframing)
2050 sp += sprintf(sp, " fe:%d",
2051 (int) stli_comstats.rxframing);
2052 if (stli_comstats.rxparity)
2053 sp += sprintf(sp, " pe:%d",
2054 (int) stli_comstats.rxparity);
2055 if (stli_comstats.rxbreaks)
2056 sp += sprintf(sp, " brk:%d",
2057 (int) stli_comstats.rxbreaks);
2058 if (stli_comstats.rxoverrun)
2059 sp += sprintf(sp, " oe:%d",
2060 (int) stli_comstats.rxoverrun);
2061
2062 cnt = sprintf(sp, "%s%s%s%s%s ",
2063 (stli_comstats.signals & TIOCM_RTS) ? "|RTS" : "",
2064 (stli_comstats.signals & TIOCM_CTS) ? "|CTS" : "",
2065 (stli_comstats.signals & TIOCM_DTR) ? "|DTR" : "",
2066 (stli_comstats.signals & TIOCM_CD) ? "|DCD" : "",
2067 (stli_comstats.signals & TIOCM_DSR) ? "|DSR" : "");
2068 *sp = ' ';
2069 sp += cnt;
2070 }
2071
2072 for (cnt = (sp - pos); (cnt < (MAXLINE - 1)); cnt++)
2073 *sp++ = ' ';
2074 if (cnt >= MAXLINE)
2075 pos[(MAXLINE - 2)] = '+';
2076 pos[(MAXLINE - 1)] = '\n';
2077
2078 return(MAXLINE);
2079}
2080
2081/*****************************************************************************/
2082
2083/*
2084 * Port info, read from the /proc file system.
2085 */
2086
2087static int stli_readproc(char *page, char **start, off_t off, int count, int *eof, void *data)
2088{
Jiri Slaby1f8ec432006-12-08 02:39:18 -08002089 struct stlibrd *brdp;
2090 struct stliport *portp;
Jiri Slaby1328d732006-12-08 02:39:19 -08002091 unsigned int brdnr, portnr, totalport;
Alan Cox4ac43602006-06-28 04:26:52 -07002092 int curoff, maxoff;
2093 char *pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002094
2095 pos = page;
2096 totalport = 0;
2097 curoff = 0;
2098
2099 if (off == 0) {
2100 pos += sprintf(pos, "%s: version %s", stli_drvtitle,
2101 stli_drvversion);
2102 while (pos < (page + MAXLINE - 1))
2103 *pos++ = ' ';
2104 *pos++ = '\n';
2105 }
2106 curoff = MAXLINE;
2107
2108/*
2109 * We scan through for each board, panel and port. The offset is
2110 * calculated on the fly, and irrelevant ports are skipped.
2111 */
2112 for (brdnr = 0; (brdnr < stli_nrbrds); brdnr++) {
2113 brdp = stli_brds[brdnr];
Alan Cox4ac43602006-06-28 04:26:52 -07002114 if (brdp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002115 continue;
2116 if (brdp->state == 0)
2117 continue;
2118
2119 maxoff = curoff + (brdp->nrports * MAXLINE);
2120 if (off >= maxoff) {
2121 curoff = maxoff;
2122 continue;
2123 }
2124
2125 totalport = brdnr * STL_MAXPORTS;
2126 for (portnr = 0; (portnr < brdp->nrports); portnr++,
2127 totalport++) {
2128 portp = brdp->ports[portnr];
Alan Cox4ac43602006-06-28 04:26:52 -07002129 if (portp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002130 continue;
2131 if (off >= (curoff += MAXLINE))
2132 continue;
2133 if ((pos - page + MAXLINE) > count)
2134 goto stli_readdone;
2135 pos += stli_portinfo(brdp, portp, totalport, pos);
2136 }
2137 }
2138
2139 *eof = 1;
2140
2141stli_readdone:
2142 *start = page;
2143 return(pos - page);
2144}
2145
2146/*****************************************************************************/
2147
2148/*
2149 * Generic send command routine. This will send a message to the slave,
2150 * of the specified type with the specified argument. Must be very
2151 * careful of data that will be copied out from shared memory -
2152 * containing command results. The command completion is all done from
2153 * a poll routine that does not have user context. Therefore you cannot
2154 * copy back directly into user space, or to the kernel stack of a
2155 * process. This routine does not sleep, so can be called from anywhere.
Alan Cox4ac43602006-06-28 04:26:52 -07002156 *
2157 * The caller must hold the brd_lock (see also stli_sendcmd the usual
2158 * entry point)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002159 */
2160
Jiri Slaby1f8ec432006-12-08 02:39:18 -08002161static void __stli_sendcmd(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002162{
Alan Cox4ac43602006-06-28 04:26:52 -07002163 cdkhdr_t __iomem *hdrp;
2164 cdkctrl_t __iomem *cp;
2165 unsigned char __iomem *bits;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002166
2167 if (test_bit(ST_CMDING, &portp->state)) {
2168 printk(KERN_ERR "STALLION: command already busy, cmd=%x!\n",
2169 (int) cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002170 return;
2171 }
2172
2173 EBRDENABLE(brdp);
Alan Cox4ac43602006-06-28 04:26:52 -07002174 cp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->ctrl;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002175 if (size > 0) {
Alan Cox4ac43602006-06-28 04:26:52 -07002176 memcpy_toio((void __iomem *) &(cp->args[0]), arg, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002177 if (copyback) {
2178 portp->argp = arg;
2179 portp->argsize = size;
2180 }
2181 }
Alan Cox4ac43602006-06-28 04:26:52 -07002182 writel(0, &cp->status);
2183 writel(cmd, &cp->cmd);
2184 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
2185 bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset +
Linus Torvalds1da177e2005-04-16 15:20:36 -07002186 portp->portidx;
Alan Cox4ac43602006-06-28 04:26:52 -07002187 writeb(readb(bits) | portp->portbit, bits);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002188 set_bit(ST_CMDING, &portp->state);
2189 EBRDDISABLE(brdp);
Alan Cox4ac43602006-06-28 04:26:52 -07002190}
2191
Jiri Slaby1f8ec432006-12-08 02:39:18 -08002192static void stli_sendcmd(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback)
Alan Cox4ac43602006-06-28 04:26:52 -07002193{
2194 unsigned long flags;
2195
2196 spin_lock_irqsave(&brd_lock, flags);
2197 __stli_sendcmd(brdp, portp, cmd, arg, size, copyback);
2198 spin_unlock_irqrestore(&brd_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002199}
2200
2201/*****************************************************************************/
2202
2203/*
2204 * Read data from shared memory. This assumes that the shared memory
2205 * is enabled and that interrupts are off. Basically we just empty out
2206 * the shared memory buffer into the tty buffer. Must be careful to
2207 * handle the case where we fill up the tty buffer, but still have
2208 * more chars to unload.
2209 */
2210
Jiri Slaby1f8ec432006-12-08 02:39:18 -08002211static void stli_read(struct stlibrd *brdp, struct stliport *portp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002212{
Alan Cox4ac43602006-06-28 04:26:52 -07002213 cdkasyrq_t __iomem *rp;
2214 char __iomem *shbuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002215 struct tty_struct *tty;
Alan Cox4ac43602006-06-28 04:26:52 -07002216 unsigned int head, tail, size;
2217 unsigned int len, stlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002218
2219 if (test_bit(ST_RXSTOP, &portp->state))
2220 return;
2221 tty = portp->tty;
Alan Cox4ac43602006-06-28 04:26:52 -07002222 if (tty == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002223 return;
2224
Alan Cox4ac43602006-06-28 04:26:52 -07002225 rp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->rxq;
2226 head = (unsigned int) readw(&rp->head);
2227 if (head != ((unsigned int) readw(&rp->head)))
2228 head = (unsigned int) readw(&rp->head);
2229 tail = (unsigned int) readw(&rp->tail);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002230 size = portp->rxsize;
2231 if (head >= tail) {
2232 len = head - tail;
2233 stlen = len;
2234 } else {
2235 len = size - (tail - head);
2236 stlen = size - tail;
2237 }
2238
Alan Cox33f0f882006-01-09 20:54:13 -08002239 len = tty_buffer_request_room(tty, len);
Alan Cox4ac43602006-06-28 04:26:52 -07002240
2241 shbuf = (char __iomem *) EBRDGETMEMPTR(brdp, portp->rxoffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002242
2243 while (len > 0) {
Alan Cox4ac43602006-06-28 04:26:52 -07002244 unsigned char *cptr;
2245
Jiri Slabya3f8d9d2006-12-08 02:39:18 -08002246 stlen = min(len, stlen);
Alan Cox4ac43602006-06-28 04:26:52 -07002247 tty_prepare_flip_string(tty, &cptr, stlen);
2248 memcpy_fromio(cptr, shbuf + tail, stlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002249 len -= stlen;
2250 tail += stlen;
2251 if (tail >= size) {
2252 tail = 0;
2253 stlen = head;
2254 }
2255 }
Alan Cox4ac43602006-06-28 04:26:52 -07002256 rp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->rxq;
2257 writew(tail, &rp->tail);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002258
2259 if (head != tail)
2260 set_bit(ST_RXING, &portp->state);
2261
2262 tty_schedule_flip(tty);
2263}
2264
2265/*****************************************************************************/
2266
2267/*
2268 * Set up and carry out any delayed commands. There is only a small set
2269 * of slave commands that can be done "off-level". So it is not too
2270 * difficult to deal with them here.
2271 */
2272
Jiri Slaby1f8ec432006-12-08 02:39:18 -08002273static void stli_dodelaycmd(struct stliport *portp, cdkctrl_t __iomem *cp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002274{
Alan Cox4ac43602006-06-28 04:26:52 -07002275 int cmd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002276
2277 if (test_bit(ST_DOSIGS, &portp->state)) {
2278 if (test_bit(ST_DOFLUSHTX, &portp->state) &&
2279 test_bit(ST_DOFLUSHRX, &portp->state))
2280 cmd = A_SETSIGNALSF;
2281 else if (test_bit(ST_DOFLUSHTX, &portp->state))
2282 cmd = A_SETSIGNALSFTX;
2283 else if (test_bit(ST_DOFLUSHRX, &portp->state))
2284 cmd = A_SETSIGNALSFRX;
2285 else
2286 cmd = A_SETSIGNALS;
2287 clear_bit(ST_DOFLUSHTX, &portp->state);
2288 clear_bit(ST_DOFLUSHRX, &portp->state);
2289 clear_bit(ST_DOSIGS, &portp->state);
Alan Cox4ac43602006-06-28 04:26:52 -07002290 memcpy_toio((void __iomem *) &(cp->args[0]), (void *) &portp->asig,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002291 sizeof(asysigs_t));
Alan Cox4ac43602006-06-28 04:26:52 -07002292 writel(0, &cp->status);
2293 writel(cmd, &cp->cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002294 set_bit(ST_CMDING, &portp->state);
2295 } else if (test_bit(ST_DOFLUSHTX, &portp->state) ||
2296 test_bit(ST_DOFLUSHRX, &portp->state)) {
2297 cmd = ((test_bit(ST_DOFLUSHTX, &portp->state)) ? FLUSHTX : 0);
2298 cmd |= ((test_bit(ST_DOFLUSHRX, &portp->state)) ? FLUSHRX : 0);
2299 clear_bit(ST_DOFLUSHTX, &portp->state);
2300 clear_bit(ST_DOFLUSHRX, &portp->state);
Alan Cox4ac43602006-06-28 04:26:52 -07002301 memcpy_toio((void __iomem *) &(cp->args[0]), (void *) &cmd, sizeof(int));
2302 writel(0, &cp->status);
2303 writel(A_FLUSH, &cp->cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002304 set_bit(ST_CMDING, &portp->state);
2305 }
2306}
2307
2308/*****************************************************************************/
2309
2310/*
2311 * Host command service checking. This handles commands or messages
2312 * coming from the slave to the host. Must have board shared memory
2313 * enabled and interrupts off when called. Notice that by servicing the
2314 * read data last we don't need to change the shared memory pointer
2315 * during processing (which is a slow IO operation).
2316 * Return value indicates if this port is still awaiting actions from
2317 * the slave (like open, command, or even TX data being sent). If 0
2318 * then port is still busy, otherwise no longer busy.
2319 */
2320
Jiri Slaby1f8ec432006-12-08 02:39:18 -08002321static int stli_hostcmd(struct stlibrd *brdp, struct stliport *portp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002322{
Alan Cox4ac43602006-06-28 04:26:52 -07002323 cdkasy_t __iomem *ap;
2324 cdkctrl_t __iomem *cp;
2325 struct tty_struct *tty;
2326 asynotify_t nt;
2327 unsigned long oldsigs;
2328 int rc, donerx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002329
Alan Cox4ac43602006-06-28 04:26:52 -07002330 ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002331 cp = &ap->ctrl;
2332
2333/*
2334 * Check if we are waiting for an open completion message.
2335 */
2336 if (test_bit(ST_OPENING, &portp->state)) {
Alan Cox4ac43602006-06-28 04:26:52 -07002337 rc = readl(&cp->openarg);
2338 if (readb(&cp->open) == 0 && rc != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002339 if (rc > 0)
2340 rc--;
Alan Cox4ac43602006-06-28 04:26:52 -07002341 writel(0, &cp->openarg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002342 portp->rc = rc;
2343 clear_bit(ST_OPENING, &portp->state);
2344 wake_up_interruptible(&portp->raw_wait);
2345 }
2346 }
2347
2348/*
2349 * Check if we are waiting for a close completion message.
2350 */
2351 if (test_bit(ST_CLOSING, &portp->state)) {
Alan Cox4ac43602006-06-28 04:26:52 -07002352 rc = (int) readl(&cp->closearg);
2353 if (readb(&cp->close) == 0 && rc != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002354 if (rc > 0)
2355 rc--;
Alan Cox4ac43602006-06-28 04:26:52 -07002356 writel(0, &cp->closearg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002357 portp->rc = rc;
2358 clear_bit(ST_CLOSING, &portp->state);
2359 wake_up_interruptible(&portp->raw_wait);
2360 }
2361 }
2362
2363/*
2364 * Check if we are waiting for a command completion message. We may
2365 * need to copy out the command results associated with this command.
2366 */
2367 if (test_bit(ST_CMDING, &portp->state)) {
Alan Cox4ac43602006-06-28 04:26:52 -07002368 rc = readl(&cp->status);
2369 if (readl(&cp->cmd) == 0 && rc != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002370 if (rc > 0)
2371 rc--;
Alan Cox4ac43602006-06-28 04:26:52 -07002372 if (portp->argp != NULL) {
2373 memcpy_fromio(portp->argp, (void __iomem *) &(cp->args[0]),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002374 portp->argsize);
Alan Cox4ac43602006-06-28 04:26:52 -07002375 portp->argp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002376 }
Alan Cox4ac43602006-06-28 04:26:52 -07002377 writel(0, &cp->status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002378 portp->rc = rc;
2379 clear_bit(ST_CMDING, &portp->state);
2380 stli_dodelaycmd(portp, cp);
2381 wake_up_interruptible(&portp->raw_wait);
2382 }
2383 }
2384
2385/*
2386 * Check for any notification messages ready. This includes lots of
2387 * different types of events - RX chars ready, RX break received,
2388 * TX data low or empty in the slave, modem signals changed state.
2389 */
2390 donerx = 0;
2391
2392 if (ap->notify) {
2393 nt = ap->changed;
2394 ap->notify = 0;
2395 tty = portp->tty;
2396
2397 if (nt.signal & SG_DCD) {
2398 oldsigs = portp->sigs;
2399 portp->sigs = stli_mktiocm(nt.sigvalue);
2400 clear_bit(ST_GETSIGS, &portp->state);
2401 if ((portp->sigs & TIOCM_CD) &&
2402 ((oldsigs & TIOCM_CD) == 0))
2403 wake_up_interruptible(&portp->open_wait);
2404 if ((oldsigs & TIOCM_CD) &&
2405 ((portp->sigs & TIOCM_CD) == 0)) {
2406 if (portp->flags & ASYNC_CHECK_CD) {
2407 if (tty)
2408 schedule_work(&portp->tqhangup);
2409 }
2410 }
2411 }
2412
2413 if (nt.data & DT_TXEMPTY)
2414 clear_bit(ST_TXBUSY, &portp->state);
2415 if (nt.data & (DT_TXEMPTY | DT_TXLOW)) {
Alan Cox4ac43602006-06-28 04:26:52 -07002416 if (tty != NULL) {
2417 tty_wakeup(tty);
2418 EBRDENABLE(brdp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002419 }
2420 }
2421
2422 if ((nt.data & DT_RXBREAK) && (portp->rxmarkmsk & BRKINT)) {
Alan Cox4ac43602006-06-28 04:26:52 -07002423 if (tty != NULL) {
Alan Cox33f0f882006-01-09 20:54:13 -08002424 tty_insert_flip_char(tty, 0, TTY_BREAK);
2425 if (portp->flags & ASYNC_SAK) {
2426 do_SAK(tty);
2427 EBRDENABLE(brdp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002428 }
Alan Cox33f0f882006-01-09 20:54:13 -08002429 tty_schedule_flip(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002430 }
2431 }
2432
2433 if (nt.data & DT_RXBUSY) {
2434 donerx++;
2435 stli_read(brdp, portp);
2436 }
2437 }
2438
2439/*
2440 * It might seem odd that we are checking for more RX chars here.
2441 * But, we need to handle the case where the tty buffer was previously
2442 * filled, but we had more characters to pass up. The slave will not
2443 * send any more RX notify messages until the RX buffer has been emptied.
2444 * But it will leave the service bits on (since the buffer is not empty).
2445 * So from here we can try to process more RX chars.
2446 */
2447 if ((!donerx) && test_bit(ST_RXING, &portp->state)) {
2448 clear_bit(ST_RXING, &portp->state);
2449 stli_read(brdp, portp);
2450 }
2451
2452 return((test_bit(ST_OPENING, &portp->state) ||
2453 test_bit(ST_CLOSING, &portp->state) ||
2454 test_bit(ST_CMDING, &portp->state) ||
2455 test_bit(ST_TXBUSY, &portp->state) ||
2456 test_bit(ST_RXING, &portp->state)) ? 0 : 1);
2457}
2458
2459/*****************************************************************************/
2460
2461/*
2462 * Service all ports on a particular board. Assumes that the boards
2463 * shared memory is enabled, and that the page pointer is pointed
2464 * at the cdk header structure.
2465 */
2466
Jiri Slaby1f8ec432006-12-08 02:39:18 -08002467static void stli_brdpoll(struct stlibrd *brdp, cdkhdr_t __iomem *hdrp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002468{
Jiri Slaby1f8ec432006-12-08 02:39:18 -08002469 struct stliport *portp;
Alan Cox4ac43602006-06-28 04:26:52 -07002470 unsigned char hostbits[(STL_MAXCHANS / 8) + 1];
2471 unsigned char slavebits[(STL_MAXCHANS / 8) + 1];
2472 unsigned char __iomem *slavep;
2473 int bitpos, bitat, bitsize;
2474 int channr, nrdevs, slavebitchange;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002475
2476 bitsize = brdp->bitsize;
2477 nrdevs = brdp->nrdevs;
2478
2479/*
2480 * Check if slave wants any service. Basically we try to do as
2481 * little work as possible here. There are 2 levels of service
2482 * bits. So if there is nothing to do we bail early. We check
2483 * 8 service bits at a time in the inner loop, so we can bypass
2484 * the lot if none of them want service.
2485 */
Alan Cox4ac43602006-06-28 04:26:52 -07002486 memcpy_fromio(&hostbits[0], (((unsigned char __iomem *) hdrp) + brdp->hostoffset),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002487 bitsize);
2488
2489 memset(&slavebits[0], 0, bitsize);
2490 slavebitchange = 0;
2491
2492 for (bitpos = 0; (bitpos < bitsize); bitpos++) {
2493 if (hostbits[bitpos] == 0)
2494 continue;
2495 channr = bitpos * 8;
2496 for (bitat = 0x1; (channr < nrdevs); channr++, bitat <<= 1) {
2497 if (hostbits[bitpos] & bitat) {
2498 portp = brdp->ports[(channr - 1)];
2499 if (stli_hostcmd(brdp, portp)) {
2500 slavebitchange++;
2501 slavebits[bitpos] |= bitat;
2502 }
2503 }
2504 }
2505 }
2506
2507/*
2508 * If any of the ports are no longer busy then update them in the
2509 * slave request bits. We need to do this after, since a host port
2510 * service may initiate more slave requests.
2511 */
2512 if (slavebitchange) {
Alan Cox4ac43602006-06-28 04:26:52 -07002513 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
2514 slavep = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002515 for (bitpos = 0; (bitpos < bitsize); bitpos++) {
Alan Cox4ac43602006-06-28 04:26:52 -07002516 if (readb(slavebits + bitpos))
2517 writeb(readb(slavep + bitpos) & ~slavebits[bitpos], slavebits + bitpos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002518 }
2519 }
2520}
2521
2522/*****************************************************************************/
2523
2524/*
2525 * Driver poll routine. This routine polls the boards in use and passes
2526 * messages back up to host when necessary. This is actually very
2527 * CPU efficient, since we will always have the kernel poll clock, it
2528 * adds only a few cycles when idle (since board service can be
2529 * determined very easily), but when loaded generates no interrupts
2530 * (with their expensive associated context change).
2531 */
2532
2533static void stli_poll(unsigned long arg)
2534{
Alan Cox4ac43602006-06-28 04:26:52 -07002535 cdkhdr_t __iomem *hdrp;
Jiri Slaby1f8ec432006-12-08 02:39:18 -08002536 struct stlibrd *brdp;
Jiri Slaby1328d732006-12-08 02:39:19 -08002537 unsigned int brdnr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002538
Jiri Slabyff8efe92006-12-08 02:39:27 -08002539 mod_timer(&stli_timerlist, STLI_TIMEOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002540
2541/*
2542 * Check each board and do any servicing required.
2543 */
2544 for (brdnr = 0; (brdnr < stli_nrbrds); brdnr++) {
2545 brdp = stli_brds[brdnr];
Alan Cox4ac43602006-06-28 04:26:52 -07002546 if (brdp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002547 continue;
2548 if ((brdp->state & BST_STARTED) == 0)
2549 continue;
2550
Alan Cox4ac43602006-06-28 04:26:52 -07002551 spin_lock(&brd_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002552 EBRDENABLE(brdp);
Alan Cox4ac43602006-06-28 04:26:52 -07002553 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
2554 if (readb(&hdrp->hostreq))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002555 stli_brdpoll(brdp, hdrp);
2556 EBRDDISABLE(brdp);
Alan Cox4ac43602006-06-28 04:26:52 -07002557 spin_unlock(&brd_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002558 }
2559}
2560
2561/*****************************************************************************/
2562
2563/*
2564 * Translate the termios settings into the port setting structure of
2565 * the slave.
2566 */
2567
Jiri Slaby1f8ec432006-12-08 02:39:18 -08002568static void stli_mkasyport(struct stliport *portp, asyport_t *pp, struct ktermios *tiosp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002569{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002570 memset(pp, 0, sizeof(asyport_t));
2571
2572/*
2573 * Start of by setting the baud, char size, parity and stop bit info.
2574 */
Alan Cox1db27c12006-09-29 02:01:38 -07002575 pp->baudout = tty_get_baud_rate(portp->tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002576 if ((tiosp->c_cflag & CBAUD) == B38400) {
2577 if ((portp->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
2578 pp->baudout = 57600;
2579 else if ((portp->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
2580 pp->baudout = 115200;
2581 else if ((portp->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
2582 pp->baudout = 230400;
2583 else if ((portp->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
2584 pp->baudout = 460800;
2585 else if ((portp->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)
2586 pp->baudout = (portp->baud_base / portp->custom_divisor);
2587 }
2588 if (pp->baudout > STL_MAXBAUD)
2589 pp->baudout = STL_MAXBAUD;
2590 pp->baudin = pp->baudout;
2591
2592 switch (tiosp->c_cflag & CSIZE) {
2593 case CS5:
2594 pp->csize = 5;
2595 break;
2596 case CS6:
2597 pp->csize = 6;
2598 break;
2599 case CS7:
2600 pp->csize = 7;
2601 break;
2602 default:
2603 pp->csize = 8;
2604 break;
2605 }
2606
2607 if (tiosp->c_cflag & CSTOPB)
2608 pp->stopbs = PT_STOP2;
2609 else
2610 pp->stopbs = PT_STOP1;
2611
2612 if (tiosp->c_cflag & PARENB) {
2613 if (tiosp->c_cflag & PARODD)
2614 pp->parity = PT_ODDPARITY;
2615 else
2616 pp->parity = PT_EVENPARITY;
2617 } else {
2618 pp->parity = PT_NOPARITY;
2619 }
2620
2621/*
2622 * Set up any flow control options enabled.
2623 */
2624 if (tiosp->c_iflag & IXON) {
2625 pp->flow |= F_IXON;
2626 if (tiosp->c_iflag & IXANY)
2627 pp->flow |= F_IXANY;
2628 }
2629 if (tiosp->c_cflag & CRTSCTS)
2630 pp->flow |= (F_RTSFLOW | F_CTSFLOW);
2631
2632 pp->startin = tiosp->c_cc[VSTART];
2633 pp->stopin = tiosp->c_cc[VSTOP];
2634 pp->startout = tiosp->c_cc[VSTART];
2635 pp->stopout = tiosp->c_cc[VSTOP];
2636
2637/*
2638 * Set up the RX char marking mask with those RX error types we must
2639 * catch. We can get the slave to help us out a little here, it will
2640 * ignore parity errors and breaks for us, and mark parity errors in
2641 * the data stream.
2642 */
2643 if (tiosp->c_iflag & IGNPAR)
2644 pp->iflag |= FI_IGNRXERRS;
2645 if (tiosp->c_iflag & IGNBRK)
2646 pp->iflag |= FI_IGNBREAK;
2647
2648 portp->rxmarkmsk = 0;
2649 if (tiosp->c_iflag & (INPCK | PARMRK))
2650 pp->iflag |= FI_1MARKRXERRS;
2651 if (tiosp->c_iflag & BRKINT)
2652 portp->rxmarkmsk |= BRKINT;
2653
2654/*
2655 * Set up clocal processing as required.
2656 */
2657 if (tiosp->c_cflag & CLOCAL)
2658 portp->flags &= ~ASYNC_CHECK_CD;
2659 else
2660 portp->flags |= ASYNC_CHECK_CD;
2661
2662/*
2663 * Transfer any persistent flags into the asyport structure.
2664 */
2665 pp->pflag = (portp->pflag & 0xffff);
2666 pp->vmin = (portp->pflag & P_RXIMIN) ? 1 : 0;
2667 pp->vtime = (portp->pflag & P_RXITIME) ? 1 : 0;
2668 pp->cc[1] = (portp->pflag & P_RXTHOLD) ? 1 : 0;
2669}
2670
2671/*****************************************************************************/
2672
2673/*
2674 * Construct a slave signals structure for setting the DTR and RTS
2675 * signals as specified.
2676 */
2677
2678static void stli_mkasysigs(asysigs_t *sp, int dtr, int rts)
2679{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002680 memset(sp, 0, sizeof(asysigs_t));
2681 if (dtr >= 0) {
2682 sp->signal |= SG_DTR;
2683 sp->sigvalue |= ((dtr > 0) ? SG_DTR : 0);
2684 }
2685 if (rts >= 0) {
2686 sp->signal |= SG_RTS;
2687 sp->sigvalue |= ((rts > 0) ? SG_RTS : 0);
2688 }
2689}
2690
2691/*****************************************************************************/
2692
2693/*
2694 * Convert the signals returned from the slave into a local TIOCM type
2695 * signals value. We keep them locally in TIOCM format.
2696 */
2697
2698static long stli_mktiocm(unsigned long sigvalue)
2699{
Alan Cox4ac43602006-06-28 04:26:52 -07002700 long tiocm = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002701 tiocm |= ((sigvalue & SG_DCD) ? TIOCM_CD : 0);
2702 tiocm |= ((sigvalue & SG_CTS) ? TIOCM_CTS : 0);
2703 tiocm |= ((sigvalue & SG_RI) ? TIOCM_RI : 0);
2704 tiocm |= ((sigvalue & SG_DSR) ? TIOCM_DSR : 0);
2705 tiocm |= ((sigvalue & SG_DTR) ? TIOCM_DTR : 0);
2706 tiocm |= ((sigvalue & SG_RTS) ? TIOCM_RTS : 0);
2707 return(tiocm);
2708}
2709
2710/*****************************************************************************/
2711
2712/*
2713 * All panels and ports actually attached have been worked out. All
2714 * we need to do here is set up the appropriate per port data structures.
2715 */
2716
Jiri Slaby1f8ec432006-12-08 02:39:18 -08002717static int stli_initports(struct stlibrd *brdp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002718{
Jiri Slaby1f8ec432006-12-08 02:39:18 -08002719 struct stliport *portp;
Jiri Slaby1328d732006-12-08 02:39:19 -08002720 unsigned int i, panelnr, panelport;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002721
Linus Torvalds1da177e2005-04-16 15:20:36 -07002722 for (i = 0, panelnr = 0, panelport = 0; (i < brdp->nrports); i++) {
Jiri Slaby1f8ec432006-12-08 02:39:18 -08002723 portp = kzalloc(sizeof(struct stliport), GFP_KERNEL);
Tobias Klauserb0b4ed72006-03-31 02:30:56 -08002724 if (!portp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002725 printk("STALLION: failed to allocate port structure\n");
2726 continue;
2727 }
2728
Linus Torvalds1da177e2005-04-16 15:20:36 -07002729 portp->magic = STLI_PORTMAGIC;
2730 portp->portnr = i;
2731 portp->brdnr = brdp->brdnr;
2732 portp->panelnr = panelnr;
2733 portp->baud_base = STL_BAUDBASE;
2734 portp->close_delay = STL_CLOSEDELAY;
2735 portp->closing_wait = 30 * HZ;
Al Viro3e577a82006-12-06 18:41:45 +00002736 INIT_WORK(&portp->tqhangup, stli_dohangup);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002737 init_waitqueue_head(&portp->open_wait);
2738 init_waitqueue_head(&portp->close_wait);
2739 init_waitqueue_head(&portp->raw_wait);
2740 panelport++;
2741 if (panelport >= brdp->panels[panelnr]) {
2742 panelport = 0;
2743 panelnr++;
2744 }
2745 brdp->ports[i] = portp;
2746 }
2747
Alan Cox4ac43602006-06-28 04:26:52 -07002748 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002749}
2750
2751/*****************************************************************************/
2752
2753/*
2754 * All the following routines are board specific hardware operations.
2755 */
2756
Jiri Slaby1f8ec432006-12-08 02:39:18 -08002757static void stli_ecpinit(struct stlibrd *brdp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002758{
2759 unsigned long memconf;
2760
Linus Torvalds1da177e2005-04-16 15:20:36 -07002761 outb(ECP_ATSTOP, (brdp->iobase + ECP_ATCONFR));
2762 udelay(10);
2763 outb(ECP_ATDISABLE, (brdp->iobase + ECP_ATCONFR));
2764 udelay(100);
2765
2766 memconf = (brdp->memaddr & ECP_ATADDRMASK) >> ECP_ATADDRSHFT;
2767 outb(memconf, (brdp->iobase + ECP_ATMEMAR));
2768}
2769
2770/*****************************************************************************/
2771
Jiri Slaby1f8ec432006-12-08 02:39:18 -08002772static void stli_ecpenable(struct stlibrd *brdp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002773{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002774 outb(ECP_ATENABLE, (brdp->iobase + ECP_ATCONFR));
2775}
2776
2777/*****************************************************************************/
2778
Jiri Slaby1f8ec432006-12-08 02:39:18 -08002779static void stli_ecpdisable(struct stlibrd *brdp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002780{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002781 outb(ECP_ATDISABLE, (brdp->iobase + ECP_ATCONFR));
2782}
2783
2784/*****************************************************************************/
2785
Jiri Slaby1f8ec432006-12-08 02:39:18 -08002786static void __iomem *stli_ecpgetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002787{
Al Viro29756fa2006-10-10 22:47:27 +01002788 void __iomem *ptr;
Alan Cox4ac43602006-06-28 04:26:52 -07002789 unsigned char val;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002790
2791 if (offset > brdp->memsize) {
2792 printk(KERN_ERR "STALLION: shared memory pointer=%x out of "
2793 "range at line=%d(%d), brd=%d\n",
2794 (int) offset, line, __LINE__, brdp->brdnr);
2795 ptr = NULL;
2796 val = 0;
2797 } else {
2798 ptr = brdp->membase + (offset % ECP_ATPAGESIZE);
2799 val = (unsigned char) (offset / ECP_ATPAGESIZE);
2800 }
2801 outb(val, (brdp->iobase + ECP_ATMEMPR));
2802 return(ptr);
2803}
2804
2805/*****************************************************************************/
2806
Jiri Slaby1f8ec432006-12-08 02:39:18 -08002807static void stli_ecpreset(struct stlibrd *brdp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002808{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002809 outb(ECP_ATSTOP, (brdp->iobase + ECP_ATCONFR));
2810 udelay(10);
2811 outb(ECP_ATDISABLE, (brdp->iobase + ECP_ATCONFR));
2812 udelay(500);
2813}
2814
2815/*****************************************************************************/
2816
Jiri Slaby1f8ec432006-12-08 02:39:18 -08002817static void stli_ecpintr(struct stlibrd *brdp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002818{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002819 outb(0x1, brdp->iobase);
2820}
2821
2822/*****************************************************************************/
2823
2824/*
2825 * The following set of functions act on ECP EISA boards.
2826 */
2827
Jiri Slaby1f8ec432006-12-08 02:39:18 -08002828static void stli_ecpeiinit(struct stlibrd *brdp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002829{
2830 unsigned long memconf;
2831
Linus Torvalds1da177e2005-04-16 15:20:36 -07002832 outb(0x1, (brdp->iobase + ECP_EIBRDENAB));
2833 outb(ECP_EISTOP, (brdp->iobase + ECP_EICONFR));
2834 udelay(10);
2835 outb(ECP_EIDISABLE, (brdp->iobase + ECP_EICONFR));
2836 udelay(500);
2837
2838 memconf = (brdp->memaddr & ECP_EIADDRMASKL) >> ECP_EIADDRSHFTL;
2839 outb(memconf, (brdp->iobase + ECP_EIMEMARL));
2840 memconf = (brdp->memaddr & ECP_EIADDRMASKH) >> ECP_EIADDRSHFTH;
2841 outb(memconf, (brdp->iobase + ECP_EIMEMARH));
2842}
2843
2844/*****************************************************************************/
2845
Jiri Slaby1f8ec432006-12-08 02:39:18 -08002846static void stli_ecpeienable(struct stlibrd *brdp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002847{
2848 outb(ECP_EIENABLE, (brdp->iobase + ECP_EICONFR));
2849}
2850
2851/*****************************************************************************/
2852
Jiri Slaby1f8ec432006-12-08 02:39:18 -08002853static void stli_ecpeidisable(struct stlibrd *brdp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002854{
2855 outb(ECP_EIDISABLE, (brdp->iobase + ECP_EICONFR));
2856}
2857
2858/*****************************************************************************/
2859
Jiri Slaby1f8ec432006-12-08 02:39:18 -08002860static void __iomem *stli_ecpeigetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002861{
Al Viro29756fa2006-10-10 22:47:27 +01002862 void __iomem *ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002863 unsigned char val;
2864
Linus Torvalds1da177e2005-04-16 15:20:36 -07002865 if (offset > brdp->memsize) {
2866 printk(KERN_ERR "STALLION: shared memory pointer=%x out of "
2867 "range at line=%d(%d), brd=%d\n",
2868 (int) offset, line, __LINE__, brdp->brdnr);
2869 ptr = NULL;
2870 val = 0;
2871 } else {
2872 ptr = brdp->membase + (offset % ECP_EIPAGESIZE);
2873 if (offset < ECP_EIPAGESIZE)
2874 val = ECP_EIENABLE;
2875 else
2876 val = ECP_EIENABLE | 0x40;
2877 }
2878 outb(val, (brdp->iobase + ECP_EICONFR));
2879 return(ptr);
2880}
2881
2882/*****************************************************************************/
2883
Jiri Slaby1f8ec432006-12-08 02:39:18 -08002884static void stli_ecpeireset(struct stlibrd *brdp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002885{
2886 outb(ECP_EISTOP, (brdp->iobase + ECP_EICONFR));
2887 udelay(10);
2888 outb(ECP_EIDISABLE, (brdp->iobase + ECP_EICONFR));
2889 udelay(500);
2890}
2891
2892/*****************************************************************************/
2893
2894/*
2895 * The following set of functions act on ECP MCA boards.
2896 */
2897
Jiri Slaby1f8ec432006-12-08 02:39:18 -08002898static void stli_ecpmcenable(struct stlibrd *brdp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002899{
2900 outb(ECP_MCENABLE, (brdp->iobase + ECP_MCCONFR));
2901}
2902
2903/*****************************************************************************/
2904
Jiri Slaby1f8ec432006-12-08 02:39:18 -08002905static void stli_ecpmcdisable(struct stlibrd *brdp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002906{
2907 outb(ECP_MCDISABLE, (brdp->iobase + ECP_MCCONFR));
2908}
2909
2910/*****************************************************************************/
2911
Jiri Slaby1f8ec432006-12-08 02:39:18 -08002912static void __iomem *stli_ecpmcgetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002913{
Al Viro29756fa2006-10-10 22:47:27 +01002914 void __iomem *ptr;
Alan Cox4ac43602006-06-28 04:26:52 -07002915 unsigned char val;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002916
2917 if (offset > brdp->memsize) {
2918 printk(KERN_ERR "STALLION: shared memory pointer=%x out of "
2919 "range at line=%d(%d), brd=%d\n",
2920 (int) offset, line, __LINE__, brdp->brdnr);
2921 ptr = NULL;
2922 val = 0;
2923 } else {
2924 ptr = brdp->membase + (offset % ECP_MCPAGESIZE);
2925 val = ((unsigned char) (offset / ECP_MCPAGESIZE)) | ECP_MCENABLE;
2926 }
2927 outb(val, (brdp->iobase + ECP_MCCONFR));
2928 return(ptr);
2929}
2930
2931/*****************************************************************************/
2932
Jiri Slaby1f8ec432006-12-08 02:39:18 -08002933static void stli_ecpmcreset(struct stlibrd *brdp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002934{
2935 outb(ECP_MCSTOP, (brdp->iobase + ECP_MCCONFR));
2936 udelay(10);
2937 outb(ECP_MCDISABLE, (brdp->iobase + ECP_MCCONFR));
2938 udelay(500);
2939}
2940
2941/*****************************************************************************/
2942
2943/*
2944 * The following set of functions act on ECP PCI boards.
2945 */
2946
Jiri Slaby1f8ec432006-12-08 02:39:18 -08002947static void stli_ecppciinit(struct stlibrd *brdp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002948{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002949 outb(ECP_PCISTOP, (brdp->iobase + ECP_PCICONFR));
2950 udelay(10);
2951 outb(0, (brdp->iobase + ECP_PCICONFR));
2952 udelay(500);
2953}
2954
2955/*****************************************************************************/
2956
Jiri Slaby1f8ec432006-12-08 02:39:18 -08002957static void __iomem *stli_ecppcigetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002958{
Al Viro29756fa2006-10-10 22:47:27 +01002959 void __iomem *ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002960 unsigned char val;
2961
Linus Torvalds1da177e2005-04-16 15:20:36 -07002962 if (offset > brdp->memsize) {
2963 printk(KERN_ERR "STALLION: shared memory pointer=%x out of "
2964 "range at line=%d(%d), board=%d\n",
2965 (int) offset, line, __LINE__, brdp->brdnr);
2966 ptr = NULL;
2967 val = 0;
2968 } else {
2969 ptr = brdp->membase + (offset % ECP_PCIPAGESIZE);
2970 val = (offset / ECP_PCIPAGESIZE) << 1;
2971 }
2972 outb(val, (brdp->iobase + ECP_PCICONFR));
2973 return(ptr);
2974}
2975
2976/*****************************************************************************/
2977
Jiri Slaby1f8ec432006-12-08 02:39:18 -08002978static void stli_ecppcireset(struct stlibrd *brdp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002979{
2980 outb(ECP_PCISTOP, (brdp->iobase + ECP_PCICONFR));
2981 udelay(10);
2982 outb(0, (brdp->iobase + ECP_PCICONFR));
2983 udelay(500);
2984}
2985
2986/*****************************************************************************/
2987
2988/*
2989 * The following routines act on ONboards.
2990 */
2991
Jiri Slaby1f8ec432006-12-08 02:39:18 -08002992static void stli_onbinit(struct stlibrd *brdp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002993{
2994 unsigned long memconf;
2995
Linus Torvalds1da177e2005-04-16 15:20:36 -07002996 outb(ONB_ATSTOP, (brdp->iobase + ONB_ATCONFR));
2997 udelay(10);
2998 outb(ONB_ATDISABLE, (brdp->iobase + ONB_ATCONFR));
2999 mdelay(1000);
3000
3001 memconf = (brdp->memaddr & ONB_ATADDRMASK) >> ONB_ATADDRSHFT;
3002 outb(memconf, (brdp->iobase + ONB_ATMEMAR));
3003 outb(0x1, brdp->iobase);
3004 mdelay(1);
3005}
3006
3007/*****************************************************************************/
3008
Jiri Slaby1f8ec432006-12-08 02:39:18 -08003009static void stli_onbenable(struct stlibrd *brdp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003010{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003011 outb((brdp->enabval | ONB_ATENABLE), (brdp->iobase + ONB_ATCONFR));
3012}
3013
3014/*****************************************************************************/
3015
Jiri Slaby1f8ec432006-12-08 02:39:18 -08003016static void stli_onbdisable(struct stlibrd *brdp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003017{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003018 outb((brdp->enabval | ONB_ATDISABLE), (brdp->iobase + ONB_ATCONFR));
3019}
3020
3021/*****************************************************************************/
3022
Jiri Slaby1f8ec432006-12-08 02:39:18 -08003023static void __iomem *stli_onbgetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003024{
Al Viro29756fa2006-10-10 22:47:27 +01003025 void __iomem *ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003026
Linus Torvalds1da177e2005-04-16 15:20:36 -07003027 if (offset > brdp->memsize) {
3028 printk(KERN_ERR "STALLION: shared memory pointer=%x out of "
3029 "range at line=%d(%d), brd=%d\n",
3030 (int) offset, line, __LINE__, brdp->brdnr);
3031 ptr = NULL;
3032 } else {
3033 ptr = brdp->membase + (offset % ONB_ATPAGESIZE);
3034 }
3035 return(ptr);
3036}
3037
3038/*****************************************************************************/
3039
Jiri Slaby1f8ec432006-12-08 02:39:18 -08003040static void stli_onbreset(struct stlibrd *brdp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003041{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003042 outb(ONB_ATSTOP, (brdp->iobase + ONB_ATCONFR));
3043 udelay(10);
3044 outb(ONB_ATDISABLE, (brdp->iobase + ONB_ATCONFR));
3045 mdelay(1000);
3046}
3047
3048/*****************************************************************************/
3049
3050/*
3051 * The following routines act on ONboard EISA.
3052 */
3053
Jiri Slaby1f8ec432006-12-08 02:39:18 -08003054static void stli_onbeinit(struct stlibrd *brdp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003055{
3056 unsigned long memconf;
3057
Linus Torvalds1da177e2005-04-16 15:20:36 -07003058 outb(0x1, (brdp->iobase + ONB_EIBRDENAB));
3059 outb(ONB_EISTOP, (brdp->iobase + ONB_EICONFR));
3060 udelay(10);
3061 outb(ONB_EIDISABLE, (brdp->iobase + ONB_EICONFR));
3062 mdelay(1000);
3063
3064 memconf = (brdp->memaddr & ONB_EIADDRMASKL) >> ONB_EIADDRSHFTL;
3065 outb(memconf, (brdp->iobase + ONB_EIMEMARL));
3066 memconf = (brdp->memaddr & ONB_EIADDRMASKH) >> ONB_EIADDRSHFTH;
3067 outb(memconf, (brdp->iobase + ONB_EIMEMARH));
3068 outb(0x1, brdp->iobase);
3069 mdelay(1);
3070}
3071
3072/*****************************************************************************/
3073
Jiri Slaby1f8ec432006-12-08 02:39:18 -08003074static void stli_onbeenable(struct stlibrd *brdp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003075{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003076 outb(ONB_EIENABLE, (brdp->iobase + ONB_EICONFR));
3077}
3078
3079/*****************************************************************************/
3080
Jiri Slaby1f8ec432006-12-08 02:39:18 -08003081static void stli_onbedisable(struct stlibrd *brdp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003082{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003083 outb(ONB_EIDISABLE, (brdp->iobase + ONB_EICONFR));
3084}
3085
3086/*****************************************************************************/
3087
Jiri Slaby1f8ec432006-12-08 02:39:18 -08003088static void __iomem *stli_onbegetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003089{
Al Viro29756fa2006-10-10 22:47:27 +01003090 void __iomem *ptr;
Alan Cox4ac43602006-06-28 04:26:52 -07003091 unsigned char val;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003092
3093 if (offset > brdp->memsize) {
3094 printk(KERN_ERR "STALLION: shared memory pointer=%x out of "
3095 "range at line=%d(%d), brd=%d\n",
3096 (int) offset, line, __LINE__, brdp->brdnr);
3097 ptr = NULL;
3098 val = 0;
3099 } else {
3100 ptr = brdp->membase + (offset % ONB_EIPAGESIZE);
3101 if (offset < ONB_EIPAGESIZE)
3102 val = ONB_EIENABLE;
3103 else
3104 val = ONB_EIENABLE | 0x40;
3105 }
3106 outb(val, (brdp->iobase + ONB_EICONFR));
3107 return(ptr);
3108}
3109
3110/*****************************************************************************/
3111
Jiri Slaby1f8ec432006-12-08 02:39:18 -08003112static void stli_onbereset(struct stlibrd *brdp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003113{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003114 outb(ONB_EISTOP, (brdp->iobase + ONB_EICONFR));
3115 udelay(10);
3116 outb(ONB_EIDISABLE, (brdp->iobase + ONB_EICONFR));
3117 mdelay(1000);
3118}
3119
3120/*****************************************************************************/
3121
3122/*
3123 * The following routines act on Brumby boards.
3124 */
3125
Jiri Slaby1f8ec432006-12-08 02:39:18 -08003126static void stli_bbyinit(struct stlibrd *brdp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003127{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003128 outb(BBY_ATSTOP, (brdp->iobase + BBY_ATCONFR));
3129 udelay(10);
3130 outb(0, (brdp->iobase + BBY_ATCONFR));
3131 mdelay(1000);
3132 outb(0x1, brdp->iobase);
3133 mdelay(1);
3134}
3135
3136/*****************************************************************************/
3137
Jiri Slaby1f8ec432006-12-08 02:39:18 -08003138static void __iomem *stli_bbygetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003139{
Al Viro29756fa2006-10-10 22:47:27 +01003140 void __iomem *ptr;
Alan Cox4ac43602006-06-28 04:26:52 -07003141 unsigned char val;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003142
Alan Cox4ac43602006-06-28 04:26:52 -07003143 BUG_ON(offset > brdp->memsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003144
Alan Cox4ac43602006-06-28 04:26:52 -07003145 ptr = brdp->membase + (offset % BBY_PAGESIZE);
3146 val = (unsigned char) (offset / BBY_PAGESIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003147 outb(val, (brdp->iobase + BBY_ATCONFR));
3148 return(ptr);
3149}
3150
3151/*****************************************************************************/
3152
Jiri Slaby1f8ec432006-12-08 02:39:18 -08003153static void stli_bbyreset(struct stlibrd *brdp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003154{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003155 outb(BBY_ATSTOP, (brdp->iobase + BBY_ATCONFR));
3156 udelay(10);
3157 outb(0, (brdp->iobase + BBY_ATCONFR));
3158 mdelay(1000);
3159}
3160
3161/*****************************************************************************/
3162
3163/*
3164 * The following routines act on original old Stallion boards.
3165 */
3166
Jiri Slaby1f8ec432006-12-08 02:39:18 -08003167static void stli_stalinit(struct stlibrd *brdp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003168{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003169 outb(0x1, brdp->iobase);
3170 mdelay(1000);
3171}
3172
3173/*****************************************************************************/
3174
Jiri Slaby1f8ec432006-12-08 02:39:18 -08003175static void __iomem *stli_stalgetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003176{
Alan Cox4ac43602006-06-28 04:26:52 -07003177 BUG_ON(offset > brdp->memsize);
3178 return brdp->membase + (offset % STAL_PAGESIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003179}
3180
3181/*****************************************************************************/
3182
Jiri Slaby1f8ec432006-12-08 02:39:18 -08003183static void stli_stalreset(struct stlibrd *brdp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003184{
Alan Cox4ac43602006-06-28 04:26:52 -07003185 u32 __iomem *vecp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003186
Alan Cox4ac43602006-06-28 04:26:52 -07003187 vecp = (u32 __iomem *) (brdp->membase + 0x30);
3188 writel(0xffff0000, vecp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003189 outb(0, brdp->iobase);
3190 mdelay(1000);
3191}
3192
3193/*****************************************************************************/
3194
3195/*
3196 * Try to find an ECP board and initialize it. This handles only ECP
3197 * board types.
3198 */
3199
Jiri Slaby1f8ec432006-12-08 02:39:18 -08003200static int stli_initecp(struct stlibrd *brdp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003201{
Alan Cox4ac43602006-06-28 04:26:52 -07003202 cdkecpsig_t sig;
3203 cdkecpsig_t __iomem *sigsp;
3204 unsigned int status, nxtid;
3205 char *name;
Jiri Slaby8f8f5a52006-12-08 02:39:23 -08003206 int retval, panelnr, nrports;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003207
Jiri Slaby8f8f5a52006-12-08 02:39:23 -08003208 if ((brdp->iobase == 0) || (brdp->memaddr == 0)) {
3209 retval = -ENODEV;
3210 goto err;
3211 }
3212
Ingo Korbb3061222007-07-17 04:05:23 -07003213 brdp->iosize = ECP_IOSIZE;
3214
Jiri Slaby8f8f5a52006-12-08 02:39:23 -08003215 if (!request_region(brdp->iobase, brdp->iosize, "istallion")) {
3216 retval = -EIO;
3217 goto err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003218 }
3219
Linus Torvalds1da177e2005-04-16 15:20:36 -07003220/*
3221 * Based on the specific board type setup the common vars to access
3222 * and enable shared memory. Set all board specific information now
3223 * as well.
3224 */
3225 switch (brdp->brdtype) {
3226 case BRD_ECP:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003227 brdp->memsize = ECP_MEMSIZE;
3228 brdp->pagesize = ECP_ATPAGESIZE;
3229 brdp->init = stli_ecpinit;
3230 brdp->enable = stli_ecpenable;
3231 brdp->reenable = stli_ecpenable;
3232 brdp->disable = stli_ecpdisable;
3233 brdp->getmemptr = stli_ecpgetmemptr;
3234 brdp->intr = stli_ecpintr;
3235 brdp->reset = stli_ecpreset;
3236 name = "serial(EC8/64)";
3237 break;
3238
3239 case BRD_ECPE:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003240 brdp->memsize = ECP_MEMSIZE;
3241 brdp->pagesize = ECP_EIPAGESIZE;
3242 brdp->init = stli_ecpeiinit;
3243 brdp->enable = stli_ecpeienable;
3244 brdp->reenable = stli_ecpeienable;
3245 brdp->disable = stli_ecpeidisable;
3246 brdp->getmemptr = stli_ecpeigetmemptr;
3247 brdp->intr = stli_ecpintr;
3248 brdp->reset = stli_ecpeireset;
3249 name = "serial(EC8/64-EI)";
3250 break;
3251
3252 case BRD_ECPMC:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003253 brdp->memsize = ECP_MEMSIZE;
3254 brdp->pagesize = ECP_MCPAGESIZE;
3255 brdp->init = NULL;
3256 brdp->enable = stli_ecpmcenable;
3257 brdp->reenable = stli_ecpmcenable;
3258 brdp->disable = stli_ecpmcdisable;
3259 brdp->getmemptr = stli_ecpmcgetmemptr;
3260 brdp->intr = stli_ecpintr;
3261 brdp->reset = stli_ecpmcreset;
3262 name = "serial(EC8/64-MCA)";
3263 break;
3264
3265 case BRD_ECPPCI:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003266 brdp->memsize = ECP_PCIMEMSIZE;
3267 brdp->pagesize = ECP_PCIPAGESIZE;
3268 brdp->init = stli_ecppciinit;
3269 brdp->enable = NULL;
3270 brdp->reenable = NULL;
3271 brdp->disable = NULL;
3272 brdp->getmemptr = stli_ecppcigetmemptr;
3273 brdp->intr = stli_ecpintr;
3274 brdp->reset = stli_ecppcireset;
3275 name = "serial(EC/RA-PCI)";
3276 break;
3277
3278 default:
Jiri Slaby8f8f5a52006-12-08 02:39:23 -08003279 retval = -EINVAL;
3280 goto err_reg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003281 }
3282
3283/*
3284 * The per-board operations structure is all set up, so now let's go
3285 * and get the board operational. Firstly initialize board configuration
3286 * registers. Set the memory mapping info so we can get at the boards
3287 * shared memory.
3288 */
3289 EBRDINIT(brdp);
3290
3291 brdp->membase = ioremap(brdp->memaddr, brdp->memsize);
Jiri Slaby8f8f5a52006-12-08 02:39:23 -08003292 if (brdp->membase == NULL) {
3293 retval = -ENOMEM;
3294 goto err_reg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003295 }
3296
3297/*
3298 * Now that all specific code is set up, enable the shared memory and
3299 * look for the a signature area that will tell us exactly what board
3300 * this is, and what it is connected to it.
3301 */
3302 EBRDENABLE(brdp);
Alan Cox4ac43602006-06-28 04:26:52 -07003303 sigsp = (cdkecpsig_t __iomem *) EBRDGETMEMPTR(brdp, CDK_SIGADDR);
Al Viro634965f2006-09-23 01:20:31 +01003304 memcpy_fromio(&sig, sigsp, sizeof(cdkecpsig_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003305 EBRDDISABLE(brdp);
3306
Jiri Slaby8f8f5a52006-12-08 02:39:23 -08003307 if (sig.magic != cpu_to_le32(ECP_MAGIC)) {
3308 retval = -ENODEV;
3309 goto err_unmap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003310 }
3311
3312/*
3313 * Scan through the signature looking at the panels connected to the
3314 * board. Calculate the total number of ports as we go.
3315 */
3316 for (panelnr = 0, nxtid = 0; (panelnr < STL_MAXPANELS); panelnr++) {
3317 status = sig.panelid[nxtid];
3318 if ((status & ECH_PNLIDMASK) != nxtid)
3319 break;
3320
3321 brdp->panelids[panelnr] = status;
3322 nrports = (status & ECH_PNL16PORT) ? 16 : 8;
3323 if ((nrports == 16) && ((status & ECH_PNLXPID) == 0))
3324 nxtid++;
3325 brdp->panels[panelnr] = nrports;
3326 brdp->nrports += nrports;
3327 nxtid++;
3328 brdp->nrpanels++;
3329 }
3330
3331
3332 brdp->state |= BST_FOUND;
Alan Cox4ac43602006-06-28 04:26:52 -07003333 return 0;
Jiri Slaby8f8f5a52006-12-08 02:39:23 -08003334err_unmap:
3335 iounmap(brdp->membase);
3336 brdp->membase = NULL;
3337err_reg:
3338 release_region(brdp->iobase, brdp->iosize);
3339err:
3340 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003341}
3342
3343/*****************************************************************************/
3344
3345/*
3346 * Try to find an ONboard, Brumby or Stallion board and initialize it.
3347 * This handles only these board types.
3348 */
3349
Jiri Slaby1f8ec432006-12-08 02:39:18 -08003350static int stli_initonb(struct stlibrd *brdp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003351{
Alan Cox4ac43602006-06-28 04:26:52 -07003352 cdkonbsig_t sig;
3353 cdkonbsig_t __iomem *sigsp;
3354 char *name;
Jiri Slaby8f8f5a52006-12-08 02:39:23 -08003355 int i, retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003356
3357/*
3358 * Do a basic sanity check on the IO and memory addresses.
3359 */
Jiri Slaby8f8f5a52006-12-08 02:39:23 -08003360 if (brdp->iobase == 0 || brdp->memaddr == 0) {
3361 retval = -ENODEV;
3362 goto err;
3363 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003364
3365 brdp->iosize = ONB_IOSIZE;
3366
Jiri Slaby8f8f5a52006-12-08 02:39:23 -08003367 if (!request_region(brdp->iobase, brdp->iosize, "istallion")) {
3368 retval = -EIO;
3369 goto err;
3370 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003371
3372/*
3373 * Based on the specific board type setup the common vars to access
3374 * and enable shared memory. Set all board specific information now
3375 * as well.
3376 */
3377 switch (brdp->brdtype) {
3378 case BRD_ONBOARD:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003379 case BRD_ONBOARD2:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003380 brdp->memsize = ONB_MEMSIZE;
3381 brdp->pagesize = ONB_ATPAGESIZE;
3382 brdp->init = stli_onbinit;
3383 brdp->enable = stli_onbenable;
3384 brdp->reenable = stli_onbenable;
3385 brdp->disable = stli_onbdisable;
3386 brdp->getmemptr = stli_onbgetmemptr;
3387 brdp->intr = stli_ecpintr;
3388 brdp->reset = stli_onbreset;
3389 if (brdp->memaddr > 0x100000)
3390 brdp->enabval = ONB_MEMENABHI;
3391 else
3392 brdp->enabval = ONB_MEMENABLO;
3393 name = "serial(ONBoard)";
3394 break;
3395
3396 case BRD_ONBOARDE:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003397 brdp->memsize = ONB_EIMEMSIZE;
3398 brdp->pagesize = ONB_EIPAGESIZE;
3399 brdp->init = stli_onbeinit;
3400 brdp->enable = stli_onbeenable;
3401 brdp->reenable = stli_onbeenable;
3402 brdp->disable = stli_onbedisable;
3403 brdp->getmemptr = stli_onbegetmemptr;
3404 brdp->intr = stli_ecpintr;
3405 brdp->reset = stli_onbereset;
3406 name = "serial(ONBoard/E)";
3407 break;
3408
3409 case BRD_BRUMBY4:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003410 brdp->memsize = BBY_MEMSIZE;
3411 brdp->pagesize = BBY_PAGESIZE;
3412 brdp->init = stli_bbyinit;
3413 brdp->enable = NULL;
3414 brdp->reenable = NULL;
3415 brdp->disable = NULL;
3416 brdp->getmemptr = stli_bbygetmemptr;
3417 brdp->intr = stli_ecpintr;
3418 brdp->reset = stli_bbyreset;
3419 name = "serial(Brumby)";
3420 break;
3421
3422 case BRD_STALLION:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003423 brdp->memsize = STAL_MEMSIZE;
3424 brdp->pagesize = STAL_PAGESIZE;
3425 brdp->init = stli_stalinit;
3426 brdp->enable = NULL;
3427 brdp->reenable = NULL;
3428 brdp->disable = NULL;
3429 brdp->getmemptr = stli_stalgetmemptr;
3430 brdp->intr = stli_ecpintr;
3431 brdp->reset = stli_stalreset;
3432 name = "serial(Stallion)";
3433 break;
3434
3435 default:
Jiri Slaby8f8f5a52006-12-08 02:39:23 -08003436 retval = -EINVAL;
3437 goto err_reg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003438 }
3439
3440/*
3441 * The per-board operations structure is all set up, so now let's go
3442 * and get the board operational. Firstly initialize board configuration
3443 * registers. Set the memory mapping info so we can get at the boards
3444 * shared memory.
3445 */
3446 EBRDINIT(brdp);
3447
3448 brdp->membase = ioremap(brdp->memaddr, brdp->memsize);
Jiri Slaby8f8f5a52006-12-08 02:39:23 -08003449 if (brdp->membase == NULL) {
3450 retval = -ENOMEM;
3451 goto err_reg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003452 }
3453
3454/*
3455 * Now that all specific code is set up, enable the shared memory and
3456 * look for the a signature area that will tell us exactly what board
3457 * this is, and how many ports.
3458 */
3459 EBRDENABLE(brdp);
Alan Cox4ac43602006-06-28 04:26:52 -07003460 sigsp = (cdkonbsig_t __iomem *) EBRDGETMEMPTR(brdp, CDK_SIGADDR);
3461 memcpy_fromio(&sig, sigsp, sizeof(cdkonbsig_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003462 EBRDDISABLE(brdp);
3463
Alan Cox4ac43602006-06-28 04:26:52 -07003464 if (sig.magic0 != cpu_to_le16(ONB_MAGIC0) ||
3465 sig.magic1 != cpu_to_le16(ONB_MAGIC1) ||
3466 sig.magic2 != cpu_to_le16(ONB_MAGIC2) ||
Jiri Slaby8f8f5a52006-12-08 02:39:23 -08003467 sig.magic3 != cpu_to_le16(ONB_MAGIC3)) {
3468 retval = -ENODEV;
3469 goto err_unmap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003470 }
3471
3472/*
3473 * Scan through the signature alive mask and calculate how many ports
3474 * there are on this board.
3475 */
3476 brdp->nrpanels = 1;
3477 if (sig.amask1) {
3478 brdp->nrports = 32;
3479 } else {
3480 for (i = 0; (i < 16); i++) {
3481 if (((sig.amask0 << i) & 0x8000) == 0)
3482 break;
3483 }
3484 brdp->nrports = i;
3485 }
3486 brdp->panels[0] = brdp->nrports;
3487
3488
3489 brdp->state |= BST_FOUND;
Alan Cox4ac43602006-06-28 04:26:52 -07003490 return 0;
Jiri Slaby8f8f5a52006-12-08 02:39:23 -08003491err_unmap:
3492 iounmap(brdp->membase);
3493 brdp->membase = NULL;
3494err_reg:
3495 release_region(brdp->iobase, brdp->iosize);
3496err:
3497 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003498}
3499
3500/*****************************************************************************/
3501
3502/*
3503 * Start up a running board. This routine is only called after the
3504 * code has been down loaded to the board and is operational. It will
3505 * read in the memory map, and get the show on the road...
3506 */
3507
Jiri Slaby1f8ec432006-12-08 02:39:18 -08003508static int stli_startbrd(struct stlibrd *brdp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003509{
Alan Cox4ac43602006-06-28 04:26:52 -07003510 cdkhdr_t __iomem *hdrp;
3511 cdkmem_t __iomem *memp;
3512 cdkasy_t __iomem *ap;
3513 unsigned long flags;
Jiri Slaby1328d732006-12-08 02:39:19 -08003514 unsigned int portnr, nrdevs, i;
Jiri Slaby1f8ec432006-12-08 02:39:18 -08003515 struct stliport *portp;
Jiri Slaby1328d732006-12-08 02:39:19 -08003516 int rc = 0;
Alan Cox4ac43602006-06-28 04:26:52 -07003517 u32 memoff;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003518
Alan Cox4ac43602006-06-28 04:26:52 -07003519 spin_lock_irqsave(&brd_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003520 EBRDENABLE(brdp);
Alan Cox4ac43602006-06-28 04:26:52 -07003521 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003522 nrdevs = hdrp->nrdevs;
3523
3524#if 0
3525 printk("%s(%d): CDK version %d.%d.%d --> "
3526 "nrdevs=%d memp=%x hostp=%x slavep=%x\n",
Alan Cox4ac43602006-06-28 04:26:52 -07003527 __FILE__, __LINE__, readb(&hdrp->ver_release), readb(&hdrp->ver_modification),
3528 readb(&hdrp->ver_fix), nrdevs, (int) readl(&hdrp->memp), readl(&hdrp->hostp),
3529 readl(&hdrp->slavep));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003530#endif
3531
3532 if (nrdevs < (brdp->nrports + 1)) {
3533 printk(KERN_ERR "STALLION: slave failed to allocate memory for "
3534 "all devices, devices=%d\n", nrdevs);
3535 brdp->nrports = nrdevs - 1;
3536 }
3537 brdp->nrdevs = nrdevs;
3538 brdp->hostoffset = hdrp->hostp - CDK_CDKADDR;
3539 brdp->slaveoffset = hdrp->slavep - CDK_CDKADDR;
3540 brdp->bitsize = (nrdevs + 7) / 8;
Alan Cox4ac43602006-06-28 04:26:52 -07003541 memoff = readl(&hdrp->memp);
3542 if (memoff > brdp->memsize) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003543 printk(KERN_ERR "STALLION: corrupted shared memory region?\n");
3544 rc = -EIO;
3545 goto stli_donestartup;
3546 }
Alan Cox4ac43602006-06-28 04:26:52 -07003547 memp = (cdkmem_t __iomem *) EBRDGETMEMPTR(brdp, memoff);
3548 if (readw(&memp->dtype) != TYP_ASYNCTRL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003549 printk(KERN_ERR "STALLION: no slave control device found\n");
3550 goto stli_donestartup;
3551 }
3552 memp++;
3553
3554/*
3555 * Cycle through memory allocation of each port. We are guaranteed to
3556 * have all ports inside the first page of slave window, so no need to
3557 * change pages while reading memory map.
3558 */
3559 for (i = 1, portnr = 0; (i < nrdevs); i++, portnr++, memp++) {
Alan Cox4ac43602006-06-28 04:26:52 -07003560 if (readw(&memp->dtype) != TYP_ASYNC)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003561 break;
3562 portp = brdp->ports[portnr];
Alan Cox4ac43602006-06-28 04:26:52 -07003563 if (portp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003564 break;
3565 portp->devnr = i;
Alan Cox4ac43602006-06-28 04:26:52 -07003566 portp->addr = readl(&memp->offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003567 portp->reqbit = (unsigned char) (0x1 << (i * 8 / nrdevs));
3568 portp->portidx = (unsigned char) (i / 8);
3569 portp->portbit = (unsigned char) (0x1 << (i % 8));
3570 }
3571
Alan Cox4ac43602006-06-28 04:26:52 -07003572 writeb(0xff, &hdrp->slavereq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003573
3574/*
3575 * For each port setup a local copy of the RX and TX buffer offsets
3576 * and sizes. We do this separate from the above, because we need to
3577 * move the shared memory page...
3578 */
3579 for (i = 1, portnr = 0; (i < nrdevs); i++, portnr++) {
3580 portp = brdp->ports[portnr];
Alan Cox4ac43602006-06-28 04:26:52 -07003581 if (portp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003582 break;
3583 if (portp->addr == 0)
3584 break;
Alan Cox4ac43602006-06-28 04:26:52 -07003585 ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
3586 if (ap != NULL) {
3587 portp->rxsize = readw(&ap->rxq.size);
3588 portp->txsize = readw(&ap->txq.size);
3589 portp->rxoffset = readl(&ap->rxq.offset);
3590 portp->txoffset = readl(&ap->txq.offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003591 }
3592 }
3593
3594stli_donestartup:
3595 EBRDDISABLE(brdp);
Alan Cox4ac43602006-06-28 04:26:52 -07003596 spin_unlock_irqrestore(&brd_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003597
3598 if (rc == 0)
3599 brdp->state |= BST_STARTED;
3600
3601 if (! stli_timeron) {
3602 stli_timeron++;
Jiri Slabyff8efe92006-12-08 02:39:27 -08003603 mod_timer(&stli_timerlist, STLI_TIMEOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003604 }
3605
Alan Cox4ac43602006-06-28 04:26:52 -07003606 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003607}
3608
3609/*****************************************************************************/
3610
3611/*
3612 * Probe and initialize the specified board.
3613 */
3614
Jiri Slaby1f8ec432006-12-08 02:39:18 -08003615static int __devinit stli_brdinit(struct stlibrd *brdp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003616{
Jiri Slaby8f8f5a52006-12-08 02:39:23 -08003617 int retval;
3618
Linus Torvalds1da177e2005-04-16 15:20:36 -07003619 switch (brdp->brdtype) {
3620 case BRD_ECP:
3621 case BRD_ECPE:
3622 case BRD_ECPMC:
3623 case BRD_ECPPCI:
Jiri Slaby8f8f5a52006-12-08 02:39:23 -08003624 retval = stli_initecp(brdp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003625 break;
3626 case BRD_ONBOARD:
3627 case BRD_ONBOARDE:
3628 case BRD_ONBOARD2:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003629 case BRD_BRUMBY4:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003630 case BRD_STALLION:
Jiri Slaby8f8f5a52006-12-08 02:39:23 -08003631 retval = stli_initonb(brdp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003632 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003633 default:
3634 printk(KERN_ERR "STALLION: board=%d is unknown board "
3635 "type=%d\n", brdp->brdnr, brdp->brdtype);
Jiri Slaby8f8f5a52006-12-08 02:39:23 -08003636 retval = -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003637 }
3638
Jiri Slaby8f8f5a52006-12-08 02:39:23 -08003639 if (retval)
3640 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003641
3642 stli_initports(brdp);
3643 printk(KERN_INFO "STALLION: %s found, board=%d io=%x mem=%x "
3644 "nrpanels=%d nrports=%d\n", stli_brdnames[brdp->brdtype],
3645 brdp->brdnr, brdp->iobase, (int) brdp->memaddr,
3646 brdp->nrpanels, brdp->nrports);
Alan Cox4ac43602006-06-28 04:26:52 -07003647 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003648}
3649
Jiri Slabya00f33f2006-12-08 02:39:20 -08003650#if STLI_EISAPROBE != 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07003651/*****************************************************************************/
3652
3653/*
3654 * Probe around trying to find where the EISA boards shared memory
3655 * might be. This is a bit if hack, but it is the best we can do.
3656 */
3657
Jiri Slaby1f8ec432006-12-08 02:39:18 -08003658static int stli_eisamemprobe(struct stlibrd *brdp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003659{
Alan Cox4ac43602006-06-28 04:26:52 -07003660 cdkecpsig_t ecpsig, __iomem *ecpsigp;
3661 cdkonbsig_t onbsig, __iomem *onbsigp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003662 int i, foundit;
3663
Linus Torvalds1da177e2005-04-16 15:20:36 -07003664/*
3665 * First up we reset the board, to get it into a known state. There
3666 * is only 2 board types here we need to worry about. Don;t use the
3667 * standard board init routine here, it programs up the shared
3668 * memory address, and we don't know it yet...
3669 */
3670 if (brdp->brdtype == BRD_ECPE) {
3671 outb(0x1, (brdp->iobase + ECP_EIBRDENAB));
3672 outb(ECP_EISTOP, (brdp->iobase + ECP_EICONFR));
3673 udelay(10);
3674 outb(ECP_EIDISABLE, (brdp->iobase + ECP_EICONFR));
3675 udelay(500);
3676 stli_ecpeienable(brdp);
3677 } else if (brdp->brdtype == BRD_ONBOARDE) {
3678 outb(0x1, (brdp->iobase + ONB_EIBRDENAB));
3679 outb(ONB_EISTOP, (brdp->iobase + ONB_EICONFR));
3680 udelay(10);
3681 outb(ONB_EIDISABLE, (brdp->iobase + ONB_EICONFR));
3682 mdelay(100);
3683 outb(0x1, brdp->iobase);
3684 mdelay(1);
3685 stli_onbeenable(brdp);
3686 } else {
Alan Cox4ac43602006-06-28 04:26:52 -07003687 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003688 }
3689
3690 foundit = 0;
3691 brdp->memsize = ECP_MEMSIZE;
3692
3693/*
3694 * Board shared memory is enabled, so now we have a poke around and
3695 * see if we can find it.
3696 */
3697 for (i = 0; (i < stli_eisamempsize); i++) {
3698 brdp->memaddr = stli_eisamemprobeaddrs[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07003699 brdp->membase = ioremap(brdp->memaddr, brdp->memsize);
Alan Cox4ac43602006-06-28 04:26:52 -07003700 if (brdp->membase == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003701 continue;
3702
3703 if (brdp->brdtype == BRD_ECPE) {
Al Viro29756fa2006-10-10 22:47:27 +01003704 ecpsigp = stli_ecpeigetmemptr(brdp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003705 CDK_SIGADDR, __LINE__);
Alan Cox4ac43602006-06-28 04:26:52 -07003706 memcpy_fromio(&ecpsig, ecpsigp, sizeof(cdkecpsig_t));
3707 if (ecpsig.magic == cpu_to_le32(ECP_MAGIC))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003708 foundit = 1;
3709 } else {
Alan Cox4ac43602006-06-28 04:26:52 -07003710 onbsigp = (cdkonbsig_t __iomem *) stli_onbegetmemptr(brdp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003711 CDK_SIGADDR, __LINE__);
Alan Cox4ac43602006-06-28 04:26:52 -07003712 memcpy_fromio(&onbsig, onbsigp, sizeof(cdkonbsig_t));
3713 if ((onbsig.magic0 == cpu_to_le16(ONB_MAGIC0)) &&
3714 (onbsig.magic1 == cpu_to_le16(ONB_MAGIC1)) &&
3715 (onbsig.magic2 == cpu_to_le16(ONB_MAGIC2)) &&
3716 (onbsig.magic3 == cpu_to_le16(ONB_MAGIC3)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003717 foundit = 1;
3718 }
3719
3720 iounmap(brdp->membase);
3721 if (foundit)
3722 break;
3723 }
3724
3725/*
3726 * Regardless of whether we found the shared memory or not we must
3727 * disable the region. After that return success or failure.
3728 */
3729 if (brdp->brdtype == BRD_ECPE)
3730 stli_ecpeidisable(brdp);
3731 else
3732 stli_onbedisable(brdp);
3733
3734 if (! foundit) {
3735 brdp->memaddr = 0;
3736 brdp->membase = NULL;
3737 printk(KERN_ERR "STALLION: failed to probe shared memory "
3738 "region for %s in EISA slot=%d\n",
3739 stli_brdnames[brdp->brdtype], (brdp->iobase >> 12));
Alan Cox4ac43602006-06-28 04:26:52 -07003740 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003741 }
Alan Cox4ac43602006-06-28 04:26:52 -07003742 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003743}
Jiri Slabya00f33f2006-12-08 02:39:20 -08003744#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003745
3746static int stli_getbrdnr(void)
3747{
Jiri Slaby1328d732006-12-08 02:39:19 -08003748 unsigned int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003749
3750 for (i = 0; i < STL_MAXBRDS; i++) {
3751 if (!stli_brds[i]) {
3752 if (i >= stli_nrbrds)
3753 stli_nrbrds = i + 1;
3754 return i;
3755 }
3756 }
3757 return -1;
3758}
3759
Jiri Slabya00f33f2006-12-08 02:39:20 -08003760#if STLI_EISAPROBE != 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07003761/*****************************************************************************/
3762
3763/*
3764 * Probe around and try to find any EISA boards in system. The biggest
3765 * problem here is finding out what memory address is associated with
3766 * an EISA board after it is found. The registers of the ECPE and
3767 * ONboardE are not readable - so we can't read them from there. We
3768 * don't have access to the EISA CMOS (or EISA BIOS) so we don't
3769 * actually have any way to find out the real value. The best we can
3770 * do is go probing around in the usual places hoping we can find it.
3771 */
3772
3773static int stli_findeisabrds(void)
3774{
Jiri Slaby1f8ec432006-12-08 02:39:18 -08003775 struct stlibrd *brdp;
Jiri Slaby1328d732006-12-08 02:39:19 -08003776 unsigned int iobase, eid, i;
Jiri Slaby8f8f5a52006-12-08 02:39:23 -08003777 int brdnr, found = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003778
3779/*
Alan Cox4ac43602006-06-28 04:26:52 -07003780 * Firstly check if this is an EISA system. If this is not an EISA system then
Linus Torvalds1da177e2005-04-16 15:20:36 -07003781 * don't bother going any further!
3782 */
Alan Cox4ac43602006-06-28 04:26:52 -07003783 if (EISA_bus)
3784 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003785
3786/*
3787 * Looks like an EISA system, so go searching for EISA boards.
3788 */
3789 for (iobase = 0x1000; (iobase <= 0xc000); iobase += 0x1000) {
3790 outb(0xff, (iobase + 0xc80));
3791 eid = inb(iobase + 0xc80);
3792 eid |= inb(iobase + 0xc81) << 8;
3793 if (eid != STL_EISAID)
3794 continue;
3795
3796/*
3797 * We have found a board. Need to check if this board was
3798 * statically configured already (just in case!).
3799 */
3800 for (i = 0; (i < STL_MAXBRDS); i++) {
3801 brdp = stli_brds[i];
Alan Cox4ac43602006-06-28 04:26:52 -07003802 if (brdp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003803 continue;
3804 if (brdp->iobase == iobase)
3805 break;
3806 }
3807 if (i < STL_MAXBRDS)
3808 continue;
3809
3810/*
3811 * We have found a Stallion board and it is not configured already.
3812 * Allocate a board structure and initialize it.
3813 */
Alan Cox4ac43602006-06-28 04:26:52 -07003814 if ((brdp = stli_allocbrd()) == NULL)
Jiri Slaby8f8f5a52006-12-08 02:39:23 -08003815 return found ? : -ENOMEM;
Jiri Slaby1328d732006-12-08 02:39:19 -08003816 brdnr = stli_getbrdnr();
3817 if (brdnr < 0)
Jiri Slaby8f8f5a52006-12-08 02:39:23 -08003818 return found ? : -ENOMEM;
Jiri Slaby1328d732006-12-08 02:39:19 -08003819 brdp->brdnr = (unsigned int)brdnr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003820 eid = inb(iobase + 0xc82);
3821 if (eid == ECP_EISAID)
3822 brdp->brdtype = BRD_ECPE;
3823 else if (eid == ONB_EISAID)
3824 brdp->brdtype = BRD_ONBOARDE;
3825 else
3826 brdp->brdtype = BRD_UNKNOWN;
3827 brdp->iobase = iobase;
3828 outb(0x1, (iobase + 0xc84));
3829 if (stli_eisamemprobe(brdp))
3830 outb(0, (iobase + 0xc84));
Jiri Slaby8f8f5a52006-12-08 02:39:23 -08003831 if (stli_brdinit(brdp) < 0) {
3832 kfree(brdp);
3833 continue;
3834 }
3835
Jiri Slabyb103b5c2006-12-08 02:39:21 -08003836 stli_brds[brdp->brdnr] = brdp;
Jiri Slaby8f8f5a52006-12-08 02:39:23 -08003837 found++;
Jiri Slabyec3dde52006-12-08 02:39:26 -08003838
3839 for (i = 0; i < brdp->nrports; i++)
3840 tty_register_device(stli_serial,
3841 brdp->brdnr * STL_MAXPORTS + i, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003842 }
3843
Jiri Slaby8f8f5a52006-12-08 02:39:23 -08003844 return found;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003845}
Jiri Slabya00f33f2006-12-08 02:39:20 -08003846#else
3847static inline int stli_findeisabrds(void) { return 0; }
3848#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003849
3850/*****************************************************************************/
3851
3852/*
3853 * Find the next available board number that is free.
3854 */
3855
3856/*****************************************************************************/
3857
Linus Torvalds1da177e2005-04-16 15:20:36 -07003858/*
3859 * We have a Stallion board. Allocate a board structure and
3860 * initialize it. Read its IO and MEMORY resources from PCI
3861 * configuration space.
3862 */
3863
Jiri Slaby845bead2006-12-08 02:39:17 -08003864static int __devinit stli_pciprobe(struct pci_dev *pdev,
3865 const struct pci_device_id *ent)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003866{
Jiri Slaby1f8ec432006-12-08 02:39:18 -08003867 struct stlibrd *brdp;
Jiri Slabyec3dde52006-12-08 02:39:26 -08003868 unsigned int i;
Jiri Slaby1328d732006-12-08 02:39:19 -08003869 int brdnr, retval = -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003870
Jiri Slaby845bead2006-12-08 02:39:17 -08003871 retval = pci_enable_device(pdev);
3872 if (retval)
3873 goto err;
3874 brdp = stli_allocbrd();
3875 if (brdp == NULL) {
3876 retval = -ENOMEM;
3877 goto err;
3878 }
Jiri Slabyb103b5c2006-12-08 02:39:21 -08003879 mutex_lock(&stli_brdslock);
Jiri Slaby1328d732006-12-08 02:39:19 -08003880 brdnr = stli_getbrdnr();
Jiri Slabyb103b5c2006-12-08 02:39:21 -08003881 if (brdnr < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003882 printk(KERN_INFO "STALLION: too many boards found, "
3883 "maximum supported %d\n", STL_MAXBRDS);
Jiri Slabyb103b5c2006-12-08 02:39:21 -08003884 mutex_unlock(&stli_brdslock);
Jiri Slaby845bead2006-12-08 02:39:17 -08003885 retval = -EIO;
3886 goto err_fr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003887 }
Jiri Slaby1328d732006-12-08 02:39:19 -08003888 brdp->brdnr = (unsigned int)brdnr;
Jiri Slabyb103b5c2006-12-08 02:39:21 -08003889 stli_brds[brdp->brdnr] = brdp;
3890 mutex_unlock(&stli_brdslock);
Jiri Slaby845bead2006-12-08 02:39:17 -08003891 brdp->brdtype = BRD_ECPPCI;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003892/*
3893 * We have all resources from the board, so lets setup the actual
3894 * board structure now.
3895 */
Jiri Slaby845bead2006-12-08 02:39:17 -08003896 brdp->iobase = pci_resource_start(pdev, 3);
3897 brdp->memaddr = pci_resource_start(pdev, 2);
3898 retval = stli_brdinit(brdp);
3899 if (retval)
Jiri Slabyb103b5c2006-12-08 02:39:21 -08003900 goto err_null;
Jiri Slaby845bead2006-12-08 02:39:17 -08003901
Jiri Slaby39014172006-12-08 02:39:22 -08003902 brdp->state |= BST_PROBED;
Jiri Slaby845bead2006-12-08 02:39:17 -08003903 pci_set_drvdata(pdev, brdp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003904
Jiri Slaby140e92a2006-12-08 02:39:24 -08003905 EBRDENABLE(brdp);
3906 brdp->enable = NULL;
3907 brdp->disable = NULL;
3908
Jiri Slabyec3dde52006-12-08 02:39:26 -08003909 for (i = 0; i < brdp->nrports; i++)
3910 tty_register_device(stli_serial, brdp->brdnr * STL_MAXPORTS + i,
3911 &pdev->dev);
3912
Alan Cox4ac43602006-06-28 04:26:52 -07003913 return 0;
Jiri Slabyb103b5c2006-12-08 02:39:21 -08003914err_null:
3915 stli_brds[brdp->brdnr] = NULL;
Jiri Slaby845bead2006-12-08 02:39:17 -08003916err_fr:
3917 kfree(brdp);
3918err:
3919 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003920}
3921
Jiri Slaby845bead2006-12-08 02:39:17 -08003922static void stli_pciremove(struct pci_dev *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003923{
Jiri Slaby1f8ec432006-12-08 02:39:18 -08003924 struct stlibrd *brdp = pci_get_drvdata(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003925
Jiri Slaby845bead2006-12-08 02:39:17 -08003926 stli_cleanup_ports(brdp);
3927
3928 iounmap(brdp->membase);
3929 if (brdp->iosize > 0)
3930 release_region(brdp->iobase, brdp->iosize);
3931
3932 stli_brds[brdp->brdnr] = NULL;
3933 kfree(brdp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003934}
3935
Jiri Slaby845bead2006-12-08 02:39:17 -08003936static struct pci_driver stli_pcidriver = {
3937 .name = "istallion",
3938 .id_table = istallion_pci_tbl,
3939 .probe = stli_pciprobe,
3940 .remove = __devexit_p(stli_pciremove)
3941};
Linus Torvalds1da177e2005-04-16 15:20:36 -07003942/*****************************************************************************/
3943
3944/*
3945 * Allocate a new board structure. Fill out the basic info in it.
3946 */
3947
Jiri Slaby1f8ec432006-12-08 02:39:18 -08003948static struct stlibrd *stli_allocbrd(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003949{
Jiri Slaby1f8ec432006-12-08 02:39:18 -08003950 struct stlibrd *brdp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003951
Jiri Slaby1f8ec432006-12-08 02:39:18 -08003952 brdp = kzalloc(sizeof(struct stlibrd), GFP_KERNEL);
Tobias Klauserb0b4ed72006-03-31 02:30:56 -08003953 if (!brdp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003954 printk(KERN_ERR "STALLION: failed to allocate memory "
Jiri Slaby1f8ec432006-12-08 02:39:18 -08003955 "(size=%Zd)\n", sizeof(struct stlibrd));
Tobias Klauserb0b4ed72006-03-31 02:30:56 -08003956 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003957 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003958 brdp->magic = STLI_BOARDMAGIC;
Alan Cox4ac43602006-06-28 04:26:52 -07003959 return brdp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003960}
3961
3962/*****************************************************************************/
3963
3964/*
3965 * Scan through all the boards in the configuration and see what we
3966 * can find.
3967 */
3968
3969static int stli_initbrds(void)
3970{
Jiri Slaby1f8ec432006-12-08 02:39:18 -08003971 struct stlibrd *brdp, *nxtbrdp;
3972 struct stlconf conf;
Jiri Slaby8f8f5a52006-12-08 02:39:23 -08003973 unsigned int i, j, found = 0;
Jiri Slaby1328d732006-12-08 02:39:19 -08003974 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003975
Jiri Slabya3f8d9d2006-12-08 02:39:18 -08003976 for (stli_nrbrds = 0; stli_nrbrds < ARRAY_SIZE(stli_brdsp);
3977 stli_nrbrds++) {
3978 memset(&conf, 0, sizeof(conf));
3979 if (stli_parsebrd(&conf, stli_brdsp[stli_nrbrds]) == 0)
3980 continue;
Alan Cox4ac43602006-06-28 04:26:52 -07003981 if ((brdp = stli_allocbrd()) == NULL)
Jiri Slabya3f8d9d2006-12-08 02:39:18 -08003982 continue;
3983 brdp->brdnr = stli_nrbrds;
3984 brdp->brdtype = conf.brdtype;
3985 brdp->iobase = conf.ioaddr1;
3986 brdp->memaddr = conf.memaddr;
Jiri Slaby8f8f5a52006-12-08 02:39:23 -08003987 if (stli_brdinit(brdp) < 0) {
3988 kfree(brdp);
3989 continue;
3990 }
Jiri Slabyb103b5c2006-12-08 02:39:21 -08003991 stli_brds[brdp->brdnr] = brdp;
Jiri Slaby8f8f5a52006-12-08 02:39:23 -08003992 found++;
Jiri Slabyec3dde52006-12-08 02:39:26 -08003993
3994 for (i = 0; i < brdp->nrports; i++)
3995 tty_register_device(stli_serial,
3996 brdp->brdnr * STL_MAXPORTS + i, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003997 }
3998
Jiri Slaby8f8f5a52006-12-08 02:39:23 -08003999 retval = stli_findeisabrds();
4000 if (retval > 0)
4001 found += retval;
Jiri Slaby845bead2006-12-08 02:39:17 -08004002
Linus Torvalds1da177e2005-04-16 15:20:36 -07004003/*
4004 * All found boards are initialized. Now for a little optimization, if
4005 * no boards are sharing the "shared memory" regions then we can just
4006 * leave them all enabled. This is in fact the usual case.
4007 */
4008 stli_shared = 0;
4009 if (stli_nrbrds > 1) {
4010 for (i = 0; (i < stli_nrbrds); i++) {
4011 brdp = stli_brds[i];
Alan Cox4ac43602006-06-28 04:26:52 -07004012 if (brdp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004013 continue;
4014 for (j = i + 1; (j < stli_nrbrds); j++) {
4015 nxtbrdp = stli_brds[j];
Alan Cox4ac43602006-06-28 04:26:52 -07004016 if (nxtbrdp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004017 continue;
4018 if ((brdp->membase >= nxtbrdp->membase) &&
4019 (brdp->membase <= (nxtbrdp->membase +
4020 nxtbrdp->memsize - 1))) {
4021 stli_shared++;
4022 break;
4023 }
4024 }
4025 }
4026 }
4027
4028 if (stli_shared == 0) {
4029 for (i = 0; (i < stli_nrbrds); i++) {
4030 brdp = stli_brds[i];
Alan Cox4ac43602006-06-28 04:26:52 -07004031 if (brdp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004032 continue;
4033 if (brdp->state & BST_FOUND) {
4034 EBRDENABLE(brdp);
4035 brdp->enable = NULL;
4036 brdp->disable = NULL;
4037 }
4038 }
4039 }
4040
Jiri Slaby140e92a2006-12-08 02:39:24 -08004041 retval = pci_register_driver(&stli_pcidriver);
4042 if (retval && found == 0) {
4043 printk(KERN_ERR "Neither isa nor eisa cards found nor pci "
4044 "driver can be registered!\n");
4045 goto err;
4046 }
4047
Alan Cox4ac43602006-06-28 04:26:52 -07004048 return 0;
Jiri Slaby8f8f5a52006-12-08 02:39:23 -08004049err:
4050 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004051}
4052
4053/*****************************************************************************/
4054
4055/*
4056 * Code to handle an "staliomem" read operation. This device is the
4057 * contents of the board shared memory. It is used for down loading
4058 * the slave image (and debugging :-)
4059 */
4060
4061static ssize_t stli_memread(struct file *fp, char __user *buf, size_t count, loff_t *offp)
4062{
Alan Cox4ac43602006-06-28 04:26:52 -07004063 unsigned long flags;
Al Viro29756fa2006-10-10 22:47:27 +01004064 void __iomem *memptr;
Jiri Slaby1f8ec432006-12-08 02:39:18 -08004065 struct stlibrd *brdp;
Jiri Slaby1328d732006-12-08 02:39:19 -08004066 unsigned int brdnr;
4067 int size, n;
Alan Cox4ac43602006-06-28 04:26:52 -07004068 void *p;
4069 loff_t off = *offp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004070
Josef Sipeka7113a92006-12-08 02:36:55 -08004071 brdnr = iminor(fp->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004072 if (brdnr >= stli_nrbrds)
Alan Cox4ac43602006-06-28 04:26:52 -07004073 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004074 brdp = stli_brds[brdnr];
Alan Cox4ac43602006-06-28 04:26:52 -07004075 if (brdp == NULL)
4076 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004077 if (brdp->state == 0)
Alan Cox4ac43602006-06-28 04:26:52 -07004078 return -ENODEV;
4079 if (off >= brdp->memsize || off + count < off)
4080 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004081
Jiri Slabya3f8d9d2006-12-08 02:39:18 -08004082 size = min(count, (size_t)(brdp->memsize - off));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004083
Alan Cox4ac43602006-06-28 04:26:52 -07004084 /*
4085 * Copy the data a page at a time
4086 */
4087
4088 p = (void *)__get_free_page(GFP_KERNEL);
4089 if(p == NULL)
4090 return -ENOMEM;
4091
Linus Torvalds1da177e2005-04-16 15:20:36 -07004092 while (size > 0) {
Alan Cox4ac43602006-06-28 04:26:52 -07004093 spin_lock_irqsave(&brd_lock, flags);
4094 EBRDENABLE(brdp);
Al Viro29756fa2006-10-10 22:47:27 +01004095 memptr = EBRDGETMEMPTR(brdp, off);
Jiri Slabya3f8d9d2006-12-08 02:39:18 -08004096 n = min(size, (int)(brdp->pagesize - (((unsigned long) off) % brdp->pagesize)));
4097 n = min(n, (int)PAGE_SIZE);
Alan Cox4ac43602006-06-28 04:26:52 -07004098 memcpy_fromio(p, memptr, n);
4099 EBRDDISABLE(brdp);
4100 spin_unlock_irqrestore(&brd_lock, flags);
4101 if (copy_to_user(buf, p, n)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004102 count = -EFAULT;
4103 goto out;
4104 }
Alan Cox4ac43602006-06-28 04:26:52 -07004105 off += n;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004106 buf += n;
4107 size -= n;
4108 }
4109out:
Alan Cox4ac43602006-06-28 04:26:52 -07004110 *offp = off;
4111 free_page((unsigned long)p);
4112 return count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004113}
4114
4115/*****************************************************************************/
4116
4117/*
4118 * Code to handle an "staliomem" write operation. This device is the
4119 * contents of the board shared memory. It is used for down loading
4120 * the slave image (and debugging :-)
Alan Cox4ac43602006-06-28 04:26:52 -07004121 *
4122 * FIXME: copy under lock
Linus Torvalds1da177e2005-04-16 15:20:36 -07004123 */
4124
4125static ssize_t stli_memwrite(struct file *fp, const char __user *buf, size_t count, loff_t *offp)
4126{
Alan Cox4ac43602006-06-28 04:26:52 -07004127 unsigned long flags;
Al Viro29756fa2006-10-10 22:47:27 +01004128 void __iomem *memptr;
Jiri Slaby1f8ec432006-12-08 02:39:18 -08004129 struct stlibrd *brdp;
Alan Cox4ac43602006-06-28 04:26:52 -07004130 char __user *chbuf;
Jiri Slaby1328d732006-12-08 02:39:19 -08004131 unsigned int brdnr;
4132 int size, n;
Alan Cox4ac43602006-06-28 04:26:52 -07004133 void *p;
4134 loff_t off = *offp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004135
Josef Sipeka7113a92006-12-08 02:36:55 -08004136 brdnr = iminor(fp->f_path.dentry->d_inode);
Alan Cox4ac43602006-06-28 04:26:52 -07004137
Linus Torvalds1da177e2005-04-16 15:20:36 -07004138 if (brdnr >= stli_nrbrds)
Alan Cox4ac43602006-06-28 04:26:52 -07004139 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004140 brdp = stli_brds[brdnr];
Alan Cox4ac43602006-06-28 04:26:52 -07004141 if (brdp == NULL)
4142 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004143 if (brdp->state == 0)
Alan Cox4ac43602006-06-28 04:26:52 -07004144 return -ENODEV;
4145 if (off >= brdp->memsize || off + count < off)
4146 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004147
4148 chbuf = (char __user *) buf;
Jiri Slabya3f8d9d2006-12-08 02:39:18 -08004149 size = min(count, (size_t)(brdp->memsize - off));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004150
Alan Cox4ac43602006-06-28 04:26:52 -07004151 /*
4152 * Copy the data a page at a time
4153 */
4154
4155 p = (void *)__get_free_page(GFP_KERNEL);
4156 if(p == NULL)
4157 return -ENOMEM;
4158
Linus Torvalds1da177e2005-04-16 15:20:36 -07004159 while (size > 0) {
Jiri Slabya3f8d9d2006-12-08 02:39:18 -08004160 n = min(size, (int)(brdp->pagesize - (((unsigned long) off) % brdp->pagesize)));
4161 n = min(n, (int)PAGE_SIZE);
Alan Cox4ac43602006-06-28 04:26:52 -07004162 if (copy_from_user(p, chbuf, n)) {
4163 if (count == 0)
4164 count = -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004165 goto out;
4166 }
Alan Cox4ac43602006-06-28 04:26:52 -07004167 spin_lock_irqsave(&brd_lock, flags);
4168 EBRDENABLE(brdp);
Al Viro29756fa2006-10-10 22:47:27 +01004169 memptr = EBRDGETMEMPTR(brdp, off);
Alan Cox4ac43602006-06-28 04:26:52 -07004170 memcpy_toio(memptr, p, n);
4171 EBRDDISABLE(brdp);
4172 spin_unlock_irqrestore(&brd_lock, flags);
4173 off += n;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004174 chbuf += n;
4175 size -= n;
4176 }
4177out:
Alan Cox4ac43602006-06-28 04:26:52 -07004178 free_page((unsigned long) p);
4179 *offp = off;
4180 return count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004181}
4182
4183/*****************************************************************************/
4184
4185/*
4186 * Return the board stats structure to user app.
4187 */
4188
4189static int stli_getbrdstats(combrd_t __user *bp)
4190{
Jiri Slaby1f8ec432006-12-08 02:39:18 -08004191 struct stlibrd *brdp;
Jiri Slaby1328d732006-12-08 02:39:19 -08004192 unsigned int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004193
4194 if (copy_from_user(&stli_brdstats, bp, sizeof(combrd_t)))
4195 return -EFAULT;
4196 if (stli_brdstats.brd >= STL_MAXBRDS)
Alan Cox4ac43602006-06-28 04:26:52 -07004197 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004198 brdp = stli_brds[stli_brdstats.brd];
Alan Cox4ac43602006-06-28 04:26:52 -07004199 if (brdp == NULL)
4200 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004201
4202 memset(&stli_brdstats, 0, sizeof(combrd_t));
4203 stli_brdstats.brd = brdp->brdnr;
4204 stli_brdstats.type = brdp->brdtype;
4205 stli_brdstats.hwid = 0;
4206 stli_brdstats.state = brdp->state;
4207 stli_brdstats.ioaddr = brdp->iobase;
4208 stli_brdstats.memaddr = brdp->memaddr;
4209 stli_brdstats.nrpanels = brdp->nrpanels;
4210 stli_brdstats.nrports = brdp->nrports;
4211 for (i = 0; (i < brdp->nrpanels); i++) {
4212 stli_brdstats.panels[i].panel = i;
4213 stli_brdstats.panels[i].hwid = brdp->panelids[i];
4214 stli_brdstats.panels[i].nrports = brdp->panels[i];
4215 }
4216
4217 if (copy_to_user(bp, &stli_brdstats, sizeof(combrd_t)))
4218 return -EFAULT;
Alan Cox4ac43602006-06-28 04:26:52 -07004219 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004220}
4221
4222/*****************************************************************************/
4223
4224/*
4225 * Resolve the referenced port number into a port struct pointer.
4226 */
4227
Jiri Slaby1328d732006-12-08 02:39:19 -08004228static struct stliport *stli_getport(unsigned int brdnr, unsigned int panelnr,
4229 unsigned int portnr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004230{
Jiri Slaby1f8ec432006-12-08 02:39:18 -08004231 struct stlibrd *brdp;
Jiri Slaby1328d732006-12-08 02:39:19 -08004232 unsigned int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004233
Jiri Slaby1328d732006-12-08 02:39:19 -08004234 if (brdnr >= STL_MAXBRDS)
Alan Cox4ac43602006-06-28 04:26:52 -07004235 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004236 brdp = stli_brds[brdnr];
Alan Cox4ac43602006-06-28 04:26:52 -07004237 if (brdp == NULL)
4238 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004239 for (i = 0; (i < panelnr); i++)
4240 portnr += brdp->panels[i];
Jiri Slaby1328d732006-12-08 02:39:19 -08004241 if (portnr >= brdp->nrports)
Alan Cox4ac43602006-06-28 04:26:52 -07004242 return NULL;
4243 return brdp->ports[portnr];
Linus Torvalds1da177e2005-04-16 15:20:36 -07004244}
4245
4246/*****************************************************************************/
4247
4248/*
4249 * Return the port stats structure to user app. A NULL port struct
4250 * pointer passed in means that we need to find out from the app
4251 * what port to get stats for (used through board control device).
4252 */
4253
Jiri Slaby1f8ec432006-12-08 02:39:18 -08004254static int stli_portcmdstats(struct stliport *portp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004255{
4256 unsigned long flags;
Jiri Slaby1f8ec432006-12-08 02:39:18 -08004257 struct stlibrd *brdp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004258 int rc;
4259
4260 memset(&stli_comstats, 0, sizeof(comstats_t));
4261
Alan Cox4ac43602006-06-28 04:26:52 -07004262 if (portp == NULL)
4263 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004264 brdp = stli_brds[portp->brdnr];
Alan Cox4ac43602006-06-28 04:26:52 -07004265 if (brdp == NULL)
4266 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004267
4268 if (brdp->state & BST_STARTED) {
4269 if ((rc = stli_cmdwait(brdp, portp, A_GETSTATS,
4270 &stli_cdkstats, sizeof(asystats_t), 1)) < 0)
Alan Cox4ac43602006-06-28 04:26:52 -07004271 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004272 } else {
4273 memset(&stli_cdkstats, 0, sizeof(asystats_t));
4274 }
4275
4276 stli_comstats.brd = portp->brdnr;
4277 stli_comstats.panel = portp->panelnr;
4278 stli_comstats.port = portp->portnr;
4279 stli_comstats.state = portp->state;
4280 stli_comstats.flags = portp->flags;
4281
Alan Cox4ac43602006-06-28 04:26:52 -07004282 spin_lock_irqsave(&brd_lock, flags);
4283 if (portp->tty != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004284 if (portp->tty->driver_data == portp) {
4285 stli_comstats.ttystate = portp->tty->flags;
Alan Cox4ac43602006-06-28 04:26:52 -07004286 stli_comstats.rxbuffered = -1;
4287 if (portp->tty->termios != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004288 stli_comstats.cflags = portp->tty->termios->c_cflag;
4289 stli_comstats.iflags = portp->tty->termios->c_iflag;
4290 stli_comstats.oflags = portp->tty->termios->c_oflag;
4291 stli_comstats.lflags = portp->tty->termios->c_lflag;
4292 }
4293 }
4294 }
Alan Cox4ac43602006-06-28 04:26:52 -07004295 spin_unlock_irqrestore(&brd_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004296
4297 stli_comstats.txtotal = stli_cdkstats.txchars;
4298 stli_comstats.rxtotal = stli_cdkstats.rxchars + stli_cdkstats.ringover;
4299 stli_comstats.txbuffered = stli_cdkstats.txringq;
4300 stli_comstats.rxbuffered += stli_cdkstats.rxringq;
4301 stli_comstats.rxoverrun = stli_cdkstats.overruns;
4302 stli_comstats.rxparity = stli_cdkstats.parity;
4303 stli_comstats.rxframing = stli_cdkstats.framing;
4304 stli_comstats.rxlost = stli_cdkstats.ringover;
4305 stli_comstats.rxbreaks = stli_cdkstats.rxbreaks;
4306 stli_comstats.txbreaks = stli_cdkstats.txbreaks;
4307 stli_comstats.txxon = stli_cdkstats.txstart;
4308 stli_comstats.txxoff = stli_cdkstats.txstop;
4309 stli_comstats.rxxon = stli_cdkstats.rxstart;
4310 stli_comstats.rxxoff = stli_cdkstats.rxstop;
4311 stli_comstats.rxrtsoff = stli_cdkstats.rtscnt / 2;
4312 stli_comstats.rxrtson = stli_cdkstats.rtscnt - stli_comstats.rxrtsoff;
4313 stli_comstats.modem = stli_cdkstats.dcdcnt;
4314 stli_comstats.hwid = stli_cdkstats.hwid;
4315 stli_comstats.signals = stli_mktiocm(stli_cdkstats.signals);
4316
Alan Cox4ac43602006-06-28 04:26:52 -07004317 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004318}
4319
4320/*****************************************************************************/
4321
4322/*
4323 * Return the port stats structure to user app. A NULL port struct
4324 * pointer passed in means that we need to find out from the app
4325 * what port to get stats for (used through board control device).
4326 */
4327
Jiri Slaby1f8ec432006-12-08 02:39:18 -08004328static int stli_getportstats(struct stliport *portp, comstats_t __user *cp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004329{
Jiri Slaby1f8ec432006-12-08 02:39:18 -08004330 struct stlibrd *brdp;
Alan Cox4ac43602006-06-28 04:26:52 -07004331 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004332
4333 if (!portp) {
4334 if (copy_from_user(&stli_comstats, cp, sizeof(comstats_t)))
4335 return -EFAULT;
4336 portp = stli_getport(stli_comstats.brd, stli_comstats.panel,
4337 stli_comstats.port);
4338 if (!portp)
4339 return -ENODEV;
4340 }
4341
4342 brdp = stli_brds[portp->brdnr];
4343 if (!brdp)
4344 return -ENODEV;
4345
4346 if ((rc = stli_portcmdstats(portp)) < 0)
4347 return rc;
4348
4349 return copy_to_user(cp, &stli_comstats, sizeof(comstats_t)) ?
4350 -EFAULT : 0;
4351}
4352
4353/*****************************************************************************/
4354
4355/*
4356 * Clear the port stats structure. We also return it zeroed out...
4357 */
4358
Jiri Slaby1f8ec432006-12-08 02:39:18 -08004359static int stli_clrportstats(struct stliport *portp, comstats_t __user *cp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004360{
Jiri Slaby1f8ec432006-12-08 02:39:18 -08004361 struct stlibrd *brdp;
Alan Cox4ac43602006-06-28 04:26:52 -07004362 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004363
4364 if (!portp) {
4365 if (copy_from_user(&stli_comstats, cp, sizeof(comstats_t)))
4366 return -EFAULT;
4367 portp = stli_getport(stli_comstats.brd, stli_comstats.panel,
4368 stli_comstats.port);
4369 if (!portp)
4370 return -ENODEV;
4371 }
4372
4373 brdp = stli_brds[portp->brdnr];
4374 if (!brdp)
4375 return -ENODEV;
4376
4377 if (brdp->state & BST_STARTED) {
4378 if ((rc = stli_cmdwait(brdp, portp, A_CLEARSTATS, NULL, 0, 0)) < 0)
4379 return rc;
4380 }
4381
4382 memset(&stli_comstats, 0, sizeof(comstats_t));
4383 stli_comstats.brd = portp->brdnr;
4384 stli_comstats.panel = portp->panelnr;
4385 stli_comstats.port = portp->portnr;
4386
4387 if (copy_to_user(cp, &stli_comstats, sizeof(comstats_t)))
4388 return -EFAULT;
4389 return 0;
4390}
4391
4392/*****************************************************************************/
4393
4394/*
4395 * Return the entire driver ports structure to a user app.
4396 */
4397
Jiri Slaby1f8ec432006-12-08 02:39:18 -08004398static int stli_getportstruct(struct stliport __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004399{
Jiri Slaby1328d732006-12-08 02:39:19 -08004400 struct stliport stli_dummyport;
Jiri Slaby1f8ec432006-12-08 02:39:18 -08004401 struct stliport *portp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004402
Jiri Slaby1f8ec432006-12-08 02:39:18 -08004403 if (copy_from_user(&stli_dummyport, arg, sizeof(struct stliport)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004404 return -EFAULT;
4405 portp = stli_getport(stli_dummyport.brdnr, stli_dummyport.panelnr,
4406 stli_dummyport.portnr);
4407 if (!portp)
4408 return -ENODEV;
Jiri Slaby1f8ec432006-12-08 02:39:18 -08004409 if (copy_to_user(arg, portp, sizeof(struct stliport)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004410 return -EFAULT;
4411 return 0;
4412}
4413
4414/*****************************************************************************/
4415
4416/*
4417 * Return the entire driver board structure to a user app.
4418 */
4419
Jiri Slaby1f8ec432006-12-08 02:39:18 -08004420static int stli_getbrdstruct(struct stlibrd __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004421{
Jiri Slaby1328d732006-12-08 02:39:19 -08004422 struct stlibrd stli_dummybrd;
Jiri Slaby1f8ec432006-12-08 02:39:18 -08004423 struct stlibrd *brdp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004424
Jiri Slaby1f8ec432006-12-08 02:39:18 -08004425 if (copy_from_user(&stli_dummybrd, arg, sizeof(struct stlibrd)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004426 return -EFAULT;
Jiri Slaby1328d732006-12-08 02:39:19 -08004427 if (stli_dummybrd.brdnr >= STL_MAXBRDS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004428 return -ENODEV;
4429 brdp = stli_brds[stli_dummybrd.brdnr];
4430 if (!brdp)
4431 return -ENODEV;
Jiri Slaby1f8ec432006-12-08 02:39:18 -08004432 if (copy_to_user(arg, brdp, sizeof(struct stlibrd)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004433 return -EFAULT;
4434 return 0;
4435}
4436
4437/*****************************************************************************/
4438
4439/*
4440 * The "staliomem" device is also required to do some special operations on
4441 * the board. We need to be able to send an interrupt to the board,
4442 * reset it, and start/stop it.
4443 */
4444
4445static int stli_memioctl(struct inode *ip, struct file *fp, unsigned int cmd, unsigned long arg)
4446{
Jiri Slaby1f8ec432006-12-08 02:39:18 -08004447 struct stlibrd *brdp;
Alan Cox4ac43602006-06-28 04:26:52 -07004448 int brdnr, rc, done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004449 void __user *argp = (void __user *)arg;
4450
Linus Torvalds1da177e2005-04-16 15:20:36 -07004451/*
4452 * First up handle the board independent ioctls.
4453 */
4454 done = 0;
4455 rc = 0;
4456
4457 switch (cmd) {
4458 case COM_GETPORTSTATS:
4459 rc = stli_getportstats(NULL, argp);
4460 done++;
4461 break;
4462 case COM_CLRPORTSTATS:
4463 rc = stli_clrportstats(NULL, argp);
4464 done++;
4465 break;
4466 case COM_GETBRDSTATS:
4467 rc = stli_getbrdstats(argp);
4468 done++;
4469 break;
4470 case COM_READPORT:
4471 rc = stli_getportstruct(argp);
4472 done++;
4473 break;
4474 case COM_READBOARD:
4475 rc = stli_getbrdstruct(argp);
4476 done++;
4477 break;
4478 }
4479
4480 if (done)
Alan Cox4ac43602006-06-28 04:26:52 -07004481 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004482
4483/*
4484 * Now handle the board specific ioctls. These all depend on the
4485 * minor number of the device they were called from.
4486 */
4487 brdnr = iminor(ip);
4488 if (brdnr >= STL_MAXBRDS)
Alan Cox4ac43602006-06-28 04:26:52 -07004489 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004490 brdp = stli_brds[brdnr];
4491 if (!brdp)
Alan Cox4ac43602006-06-28 04:26:52 -07004492 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004493 if (brdp->state == 0)
Alan Cox4ac43602006-06-28 04:26:52 -07004494 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004495
4496 switch (cmd) {
4497 case STL_BINTR:
4498 EBRDINTR(brdp);
4499 break;
4500 case STL_BSTART:
4501 rc = stli_startbrd(brdp);
4502 break;
4503 case STL_BSTOP:
4504 brdp->state &= ~BST_STARTED;
4505 break;
4506 case STL_BRESET:
4507 brdp->state &= ~BST_STARTED;
4508 EBRDRESET(brdp);
4509 if (stli_shared == 0) {
4510 if (brdp->reenable != NULL)
4511 (* brdp->reenable)(brdp);
4512 }
4513 break;
4514 default:
4515 rc = -ENOIOCTLCMD;
4516 break;
4517 }
Alan Cox4ac43602006-06-28 04:26:52 -07004518 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004519}
4520
Jeff Dikeb68e31d2006-10-02 02:17:18 -07004521static const struct tty_operations stli_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004522 .open = stli_open,
4523 .close = stli_close,
4524 .write = stli_write,
4525 .put_char = stli_putchar,
4526 .flush_chars = stli_flushchars,
4527 .write_room = stli_writeroom,
4528 .chars_in_buffer = stli_charsinbuffer,
4529 .ioctl = stli_ioctl,
4530 .set_termios = stli_settermios,
4531 .throttle = stli_throttle,
4532 .unthrottle = stli_unthrottle,
4533 .stop = stli_stop,
4534 .start = stli_start,
4535 .hangup = stli_hangup,
4536 .flush_buffer = stli_flushbuffer,
4537 .break_ctl = stli_breakctl,
4538 .wait_until_sent = stli_waituntilsent,
4539 .send_xchar = stli_sendxchar,
4540 .read_proc = stli_readproc,
4541 .tiocmget = stli_tiocmget,
4542 .tiocmset = stli_tiocmset,
4543};
4544
4545/*****************************************************************************/
Jiri Slabyf1cc54f2006-12-08 02:39:24 -08004546/*
4547 * Loadable module initialization stuff.
4548 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004549
Jiri Slabyf2362c92006-12-08 02:39:25 -08004550static void istallion_cleanup_isa(void)
Jiri Slabyf1cc54f2006-12-08 02:39:24 -08004551{
4552 struct stlibrd *brdp;
4553 unsigned int j;
Jiri Slabyf1cc54f2006-12-08 02:39:24 -08004554
4555 for (j = 0; (j < stli_nrbrds); j++) {
4556 if ((brdp = stli_brds[j]) == NULL || (brdp->state & BST_PROBED))
4557 continue;
4558
4559 stli_cleanup_ports(brdp);
4560
4561 iounmap(brdp->membase);
4562 if (brdp->iosize > 0)
4563 release_region(brdp->iobase, brdp->iosize);
4564 kfree(brdp);
4565 stli_brds[j] = NULL;
4566 }
4567}
4568
Jiri Slabyf2362c92006-12-08 02:39:25 -08004569static int __init istallion_module_init(void)
4570{
4571 unsigned int i;
4572 int retval;
4573
4574 printk(KERN_INFO "%s: version %s\n", stli_drvtitle, stli_drvversion);
4575
4576 spin_lock_init(&stli_lock);
4577 spin_lock_init(&brd_lock);
4578
4579 stli_txcookbuf = kmalloc(STLI_TXBUFSIZE, GFP_KERNEL);
4580 if (!stli_txcookbuf) {
4581 printk(KERN_ERR "STALLION: failed to allocate memory "
4582 "(size=%d)\n", STLI_TXBUFSIZE);
4583 retval = -ENOMEM;
4584 goto err;
4585 }
4586
4587 stli_serial = alloc_tty_driver(STL_MAXBRDS * STL_MAXPORTS);
4588 if (!stli_serial) {
4589 retval = -ENOMEM;
4590 goto err_free;
4591 }
4592
4593 stli_serial->owner = THIS_MODULE;
4594 stli_serial->driver_name = stli_drvname;
4595 stli_serial->name = stli_serialname;
4596 stli_serial->major = STL_SERIALMAJOR;
4597 stli_serial->minor_start = 0;
4598 stli_serial->type = TTY_DRIVER_TYPE_SERIAL;
4599 stli_serial->subtype = SERIAL_TYPE_NORMAL;
4600 stli_serial->init_termios = stli_deftermios;
Jiri Slabyec3dde52006-12-08 02:39:26 -08004601 stli_serial->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
Jiri Slabyf2362c92006-12-08 02:39:25 -08004602 tty_set_operations(stli_serial, &stli_ops);
4603
4604 retval = tty_register_driver(stli_serial);
4605 if (retval) {
4606 printk(KERN_ERR "STALLION: failed to register serial driver\n");
4607 goto err_ttyput;
4608 }
4609
4610 retval = stli_initbrds();
4611 if (retval)
4612 goto err_ttyunr;
4613
4614/*
4615 * Set up a character driver for the shared memory region. We need this
4616 * to down load the slave code image. Also it is a useful debugging tool.
4617 */
4618 retval = register_chrdev(STL_SIOMEMMAJOR, "staliomem", &stli_fsiomem);
4619 if (retval) {
4620 printk(KERN_ERR "STALLION: failed to register serial memory "
4621 "device\n");
4622 goto err_deinit;
4623 }
4624
4625 istallion_class = class_create(THIS_MODULE, "staliomem");
4626 for (i = 0; i < 4; i++)
4627 class_device_create(istallion_class, NULL,
4628 MKDEV(STL_SIOMEMMAJOR, i),
4629 NULL, "staliomem%d", i);
4630
4631 return 0;
4632err_deinit:
4633 pci_unregister_driver(&stli_pcidriver);
4634 istallion_cleanup_isa();
4635err_ttyunr:
4636 tty_unregister_driver(stli_serial);
4637err_ttyput:
4638 put_tty_driver(stli_serial);
4639err_free:
4640 kfree(stli_txcookbuf);
4641err:
4642 return retval;
4643}
4644
4645/*****************************************************************************/
4646
4647static void __exit istallion_module_exit(void)
4648{
4649 unsigned int j;
4650
4651 printk(KERN_INFO "Unloading %s: version %s\n", stli_drvtitle,
4652 stli_drvversion);
4653
4654 if (stli_timeron) {
4655 stli_timeron = 0;
4656 del_timer_sync(&stli_timerlist);
4657 }
4658
4659 unregister_chrdev(STL_SIOMEMMAJOR, "staliomem");
4660
4661 for (j = 0; j < 4; j++)
4662 class_device_destroy(istallion_class, MKDEV(STL_SIOMEMMAJOR,
4663 j));
4664 class_destroy(istallion_class);
4665
4666 pci_unregister_driver(&stli_pcidriver);
4667 istallion_cleanup_isa();
4668
4669 tty_unregister_driver(stli_serial);
4670 put_tty_driver(stli_serial);
4671
4672 kfree(stli_txcookbuf);
4673}
4674
Jiri Slabyf1cc54f2006-12-08 02:39:24 -08004675module_init(istallion_module_init);
4676module_exit(istallion_module_exit);