OpenCores
URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [char/] [epca.c] - Blame information for rev 62

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 62 marcus.erl
/*
2
        Copyright (C) 1996  Digi International.
3
 
4
        For technical support please email digiLinux@dgii.com or
5
        call Digi tech support at (612) 912-3456
6
 
7
        ** This driver is no longer supported by Digi **
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
/* See README.epca for change history --DAT*/
28
 
29
#include <linux/module.h>
30
#include <linux/kernel.h>
31
#include <linux/types.h>
32
#include <linux/init.h>
33
#include <linux/serial.h>
34
#include <linux/delay.h>
35
#include <linux/ctype.h>
36
#include <linux/tty.h>
37
#include <linux/tty_flip.h>
38
#include <linux/slab.h>
39
#include <linux/ioport.h>
40
#include <linux/interrupt.h>
41
#include <asm/uaccess.h>
42
#include <asm/io.h>
43
#include <linux/spinlock.h>
44
#include <linux/pci.h>
45
#include "digiPCI.h"
46
 
47
 
48
#include "digi1.h"
49
#include "digiFep1.h"
50
#include "epca.h"
51
#include "epcaconfig.h"
52
 
53
#define VERSION            "1.3.0.1-LK2.6"
54
 
55
/* This major needs to be submitted to Linux to join the majors list */
56
#define DIGIINFOMAJOR       35  /* For Digi specific ioctl */
57
 
58
 
59
#define MAXCARDS 7
60
#define epcaassert(x, msg)  if (!(x)) epca_error(__LINE__, msg)
61
 
62
#define PFX "epca: "
63
 
64
static int nbdevs, num_cards, liloconfig;
65
static int digi_poller_inhibited = 1 ;
66
 
67
static int setup_error_code;
68
static int invalid_lilo_config;
69
 
70
/*
71
 * The ISA boards do window flipping into the same spaces so its only sane with
72
 * a single lock. It's still pretty efficient.
73
 */
74
static DEFINE_SPINLOCK(epca_lock);
75
 
76
/* MAXBOARDS is typically 12, but ISA and EISA cards are restricted to 7 below. */
77
static struct board_info boards[MAXBOARDS];
78
 
79
static struct tty_driver *pc_driver;
80
static struct tty_driver *pc_info;
81
 
82
/* ------------------ Begin Digi specific structures -------------------- */
83
 
84
/*
85
 * digi_channels represents an array of structures that keep track of each
86
 * channel of the Digi product. Information such as transmit and receive
87
 * pointers, termio data, and signal definitions (DTR, CTS, etc ...) are stored
88
 * here. This structure is NOT used to overlay the cards physical channel
89
 * structure.
90
 */
91
static struct channel digi_channels[MAX_ALLOC];
92
 
93
/*
94
 * card_ptr is an array used to hold the address of the first channel structure
95
 * of each card. This array will hold the addresses of various channels located
96
 * in digi_channels.
97
 */
98
static struct channel *card_ptr[MAXCARDS];
99
 
100
static struct timer_list epca_timer;
101
 
102
/*
103
 * Begin generic memory functions. These functions will be alias (point at)
104
 * more specific functions dependent on the board being configured.
105
 */
106
static void memwinon(struct board_info *b, unsigned int win);
107
static void memwinoff(struct board_info *b, unsigned int win);
108
static void globalwinon(struct channel *ch);
109
static void rxwinon(struct channel *ch);
110
static void txwinon(struct channel *ch);
111
static void memoff(struct channel *ch);
112
static void assertgwinon(struct channel *ch);
113
static void assertmemoff(struct channel *ch);
114
 
115
/* ---- Begin more 'specific' memory functions for cx_like products --- */
116
 
117
static void pcxem_memwinon(struct board_info *b, unsigned int win);
118
static void pcxem_memwinoff(struct board_info *b, unsigned int win);
119
static void pcxem_globalwinon(struct channel *ch);
120
static void pcxem_rxwinon(struct channel *ch);
121
static void pcxem_txwinon(struct channel *ch);
122
static void pcxem_memoff(struct channel *ch);
123
 
124
/* ------ Begin more 'specific' memory functions for the pcxe ------- */
125
 
126
static void pcxe_memwinon(struct board_info *b, unsigned int win);
127
static void pcxe_memwinoff(struct board_info *b, unsigned int win);
128
static void pcxe_globalwinon(struct channel *ch);
129
static void pcxe_rxwinon(struct channel *ch);
130
static void pcxe_txwinon(struct channel *ch);
131
static void pcxe_memoff(struct channel *ch);
132
 
133
/* ---- Begin more 'specific' memory functions for the pc64xe and pcxi ---- */
134
/* Note : pc64xe and pcxi share the same windowing routines */
135
 
136
static void pcxi_memwinon(struct board_info *b, unsigned int win);
137
static void pcxi_memwinoff(struct board_info *b, unsigned int win);
138
static void pcxi_globalwinon(struct channel *ch);
139
static void pcxi_rxwinon(struct channel *ch);
140
static void pcxi_txwinon(struct channel *ch);
141
static void pcxi_memoff(struct channel *ch);
142
 
143
/* - Begin 'specific' do nothing memory functions needed for some cards - */
144
 
145
static void dummy_memwinon(struct board_info *b, unsigned int win);
146
static void dummy_memwinoff(struct board_info *b, unsigned int win);
147
static void dummy_globalwinon(struct channel *ch);
148
static void dummy_rxwinon(struct channel *ch);
149
static void dummy_txwinon(struct channel *ch);
150
static void dummy_memoff(struct channel *ch);
151
static void dummy_assertgwinon(struct channel *ch);
152
static void dummy_assertmemoff(struct channel *ch);
153
 
154
static struct channel *verifyChannel(struct tty_struct *);
155
static void pc_sched_event(struct channel *, int);
156
static void epca_error(int, char *);
157
static void pc_close(struct tty_struct *, struct file *);
158
static void shutdown(struct channel *);
159
static void pc_hangup(struct tty_struct *);
160
static void pc_put_char(struct tty_struct *, unsigned char);
161
static int pc_write_room(struct tty_struct *);
162
static int pc_chars_in_buffer(struct tty_struct *);
163
static void pc_flush_buffer(struct tty_struct *);
164
static void pc_flush_chars(struct tty_struct *);
165
static int block_til_ready(struct tty_struct *, struct file *,
166
                           struct channel *);
167
static int pc_open(struct tty_struct *, struct file *);
168
static void post_fep_init(unsigned int crd);
169
static void epcapoll(unsigned long);
170
static void doevent(int);
171
static void fepcmd(struct channel *, int, int, int, int, int);
172
static unsigned termios2digi_h(struct channel *ch, unsigned);
173
static unsigned termios2digi_i(struct channel *ch, unsigned);
174
static unsigned termios2digi_c(struct channel *ch, unsigned);
175
static void epcaparam(struct tty_struct *, struct channel *);
176
static void receive_data(struct channel *);
177
static int pc_ioctl(struct tty_struct *, struct file *,
178
                    unsigned int, unsigned long);
179
static int info_ioctl(struct tty_struct *, struct file *,
180
                    unsigned int, unsigned long);
181
static void pc_set_termios(struct tty_struct *, struct ktermios *);
182
static void do_softint(struct work_struct *work);
183
static void pc_stop(struct tty_struct *);
184
static void pc_start(struct tty_struct *);
185
static void pc_throttle(struct tty_struct * tty);
186
static void pc_unthrottle(struct tty_struct *tty);
187
static void digi_send_break(struct channel *ch, int msec);
188
static void setup_empty_event(struct tty_struct *tty, struct channel *ch);
189
void epca_setup(char *, int *);
190
 
191
static int pc_write(struct tty_struct *, const unsigned char *, int);
192
static int pc_init(void);
193
static int init_PCI(void);
194
 
195
/*
196
 * Table of functions for each board to handle memory. Mantaining parallelism
197
 * is a *very* good idea here. The idea is for the runtime code to blindly call
198
 * these functions, not knowing/caring about the underlying hardware. This
199
 * stuff should contain no conditionals; if more functionality is needed a
200
 * different entry should be established. These calls are the interface calls
201
 * and are the only functions that should be accessed. Anyone caught making
202
 * direct calls deserves what they get.
203
 */
204
static void memwinon(struct board_info *b, unsigned int win)
205
{
206
        b->memwinon(b, win);
207
}
208
 
209
static void memwinoff(struct board_info *b, unsigned int win)
210
{
211
        b->memwinoff(b, win);
212
}
213
 
214
static void globalwinon(struct channel *ch)
215
{
216
        ch->board->globalwinon(ch);
217
}
218
 
219
static void rxwinon(struct channel *ch)
220
{
221
        ch->board->rxwinon(ch);
222
}
223
 
224
static void txwinon(struct channel *ch)
225
{
226
        ch->board->txwinon(ch);
227
}
228
 
229
static void memoff(struct channel *ch)
230
{
231
        ch->board->memoff(ch);
232
}
233
static void assertgwinon(struct channel *ch)
234
{
235
        ch->board->assertgwinon(ch);
236
}
237
 
238
static void assertmemoff(struct channel *ch)
239
{
240
        ch->board->assertmemoff(ch);
241
}
242
 
243
/* PCXEM windowing is the same as that used in the PCXR and CX series cards. */
244
static void pcxem_memwinon(struct board_info *b, unsigned int win)
245
{
246
        outb_p(FEPWIN|win, b->port + 1);
247
}
248
 
249
static void pcxem_memwinoff(struct board_info *b, unsigned int win)
250
{
251
        outb_p(0, b->port + 1);
252
}
253
 
254
static void pcxem_globalwinon(struct channel *ch)
255
{
256
        outb_p( FEPWIN, (int)ch->board->port + 1);
257
}
258
 
259
static void pcxem_rxwinon(struct channel *ch)
260
{
261
        outb_p(ch->rxwin, (int)ch->board->port + 1);
262
}
263
 
264
static void pcxem_txwinon(struct channel *ch)
265
{
266
        outb_p(ch->txwin, (int)ch->board->port + 1);
267
}
268
 
269
static void pcxem_memoff(struct channel *ch)
270
{
271
        outb_p(0, (int)ch->board->port + 1);
272
}
273
 
274
/* ----------------- Begin pcxe memory window stuff ------------------ */
275
static void pcxe_memwinon(struct board_info *b, unsigned int win)
276
{
277
        outb_p(FEPWIN | win, b->port + 1);
278
}
279
 
280
static void pcxe_memwinoff(struct board_info *b, unsigned int win)
281
{
282
        outb_p(inb(b->port) & ~FEPMEM, b->port + 1);
283
        outb_p(0, b->port + 1);
284
}
285
 
286
static void pcxe_globalwinon(struct channel *ch)
287
{
288
        outb_p(FEPWIN, (int)ch->board->port + 1);
289
}
290
 
291
static void pcxe_rxwinon(struct channel *ch)
292
{
293
        outb_p(ch->rxwin, (int)ch->board->port + 1);
294
}
295
 
296
static void pcxe_txwinon(struct channel *ch)
297
{
298
        outb_p(ch->txwin, (int)ch->board->port + 1);
299
}
300
 
301
static void pcxe_memoff(struct channel *ch)
302
{
303
        outb_p(0, (int)ch->board->port);
304
        outb_p(0, (int)ch->board->port + 1);
305
}
306
 
307
/* ------------- Begin pc64xe and pcxi memory window stuff -------------- */
308
static void pcxi_memwinon(struct board_info *b, unsigned int win)
309
{
310
        outb_p(inb(b->port) | FEPMEM, b->port);
311
}
312
 
313
static void pcxi_memwinoff(struct board_info *b, unsigned int win)
314
{
315
        outb_p(inb(b->port) & ~FEPMEM, b->port);
316
}
317
 
318
static void pcxi_globalwinon(struct channel *ch)
319
{
320
        outb_p(FEPMEM, ch->board->port);
321
}
322
 
323
static void pcxi_rxwinon(struct channel *ch)
324
{
325
        outb_p(FEPMEM, ch->board->port);
326
}
327
 
328
static void pcxi_txwinon(struct channel *ch)
329
{
330
        outb_p(FEPMEM, ch->board->port);
331
}
332
 
333
static void pcxi_memoff(struct channel *ch)
334
{
335
        outb_p(0, ch->board->port);
336
}
337
 
338
static void pcxi_assertgwinon(struct channel *ch)
339
{
340
        epcaassert(inb(ch->board->port) & FEPMEM, "Global memory off");
341
}
342
 
343
static void pcxi_assertmemoff(struct channel *ch)
344
{
345
        epcaassert(!(inb(ch->board->port) & FEPMEM), "Memory on");
346
}
347
 
348
/*
349
 * Not all of the cards need specific memory windowing routines. Some cards
350
 * (Such as PCI) needs no windowing routines at all. We provide these do
351
 * nothing routines so that the same code base can be used. The driver will
352
 * ALWAYS call a windowing routine if it thinks it needs to; regardless of the
353
 * card. However, dependent on the card the routine may or may not do anything.
354
 */
355
static void dummy_memwinon(struct board_info *b, unsigned int win)
356
{
357
}
358
 
359
static void dummy_memwinoff(struct board_info *b, unsigned int win)
360
{
361
}
362
 
363
static void dummy_globalwinon(struct channel *ch)
364
{
365
}
366
 
367
static void dummy_rxwinon(struct channel *ch)
368
{
369
}
370
 
371
static void dummy_txwinon(struct channel *ch)
372
{
373
}
374
 
375
static void dummy_memoff(struct channel *ch)
376
{
377
}
378
 
379
static void dummy_assertgwinon(struct channel *ch)
380
{
381
}
382
 
383
static void dummy_assertmemoff(struct channel *ch)
384
{
385
}
386
 
387
static struct channel *verifyChannel(struct tty_struct *tty)
388
{
389
        /*
390
         * This routine basically provides a sanity check. It insures that the
391
         * channel returned is within the proper range of addresses as well as
392
         * properly initialized. If some bogus info gets passed in
393
         * through tty->driver_data this should catch it.
394
         */
395
        if (tty) {
396
                struct channel *ch = (struct channel *)tty->driver_data;
397
                if ((ch >= &digi_channels[0]) && (ch < &digi_channels[nbdevs])) {
398
                        if (ch->magic == EPCA_MAGIC)
399
                                return ch;
400
                }
401
        }
402
        return NULL;
403
}
404
 
405
static void pc_sched_event(struct channel *ch, int event)
406
{
407
        /*
408
         * We call this to schedule interrupt processing on some event. The
409
         * kernel sees our request and calls the related routine in OUR driver.
410
         */
411
        ch->event |= 1 << event;
412
        schedule_work(&ch->tqueue);
413
}
414
 
