1
2 /* rio_linux.c -- Linux driver for the Specialix RIO series cards.
3 *
4 *
5 * (C) 1999 R.E.Wolff@BitWizard.nl
6 *
7 * Specialix pays for the development and support of this driver.
8 * Please DO contact support@specialix.co.uk if you require
9 * support. But please read the documentation (rio.txt) first.
10 *
11 *
12 *
13 * This program is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU General Public License as
15 * published by the Free Software Foundation; either version 2 of
16 * the License, or (at your option) any later version.
17 *
18 * This program is distributed in the hope that it will be
19 * useful, but WITHOUT ANY WARRANTY; without even the implied
20 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
21 * PURPOSE. See the GNU General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public
24 * License along with this program; if not, write to the Free
25 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
26 * USA.
27 *
28 * */
29
30 #include <linux/module.h>
31 #include <linux/kdev_t.h>
32 #include <asm/io.h>
33 #include <linux/kernel.h>
34 #include <linux/sched.h>
35 #include <linux/ioport.h>
36 #include <linux/interrupt.h>
37 #include <linux/errno.h>
38 #include <linux/tty.h>
39 #include <linux/tty_flip.h>
40 #include <linux/mm.h>
41 #include <linux/serial.h>
42 #include <linux/fcntl.h>
43 #include <linux/major.h>
44 #include <linux/delay.h>
45 #include <linux/pci.h>
46 #include <linux/slab.h>
47 #include <linux/miscdevice.h>
48 #include <linux/init.h>
49
50 #include <linux/generic_serial.h>
51 #include <asm/uaccess.h>
52
53 #include "linux_compat.h"
54 #include "pkt.h"
55 #include "daemon.h"
56 #include "rio.h"
57 #include "riospace.h"
58 #include "cmdpkt.h"
59 #include "map.h"
60 #include "rup.h"
61 #include "port.h"
62 #include "riodrvr.h"
63 #include "rioinfo.h"
64 #include "func.h"
65 #include "errors.h"
66 #include "pci.h"
67
68 #include "parmmap.h"
69 #include "unixrup.h"
70 #include "board.h"
71 #include "host.h"
72 #include "phb.h"
73 #include "link.h"
74 #include "cmdblk.h"
75 #include "route.h"
76 #include "cirrus.h"
77 #include "rioioctl.h"
78 #include "param.h"
79 #include "protsts.h"
80 #include "rioboard.h"
81
82
83 #include "rio_linux.h"
84
85 /* I don't think that this driver can handle more than 512 ports on
86 one machine. Specialix specifies max 4 boards in one machine. I don't
87 know why. If you want to try anyway you'll have to increase the number
88 of boards in rio.h. You'll have to allocate more majors if you need
89 more than 512 ports.... */
90
91 #ifndef RIO_NORMAL_MAJOR0
92 /* This allows overriding on the compiler commandline, or in a "major.h"
93 include or something like that */
94 #define RIO_NORMAL_MAJOR0 154
95 #define RIO_NORMAL_MAJOR1 156
96 #endif
97
98 #ifndef PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8
99 #define PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8 0x2000
100 #endif
101
102 #ifndef RIO_WINDOW_LEN
103 #define RIO_WINDOW_LEN 0x10000
104 #endif
105
106
107 /* Configurable options:
108 (Don't be too sure that it'll work if you toggle them) */
109
110 /* Am I paranoid or not ? ;-) */
111 #undef RIO_PARANOIA_CHECK
112
113
114 /* 20 -> 2000 per second. The card should rate-limit interrupts at 1000
115 Hz, but it is user configurable. I don't recommend going above 1000
116 Hz. The interrupt ratelimit might trigger if the interrupt is
117 shared with a very active other device.
118 undef this if you want to disable the check....
119 */
120 #define IRQ_RATE_LIMIT 200
121
122
123 /* These constants are derived from SCO Source */
124 static struct Conf
125 RIOConf = {
126 /* locator */ "RIO Config here",
127 /* startuptime */ HZ * 2,
128 /* how long to wait for card to run */
129 /* slowcook */ 0,
130 /* TRUE -> always use line disc. */
131 /* intrpolltime */ 1,
132 /* The frequency of OUR polls */
133 /* breakinterval */ 25,
134 /* x10 mS XXX: units seem to be 1ms not 10! -- REW */
135 /* timer */ 10,
136 /* mS */
137 /* RtaLoadBase */ 0x7000,
138 /* HostLoadBase */ 0x7C00,
139 /* XpHz */ 5,
140 /* number of Xprint hits per second */
141 /* XpCps */ 120,
142 /* Xprint characters per second */
143 /* XpOn */ "\033d#",
144 /* start Xprint for a wyse 60 */
145 /* XpOff */ "\024",
146 /* end Xprint for a wyse 60 */
147 /* MaxXpCps */ 2000,
148 /* highest Xprint speed */
149 /* MinXpCps */ 10,
150 /* slowest Xprint speed */
151 /* SpinCmds */ 1,
152 /* non-zero for mega fast boots */
153 /* First Addr */ 0x0A0000,
154 /* First address to look at */
155 /* Last Addr */ 0xFF0000,
156 /* Last address looked at */
157 /* BufferSize */ 1024,
158 /* Bytes per port of buffering */
159 /* LowWater */ 256,
160 /* how much data left before wakeup */
161 /* LineLength */ 80,
162 /* how wide is the console? */
163 /* CmdTimeout */ HZ,
164 /* how long a close command may take */
165 };
166
167
168
169
170 /* Function prototypes */
171
172 static void rio_disable_tx_interrupts(void *ptr);
173 static void rio_enable_tx_interrupts(void *ptr);
174 static void rio_disable_rx_interrupts(void *ptr);
175 static void rio_enable_rx_interrupts(void *ptr);
176 static int rio_carrier_raised(struct tty_port *port);
177 static void rio_shutdown_port(void *ptr);
178 static int rio_set_real_termios(void *ptr);
179 static void rio_hungup(void *ptr);
180 static void rio_close(void *ptr);
181 static int rio_chars_in_buffer(void *ptr);
182 static long rio_fw_ioctl(struct file *filp, unsigned int cmd, unsigned long arg);
183 static int rio_init_drivers(void);
184
185 static void my_hd(void *addr, int len);
186
187 static struct tty_driver *rio_driver, *rio_driver2;
188
189 /* The name "p" is a bit non-descript. But that's what the rio-lynxos
190 sources use all over the place. */
191 struct rio_info *p;
192
193 int rio_debug;
194
195
196 /* You can have the driver poll your card.
197 - Set rio_poll to 1 to poll every timer tick (10ms on Intel).
198 This is used when the card cannot use an interrupt for some reason.
199 */
200 static int rio_poll = 1;
201
202
203 /* These are the only open spaces in my computer. Yours may have more
204 or less.... */
205 static int rio_probe_addrs[] = { 0xc0000, 0xd0000, 0xe0000 };
206
207 #define NR_RIO_ADDRS ARRAY_SIZE(rio_probe_addrs)
208
209
210 /* Set the mask to all-ones. This alas, only supports 32 interrupts.
211 Some architectures may need more. -- Changed to LONG to
212 support up to 64 bits on 64bit architectures. -- REW 20/06/99 */
213 static long rio_irqmask = -1;
214
215 MODULE_AUTHOR("Rogier Wolff <R.E.Wolff@bitwizard.nl>, Patrick van de Lageweg <patrick@bitwizard.nl>");
216 MODULE_DESCRIPTION("RIO driver");
217 MODULE_LICENSE("GPL");
218 module_param(rio_poll, int, 0);
219 module_param(rio_debug, int, 0644);
220 module_param(rio_irqmask, long, 0);
221
222 static struct real_driver rio_real_driver = {
223 rio_disable_tx_interrupts,
224 rio_enable_tx_interrupts,
225 rio_disable_rx_interrupts,
226 rio_enable_rx_interrupts,
227 rio_shutdown_port,
228 rio_set_real_termios,
229 rio_chars_in_buffer,
230 rio_close,
231 rio_hungup,
232 NULL
233 };
234
235 /*
236 * Firmware loader driver specific routines
237 *
238 */
239
240 static const struct file_operations rio_fw_fops = {
241 .owner = THIS_MODULE,
242 .unlocked_ioctl = rio_fw_ioctl,
243 };
244
245 static struct miscdevice rio_fw_device = {
246 RIOCTL_MISC_MINOR, "rioctl", &rio_fw_fops
247 };
248
249
250
251
252
253 #ifdef RIO_PARANOIA_CHECK
254
255 /* This doesn't work. Who's paranoid around here? Not me! */
256
rio_paranoia_check(struct rio_port const * port,char * name,const char * routine)257 static inline int rio_paranoia_check(struct rio_port const *port, char *name, const char *routine)
258 {
259
260 static const char *badmagic = KERN_ERR "rio: Warning: bad rio port magic number for device %s in %s\n";
261 static const char *badinfo = KERN_ERR "rio: Warning: null rio port for device %s in %s\n";
262
263 if (!port) {
264 printk(badinfo, name, routine);
265 return 1;
266 }
267 if (port->magic != RIO_MAGIC) {
268 printk(badmagic, name, routine);
269 return 1;
270 }
271
272 return 0;
273 }
274 #else
275 #define rio_paranoia_check(a,b,c) 0
276 #endif
277
278
279 #ifdef DEBUG
my_hd(void * ad,int len)280 static void my_hd(void *ad, int len)
281 {
282 int i, j, ch;
283 unsigned char *addr = ad;
284
285 for (i = 0; i < len; i += 16) {
286 rio_dprintk(RIO_DEBUG_PARAM, "%08lx ", (unsigned long) addr + i);
287 for (j = 0; j < 16; j++) {
288 rio_dprintk(RIO_DEBUG_PARAM, "%02x %s", addr[j + i], (j == 7) ? " " : "");
289 }
290 for (j = 0; j < 16; j++) {
291 ch = addr[j + i];
292 rio_dprintk(RIO_DEBUG_PARAM, "%c", (ch < 0x20) ? '.' : ((ch > 0x7f) ? '.' : ch));
293 }
294 rio_dprintk(RIO_DEBUG_PARAM, "\n");
295 }
296 }
297 #else
298 #define my_hd(ad,len) do{/* nothing*/ } while (0)
299 #endif
300
301
302 /* Delay a number of jiffies, allowing a signal to interrupt */
RIODelay(struct Port * PortP,int njiffies)303 int RIODelay(struct Port *PortP, int njiffies)
304 {
305 func_enter();
306
307 rio_dprintk(RIO_DEBUG_DELAY, "delaying %d jiffies\n", njiffies);
308 msleep_interruptible(jiffies_to_msecs(njiffies));
309 func_exit();
310
311 if (signal_pending(current))
312 return RIO_FAIL;
313 else
314 return !RIO_FAIL;
315 }
316
317
318 /* Delay a number of jiffies, disallowing a signal to interrupt */
RIODelay_ni(struct Port * PortP,int njiffies)319 int RIODelay_ni(struct Port *PortP, int njiffies)
320 {
321 func_enter();
322
323 rio_dprintk(RIO_DEBUG_DELAY, "delaying %d jiffies (ni)\n", njiffies);
324 msleep(jiffies_to_msecs(njiffies));
325 func_exit();
326 return !RIO_FAIL;
327 }
328
rio_copy_to_card(void * from,void __iomem * to,int len)329 void rio_copy_to_card(void *from, void __iomem *to, int len)
330 {
331 rio_copy_toio(to, from, len);
332 }
333
rio_minor(struct tty_struct * tty)334 int rio_minor(struct tty_struct *tty)
335 {
336 return tty->index + (tty->driver == rio_driver) ? 0 : 256;
337 }
338
rio_set_real_termios(void * ptr)339 static int rio_set_real_termios(void *ptr)
340 {
341 return RIOParam((struct Port *) ptr, RIOC_CONFIG, 1, 1);
342 }
343
344
rio_reset_interrupt(struct Host * HostP)345 static void rio_reset_interrupt(struct Host *HostP)
346 {
347 func_enter();
348
349 switch (HostP->Type) {
350 case RIO_AT:
351 case RIO_MCA:
352 case RIO_PCI:
353 writeb(0xFF, &HostP->ResetInt);
354 }
355
356 func_exit();
357 }
358
359
rio_interrupt(int irq,void * ptr)360 static irqreturn_t rio_interrupt(int irq, void *ptr)
361 {
362 struct Host *HostP;
363 func_enter();
364
365 HostP = ptr; /* &p->RIOHosts[(long)ptr]; */
366 rio_dprintk(RIO_DEBUG_IFLOW, "rio: enter rio_interrupt (%d/%d)\n", irq, HostP->Ivec);
367
368 /* AAargh! The order in which to do these things is essential and
369 not trivial.
370
371 - hardware twiddling goes before "recursive". Otherwise when we
372 poll the card, and a recursive interrupt happens, we won't
373 ack the card, so it might keep on interrupting us. (especially
374 level sensitive interrupt systems like PCI).
375
376 - Rate limit goes before hardware twiddling. Otherwise we won't
377 catch a card that has gone bonkers.
378
379 - The "initialized" test goes after the hardware twiddling. Otherwise
380 the card will stick us in the interrupt routine again.
381
382 - The initialized test goes before recursive.
383 */
384
385 rio_dprintk(RIO_DEBUG_IFLOW, "rio: We've have noticed the interrupt\n");
386 if (HostP->Ivec == irq) {
387 /* Tell the card we've noticed the interrupt. */
388 rio_reset_interrupt(HostP);
389 }
390
391 if ((HostP->Flags & RUN_STATE) != RC_RUNNING)
392 return IRQ_HANDLED;
393
394 if (test_and_set_bit(RIO_BOARD_INTR_LOCK, &HostP->locks)) {
395 printk(KERN_ERR "Recursive interrupt! (host %p/irq%d)\n", ptr, HostP->Ivec);
396 return IRQ_HANDLED;
397 }
398
399 RIOServiceHost(p, HostP);
400
401 rio_dprintk(RIO_DEBUG_IFLOW, "riointr() doing host %p type %d\n", ptr, HostP->Type);
402
403 clear_bit(RIO_BOARD_INTR_LOCK, &HostP->locks);
404 rio_dprintk(RIO_DEBUG_IFLOW, "rio: exit rio_interrupt (%d/%d)\n", irq, HostP->Ivec);
405 func_exit();
406 return IRQ_HANDLED;
407 }
408
409
rio_pollfunc(unsigned long data)410 static void rio_pollfunc(unsigned long data)
411 {
412 func_enter();
413
414 rio_interrupt(0, &p->RIOHosts[data]);
415 mod_timer(&p->RIOHosts[data].timer, jiffies + rio_poll);
416
417 func_exit();
418 }
419
420
421 /* ********************************************************************** *
422 * Here are the routines that actually *
423 * interface with the generic_serial driver *
424 * ********************************************************************** */
425
426 /* Ehhm. I don't know how to fiddle with interrupts on the Specialix
427 cards. .... Hmm. Ok I figured it out. You don't. -- REW */
428
rio_disable_tx_interrupts(void * ptr)429 static void rio_disable_tx_interrupts(void *ptr)
430 {
431 func_enter();
432
433 /* port->gs.port.flags &= ~GS_TX_INTEN; */
434
435 func_exit();
436 }
437
438
rio_enable_tx_interrupts(void * ptr)439 static void rio_enable_tx_interrupts(void *ptr)
440 {
441 struct Port *PortP = ptr;
442 /* int hn; */
443
444 func_enter();
445
446 /* hn = PortP->HostP - p->RIOHosts;
447
448 rio_dprintk (RIO_DEBUG_TTY, "Pushing host %d\n", hn);
449 rio_interrupt (-1,(void *) hn, NULL); */
450
451 RIOTxEnable((char *) PortP);
452
453 /*
454 * In general we cannot count on "tx empty" interrupts, although
455 * the interrupt routine seems to be able to tell the difference.
456 */
457 PortP->gs.port.flags &= ~GS_TX_INTEN;
458
459 func_exit();
460 }
461
462
rio_disable_rx_interrupts(void * ptr)463 static void rio_disable_rx_interrupts(void *ptr)
464 {
465 func_enter();
466 func_exit();
467 }
468
rio_enable_rx_interrupts(void * ptr)469 static void rio_enable_rx_interrupts(void *ptr)
470 {
471 /* struct rio_port *port = ptr; */
472 func_enter();
473 func_exit();
474 }
475
476
477 /* Jeez. Isn't this simple? */
rio_carrier_raised(struct tty_port * port)478 static int rio_carrier_raised(struct tty_port *port)
479 {
480 struct Port *PortP = container_of(port, struct Port, gs.port);
481 int rv;
482
483 func_enter();
484 rv = (PortP->ModemState & RIOC_MSVR1_CD) != 0;
485
486 rio_dprintk(RIO_DEBUG_INIT, "Getting CD status: %d\n", rv);
487
488 func_exit();
489 return rv;
490 }
491
492
493 /* Jeez. Isn't this simple? Actually, we can sync with the actual port
494 by just pushing stuff into the queue going to the port... */
rio_chars_in_buffer(void * ptr)495 static int rio_chars_in_buffer(void *ptr)
496 {
497 func_enter();
498
499 func_exit();
500 return 0;
501 }
502
503
504 /* Nothing special here... */
rio_shutdown_port(void * ptr)505 static void rio_shutdown_port(void *ptr)
506 {
507 struct Port *PortP;
508
509 func_enter();
510
511 PortP = (struct Port *) ptr;
512 PortP->gs.port.tty = NULL;
513 func_exit();
514 }
515
516
517 /* I haven't the foggiest why the decrement use count has to happen
518 here. The whole linux serial drivers stuff needs to be redesigned.
519 My guess is that this is a hack to minimize the impact of a bug
520 elsewhere. Thinking about it some more. (try it sometime) Try
521 running minicom on a serial port that is driven by a modularized
522 driver. Have the modem hangup. Then remove the driver module. Then
523 exit minicom. I expect an "oops". -- REW */
rio_hungup(void * ptr)524 static void rio_hungup(void *ptr)
525 {
526 struct Port *PortP;
527
528 func_enter();
529
530 PortP = (struct Port *) ptr;
531 PortP->gs.port.tty = NULL;
532
533 func_exit();
534 }
535
536
537 /* The standard serial_close would become shorter if you'd wrap it like
538 this.
539 rs_close (...){save_flags;cli;real_close();dec_use_count;restore_flags;}
540 */
rio_close(void * ptr)541 static void rio_close(void *ptr)
542 {
543 struct Port *PortP;
544
545 func_enter();
546
547 PortP = (struct Port *) ptr;
548
549 riotclose(ptr);
550
551 if (PortP->gs.port.count) {
552 printk(KERN_ERR "WARNING port count:%d\n", PortP->gs.port.count);
553 PortP->gs.port.count = 0;
554 }
555
556 PortP->gs.port.tty = NULL;
557 func_exit();
558 }
559
560
561
rio_fw_ioctl(struct file * filp,unsigned int cmd,unsigned long arg)562 static long rio_fw_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
563 {
564 int rc = 0;
565 func_enter();
566
567 /* The "dev" argument isn't used. */
568 lock_kernel();
569 rc = riocontrol(p, 0, cmd, arg, capable(CAP_SYS_ADMIN));
570 unlock_kernel();
571
572 func_exit();
573 return rc;
574 }
575
576 extern int RIOShortCommand(struct rio_info *p, struct Port *PortP, int command, int len, int arg);
577
rio_ioctl(struct tty_struct * tty,struct file * filp,unsigned int cmd,unsigned long arg)578 static int rio_ioctl(struct tty_struct *tty, struct file *filp, unsigned int cmd, unsigned long arg)
579 {
580 void __user *argp = (void __user *)arg;
581 int rc;
582 struct Port *PortP;
583 int ival;
584
585 func_enter();
586
587 PortP = (struct Port *) tty->driver_data;
588
589 rc = 0;
590 switch (cmd) {
591 case TIOCSSOFTCAR:
592 if ((rc = get_user(ival, (unsigned __user *) argp)) == 0) {
593 tty->termios->c_cflag = (tty->termios->c_cflag & ~CLOCAL) | (ival ? CLOCAL : 0);
594 }
595 break;
596 case TIOCGSERIAL:
597 rc = -EFAULT;
598 if (access_ok(VERIFY_WRITE, argp, sizeof(struct serial_struct)))
599 rc = gs_getserial(&PortP->gs, argp);
600 break;
601 case TCSBRK:
602 if (PortP->State & RIO_DELETED) {
603 rio_dprintk(RIO_DEBUG_TTY, "BREAK on deleted RTA\n");
604 rc = -EIO;
605 } else {
606 if (RIOShortCommand(p, PortP, RIOC_SBREAK, 2, 250) ==
607 RIO_FAIL) {
608 rio_dprintk(RIO_DEBUG_INTR, "SBREAK RIOShortCommand failed\n");
609 rc = -EIO;
610 }
611 }
612 break;
613 case TCSBRKP:
614 if (PortP->State & RIO_DELETED) {
615 rio_dprintk(RIO_DEBUG_TTY, "BREAK on deleted RTA\n");
616 rc = -EIO;
617 } else {
618 int l;
619 l = arg ? arg * 100 : 250;
620 if (l > 255)
621 l = 255;
622 if (RIOShortCommand(p, PortP, RIOC_SBREAK, 2,
623 arg ? arg * 100 : 250) == RIO_FAIL) {
624 rio_dprintk(RIO_DEBUG_INTR, "SBREAK RIOShortCommand failed\n");
625 rc = -EIO;
626 }
627 }
628 break;
629 case TIOCSSERIAL:
630 rc = -EFAULT;
631 if (access_ok(VERIFY_READ, argp, sizeof(struct serial_struct)))
632 rc = gs_setserial(&PortP->gs, argp);
633 break;
634 default:
635 rc = -ENOIOCTLCMD;
636 break;
637 }
638 func_exit();
639 return rc;
640 }
641
642
643 /* The throttle/unthrottle scheme for the Specialix card is different
644 * from other drivers and deserves some explanation.
645 * The Specialix hardware takes care of XON/XOFF
646 * and CTS/RTS flow control itself. This means that all we have to
647 * do when signalled by the upper tty layer to throttle/unthrottle is
648 * to make a note of it here. When we come to read characters from the
649 * rx buffers on the card (rio_receive_chars()) we look to see if the
650 * upper layer can accept more (as noted here in rio_rx_throt[]).
651 * If it can't we simply don't remove chars from the cards buffer.
652 * When the tty layer can accept chars, we again note that here and when
653 * rio_receive_chars() is called it will remove them from the cards buffer.
654 * The card will notice that a ports buffer has drained below some low
655 * water mark and will unflow control the line itself, using whatever
656 * flow control scheme is in use for that port. -- Simon Allen
657 */
658
rio_throttle(struct tty_struct * tty)659 static void rio_throttle(struct tty_struct *tty)
660 {
661 struct Port *port = (struct Port *) tty->driver_data;
662
663 func_enter();
664 /* If the port is using any type of input flow
665 * control then throttle the port.
666 */
667
668 if ((tty->termios->c_cflag & CRTSCTS) || (I_IXOFF(tty))) {
669 port->State |= RIO_THROTTLE_RX;
670 }
671
672 func_exit();
673 }
674
675
rio_unthrottle(struct tty_struct * tty)676 static void rio_unthrottle(struct tty_struct *tty)
677 {
678 struct Port *port = (struct Port *) tty->driver_data;
679
680 func_enter();
681 /* Always unthrottle even if flow control is not enabled on
682 * this port in case we disabled flow control while the port
683 * was throttled
684 */
685
686 port->State &= ~RIO_THROTTLE_RX;
687
688 func_exit();
689 return;
690 }
691
692
693
694
695
696 /* ********************************************************************** *
697 * Here are the initialization routines. *
698 * ********************************************************************** */
699
700
get_VPD_PROM(struct Host * hp)701 static struct vpd_prom *get_VPD_PROM(struct Host *hp)
702 {
703 static struct vpd_prom vpdp;
704 char *p;
705 int i;
706
707 func_enter();
708 rio_dprintk(RIO_DEBUG_PROBE, "Going to verify vpd prom at %p.\n", hp->Caddr + RIO_VPD_ROM);
709
710 p = (char *) &vpdp;
711 for (i = 0; i < sizeof(struct vpd_prom); i++)
712 *p++ = readb(hp->Caddr + RIO_VPD_ROM + i * 2);
713 /* read_rio_byte (hp, RIO_VPD_ROM + i*2); */
714
715 /* Terminate the identifier string.
716 *** requires one extra byte in struct vpd_prom *** */
717 *p++ = 0;
718
719 if (rio_debug & RIO_DEBUG_PROBE)
720 my_hd((char *) &vpdp, 0x20);
721
722 func_exit();
723
724 return &vpdp;
725 }
726
727 static const struct tty_operations rio_ops = {
728 .open = riotopen,
729 .close = gs_close,
730 .write = gs_write,
731 .put_char = gs_put_char,
732 .flush_chars = gs_flush_chars,
733 .write_room = gs_write_room,
734 .chars_in_buffer = gs_chars_in_buffer,
735 .flush_buffer = gs_flush_buffer,
736 .ioctl = rio_ioctl,
737 .throttle = rio_throttle,
738 .unthrottle = rio_unthrottle,
739 .set_termios = gs_set_termios,
740 .stop = gs_stop,
741 .start = gs_start,
742 .hangup = gs_hangup,
743 };
744
rio_init_drivers(void)745 static int rio_init_drivers(void)
746 {
747 int error = -ENOMEM;
748
749 rio_driver = alloc_tty_driver(256);
750 if (!rio_driver)
751 goto out;
752 rio_driver2 = alloc_tty_driver(256);
753 if (!rio_driver2)
754 goto out1;
755
756 func_enter();
757
758 rio_driver->owner = THIS_MODULE;
759 rio_driver->driver_name = "specialix_rio";
760 rio_driver->name = "ttySR";
761 rio_driver->major = RIO_NORMAL_MAJOR0;
762 rio_driver->type = TTY_DRIVER_TYPE_SERIAL;
763 rio_driver->subtype = SERIAL_TYPE_NORMAL;
764 rio_driver->init_termios = tty_std_termios;
765 rio_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
766 rio_driver->flags = TTY_DRIVER_REAL_RAW;
767 tty_set_operations(rio_driver, &rio_ops);
768
769 rio_driver2->owner = THIS_MODULE;
770 rio_driver2->driver_name = "specialix_rio";
771 rio_driver2->name = "ttySR";
772 rio_driver2->major = RIO_NORMAL_MAJOR1;
773 rio_driver2->type = TTY_DRIVER_TYPE_SERIAL;
774 rio_driver2->subtype = SERIAL_TYPE_NORMAL;
775 rio_driver2->init_termios = tty_std_termios;
776 rio_driver2->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
777 rio_driver2->flags = TTY_DRIVER_REAL_RAW;
778 tty_set_operations(rio_driver2, &rio_ops);
779
780 rio_dprintk(RIO_DEBUG_INIT, "set_termios = %p\n", gs_set_termios);
781
782 if ((error = tty_register_driver(rio_driver)))
783 goto out2;
784 if ((error = tty_register_driver(rio_driver2)))
785 goto out3;
786 func_exit();
787 return 0;
788 out3:
789 tty_unregister_driver(rio_driver);
790 out2:
791 put_tty_driver(rio_driver2);
792 out1:
793 put_tty_driver(rio_driver);
794 out:
795 printk(KERN_ERR "rio: Couldn't register a rio driver, error = %d\n", error);
796 return 1;
797 }
798
799 static const struct tty_port_operations rio_port_ops = {
800 .carrier_raised = rio_carrier_raised,
801 };
802
rio_init_datastructures(void)803 static int rio_init_datastructures(void)
804 {
805 int i;
806 struct Port *port;
807 func_enter();
808
809 /* Many drivers statically allocate the maximum number of ports
810 There is no reason not to allocate them dynamically. Is there? -- REW */
811 /* However, the RIO driver allows users to configure their first
812 RTA as the ports numbered 504-511. We therefore need to allocate
813 the whole range. :-( -- REW */
814
815 #define RI_SZ sizeof(struct rio_info)
816 #define HOST_SZ sizeof(struct Host)
817 #define PORT_SZ sizeof(struct Port *)
818 #define TMIO_SZ sizeof(struct termios *)
819 rio_dprintk(RIO_DEBUG_INIT, "getting : %Zd %Zd %Zd %Zd %Zd bytes\n", RI_SZ, RIO_HOSTS * HOST_SZ, RIO_PORTS * PORT_SZ, RIO_PORTS * TMIO_SZ, RIO_PORTS * TMIO_SZ);
820
821 if (!(p = kzalloc(RI_SZ, GFP_KERNEL)))
822 goto free0;
823 if (!(p->RIOHosts = kzalloc(RIO_HOSTS * HOST_SZ, GFP_KERNEL)))
824 goto free1;
825 if (!(p->RIOPortp = kzalloc(RIO_PORTS * PORT_SZ, GFP_KERNEL)))
826 goto free2;
827 p->RIOConf = RIOConf;
828 rio_dprintk(RIO_DEBUG_INIT, "Got : %p %p %p\n", p, p->RIOHosts, p->RIOPortp);
829
830 #if 1
831 for (i = 0; i < RIO_PORTS; i++) {
832 port = p->RIOPortp[i] = kzalloc(sizeof(struct Port), GFP_KERNEL);
833 if (!port) {
834 goto free6;
835 }
836 rio_dprintk(RIO_DEBUG_INIT, "initing port %d (%d)\n", i, port->Mapped);
837 tty_port_init(&port->gs.port);
838 port->gs.port.ops = &rio_port_ops;
839 port->PortNum = i;
840 port->gs.magic = RIO_MAGIC;
841 port->gs.close_delay = HZ / 2;
842 port->gs.closing_wait = 30 * HZ;
843 port->gs.rd = &rio_real_driver;
844 spin_lock_init(&port->portSem);
845 }
846 #else
847 /* We could postpone initializing them to when they are configured. */
848 #endif
849
850
851
852 if (rio_debug & RIO_DEBUG_INIT) {
853 my_hd(&rio_real_driver, sizeof(rio_real_driver));
854 }
855
856
857 func_exit();
858 return 0;
859
860 free6:for (i--; i >= 0; i--)
861 kfree(p->RIOPortp[i]);
862 /*free5:
863 free4:
864 free3:*/ kfree(p->RIOPortp);
865 free2:kfree(p->RIOHosts);
866 free1:
867 rio_dprintk(RIO_DEBUG_INIT, "Not enough memory! %p %p %p\n", p, p->RIOHosts, p->RIOPortp);
868 kfree(p);
869 free0:
870 return -ENOMEM;
871 }
872
rio_release_drivers(void)873 static void __exit rio_release_drivers(void)
874 {
875 func_enter();
876 tty_unregister_driver(rio_driver2);
877 tty_unregister_driver(rio_driver);
878 put_tty_driver(rio_driver2);
879 put_tty_driver(rio_driver);
880 func_exit();
881 }
882
883
884 #ifdef CONFIG_PCI
885 /* This was written for SX, but applies to RIO too...
886 (including bugs....)
887
888 There is another bit besides Bit 17. Turning that bit off
889 (on boards shipped with the fix in the eeprom) results in a
890 hang on the next access to the card.
891 */
892
893 /********************************************************
894 * Setting bit 17 in the CNTRL register of the PLX 9050 *
895 * chip forces a retry on writes while a read is pending.*
896 * This is to prevent the card locking up on Intel Xeon *
897 * multiprocessor systems with the NX chipset. -- NV *
898 ********************************************************/
899
900 /* Newer cards are produced with this bit set from the configuration
901 EEprom. As the bit is read/write for the CPU, we can fix it here,
902 if we detect that it isn't set correctly. -- REW */
903
fix_rio_pci(struct pci_dev * pdev)904 static void fix_rio_pci(struct pci_dev *pdev)
905 {
906 unsigned long hwbase;
907 unsigned char __iomem *rebase;
908 unsigned int t;
909
910 #define CNTRL_REG_OFFSET 0x50
911 #define CNTRL_REG_GOODVALUE 0x18260000
912
913 hwbase = pci_resource_start(pdev, 0);
914 rebase = ioremap(hwbase, 0x80);
915 t = readl(rebase + CNTRL_REG_OFFSET);
916 if (t != CNTRL_REG_GOODVALUE) {
917 printk(KERN_DEBUG "rio: performing cntrl reg fix: %08x -> %08x\n", t, CNTRL_REG_GOODVALUE);
918 writel(CNTRL_REG_GOODVALUE, rebase + CNTRL_REG_OFFSET);
919 }
920 iounmap(rebase);
921 }
922 #endif
923
924
rio_init(void)925 static int __init rio_init(void)
926 {
927 int found = 0;
928 int i;
929 struct Host *hp;
930 int retval;
931 struct vpd_prom *vpdp;
932 int okboard;
933
934 #ifdef CONFIG_PCI
935 struct pci_dev *pdev = NULL;
936 unsigned short tshort;
937 #endif
938
939 func_enter();
940 rio_dprintk(RIO_DEBUG_INIT, "Initing rio module... (rio_debug=%d)\n", rio_debug);
941
942 if (abs((long) (&rio_debug) - rio_debug) < 0x10000) {
943 printk(KERN_WARNING "rio: rio_debug is an address, instead of a value. " "Assuming -1. Was %x/%p.\n", rio_debug, &rio_debug);
944 rio_debug = -1;
945 }
946
947 if (misc_register(&rio_fw_device) < 0) {
948 printk(KERN_ERR "RIO: Unable to register firmware loader driver.\n");
949 return -EIO;
950 }
951
952 retval = rio_init_datastructures();
953 if (retval < 0) {
954 misc_deregister(&rio_fw_device);
955 return retval;
956 }
957 #ifdef CONFIG_PCI
958 /* First look for the JET devices: */
959 while ((pdev = pci_get_device(PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8, pdev))) {
960 u32 tint;
961
962 if (pci_enable_device(pdev))
963 continue;
964
965 /* Specialix has a whole bunch of cards with
966 0x2000 as the device ID. They say its because
967 the standard requires it. Stupid standard. */
968 /* It seems that reading a word doesn't work reliably on 2.0.
969 Also, reading a non-aligned dword doesn't work. So we read the
970 whole dword at 0x2c and extract the word at 0x2e (SUBSYSTEM_ID)
971 ourselves */
972 pci_read_config_dword(pdev, 0x2c, &tint);
973 tshort = (tint >> 16) & 0xffff;
974 rio_dprintk(RIO_DEBUG_PROBE, "Got a specialix card: %x.\n", tint);
975 if (tshort != 0x0100) {
976 rio_dprintk(RIO_DEBUG_PROBE, "But it's not a RIO card (%d)...\n", tshort);
977 continue;
978 }
979 rio_dprintk(RIO_DEBUG_PROBE, "cp1\n");
980
981 hp = &p->RIOHosts[p->RIONumHosts];
982 hp->PaddrP = pci_resource_start(pdev, 2);
983 hp->Ivec = pdev->irq;
984 if (((1 << hp->Ivec) & rio_irqmask) == 0)
985 hp->Ivec = 0;
986 hp->Caddr = ioremap(p->RIOHosts[p->RIONumHosts].PaddrP, RIO_WINDOW_LEN);
987 hp->CardP = (struct DpRam __iomem *) hp->Caddr;
988 hp->Type = RIO_PCI;
989 hp->Copy = rio_copy_to_card;
990 hp->Mode = RIO_PCI_BOOT_FROM_RAM;
991 spin_lock_init(&hp->HostLock);
992 rio_reset_interrupt(hp);
993 rio_start_card_running(hp);
994
995 rio_dprintk(RIO_DEBUG_PROBE, "Going to test it (%p/%p).\n", (void *) p->RIOHosts[p->RIONumHosts].PaddrP, p->RIOHosts[p->RIONumHosts].Caddr);
996 if (RIOBoardTest(p->RIOHosts[p->RIONumHosts].PaddrP, p->RIOHosts[p->RIONumHosts].Caddr, RIO_PCI, 0) == 0) {
997 rio_dprintk(RIO_DEBUG_INIT, "Done RIOBoardTest\n");
998 writeb(0xFF, &p->RIOHosts[p->RIONumHosts].ResetInt);
999 p->RIOHosts[p->RIONumHosts].UniqueNum =
1000 ((readb(&p->RIOHosts[p->RIONumHosts].Unique[0]) & 0xFF) << 0) |
1001 ((readb(&p->RIOHosts[p->RIONumHosts].Unique[1]) & 0xFF) << 8) | ((readb(&p->RIOHosts[p->RIONumHosts].Unique[2]) & 0xFF) << 16) | ((readb(&p->RIOHosts[p->RIONumHosts].Unique[3]) & 0xFF) << 24);
1002 rio_dprintk(RIO_DEBUG_PROBE, "Hmm Tested ok, uniqid = %x.\n", p->RIOHosts[p->RIONumHosts].UniqueNum);
1003
1004 fix_rio_pci(pdev);
1005
1006 p->RIOHosts[p->RIONumHosts].pdev = pdev;
1007 pci_dev_get(pdev);
1008
1009 p->RIOLastPCISearch = 0;
1010 p->RIONumHosts++;
1011 found++;
1012 } else {
1013 iounmap(p->RIOHosts[p->RIONumHosts].Caddr);
1014 p->RIOHosts[p->RIONumHosts].Caddr = NULL;
1015 }
1016 }
1017
1018 /* Then look for the older PCI card.... : */
1019
1020 /* These older PCI cards have problems (only byte-mode access is
1021 supported), which makes them a bit awkward to support.
1022 They also have problems sharing interrupts. Be careful.
1023 (The driver now refuses to share interrupts for these
1024 cards. This should be sufficient).
1025 */
1026
1027 /* Then look for the older RIO/PCI devices: */
1028 while ((pdev = pci_get_device(PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_RIO, pdev))) {
1029 if (pci_enable_device(pdev))
1030 continue;
1031
1032 #ifdef CONFIG_RIO_OLDPCI
1033 hp = &p->RIOHosts[p->RIONumHosts];
1034 hp->PaddrP = pci_resource_start(pdev, 0);
1035 hp->Ivec = pdev->irq;
1036 if (((1 << hp->Ivec) & rio_irqmask) == 0)
1037 hp->Ivec = 0;
1038 hp->Ivec |= 0x8000; /* Mark as non-sharable */
1039 hp->Caddr = ioremap(p->RIOHosts[p->RIONumHosts].PaddrP, RIO_WINDOW_LEN);
1040 hp->CardP = (struct DpRam __iomem *) hp->Caddr;
1041 hp->Type = RIO_PCI;
1042 hp->Copy = rio_copy_to_card;
1043 hp->Mode = RIO_PCI_BOOT_FROM_RAM;
1044 spin_lock_init(&hp->HostLock);
1045
1046 rio_dprintk(RIO_DEBUG_PROBE, "Ivec: %x\n", hp->Ivec);
1047 rio_dprintk(RIO_DEBUG_PROBE, "Mode: %x\n", hp->Mode);
1048
1049 rio_reset_interrupt(hp);
1050 rio_start_card_running(hp);
1051 rio_dprintk(RIO_DEBUG_PROBE, "Going to test it (%p/%p).\n", (void *) p->RIOHosts[p->RIONumHosts].PaddrP, p->RIOHosts[p->RIONumHosts].Caddr);
1052 if (RIOBoardTest(p->RIOHosts[p->RIONumHosts].PaddrP, p->RIOHosts[p->RIONumHosts].Caddr, RIO_PCI, 0) == 0) {
1053 writeb(0xFF, &p->RIOHosts[p->RIONumHosts].ResetInt);
1054 p->RIOHosts[p->RIONumHosts].UniqueNum =
1055 ((readb(&p->RIOHosts[p->RIONumHosts].Unique[0]) & 0xFF) << 0) |
1056 ((readb(&p->RIOHosts[p->RIONumHosts].Unique[1]) & 0xFF) << 8) | ((readb(&p->RIOHosts[p->RIONumHosts].Unique[2]) & 0xFF) << 16) | ((readb(&p->RIOHosts[p->RIONumHosts].Unique[3]) & 0xFF) << 24);
1057 rio_dprintk(RIO_DEBUG_PROBE, "Hmm Tested ok, uniqid = %x.\n", p->RIOHosts[p->RIONumHosts].UniqueNum);
1058
1059 p->RIOHosts[p->RIONumHosts].pdev = pdev;
1060 pci_dev_get(pdev);
1061
1062 p->RIOLastPCISearch = 0;
1063 p->RIONumHosts++;
1064 found++;
1065 } else {
1066 iounmap(p->RIOHosts[p->RIONumHosts].Caddr);
1067 p->RIOHosts[p->RIONumHosts].Caddr = NULL;
1068 }
1069 #else
1070 printk(KERN_ERR "Found an older RIO PCI card, but the driver is not " "compiled to support it.\n");
1071 #endif
1072 }
1073 #endif /* PCI */
1074
1075 /* Now probe for ISA cards... */
1076 for (i = 0; i < NR_RIO_ADDRS; i++) {
1077 hp = &p->RIOHosts[p->RIONumHosts];
1078 hp->PaddrP = rio_probe_addrs[i];
1079 /* There was something about the IRQs of these cards. 'Forget what.--REW */
1080 hp->Ivec = 0;
1081 hp->Caddr = ioremap(p->RIOHosts[p->RIONumHosts].PaddrP, RIO_WINDOW_LEN);
1082 hp->CardP = (struct DpRam __iomem *) hp->Caddr;
1083 hp->Type = RIO_AT;
1084 hp->Copy = rio_copy_to_card; /* AT card PCI???? - PVDL
1085 * -- YES! this is now a normal copy. Only the
1086 * old PCI card uses the special PCI copy.
1087 * Moreover, the ISA card will work with the
1088 * special PCI copy anyway. -- REW */
1089 hp->Mode = 0;
1090 spin_lock_init(&hp->HostLock);
1091
1092 vpdp = get_VPD_PROM(hp);
1093 rio_dprintk(RIO_DEBUG_PROBE, "Got VPD ROM\n");
1094 okboard = 0;
1095 if ((strncmp(vpdp->identifier, RIO_ISA_IDENT, 16) == 0) || (strncmp(vpdp->identifier, RIO_ISA2_IDENT, 16) == 0) || (strncmp(vpdp->identifier, RIO_ISA3_IDENT, 16) == 0)) {
1096 /* Board is present... */
1097 if (RIOBoardTest(hp->PaddrP, hp->Caddr, RIO_AT, 0) == 0) {
1098 /* ... and feeling fine!!!! */
1099 rio_dprintk(RIO_DEBUG_PROBE, "Hmm Tested ok, uniqid = %x.\n", p->RIOHosts[p->RIONumHosts].UniqueNum);
1100 if (RIOAssignAT(p, hp->PaddrP, hp->Caddr, 0)) {
1101 rio_dprintk(RIO_DEBUG_PROBE, "Hmm Tested ok, host%d uniqid = %x.\n", p->RIONumHosts, p->RIOHosts[p->RIONumHosts - 1].UniqueNum);
1102 okboard++;
1103 found++;
1104 }
1105 }
1106
1107 if (!okboard) {
1108 iounmap(hp->Caddr);
1109 hp->Caddr = NULL;
1110 }
1111 }
1112 }
1113
1114
1115 for (i = 0; i < p->RIONumHosts; i++) {
1116 hp = &p->RIOHosts[i];
1117 if (hp->Ivec) {
1118 int mode = IRQF_SHARED;
1119 if (hp->Ivec & 0x8000) {
1120 mode = 0;
1121 hp->Ivec &= 0x7fff;
1122 }
1123 rio_dprintk(RIO_DEBUG_INIT, "Requesting interrupt hp: %p rio_interrupt: %d Mode: %x\n", hp, hp->Ivec, hp->Mode);
1124 retval = request_irq(hp->Ivec, rio_interrupt, mode, "rio", hp);
1125 rio_dprintk(RIO_DEBUG_INIT, "Return value from request_irq: %d\n", retval);
1126 if (retval) {
1127 printk(KERN_ERR "rio: Cannot allocate irq %d.\n", hp->Ivec);
1128 hp->Ivec = 0;
1129 }
1130 rio_dprintk(RIO_DEBUG_INIT, "Got irq %d.\n", hp->Ivec);
1131 if (hp->Ivec != 0) {
1132 rio_dprintk(RIO_DEBUG_INIT, "Enabling interrupts on rio card.\n");
1133 hp->Mode |= RIO_PCI_INT_ENABLE;
1134 } else
1135 hp->Mode &= ~RIO_PCI_INT_ENABLE;
1136 rio_dprintk(RIO_DEBUG_INIT, "New Mode: %x\n", hp->Mode);
1137 rio_start_card_running(hp);
1138 }
1139 /* Init the timer "always" to make sure that it can safely be
1140 deleted when we unload... */
1141
1142 setup_timer(&hp->timer, rio_pollfunc, i);
1143 if (!hp->Ivec) {
1144 rio_dprintk(RIO_DEBUG_INIT, "Starting polling at %dj intervals.\n", rio_poll);
1145 mod_timer(&hp->timer, jiffies + rio_poll);
1146 }
1147 }
1148
1149 if (found) {
1150 rio_dprintk(RIO_DEBUG_INIT, "rio: total of %d boards detected.\n", found);
1151 rio_init_drivers();
1152 } else {
1153 /* deregister the misc device we created earlier */
1154 misc_deregister(&rio_fw_device);
1155 }
1156
1157 func_exit();
1158 return found ? 0 : -EIO;
1159 }
1160
1161
rio_exit(void)1162 static void __exit rio_exit(void)
1163 {
1164 int i;
1165 struct Host *hp;
1166
1167 func_enter();
1168
1169 for (i = 0, hp = p->RIOHosts; i < p->RIONumHosts; i++, hp++) {
1170 RIOHostReset(hp->Type, hp->CardP, hp->Slot);
1171 if (hp->Ivec) {
1172 free_irq(hp->Ivec, hp);
1173 rio_dprintk(RIO_DEBUG_INIT, "freed irq %d.\n", hp->Ivec);
1174 }
1175 /* It is safe/allowed to del_timer a non-active timer */
1176 del_timer_sync(&hp->timer);
1177 if (hp->Caddr)
1178 iounmap(hp->Caddr);
1179 if (hp->Type == RIO_PCI)
1180 pci_dev_put(hp->pdev);
1181 }
1182
1183 if (misc_deregister(&rio_fw_device) < 0) {
1184 printk(KERN_INFO "rio: couldn't deregister control-device\n");
1185 }
1186
1187
1188 rio_dprintk(RIO_DEBUG_CLEANUP, "Cleaning up drivers\n");
1189
1190 rio_release_drivers();
1191
1192 /* Release dynamically allocated memory */
1193 kfree(p->RIOPortp);
1194 kfree(p->RIOHosts);
1195 kfree(p);
1196
1197 func_exit();
1198 }
1199
1200 module_init(rio_init);
1201 module_exit(rio_exit);
1202