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