415
static void epca_error(int line, char *msg)
416
{
417
        printk(KERN_ERR "epca_error (Digi): line = %d %s\n",line,msg);
418
}
419
 
420
static void pc_close(struct tty_struct *tty, struct file *filp)
421
{
422
        struct channel *ch;
423
        unsigned long flags;
424
        /*
425
         * verifyChannel returns the channel from the tty struct if it is
426
         * valid. This serves as a sanity check.
427
         */
428
        if ((ch = verifyChannel(tty)) != NULL) {
429
                spin_lock_irqsave(&epca_lock, flags);
430
                if (tty_hung_up_p(filp)) {
431
                        spin_unlock_irqrestore(&epca_lock, flags);
432
                        return;
433
                }
434
                if (ch->count-- > 1)  {
435
                        /* Begin channel is open more than once */
436
                        /*
437
                         * Return without doing anything. Someone might still
438
                         * be using the channel.
439
                         */
440
                        spin_unlock_irqrestore(&epca_lock, flags);
441
                        return;
442
                }
443
 
444
                /* Port open only once go ahead with shutdown & reset */
445
                BUG_ON(ch->count < 0);
446
 
447
                /*
448
                 * Let the rest of the driver know the channel is being closed.
449
                 * This becomes important if an open is attempted before close
450
                 * is finished.
451
                 */
452
                ch->asyncflags |= ASYNC_CLOSING;
453
                tty->closing = 1;
454
 
455
                spin_unlock_irqrestore(&epca_lock, flags);
456
 
457
                if (ch->asyncflags & ASYNC_INITIALIZED)  {
458
                        /* Setup an event to indicate when the transmit buffer empties */
459
                        setup_empty_event(tty, ch);
460
                        tty_wait_until_sent(tty, 3000); /* 30 seconds timeout */
461
                }
462
                if (tty->driver->flush_buffer)
463
                        tty->driver->flush_buffer(tty);
464
 
465
                tty_ldisc_flush(tty);
466
                shutdown(ch);
467
 
468
                spin_lock_irqsave(&epca_lock, flags);
469
                tty->closing = 0;
470
                ch->event = 0;
471
                ch->tty = NULL;
472
                spin_unlock_irqrestore(&epca_lock, flags);
473
 
474
                if (ch->blocked_open) {
475
                        if (ch->close_delay)
476
                                msleep_interruptible(jiffies_to_msecs(ch->close_delay));
477
                        wake_up_interruptible(&ch->open_wait);
478
                }
479
                ch->asyncflags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_INITIALIZED |
480
                                      ASYNC_CLOSING);
481
                wake_up_interruptible(&ch->close_wait);
482
        }
483
}
484
 
485
static void shutdown(struct channel *ch)
486
{
487
        unsigned long flags;
488
        struct tty_struct *tty;
489
        struct board_chan __iomem *bc;
490
 
491
        if (!(ch->asyncflags & ASYNC_INITIALIZED))
492
                return;
493
 
494
        spin_lock_irqsave(&epca_lock, flags);
495
 
496
        globalwinon(ch);
497
        bc = ch->brdchan;
498
 
499
        /*
500
         * In order for an event to be generated on the receipt of data the
501
         * idata flag must be set. Since we are shutting down, this is not
502
         * necessary clear this flag.
503
         */
504
        if (bc)
505
                writeb(0, &bc->idata);
506
        tty = ch->tty;
507
 
508
        /* If we're a modem control device and HUPCL is on, drop RTS & DTR. */
509
        if (tty->termios->c_cflag & HUPCL)  {
510
                ch->omodem &= ~(ch->m_rts | ch->m_dtr);
511
                fepcmd(ch, SETMODEM, 0, ch->m_dtr | ch->m_rts, 10, 1);
512
        }
513
        memoff(ch);
514
 
515
        /*
516
         * The channel has officialy been closed. The next time it is opened it
517
         * will have to reinitialized. Set a flag to indicate this.
518
         */
519
        /* Prevent future Digi programmed interrupts from coming active */
520
        ch->asyncflags &= ~ASYNC_INITIALIZED;
521
        spin_unlock_irqrestore(&epca_lock, flags);
522
}
523
 
524
static void pc_hangup(struct tty_struct *tty)
525
{
526
        struct channel *ch;
527
 
528
        /*
529
         * verifyChannel returns the channel from the tty struct if it is
530
         * valid. This serves as a sanity check.
531
         */
532
        if ((ch = verifyChannel(tty)) != NULL) {
533
                unsigned long flags;
534
 
535
                if (tty->driver->flush_buffer)
536
                        tty->driver->flush_buffer(tty);
537
                tty_ldisc_flush(tty);
538
                shutdown(ch);
539
 
540
                spin_lock_irqsave(&epca_lock, flags);
541
                ch->tty   = NULL;
542
                ch->event = 0;
543
                ch->count = 0;
544
                ch->asyncflags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_INITIALIZED);
545
                spin_unlock_irqrestore(&epca_lock, flags);
546
                wake_up_interruptible(&ch->open_wait);
547
        }
548
}
549
 
550
static int pc_write(struct tty_struct *tty,
551
                    const unsigned char *buf, int bytesAvailable)
552
{
553
        unsigned int head, tail;
554
        int dataLen;
555
        int size;
556
        int amountCopied;
557
        struct channel *ch;
558
        unsigned long flags;
559
        int remain;
560
        struct board_chan __iomem *bc;
561
 
562
        /*
563
         * pc_write is primarily called directly by the kernel routine
564
         * tty_write (Though it can also be called by put_char) found in
565
         * tty_io.c. pc_write is passed a line discipline buffer where the data
566
         * to be written out is stored. The line discipline implementation
567
         * itself is done at the kernel level and is not brought into the
568
         * driver.
569
         */
570
 
571
        /*
572
         * verifyChannel returns the channel from the tty struct if it is
573
         * valid. This serves as a sanity check.
574
         */
575
        if ((ch = verifyChannel(tty)) == NULL)
576
                return 0;
577
 
578
        /* Make a pointer to the channel data structure found on the board. */
579
        bc   = ch->brdchan;
580
        size = ch->txbufsize;
581
        amountCopied = 0;
582
 
583
        spin_lock_irqsave(&epca_lock, flags);
584
        globalwinon(ch);
585
 
586
        head = readw(&bc->tin) & (size - 1);
587
        tail = readw(&bc->tout);
588
 
589
        if (tail != readw(&bc->tout))
590
                tail = readw(&bc->tout);
591
        tail &= (size - 1);
592
 
593
        if (head >= tail) {
594
                /* head has not wrapped */
595
                /*
596
                 * remain (much like dataLen above) represents the total amount
597
                 * of space available on the card for data. Here dataLen
598
                 * represents the space existing between the head pointer and
599
                 * the end of buffer. This is important because a memcpy cannot
600
                 * be told to automatically wrap around when it hits the buffer
601
                 * end.
602
                 */
603
                dataLen = size - head;
604
                remain = size - (head - tail) - 1;
605
        } else {
606
                /* head has wrapped around */
607
                remain = tail - head - 1;
608
                dataLen = remain;
609
        }
610
        /*
611
         * Check the space on the card. If we have more data than space; reduce
612
         * the amount of data to fit the space.
613
         */
614
        bytesAvailable = min(remain, bytesAvailable);
615
        txwinon(ch);
616
        while (bytesAvailable > 0) {
617
                /* there is data to copy onto card */
618
 
619
                /*
620
                 * If head is not wrapped, the below will make sure the first
621
                 * data copy fills to the end of card buffer.
622
                 */
623
                dataLen = min(bytesAvailable, dataLen);
624
                memcpy_toio(ch->txptr + head, buf, dataLen);
625
                buf += dataLen;
626
                head += dataLen;
627
                amountCopied += dataLen;
628
                bytesAvailable -= dataLen;
629
 
630
                if (head >= size) {
631
                        head = 0;
632
                        dataLen = tail;
633
                }
634
        }
635
        ch->statusflags |= TXBUSY;
636
        globalwinon(ch);
637
        writew(head, &bc->tin);
638
 
639
        if ((ch->statusflags & LOWWAIT) == 0)  {
640
                ch->statusflags |= LOWWAIT;
641
                writeb(1, &bc->ilow);
642
        }
643
        memoff(ch);
644
        spin_unlock_irqrestore(&epca_lock, flags);
645
        return amountCopied;
646
}
647
 
648
static void pc_put_char(struct tty_struct *tty, unsigned char c)
649
{
650
        pc_write(tty, &c, 1);
651
}
652
 
653
static int pc_write_room(struct tty_struct *tty)
654
{
655
        int remain;
656
        struct channel *ch;
657
        unsigned long flags;
658
        unsigned int head, tail;
659
        struct board_chan __iomem *bc;
660
 
661
        remain = 0;
662
 
663
        /*
664
         * verifyChannel returns the channel from the tty struct if it is
665
         * valid. This serves as a sanity check.
666
         */
667
        if ((ch = verifyChannel(tty)) != NULL)  {
668
                spin_lock_irqsave(&epca_lock, flags);
669
                globalwinon(ch);
670
 
671
                bc   = ch->brdchan;
672
                head = readw(&bc->tin) & (ch->txbufsize - 1);
673
                tail = readw(&bc->tout);
674
 
675
                if (tail != readw(&bc->tout))
676
                        tail = readw(&bc->tout);
677
                /* Wrap tail if necessary */
678
                tail &= (ch->txbufsize - 1);
679
 
680
                if ((remain = tail - head - 1) < 0 )
681
                        remain += ch->txbufsize;
682
 
683
                if (remain && (ch->statusflags & LOWWAIT) == 0) {
684
                        ch->statusflags |= LOWWAIT;
685
                        writeb(1, &bc->ilow);
686
                }
687
                memoff(ch);
688
                spin_unlock_irqrestore(&epca_lock, flags);
689
        }
690
        /* Return how much room is left on card */
691
        return remain;
692
}
693
 
694
static int pc_chars_in_buffer(struct tty_struct *tty)
695
{
696
        int chars;
697
        unsigned int ctail, head, tail;
698
        int remain;
699
        unsigned long flags;
700
        struct channel *ch;
701
        struct board_chan __iomem *bc;
702
 
703
        /*
704
         * verifyChannel returns the channel from the tty struct if it is
705
         * valid. This serves as a sanity check.
706
         */
707
        if ((ch = verifyChannel(tty)) == NULL)
708
                return 0;
709
 
710
        spin_lock_irqsave(&epca_lock, flags);
711
        globalwinon(ch);
712
 
713
        bc = ch->brdchan;
714
        tail = readw(&bc->tout);
715
        head = readw(&bc->tin);
716
        ctail = readw(&ch->mailbox->cout);
717
 
718
        if (tail == head && readw(&ch->mailbox->cin) == ctail && readb(&bc->tbusy) == 0)
719
                chars = 0;
720
        else  { /* Begin if some space on the card has been used */
721
                head = readw(&bc->tin) & (ch->txbufsize - 1);
722
                tail &= (ch->txbufsize - 1);
723
                /*
724
                 * The logic here is basically opposite of the above
725
                 * pc_write_room here we are finding the amount of bytes in the
726
                 * buffer filled. Not the amount of bytes empty.
727
                 */
728
                if ((remain = tail - head - 1) < 0 )
729
                        remain += ch->txbufsize;
730
                chars = (int)(ch->txbufsize - remain);
731
                /*
732
                 * Make it possible to wakeup anything waiting for output in
733
                 * tty_ioctl.c, etc.
734
                 *
735
                 * If not already set. Setup an event to indicate when the
736
                 * transmit buffer empties.
737
                 */
738
                if (!(ch->statusflags & EMPTYWAIT))
739
                        setup_empty_event(tty,ch);
740
        } /* End if some space on the card has been used */
741
        memoff(ch);
742
        spin_unlock_irqrestore(&epca_lock, flags);
743
        /* Return number of characters residing on card. */
744
        return chars;
745
}
746
 
747
static void pc_flush_buffer(struct tty_struct *tty)
748
{
749
        unsigned int tail;
750
        unsigned long flags;
751
        struct channel *ch;
752
        struct board_chan __iomem *bc;
753
        /*
754
         * verifyChannel returns the channel from the tty struct if it is
755
         * valid. This serves as a sanity check.
756
         */
757
        if ((ch = verifyChannel(tty)) == NULL)
758
                return;
759
 
760
        spin_lock_irqsave(&epca_lock, flags);
761
        globalwinon(ch);
762
        bc   = ch->brdchan;
763
        tail = readw(&bc->tout);
764
        /* Have FEP move tout pointer; effectively flushing transmit buffer */
765
        fepcmd(ch, STOUT, (unsigned) tail, 0, 0, 0);
766
        memoff(ch);
767
        spin_unlock_irqrestore(&epca_lock, flags);
768
        tty_wakeup(tty);
769
}
770
 
771
static void pc_flush_chars(struct tty_struct *tty)
772
{
773
        struct channel *ch;
774
        /*
775
         * verifyChannel returns the channel from the tty struct if it is
776
         * valid. This serves as a sanity check.
777
         */
778
        if ((ch = verifyChannel(tty)) != NULL) {
779
                unsigned long flags;
780
                spin_lock_irqsave(&epca_lock, flags);
781
                /*
782
                 * If not already set and the transmitter is busy setup an
783
                 * event to indicate when the transmit empties.
784
                 */
785
                if ((ch->statusflags & TXBUSY) && !(ch->statusflags & EMPTYWAIT))
786
                        setup_empty_event(tty,ch);
787
                spin_unlock_irqrestore(&epca_lock, flags);
788
        }
789
}
790
 
791
static int block_til_ready(struct tty_struct *tty,
792
                           struct file *filp, struct channel *ch)
