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