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