793
{
794
        DECLARE_WAITQUEUE(wait,current);
795
        int retval, do_clocal = 0;
796
        unsigned long flags;
797
 
798
        if (tty_hung_up_p(filp)) {
799
                if (ch->asyncflags & ASYNC_HUP_NOTIFY)
800
                        retval = -EAGAIN;
801
                else
802
                        retval = -ERESTARTSYS;
803
                return retval;
804
        }
805
 
806
        /*
807
         * If the device is in the middle of being closed, then block until
808
         * it's done, and then try again.
809
         */
810
        if (ch->asyncflags & ASYNC_CLOSING) {
811
                interruptible_sleep_on(&ch->close_wait);
812
 
813
                if (ch->asyncflags & ASYNC_HUP_NOTIFY)
814
                        return -EAGAIN;
815
                else
816
                        return -ERESTARTSYS;
817
        }
818
 
819
        if (filp->f_flags & O_NONBLOCK)  {
820
                /*
821
                 * If non-blocking mode is set, then make the check up front
822
                 * and then exit.
823
                 */
824
                ch->asyncflags |= ASYNC_NORMAL_ACTIVE;
825
                return 0;
826
        }
827
        if (tty->termios->c_cflag & CLOCAL)
828
                do_clocal = 1;
829
        /* Block waiting for the carrier detect and the line to become free */
830
 
831
        retval = 0;
832
        add_wait_queue(&ch->open_wait, &wait);
833
 
834
        spin_lock_irqsave(&epca_lock, flags);
835
        /* We dec count so that pc_close will know when to free things */
836
        if (!tty_hung_up_p(filp))
837
                ch->count--;
838
        ch->blocked_open++;
839
        while (1) {
840
                set_current_state(TASK_INTERRUPTIBLE);
841
                if (tty_hung_up_p(filp) ||
842
                    !(ch->asyncflags & ASYNC_INITIALIZED))
843
                {
844
                        if (ch->asyncflags & ASYNC_HUP_NOTIFY)
845
                                retval = -EAGAIN;
846
                        else
847
                                retval = -ERESTARTSYS;
848
                        break;
849
                }
850
                if (!(ch->asyncflags & ASYNC_CLOSING) &&
851
                          (do_clocal || (ch->imodem & ch->dcd)))
852
                        break;
853
                if (signal_pending(current)) {
854
                        retval = -ERESTARTSYS;
855
                        break;
856
                }
857
                spin_unlock_irqrestore(&epca_lock, flags);
858
                /*
859
                 * Allow someone else to be scheduled. We will occasionally go
860
                 * through this loop until one of the above conditions change.
861
                 * The below schedule call will allow other processes to enter
862
                 * and prevent this loop from hogging the cpu.
863
                 */
864
                schedule();
865
                spin_lock_irqsave(&epca_lock, flags);
866
        }
867
 
868
        __set_current_state(TASK_RUNNING);
869
        remove_wait_queue(&ch->open_wait, &wait);
870
        if (!tty_hung_up_p(filp))
871
                ch->count++;
872
        ch->blocked_open--;
873
 
874
        spin_unlock_irqrestore(&epca_lock, flags);
875
 
876
        if (retval)
877
                return retval;
878
 
879
        ch->asyncflags |= ASYNC_NORMAL_ACTIVE;
880
        return 0;
881
}
882
 
883
static int pc_open(struct tty_struct *tty, struct file * filp)
884
{
885
        struct channel *ch;
886
        unsigned long flags;
887
        int line, retval, boardnum;
888
        struct board_chan __iomem *bc;
889
        unsigned int head;
890
 
891
        line = tty->index;
892
        if (line < 0 || line >= nbdevs)
893
                return -ENODEV;
894
 
895
        ch = &digi_channels[line];
896
        boardnum = ch->boardnum;
897
 
898
        /* Check status of board configured in system.  */
899
 
900
        /*
901
         * I check to see if the epca_setup routine detected an user error. It
902
         * might be better to put this in pc_init, but for the moment it goes
903
         * here.
904
         */
905
        if (invalid_lilo_config) {
906
                if (setup_error_code & INVALID_BOARD_TYPE)
907
                        printk(KERN_ERR "epca: pc_open: Invalid board type specified in kernel options.\n");
908
                if (setup_error_code & INVALID_NUM_PORTS)
909
                        printk(KERN_ERR "epca: pc_open: Invalid number of ports specified in kernel options.\n");
910
                if (setup_error_code & INVALID_MEM_BASE)
911
                        printk(KERN_ERR "epca: pc_open: Invalid board memory address specified in kernel options.\n");
912
                if (setup_error_code & INVALID_PORT_BASE)
913
                        printk(KERN_ERR "epca; pc_open: Invalid board port address specified in kernel options.\n");
914
                if (setup_error_code & INVALID_BOARD_STATUS)
915
                        printk(KERN_ERR "epca: pc_open: Invalid board status specified in kernel options.\n");
916
                if (setup_error_code & INVALID_ALTPIN)
917
                        printk(KERN_ERR "epca: pc_open: Invalid board altpin specified in kernel options;\n");
918
                tty->driver_data = NULL;   /* Mark this device as 'down' */
919
                return -ENODEV;
920
        }
921
        if (boardnum >= num_cards || boards[boardnum].status == DISABLED)  {
922
                tty->driver_data = NULL;   /* Mark this device as 'down' */
923
                return(-ENODEV);
924
        }
925
 
926
        if ((bc = ch->brdchan) == 0) {
927
                tty->driver_data = NULL;
928
                return -ENODEV;
929
        }
930
 
931
        spin_lock_irqsave(&epca_lock, flags);
932
        /*
933
         * Every time a channel is opened, increment a counter. This is
934
         * necessary because we do not wish to flush and shutdown the channel
935
         * until the last app holding the channel open, closes it.
936
         */
937
        ch->count++;
938
        /*
939
         * Set a kernel structures pointer to our local channel structure. This
940
         * way we can get to it when passed only a tty struct.
941
         */
942
        tty->driver_data = ch;
943
        /*
944
         * If this is the first time the channel has been opened, initialize
945
         * the tty->termios struct otherwise let pc_close handle it.
946
         */
947
        globalwinon(ch);
948
        ch->statusflags = 0;
949
 
950
        /* Save boards current modem status */
951
        ch->imodem = readb(&bc->mstat);
952
 
953
        /*
954
         * Set receive head and tail ptrs to each other. This indicates no data
955
         * available to read.
956
         */
957
        head = readw(&bc->rin);
958
        writew(head, &bc->rout);
959
 
960
        /* Set the channels associated tty structure */
961
        ch->tty = tty;
962
 
963
        /*
964
         * The below routine generally sets up parity, baud, flow control
965
         * issues, etc.... It effect both control flags and input flags.
966
         */
967
        epcaparam(tty,ch);
968
        ch->asyncflags |= ASYNC_INITIALIZED;
969
        memoff(ch);
970
        spin_unlock_irqrestore(&epca_lock, flags);
971
 
972
        retval = block_til_ready(tty, filp, ch);
973
        if (retval)
974
                return retval;
975
        /*
976
         * Set this again in case a hangup set it to zero while this open() was
977
         * waiting for the line...
978
         */
979
        spin_lock_irqsave(&epca_lock, flags);
980
        ch->tty = tty;
981
        globalwinon(ch);
982
        /* Enable Digi Data events */
983
        writeb(1, &bc->idata);
984
        memoff(ch);
985
        spin_unlock_irqrestore(&epca_lock, flags);
986
        return 0;
987
}
988
 
989
static int __init epca_module_init(void)
990
{
991
        return pc_init();
992
}
993
module_init(epca_module_init);
994
 
995
static struct pci_driver epca_driver;
996
 
997
static void __exit epca_module_exit(void)
998
{
999
        int               count, crd;
1000
        struct board_info *bd;
1001
        struct channel    *ch;
1002
 
1003
        del_timer_sync(&epca_timer);
1004
 
1005
        if (tty_unregister_driver(pc_driver) || tty_unregister_driver(pc_info))
1006
        {
1007
                printk(KERN_WARNING "epca: cleanup_module failed to un-register tty driver\n");
1008
                return;
1009
        }
1010
        put_tty_driver(pc_driver);
1011
        put_tty_driver(pc_info);
1012
 
1013
        for (crd = 0; crd < num_cards; crd++) {
1014
                bd = &boards[crd];
1015
                if (!bd) { /* sanity check */
1016
                        printk(KERN_ERR "<Error> - Digi : cleanup_module failed\n");
1017
                        return;
1018
                }
1019
                ch = card_ptr[crd];
1020
                for (count = 0; count < bd->numports; count++, ch++) {
1021
                        if (ch && ch->tty)
1022
                                tty_hangup(ch->tty);
1023
                }
1024
        }
1025
        pci_unregister_driver(&epca_driver);
1026
}
1027
module_exit(epca_module_exit);
1028
 
1029
static const struct tty_operations pc_ops = {
1030
        .open = pc_open,
1031
        .close = pc_close,
1032
        .write = pc_write,
1033
        .write_room = pc_write_room,
1034
        .flush_buffer = pc_flush_buffer,
1035
        .chars_in_buffer = pc_chars_in_buffer,
1036
        .flush_chars = pc_flush_chars,
1037
        .put_char = pc_put_char,
1038
        .ioctl = pc_ioctl,
1039
        .set_termios = pc_set_termios,
1040
        .stop = pc_stop,
1041
        .start = pc_start,
1042
        .throttle = pc_throttle,
1043
        .unthrottle = pc_unthrottle,
1044
        .hangup = pc_hangup,
1045
};
1046
 
1047
static int info_open(struct tty_struct *tty, struct file * filp)
1048
{
1049
        return 0;
1050
}
1051
 
1052
static struct tty_operations info_ops = {
1053
        .open = info_open,
1054
        .ioctl = info_ioctl,
1055
};
1056
 
1057
static int __init pc_init(void)
1058
{
1059
        int crd;
1060
        struct board_info *bd;
1061
        unsigned char board_id = 0;
1062
        int err = -ENOMEM;
1063
 
1064
        int pci_boards_found, pci_count;
1065
 
1066
        pci_count = 0;
1067
 
1068
        pc_driver = alloc_tty_driver(MAX_ALLOC);
1069
        if (!pc_driver)
1070
                goto out1;
1071
 
1072
        pc_info = alloc_tty_driver(MAX_ALLOC);
1073
        if (!pc_info)
1074
                goto out2;
1075
 
1076
        /*
1077
         * If epca_setup has not been ran by LILO set num_cards to defaults;
1078
         * copy board structure defined by digiConfig into drivers board
1079
         * structure. Note : If LILO has ran epca_setup then epca_setup will
1080
         * handle defining num_cards as well as copying the data into the board
1081
         * structure.
1082
         */
1083
        if (!liloconfig) {
1084
                /* driver has been configured via. epcaconfig */
1085
                nbdevs = NBDEVS;
1086
                num_cards = NUMCARDS;
1087
                memcpy(&boards, &static_boards,
1088
                       sizeof(struct board_info) * NUMCARDS);
1089
        }
1090
 
1091
        /*
1092
         * Note : If lilo was used to configure the driver and the ignore
1093
         * epcaconfig option was choosen (digiepca=2) then nbdevs and num_cards
1094
         * will equal 0 at this point. This is okay; PCI cards will still be
1095
         * picked up if detected.
1096
         */
1097
 
1098
        /*
1099
         * Set up interrupt, we will worry about memory allocation in
1100
         * post_fep_init.
1101
         */
1102
        printk(KERN_INFO "DIGI epca driver version %s loaded.\n",VERSION);
1103
 
1104
        /*
1105
         * NOTE : This code assumes that the number of ports found in the
1106
         * boards array is correct. This could be wrong if the card in question
1107
         * is PCI (And therefore has no ports entry in the boards structure.)
1108
         * The rest of the information will be valid for PCI because the
1109
         * beginning of pc_init scans for PCI and determines i/o and base
1110
         * memory addresses. I am not sure if it is possible to read the number
1111
         * of ports supported by the card prior to it being booted (Since that
1112
         * is the state it is in when pc_init is run). Because it is not
1113
         * possible to query the number of supported ports until after the card
1114
         * has booted; we are required to calculate the card_ptrs as the card
1115
         * is initialized (Inside post_fep_init). The negative thing about this
1116
         * approach is that digiDload's call to GET_INFO will have a bad port
1117
         * value. (Since this is called prior to post_fep_init.)
1118
         */
1119
        pci_boards_found = 0;
1120
        if (num_cards < MAXBOARDS)
1121
                pci_boards_found += init_PCI();
1122
        num_cards += pci_boards_found;
1123
 
1124
        pc_driver->owner = THIS_MODULE;
1125
        pc_driver->name = "ttyD";
1126
        pc_driver->major = DIGI_MAJOR;
1127
        pc_driver->minor_start = 0;
1128
        pc_driver->type = TTY_DRIVER_TYPE_SERIAL;
1129
        pc_driver->subtype = SERIAL_TYPE_NORMAL;
1130
        pc_driver->init_termios = tty_std_termios;
1131
        pc_driver->init_termios.c_iflag = 0;
1132
        pc_driver->init_termios.c_oflag = 0;
1133
        pc_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL | HUPCL;
1134
        pc_driver->init_termios.c_lflag = 0;
1135
        pc_driver->init_termios.c_ispeed = 9600;
1136
        pc_driver->init_termios.c_ospeed = 9600;
1137
        pc_driver->flags = TTY_DRIVER_REAL_RAW;
1138
        tty_set_operations(pc_driver, &pc_ops);
1139
 
1140
        pc_info->owner = THIS_MODULE;
1141
        pc_info->name = "digi_ctl";
1142
        pc_info->major = DIGIINFOMAJOR;
1143
        pc_info->minor_start = 0;
1144
        pc_info->type = TTY_DRIVER_TYPE_SERIAL;
1145
        pc_info->subtype = SERIAL_TYPE_INFO;
1146
        pc_info->init_termios = tty_std_termios;
1147
        pc_info->init_termios.c_iflag = 0;
1148
        pc_info->init_termios.c_oflag = 0;
1149
        pc_info->init_termios.c_lflag = 0;
1150
        pc_info->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL;
1151
        pc_info->init_termios.c_ispeed = 9600;
1152
        pc_info->init_termios.c_ospeed = 9600;
1153
        pc_info->flags = TTY_DRIVER_REAL_RAW;
1154
        tty_set_operations(pc_info, &info_ops);
1155
 
1156
 
1157
        for (crd = 0; crd < num_cards; crd++) {
1158
                /*
1159
                 * This is where the appropriate memory handlers for the
1160
                 * hardware is set. Everything at runtime blindly jumps through
1161
                 * these vectors.
1162
                 */
1163
 
1164
                /* defined in epcaconfig.h */
1165
                bd = &boards[crd];
1166
 
1167
                switch (bd->type) {
1168
                case PCXEM:
1169
                case EISAXEM:
1170
                        bd->memwinon     = pcxem_memwinon;
1171
                        bd->memwinoff    = pcxem_memwinoff;
1172
                        bd->globalwinon  = pcxem_globalwinon;
1173
                        bd->txwinon      = pcxem_txwinon;
1174
                        bd->rxwinon      = pcxem_rxwinon;
1175
                        bd->memoff       = pcxem_memoff;
1176
                        bd->assertgwinon = dummy_assertgwinon;
1177
                        bd->assertmemoff = dummy_assertmemoff;
1178
                        break;
1179
 
1180
                case PCIXEM:
1181
                case PCIXRJ:
1182
                case PCIXR:
1183
                        bd->memwinon     = dummy_memwinon;
1184
                        bd->memwinoff    = dummy_memwinoff;
1185
                        bd->globalwinon  = dummy_globalwinon;
1186
                        bd->txwinon      = dummy_txwinon;
1187
                        bd->rxwinon      = dummy_rxwinon;
1188
                        bd->memoff       = dummy_memoff;
1189
                        bd->assertgwinon = dummy_assertgwinon;
1190
                        bd->assertmemoff = dummy_assertmemoff;
1191
                        break;
1192
 
1193
                case PCXE:
1194
                case PCXEVE:
1195
                        bd->memwinon     = pcxe_memwinon;
1196
                        bd->memwinoff    = pcxe_memwinoff;
1197
                        bd->globalwinon  = pcxe_globalwinon;
1198
                        bd->txwinon      = pcxe_txwinon;
1199
                        bd->rxwinon      = pcxe_rxwinon;
1200
                        bd->memoff       = pcxe_memoff;
1201
                        bd->assertgwinon = dummy_assertgwinon;
1202
                        bd->assertmemoff = dummy_assertmemoff;
1203
                        break;
1204
 
1205
                case PCXI:
1206
                case PC64XE:
1207
                        bd->memwinon     = pcxi_memwinon;
1208
                        bd->memwinoff    = pcxi_memwinoff;
1209
                        bd->globalwinon  = pcxi_globalwinon;
1210
                        bd->txwinon      = pcxi_txwinon;
1211
                        bd->rxwinon      = pcxi_rxwinon;
1212
                        bd->memoff       = pcxi_memoff;
1213
                        bd->assertgwinon = pcxi_assertgwinon;
1214
                        bd->assertmemoff = pcxi_assertmemoff;
1215
                        break;
1216
 
1217
                default:
1218
                        break;
1219
                }
1220
 
1221
                /*
1222
                 * Some cards need a memory segment to be defined for use in
1223
                 * transmit and receive windowing operations. These boards are
1224
                 * listed in the below switch. In the case of the XI the amount
1225
                 * of memory on the board is variable so the memory_seg is also
1226
                 * variable. This code determines what they segment should be.
1227
                 */
1228
                switch (bd->type) {
1229
                case PCXE:
1230
                case PCXEVE:
1231
                case PC64XE:
1232
                        bd->memory_seg = 0xf000;
1233
                        break;
1234
 
1235
                case PCXI:
1236
                        board_id = inb((int)bd->port);
1237
                        if ((board_id & 0x1) == 0x1) {
1238
                                /* it's an XI card */
1239
                                /* Is it a 64K board */
1240
                                if ((board_id & 0x30) == 0)
1241
                                        bd->memory_seg = 0xf000;
1242
 
1243
                                /* Is it a 128K board */
1244
                                if ((board_id & 0x30) == 0x10)
1245
                                        bd->memory_seg = 0xe000;
1246
 
1247
                                /* Is is a 256K board */
1248
                                if ((board_id & 0x30) == 0x20)
1249
                                        bd->memory_seg = 0xc000;
1250
 
1251
                                /* Is it a 512K board */
1252
                                if ((board_id & 0x30) == 0x30)
1253
                                        bd->memory_seg = 0x8000;
1254
                        } else
1255
                                printk(KERN_ERR "epca: Board at 0x%x doesn't appear to be an XI\n",(int)bd->port);
1256
                        break;
1257
                }
1258
        }
1259
 
1260
        err = tty_register_driver(pc_driver);
1261
        if (err) {
1262
                printk(KERN_ERR "Couldn't register Digi PC/ driver");
1263
                goto out3;
1264
        }
1265
 
1266
        err = tty_register_driver(pc_info);
1267
        if (err) {
1268
                printk(KERN_ERR "Couldn't register Digi PC/ info ");
1269
                goto out4;
1270
        }
1271
 
1272
        /* Start up the poller to check for events on all enabled boards */
1273
        init_timer(&epca_timer);
1274
        epca_timer.function = epcapoll;
1275
        mod_timer(&epca_timer, jiffies + HZ/25);
1276
        return 0;
1277
 
1278
out4:
1279
        tty_unregister_driver(pc_driver);
1280
out3:
1281
        put_tty_driver(pc_info);
1282
out2:
1283
        put_tty_driver(pc_driver);
1284
out1:
1285
        return err;
1286
}
1287
 
