]> bbs.cooldavid.org Git - net-next-2.6.git/blame - drivers/char/epca.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Linux-2.6.12-rc2
[net-next-2.6.git] / drivers / char / epca.c
CommitLineData
1da177e4
LT		 1/*
2
3
4 Copyright (C) 1996 Digi International.
5
6 For technical support please email digiLinux@dgii.com or
7 call Digi tech support at (612) 912-3456
8
9 Much of this design and code came from epca.c which was
10 copyright (C) 1994, 1995 Troy De Jongh, and subsquently
11 modified by David Nugent, Christoph Lameter, Mike McLagan.
12
13 This program is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 2 of the License, or
16 (at your option) any later version.
17
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
22
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software
25 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26
27--------------------------------------------------------------------------- */
28/* See README.epca for change history --DAT*/
29
30
31#include <linux/config.h>
32#include <linux/module.h>
33#include <linux/kernel.h>
34#include <linux/types.h>
35#include <linux/init.h>
36#include <linux/serial.h>
37#include <linux/delay.h>
38#include <linux/ctype.h>
39#include <linux/tty.h>
40#include <linux/tty_flip.h>
41#include <linux/slab.h>
42#include <linux/ioport.h>
43#include <linux/interrupt.h>
44#include <asm/uaccess.h>
45#include <asm/io.h>
46
47#ifdef CONFIG_PCI
48#define ENABLE_PCI
49#endif /* CONFIG_PCI */
50
51#define putUser(arg1, arg2) put_user(arg1, (unsigned long __user *)arg2)
52#define getUser(arg1, arg2) get_user(arg1, (unsigned __user *)arg2)
53
54#ifdef ENABLE_PCI
55#include <linux/pci.h>
56#include "digiPCI.h"
57#endif /* ENABLE_PCI */
58
59#include "digi1.h"
60#include "digiFep1.h"
61#include "epca.h"
62#include "epcaconfig.h"
63
64#if BITS_PER_LONG != 32
65# error FIXME: this driver only works on 32-bit platforms
66#endif
67
68/* ---------------------- Begin defines ------------------------ */
69
70#define VERSION "1.3.0.1-LK"
71
72/* This major needs to be submitted to Linux to join the majors list */
73
74#define DIGIINFOMAJOR 35 /* For Digi specific ioctl */
75
76
77#define MAXCARDS 7
78#define epcaassert(x, msg) if (!(x)) epca_error(__LINE__, msg)
79
80#define PFX "epca: "
81
82/* ----------------- Begin global definitions ------------------- */
83
84static char mesg[100];
85static int nbdevs, num_cards, liloconfig;
86static int digi_poller_inhibited = 1 ;
87
88static int setup_error_code;
89static int invalid_lilo_config;
90
91/* -----------------------------------------------------------------------
92 MAXBOARDS is typically 12, but ISA and EISA cards are restricted to
93 7 below.
94--------------------------------------------------------------------------*/
95static struct board_info boards[MAXBOARDS];
96
97
98/* ------------- Begin structures used for driver registeration ---------- */
99
100static struct tty_driver *pc_driver;
101static struct tty_driver *pc_info;
102
103/* ------------------ Begin Digi specific structures -------------------- */
104
105/* ------------------------------------------------------------------------
106 digi_channels represents an array of structures that keep track of
107 each channel of the Digi product. Information such as transmit and
108 receive pointers, termio data, and signal definitions (DTR, CTS, etc ...)
109 are stored here. This structure is NOT used to overlay the cards
110 physical channel structure.
111-------------------------------------------------------------------------- */
112
113static struct channel digi_channels[MAX_ALLOC];
114
115/* ------------------------------------------------------------------------
116 card_ptr is an array used to hold the address of the
117 first channel structure of each card. This array will hold
118 the addresses of various channels located in digi_channels.
119-------------------------------------------------------------------------- */
120static struct channel *card_ptr[MAXCARDS];
121
122static struct timer_list epca_timer;
123
124/* ---------------------- Begin function prototypes --------------------- */
125
126/* ----------------------------------------------------------------------
127 Begin generic memory functions. These functions will be alias
128 (point at) more specific functions dependent on the board being
129 configured.
130----------------------------------------------------------------------- */
131
132static inline void memwinon(struct board_info *b, unsigned int win);
133static inline void memwinoff(struct board_info *b, unsigned int win);
134static inline void globalwinon(struct channel *ch);
135static inline void rxwinon(struct channel *ch);
136static inline void txwinon(struct channel *ch);
137static inline void memoff(struct channel *ch);
138static inline void assertgwinon(struct channel *ch);
139static inline void assertmemoff(struct channel *ch);
140
141/* ---- Begin more 'specific' memory functions for cx_like products --- */
142
143static inline void pcxem_memwinon(struct board_info *b, unsigned int win);
144static inline void pcxem_memwinoff(struct board_info *b, unsigned int win);
145static inline void pcxem_globalwinon(struct channel *ch);
146static inline void pcxem_rxwinon(struct channel *ch);
147static inline void pcxem_txwinon(struct channel *ch);
148static inline void pcxem_memoff(struct channel *ch);
149
150/* ------ Begin more 'specific' memory functions for the pcxe ------- */
151
152static inline void pcxe_memwinon(struct board_info *b, unsigned int win);
153static inline void pcxe_memwinoff(struct board_info *b, unsigned int win);
154static inline void pcxe_globalwinon(struct channel *ch);
155static inline void pcxe_rxwinon(struct channel *ch);
156static inline void pcxe_txwinon(struct channel *ch);
157static inline void pcxe_memoff(struct channel *ch);
158
159/* ---- Begin more 'specific' memory functions for the pc64xe and pcxi ---- */
160/* Note : pc64xe and pcxi share the same windowing routines */
161
162static inline void pcxi_memwinon(struct board_info *b, unsigned int win);
163static inline void pcxi_memwinoff(struct board_info *b, unsigned int win);
164static inline void pcxi_globalwinon(struct channel *ch);
165static inline void pcxi_rxwinon(struct channel *ch);
166static inline void pcxi_txwinon(struct channel *ch);
167static inline void pcxi_memoff(struct channel *ch);
168
169/* - Begin 'specific' do nothing memory functions needed for some cards - */
170
171static inline void dummy_memwinon(struct board_info *b, unsigned int win);
172static inline void dummy_memwinoff(struct board_info *b, unsigned int win);
173static inline void dummy_globalwinon(struct channel *ch);
174static inline void dummy_rxwinon(struct channel *ch);
175static inline void dummy_txwinon(struct channel *ch);
176static inline void dummy_memoff(struct channel *ch);
177static inline void dummy_assertgwinon(struct channel *ch);
178static inline void dummy_assertmemoff(struct channel *ch);
179
180/* ------------------- Begin declare functions ----------------------- */
181
182static inline struct channel *verifyChannel(register struct tty_struct *);
183static inline void pc_sched_event(struct channel *, int);
184static void epca_error(int, char *);
185static void pc_close(struct tty_struct *, struct file *);
186static void shutdown(struct channel *);
187static void pc_hangup(struct tty_struct *);
188static void pc_put_char(struct tty_struct *, unsigned char);
189static int pc_write_room(struct tty_struct *);
190static int pc_chars_in_buffer(struct tty_struct *);
191static void pc_flush_buffer(struct tty_struct *);
192static void pc_flush_chars(struct tty_struct *);
193static int block_til_ready(struct tty_struct *, struct file *,
194 struct channel *);
195static int pc_open(struct tty_struct *, struct file *);
196static void post_fep_init(unsigned int crd);
197static void epcapoll(unsigned long);
198static void doevent(int);
199static void fepcmd(struct channel *, int, int, int, int, int);
200static unsigned termios2digi_h(struct channel *ch, unsigned);
201static unsigned termios2digi_i(struct channel *ch, unsigned);
202static unsigned termios2digi_c(struct channel *ch, unsigned);
203static void epcaparam(struct tty_struct *, struct channel *);
204static void receive_data(struct channel *);
205static int pc_ioctl(struct tty_struct *, struct file *,
206 unsigned int, unsigned long);
207static int info_ioctl(struct tty_struct *, struct file *,
208 unsigned int, unsigned long);
209static void pc_set_termios(struct tty_struct *, struct termios *);
210static void do_softint(void *);
211static void pc_stop(struct tty_struct *);
212static void pc_start(struct tty_struct *);
213static void pc_throttle(struct tty_struct * tty);
214static void pc_unthrottle(struct tty_struct *tty);
215static void digi_send_break(struct channel *ch, int msec);
216static void setup_empty_event(struct tty_struct *tty, struct channel *ch);
217void epca_setup(char *, int *);
218void console_print(const char *);
219
220static int get_termio(struct tty_struct *, struct termio __user *);
221static int pc_write(struct tty_struct *, const unsigned char *, int);
222int pc_init(void);
223
224#ifdef ENABLE_PCI
225static int init_PCI(void);
226#endif /* ENABLE_PCI */
227
228
229/* ------------------------------------------------------------------
230 Table of functions for each board to handle memory. Mantaining
231 parallelism is a *very* good idea here. The idea is for the
232 runtime code to blindly call these functions, not knowing/caring
233 about the underlying hardware. This stuff should contain no
234 conditionals; if more functionality is needed a different entry
235 should be established. These calls are the interface calls and
236 are the only functions that should be accessed. Anyone caught
237 making direct calls deserves what they get.
238-------------------------------------------------------------------- */
239
240static inline void memwinon(struct board_info *b, unsigned int win)
241{
242 (b->memwinon)(b, win);
243}
244
245static inline void memwinoff(struct board_info *b, unsigned int win)
246{
247 (b->memwinoff)(b, win);
248}
249
250static inline void globalwinon(struct channel *ch)
251{
252 (ch->board->globalwinon)(ch);
253}
254
255static inline void rxwinon(struct channel *ch)
256{
257 (ch->board->rxwinon)(ch);
258}
259
260static inline void txwinon(struct channel *ch)
261{
262 (ch->board->txwinon)(ch);
263}
264
265static inline void memoff(struct channel *ch)
266{
267 (ch->board->memoff)(ch);
268}
269static inline void assertgwinon(struct channel *ch)
270{
271 (ch->board->assertgwinon)(ch);
272}
273
274static inline void assertmemoff(struct channel *ch)
275{
276 (ch->board->assertmemoff)(ch);
277}
278
279/* ---------------------------------------------------------
280 PCXEM windowing is the same as that used in the PCXR
281 and CX series cards.
282------------------------------------------------------------ */
283
284static inline void pcxem_memwinon(struct board_info *b, unsigned int win)
285{
286 outb_p(FEPWIN|win, (int)b->port + 1);
287}
288
289static inline void pcxem_memwinoff(struct board_info *b, unsigned int win)
290{
291 outb_p(0, (int)b->port + 1);
292}
293
294static inline void pcxem_globalwinon(struct channel *ch)
295{
296 outb_p( FEPWIN, (int)ch->board->port + 1);
297}
298
299static inline void pcxem_rxwinon(struct channel *ch)
300{
301 outb_p(ch->rxwin, (int)ch->board->port + 1);
302}
303
304static inline void pcxem_txwinon(struct channel *ch)
305{
306 outb_p(ch->txwin, (int)ch->board->port + 1);
307}
308
309static inline void pcxem_memoff(struct channel *ch)
310{
311 outb_p(0, (int)ch->board->port + 1);
312}
313
314/* ----------------- Begin pcxe memory window stuff ------------------ */
315
316static inline void pcxe_memwinon(struct board_info *b, unsigned int win)
317{
318 outb_p(FEPWIN | win, (int)b->port + 1);
319}
320
321static inline void pcxe_memwinoff(struct board_info *b, unsigned int win)
322{
323 outb_p(inb((int)b->port) & ~FEPMEM,
324 (int)b->port + 1);
325 outb_p(0, (int)b->port + 1);
326}
327
328static inline void pcxe_globalwinon(struct channel *ch)
329{
330 outb_p( FEPWIN, (int)ch->board->port + 1);
331}
332
333static inline void pcxe_rxwinon(struct channel *ch)
334{
335 outb_p(ch->rxwin, (int)ch->board->port + 1);
336}
337
338static inline void pcxe_txwinon(struct channel *ch)
339{
340 outb_p(ch->txwin, (int)ch->board->port + 1);
341}
342
343static inline void pcxe_memoff(struct channel *ch)
344{
345 outb_p(0, (int)ch->board->port);
346 outb_p(0, (int)ch->board->port + 1);
347}
348
349/* ------------- Begin pc64xe and pcxi memory window stuff -------------- */
350
351static inline void pcxi_memwinon(struct board_info *b, unsigned int win)
352{
353 outb_p(inb((int)b->port) | FEPMEM, (int)b->port);
354}
355
356static inline void pcxi_memwinoff(struct board_info *b, unsigned int win)
357{
358 outb_p(inb((int)b->port) & ~FEPMEM, (int)b->port);
359}
360
361static inline void pcxi_globalwinon(struct channel *ch)
362{
363 outb_p(FEPMEM, (int)ch->board->port);
364}
365
366static inline void pcxi_rxwinon(struct channel *ch)
367{
368 outb_p(FEPMEM, (int)ch->board->port);
369}
370
371static inline void pcxi_txwinon(struct channel *ch)
372{
373 outb_p(FEPMEM, (int)ch->board->port);
374}
375
376static inline void pcxi_memoff(struct channel *ch)
377{
378 outb_p(0, (int)ch->board->port);
379}
380
381static inline void pcxi_assertgwinon(struct channel *ch)
382{
383 epcaassert(inb((int)ch->board->port) & FEPMEM, "Global memory off");
384}
385
386static inline void pcxi_assertmemoff(struct channel *ch)
387{
388 epcaassert(!(inb((int)ch->board->port) & FEPMEM), "Memory on");
389}
390
391
392/* ----------------------------------------------------------------------
393 Not all of the cards need specific memory windowing routines. Some
394 cards (Such as PCI) needs no windowing routines at all. We provide
395 these do nothing routines so that the same code base can be used.
396 The driver will ALWAYS call a windowing routine if it thinks it needs
397 to; regardless of the card. However, dependent on the card the routine
398 may or may not do anything.
399---------------------------------------------------------------------------*/
400
401static inline void dummy_memwinon(struct board_info *b, unsigned int win)
402{
403}
404
405static inline void dummy_memwinoff(struct board_info *b, unsigned int win)
406{
407}
408
409static inline void dummy_globalwinon(struct channel *ch)
410{
411}
412
413static inline void dummy_rxwinon(struct channel *ch)
414{
415}
416
417static inline void dummy_txwinon(struct channel *ch)
418{
419}
420
421static inline void dummy_memoff(struct channel *ch)
422{
423}
424
425static inline void dummy_assertgwinon(struct channel *ch)
426{
427}
428
429static inline void dummy_assertmemoff(struct channel *ch)
430{
431}
432
433/* ----------------- Begin verifyChannel function ----------------------- */
434static inline struct channel *verifyChannel(register struct tty_struct *tty)
435{ /* Begin verifyChannel */
436
437 /* --------------------------------------------------------------------
438 This routine basically provides a sanity check. It insures that
439 the channel returned is within the proper range of addresses as
440 well as properly initialized. If some bogus info gets passed in
441 through tty->driver_data this should catch it.
442 --------------------------------------------------------------------- */
443
444 if (tty)
445 { /* Begin if tty */
446
447 register struct channel *ch = (struct channel *)tty->driver_data;
448
449 if ((ch >= &digi_channels[0]) && (ch < &digi_channels[nbdevs]))
450 {
451 if (ch->magic == EPCA_MAGIC)
452 return ch;
453 }
454
455 } /* End if tty */
456
457 /* Else return a NULL for invalid */
458 return NULL;
459
460} /* End verifyChannel */
461
462/* ------------------ Begin pc_sched_event ------------------------- */
463
464static inline void pc_sched_event(struct channel *ch, int event)
465{ /* Begin pc_sched_event */
466
467
468 /* ----------------------------------------------------------------------
469 We call this to schedule interrupt processing on some event. The
470 kernel sees our request and calls the related routine in OUR driver.
471 -------------------------------------------------------------------------*/
472
473 ch->event |= 1 << event;
474 schedule_work(&ch->tqueue);
475
476
477} /* End pc_sched_event */
478
479/* ------------------ Begin epca_error ------------------------- */
480
481static void epca_error(int line, char *msg)
482{ /* Begin epca_error */
483
484 printk(KERN_ERR "epca_error (Digi): line = %d %s\n",line,msg);
485 return;
486
487} /* End epca_error */
488
489/* ------------------ Begin pc_close ------------------------- */
490static void pc_close(struct tty_struct * tty, struct file * filp)
491{ /* Begin pc_close */
492
493 struct channel *ch;
494 unsigned long flags;
495
496 /* ---------------------------------------------------------
497 verifyChannel returns the channel from the tty struct
498 if it is valid. This serves as a sanity check.
499 ------------------------------------------------------------- */
500
501 if ((ch = verifyChannel(tty)) != NULL)
502 { /* Begin if ch != NULL */
503
504 save_flags(flags);
505 cli();
506
507 if (tty_hung_up_p(filp))
508 {
509 restore_flags(flags);
510 return;
511 }
512
513 /* Check to see if the channel is open more than once */
514 if (ch->count-- > 1)
515 { /* Begin channel is open more than once */
516
517 /* -------------------------------------------------------------
518 Return without doing anything. Someone might still be using
519 the channel.
520 ---------------------------------------------------------------- */
521
522 restore_flags(flags);
523 return;
524 } /* End channel is open more than once */
525
526 /* Port open only once go ahead with shutdown & reset */
527
528 if (ch->count < 0)
529 {
530 ch->count = 0;
531 }
532
533 /* ---------------------------------------------------------------
534 Let the rest of the driver know the channel is being closed.
535 This becomes important if an open is attempted before close
536 is finished.
537 ------------------------------------------------------------------ */
538
539 ch->asyncflags |= ASYNC_CLOSING;
540
541 tty->closing = 1;
542
543 if (ch->asyncflags & ASYNC_INITIALIZED)
544 {
545 /* Setup an event to indicate when the transmit buffer empties */
546 setup_empty_event(tty, ch);
547 tty_wait_until_sent(tty, 3000); /* 30 seconds timeout */
548 }
549
550 if (tty->driver->flush_buffer)
551 tty->driver->flush_buffer(tty);
552
553 tty_ldisc_flush(tty);
554 shutdown(ch);
555 tty->closing = 0;
556 ch->event = 0;
557 ch->tty = NULL;
558
559 if (ch->blocked_open)
560 { /* Begin if blocked_open */
561
562 if (ch->close_delay)
563 {
564 msleep_interruptible(jiffies_to_msecs(ch->close_delay));
565 }
566
567 wake_up_interruptible(&ch->open_wait);
568
569 } /* End if blocked_open */
570
571 ch->asyncflags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_INITIALIZED |
572 ASYNC_CLOSING);
573 wake_up_interruptible(&ch->close_wait);
574
575
576 restore_flags(flags);
577
578 } /* End if ch != NULL */
579
580} /* End pc_close */
581
582/* ------------------ Begin shutdown ------------------------- */
583
584static void shutdown(struct channel *ch)
585{ /* Begin shutdown */
586
587 unsigned long flags;
588 struct tty_struct *tty;
589 volatile struct board_chan *bc;
590
591 if (!(ch->asyncflags & ASYNC_INITIALIZED))
592 return;
593
594 save_flags(flags);
595 cli();
596 globalwinon(ch);
597
598 bc = ch->brdchan;
599
600 /* ------------------------------------------------------------------
601 In order for an event to be generated on the receipt of data the
602 idata flag must be set. Since we are shutting down, this is not
603 necessary clear this flag.
604 --------------------------------------------------------------------- */
605
606 if (bc)
607 bc->idata = 0;
608
609 tty = ch->tty;
610
611 /* ----------------------------------------------------------------
612 If we're a modem control device and HUPCL is on, drop RTS & DTR.
613 ------------------------------------------------------------------ */
614
615 if (tty->termios->c_cflag & HUPCL)
616 {
617 ch->omodem &= ~(ch->m_rts | ch->m_dtr);
618 fepcmd(ch, SETMODEM, 0, ch->m_dtr | ch->m_rts, 10, 1);
619 }
620
621 memoff(ch);
622
623 /* ------------------------------------------------------------------
624 The channel has officialy been closed. The next time it is opened
625 it will have to reinitialized. Set a flag to indicate this.
626 ---------------------------------------------------------------------- */
627
628 /* Prevent future Digi programmed interrupts from coming active */
629
630 ch->asyncflags &= ~ASYNC_INITIALIZED;
631 restore_flags(flags);
632
633} /* End shutdown */
634
635/* ------------------ Begin pc_hangup ------------------------- */
636
637static void pc_hangup(struct tty_struct *tty)
638{ /* Begin pc_hangup */
639
640 struct channel *ch;
641
642 /* ---------------------------------------------------------
643 verifyChannel returns the channel from the tty struct
644 if it is valid. This serves as a sanity check.
645 ------------------------------------------------------------- */
646
647 if ((ch = verifyChannel(tty)) != NULL)
648 { /* Begin if ch != NULL */
649
650 unsigned long flags;
651
652 save_flags(flags);
653 cli();
654 if (tty->driver->flush_buffer)
655 tty->driver->flush_buffer(tty);
656 tty_ldisc_flush(tty);
657 shutdown(ch);
658
659 ch->tty = NULL;
660 ch->event = 0;
661 ch->count = 0;
662 restore_flags(flags);
663 ch->asyncflags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_INITIALIZED);
664 wake_up_interruptible(&ch->open_wait);
665
666 } /* End if ch != NULL */
667
668} /* End pc_hangup */
669
670/* ------------------ Begin pc_write ------------------------- */
671
672static int pc_write(struct tty_struct * tty,
673 const unsigned char *buf, int bytesAvailable)
674{ /* Begin pc_write */
675
676 register unsigned int head, tail;
677 register int dataLen;
678 register int size;
679 register int amountCopied;
680
681
682 struct channel *ch;
683 unsigned long flags;
684 int remain;
685 volatile struct board_chan *bc;
686
687
688 /* ----------------------------------------------------------------
689 pc_write is primarily called directly by the kernel routine
690 tty_write (Though it can also be called by put_char) found in
691 tty_io.c. pc_write is passed a line discipline buffer where
692 the data to be written out is stored. The line discipline
693 implementation itself is done at the kernel level and is not
694 brought into the driver.
695 ------------------------------------------------------------------- */
696
697 /* ---------------------------------------------------------
698 verifyChannel returns the channel from the tty struct
699 if it is valid. This serves as a sanity check.
700 ------------------------------------------------------------- */
701
702 if ((ch = verifyChannel(tty)) == NULL)
703 return 0;
704
705 /* Make a pointer to the channel data structure found on the board. */
706
707 bc = ch->brdchan;
708 size = ch->txbufsize;
709
710 amountCopied = 0;
711 save_flags(flags);
712 cli();
713
714 globalwinon(ch);
715
716 head = bc->tin & (size - 1);
717 tail = bc->tout;
718
719 if (tail != bc->tout)
720 tail = bc->tout;
721 tail &= (size - 1);
722
723 /* If head >= tail, head has not wrapped around. */
724 if (head >= tail)
725 { /* Begin head has not wrapped */
726
727 /* ---------------------------------------------------------------
728 remain (much like dataLen above) represents the total amount of
729 space available on the card for data. Here dataLen represents
730 the space existing between the head pointer and the end of
731 buffer. This is important because a memcpy cannot be told to
732 automatically wrap around when it hits the buffer end.
733 ------------------------------------------------------------------ */
734
735 dataLen = size - head;
736 remain = size - (head - tail) - 1;
737
738 } /* End head has not wrapped */
739 else
740 { /* Begin head has wrapped around */
741
742 remain = tail - head - 1;
743 dataLen = remain;
744
745 } /* End head has wrapped around */
746
747 /* -------------------------------------------------------------------
748 Check the space on the card. If we have more data than
749 space; reduce the amount of data to fit the space.
750 ---------------------------------------------------------------------- */
751
752 bytesAvailable = min(remain, bytesAvailable);
753
754 txwinon(ch);
755 while (bytesAvailable > 0)
756 { /* Begin while there is data to copy onto card */
757
758 /* -----------------------------------------------------------------
759 If head is not wrapped, the below will make sure the first
760 data copy fills to the end of card buffer.
761 ------------------------------------------------------------------- */
762
763 dataLen = min(bytesAvailable, dataLen);
764 memcpy(ch->txptr + head, buf, dataLen);
765 buf += dataLen;
766 head += dataLen;
767 amountCopied += dataLen;
768 bytesAvailable -= dataLen;
769
770 if (head >= size)
771 {
772 head = 0;
773 dataLen = tail;
774 }
775
776 } /* End while there is data to copy onto card */
777
778 ch->statusflags |= TXBUSY;
779 globalwinon(ch);
780 bc->tin = head;
781
782 if ((ch->statusflags & LOWWAIT) == 0)
783 {
784 ch->statusflags |= LOWWAIT;
785 bc->ilow = 1;
786 }
787 memoff(ch);
788 restore_flags(flags);
789
790 return(amountCopied);
791
792} /* End pc_write */
793
794/* ------------------ Begin pc_put_char ------------------------- */
795
796static void pc_put_char(struct tty_struct *tty, unsigned char c)
797{ /* Begin pc_put_char */
798
799
800 pc_write(tty, &c, 1);
801 return;
802
803} /* End pc_put_char */
804
805/* ------------------ Begin pc_write_room ------------------------- */
806
807static int pc_write_room(struct tty_struct *tty)
808{ /* Begin pc_write_room */
809
810 int remain;
811 struct channel *ch;
812 unsigned long flags;
813 unsigned int head, tail;
814 volatile struct board_chan *bc;
815
816 remain = 0;
817
818 /* ---------------------------------------------------------
819 verifyChannel returns the channel from the tty struct
820 if it is valid. This serves as a sanity check.
821 ------------------------------------------------------------- */
822
823 if ((ch = verifyChannel(tty)) != NULL)
824 {
825 save_flags(flags);
826 cli();
827 globalwinon(ch);
828
829 bc = ch->brdchan;
830 head = bc->tin & (ch->txbufsize - 1);
831 tail = bc->tout;
832
833 if (tail != bc->tout)
834 tail = bc->tout;
835 /* Wrap tail if necessary */
836 tail &= (ch->txbufsize - 1);
837
838 if ((remain = tail - head - 1) < 0 )
839 remain += ch->txbufsize;
840
841 if (remain && (ch->statusflags & LOWWAIT) == 0)
842 {
843 ch->statusflags |= LOWWAIT;
844 bc->ilow = 1;
845 }
846 memoff(ch);
847 restore_flags(flags);
848 }
849
850 /* Return how much room is left on card */
851 return remain;
852
853} /* End pc_write_room */
854
855/* ------------------ Begin pc_chars_in_buffer ---------------------- */
856
857static int pc_chars_in_buffer(struct tty_struct *tty)
858{ /* Begin pc_chars_in_buffer */
859
860 int chars;
861 unsigned int ctail, head, tail;
862 int remain;
863 unsigned long flags;
864 struct channel *ch;
865 volatile struct board_chan *bc;
866
867
868 /* ---------------------------------------------------------
869 verifyChannel returns the channel from the tty struct
870 if it is valid. This serves as a sanity check.
871 ------------------------------------------------------------- */
872
873 if ((ch = verifyChannel(tty)) == NULL)
874 return(0);
875
876 save_flags(flags);
877 cli();
878 globalwinon(ch);
879
880 bc = ch->brdchan;
881 tail = bc->tout;
882 head = bc->tin;
883 ctail = ch->mailbox->cout;
884
885 if (tail == head && ch->mailbox->cin == ctail && bc->tbusy == 0)
886 chars = 0;
887 else
888 { /* Begin if some space on the card has been used */
889
890 head = bc->tin & (ch->txbufsize - 1);
891 tail &= (ch->txbufsize - 1);
892
893 /* --------------------------------------------------------------
894 The logic here is basically opposite of the above pc_write_room
895 here we are finding the amount of bytes in the buffer filled.
896 Not the amount of bytes empty.
897 ------------------------------------------------------------------- */
898
899 if ((remain = tail - head - 1) < 0 )
900 remain += ch->txbufsize;
901
902 chars = (int)(ch->txbufsize - remain);
903
904 /* -------------------------------------------------------------
905 Make it possible to wakeup anything waiting for output
906 in tty_ioctl.c, etc.
907
908 If not already set. Setup an event to indicate when the
909 transmit buffer empties
910 ----------------------------------------------------------------- */
911
912 if (!(ch->statusflags & EMPTYWAIT))
913 setup_empty_event(tty,ch);
914
915 } /* End if some space on the card has been used */
916
917 memoff(ch);
918 restore_flags(flags);
919
920 /* Return number of characters residing on card. */
921 return(chars);
922
923} /* End pc_chars_in_buffer */
924
925/* ------------------ Begin pc_flush_buffer ---------------------- */
926
927static void pc_flush_buffer(struct tty_struct *tty)
928{ /* Begin pc_flush_buffer */
929
930 unsigned int tail;
931 unsigned long flags;
932 struct channel *ch;
933 volatile struct board_chan *bc;
934
935
936 /* ---------------------------------------------------------
937 verifyChannel returns the channel from the tty struct
938 if it is valid. This serves as a sanity check.
939 ------------------------------------------------------------- */
940
941 if ((ch = verifyChannel(tty)) == NULL)
942 return;
943
944 save_flags(flags);
945 cli();
946
947 globalwinon(ch);
948
949 bc = ch->brdchan;
950 tail = bc->tout;
951
952 /* Have FEP move tout pointer; effectively flushing transmit buffer */
953
954 fepcmd(ch, STOUT, (unsigned) tail, 0, 0, 0);
955
956 memoff(ch);
957 restore_flags(flags);
958
959 wake_up_interruptible(&tty->write_wait);
960 tty_wakeup(tty);
961
962} /* End pc_flush_buffer */
963
964/* ------------------ Begin pc_flush_chars ---------------------- */
965
966static void pc_flush_chars(struct tty_struct *tty)
967{ /* Begin pc_flush_chars */
968
969 struct channel * ch;
970
971 /* ---------------------------------------------------------
972 verifyChannel returns the channel from the tty struct
973 if it is valid. This serves as a sanity check.
974 ------------------------------------------------------------- */
975
976 if ((ch = verifyChannel(tty)) != NULL)
977 {
978 unsigned long flags;
979
980 save_flags(flags);
981 cli();
982
983 /* ----------------------------------------------------------------
984 If not already set and the transmitter is busy setup an event
985 to indicate when the transmit empties.
986 ------------------------------------------------------------------- */
987
988 if ((ch->statusflags & TXBUSY) && !(ch->statusflags & EMPTYWAIT))
989 setup_empty_event(tty,ch);
990
991 restore_flags(flags);
992 }
993
994} /* End pc_flush_chars */
995
996/* ------------------ Begin block_til_ready ---------------------- */
997
998static int block_til_ready(struct tty_struct *tty,
999 struct file *filp, struct channel *ch)
1000{ /* Begin block_til_ready */
1001
1002 DECLARE_WAITQUEUE(wait,current);
1003 int retval, do_clocal = 0;
1004 unsigned long flags;
1005
1006
1007 if (tty_hung_up_p(filp))
1008 {
1009 if (ch->asyncflags & ASYNC_HUP_NOTIFY)
1010 retval = -EAGAIN;
1011 else
1012 retval = -ERESTARTSYS;
1013 return(retval);
1014 }
1015
1016 /* -----------------------------------------------------------------
1017 If the device is in the middle of being closed, then block
1018 until it's done, and then try again.
1019 -------------------------------------------------------------------- */
1020 if (ch->asyncflags & ASYNC_CLOSING)
1021 {
1022 interruptible_sleep_on(&ch->close_wait);
1023
1024 if (ch->asyncflags & ASYNC_HUP_NOTIFY)
1025 return -EAGAIN;
1026 else
1027 return -ERESTARTSYS;
1028 }
1029
1030 if (filp->f_flags & O_NONBLOCK)
1031 {
1032 /* -----------------------------------------------------------------
1033 If non-blocking mode is set, then make the check up front
1034 and then exit.
1035 -------------------------------------------------------------------- */
1036
1037 ch->asyncflags |= ASYNC_NORMAL_ACTIVE;
1038
1039 return 0;
1040 }
1041
1042
1043 if (tty->termios->c_cflag & CLOCAL)
1044 do_clocal = 1;
1045
1046 /* Block waiting for the carrier detect and the line to become free */
1047
1048 retval = 0;
1049 add_wait_queue(&ch->open_wait, &wait);
1050 save_flags(flags);
1051 cli();
1052
1053
1054 /* We dec count so that pc_close will know when to free things */
1055 if (!tty_hung_up_p(filp))
1056 ch->count--;
1057
1058 restore_flags(flags);
1059
1060 ch->blocked_open++;
1061
1062 while(1)
1063 { /* Begin forever while */
1064
1065 set_current_state(TASK_INTERRUPTIBLE);
1066
1067 if (tty_hung_up_p(filp) ||
1068 !(ch->asyncflags & ASYNC_INITIALIZED))
1069 {
1070 if (ch->asyncflags & ASYNC_HUP_NOTIFY)
1071 retval = -EAGAIN;
1072 else
1073 retval = -ERESTARTSYS;
1074 break;
1075 }
1076
1077 if (!(ch->asyncflags & ASYNC_CLOSING) &&
1078 (do_clocal || (ch->imodem & ch->dcd)))
1079 break;
1080
1081 if (signal_pending(current))
1082 {
1083 retval = -ERESTARTSYS;
1084 break;
1085 }
1086
1087 /* ---------------------------------------------------------------
1088 Allow someone else to be scheduled. We will occasionally go
1089 through this loop until one of the above conditions change.
1090 The below schedule call will allow other processes to enter and
1091 prevent this loop from hogging the cpu.
1092 ------------------------------------------------------------------ */
1093 schedule();
1094
1095 } /* End forever while */
1096
1097 current->state = TASK_RUNNING;
1098 remove_wait_queue(&ch->open_wait, &wait);
1099 cli();
1100 if (!tty_hung_up_p(filp))
1101 ch->count++;
1102 restore_flags(flags);
1103
1104 ch->blocked_open--;
1105
1106 if (retval)
1107 return retval;
1108
1109 ch->asyncflags |= ASYNC_NORMAL_ACTIVE;
1110
1111 return 0;
1112
1113} /* End block_til_ready */
1114
1115/* ------------------ Begin pc_open ---------------------- */
1116
1117static int pc_open(struct tty_struct *tty, struct file * filp)
1118{ /* Begin pc_open */
1119
1120 struct channel *ch;
1121 unsigned long flags;
1122 int line, retval, boardnum;
1123 volatile struct board_chan *bc;
1124 volatile unsigned int head;
1125
1126 line = tty->index;
1127 if (line < 0 || line >= nbdevs)
1128 {
1129 printk(KERN_ERR "<Error> - pc_open : line out of range in pc_open\n");
1130 tty->driver_data = NULL;
1131 return(-ENODEV);
1132 }
1133
1134
1135 ch = &digi_channels[line];
1136 boardnum = ch->boardnum;
1137
1138 /* Check status of board configured in system. */
1139
1140 /* -----------------------------------------------------------------
1141 I check to see if the epca_setup routine detected an user error.
1142 It might be better to put this in pc_init, but for the moment it
1143 goes here.
1144 ---------------------------------------------------------------------- */
1145
1146 if (invalid_lilo_config)
1147 {
1148 if (setup_error_code & INVALID_BOARD_TYPE)
1149 printk(KERN_ERR "<Error> - pc_open: Invalid board type specified in LILO command\n");
1150
1151 if (setup_error_code & INVALID_NUM_PORTS)
1152 printk(KERN_ERR "<Error> - pc_open: Invalid number of ports specified in LILO command\n");
1153
1154 if (setup_error_code & INVALID_MEM_BASE)
1155 printk(KERN_ERR "<Error> - pc_open: Invalid board memory address specified in LILO command\n");
1156
1157 if (setup_error_code & INVALID_PORT_BASE)
1158 printk(KERN_ERR "<Error> - pc_open: Invalid board port address specified in LILO command\n");
1159
1160 if (setup_error_code & INVALID_BOARD_STATUS)
1161 printk(KERN_ERR "<Error> - pc_open: Invalid board status specified in LILO command\n");
1162
1163 if (setup_error_code & INVALID_ALTPIN)
1164 printk(KERN_ERR "<Error> - pc_open: Invalid board altpin specified in LILO command\n");
1165
1166 tty->driver_data = NULL; /* Mark this device as 'down' */
1167 return(-ENODEV);
1168 }
1169
1170 if ((boardnum >= num_cards) || (boards[boardnum].status == DISABLED))
1171 {
1172 tty->driver_data = NULL; /* Mark this device as 'down' */
1173 return(-ENODEV);
1174 }
1175
1176 if (( bc = ch->brdchan) == 0)
1177 {
1178 tty->driver_data = NULL;
1179 return(-ENODEV);
1180 }
1181
1182 /* ------------------------------------------------------------------
1183 Every time a channel is opened, increment a counter. This is
1184 necessary because we do not wish to flush and shutdown the channel
1185 until the last app holding the channel open, closes it.
1186 --------------------------------------------------------------------- */
1187
1188 ch->count++;
1189
1190 /* ----------------------------------------------------------------
1191 Set a kernel structures pointer to our local channel
1192 structure. This way we can get to it when passed only
1193 a tty struct.
1194 ------------------------------------------------------------------ */
1195
1196 tty->driver_data = ch;
1197
1198 /* ----------------------------------------------------------------
1199 If this is the first time the channel has been opened, initialize
1200 the tty->termios struct otherwise let pc_close handle it.
1201 -------------------------------------------------------------------- */
1202
1203 save_flags(flags);
1204 cli();
1205
1206 globalwinon(ch);
1207 ch->statusflags = 0;
1208
1209 /* Save boards current modem status */
1210 ch->imodem = bc->mstat;
1211
1212 /* ----------------------------------------------------------------
1213 Set receive head and tail ptrs to each other. This indicates
1214 no data available to read.
1215 ----------------------------------------------------------------- */
1216 head = bc->rin;
1217 bc->rout = head;
1218
1219 /* Set the channels associated tty structure */
1220 ch->tty = tty;
1221
1222 /* -----------------------------------------------------------------
1223 The below routine generally sets up parity, baud, flow control
1224 issues, etc.... It effect both control flags and input flags.
1225 -------------------------------------------------------------------- */
1226 epcaparam(tty,ch);
1227
1228 ch->asyncflags |= ASYNC_INITIALIZED;
1229 memoff(ch);
1230
1231 restore_flags(flags);
1232
1233 retval = block_til_ready(tty, filp, ch);
1234 if (retval)
1235 {
1236 return retval;
1237 }
1238
1239 /* -------------------------------------------------------------
1240 Set this again in case a hangup set it to zero while this
1241 open() was waiting for the line...
1242 --------------------------------------------------------------- */
1243 ch->tty = tty;
1244
1245 save_flags(flags);
1246 cli();
1247 globalwinon(ch);
1248
1249 /* Enable Digi Data events */
1250 bc->idata = 1;
1251
1252 memoff(ch);
1253 restore_flags(flags);
1254
1255 return 0;
1256
1257} /* End pc_open */
1258
1259#ifdef MODULE
1260static int __init epca_module_init(void)
1261{ /* Begin init_module */
1262
1263 unsigned long flags;
1264
1265 save_flags(flags);
1266 cli();
1267
1268 pc_init();
1269
1270 restore_flags(flags);
1271
1272 return(0);
1273}
1274
1275module_init(epca_module_init);
1276#endif
1277
1278#ifdef ENABLE_PCI
1279static struct pci_driver epca_driver;
1280#endif
1281
1282#ifdef MODULE
1283/* -------------------- Begin cleanup_module ---------------------- */
1284
1285static void __exit epca_module_exit(void)
1286{
1287
1288 int count, crd;
1289 struct board_info *bd;
1290 struct channel *ch;
1291 unsigned long flags;
1292
1293 del_timer_sync(&epca_timer);
1294
1295 save_flags(flags);
1296 cli();
1297
1298 if ((tty_unregister_driver(pc_driver)) ||
1299 (tty_unregister_driver(pc_info)))
1300 {
1301 printk(KERN_WARNING "<Error> - DIGI : cleanup_module failed to un-register tty driver\n");
1302 restore_flags(flags);
1303 return;
1304 }
1305 put_tty_driver(pc_driver);
1306 put_tty_driver(pc_info);
1307
1308 for (crd = 0; crd < num_cards; crd++)
1309 { /* Begin for each card */
1310
1311 bd = &boards[crd];
1312
1313 if (!bd)
1314 { /* Begin sanity check */
1315 printk(KERN_ERR "<Error> - Digi : cleanup_module failed\n");
1316 return;
1317 } /* End sanity check */
1318
1319 ch = card_ptr[crd];
1320
1321 for (count = 0; count < bd->numports; count++, ch++)
1322 { /* Begin for each port */
1323
1324 if (ch)
1325 {
1326 if (ch->tty)
1327 tty_hangup(ch->tty);
1328 kfree(ch->tmp_buf);
1329 }
1330
1331 } /* End for each port */
1332 } /* End for each card */
1333
1334#ifdef ENABLE_PCI
1335 pci_unregister_driver (&epca_driver);
1336#endif
1337
1338 restore_flags(flags);
1339
1340}
1341module_exit(epca_module_exit);
1342#endif /* MODULE */
1343
1344static struct tty_operations pc_ops = {
1345 .open = pc_open,
1346 .close = pc_close,
1347 .write = pc_write,
1348 .write_room = pc_write_room,
1349 .flush_buffer = pc_flush_buffer,
1350 .chars_in_buffer = pc_chars_in_buffer,
1351 .flush_chars = pc_flush_chars,
1352 .put_char = pc_put_char,
1353 .ioctl = pc_ioctl,
1354 .set_termios = pc_set_termios,
1355 .stop = pc_stop,
1356 .start = pc_start,
1357 .throttle = pc_throttle,
1358 .unthrottle = pc_unthrottle,
1359 .hangup = pc_hangup,
1360};
1361
1362static int info_open(struct tty_struct *tty, struct file * filp)
1363{
1364 return 0;
1365}
1366
1367static struct tty_operations info_ops = {
1368 .open = info_open,
1369 .ioctl = info_ioctl,
1370};
1371
1372/* ------------------ Begin pc_init ---------------------- */
1373
1374int __init pc_init(void)
1375{ /* Begin pc_init */
1376
1377 /* ----------------------------------------------------------------
1378 pc_init is called by the operating system during boot up prior to
1379 any open calls being made. In the older versions of Linux (Prior
1380 to 2.0.0) an entry is made into tty_io.c. A pointer to the last
1381 memory location (from kernel space) used (kmem_start) is passed
1382 to pc_init. It is pc_inits responsibility to modify this value
1383 for any memory that the Digi driver might need and then return
1384 this value to the operating system. For example if the driver
1385 wishes to allocate 1K of kernel memory, pc_init would return
1386 (kmem_start + 1024). This memory (Between kmem_start and kmem_start
1387 + 1024) would then be available for use exclusively by the driver.
1388 In this case our driver does not allocate any of this kernel
1389 memory.
1390 ------------------------------------------------------------------*/
1391
1392 ulong flags;
1393 int crd;
1394 struct board_info *bd;
1395 unsigned char board_id = 0;
1396
1397#ifdef ENABLE_PCI
1398 int pci_boards_found, pci_count;
1399
1400 pci_count = 0;
1401#endif /* ENABLE_PCI */
1402
1403 pc_driver = alloc_tty_driver(MAX_ALLOC);
1404 if (!pc_driver)
1405 return -ENOMEM;
1406
1407 pc_info = alloc_tty_driver(MAX_ALLOC);
1408 if (!pc_info) {
1409 put_tty_driver(pc_driver);
1410 return -ENOMEM;
1411 }
1412
1413 /* -----------------------------------------------------------------------
1414 If epca_setup has not been ran by LILO set num_cards to defaults; copy
1415 board structure defined by digiConfig into drivers board structure.
1416 Note : If LILO has ran epca_setup then epca_setup will handle defining
1417 num_cards as well as copying the data into the board structure.
1418 -------------------------------------------------------------------------- */
1419 if (!liloconfig)
1420 { /* Begin driver has been configured via. epcaconfig */
1421
1422 nbdevs = NBDEVS;
1423 num_cards = NUMCARDS;
1424 memcpy((void *)&boards, (void *)&static_boards,
1425 (sizeof(struct board_info) * NUMCARDS));
1426 } /* End driver has been configured via. epcaconfig */
1427
1428 /* -----------------------------------------------------------------
1429 Note : If lilo was used to configure the driver and the
1430 ignore epcaconfig option was choosen (digiepca=2) then
1431 nbdevs and num_cards will equal 0 at this point. This is
1432 okay; PCI cards will still be picked up if detected.
1433 --------------------------------------------------------------------- */
1434
1435 /* -----------------------------------------------------------
1436 Set up interrupt, we will worry about memory allocation in
1437 post_fep_init.
1438 --------------------------------------------------------------- */
1439
1440
1441 printk(KERN_INFO "DIGI epca driver version %s loaded.\n",VERSION);
1442
1443#ifdef ENABLE_PCI
1444
1445 /* ------------------------------------------------------------------
1446 NOTE : This code assumes that the number of ports found in
1447 the boards array is correct. This could be wrong if
1448 the card in question is PCI (And therefore has no ports
1449 entry in the boards structure.) The rest of the
1450 information will be valid for PCI because the beginning
1451 of pc_init scans for PCI and determines i/o and base
1452 memory addresses. I am not sure if it is possible to
1453 read the number of ports supported by the card prior to
1454 it being booted (Since that is the state it is in when
1455 pc_init is run). Because it is not possible to query the
1456 number of supported ports until after the card has booted;
1457 we are required to calculate the card_ptrs as the card is
1458 is initialized (Inside post_fep_init). The negative thing
1459 about this approach is that digiDload's call to GET_INFO
1460 will have a bad port value. (Since this is called prior
1461 to post_fep_init.)
1462
1463 --------------------------------------------------------------------- */
1464
1465 pci_boards_found = 0;
1466 if(num_cards < MAXBOARDS)
1467 pci_boards_found += init_PCI();
1468 num_cards += pci_boards_found;
1469
1470#endif /* ENABLE_PCI */
1471
1472 pc_driver->owner = THIS_MODULE;
1473 pc_driver->name = "ttyD";
1474 pc_driver->devfs_name = "tts/D";
1475 pc_driver->major = DIGI_MAJOR;
1476 pc_driver->minor_start = 0;
1477 pc_driver->type = TTY_DRIVER_TYPE_SERIAL;
1478 pc_driver->subtype = SERIAL_TYPE_NORMAL;
1479 pc_driver->init_termios = tty_std_termios;
1480 pc_driver->init_termios.c_iflag = 0;
1481 pc_driver->init_termios.c_oflag = 0;
1482 pc_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL | HUPCL;
1483 pc_driver->init_termios.c_lflag = 0;
1484 pc_driver->flags = TTY_DRIVER_REAL_RAW;
1485 tty_set_operations(pc_driver, &pc_ops);
1486
1487 pc_info->owner = THIS_MODULE;
1488 pc_info->name = "digi_ctl";
1489 pc_info->major = DIGIINFOMAJOR;
1490 pc_info->minor_start = 0;
1491 pc_info->type = TTY_DRIVER_TYPE_SERIAL;
1492 pc_info->subtype = SERIAL_TYPE_INFO;
1493 pc_info->init_termios = tty_std_termios;
1494 pc_info->init_termios.c_iflag = 0;
1495 pc_info->init_termios.c_oflag = 0;
1496 pc_info->init_termios.c_lflag = 0;
1497 pc_info->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL;
1498 pc_info->flags = TTY_DRIVER_REAL_RAW;
1499 tty_set_operations(pc_info, &info_ops);
1500
1501
1502 save_flags(flags);
1503 cli();
1504
1505 for (crd = 0; crd < num_cards; crd++)
1506 { /* Begin for each card */
1507
1508 /* ------------------------------------------------------------------
1509 This is where the appropriate memory handlers for the hardware is
1510 set. Everything at runtime blindly jumps through these vectors.
1511 ---------------------------------------------------------------------- */
1512
1513 /* defined in epcaconfig.h */
1514 bd = &boards[crd];
1515
1516 switch (bd->type)
1517 { /* Begin switch on bd->type {board type} */
1518 case PCXEM:
1519 case EISAXEM:
1520 bd->memwinon = pcxem_memwinon ;
1521 bd->memwinoff = pcxem_memwinoff ;
1522 bd->globalwinon = pcxem_globalwinon ;
1523 bd->txwinon = pcxem_txwinon ;
1524 bd->rxwinon = pcxem_rxwinon ;
1525 bd->memoff = pcxem_memoff ;
1526 bd->assertgwinon = dummy_assertgwinon;
1527 bd->assertmemoff = dummy_assertmemoff;
1528 break;
1529
1530 case PCIXEM:
1531 case PCIXRJ:
1532 case PCIXR:
1533 bd->memwinon = dummy_memwinon;
1534 bd->memwinoff = dummy_memwinoff;
1535 bd->globalwinon = dummy_globalwinon;
1536 bd->txwinon = dummy_txwinon;
1537 bd->rxwinon = dummy_rxwinon;
1538 bd->memoff = dummy_memoff;
1539 bd->assertgwinon = dummy_assertgwinon;
1540 bd->assertmemoff = dummy_assertmemoff;
1541 break;
1542
1543 case PCXE:
1544 case PCXEVE:
1545
1546 bd->memwinon = pcxe_memwinon;
1547 bd->memwinoff = pcxe_memwinoff;
1548 bd->globalwinon = pcxe_globalwinon;
1549 bd->txwinon = pcxe_txwinon;
1550 bd->rxwinon = pcxe_rxwinon;
1551 bd->memoff = pcxe_memoff;
1552 bd->assertgwinon = dummy_assertgwinon;
1553 bd->assertmemoff = dummy_assertmemoff;
1554 break;
1555
1556 case PCXI:
1557 case PC64XE:
1558
1559 bd->memwinon = pcxi_memwinon;
1560 bd->memwinoff = pcxi_memwinoff;
1561 bd->globalwinon = pcxi_globalwinon;
1562 bd->txwinon = pcxi_txwinon;
1563 bd->rxwinon = pcxi_rxwinon;
1564 bd->memoff = pcxi_memoff;
1565 bd->assertgwinon = pcxi_assertgwinon;
1566 bd->assertmemoff = pcxi_assertmemoff;
1567 break;
1568
1569 default:
1570 break;
1571
1572 } /* End switch on bd->type */
1573
1574 /* ---------------------------------------------------------------
1575 Some cards need a memory segment to be defined for use in
1576 transmit and receive windowing operations. These boards
1577 are listed in the below switch. In the case of the XI the
1578 amount of memory on the board is variable so the memory_seg
1579 is also variable. This code determines what they segment
1580 should be.
1581 ----------------------------------------------------------------- */
1582
1583 switch (bd->type)
1584 { /* Begin switch on bd->type {board type} */
1585
1586 case PCXE:
1587 case PCXEVE:
1588 case PC64XE:
1589 bd->memory_seg = 0xf000;
1590 break;
1591
1592 case PCXI:
1593 board_id = inb((int)bd->port);
1594 if ((board_id & 0x1) == 0x1)
1595 { /* Begin it's an XI card */
1596
1597 /* Is it a 64K board */
1598 if ((board_id & 0x30) == 0)
1599 bd->memory_seg = 0xf000;
1600
1601 /* Is it a 128K board */
1602 if ((board_id & 0x30) == 0x10)
1603 bd->memory_seg = 0xe000;
1604
1605 /* Is is a 256K board */
1606 if ((board_id & 0x30) == 0x20)
1607 bd->memory_seg = 0xc000;
1608
1609 /* Is it a 512K board */
1610 if ((board_id & 0x30) == 0x30)
1611 bd->memory_seg = 0x8000;
1612
1613 } /* End it is an XI card */
1614 else
1615 {
1616 printk(KERN_ERR "<Error> - Board at 0x%x doesn't appear to be an XI\n",(int)bd->port);
1617 }
1618 break;
1619
1620 } /* End switch on bd->type */
1621
1622 } /* End for each card */
1623
1624 if (tty_register_driver(pc_driver))
1625 panic("Couldn't register Digi PC/ driver");
1626
1627 if (tty_register_driver(pc_info))
1628 panic("Couldn't register Digi PC/ info ");
1629
1630 /* -------------------------------------------------------------------
1631 Start up the poller to check for events on all enabled boards
1632 ---------------------------------------------------------------------- */
1633
1634 init_timer(&epca_timer);
1635 epca_timer.function = epcapoll;
1636 mod_timer(&epca_timer, jiffies + HZ/25);
1637
1638 restore_flags(flags);
1639
1640 return 0;
1641
1642} /* End pc_init */
1643
1644/* ------------------ Begin post_fep_init ---------------------- */
1645
1646static void post_fep_init(unsigned int crd)
1647{ /* Begin post_fep_init */
1648
1649 int i;
1650 unchar *memaddr;
1651 volatile struct global_data *gd;
1652 struct board_info *bd;
1653 volatile struct board_chan *bc;
1654 struct channel *ch;
1655 int shrinkmem = 0, lowwater ;
1656
1657 /* -------------------------------------------------------------
1658 This call is made by the user via. the ioctl call DIGI_INIT.
1659 It is responsible for setting up all the card specific stuff.
1660 ---------------------------------------------------------------- */
1661 bd = &boards[crd];
1662
1663 /* -----------------------------------------------------------------
1664 If this is a PCI board, get the port info. Remember PCI cards
1665 do not have entries into the epcaconfig.h file, so we can't get
1666 the number of ports from it. Unfortunetly, this means that anyone
1667 doing a DIGI_GETINFO before the board has booted will get an invalid
1668 number of ports returned (It should return 0). Calls to DIGI_GETINFO
1669 after DIGI_INIT has been called will return the proper values.
1670 ------------------------------------------------------------------- */
1671
1672 if (bd->type >= PCIXEM) /* If the board in question is PCI */
1673 { /* Begin get PCI number of ports */
1674
1675 /* --------------------------------------------------------------------
1676 Below we use XEMPORTS as a memory offset regardless of which PCI
1677 card it is. This is because all of the supported PCI cards have
1678 the same memory offset for the channel data. This will have to be
1679 changed if we ever develop a PCI/XE card. NOTE : The FEP manual
1680 states that the port offset is 0xC22 as opposed to 0xC02. This is
1681 only true for PC/XE, and PC/XI cards; not for the XEM, or CX series.
1682 On the PCI cards the number of ports is determined by reading a
1683 ID PROM located in the box attached to the card. The card can then
1684 determine the index the id to determine the number of ports available.
1685 (FYI - The id should be located at 0x1ac (And may use up to 4 bytes
1686 if the box in question is a XEM or CX)).
1687 ------------------------------------------------------------------------ */
1688
1689 bd->numports = (unsigned short)*(unsigned char *)bus_to_virt((unsigned long)
1690 (bd->re_map_membase + XEMPORTS));
1691
1692
1693 epcaassert(bd->numports <= 64,"PCI returned a invalid number of ports");
1694 nbdevs += (bd->numports);
1695
1696 } /* End get PCI number of ports */
1697
1698 if (crd != 0)
1699 card_ptr[crd] = card_ptr[crd-1] + boards[crd-1].numports;
1700 else
1701 card_ptr[crd] = &digi_channels[crd]; /* <- For card 0 only */
1702
1703 ch = card_ptr[crd];
1704
1705
1706 epcaassert(ch <= &digi_channels[nbdevs - 1], "ch out of range");
1707
1708 memaddr = (unchar *)bd->re_map_membase;
1709
1710 /*
1711 The below command is necessary because newer kernels (2.1.x and
1712 up) do not have a 1:1 virtual to physical mapping. The below
1713 call adjust for that.
1714 */
1715
1716 memaddr = (unsigned char *)bus_to_virt((unsigned long)memaddr);
1717
1718 /* -----------------------------------------------------------------
1719 The below assignment will set bc to point at the BEGINING of
1720 the cards channel structures. For 1 card there will be between
1721 8 and 64 of these structures.
1722 -------------------------------------------------------------------- */
1723
1724 bc = (volatile struct board_chan *)((ulong)memaddr + CHANSTRUCT);
1725
1726 /* -------------------------------------------------------------------
1727 The below assignment will set gd to point at the BEGINING of
1728 global memory address 0xc00. The first data in that global
1729 memory actually starts at address 0xc1a. The command in
1730 pointer begins at 0xd10.
1731 ---------------------------------------------------------------------- */
1732
1733 gd = (volatile struct global_data *)((ulong)memaddr + GLOBAL);
1734
1735 /* --------------------------------------------------------------------
1736 XEPORTS (address 0xc22) points at the number of channels the
1737 card supports. (For 64XE, XI, XEM, and XR use 0xc02)
1738 ----------------------------------------------------------------------- */
1739
1740 if (((bd->type == PCXEVE) | (bd->type == PCXE)) &&
1741 (*(ushort *)((ulong)memaddr + XEPORTS) < 3))
1742 shrinkmem = 1;
1743 if (bd->type < PCIXEM)
1744 if (!request_region((int)bd->port, 4, board_desc[bd->type]))
1745 return;
1746
1747 memwinon(bd, 0);
1748
1749 /* --------------------------------------------------------------------
1750 Remember ch is the main drivers channels structure, while bc is
1751 the cards channel structure.
1752 ------------------------------------------------------------------------ */
1753
1754 /* For every port on the card do ..... */
1755
1756 for (i = 0; i < bd->numports; i++, ch++, bc++)
1757 { /* Begin for each port */
1758
1759 ch->brdchan = bc;
1760 ch->mailbox = gd;
1761 INIT_WORK(&ch->tqueue, do_softint, ch);
1762 ch->board = &boards[crd];
1763
1764 switch (bd->type)
1765 { /* Begin switch bd->type */
1766
1767 /* ----------------------------------------------------------------
1768 Since some of the boards use different bitmaps for their
1769 control signals we cannot hard code these values and retain
1770 portability. We virtualize this data here.
1771 ------------------------------------------------------------------- */
1772 case EISAXEM:
1773 case PCXEM:
1774 case PCIXEM:
1775 case PCIXRJ:
1776 case PCIXR:
1777 ch->m_rts = 0x02 ;
1778 ch->m_dcd = 0x80 ;
1779 ch->m_dsr = 0x20 ;
1780 ch->m_cts = 0x10 ;
1781 ch->m_ri = 0x40 ;
1782 ch->m_dtr = 0x01 ;
1783 break;
1784
1785 case PCXE:
1786 case PCXEVE:
1787 case PCXI:
1788 case PC64XE:
1789 ch->m_rts = 0x02 ;
1790 ch->m_dcd = 0x08 ;
1791 ch->m_dsr = 0x10 ;
1792 ch->m_cts = 0x20 ;
1793 ch->m_ri = 0x40 ;
1794 ch->m_dtr = 0x80 ;
1795 break;
1796
1797 } /* End switch bd->type */
1798
1799 if (boards[crd].altpin)
1800 {
1801 ch->dsr = ch->m_dcd;
1802 ch->dcd = ch->m_dsr;
1803 ch->digiext.digi_flags |= DIGI_ALTPIN;
1804 }
1805 else
1806 {
1807 ch->dcd = ch->m_dcd;
1808 ch->dsr = ch->m_dsr;
1809 }
1810
1811 ch->boardnum = crd;
1812 ch->channelnum = i;
1813 ch->magic = EPCA_MAGIC;
1814 ch->tty = NULL;
1815
1816 if (shrinkmem)
1817 {
1818 fepcmd(ch, SETBUFFER, 32, 0, 0, 0);
1819 shrinkmem = 0;
1820 }
1821
1822 switch (bd->type)
1823 { /* Begin switch bd->type */
1824
1825 case PCIXEM:
1826 case PCIXRJ:
1827 case PCIXR:
1828 /* Cover all the 2MEG cards */
1829 ch->txptr = memaddr + (((bc->tseg) << 4) & 0x1fffff);
1830 ch->rxptr = memaddr + (((bc->rseg) << 4) & 0x1fffff);
1831 ch->txwin = FEPWIN | ((bc->tseg) >> 11);
1832 ch->rxwin = FEPWIN | ((bc->rseg) >> 11);
1833 break;
1834
1835 case PCXEM:
1836 case EISAXEM:
1837 /* Cover all the 32K windowed cards */
1838 /* Mask equal to window size - 1 */
1839 ch->txptr = memaddr + (((bc->tseg) << 4) & 0x7fff);
1840 ch->rxptr = memaddr + (((bc->rseg) << 4) & 0x7fff);
1841 ch->txwin = FEPWIN | ((bc->tseg) >> 11);
1842 ch->rxwin = FEPWIN | ((bc->rseg) >> 11);
1843 break;
1844
1845 case PCXEVE:
1846 case PCXE:
1847 ch->txptr = memaddr + (((bc->tseg - bd->memory_seg) << 4) & 0x1fff);
1848 ch->txwin = FEPWIN | ((bc->tseg - bd->memory_seg) >> 9);
1849 ch->rxptr = memaddr + (((bc->rseg - bd->memory_seg) << 4) & 0x1fff);
1850 ch->rxwin = FEPWIN | ((bc->rseg - bd->memory_seg) >>9 );
1851 break;
1852
1853 case PCXI:
1854 case PC64XE:
1855 ch->txptr = memaddr + ((bc->tseg - bd->memory_seg) << 4);
1856 ch->rxptr = memaddr + ((bc->rseg - bd->memory_seg) << 4);
1857 ch->txwin = ch->rxwin = 0;
1858 break;
1859
1860 } /* End switch bd->type */
1861
1862 ch->txbufhead = 0;
1863 ch->txbufsize = bc->tmax + 1;
1864
1865 ch->rxbufhead = 0;
1866 ch->rxbufsize = bc->rmax + 1;
1867
1868 lowwater = ch->txbufsize >= 2000 ? 1024 : (ch->txbufsize / 2);
1869
1870 /* Set transmitter low water mark */
1871 fepcmd(ch, STXLWATER, lowwater, 0, 10, 0);
1872
1873 /* Set receiver low water mark */
1874
1875 fepcmd(ch, SRXLWATER, (ch->rxbufsize / 4), 0, 10, 0);
1876
1877 /* Set receiver high water mark */
1878
1879 fepcmd(ch, SRXHWATER, (3 * ch->rxbufsize / 4), 0, 10, 0);
1880
1881 bc->edelay = 100;
1882 bc->idata = 1;
1883
1884 ch->startc = bc->startc;
1885 ch->stopc = bc->stopc;
1886 ch->startca = bc->startca;
1887 ch->stopca = bc->stopca;
1888
1889 ch->fepcflag = 0;
1890 ch->fepiflag = 0;
1891 ch->fepoflag = 0;
1892 ch->fepstartc = 0;
1893 ch->fepstopc = 0;
1894 ch->fepstartca = 0;
1895 ch->fepstopca = 0;
1896
1897 ch->close_delay = 50;
1898 ch->count = 0;
1899 ch->blocked_open = 0;
1900 init_waitqueue_head(&ch->open_wait);
1901 init_waitqueue_head(&ch->close_wait);
1902 ch->tmp_buf = kmalloc(ch->txbufsize,GFP_KERNEL);
1903 if (!(ch->tmp_buf))
1904 {
1905 printk(KERN_ERR "POST FEP INIT : kmalloc failed for port 0x%x\n",i);
1906 release_region((int)bd->port, 4);
1907 while(i-- > 0)
1908 kfree((ch--)->tmp_buf);
1909 return;
1910 }
1911 else
1912 memset((void *)ch->tmp_buf,0,ch->txbufsize);
1913 } /* End for each port */
1914
1915 printk(KERN_INFO
1916 "Digi PC/Xx Driver V%s: %s I/O = 0x%lx Mem = 0x%lx Ports = %d\n",
1917 VERSION, board_desc[bd->type], (long)bd->port, (long)bd->membase, bd->numports);
1918 sprintf(mesg,
1919 "Digi PC/Xx Driver V%s: %s I/O = 0x%lx Mem = 0x%lx Ports = %d\n",
1920 VERSION, board_desc[bd->type], (long)bd->port, (long)bd->membase, bd->numports);
1921 console_print(mesg);
1922
1923 memwinoff(bd, 0);
1924
1925} /* End post_fep_init */
1926
1927/* --------------------- Begin epcapoll ------------------------ */
1928
1929static void epcapoll(unsigned long ignored)
1930{ /* Begin epcapoll */
1931
1932 unsigned long flags;
1933 int crd;
1934 volatile unsigned int head, tail;
1935 struct channel *ch;
1936 struct board_info *bd;
1937
1938 /* -------------------------------------------------------------------
1939 This routine is called upon every timer interrupt. Even though
1940 the Digi series cards are capable of generating interrupts this
1941 method of non-looping polling is more efficient. This routine
1942 checks for card generated events (Such as receive data, are transmit
1943 buffer empty) and acts on those events.
1944 ----------------------------------------------------------------------- */
1945
1946 save_flags(flags);
1947 cli();
1948
1949 for (crd = 0; crd < num_cards; crd++)
1950 { /* Begin for each card */
1951
1952 bd = &boards[crd];
1953 ch = card_ptr[crd];
1954
1955 if ((bd->status == DISABLED) || digi_poller_inhibited)
1956 continue; /* Begin loop next interation */
1957
1958 /* -----------------------------------------------------------
1959 assertmemoff is not needed here; indeed it is an empty subroutine.
1960 It is being kept because future boards may need this as well as
1961 some legacy boards.
1962 ---------------------------------------------------------------- */
1963
1964 assertmemoff(ch);
1965
1966 globalwinon(ch);
1967
1968 /* ---------------------------------------------------------------
1969 In this case head and tail actually refer to the event queue not
1970 the transmit or receive queue.
1971 ------------------------------------------------------------------- */
1972
1973 head = ch->mailbox->ein;
1974 tail = ch->mailbox->eout;
1975
1976 /* If head isn't equal to tail we have an event */
1977
1978 if (head != tail)
1979 doevent(crd);
1980
1981 memoff(ch);
1982
1983 } /* End for each card */
1984
1985 mod_timer(&epca_timer, jiffies + (HZ / 25));
1986
1987 restore_flags(flags);
1988} /* End epcapoll */
1989
1990/* --------------------- Begin doevent ------------------------ */
1991
1992static void doevent(int crd)
1993{ /* Begin doevent */
1994
1995 volatile unchar *eventbuf;
1996 struct channel *ch, *chan0;
1997 static struct tty_struct *tty;
1998 volatile struct board_info *bd;
1999 volatile struct board_chan *bc;
2000 register volatile unsigned int tail, head;
2001 register int event, channel;
2002 register int mstat, lstat;
2003
2004 /* -------------------------------------------------------------------
2005 This subroutine is called by epcapoll when an event is detected
2006 in the event queue. This routine responds to those events.
2007 --------------------------------------------------------------------- */
2008
2009 bd = &boards[crd];
2010
2011 chan0 = card_ptr[crd];
2012 epcaassert(chan0 <= &digi_channels[nbdevs - 1], "ch out of range");
2013
2014 assertgwinon(chan0);
2015
2016 while ((tail = chan0->mailbox->eout) != (head = chan0->mailbox->ein))
2017 { /* Begin while something in event queue */
2018
2019 assertgwinon(chan0);
2020
2021 eventbuf = (volatile unchar *)bus_to_virt((ulong)(bd->re_map_membase + tail + ISTART));
2022
2023 /* Get the channel the event occurred on */
2024 channel = eventbuf[0];
2025
2026 /* Get the actual event code that occurred */
2027 event = eventbuf[1];
2028
2029 /* ----------------------------------------------------------------
2030 The two assignments below get the current modem status (mstat)
2031 and the previous modem status (lstat). These are useful becuase
2032 an event could signal a change in modem signals itself.
2033 ------------------------------------------------------------------- */
2034
2035 mstat = eventbuf[2];
2036 lstat = eventbuf[3];
2037
2038 ch = chan0 + channel;
2039
2040 if ((unsigned)channel >= bd->numports || !ch)
2041 {
2042 if (channel >= bd->numports)
2043 ch = chan0;
2044 bc = ch->brdchan;
2045 goto next;
2046 }
2047
2048 if ((bc = ch->brdchan) == NULL)
2049 goto next;
2050
2051 if (event & DATA_IND)
2052 { /* Begin DATA_IND */
2053
2054 receive_data(ch);
2055 assertgwinon(ch);
2056
2057 } /* End DATA_IND */
2058 /* else *//* Fix for DCD transition missed bug */
2059 if (event & MODEMCHG_IND)
2060 { /* Begin MODEMCHG_IND */
2061
2062 /* A modem signal change has been indicated */
2063
2064 ch->imodem = mstat;
2065
2066 if (ch->asyncflags & ASYNC_CHECK_CD)
2067 {
2068 if (mstat & ch->dcd) /* We are now receiving dcd */
2069 wake_up_interruptible(&ch->open_wait);
2070 else
2071 pc_sched_event(ch, EPCA_EVENT_HANGUP); /* No dcd; hangup */
2072 }
2073
2074 } /* End MODEMCHG_IND */
2075
2076 tty = ch->tty;
2077 if (tty)
2078 { /* Begin if valid tty */
2079
2080 if (event & BREAK_IND)
2081 { /* Begin if BREAK_IND */
2082
2083 /* A break has been indicated */
2084
2085 tty->flip.count++;
2086 *tty->flip.flag_buf_ptr++ = TTY_BREAK;
2087
2088 *tty->flip.char_buf_ptr++ = 0;
2089
2090 tty_schedule_flip(tty);
2091
2092 } /* End if BREAK_IND */
2093 else
2094 if (event & LOWTX_IND)
2095 { /* Begin LOWTX_IND */
2096
2097 if (ch->statusflags & LOWWAIT)
2098 { /* Begin if LOWWAIT */
2099
2100 ch->statusflags &= ~LOWWAIT;
2101 tty_wakeup(tty);
2102 wake_up_interruptible(&tty->write_wait);
2103
2104 } /* End if LOWWAIT */
2105
2106 } /* End LOWTX_IND */
2107 else
2108 if (event & EMPTYTX_IND)
2109 { /* Begin EMPTYTX_IND */
2110
2111 /* This event is generated by setup_empty_event */
2112
2113 ch->statusflags &= ~TXBUSY;
2114 if (ch->statusflags & EMPTYWAIT)
2115 { /* Begin if EMPTYWAIT */
2116
2117 ch->statusflags &= ~EMPTYWAIT;
2118 tty_wakeup(tty);
2119
2120 wake_up_interruptible(&tty->write_wait);
2121
2122 } /* End if EMPTYWAIT */
2123
2124 } /* End EMPTYTX_IND */
2125
2126 } /* End if valid tty */
2127
2128
2129 next:
2130 globalwinon(ch);
2131
2132 if (!bc)
2133 printk(KERN_ERR "<Error> - bc == NULL in doevent!\n");
2134 else
2135 bc->idata = 1;
2136
2137 chan0->mailbox->eout = (tail + 4) & (IMAX - ISTART - 4);
2138 globalwinon(chan0);
2139
2140 } /* End while something in event queue */
2141
2142} /* End doevent */
2143
2144/* --------------------- Begin fepcmd ------------------------ */
2145
2146static void fepcmd(struct channel *ch, int cmd, int word_or_byte,
2147 int byte2, int ncmds, int bytecmd)
2148{ /* Begin fepcmd */
2149
2150 unchar *memaddr;
2151 unsigned int head, cmdTail, cmdStart, cmdMax;
2152 long count;
2153 int n;
2154
2155 /* This is the routine in which commands may be passed to the card. */
2156
2157 if (ch->board->status == DISABLED)
2158 {
2159 return;
2160 }
2161
2162 assertgwinon(ch);
2163
2164 /* Remember head (As well as max) is just an offset not a base addr */
2165 head = ch->mailbox->cin;
2166
2167 /* cmdStart is a base address */
2168 cmdStart = ch->mailbox->cstart;
2169
2170 /* ------------------------------------------------------------------
2171 We do the addition below because we do not want a max pointer
2172 relative to cmdStart. We want a max pointer that points at the
2173 physical end of the command queue.
2174 -------------------------------------------------------------------- */
2175
2176 cmdMax = (cmdStart + 4 + (ch->mailbox->cmax));
2177
2178 memaddr = ch->board->re_map_membase;
2179
2180 /*
2181 The below command is necessary because newer kernels (2.1.x and
2182 up) do not have a 1:1 virtual to physical mapping. The below
2183 call adjust for that.
2184 */
2185
2186 memaddr = (unsigned char *)bus_to_virt((unsigned long)memaddr);
2187
2188 if (head >= (cmdMax - cmdStart) || (head & 03))
2189 {
2190 printk(KERN_ERR "line %d: Out of range, cmd = %x, head = %x\n", __LINE__,
2191 cmd, head);
2192 printk(KERN_ERR "line %d: Out of range, cmdMax = %x, cmdStart = %x\n", __LINE__,
2193 cmdMax, cmdStart);
2194 return;
2195 }
2196
2197 if (bytecmd)
2198 {
2199 *(volatile unchar *)(memaddr + head + cmdStart + 0) = (unchar)cmd;
2200
2201 *(volatile unchar *)(memaddr + head + cmdStart + 1) = (unchar)ch->channelnum;
2202 /* Below word_or_byte is bits to set */
2203 *(volatile unchar *)(memaddr + head + cmdStart + 2) = (unchar)word_or_byte;
2204 /* Below byte2 is bits to reset */
2205 *(volatile unchar *)(memaddr + head + cmdStart + 3) = (unchar)byte2;
2206
2207 }
2208 else
2209 {
2210 *(volatile unchar *)(memaddr + head + cmdStart + 0) = (unchar)cmd;
2211 *(volatile unchar *)(memaddr + head + cmdStart + 1) = (unchar)ch->channelnum;
2212 *(volatile ushort*)(memaddr + head + cmdStart + 2) = (ushort)word_or_byte;
2213 }
2214
2215 head = (head + 4) & (cmdMax - cmdStart - 4);
2216 ch->mailbox->cin = head;
2217
2218 count = FEPTIMEOUT;
2219
2220 for (;;)
2221 { /* Begin forever loop */
2222
2223 count--;
2224 if (count == 0)
2225 {
2226 printk(KERN_ERR "<Error> - Fep not responding in fepcmd()\n");
2227 return;
2228 }
2229
2230 head = ch->mailbox->cin;
2231 cmdTail = ch->mailbox->cout;
2232
2233 n = (head - cmdTail) & (cmdMax - cmdStart - 4);
2234
2235 /* ----------------------------------------------------------
2236 Basically this will break when the FEP acknowledges the
2237 command by incrementing cmdTail (Making it equal to head).
2238 ------------------------------------------------------------- */
2239
2240 if (n <= ncmds * (sizeof(short) * 4))
2241 break; /* Well nearly forever :-) */
2242
2243 } /* End forever loop */
2244
2245} /* End fepcmd */
2246
2247/* ---------------------------------------------------------------------
2248 Digi products use fields in their channels structures that are very
2249 similar to the c_cflag and c_iflag fields typically found in UNIX
2250 termios structures. The below three routines allow mappings
2251 between these hardware "flags" and their respective Linux flags.
2252------------------------------------------------------------------------- */
2253
2254/* --------------------- Begin termios2digi_h -------------------- */
2255
2256static unsigned termios2digi_h(struct channel *ch, unsigned cflag)
2257{ /* Begin termios2digi_h */
2258
2259 unsigned res = 0;
2260
2261 if (cflag & CRTSCTS)
2262 {
2263 ch->digiext.digi_flags |= (RTSPACE | CTSPACE);
2264 res |= ((ch->m_cts) | (ch->m_rts));
2265 }
2266
2267 if (ch->digiext.digi_flags & RTSPACE)
2268 res |= ch->m_rts;
2269
2270 if (ch->digiext.digi_flags & DTRPACE)
2271 res |= ch->m_dtr;
2272
2273 if (ch->digiext.digi_flags & CTSPACE)
2274 res |= ch->m_cts;
2275
2276 if (ch->digiext.digi_flags & DSRPACE)
2277 res |= ch->dsr;
2278
2279 if (ch->digiext.digi_flags & DCDPACE)
2280 res |= ch->dcd;
2281
2282 if (res & (ch->m_rts))
2283 ch->digiext.digi_flags |= RTSPACE;
2284
2285 if (res & (ch->m_cts))
2286 ch->digiext.digi_flags |= CTSPACE;
2287
2288 return res;
2289
2290} /* End termios2digi_h */
2291
2292/* --------------------- Begin termios2digi_i -------------------- */
2293static unsigned termios2digi_i(struct channel *ch, unsigned iflag)
2294{ /* Begin termios2digi_i */
2295
2296 unsigned res = iflag & (IGNBRK | BRKINT | IGNPAR | PARMRK |
2297 INPCK | ISTRIP|IXON|IXANY|IXOFF);
2298
2299 if (ch->digiext.digi_flags & DIGI_AIXON)
2300 res |= IAIXON;
2301 return res;
2302
2303} /* End termios2digi_i */
2304
2305/* --------------------- Begin termios2digi_c -------------------- */
2306
2307static unsigned termios2digi_c(struct channel *ch, unsigned cflag)
2308{ /* Begin termios2digi_c */
2309
2310 unsigned res = 0;
2311
2312#ifdef SPEED_HACK
2313 /* CL: HACK to force 115200 at 38400 and 57600 at 19200 Baud */
2314 if ((cflag & CBAUD)== B38400) cflag=cflag - B38400 + B115200;
2315 if ((cflag & CBAUD)== B19200) cflag=cflag - B19200 + B57600;
2316#endif /* SPEED_HACK */
2317
2318 if (cflag & CBAUDEX)
2319 { /* Begin detected CBAUDEX */
2320
2321 ch->digiext.digi_flags |= DIGI_FAST;
2322
2323 /* -------------------------------------------------------------
2324 HUPCL bit is used by FEP to indicate fast baud
2325 table is to be used.
2326 ----------------------------------------------------------------- */
2327
2328 res |= FEP_HUPCL;
2329
2330 } /* End detected CBAUDEX */
2331 else ch->digiext.digi_flags &= ~DIGI_FAST;
2332
2333 /* -------------------------------------------------------------------
2334 CBAUD has bit position 0x1000 set these days to indicate Linux
2335 baud rate remap. Digi hardware can't handle the bit assignment.
2336 (We use a different bit assignment for high speed.). Clear this
2337 bit out.
2338 ---------------------------------------------------------------------- */
2339 res |= cflag & ((CBAUD ^ CBAUDEX) | PARODD | PARENB | CSTOPB | CSIZE);
2340
2341 /* -------------------------------------------------------------
2342 This gets a little confusing. The Digi cards have their own
2343 representation of c_cflags controling baud rate. For the most
2344 part this is identical to the Linux implementation. However;
2345 Digi supports one rate (76800) that Linux doesn't. This means
2346 that the c_cflag entry that would normally mean 76800 for Digi
2347 actually means 115200 under Linux. Without the below mapping,
2348 a stty 115200 would only drive the board at 76800. Since
2349 the rate 230400 is also found after 76800, the same problem afflicts
2350 us when we choose a rate of 230400. Without the below modificiation
2351 stty 230400 would actually give us 115200.
2352
2353 There are two additional differences. The Linux value for CLOCAL
2354 (0x800; 0004000) has no meaning to the Digi hardware. Also in
2355 later releases of Linux; the CBAUD define has CBAUDEX (0x1000;
2356 0010000) ored into it (CBAUD = 0x100f as opposed to 0xf). CBAUDEX
2357 should be checked for a screened out prior to termios2digi_c
2358 returning. Since CLOCAL isn't used by the board this can be
2359 ignored as long as the returned value is used only by Digi hardware.
2360 ----------------------------------------------------------------- */
2361
2362 if (cflag & CBAUDEX)
2363 {
2364 /* -------------------------------------------------------------
2365 The below code is trying to guarantee that only baud rates
2366 115200 and 230400 are remapped. We use exclusive or because
2367 the various baud rates share common bit positions and therefore
2368 can't be tested for easily.
2369 ----------------------------------------------------------------- */
2370
2371
2372 if ((!((cflag & 0x7) ^ (B115200 & ~CBAUDEX))) ||
2373 (!((cflag & 0x7) ^ (B230400 & ~CBAUDEX))))
2374 {
2375 res += 1;
2376 }
2377 }
2378
2379 return res;
2380
2381} /* End termios2digi_c */
2382
2383/* --------------------- Begin epcaparam ----------------------- */
2384
2385static void epcaparam(struct tty_struct *tty, struct channel *ch)
2386{ /* Begin epcaparam */
2387
2388 unsigned int cmdHead;
2389 struct termios *ts;
2390 volatile struct board_chan *bc;
2391 unsigned mval, hflow, cflag, iflag;
2392
2393 bc = ch->brdchan;
2394 epcaassert(bc !=0, "bc out of range");
2395
2396 assertgwinon(ch);
2397
2398 ts = tty->termios;
2399
2400 if ((ts->c_cflag & CBAUD) == 0)
2401 { /* Begin CBAUD detected */
2402
2403 cmdHead = bc->rin;
2404 bc->rout = cmdHead;
2405 cmdHead = bc->tin;
2406
2407 /* Changing baud in mid-stream transmission can be wonderful */
2408 /* ---------------------------------------------------------------
2409 Flush current transmit buffer by setting cmdTail pointer (tout)
2410 to cmdHead pointer (tin). Hopefully the transmit buffer is empty.
2411 ----------------------------------------------------------------- */
2412
2413 fepcmd(ch, STOUT, (unsigned) cmdHead, 0, 0, 0);
2414 mval = 0;
2415
2416 } /* End CBAUD detected */
2417 else
2418 { /* Begin CBAUD not detected */
2419
2420 /* -------------------------------------------------------------------
2421 c_cflags have changed but that change had nothing to do with BAUD.
2422 Propagate the change to the card.
2423 ---------------------------------------------------------------------- */
2424
2425 cflag = termios2digi_c(ch, ts->c_cflag);
2426
2427 if (cflag != ch->fepcflag)
2428 {
2429 ch->fepcflag = cflag;
2430 /* Set baud rate, char size, stop bits, parity */
2431 fepcmd(ch, SETCTRLFLAGS, (unsigned) cflag, 0, 0, 0);
2432 }
2433
2434
2435 /* ----------------------------------------------------------------
2436 If the user has not forced CLOCAL and if the device is not a
2437 CALLOUT device (Which is always CLOCAL) we set flags such that
2438 the driver will wait on carrier detect.
2439 ------------------------------------------------------------------- */
2440
2441 if (ts->c_cflag & CLOCAL)
2442 { /* Begin it is a cud device or a ttyD device with CLOCAL on */
2443 ch->asyncflags &= ~ASYNC_CHECK_CD;
2444 } /* End it is a cud device or a ttyD device with CLOCAL on */
2445 else
2446 { /* Begin it is a ttyD device */
2447 ch->asyncflags |= ASYNC_CHECK_CD;
2448 } /* End it is a ttyD device */
2449
2450 mval = ch->m_dtr | ch->m_rts;
2451
2452 } /* End CBAUD not detected */
2453
2454 iflag = termios2digi_i(ch, ts->c_iflag);
2455
2456 /* Check input mode flags */
2457
2458 if (iflag != ch->fepiflag)
2459 {
2460 ch->fepiflag = iflag;
2461
2462 /* ---------------------------------------------------------------
2463 Command sets channels iflag structure on the board. Such things
2464 as input soft flow control, handling of parity errors, and
2465 break handling are all set here.
2466 ------------------------------------------------------------------- */
2467
2468 /* break handling, parity handling, input stripping, flow control chars */
2469 fepcmd(ch, SETIFLAGS, (unsigned int) ch->fepiflag, 0, 0, 0);
2470 }
2471
2472 /* ---------------------------------------------------------------
2473 Set the board mint value for this channel. This will cause hardware
2474 events to be generated each time the DCD signal (Described in mint)
2475 changes.
2476 ------------------------------------------------------------------- */
2477 bc->mint = ch->dcd;
2478
2479 if ((ts->c_cflag & CLOCAL) || (ch->digiext.digi_flags & DIGI_FORCEDCD))
2480 if (ch->digiext.digi_flags & DIGI_FORCEDCD)
2481 bc->mint = 0;
2482
2483 ch->imodem = bc->mstat;
2484
2485 hflow = termios2digi_h(ch, ts->c_cflag);
2486
2487 if (hflow != ch->hflow)
2488 {
2489 ch->hflow = hflow;
2490
2491 /* --------------------------------------------------------------
2492 Hard flow control has been selected but the board is not
2493 using it. Activate hard flow control now.
2494 ----------------------------------------------------------------- */
2495
2496 fepcmd(ch, SETHFLOW, hflow, 0xff, 0, 1);
2497 }
2498
2499
2500 mval ^= ch->modemfake & (mval ^ ch->modem);
2501
2502 if (ch->omodem ^ mval)
2503 {
2504 ch->omodem = mval;
2505
2506 /* --------------------------------------------------------------
2507 The below command sets the DTR and RTS mstat structure. If
2508 hard flow control is NOT active these changes will drive the
2509 output of the actual DTR and RTS lines. If hard flow control
2510 is active, the changes will be saved in the mstat structure and
2511 only asserted when hard flow control is turned off.
2512 ----------------------------------------------------------------- */
2513
2514 /* First reset DTR & RTS; then set them */
2515 fepcmd(ch, SETMODEM, 0, ((ch->m_dtr)|(ch->m_rts)), 0, 1);
2516 fepcmd(ch, SETMODEM, mval, 0, 0, 1);
2517
2518 }
2519
2520 if (ch->startc != ch->fepstartc || ch->stopc != ch->fepstopc)
2521 {
2522 ch->fepstartc = ch->startc;
2523 ch->fepstopc = ch->stopc;
2524
2525 /* ------------------------------------------------------------
2526 The XON / XOFF characters have changed; propagate these
2527 changes to the card.
2528 --------------------------------------------------------------- */
2529
2530 fepcmd(ch, SONOFFC, ch->fepstartc, ch->fepstopc, 0, 1);
2531 }
2532
2533 if (ch->startca != ch->fepstartca || ch->stopca != ch->fepstopca)
2534 {
2535 ch->fepstartca = ch->startca;
2536 ch->fepstopca = ch->stopca;
2537
2538 /* ---------------------------------------------------------------
2539 Similar to the above, this time the auxilarly XON / XOFF
2540 characters have changed; propagate these changes to the card.
2541 ------------------------------------------------------------------ */
2542
2543 fepcmd(ch, SAUXONOFFC, ch->fepstartca, ch->fepstopca, 0, 1);
2544 }
2545
2546} /* End epcaparam */
2547
2548/* --------------------- Begin receive_data ----------------------- */
2549
2550static void receive_data(struct channel *ch)
2551{ /* Begin receive_data */
2552
2553 unchar *rptr;
2554 struct termios *ts = NULL;
2555 struct tty_struct *tty;
2556 volatile struct board_chan *bc;
2557 register int dataToRead, wrapgap, bytesAvailable;
2558 register unsigned int tail, head;
2559 unsigned int wrapmask;
2560 int rc;
2561
2562
2563 /* ---------------------------------------------------------------
2564 This routine is called by doint when a receive data event
2565 has taken place.
2566 ------------------------------------------------------------------- */
2567
2568 globalwinon(ch);
2569
2570 if (ch->statusflags & RXSTOPPED)
2571 return;
2572
2573 tty = ch->tty;
2574 if (tty)
2575 ts = tty->termios;
2576
2577 bc = ch->brdchan;
2578
2579 if (!bc)
2580 {
2581 printk(KERN_ERR "<Error> - bc is NULL in receive_data!\n");
2582 return;
2583 }
2584
2585 wrapmask = ch->rxbufsize - 1;
2586
2587 /* ---------------------------------------------------------------------
2588 Get the head and tail pointers to the receiver queue. Wrap the
2589 head pointer if it has reached the end of the buffer.
2590 ------------------------------------------------------------------------ */
2591
2592 head = bc->rin;
2593 head &= wrapmask;
2594 tail = bc->rout & wrapmask;
2595
2596 bytesAvailable = (head - tail) & wrapmask;
2597
2598 if (bytesAvailable == 0)
2599 return;
2600
2601 /* ------------------------------------------------------------------
2602 If CREAD bit is off or device not open, set TX tail to head
2603 --------------------------------------------------------------------- */
2604
2605 if (!tty || !ts || !(ts->c_cflag & CREAD))
2606 {
2607 bc->rout = head;
2608 return;
2609 }
2610
2611 if (tty->flip.count == TTY_FLIPBUF_SIZE)
2612 return;
2613
2614 if (bc->orun)
2615 {
2616 bc->orun = 0;
2617 printk(KERN_WARNING "overrun! DigiBoard device %s\n",tty->name);
2618 }
2619
2620 rxwinon(ch);
2621 rptr = tty->flip.char_buf_ptr;
2622 rc = tty->flip.count;
2623
2624 while (bytesAvailable > 0)
2625 { /* Begin while there is data on the card */
2626
2627 wrapgap = (head >= tail) ? head - tail : ch->rxbufsize - tail;
2628
2629 /* ---------------------------------------------------------------
2630 Even if head has wrapped around only report the amount of
2631 data to be equal to the size - tail. Remember memcpy can't
2632 automaticly wrap around the receive buffer.
2633 ----------------------------------------------------------------- */
2634
2635 dataToRead = (wrapgap < bytesAvailable) ? wrapgap : bytesAvailable;
2636
2637 /* --------------------------------------------------------------
2638 Make sure we don't overflow the buffer
2639 ----------------------------------------------------------------- */
2640
2641 if ((rc + dataToRead) > TTY_FLIPBUF_SIZE)
2642 dataToRead = TTY_FLIPBUF_SIZE - rc;
2643
2644 if (dataToRead == 0)
2645 break;
2646
2647 /* ---------------------------------------------------------------
2648 Move data read from our card into the line disciplines buffer
2649 for translation if necessary.
2650 ------------------------------------------------------------------ */
2651
2652 if ((memcpy(rptr, ch->rxptr + tail, dataToRead)) != rptr)
2653 printk(KERN_ERR "<Error> - receive_data : memcpy failed\n");
2654
2655 rc += dataToRead;
2656 rptr += dataToRead;
2657 tail = (tail + dataToRead) & wrapmask;
2658 bytesAvailable -= dataToRead;
2659
2660 } /* End while there is data on the card */
2661
2662
2663 tty->flip.count = rc;
2664 tty->flip.char_buf_ptr = rptr;
2665 globalwinon(ch);
2666 bc->rout = tail;
2667
2668 /* Must be called with global data */
2669 tty_schedule_flip(ch->tty);
2670 return;
2671
2672} /* End receive_data */
2673
2674static int info_ioctl(struct tty_struct *tty, struct file * file,
2675 unsigned int cmd, unsigned long arg)
2676{
2677 switch (cmd)
2678 { /* Begin switch cmd */
2679
2680 case DIGI_GETINFO:
2681 { /* Begin case DIGI_GETINFO */
2682
2683 struct digi_info di ;
2684 int brd;
2685
2686 getUser(brd, (unsigned int __user *)arg);
2687
2688 if ((brd < 0) || (brd >= num_cards) || (num_cards == 0))
2689 return (-ENODEV);
2690
2691 memset(&di, 0, sizeof(di));
2692
2693 di.board = brd ;
2694 di.status = boards[brd].status;
2695 di.type = boards[brd].type ;
2696 di.numports = boards[brd].numports ;
2697 di.port = boards[brd].port ;
2698 di.membase = boards[brd].membase ;
2699
2700 if (copy_to_user((void __user *)arg, &di, sizeof (di)))
2701 return -EFAULT;
2702 break;
2703
2704 } /* End case DIGI_GETINFO */
2705
2706 case DIGI_POLLER:
2707 { /* Begin case DIGI_POLLER */
2708
2709 int brd = arg & 0xff000000 >> 16 ;
2710 unsigned char state = arg & 0xff ;
2711
2712 if ((brd < 0) || (brd >= num_cards))
2713 {
2714 printk(KERN_ERR "<Error> - DIGI POLLER : brd not valid!\n");
2715 return (-ENODEV);
2716 }
2717
2718 digi_poller_inhibited = state ;
2719 break ;
2720
2721 } /* End case DIGI_POLLER */
2722
2723 case DIGI_INIT:
2724 { /* Begin case DIGI_INIT */
2725
2726 /* ------------------------------------------------------------
2727 This call is made by the apps to complete the initilization
2728 of the board(s). This routine is responsible for setting
2729 the card to its initial state and setting the drivers control
2730 fields to the sutianle settings for the card in question.
2731 ---------------------------------------------------------------- */
2732
2733 int crd ;
2734 for (crd = 0; crd < num_cards; crd++)
2735 post_fep_init (crd);
2736
2737 break ;
2738
2739 } /* End case DIGI_INIT */
2740
2741
2742 default:
2743 return -ENOIOCTLCMD;
2744
2745 } /* End switch cmd */
2746 return (0) ;
2747}
2748/* --------------------- Begin pc_ioctl ----------------------- */
2749
2750static int pc_tiocmget(struct tty_struct *tty, struct file *file)
2751{
2752 struct channel *ch = (struct channel *) tty->driver_data;
2753 volatile struct board_chan *bc;
2754 unsigned int mstat, mflag = 0;
2755 unsigned long flags;
2756
2757 if (ch)
2758 bc = ch->brdchan;
2759 else
2760 {
2761 printk(KERN_ERR "<Error> - ch is NULL in pc_tiocmget!\n");
2762 return(-EINVAL);
2763 }
2764
2765 save_flags(flags);
2766 cli();
2767 globalwinon(ch);
2768 mstat = bc->mstat;
2769 memoff(ch);
2770 restore_flags(flags);
2771
2772 if (mstat & ch->m_dtr)
2773 mflag |= TIOCM_DTR;
2774
2775 if (mstat & ch->m_rts)
2776 mflag |= TIOCM_RTS;
2777
2778 if (mstat & ch->m_cts)
2779 mflag |= TIOCM_CTS;
2780
2781 if (mstat & ch->dsr)
2782 mflag |= TIOCM_DSR;
2783
2784 if (mstat & ch->m_ri)
2785 mflag |= TIOCM_RI;
2786
2787 if (mstat & ch->dcd)
2788 mflag |= TIOCM_CD;
2789
2790 return mflag;
2791}
2792
2793static int pc_tiocmset(struct tty_struct *tty, struct file *file,
2794 unsigned int set, unsigned int clear)
2795{
2796 struct channel *ch = (struct channel *) tty->driver_data;
2797 unsigned long flags;
2798
2799 if (!ch) {
2800 printk(KERN_ERR "<Error> - ch is NULL in pc_tiocmset!\n");
2801 return(-EINVAL);
2802 }
2803
2804 save_flags(flags);
2805 cli();
2806 /*
2807 * I think this modemfake stuff is broken. It doesn't
2808 * correctly reflect the behaviour desired by the TIOCM*
2809 * ioctls. Therefore this is probably broken.
2810 */
2811 if (set & TIOCM_RTS) {
2812 ch->modemfake |= ch->m_rts;
2813 ch->modem |= ch->m_rts;
2814 }
2815 if (set & TIOCM_DTR) {
2816 ch->modemfake |= ch->m_dtr;
2817 ch->modem |= ch->m_dtr;
2818 }
2819 if (clear & TIOCM_RTS) {
2820 ch->modemfake |= ch->m_rts;
2821 ch->modem &= ~ch->m_rts;
2822 }
2823 if (clear & TIOCM_DTR) {
2824 ch->modemfake |= ch->m_dtr;
2825 ch->modem &= ~ch->m_dtr;
2826 }
2827
2828 globalwinon(ch);
2829
2830 /* --------------------------------------------------------------
2831 The below routine generally sets up parity, baud, flow control
2832 issues, etc.... It effect both control flags and input flags.
2833 ------------------------------------------------------------------ */
2834
2835 epcaparam(tty,ch);
2836 memoff(ch);
2837 restore_flags(flags);
2838 return 0;
2839}
2840
2841static int pc_ioctl(struct tty_struct *tty, struct file * file,
2842 unsigned int cmd, unsigned long arg)
2843{ /* Begin pc_ioctl */
2844
2845 digiflow_t dflow;
2846 int retval;
2847 unsigned long flags;
2848 unsigned int mflag, mstat;
2849 unsigned char startc, stopc;
2850 volatile struct board_chan *bc;
2851 struct channel *ch = (struct channel *) tty->driver_data;
2852 void __user *argp = (void __user *)arg;
2853
2854 if (ch)
2855 bc = ch->brdchan;
2856 else
2857 {
2858 printk(KERN_ERR "<Error> - ch is NULL in pc_ioctl!\n");
2859 return(-EINVAL);
2860 }
2861
2862 save_flags(flags);
2863
2864 /* -------------------------------------------------------------------
2865 For POSIX compliance we need to add more ioctls. See tty_ioctl.c
2866 in /usr/src/linux/drivers/char for a good example. In particular
2867 think about adding TCSETAF, TCSETAW, TCSETA, TCSETSF, TCSETSW, TCSETS.
2868 ---------------------------------------------------------------------- */
2869
2870 switch (cmd)
2871 { /* Begin switch cmd */
2872
2873 case TCGETS:
2874 if (copy_to_user(argp,
2875 tty->termios, sizeof(struct termios)))
2876 return -EFAULT;
2877 return(0);
2878
2879 case TCGETA:
2880 return get_termio(tty, argp);
2881
2882 case TCSBRK: /* SVID version: non-zero arg --> no break */
2883
2884 retval = tty_check_change(tty);
2885 if (retval)
2886 return retval;
2887
2888 /* Setup an event to indicate when the transmit buffer empties */
2889
2890 setup_empty_event(tty,ch);
2891 tty_wait_until_sent(tty, 0);
2892 if (!arg)
2893 digi_send_break(ch, HZ/4); /* 1/4 second */
2894 return 0;
2895
2896 case TCSBRKP: /* support for POSIX tcsendbreak() */
2897
2898 retval = tty_check_change(tty);
2899 if (retval)
2900 return retval;
2901
2902 /* Setup an event to indicate when the transmit buffer empties */
2903
2904 setup_empty_event(tty,ch);
2905 tty_wait_until_sent(tty, 0);
2906 digi_send_break(ch, arg ? arg*(HZ/10) : HZ/4);
2907 return 0;
2908
2909 case TIOCGSOFTCAR:
2910 if (put_user(C_CLOCAL(tty)?1:0, (unsigned long __user *)arg))
2911 return -EFAULT;
2912 return 0;
2913
2914 case TIOCSSOFTCAR:
2915 {
2916 unsigned int value;
2917
2918 if (get_user(value, (unsigned __user *)argp))
2919 return -EFAULT;
2920 tty->termios->c_cflag =
2921 ((tty->termios->c_cflag & ~CLOCAL) |
2922 (value ? CLOCAL : 0));
2923 return 0;
2924 }
2925
2926 case TIOCMODG:
2927 mflag = pc_tiocmget(tty, file);
2928 if (put_user(mflag, (unsigned long __user *)argp))
2929 return -EFAULT;
2930 break;
2931
2932 case TIOCMODS:
2933 if (get_user(mstat, (unsigned __user *)argp))
2934 return -EFAULT;
2935 return pc_tiocmset(tty, file, mstat, ~mstat);
2936
2937 case TIOCSDTR:
2938 ch->omodem |= ch->m_dtr;
2939 cli();
2940 globalwinon(ch);
2941 fepcmd(ch, SETMODEM, ch->m_dtr, 0, 10, 1);
2942 memoff(ch);
2943 restore_flags(flags);
2944 break;
2945
2946 case TIOCCDTR:
2947 ch->omodem &= ~ch->m_dtr;
2948 cli();
2949 globalwinon(ch);
2950 fepcmd(ch, SETMODEM, 0, ch->m_dtr, 10, 1);
2951 memoff(ch);
2952 restore_flags(flags);
2953 break;
2954
2955 case DIGI_GETA:
2956 if (copy_to_user(argp, &ch->digiext, sizeof(digi_t)))
2957 return -EFAULT;
2958 break;
2959
2960 case DIGI_SETAW:
2961 case DIGI_SETAF:
2962 if ((cmd) == (DIGI_SETAW))
2963 {
2964 /* Setup an event to indicate when the transmit buffer empties */
2965
2966 setup_empty_event(tty,ch);
2967 tty_wait_until_sent(tty, 0);
2968 }
2969 else
2970 {
2971 /* ldisc lock already held in ioctl */
2972 if (tty->ldisc.flush_buffer)
2973 tty->ldisc.flush_buffer(tty);
2974 }
2975
2976 /* Fall Thru */
2977
2978 case DIGI_SETA:
2979 if (copy_from_user(&ch->digiext, argp, sizeof(digi_t)))
2980 return -EFAULT;
2981
2982 if (ch->digiext.digi_flags & DIGI_ALTPIN)
2983 {
2984 ch->dcd = ch->m_dsr;
2985 ch->dsr = ch->m_dcd;
2986 }
2987 else
2988 {
2989 ch->dcd = ch->m_dcd;
2990 ch->dsr = ch->m_dsr;
2991 }
2992
2993 cli();
2994 globalwinon(ch);
2995
2996 /* -----------------------------------------------------------------
2997 The below routine generally sets up parity, baud, flow control
2998 issues, etc.... It effect both control flags and input flags.
2999 ------------------------------------------------------------------- */
3000
3001 epcaparam(tty,ch);
3002 memoff(ch);
3003 restore_flags(flags);
3004 break;
3005
3006 case DIGI_GETFLOW:
3007 case DIGI_GETAFLOW:
3008 cli();
3009 globalwinon(ch);
3010 if ((cmd) == (DIGI_GETFLOW))
3011 {
3012 dflow.startc = bc->startc;
3013 dflow.stopc = bc->stopc;
3014 }
3015 else
3016 {
3017 dflow.startc = bc->startca;
3018 dflow.stopc = bc->stopca;
3019 }
3020 memoff(ch);
3021 restore_flags(flags);
3022
3023 if (copy_to_user(argp, &dflow, sizeof(dflow)))
3024 return -EFAULT;
3025 break;
3026
3027 case DIGI_SETAFLOW:
3028 case DIGI_SETFLOW:
3029 if ((cmd) == (DIGI_SETFLOW))
3030 {
3031 startc = ch->startc;
3032 stopc = ch->stopc;
3033 }
3034 else
3035 {
3036 startc = ch->startca;
3037 stopc = ch->stopca;
3038 }
3039
3040 if (copy_from_user(&dflow, argp, sizeof(dflow)))
3041 return -EFAULT;
3042
3043 if (dflow.startc != startc || dflow.stopc != stopc)
3044 { /* Begin if setflow toggled */
3045 cli();
3046 globalwinon(ch);
3047
3048 if ((cmd) == (DIGI_SETFLOW))
3049 {
3050 ch->fepstartc = ch->startc = dflow.startc;
3051 ch->fepstopc = ch->stopc = dflow.stopc;
3052 fepcmd(ch, SONOFFC, ch->fepstartc, ch->fepstopc, 0, 1);
3053 }
3054 else
3055 {
3056 ch->fepstartca = ch->startca = dflow.startc;
3057 ch->fepstopca = ch->stopca = dflow.stopc;
3058 fepcmd(ch, SAUXONOFFC, ch->fepstartca, ch->fepstopca, 0, 1);
3059 }
3060
3061 if (ch->statusflags & TXSTOPPED)
3062 pc_start(tty);
3063
3064 memoff(ch);
3065 restore_flags(flags);
3066
3067 } /* End if setflow toggled */
3068 break;
3069
3070 default:
3071 return -ENOIOCTLCMD;
3072
3073 } /* End switch cmd */
3074
3075 return 0;
3076
3077} /* End pc_ioctl */
3078
3079/* --------------------- Begin pc_set_termios ----------------------- */
3080
3081static void pc_set_termios(struct tty_struct *tty, struct termios *old_termios)
3082{ /* Begin pc_set_termios */
3083
3084 struct channel *ch;
3085 unsigned long flags;
3086
3087 /* ---------------------------------------------------------
3088 verifyChannel returns the channel from the tty struct
3089 if it is valid. This serves as a sanity check.
3090 ------------------------------------------------------------- */
3091
3092 if ((ch = verifyChannel(tty)) != NULL)
3093 { /* Begin if channel valid */
3094
3095 save_flags(flags);
3096 cli();
3097 globalwinon(ch);
3098 epcaparam(tty, ch);
3099 memoff(ch);
3100
3101 if ((old_termios->c_cflag & CRTSCTS) &&
3102 ((tty->termios->c_cflag & CRTSCTS) == 0))
3103 tty->hw_stopped = 0;
3104
3105 if (!(old_termios->c_cflag & CLOCAL) &&
3106 (tty->termios->c_cflag & CLOCAL))
3107 wake_up_interruptible(&ch->open_wait);
3108
3109 restore_flags(flags);
3110
3111 } /* End if channel valid */
3112
3113} /* End pc_set_termios */
3114
3115/* --------------------- Begin do_softint ----------------------- */
3116
3117static void do_softint(void *private_)
3118{ /* Begin do_softint */
3119
3120 struct channel *ch = (struct channel *) private_;
3121
3122
3123 /* Called in response to a modem change event */
3124
3125 if (ch && ch->magic == EPCA_MAGIC)
3126 { /* Begin EPCA_MAGIC */
3127
3128 struct tty_struct *tty = ch->tty;
3129
3130 if (tty && tty->driver_data)
3131 {
3132 if (test_and_clear_bit(EPCA_EVENT_HANGUP, &ch->event))
3133 { /* Begin if clear_bit */
3134
3135 tty_hangup(tty); /* FIXME: module removal race here - AKPM */
3136 wake_up_interruptible(&ch->open_wait);
3137 ch->asyncflags &= ~ASYNC_NORMAL_ACTIVE;
3138
3139 } /* End if clear_bit */
3140 }
3141
3142 } /* End EPCA_MAGIC */
3143} /* End do_softint */
3144
3145/* ------------------------------------------------------------
3146 pc_stop and pc_start provide software flow control to the
3147 routine and the pc_ioctl routine.
3148---------------------------------------------------------------- */
3149
3150/* --------------------- Begin pc_stop ----------------------- */
3151
3152static void pc_stop(struct tty_struct *tty)
3153{ /* Begin pc_stop */
3154
3155 struct channel *ch;
3156 unsigned long flags;
3157
3158 /* ---------------------------------------------------------
3159 verifyChannel returns the channel from the tty struct
3160 if it is valid. This serves as a sanity check.
3161 ------------------------------------------------------------- */
3162
3163 if ((ch = verifyChannel(tty)) != NULL)
3164 { /* Begin if valid channel */
3165
3166 save_flags(flags);
3167 cli();
3168
3169 if ((ch->statusflags & TXSTOPPED) == 0)
3170 { /* Begin if transmit stop requested */
3171
3172 globalwinon(ch);
3173
3174 /* STOP transmitting now !! */
3175
3176 fepcmd(ch, PAUSETX, 0, 0, 0, 0);
3177
3178 ch->statusflags |= TXSTOPPED;
3179 memoff(ch);
3180
3181 } /* End if transmit stop requested */
3182
3183 restore_flags(flags);
3184
3185 } /* End if valid channel */
3186
3187} /* End pc_stop */
3188
3189/* --------------------- Begin pc_start ----------------------- */
3190
3191static void pc_start(struct tty_struct *tty)
3192{ /* Begin pc_start */
3193
3194 struct channel *ch;
3195
3196 /* ---------------------------------------------------------
3197 verifyChannel returns the channel from the tty struct
3198 if it is valid. This serves as a sanity check.
3199 ------------------------------------------------------------- */
3200
3201 if ((ch = verifyChannel(tty)) != NULL)
3202 { /* Begin if channel valid */
3203
3204 unsigned long flags;
3205
3206 save_flags(flags);
3207 cli();
3208
3209 /* Just in case output was resumed because of a change in Digi-flow */
3210 if (ch->statusflags & TXSTOPPED)
3211 { /* Begin transmit resume requested */
3212
3213 volatile struct board_chan *bc;
3214
3215 globalwinon(ch);
3216 bc = ch->brdchan;
3217 if (ch->statusflags & LOWWAIT)
3218 bc->ilow = 1;
3219
3220 /* Okay, you can start transmitting again... */
3221
3222 fepcmd(ch, RESUMETX, 0, 0, 0, 0);
3223
3224 ch->statusflags &= ~TXSTOPPED;
3225 memoff(ch);
3226
3227 } /* End transmit resume requested */
3228
3229 restore_flags(flags);
3230
3231 } /* End if channel valid */
3232
3233} /* End pc_start */
3234
3235/* ------------------------------------------------------------------
3236 The below routines pc_throttle and pc_unthrottle are used
3237 to slow (And resume) the receipt of data into the kernels
3238 receive buffers. The exact occurrence of this depends on the
3239 size of the kernels receive buffer and what the 'watermarks'
3240 are set to for that buffer. See the n_ttys.c file for more
3241 details.
3242______________________________________________________________________ */
3243/* --------------------- Begin throttle ----------------------- */
3244
3245static void pc_throttle(struct tty_struct * tty)
3246{ /* Begin pc_throttle */
3247
3248 struct channel *ch;
3249 unsigned long flags;
3250
3251 /* ---------------------------------------------------------
3252 verifyChannel returns the channel from the tty struct
3253 if it is valid. This serves as a sanity check.
3254 ------------------------------------------------------------- */
3255
3256 if ((ch = verifyChannel(tty)) != NULL)
3257 { /* Begin if channel valid */
3258
3259
3260 save_flags(flags);
3261 cli();
3262
3263 if ((ch->statusflags & RXSTOPPED) == 0)
3264 {
3265 globalwinon(ch);
3266 fepcmd(ch, PAUSERX, 0, 0, 0, 0);
3267
3268 ch->statusflags |= RXSTOPPED;
3269 memoff(ch);
3270 }
3271 restore_flags(flags);
3272
3273 } /* End if channel valid */
3274
3275} /* End pc_throttle */
3276
3277/* --------------------- Begin unthrottle ----------------------- */
3278
3279static void pc_unthrottle(struct tty_struct *tty)
3280{ /* Begin pc_unthrottle */
3281
3282 struct channel *ch;
3283 unsigned long flags;
3284 volatile struct board_chan *bc;
3285
3286
3287 /* ---------------------------------------------------------
3288 verifyChannel returns the channel from the tty struct
3289 if it is valid. This serves as a sanity check.
3290 ------------------------------------------------------------- */
3291
3292 if ((ch = verifyChannel(tty)) != NULL)
3293 { /* Begin if channel valid */
3294
3295
3296 /* Just in case output was resumed because of a change in Digi-flow */
3297 save_flags(flags);
3298 cli();
3299
3300 if (ch->statusflags & RXSTOPPED)
3301 {
3302
3303 globalwinon(ch);
3304 bc = ch->brdchan;
3305 fepcmd(ch, RESUMERX, 0, 0, 0, 0);
3306
3307 ch->statusflags &= ~RXSTOPPED;
3308 memoff(ch);
3309 }
3310 restore_flags(flags);
3311
3312 } /* End if channel valid */
3313
3314} /* End pc_unthrottle */
3315
3316/* --------------------- Begin digi_send_break ----------------------- */
3317
3318void digi_send_break(struct channel *ch, int msec)
3319{ /* Begin digi_send_break */
3320
3321 unsigned long flags;
3322
3323 save_flags(flags);
3324 cli();
3325 globalwinon(ch);
3326
3327 /* --------------------------------------------------------------------
3328 Maybe I should send an infinite break here, schedule() for
3329 msec amount of time, and then stop the break. This way,
3330 the user can't screw up the FEP by causing digi_send_break()
3331 to be called (i.e. via an ioctl()) more than once in msec amount
3332 of time. Try this for now...
3333 ------------------------------------------------------------------------ */
3334
3335 fepcmd(ch, SENDBREAK, msec, 0, 10, 0);
3336 memoff(ch);
3337
3338 restore_flags(flags);
3339
3340} /* End digi_send_break */
3341
3342/* --------------------- Begin setup_empty_event ----------------------- */
3343
3344static void setup_empty_event(struct tty_struct *tty, struct channel *ch)
3345{ /* Begin setup_empty_event */
3346
3347 volatile struct board_chan *bc = ch->brdchan;
3348 unsigned long int flags;
3349
3350 save_flags(flags);
3351 cli();
3352 globalwinon(ch);
3353 ch->statusflags |= EMPTYWAIT;
3354
3355 /* ------------------------------------------------------------------
3356 When set the iempty flag request a event to be generated when the
3357 transmit buffer is empty (If there is no BREAK in progress).
3358 --------------------------------------------------------------------- */
3359
3360 bc->iempty = 1;
3361 memoff(ch);
3362 restore_flags(flags);
3363
3364} /* End setup_empty_event */
3365
3366/* --------------------- Begin get_termio ----------------------- */
3367
3368static int get_termio(struct tty_struct * tty, struct termio __user * termio)
3369{ /* Begin get_termio */
3370 return kernel_termios_to_user_termio(termio, tty->termios);
3371} /* End get_termio */
3372/* ---------------------- Begin epca_setup -------------------------- */
3373void epca_setup(char *str, int *ints)
3374{ /* Begin epca_setup */
3375
3376 struct board_info board;
3377 int index, loop, last;
3378 char *temp, *t2;
3379 unsigned len;
3380
3381 /* ----------------------------------------------------------------------
3382 If this routine looks a little strange it is because it is only called
3383 if a LILO append command is given to boot the kernel with parameters.
3384 In this way, we can provide the user a method of changing his board
3385 configuration without rebuilding the kernel.
3386 ----------------------------------------------------------------------- */
3387 if (!liloconfig)
3388 liloconfig = 1;
3389
3390 memset(&board, 0, sizeof(board));
3391
3392 /* Assume the data is int first, later we can change it */
3393 /* I think that array position 0 of ints holds the number of args */
3394 for (last = 0, index = 1; index <= ints[0]; index++)
3395 switch(index)
3396 { /* Begin parse switch */
3397
3398 case 1:
3399 board.status = ints[index];
3400
3401 /* ---------------------------------------------------------
3402 We check for 2 (As opposed to 1; because 2 is a flag
3403 instructing the driver to ignore epcaconfig.) For this
3404 reason we check for 2.
3405 ------------------------------------------------------------ */
3406 if (board.status == 2)
3407 { /* Begin ignore epcaconfig as well as lilo cmd line */
3408 nbdevs = 0;
3409 num_cards = 0;
3410 return;
3411 } /* End ignore epcaconfig as well as lilo cmd line */
3412
3413 if (board.status > 2)
3414 {
3415 printk(KERN_ERR "<Error> - epca_setup: Invalid board status 0x%x\n", board.status);
3416 invalid_lilo_config = 1;
3417 setup_error_code |= INVALID_BOARD_STATUS;
3418 return;
3419 }
3420 last = index;
3421 break;
3422
3423 case 2:
3424 board.type = ints[index];
3425 if (board.type >= PCIXEM)
3426 {
3427 printk(KERN_ERR "<Error> - epca_setup: Invalid board type 0x%x\n", board.type);
3428 invalid_lilo_config = 1;
3429 setup_error_code |= INVALID_BOARD_TYPE;
3430 return;
3431 }
3432 last = index;
3433 break;
3434
3435 case 3:
3436 board.altpin = ints[index];
3437 if (board.altpin > 1)
3438 {
3439 printk(KERN_ERR "<Error> - epca_setup: Invalid board altpin 0x%x\n", board.altpin);
3440 invalid_lilo_config = 1;
3441 setup_error_code |= INVALID_ALTPIN;
3442 return;
3443 }
3444 last = index;
3445 break;
3446
3447 case 4:
3448 board.numports = ints[index];
3449 if ((board.numports < 2) || (board.numports > 256))
3450 {
3451 printk(KERN_ERR "<Error> - epca_setup: Invalid board numports 0x%x\n", board.numports);
3452 invalid_lilo_config = 1;
3453 setup_error_code |= INVALID_NUM_PORTS;
3454 return;
3455 }
3456 nbdevs += board.numports;
3457 last = index;
3458 break;
3459
3460 case 5:
3461 board.port = (unsigned char *)ints[index];
3462 if (ints[index] <= 0)
3463 {
3464 printk(KERN_ERR "<Error> - epca_setup: Invalid io port 0x%x\n", (unsigned int)board.port);
3465 invalid_lilo_config = 1;
3466 setup_error_code |= INVALID_PORT_BASE;
3467 return;
3468 }
3469 last = index;
3470 break;
3471
3472 case 6:
3473 board.membase = (unsigned char *)ints[index];
3474 if (ints[index] <= 0)
3475 {
3476 printk(KERN_ERR "<Error> - epca_setup: Invalid memory base 0x%x\n",(unsigned int)board.membase);
3477 invalid_lilo_config = 1;
3478 setup_error_code |= INVALID_MEM_BASE;
3479 return;
3480 }
3481 last = index;
3482 break;
3483
3484 default:
3485 printk(KERN_ERR "<Error> - epca_setup: Too many integer parms\n");
3486 return;
3487
3488 } /* End parse switch */
3489
3490 while (str && *str)
3491 { /* Begin while there is a string arg */
3492
3493 /* find the next comma or terminator */
3494 temp = str;
3495
3496 /* While string is not null, and a comma hasn't been found */
3497 while (*temp && (*temp != ','))
3498 temp++;
3499
3500 if (!*temp)
3501 temp = NULL;
3502 else
3503 *temp++ = 0;
3504
3505 /* Set index to the number of args + 1 */
3506 index = last + 1;
3507
3508 switch(index)
3509 {
3510 case 1:
3511 len = strlen(str);
3512 if (strncmp("Disable", str, len) == 0)
3513 board.status = 0;
3514 else
3515 if (strncmp("Enable", str, len) == 0)
3516 board.status = 1;
3517 else
3518 {
3519 printk(KERN_ERR "<Error> - epca_setup: Invalid status %s\n", str);
3520 invalid_lilo_config = 1;
3521 setup_error_code |= INVALID_BOARD_STATUS;
3522 return;
3523 }
3524 last = index;
3525 break;
3526
3527 case 2:
3528
3529 for(loop = 0; loop < EPCA_NUM_TYPES; loop++)
3530 if (strcmp(board_desc[loop], str) == 0)
3531 break;
3532
3533
3534 /* ---------------------------------------------------------------
3535 If the index incremented above refers to a legitamate board
3536 type set it here.
3537 ------------------------------------------------------------------*/
3538
3539 if (index < EPCA_NUM_TYPES)
3540 board.type = loop;
3541 else
3542 {
3543 printk(KERN_ERR "<Error> - epca_setup: Invalid board type: %s\n", str);
3544 invalid_lilo_config = 1;
3545 setup_error_code |= INVALID_BOARD_TYPE;
3546 return;
3547 }
3548 last = index;
3549 break;
3550
3551 case 3:
3552 len = strlen(str);
3553 if (strncmp("Disable", str, len) == 0)
3554 board.altpin = 0;
3555 else
3556 if (strncmp("Enable", str, len) == 0)
3557 board.altpin = 1;
3558 else
3559 {
3560 printk(KERN_ERR "<Error> - epca_setup: Invalid altpin %s\n", str);
3561 invalid_lilo_config = 1;
3562 setup_error_code |= INVALID_ALTPIN;
3563 return;
3564 }
3565 last = index;
3566 break;
3567
3568 case 4:
3569 t2 = str;
3570 while (isdigit(*t2))
3571 t2++;
3572
3573 if (*t2)
3574 {
3575 printk(KERN_ERR "<Error> - epca_setup: Invalid port count %s\n", str);
3576 invalid_lilo_config = 1;
3577 setup_error_code |= INVALID_NUM_PORTS;
3578 return;
3579 }
3580
3581 /* ------------------------------------------------------------
3582 There is not a man page for simple_strtoul but the code can be
3583 found in vsprintf.c. The first argument is the string to
3584 translate (To an unsigned long obviously), the second argument
3585 can be the address of any character variable or a NULL. If a
3586 variable is given, the end pointer of the string will be stored
3587 in that variable; if a NULL is given the end pointer will
3588 not be returned. The last argument is the base to use. If
3589 a 0 is indicated, the routine will attempt to determine the
3590 proper base by looking at the values prefix (A '0' for octal,
3591 a 'x' for hex, etc ... If a value is given it will use that
3592 value as the base.
3593 ---------------------------------------------------------------- */
3594 board.numports = simple_strtoul(str, NULL, 0);
3595 nbdevs += board.numports;
3596 last = index;
3597 break;
3598
3599 case 5:
3600 t2 = str;
3601 while (isxdigit(*t2))
3602 t2++;
3603
3604 if (*t2)
3605 {
3606 printk(KERN_ERR "<Error> - epca_setup: Invalid i/o address %s\n", str);
3607 invalid_lilo_config = 1;
3608 setup_error_code |= INVALID_PORT_BASE;
3609 return;
3610 }
3611
3612 board.port = (unsigned char *)simple_strtoul(str, NULL, 16);
3613 last = index;
3614 break;
3615
3616 case 6:
3617 t2 = str;
3618 while (isxdigit(*t2))
3619 t2++;
3620
3621 if (*t2)
3622 {
3623 printk(KERN_ERR "<Error> - epca_setup: Invalid memory base %s\n",str);
3624 invalid_lilo_config = 1;
3625 setup_error_code |= INVALID_MEM_BASE;
3626 return;
3627 }
3628
3629 board.membase = (unsigned char *)simple_strtoul(str, NULL, 16);
3630 last = index;
3631 break;
3632
3633 default:
3634 printk(KERN_ERR "PC/Xx: Too many string parms\n");
3635 return;
3636 }
3637 str = temp;
3638
3639 } /* End while there is a string arg */
3640
3641
3642 if (last < 6)
3643 {
3644 printk(KERN_ERR "PC/Xx: Insufficient parms specified\n");
3645 return;
3646 }
3647
3648 /* I should REALLY validate the stuff here */
3649
3650 /* Copies our local copy of board into boards */
3651 memcpy((void *)&boards[num_cards],(void *)&board, sizeof(board));
3652
3653
3654 /* Does this get called once per lilo arg are what ? */
3655
3656 printk(KERN_INFO "PC/Xx: Added board %i, %s %i ports at 0x%4.4X base 0x%6.6X\n",
3657 num_cards, board_desc[board.type],
3658 board.numports, (int)board.port, (unsigned int) board.membase);
3659
3660 num_cards++;
3661
3662} /* End epca_setup */
3663
3664
3665
3666#ifdef ENABLE_PCI
3667/* ------------------------ Begin init_PCI --------------------------- */
3668
3669enum epic_board_types {
3670 brd_xr = 0,
3671 brd_xem,
3672 brd_cx,
3673 brd_xrj,
3674};
3675
3676
3677/* indexed directly by epic_board_types enum */
3678static struct {
3679 unsigned char board_type;
3680 unsigned bar_idx; /* PCI base address region */
3681} epca_info_tbl[] = {
3682 { PCIXR, 0, },
3683 { PCIXEM, 0, },
3684 { PCICX, 0, },
3685 { PCIXRJ, 2, },
3686};
3687
3688
3689static int __devinit epca_init_one (struct pci_dev *pdev,
3690 const struct pci_device_id *ent)
3691{
3692 static int board_num = -1;
3693 int board_idx, info_idx = ent->driver_data;
3694 unsigned long addr;
3695
3696 if (pci_enable_device(pdev))
3697 return -EIO;
3698
3699 board_num++;
3700 board_idx = board_num + num_cards;
3701 if (board_idx >= MAXBOARDS)
3702 goto err_out;
3703
3704 addr = pci_resource_start (pdev, epca_info_tbl[info_idx].bar_idx);
3705 if (!addr) {
3706 printk (KERN_ERR PFX "PCI region #%d not available (size 0)\n",
3707 epca_info_tbl[info_idx].bar_idx);
3708 goto err_out;
3709 }
3710
3711 boards[board_idx].status = ENABLED;
3712 boards[board_idx].type = epca_info_tbl[info_idx].board_type;
3713 boards[board_idx].numports = 0x0;
3714 boards[board_idx].port =
3715 (unsigned char *)((char *) addr + PCI_IO_OFFSET);
3716 boards[board_idx].membase =
3717 (unsigned char *)((char *) addr);
3718
3719 if (!request_mem_region (addr + PCI_IO_OFFSET, 0x200000, "epca")) {
3720 printk (KERN_ERR PFX "resource 0x%x @ 0x%lx unavailable\n",
3721 0x200000, addr + PCI_IO_OFFSET);
3722 goto err_out;
3723 }
3724
3725 boards[board_idx].re_map_port = ioremap(addr + PCI_IO_OFFSET, 0x200000);
3726 if (!boards[board_idx].re_map_port) {
3727 printk (KERN_ERR PFX "cannot map 0x%x @ 0x%lx\n",
3728 0x200000, addr + PCI_IO_OFFSET);
3729 goto err_out_free_pciio;
3730 }
3731
3732 if (!request_mem_region (addr, 0x200000, "epca")) {
3733 printk (KERN_ERR PFX "resource 0x%x @ 0x%lx unavailable\n",
3734 0x200000, addr);
3735 goto err_out_free_iounmap;
3736 }
3737
3738 boards[board_idx].re_map_membase = ioremap(addr, 0x200000);
3739 if (!boards[board_idx].re_map_membase) {
3740 printk (KERN_ERR PFX "cannot map 0x%x @ 0x%lx\n",
3741 0x200000, addr + PCI_IO_OFFSET);
3742 goto err_out_free_memregion;
3743 }
3744
3745 /* --------------------------------------------------------------
3746 I don't know what the below does, but the hardware guys say
3747 its required on everything except PLX (In this case XRJ).
3748 ---------------------------------------------------------------- */
3749 if (info_idx != brd_xrj) {
3750 pci_write_config_byte(pdev, 0x40, 0);
3751 pci_write_config_byte(pdev, 0x46, 0);
3752 }
3753
3754 return 0;
3755
3756err_out_free_memregion:
3757 release_mem_region (addr, 0x200000);
3758err_out_free_iounmap:
3759 iounmap (boards[board_idx].re_map_port);
3760err_out_free_pciio:
3761 release_mem_region (addr + PCI_IO_OFFSET, 0x200000);
3762err_out:
3763 return -ENODEV;
3764}
3765
3766
3767static struct pci_device_id epca_pci_tbl[] = {
3768 { PCI_VENDOR_DIGI, PCI_DEVICE_XR, PCI_ANY_ID, PCI_ANY_ID, 0, 0, brd_xr },
3769 { PCI_VENDOR_DIGI, PCI_DEVICE_XEM, PCI_ANY_ID, PCI_ANY_ID, 0, 0, brd_xem },
3770 { PCI_VENDOR_DIGI, PCI_DEVICE_CX, PCI_ANY_ID, PCI_ANY_ID, 0, 0, brd_cx },
3771 { PCI_VENDOR_DIGI, PCI_DEVICE_XRJ, PCI_ANY_ID, PCI_ANY_ID, 0, 0, brd_xrj },
3772 { 0, }
3773};
3774
3775MODULE_DEVICE_TABLE(pci, epca_pci_tbl);
3776
3777int __init init_PCI (void)
3778{ /* Begin init_PCI */
3779 memset (&epca_driver, 0, sizeof (epca_driver));
3780 epca_driver.name = "epca";
3781 epca_driver.id_table = epca_pci_tbl;
3782 epca_driver.probe = epca_init_one;
3783
3784 return pci_register_driver(&epca_driver);
3785} /* End init_PCI */
3786
3787#endif /* ENABLE_PCI */
3788
3789MODULE_LICENSE("GPL");
Clone of davem's net-next-2.6 tree