1288
static void post_fep_init(unsigned int crd)
1289
{
1290
        int i;
1291
        void __iomem *memaddr;
1292
        struct global_data __iomem *gd;
1293
        struct board_info *bd;
1294
        struct board_chan __iomem *bc;
1295
        struct channel *ch;
1296
        int shrinkmem = 0, lowwater;
1297
 
1298
        /*
1299
         * This call is made by the user via. the ioctl call DIGI_INIT. It is
1300
         * responsible for setting up all the card specific stuff.
1301
         */
1302
        bd = &boards[crd];
1303
 
1304
        /*
1305
         * If this is a PCI board, get the port info. Remember PCI cards do not
1306
         * have entries into the epcaconfig.h file, so we can't get the number
1307
         * of ports from it. Unfortunetly, this means that anyone doing a
1308
         * DIGI_GETINFO before the board has booted will get an invalid number
1309
         * of ports returned (It should return 0). Calls to DIGI_GETINFO after
1310
         * DIGI_INIT has been called will return the proper values.
1311
         */
1312
        if (bd->type >= PCIXEM) { /* Begin get PCI number of ports */
1313
                /*
1314
                 * Below we use XEMPORTS as a memory offset regardless of which
1315
                 * PCI card it is. This is because all of the supported PCI
1316
                 * cards have the same memory offset for the channel data. This
1317
                 * will have to be changed if we ever develop a PCI/XE card.
1318
                 * NOTE : The FEP manual states that the port offset is 0xC22
1319
                 * as opposed to 0xC02. This is only true for PC/XE, and PC/XI
1320
                 * cards; not for the XEM, or CX series. On the PCI cards the
1321
                 * number of ports is determined by reading a ID PROM located
1322
                 * in the box attached to the card. The card can then determine
1323
                 * the index the id to determine the number of ports available.
1324
                 * (FYI - The id should be located at 0x1ac (And may use up to
1325
                 * 4 bytes if the box in question is a XEM or CX)).
1326
                 */
1327
                /* PCI cards are already remapped at this point ISA are not */
1328
                bd->numports = readw(bd->re_map_membase + XEMPORTS);
1329
                epcaassert(bd->numports <= 64,"PCI returned a invalid number of ports");
1330
                nbdevs += (bd->numports);
1331
        } else {
1332
                /* Fix up the mappings for ISA/EISA etc */
1333
                /* FIXME: 64K - can we be smarter ? */
1334
                bd->re_map_membase = ioremap(bd->membase, 0x10000);
1335
        }
1336
 
1337
        if (crd != 0)
1338
                card_ptr[crd] = card_ptr[crd-1] + boards[crd-1].numports;
1339
        else
1340
                card_ptr[crd] = &digi_channels[crd]; /* <- For card 0 only */
1341
 
1342
        ch = card_ptr[crd];
1343
        epcaassert(ch <= &digi_channels[nbdevs - 1], "ch out of range");
1344
 
1345
        memaddr = bd->re_map_membase;
1346
 
1347
        /*
1348
         * The below assignment will set bc to point at the BEGINING of the
1349
         * cards channel structures. For 1 card there will be between 8 and 64
1350
         * of these structures.
1351
         */
1352
        bc = memaddr + CHANSTRUCT;
1353
 
1354
        /*
1355
         * The below assignment will set gd to point at the BEGINING of global
1356
         * memory address 0xc00. The first data in that global memory actually
1357
         * starts at address 0xc1a. The command in pointer begins at 0xd10.
1358
         */
1359
        gd = memaddr + GLOBAL;
1360
 
1361
        /*
1362
         * XEPORTS (address 0xc22) points at the number of channels the card
1363
         * supports. (For 64XE, XI, XEM, and XR use 0xc02)
1364
         */
1365
        if ((bd->type == PCXEVE || bd->type == PCXE) && (readw(memaddr + XEPORTS) < 3))
1366
                shrinkmem = 1;
1367
        if (bd->type < PCIXEM)
1368
                if (!request_region((int)bd->port, 4, board_desc[bd->type]))
1369
                        return;
1370
        memwinon(bd, 0);
1371
 
1372
        /*
1373
         * Remember ch is the main drivers channels structure, while bc is the
1374
         * cards channel structure.
1375
         */
1376
        for (i = 0; i < bd->numports; i++, ch++, bc++) {
1377
                unsigned long flags;
1378
                u16 tseg, rseg;
1379
 
1380
                ch->brdchan = bc;
1381
                ch->mailbox = gd;
1382
                INIT_WORK(&ch->tqueue, do_softint);
1383
                ch->board = &boards[crd];
1384
 
1385
                spin_lock_irqsave(&epca_lock, flags);
1386
                switch (bd->type) {
1387
                /*
1388
                 * Since some of the boards use different bitmaps for
1389
                 * their control signals we cannot hard code these
1390
                 * values and retain portability. We virtualize this
1391
                 * data here.
1392
                 */
1393
                case EISAXEM:
1394
                case PCXEM:
1395
                case PCIXEM:
1396
                case PCIXRJ:
1397
                case PCIXR:
1398
                        ch->m_rts = 0x02;
1399
                        ch->m_dcd = 0x80;
1400
                        ch->m_dsr = 0x20;
1401
                        ch->m_cts = 0x10;
1402
                        ch->m_ri  = 0x40;
1403
                        ch->m_dtr = 0x01;
1404
                        break;
1405
 
1406
                case PCXE:
1407
                case PCXEVE:
1408
                case PCXI:
1409
                case PC64XE:
1410
                        ch->m_rts = 0x02;
1411
                        ch->m_dcd = 0x08;
1412
                        ch->m_dsr = 0x10;
1413
                        ch->m_cts = 0x20;
1414
                        ch->m_ri  = 0x40;
1415
                        ch->m_dtr = 0x80;
1416
                        break;
1417
                }
1418
 
1419
                if (boards[crd].altpin) {
1420
                        ch->dsr = ch->m_dcd;
1421
                        ch->dcd = ch->m_dsr;
1422
                        ch->digiext.digi_flags |= DIGI_ALTPIN;
1423
                } else {
1424
                        ch->dcd = ch->m_dcd;
1425
                        ch->dsr = ch->m_dsr;
1426
                }
1427
 
1428
                ch->boardnum   = crd;
1429
                ch->channelnum = i;
1430
                ch->magic      = EPCA_MAGIC;
1431
                ch->tty        = NULL;
1432
 
1433
                if (shrinkmem) {
1434
                        fepcmd(ch, SETBUFFER, 32, 0, 0, 0);
1435
                        shrinkmem = 0;
1436
                }
1437
 
1438
                tseg = readw(&bc->tseg);
1439
                rseg = readw(&bc->rseg);
1440
 
1441
                switch (bd->type) {
1442
                case PCIXEM:
1443
                case PCIXRJ:
1444
                case PCIXR:
1445
                        /* Cover all the 2MEG cards */
1446
                        ch->txptr = memaddr + ((tseg << 4) & 0x1fffff);
1447
                        ch->rxptr = memaddr + ((rseg << 4) & 0x1fffff);
1448
                        ch->txwin = FEPWIN | (tseg >> 11);
1449
                        ch->rxwin = FEPWIN | (rseg >> 11);
1450
                        break;
1451
 
1452
                case PCXEM:
1453
                case EISAXEM:
1454
                        /* Cover all the 32K windowed cards */
1455
                        /* Mask equal to window size - 1 */
1456
                        ch->txptr = memaddr + ((tseg << 4) & 0x7fff);
1457
                        ch->rxptr = memaddr + ((rseg << 4) & 0x7fff);
1458
                        ch->txwin = FEPWIN | (tseg >> 11);
1459
                        ch->rxwin = FEPWIN | (rseg >> 11);
1460
                        break;
1461
 
1462
                case PCXEVE:
1463
                case PCXE:
1464
                        ch->txptr = memaddr + (((tseg - bd->memory_seg) << 4) & 0x1fff);
1465
                        ch->txwin = FEPWIN | ((tseg - bd->memory_seg) >> 9);
1466
                        ch->rxptr = memaddr + (((rseg - bd->memory_seg) << 4) & 0x1fff);
1467
                        ch->rxwin = FEPWIN | ((rseg - bd->memory_seg) >>9 );
1468
                        break;
1469
 
1470
                case PCXI:
1471
                case PC64XE:
1472
                        ch->txptr = memaddr + ((tseg - bd->memory_seg) << 4);
1473
                        ch->rxptr = memaddr + ((rseg - bd->memory_seg) << 4);
1474
                        ch->txwin = ch->rxwin = 0;
1475
                        break;
1476
                }
1477
 
1478
                ch->txbufhead = 0;
1479
                ch->txbufsize = readw(&bc->tmax) + 1;
1480
 
1481
                ch->rxbufhead = 0;
1482
                ch->rxbufsize = readw(&bc->rmax) + 1;
1483
 
1484
                lowwater = ch->txbufsize >= 2000 ? 1024 : (ch->txbufsize / 2);
1485
 
1486
                /* Set transmitter low water mark */
1487
                fepcmd(ch, STXLWATER, lowwater, 0, 10, 0);
1488
 
1489
                /* Set receiver low water mark */
1490
                fepcmd(ch, SRXLWATER, (ch->rxbufsize / 4), 0, 10, 0);
1491
 
1492
                /* Set receiver high water mark */
1493
                fepcmd(ch, SRXHWATER, (3 * ch->rxbufsize / 4), 0, 10, 0);
1494
 
1495
                writew(100, &bc->edelay);
1496
                writeb(1, &bc->idata);
1497
 
1498
                ch->startc  = readb(&bc->startc);
1499
                ch->stopc   = readb(&bc->stopc);
1500
                ch->startca = readb(&bc->startca);
1501
                ch->stopca  = readb(&bc->stopca);
1502
 
1503
                ch->fepcflag = 0;
1504
                ch->fepiflag = 0;
1505
                ch->fepoflag = 0;
1506
                ch->fepstartc = 0;
1507
                ch->fepstopc = 0;
1508
                ch->fepstartca = 0;
1509
                ch->fepstopca = 0;
1510
 
1511
                ch->close_delay = 50;
1512
                ch->count = 0;
1513
                ch->blocked_open = 0;
1514
                init_waitqueue_head(&ch->open_wait);
1515
                init_waitqueue_head(&ch->close_wait);
1516
 
1517
                spin_unlock_irqrestore(&epca_lock, flags);
1518
        }
1519
 
1520
        printk(KERN_INFO
1521
                "Digi PC/Xx Driver V%s:  %s I/O = 0x%lx Mem = 0x%lx Ports = %d\n",
1522
                VERSION, board_desc[bd->type], (long)bd->port, (long)bd->membase, bd->numports);
1523
        memwinoff(bd, 0);
1524
}
1525
 
1526
static void epcapoll(unsigned long ignored)
1527
{
1528
        unsigned long flags;
1529
        int crd;
1530
        volatile unsigned int head, tail;
1531
        struct channel *ch;
1532
        struct board_info *bd;
1533
 
1534
        /*
1535
         * This routine is called upon every timer interrupt. Even though the
1536
         * Digi series cards are capable of generating interrupts this method
1537
         * of non-looping polling is more efficient. This routine checks for
1538
         * card generated events (Such as receive data, are transmit buffer
1539
         * empty) and acts on those events.
1540
         */
1541
        for (crd = 0; crd < num_cards; crd++) {
1542
                bd = &boards[crd];
1543
                ch = card_ptr[crd];
1544
 
1545
                if ((bd->status == DISABLED) || digi_poller_inhibited)
1546
                        continue;
1547
 
1548
                /*
1549
                 * assertmemoff is not needed here; indeed it is an empty
1550
                 * subroutine. It is being kept because future boards may need
1551
                 * this as well as some legacy boards.
1552
                 */
1553
                spin_lock_irqsave(&epca_lock, flags);
1554
 
1555
                assertmemoff(ch);
1556
 
1557
                globalwinon(ch);
1558
 
1559
                /*
1560
                 * In this case head and tail actually refer to the event queue
1561
                 * not the transmit or receive queue.
1562
                 */
1563
                head = readw(&ch->mailbox->ein);
1564
                tail = readw(&ch->mailbox->eout);
1565
 
1566
                /* If head isn't equal to tail we have an event */
1567
                if (head != tail)
1568
                        doevent(crd);
1569
                memoff(ch);
1570
 
1571
                spin_unlock_irqrestore(&epca_lock, flags);
1572
        } /* End for each card */
1573
        mod_timer(&epca_timer, jiffies + (HZ / 25));
1574
}
1575
 
1576
static void doevent(int crd)
1577
{
1578
        void __iomem *eventbuf;
1579
        struct channel *ch, *chan0;
1580
        static struct tty_struct *tty;
1581
        struct board_info *bd;
1582
        struct board_chan __iomem *bc;
1583
        unsigned int tail, head;
1584
        int event, channel;
1585
        int mstat, lstat;
1586
 
1587
        /*
1588
         * This subroutine is called by epcapoll when an event is detected
1589
         * in the event queue. This routine responds to those events.
1590
         */
1591
        bd = &boards[crd];
1592
 
1593
        chan0 = card_ptr[crd];
1594
        epcaassert(chan0 <= &digi_channels[nbdevs - 1], "ch out of range");
1595
        assertgwinon(chan0);
1596
        while ((tail = readw(&chan0->mailbox->eout)) != (head = readw(&chan0->mailbox->ein))) { /* Begin while something in event queue */
1597
                assertgwinon(chan0);
1598
                eventbuf = bd->re_map_membase + tail + ISTART;
1599
                /* Get the channel the event occurred on */
1600
                channel = readb(eventbuf);
1601
                /* Get the actual event code that occurred */
1602
                event = readb(eventbuf + 1);
1603
                /*
1604
                 * The two assignments below get the current modem status
1605
                 * (mstat) and the previous modem status (lstat). These are
1606
                 * useful becuase an event could signal a change in modem
1607
                 * signals itself.
1608
                 */
1609
                mstat = readb(eventbuf + 2);
1610
                lstat = readb(eventbuf + 3);
1611
 
1612
                ch = chan0 + channel;
1613
                if ((unsigned)channel >= bd->numports || !ch)  {
1614
                        if (channel >= bd->numports)
1615
                                ch = chan0;
1616
                        bc = ch->brdchan;
1617
                        goto next;
1618
                }
1619
 
1620
                if ((bc = ch->brdchan) == NULL)
1621
                        goto next;
1622
 
1623
                if (event & DATA_IND)  { /* Begin DATA_IND */
1624
                        receive_data(ch);
1625
                        assertgwinon(ch);
1626
                } /* End DATA_IND */
1627
                /* else *//* Fix for DCD transition missed bug */
1628
                if (event & MODEMCHG_IND) {
1629
                        /* A modem signal change has been indicated */
1630
                        ch->imodem = mstat;
1631
                        if (ch->asyncflags & ASYNC_CHECK_CD) {
1632
                                if (mstat & ch->dcd)  /* We are now receiving dcd */
1633
                                        wake_up_interruptible(&ch->open_wait);
1634
                                else
1635
                                        pc_sched_event(ch, EPCA_EVENT_HANGUP); /* No dcd; hangup */
1636
                        }
1637
                }
1638
                tty = ch->tty;
1639
                if (tty) {
1640
                        if (event & BREAK_IND) {
1641
                                /* A break has been indicated */
1642
                                tty_insert_flip_char(tty, 0, TTY_BREAK);
1643
                                tty_schedule_flip(tty);
1644
                        } else if (event & LOWTX_IND)  {
1645
                                if (ch->statusflags & LOWWAIT) {
1646
                                        ch->statusflags &= ~LOWWAIT;
1647
                                        tty_wakeup(tty);
1648
                                }
1649
                        } else if (event & EMPTYTX_IND) {
1650
                                /* This event is generated by setup_empty_event */
1651
                                ch->statusflags &= ~TXBUSY;
1652
                                if (ch->statusflags & EMPTYWAIT) {
1653
                                        ch->statusflags &= ~EMPTYWAIT;
1654
                                        tty_wakeup(tty);
1655
                                }
1656
                        }
1657
                }
1658
        next:
1659
                globalwinon(ch);
1660
                BUG_ON(!bc);
1661
                writew(1, &bc->idata);
1662
                writew((tail + 4) & (IMAX - ISTART - 4), &chan0->mailbox->eout);
1663
                globalwinon(chan0);
1664
        } /* End while something in event queue */
1665
}
1666
 
1667
static void fepcmd(struct channel *ch, int cmd, int word_or_byte,
1668
                   int byte2, int ncmds, int bytecmd)
1669
{
1670
        unchar __iomem *memaddr;
1671
        unsigned int head, cmdTail, cmdStart, cmdMax;
1672
        long count;
1673
        int n;
1674
 
1675
        /* This is the routine in which commands may be passed to the card. */
1676
 
1677
        if (ch->board->status == DISABLED)
1678
                return;
1679
        assertgwinon(ch);
1680
        /* Remember head (As well as max) is just an offset not a base addr */
1681
        head = readw(&ch->mailbox->cin);
1682
        /* cmdStart is a base address */
1683
        cmdStart = readw(&ch->mailbox->cstart);
1684
        /*
1685
         * We do the addition below because we do not want a max pointer
1686
         * relative to cmdStart. We want a max pointer that points at the
1687
         * physical end of the command queue.
1688
         */
1689
        cmdMax = (cmdStart + 4 + readw(&ch->mailbox->cmax));
1690
        memaddr = ch->board->re_map_membase;
1691
 
1692
        if (head >= (cmdMax - cmdStart) || (head & 03))  {
1693
                printk(KERN_ERR "line %d: Out of range, cmd = %x, head = %x\n", __LINE__,  cmd, head);
1694
                printk(KERN_ERR "line %d: Out of range, cmdMax = %x, cmdStart = %x\n", __LINE__,  cmdMax, cmdStart);
1695
                return;
1696
        }
1697
        if (bytecmd)  {
1698
                writeb(cmd, memaddr + head + cmdStart + 0);
1699
                writeb(ch->channelnum,  memaddr + head + cmdStart + 1);
1700
                /* Below word_or_byte is bits to set */
1701
                writeb(word_or_byte,  memaddr + head + cmdStart + 2);
1702
                /* Below byte2 is bits to reset */
1703
                writeb(byte2, memaddr + head + cmdStart + 3);
1704
        }  else {
1705
                writeb(cmd, memaddr + head + cmdStart + 0);
1706
                writeb(ch->channelnum,  memaddr + head + cmdStart + 1);
1707
                writeb(word_or_byte,  memaddr + head + cmdStart + 2);
1708
        }
1709
        head = (head + 4) & (cmdMax - cmdStart - 4);
1710
        writew(head, &ch->mailbox->cin);
1711
        count = FEPTIMEOUT;
1712
 
1713
        for (;;) {
1714
                count--;
1715
                if (count == 0)  {
1716
                        printk(KERN_ERR "<Error> - Fep not responding in fepcmd()\n");
1717
                        return;
1718
                }
1719
                head = readw(&ch->mailbox->cin);
1720
                cmdTail = readw(&ch->mailbox->cout);
1721
                n = (head - cmdTail) & (cmdMax - cmdStart - 4);
1722
                /*
1723
                 * Basically this will break when the FEP acknowledges the
1724
                 * command by incrementing cmdTail (Making it equal to head).
1725
                 */
1726
                if (n <= ncmds * (sizeof(short) * 4))
1727
                        break;
1728
        }
1729
}
1730
 
1731
/*
1732
 * Digi products use fields in their channels structures that are very similar
1733
 * to the c_cflag and c_iflag fields typically found in UNIX termios
1734
 * structures. The below three routines allow mappings between these hardware
1735
 * "flags" and their respective Linux flags.
1736
 */
1737
static unsigned termios2digi_h(struct channel *ch, unsigned cflag)
1738
{
1739
        unsigned res = 0;
1740
 
1741
        if (cflag & CRTSCTS) {
1742
                ch->digiext.digi_flags |= (RTSPACE | CTSPACE);
1743
                res |= ((ch->m_cts) | (ch->m_rts));
1744
        }
1745
 
1746
        if (ch->digiext.digi_flags & RTSPACE)
1747
                res |= ch->m_rts;
1748
 
1749
        if (ch->digiext.digi_flags & DTRPACE)
1750
                res |= ch->m_dtr;
1751
 
1752
        if (ch->digiext.digi_flags & CTSPACE)
1753
                res |= ch->m_cts;
1754
 
1755
        if (ch->digiext.digi_flags & DSRPACE)
1756
                res |= ch->dsr;
1757
 
1758
        if (ch->digiext.digi_flags & DCDPACE)
1759
                res |= ch->dcd;
1760
 
1761
        if (res & (ch->m_rts))
1762
                ch->digiext.digi_flags |= RTSPACE;
1763
 
1764
        if (res & (ch->m_cts))
1765
                ch->digiext.digi_flags |= CTSPACE;
1766
 
1767
        return res;
1768
}
1769
 
1770
static unsigned termios2digi_i(struct channel *ch, unsigned iflag)
1771
{
1772
        unsigned res = iflag & (IGNBRK | BRKINT | IGNPAR | PARMRK |
1773
                                INPCK | ISTRIP|IXON|IXANY|IXOFF);
1774
        if (ch->digiext.digi_flags & DIGI_AIXON)
1775
                res |= IAIXON;
1776
        return res;
1777
}
1778
 
1779
static unsigned termios2digi_c(struct channel *ch, unsigned cflag)
1780
{
1781
        unsigned res = 0;
1782
        if (cflag & CBAUDEX) {
1783
                ch->digiext.digi_flags |= DIGI_FAST;
1784
                /*
1785
                 * HUPCL bit is used by FEP to indicate fast baud table is to
1786
                 * be used.
1787
                 */
1788
                res |= FEP_HUPCL;
1789
        } else
1790
                ch->digiext.digi_flags &= ~DIGI_FAST;
1791
        /*
1792
         * CBAUD has bit position 0x1000 set these days to indicate Linux
1793
         * baud rate remap. Digi hardware can't handle the bit assignment.
1794
         * (We use a different bit assignment for high speed.). Clear this
1795
         * bit out.
1796
         */
1797
        res |= cflag & ((CBAUD ^ CBAUDEX) | PARODD | PARENB | CSTOPB | CSIZE);
1798
        /*
1799
         * This gets a little confusing. The Digi cards have their own
1800
         * representation of c_cflags controling baud rate. For the most part
1801
         * this is identical to the Linux implementation. However; Digi
1802
         * supports one rate (76800) that Linux doesn't. This means that the
1803
         * c_cflag entry that would normally mean 76800 for Digi actually means
1804
         * 115200 under Linux. Without the below mapping, a stty 115200 would
1805
         * only drive the board at 76800. Since the rate 230400 is also found
1806
         * after 76800, the same problem afflicts us when we choose a rate of
1807
         * 230400. Without the below modificiation stty 230400 would actually
1808
         * give us 115200.
1809
         *
1810
         * There are two additional differences. The Linux value for CLOCAL
1811
         * (0x800; 0004000) has no meaning to the Digi hardware. Also in later
1812
         * releases of Linux; the CBAUD define has CBAUDEX (0x1000; 0010000)
1813
         * ored into it (CBAUD = 0x100f as opposed to 0xf). CBAUDEX should be
1814
         * checked for a screened out prior to termios2digi_c returning. Since
1815
         * CLOCAL isn't used by the board this can be ignored as long as the
1816
         * returned value is used only by Digi hardware.
1817
         */
1818
        if (cflag & CBAUDEX) {
1819
                /*
1820
                 * The below code is trying to guarantee that only baud rates
1821
                 * 115200 and 230400 are remapped. We use exclusive or because
1822
                 * the various baud rates share common bit positions and
1823
                 * therefore can't be tested for easily.
1824
                 */
1825
                if ((!((cflag & 0x7) ^ (B115200 & ~CBAUDEX))) ||
1826
                    (!((cflag & 0x7) ^ (B230400 & ~CBAUDEX))))
1827
                        res += 1;
1828
        }
1829
        return res;
1830
}
1831
 
1832
/* Caller must hold the locks */
1833
static void epcaparam(struct tty_struct *tty, struct channel *ch)
1834
{
1835
        unsigned int cmdHead;
1836
        struct ktermios *ts;
1837
        struct board_chan __iomem *bc;
1838
        unsigned mval, hflow, cflag, iflag;
1839
 
1840
        bc = ch->brdchan;
1841
        epcaassert(bc !=0, "bc out of range");
1842
 
1843
        assertgwinon(ch);
1844
        ts = tty->termios;
1845
        if ((ts->c_cflag & CBAUD) == 0)  { /* Begin CBAUD detected */
1846
                cmdHead = readw(&bc->rin);
1847
                writew(cmdHead, &bc->rout);
1848
                cmdHead = readw(&bc->tin);
1849
                /* Changing baud in mid-stream transmission can be wonderful */
1850
                /*
1851
                 * Flush current transmit buffer by setting cmdTail pointer
1852
                 * (tout) to cmdHead pointer (tin). Hopefully the transmit
1853
                 * buffer is empty.
1854
                 */
1855
                fepcmd(ch, STOUT, (unsigned) cmdHead, 0, 0, 0);
1856
                mval = 0;
1857
        } else { /* Begin CBAUD not detected */
1858
                /*
1859
                 * c_cflags have changed but that change had nothing to do with
1860
                 * BAUD. Propagate the change to the card.
1861
                 */
1862
                cflag = termios2digi_c(ch, ts->c_cflag);
1863
                if (cflag != ch->fepcflag)  {
1864
                        ch->fepcflag = cflag;
1865
                        /* Set baud rate, char size, stop bits, parity */
1866
                        fepcmd(ch, SETCTRLFLAGS, (unsigned) cflag, 0, 0, 0);
1867
                }
1868
                /*
1869
                 * If the user has not forced CLOCAL and if the device is not a
1870
                 * CALLOUT device (Which is always CLOCAL) we set flags such
1871
                 * that the driver will wait on carrier detect.
1872
                 */
1873
                if (ts->c_cflag & CLOCAL)
1874
                        ch->asyncflags &= ~ASYNC_CHECK_CD;
1875
                else
1876
                        ch->asyncflags |= ASYNC_CHECK_CD;
1877
                mval = ch->m_dtr | ch->m_rts;
1878
        } /* End CBAUD not detected */
1879
        iflag = termios2digi_i(ch, ts->c_iflag);
1880
        /* Check input mode flags */
1881
        if (iflag != ch->fepiflag)  {
1882
                ch->fepiflag = iflag;
1883
                /*
1884
                 * Command sets channels iflag structure on the board. Such
1885
                 * things as input soft flow control, handling of parity
1886
                 * errors, and break handling are all set here.
1887
                 */
1888
                /* break handling, parity handling, input stripping, flow control chars */
1889
                fepcmd(ch, SETIFLAGS, (unsigned int) ch->fepiflag, 0, 0, 0);
1890
        }
1891
        /*
1892
         * Set the board mint value for this channel. This will cause hardware
1893
         * events to be generated each time the DCD signal (Described in mint)
1894
         * changes.
1895
         */
1896
        writeb(ch->dcd, &bc->mint);
1897
        if ((ts->c_cflag & CLOCAL) || (ch->digiext.digi_flags & DIGI_FORCEDCD))
1898
                if (ch->digiext.digi_flags & DIGI_FORCEDCD)
1899
                        writeb(0, &bc->mint);
1900
        ch->imodem = readb(&bc->mstat);
1901
        hflow = termios2digi_h(ch, ts->c_cflag);
1902
        if (hflow != ch->hflow)  {
1903
                ch->hflow = hflow;
1904
                /*
1905
                 * Hard flow control has been selected but the board is not
1906
                 * using it. Activate hard flow control now.
1907
                 */
1908
                fepcmd(ch, SETHFLOW, hflow, 0xff, 0, 1);
1909
        }
1910
        mval ^= ch->modemfake & (mval ^ ch->modem);
1911
 
1912
        if (ch->omodem ^ mval)  {
1913
                ch->omodem = mval;
1914
                /*
1915
                 * The below command sets the DTR and RTS mstat structure. If
1916
                 * hard flow control is NOT active these changes will drive the
1917
                 * output of the actual DTR and RTS lines. If hard flow control
1918
                 * is active, the changes will be saved in the mstat structure
1919
                 * and only asserted when hard flow control is turned off.
1920
                 */
1921
 
1922
                /* First reset DTR & RTS; then set them */
1923
                fepcmd(ch, SETMODEM, 0, ((ch->m_dtr)|(ch->m_rts)), 0, 1);
1924
                fepcmd(ch, SETMODEM, mval, 0, 0, 1);
1925
        }
1926
        if (ch->startc != ch->fepstartc || ch->stopc != ch->fepstopc)  {
1927
                ch->fepstartc = ch->startc;
1928
                ch->fepstopc = ch->stopc;
1929
                /*
1930
                 * The XON / XOFF characters have changed; propagate these
1931
                 * changes to the card.
1932
                 */
1933
                fepcmd(ch, SONOFFC, ch->fepstartc, ch->fepstopc, 0, 1);
1934
        }
1935
        if (ch->startca != ch->fepstartca || ch->stopca != ch->fepstopca)  {
1936
                ch->fepstartca = ch->startca;
1937
                ch->fepstopca = ch->stopca;
1938
                /*
1939
                 * Similar to the above, this time the auxilarly XON / XOFF
1940
                 * characters have changed; propagate these changes to the card.
1941
                 */
1942
                fepcmd(ch, SAUXONOFFC, ch->fepstartca, ch->fepstopca, 0, 1);
1943
        }
1944
}
1945
 
1946
/* Caller holds lock */
1947
static void receive_data(struct channel *ch)
1948
{
1949
        unchar *rptr;
1950
        struct ktermios *ts = NULL;
1951
        struct tty_struct *tty;
1952
        struct board_chan __iomem *bc;
1953
        int dataToRead, wrapgap, bytesAvailable;
1954
        unsigned int tail, head;
1955
        unsigned int wrapmask;
1956
 
1957
        /*
1958
         * This routine is called by doint when a receive data event has taken
1959
         * place.
1960
         */
1961
        globalwinon(ch);
1962
        if (ch->statusflags & RXSTOPPED)
1963
                return;
1964
        tty = ch->tty;
1965
        if (tty)
1966
                ts = tty->termios;
1967
        bc = ch->brdchan;
1968
        BUG_ON(!bc);
1969
        wrapmask = ch->rxbufsize - 1;
1970
 
1971
        /*
1972
         * Get the head and tail pointers to the receiver queue. Wrap the head
1973
         * pointer if it has reached the end of the buffer.
1974
         */
1975
        head = readw(&bc->rin);
1976
        head &= wrapmask;
1977
        tail = readw(&bc->rout) & wrapmask;
1978
 
1979
        bytesAvailable = (head - tail) & wrapmask;
1980
        if (bytesAvailable == 0)
1981
                return;
1982
 
1983
        /* If CREAD bit is off or device not open, set TX tail to head */
1984
        if (!tty || !ts || !(ts->c_cflag & CREAD))  {
1985
                writew(head, &bc->rout);
1986
                return;
1987
        }
1988
 
1989
        if (tty_buffer_request_room(tty, bytesAvailable + 1) == 0)
1990
                return;
1991
 
1992
        if (readb(&bc->orun)) {
1993
                writeb(0, &bc->orun);
1994
                printk(KERN_WARNING "epca; overrun! DigiBoard device %s\n",tty->name);
1995
                tty_insert_flip_char(tty, 0, TTY_OVERRUN);
1996
        }
1997
        rxwinon(ch);
1998
        while (bytesAvailable > 0)  { /* Begin while there is data on the card */
1999
                wrapgap = (head >= tail) ? head - tail : ch->rxbufsize - tail;
2000
                /*
2001
                 * Even if head has wrapped around only report the amount of
2002
                 * data to be equal to the size - tail. Remember memcpy can't
2003
                 * automaticly wrap around the receive buffer.
2004
                 */
2005
                dataToRead = (wrapgap < bytesAvailable) ? wrapgap : bytesAvailable;
2006
                /* Make sure we don't overflow the buffer */
2007
                dataToRead = tty_prepare_flip_string(tty, &rptr, dataToRead);
2008
                if (dataToRead == 0)
2009
                        break;
2010
                /*
2011
                 * Move data read from our card into the line disciplines
2012
                 * buffer for translation if necessary.
2013
                 */
2014
                memcpy_fromio(rptr, ch->rxptr + tail, dataToRead);
2015
                tail = (tail + dataToRead) & wrapmask;
2016
                bytesAvailable -= dataToRead;
2017
        } /* End while there is data on the card */
2018
        globalwinon(ch);
2019
        writew(tail, &bc->rout);
2020
        /* Must be called with global data */
2021
        tty_schedule_flip(ch->tty);
2022
}
2023
 
2024
static int info_ioctl(struct tty_struct *tty, struct file *file,
2025
                    unsigned int cmd, unsigned long arg)
2026
{
2027
        switch (cmd) {
2028
        case DIGI_GETINFO:
2029
                {
2030
                        struct digi_info di;
2031
                        int brd;
2032
 
2033
                        if (get_user(brd, (unsigned int __user *)arg))
2034
                                return -EFAULT;
2035
                        if (brd < 0 || brd >= num_cards || num_cards == 0)
2036
                                return -ENODEV;
2037
 
2038
                        memset(&di, 0, sizeof(di));
2039
 
2040
                        di.board = brd;
2041
                        di.status = boards[brd].status;
2042
                        di.type = boards[brd].type ;
2043
                        di.numports = boards[brd].numports ;
2044
                        /* Legacy fixups - just move along nothing to see */
2045
                        di.port = (unsigned char *)boards[brd].port ;
2046
                        di.membase = (unsigned char *)boards[brd].membase ;
2047
 
2048
                        if (copy_to_user((void __user *)arg, &di, sizeof(di)))
2049
                                return -EFAULT;
2050
                        break;
2051
 
2052
                }
2053
 
2054
        case DIGI_POLLER:
2055
                {
2056
                        int brd = arg & 0xff000000 >> 16;
2057
                        unsigned char state = arg & 0xff;
2058
 
2059
                        if (brd < 0 || brd >= num_cards) {
2060
                                printk(KERN_ERR "epca: DIGI POLLER : brd not valid!\n");
2061
                                return -ENODEV;
2062
                        }
2063
                        digi_poller_inhibited = state;
2064
                        break;
2065
                }
2066
 
2067
        case DIGI_INIT:
2068
                {
2069
                        /*
2070
                         * This call is made by the apps to complete the
2071
                         * initilization of the board(s). This routine is
2072
                         * responsible for setting the card to its initial
2073
                         * state and setting the drivers control fields to the
2074
                         * sutianle settings for the card in question.
2075
                         */
2076
                        int crd;
2077
                        for (crd = 0; crd < num_cards; crd++)
2078
                                post_fep_init(crd);
2079
                        break;
2080
                }
2081
        default:
2082
                return -ENOTTY;
2083
        }
2084
        return 0;
2085
}
2086
 
2087
static int pc_tiocmget(struct tty_struct *tty, struct file *file)
2088
{
2089
        struct channel *ch = (struct channel *) tty->driver_data;
2090
        struct board_chan __iomem *bc;
2091
        unsigned int mstat, mflag = 0;
2092
        unsigned long flags;
2093
 
2094
        if (ch)
2095
                bc = ch->brdchan;
2096
        else
2097
                return -EINVAL;
2098
 
2099
        spin_lock_irqsave(&epca_lock, flags);
2100
        globalwinon(ch);
2101
        mstat = readb(&bc->mstat);
2102
        memoff(ch);
2103
        spin_unlock_irqrestore(&epca_lock, flags);
2104
 
2105
        if (mstat & ch->m_dtr)
2106
                mflag |= TIOCM_DTR;
2107
        if (mstat & ch->m_rts)
2108
                mflag |= TIOCM_RTS;
2109
        if (mstat & ch->m_cts)
2110
                mflag |= TIOCM_CTS;
2111
        if (mstat & ch->dsr)
2112
                mflag |= TIOCM_DSR;
2113
        if (mstat & ch->m_ri)
2114
                mflag |= TIOCM_RI;
2115
        if (mstat & ch->dcd)
2116
                mflag |= TIOCM_CD;
2117
        return mflag;
2118
}
2119
 
2120
static int pc_tiocmset(struct tty_struct *tty, struct file *file,
2121
                       unsigned int set, unsigned int clear)
2122
{
2123
        struct channel *ch = (struct channel *) tty->driver_data;
2124
        unsigned long flags;
2125
 
2126
        if (!ch)
2127
                return -EINVAL;
2128
 
2129
        spin_lock_irqsave(&epca_lock, flags);
2130
        /*
2131
         * I think this modemfake stuff is broken. It doesn't correctly reflect
2132
         * the behaviour desired by the TIOCM* ioctls. Therefore this is
2133
         * probably broken.
2134
         */
2135
        if (set & TIOCM_RTS) {
2136
                ch->modemfake |= ch->m_rts;
2137
                ch->modem |= ch->m_rts;
2138
        }
2139
        if (set & TIOCM_DTR) {
2140
                ch->modemfake |= ch->m_dtr;
2141
                ch->modem |= ch->m_dtr;
2142
        }
2143
        if (clear & TIOCM_RTS) {
2144
                ch->modemfake |= ch->m_rts;
2145
                ch->modem &= ~ch->m_rts;
2146
        }
2147
        if (clear & TIOCM_DTR) {
2148
                ch->modemfake |= ch->m_dtr;
2149
                ch->modem &= ~ch->m_dtr;
2150
        }
2151
        globalwinon(ch);
2152
        /*
2153
         * The below routine generally sets up parity, baud, flow control
2154
         * issues, etc.... It effect both control flags and input flags.
2155
         */
2156
        epcaparam(tty,ch);
2157
        memoff(ch);
2158
        spin_unlock_irqrestore(&epca_lock, flags);
2159
        return 0;
2160
}
2161
 
2162
static int pc_ioctl(struct tty_struct *tty, struct file * file,
2163
                    unsigned int cmd, unsigned long arg)
2164
{
2165
        digiflow_t dflow;
2166
        int retval;
2167
        unsigned long flags;
2168
        unsigned int mflag, mstat;
2169
        unsigned char startc, stopc;
2170
        struct board_chan __iomem *bc;
2171
        struct channel *ch = (struct channel *) tty->driver_data;
2172
        void __user *argp = (void __user *)arg;
2173
 
2174
        if (ch)
2175
                bc = ch->brdchan;
2176
        else
2177
                return -EINVAL;
2178
 
2179
        /*
2180
         * For POSIX compliance we need to add more ioctls. See tty_ioctl.c in
2181
         * /usr/src/linux/drivers/char for a good example. In particular think
2182
         * about adding TCSETAF, TCSETAW, TCSETA, TCSETSF, TCSETSW, TCSETS.
2183
         */
2184
        switch (cmd) {
2185
        case TCSBRK:    /* SVID version: non-zero arg --> no break */
2186
                retval = tty_check_change(tty);
2187
                if (retval)
2188
                        return retval;
2189
                /* Setup an event to indicate when the transmit buffer empties */
2190
                spin_lock_irqsave(&epca_lock, flags);
2191
                setup_empty_event(tty,ch);
2192
                spin_unlock_irqrestore(&epca_lock, flags);
2193
                tty_wait_until_sent(tty, 0);
2194
                if (!arg)
2195
                        digi_send_break(ch, HZ / 4);    /* 1/4 second */
2196
                return 0;
2197
        case TCSBRKP:   /* support for POSIX tcsendbreak() */
2198
                retval = tty_check_change(tty);
2199
                if (retval)
2200
                        return retval;
2201
 
2202
                /* Setup an event to indicate when the transmit buffer empties */
2203
                spin_lock_irqsave(&epca_lock, flags);
2204
                setup_empty_event(tty,ch);
2205
                spin_unlock_irqrestore(&epca_lock, flags);
2206
                tty_wait_until_sent(tty, 0);
2207
                digi_send_break(ch, arg ? arg*(HZ/10) : HZ/4);
2208
                return 0;
2209
        case TIOCGSOFTCAR:
2210
                if (put_user(C_CLOCAL(tty)?1:0, (unsigned long __user *)arg))
2211
                        return -EFAULT;
2212
                return 0;
2213
        case TIOCSSOFTCAR:
2214
                {
2215
                        unsigned int value;
2216
 
2217
                        if (get_user(value, (unsigned __user *)argp))
2218
                                return -EFAULT;
2219
                        tty->termios->c_cflag =
2220
                                ((tty->termios->c_cflag & ~CLOCAL) |
2221
                                 (value ? CLOCAL : 0));
2222
                        return 0;
2223
                }
2224
        case TIOCMODG:
2225
                mflag = pc_tiocmget(tty, file);
2226
                if (put_user(mflag, (unsigned long __user *)argp))
2227
                        return -EFAULT;
2228
                break;
2229
        case TIOCMODS:
2230
                if (get_user(mstat, (unsigned __user *)argp))
2231
                        return -EFAULT;
2232
                return pc_tiocmset(tty, file, mstat, ~mstat);
2233
        case TIOCSDTR:
2234
                spin_lock_irqsave(&epca_lock, flags);
2235
                ch->omodem |= ch->m_dtr;
2236
                globalwinon(ch);
2237
                fepcmd(ch, SETMODEM, ch->m_dtr, 0, 10, 1);
2238
                memoff(ch);
2239
                spin_unlock_irqrestore(&epca_lock, flags);
2240
                break;
2241
 
2242
        case TIOCCDTR:
2243
                spin_lock_irqsave(&epca_lock, flags);
2244
                ch->omodem &= ~ch->m_dtr;
2245
                globalwinon(ch);
2246
                fepcmd(ch, SETMODEM, 0, ch->m_dtr, 10, 1);
2247
                memoff(ch);
2248
                spin_unlock_irqrestore(&epca_lock, flags);
2249
                break;
2250
        case DIGI_GETA:
2251
                if (copy_to_user(argp, &ch->digiext, sizeof(digi_t)))
2252
                        return -EFAULT;
2253
                break;
2254
        case DIGI_SETAW:
2255
        case DIGI_SETAF:
2256
                if (cmd == DIGI_SETAW) {
2257
                        /* Setup an event to indicate when the transmit buffer empties */
2258
                        spin_lock_irqsave(&epca_lock, flags);
2259
                        setup_empty_event(tty,ch);
2260
                        spin_unlock_irqrestore(&epca_lock, flags);
2261
                        tty_wait_until_sent(tty, 0);
2262
                } else {
2263
                        /* ldisc lock already held in ioctl */
2264
                        if (tty->ldisc.flush_buffer)
2265
                                tty->ldisc.flush_buffer(tty);
2266
                }
2267
                /* Fall Thru */
2268
        case DIGI_SETA:
2269
                if (copy_from_user(&ch->digiext, argp, sizeof(digi_t)))
2270
                        return -EFAULT;
2271
 
2272
                if (ch->digiext.digi_flags & DIGI_ALTPIN)  {
2273
                        ch->dcd = ch->m_dsr;
2274
                        ch->dsr = ch->m_dcd;
2275
                } else {
2276
                        ch->dcd = ch->m_dcd;
2277
                        ch->dsr = ch->m_dsr;
2278
                        }
2279
 
2280
                spin_lock_irqsave(&epca_lock, flags);
2281
                globalwinon(ch);
2282
 
2283
                /*
2284
                 * The below routine generally sets up parity, baud, flow
2285
                 * control issues, etc.... It effect both control flags and
2286
                 * input flags.
2287
                 */
2288
                epcaparam(tty,ch);
2289
                memoff(ch);
2290
                spin_unlock_irqrestore(&epca_lock, flags);
2291
                break;
2292
 
2293
        case DIGI_GETFLOW:
2294
        case DIGI_GETAFLOW:
2295
                spin_lock_irqsave(&epca_lock, flags);
2296
                globalwinon(ch);
2297
                if (cmd == DIGI_GETFLOW) {
2298
                        dflow.startc = readb(&bc->startc);
2299
                        dflow.stopc = readb(&bc->stopc);
2300
                } else {
2301
                        dflow.startc = readb(&bc->startca);
2302
                        dflow.stopc = readb(&bc->stopca);
2303
                }
2304
                memoff(ch);
2305
                spin_unlock_irqrestore(&epca_lock, flags);
2306
 
2307
                if (copy_to_user(argp, &dflow, sizeof(dflow)))
2308
                        return -EFAULT;
2309
                break;
2310
 
2311
        case DIGI_SETAFLOW:
2312
        case DIGI_SETFLOW:
2313
                if (cmd == DIGI_SETFLOW) {
2314
                        startc = ch->startc;
2315
                        stopc = ch->stopc;
2316
                } else {
2317
                        startc = ch->startca;
2318
                        stopc = ch->stopca;
2319
                }
2320
 
2321
                if (copy_from_user(&dflow, argp, sizeof(dflow)))
2322
                        return -EFAULT;
2323
 
2324
                if (dflow.startc != startc || dflow.stopc != stopc) { /* Begin  if setflow toggled */
2325
                        spin_lock_irqsave(&epca_lock, flags);
2326
                        globalwinon(ch);
2327
 
2328
                        if (cmd == DIGI_SETFLOW) {
2329
                                ch->fepstartc = ch->startc = dflow.startc;
2330
                                ch->fepstopc = ch->stopc = dflow.stopc;
2331
                                fepcmd(ch, SONOFFC, ch->fepstartc, ch->fepstopc, 0, 1);
2332
                        } else {
2333
                                ch->fepstartca = ch->startca = dflow.startc;
2334
                                ch->fepstopca  = ch->stopca = dflow.stopc;
2335
                                fepcmd(ch, SAUXONOFFC, ch->fepstartca, ch->fepstopca, 0, 1);
2336
                        }
2337
 
2338
                        if (ch->statusflags & TXSTOPPED)
2339
                                pc_start(tty);
2340
 
2341
                        memoff(ch);
2342
                        spin_unlock_irqrestore(&epca_lock, flags);
2343
                } /* End if setflow toggled */
2344
                break;
2345
        default:
2346
                return -ENOIOCTLCMD;
2347
        }
2348
        return 0;
2349
}
2350
 
2351
static void pc_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
2352
{
2353
        struct channel *ch;
2354
        unsigned long flags;
2355
        /*
2356
         * verifyChannel returns the channel from the tty struct if it is
2357
         * valid. This serves as a sanity check.
2358
         */
2359
        if ((ch = verifyChannel(tty)) != NULL)  { /* Begin if channel valid */
2360
                spin_lock_irqsave(&epca_lock, flags);
2361
                globalwinon(ch);
2362
                epcaparam(tty, ch);
2363
                memoff(ch);
2364
                spin_unlock_irqrestore(&epca_lock, flags);
2365
 
2366
                if ((old_termios->c_cflag & CRTSCTS) &&
2367
                         ((tty->termios->c_cflag & CRTSCTS) == 0))
2368
                        tty->hw_stopped = 0;
2369
 
2370
                if (!(old_termios->c_cflag & CLOCAL) &&
2371
                         (tty->termios->c_cflag & CLOCAL))
2372
                        wake_up_interruptible(&ch->open_wait);
2373
 
2374
        } /* End if channel valid */
2375
}
2376
 
2377
static void do_softint(struct work_struct *work)
2378
{
2379
        struct channel *ch = container_of(work, struct channel, tqueue);
2380
        /* Called in response to a modem change event */
2381
        if (ch && ch->magic == EPCA_MAGIC) {
2382
                struct tty_struct *tty = ch->tty;
2383
 
2384
                if (tty && tty->driver_data) {
2385
                        if (test_and_clear_bit(EPCA_EVENT_HANGUP, &ch->event)) {
2386
                                tty_hangup(tty);        /* FIXME: module removal race here - AKPM */
2387
                                wake_up_interruptible(&ch->open_wait);
2388
                                ch->asyncflags &= ~ASYNC_NORMAL_ACTIVE;
2389
                        }
2390
                }
2391
        }
2392
}
2393
 
2394
/*
2395
 * pc_stop and pc_start provide software flow control to the routine and the
2396
 * pc_ioctl routine.
2397
 */
2398
static void pc_stop(struct tty_struct *tty)
2399
{
2400
        struct channel *ch;
2401
        unsigned long flags;
2402
        /*
2403
         * verifyChannel returns the channel from the tty struct if it is
2404
         * valid. This serves as a sanity check.
2405
         */
2406
        if ((ch = verifyChannel(tty)) != NULL) {
2407
                spin_lock_irqsave(&epca_lock, flags);
2408
                if ((ch->statusflags & TXSTOPPED) == 0) { /* Begin if transmit stop requested */
2409
                        globalwinon(ch);
2410
                        /* STOP transmitting now !! */
2411
                        fepcmd(ch, PAUSETX, 0, 0, 0, 0);
2412
                        ch->statusflags |= TXSTOPPED;
2413
                        memoff(ch);
2414
                } /* End if transmit stop requested */
2415
                spin_unlock_irqrestore(&epca_lock, flags);
2416
        }
2417
}
2418
 
2419
static void pc_start(struct tty_struct *tty)
2420
{
2421
        struct channel *ch;
2422
        /*
2423
         * verifyChannel returns the channel from the tty struct if it is
2424
         * valid. This serves as a sanity check.
2425
         */
2426
        if ((ch = verifyChannel(tty)) != NULL) {
2427
                unsigned long flags;
2428
                spin_lock_irqsave(&epca_lock, flags);
2429
                /* Just in case output was resumed because of a change in Digi-flow */
2430
                if (ch->statusflags & TXSTOPPED)  { /* Begin transmit resume requested */
2431
                        struct board_chan __iomem *bc;
2432
                        globalwinon(ch);
2433
                        bc = ch->brdchan;
2434
                        if (ch->statusflags & LOWWAIT)
2435
                                writeb(1, &bc->ilow);
2436
                        /* Okay, you can start transmitting again... */
2437
                        fepcmd(ch, RESUMETX, 0, 0, 0, 0);
2438
                        ch->statusflags &= ~TXSTOPPED;
2439
                        memoff(ch);
2440
                } /* End transmit resume requested */
2441
                spin_unlock_irqrestore(&epca_lock, flags);
2442
        }
2443
}
2444
 
2445
/*
2446
 * The below routines pc_throttle and pc_unthrottle are used to slow (And
2447
 * resume) the receipt of data into the kernels receive buffers. The exact
2448
 * occurrence of this depends on the size of the kernels receive buffer and
2449
 * what the 'watermarks' are set to for that buffer. See the n_ttys.c file for
2450
 * more details.
2451
 */
2452
static void pc_throttle(struct tty_struct *tty)
2453
{
2454
        struct channel *ch;
2455
        unsigned long flags;
2456
        /*
2457
         * verifyChannel returns the channel from the tty struct if it is
2458
         * valid. This serves as a sanity check.
2459
         */
2460
        if ((ch = verifyChannel(tty)) != NULL) {
2461
                spin_lock_irqsave(&epca_lock, flags);
2462
                if ((ch->statusflags & RXSTOPPED) == 0) {
2463
                        globalwinon(ch);
2464
                        fepcmd(ch, PAUSERX, 0, 0, 0, 0);
2465
                        ch->statusflags |= RXSTOPPED;
2466
                        memoff(ch);
2467
                }
2468
                spin_unlock_irqrestore(&epca_lock, flags);
2469
        }
2470
}
2471
 
2472
static void pc_unthrottle(struct tty_struct *tty)
2473
{
2474
        struct channel *ch;
2475
        unsigned long flags;
2476
        /*
2477
         * verifyChannel returns the channel from the tty struct if it is
2478
         * valid. This serves as a sanity check.
2479
         */
2480
        if ((ch = verifyChannel(tty)) != NULL) {
2481
                /* Just in case output was resumed because of a change in Digi-flow */
2482
                spin_lock_irqsave(&epca_lock, flags);
2483
                if (ch->statusflags & RXSTOPPED) {
2484
                        globalwinon(ch);
2485
                        fepcmd(ch, RESUMERX, 0, 0, 0, 0);
2486
                        ch->statusflags &= ~RXSTOPPED;
2487
                        memoff(ch);
2488
                }
2489
                spin_unlock_irqrestore(&epca_lock, flags);
2490
        }
2491
}
2492
 
2493
void digi_send_break(struct channel *ch, int msec)
2494
{
2495
        unsigned long flags;
2496
 
2497
        spin_lock_irqsave(&epca_lock, flags);
2498
        globalwinon(ch);
2499
        /*
2500
         * Maybe I should send an infinite break here, schedule() for msec
2501
         * amount of time, and then stop the break. This way, the user can't
2502
         * screw up the FEP by causing digi_send_break() to be called (i.e. via
2503
         * an ioctl()) more than once in msec amount of time.
2504
         * Try this for now...
2505
         */
2506
        fepcmd(ch, SENDBREAK, msec, 0, 10, 0);
2507
        memoff(ch);
2508
        spin_unlock_irqrestore(&epca_lock, flags);
2509
}
2510
 
2511
/* Caller MUST hold the lock */
2512
static void setup_empty_event(struct tty_struct *tty, struct channel *ch)
2513
{
2514
        struct board_chan __iomem *bc = ch->brdchan;
2515
 
2516
        globalwinon(ch);
2517
        ch->statusflags |= EMPTYWAIT;
2518
        /*
2519
         * When set the iempty flag request a event to be generated when the
2520
         * transmit buffer is empty (If there is no BREAK in progress).
2521
         */
2522
        writeb(1, &bc->iempty);
2523
        memoff(ch);
2524
}
2525
 
2526
void epca_setup(char *str, int *ints)
2527
{
2528
        struct board_info board;
2529
        int               index, loop, last;
2530
        char              *temp, *t2;
2531
        unsigned          len;
2532
 
2533
        /*
2534
         * If this routine looks a little strange it is because it is only
2535
         * called if a LILO append command is given to boot the kernel with
2536
         * parameters. In this way, we can provide the user a method of
2537
         * changing his board configuration without rebuilding the kernel.
2538
         */
2539
        if (!liloconfig)
2540
                liloconfig = 1;
2541
 
2542
        memset(&board, 0, sizeof(board));
2543
 
2544
        /* Assume the data is int first, later we can change it */
2545
        /* I think that array position 0 of ints holds the number of args */
2546
        for (last = 0, index = 1; index <= ints[0]; index++)
2547
                switch (index) { /* Begin parse switch */
2548
                case 1:
2549
                        board.status = ints[index];
2550
                        /*
2551
                         * We check for 2 (As opposed to 1; because 2 is a flag
2552
                         * instructing the driver to ignore epcaconfig.) For
2553
                         * this reason we check for 2.
2554
                         */
2555
                        if (board.status == 2) { /* Begin ignore epcaconfig as well as lilo cmd line */
2556
                                nbdevs = 0;
2557
                                num_cards = 0;
2558
                                return;
2559
                        } /* End ignore epcaconfig as well as lilo cmd line */
2560
 
2561
                        if (board.status > 2) {
2562
                                printk(KERN_ERR "epca_setup: Invalid board status 0x%x\n", board.status);
2563
                                invalid_lilo_config = 1;
2564
                                setup_error_code |= INVALID_BOARD_STATUS;
2565
                                return;
2566
                        }
2567
                        last = index;
2568
                        break;
2569
                case 2:
2570
                        board.type = ints[index];
2571
                        if (board.type >= PCIXEM)  {
2572
                                printk(KERN_ERR "epca_setup: Invalid board type 0x%x\n", board.type);
2573
                                invalid_lilo_config = 1;
2574
                                setup_error_code |= INVALID_BOARD_TYPE;
2575
                                return;
2576
                        }
2577
                        last = index;
2578
                        break;
2579
                case 3:
2580
                        board.altpin = ints[index];
2581
                        if (board.altpin > 1) {
2582
                                printk(KERN_ERR "epca_setup: Invalid board altpin 0x%x\n", board.altpin);
2583
                                invalid_lilo_config = 1;
2584
                                setup_error_code |= INVALID_ALTPIN;
2585
                                return;
2586
                        }
2587
                        last = index;
2588
                        break;
2589
 
2590
                case 4:
2591
                        board.numports = ints[index];
2592
                        if (board.numports < 2 || board.numports > 256) {
2593
                                printk(KERN_ERR "epca_setup: Invalid board numports 0x%x\n", board.numports);
2594
                                invalid_lilo_config = 1;
2595
                                setup_error_code |= INVALID_NUM_PORTS;
2596
                                return;
2597
                        }
2598
                        nbdevs += board.numports;
2599
                        last = index;
2600
                        break;
2601
 
2602
                case 5:
2603
                        board.port = ints[index];
2604
                        if (ints[index] <= 0) {
2605
                                printk(KERN_ERR "epca_setup: Invalid io port 0x%x\n", (unsigned int)board.port);
2606
                                invalid_lilo_config = 1;
2607
                                setup_error_code |= INVALID_PORT_BASE;
2608
                                return;
2609
                        }
2610
                        last = index;
2611
                        break;
2612
 
2613
                case 6:
2614
                        board.membase = ints[index];
2615
                        if (ints[index] <= 0) {
2616
                                printk(KERN_ERR "epca_setup: Invalid memory base 0x%x\n",(unsigned int)board.membase);
2617
                                invalid_lilo_config = 1;
2618
                                setup_error_code |= INVALID_MEM_BASE;
2619
                                return;
2620
                        }
2621
                        last = index;
2622
                        break;
2623
 
2624
                default:
2625
                        printk(KERN_ERR "<Error> - epca_setup: Too many integer parms\n");
2626
                        return;
2627
 
2628
                } /* End parse switch */
2629
 
2630
        while (str && *str)  { /* Begin while there is a string arg */
2631
                /* find the next comma or terminator */
2632
                temp = str;
2633
                /* While string is not null, and a comma hasn't been found */
2634
                while (*temp && (*temp != ','))
2635
                        temp++;
2636
                if (!*temp)
2637
                        temp = NULL;
2638
                else
2639
                        *temp++ = 0;
2640
                /* Set index to the number of args + 1 */
2641
                index = last + 1;
2642
 
2643
                switch (index) {
2644
                case 1:
2645
                        len = strlen(str);
2646
                        if (strncmp("Disable", str, len) == 0)
2647
                                board.status = 0;
2648
                        else if (strncmp("Enable", str, len) == 0)
2649
                                board.status = 1;
2650
                        else {
2651
                                printk(KERN_ERR "epca_setup: Invalid status %s\n", str);
2652
                                invalid_lilo_config = 1;
2653
                                setup_error_code |= INVALID_BOARD_STATUS;
2654
                                return;
2655
                        }
2656
                        last = index;
2657
                        break;
2658
 
2659
                case 2:
2660
                        for (loop = 0; loop < EPCA_NUM_TYPES; loop++)
2661
                                if (strcmp(board_desc[loop], str) == 0)
2662
                                        break;
2663
                        /*
2664
                         * If the index incremented above refers to a
2665
                         * legitamate board type set it here.
2666
                         */
2667
                        if (index < EPCA_NUM_TYPES)
2668
                                board.type = loop;
2669
                        else {
2670
                                printk(KERN_ERR "epca_setup: Invalid board type: %s\n", str);
2671
                                invalid_lilo_config = 1;
2672
                                setup_error_code |= INVALID_BOARD_TYPE;
2673
                                return;
2674
                        }
2675
                        last = index;
2676
                        break;
2677
 
2678
                case 3:
2679
                        len = strlen(str);
2680
                        if (strncmp("Disable", str, len) == 0)
2681
                                board.altpin = 0;
2682
                        else if (strncmp("Enable", str, len) == 0)
2683
                                board.altpin = 1;
2684
                        else {
2685
                                printk(KERN_ERR "epca_setup: Invalid altpin %s\n", str);
2686
                                invalid_lilo_config = 1;
2687
                                setup_error_code |= INVALID_ALTPIN;
2688
                                return;
2689
                        }
2690
                        last = index;
2691
                        break;
2692
 
2693
                case 4:
2694
                        t2 = str;
2695
                        while (isdigit(*t2))
2696
                                t2++;
2697
 
2698
                        if (*t2) {
2699
                                printk(KERN_ERR "epca_setup: Invalid port count %s\n", str);
2700
                                invalid_lilo_config = 1;
2701
                                setup_error_code |= INVALID_NUM_PORTS;
2702
                                return;
2703
                        }
2704
 
2705
                        /*
2706
                         * There is not a man page for simple_strtoul but the
2707
                         * code can be found in vsprintf.c. The first argument
2708
                         * is the string to translate (To an unsigned long
2709
                         * obviously), the second argument can be the address
2710
                         * of any character variable or a NULL. If a variable
2711
                         * is given, the end pointer of the string will be
2712
                         * stored in that variable; if a NULL is given the end
2713
                         * pointer will not be returned. The last argument is
2714
                         * the base to use. If a 0 is indicated, the routine
2715
                         * will attempt to determine the proper base by looking
2716
                         * at the values prefix (A '0' for octal, a 'x' for
2717
                         * hex, etc ... If a value is given it will use that
2718
                         * value as the base.
2719
                         */
2720
                        board.numports = simple_strtoul(str, NULL, 0);
2721
                        nbdevs += board.numports;
2722
                        last = index;
2723
                        break;
2724
 
2725
                case 5:
2726
                        t2 = str;
2727
                        while (isxdigit(*t2))
2728
                                t2++;
2729
 
2730
                        if (*t2) {
2731
                                printk(KERN_ERR "epca_setup: Invalid i/o address %s\n", str);
2732
                                invalid_lilo_config = 1;
2733
                                setup_error_code |= INVALID_PORT_BASE;
2734
                                return;
2735
                        }
2736
 
2737
                        board.port = simple_strtoul(str, NULL, 16);
2738
                        last = index;
2739
                        break;
2740
 
2741
                case 6:
2742
                        t2 = str;
2743
                        while (isxdigit(*t2))
2744
                                t2++;
2745
 
2746
                        if (*t2) {
2747
                                printk(KERN_ERR "epca_setup: Invalid memory base %s\n",str);
2748
                                invalid_lilo_config = 1;
2749
                                setup_error_code |= INVALID_MEM_BASE;
2750
                                return;
2751
                        }
2752
                        board.membase = simple_strtoul(str, NULL, 16);
2753
                        last = index;
2754
                        break;
2755
                default:
2756
                        printk(KERN_ERR "epca: Too many string parms\n");
2757
                        return;
2758
                }
2759
                str = temp;
2760
        } /* End while there is a string arg */
2761
 
2762
        if (last < 6) {
2763
                printk(KERN_ERR "epca: Insufficient parms specified\n");
2764
                return;
2765
        }
2766
 
2767
        /* I should REALLY validate the stuff here */
2768
        /* Copies our local copy of board into boards */
2769
        memcpy((void *)&boards[num_cards],(void *)&board, sizeof(board));
2770
        /* Does this get called once per lilo arg are what ? */
2771
        printk(KERN_INFO "PC/Xx: Added board %i, %s %i ports at 0x%4.4X base 0x%6.6X\n",
2772
                num_cards, board_desc[board.type],
2773
                board.numports, (int)board.port, (unsigned int) board.membase);
2774
        num_cards++;
2775
}
2776
 
2777
enum epic_board_types {
2778
        brd_xr = 0,
2779
        brd_xem,
2780
        brd_cx,
2781
        brd_xrj,
2782
};
2783
 
2784
/* indexed directly by epic_board_types enum */
2785
static struct {
2786
        unsigned char board_type;
2787
        unsigned bar_idx;               /* PCI base address region */
2788
} epca_info_tbl[] = {
2789
        { PCIXR, 0, },
2790
        { PCIXEM, 0, },
2791
        { PCICX, 0, },
2792
        { PCIXRJ, 2, },
2793
};
2794
 
2795
static int __devinit epca_init_one(struct pci_dev *pdev,
2796
                                 const struct pci_device_id *ent)
2797
{
2798
        static int board_num = -1;
2799
        int board_idx, info_idx = ent->driver_data;
2800
        unsigned long addr;
2801
 
2802
        if (pci_enable_device(pdev))
2803
                return -EIO;
2804
 
2805
        board_num++;
2806
        board_idx = board_num + num_cards;
2807
        if (board_idx >= MAXBOARDS)
2808
                goto err_out;
2809
 
2810
        addr = pci_resource_start (pdev, epca_info_tbl[info_idx].bar_idx);
2811
        if (!addr) {
2812
                printk (KERN_ERR PFX "PCI region #%d not available (size 0)\n",
2813
                        epca_info_tbl[info_idx].bar_idx);
2814
                goto err_out;
2815
        }
2816
 
2817
        boards[board_idx].status = ENABLED;
2818
        boards[board_idx].type = epca_info_tbl[info_idx].board_type;
2819
        boards[board_idx].numports = 0x0;
2820
        boards[board_idx].port = addr + PCI_IO_OFFSET;
2821
        boards[board_idx].membase = addr;
2822
 
2823
        if (!request_mem_region (addr + PCI_IO_OFFSET, 0x200000, "epca")) {
2824
                printk (KERN_ERR PFX "resource 0x%x @ 0x%lx unavailable\n",
2825
                        0x200000, addr + PCI_IO_OFFSET);
2826
                goto err_out;
2827
        }
2828
 
2829
        boards[board_idx].re_map_port = ioremap(addr + PCI_IO_OFFSET, 0x200000);
2830
        if (!boards[board_idx].re_map_port) {
2831
                printk (KERN_ERR PFX "cannot map 0x%x @ 0x%lx\n",
2832
                        0x200000, addr + PCI_IO_OFFSET);
2833
                goto err_out_free_pciio;
2834
        }
2835
 
2836
        if (!request_mem_region (addr, 0x200000, "epca")) {
2837
                printk (KERN_ERR PFX "resource 0x%x @ 0x%lx unavailable\n",
2838
                        0x200000, addr);
2839
                goto err_out_free_iounmap;
2840
        }
2841
 
2842
        boards[board_idx].re_map_membase = ioremap(addr, 0x200000);
2843
        if (!boards[board_idx].re_map_membase) {
2844
                printk (KERN_ERR PFX "cannot map 0x%x @ 0x%lx\n",
2845
                        0x200000, addr + PCI_IO_OFFSET);
2846
                goto err_out_free_memregion;
2847
        }
2848
 
2849
        /*
2850
         * I don't know what the below does, but the hardware guys say its
2851
         * required on everything except PLX (In this case XRJ).
2852
         */
2853
        if (info_idx != brd_xrj) {
2854
                pci_write_config_byte(pdev, 0x40, 0);
2855
                pci_write_config_byte(pdev, 0x46, 0);
2856
        }
2857
 
2858
        return 0;
2859
 
2860
err_out_free_memregion:
2861
        release_mem_region (addr, 0x200000);
2862
err_out_free_iounmap:
2863
        iounmap (boards[board_idx].re_map_port);
2864
err_out_free_pciio:
2865
        release_mem_region (addr + PCI_IO_OFFSET, 0x200000);
2866
err_out:
2867
        return -ENODEV;
2868
}
2869
 
2870
 
2871
static struct pci_device_id epca_pci_tbl[] = {
2872
        { PCI_VENDOR_DIGI, PCI_DEVICE_XR, PCI_ANY_ID, PCI_ANY_ID, 0, 0, brd_xr },
2873
        { PCI_VENDOR_DIGI, PCI_DEVICE_XEM, PCI_ANY_ID, PCI_ANY_ID, 0, 0, brd_xem },
2874
        { PCI_VENDOR_DIGI, PCI_DEVICE_CX, PCI_ANY_ID, PCI_ANY_ID, 0, 0, brd_cx },
2875
        { PCI_VENDOR_DIGI, PCI_DEVICE_XRJ, PCI_ANY_ID, PCI_ANY_ID, 0, 0, brd_xrj },
2876
        { 0, }
2877
};
2878
 
2879
MODULE_DEVICE_TABLE(pci, epca_pci_tbl);
2880
 
2881
int __init init_PCI (void)
2882
{
2883
        memset (&epca_driver, 0, sizeof (epca_driver));
2884
        epca_driver.name = "epca";
2885
        epca_driver.id_table = epca_pci_tbl;
2886
        epca_driver.probe = epca_init_one;
2887
 
2888
        return pci_register_driver(&epca_driver);
2889
}
2890
 
2891
MODULE_LICENSE("GPL");

powered by: WebSVN 2.1.0

© copyright 1999-2025 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.