1#undef BLOCKMOVE
2#define Z_WAKE
3#undef Z_EXT_CHARS_IN_BUFFER
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22#define CY_VERSION "2.6"
23
24
25
26
27
28#define NR_CARDS 4
29
30
31
32
33
34
35#define NR_PORTS 256
36
37#define ZO_V1 0
38#define ZO_V2 1
39#define ZE_V1 2
40
41#define SERIAL_PARANOIA_CHECK
42#undef CY_DEBUG_OPEN
43#undef CY_DEBUG_THROTTLE
44#undef CY_DEBUG_OTHER
45#undef CY_DEBUG_IO
46#undef CY_DEBUG_COUNT
47#undef CY_DEBUG_DTR
48#undef CY_DEBUG_WAIT_UNTIL_SENT
49#undef CY_DEBUG_INTERRUPTS
50#undef CY_16Y_HACK
51#undef CY_ENABLE_MONITORING
52#undef CY_PCI_DEBUG
53
54
55
56
57#include <linux/module.h>
58#include <linux/errno.h>
59#include <linux/signal.h>
60#include <linux/sched.h>
61#include <linux/timer.h>
62#include <linux/interrupt.h>
63#include <linux/tty.h>
64#include <linux/tty_flip.h>
65#include <linux/serial.h>
66#include <linux/major.h>
67#include <linux/string.h>
68#include <linux/fcntl.h>
69#include <linux/ptrace.h>
70#include <linux/cyclades.h>
71#include <linux/mm.h>
72#include <linux/ioport.h>
73#include <linux/init.h>
74#include <linux/delay.h>
75#include <linux/spinlock.h>
76#include <linux/bitops.h>
77#include <linux/firmware.h>
78#include <linux/device.h>
79#include <linux/slab.h>
80
81#include <linux/io.h>
82#include <linux/uaccess.h>
83
84#include <linux/kernel.h>
85#include <linux/pci.h>
86
87#include <linux/stat.h>
88#include <linux/proc_fs.h>
89#include <linux/seq_file.h>
90
91static void cy_send_xchar(struct tty_struct *tty, char ch);
92
93#ifndef SERIAL_XMIT_SIZE
94#define SERIAL_XMIT_SIZE (min(PAGE_SIZE, 4096))
95#endif
96
97#define STD_COM_FLAGS (0)
98
99
100#define ZL_MAX_BLOCKS 16
101#define DRIVER_VERSION 0x02010203
102#define RAM_SIZE 0x80000
103
104enum zblock_type {
105 ZBLOCK_PRG = 0,
106 ZBLOCK_FPGA = 1
107};
108
109struct zfile_header {
110 char name[64];
111 char date[32];
112 char aux[32];
113 u32 n_config;
114 u32 config_offset;
115 u32 n_blocks;
116 u32 block_offset;
117 u32 reserved[9];
118} __attribute__ ((packed));
119
120struct zfile_config {
121 char name[64];
122 u32 mailbox;
123 u32 function;
124 u32 n_blocks;
125 u32 block_list[ZL_MAX_BLOCKS];
126} __attribute__ ((packed));
127
128struct zfile_block {
129 u32 type;
130 u32 file_offset;
131 u32 ram_offset;
132 u32 size;
133} __attribute__ ((packed));
134
135static struct tty_driver *cy_serial_driver;
136
137#ifdef CONFIG_ISA
138
139
140
141
142
143
144
145static unsigned int cy_isa_addresses[] = {
146 0xD0000,
147 0xD2000,
148 0xD4000,
149 0xD6000,
150 0xD8000,
151 0xDA000,
152 0xDC000,
153 0xDE000,
154 0, 0, 0, 0, 0, 0, 0, 0
155};
156
157#define NR_ISA_ADDRS ARRAY_SIZE(cy_isa_addresses)
158
159static long maddr[NR_CARDS];
160static int irq[NR_CARDS];
161
162module_param_array(maddr, long, NULL, 0);
163module_param_array(irq, int, NULL, 0);
164
165#endif
166
167
168
169
170static struct cyclades_card cy_card[NR_CARDS];
171
172static int cy_next_channel;
173
174
175
176
177
178
179
180
181
182
183static const int baud_table[] = {
184 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
185 1800, 2400, 4800, 9600, 19200, 38400, 57600, 76800, 115200, 150000,
186 230400, 0
187};
188
189static const char baud_co_25[] = {
190
191
192 0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x02,
193 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
194};
195
196static const char baud_bpr_25[] = {
197 0x00, 0xf5, 0xa3, 0x6f, 0x5c, 0x51, 0xf5, 0xa3, 0x51, 0xa3,
198 0x6d, 0x51, 0xa3, 0x51, 0xa3, 0x51, 0x36, 0x29, 0x1b, 0x15
199};
200
201static const char baud_co_60[] = {
202
203
204 0x00, 0x00, 0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03,
205 0x03, 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
206 0x00
207};
208
209static const char baud_bpr_60[] = {
210 0x00, 0x82, 0x21, 0xff, 0xdb, 0xc3, 0x92, 0x62, 0xc3, 0x62,
211 0x41, 0xc3, 0x62, 0xc3, 0x62, 0xc3, 0x82, 0x62, 0x41, 0x32,
212 0x21
213};
214
215static const char baud_cor3[] = {
216 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
217 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x07,
218 0x07
219};
220
221
222
223
224
225
226
227
228
229
230
231
232static const char rflow_thr[] = {
233 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
234 0x00, 0x00, 0x00, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
235 0x0a
236};
237
238
239
240
241static const unsigned int cy_chip_offset[] = { 0x0000,
242 0x0400,
243 0x0800,
244 0x0C00,
245 0x0200,
246 0x0600,
247 0x0A00,
248 0x0E00
249};
250
251
252
253#ifdef CONFIG_PCI
254static const struct pci_device_id cy_pci_dev_id[] = {
255
256 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Y_Lo) },
257
258 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Y_Hi) },
259
260 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_4Y_Lo) },
261
262 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_4Y_Hi) },
263
264 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_8Y_Lo) },
265
266 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_8Y_Hi) },
267
268 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Z_Lo) },
269
270 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Z_Hi) },
271 { }
272};
273MODULE_DEVICE_TABLE(pci, cy_pci_dev_id);
274#endif
275
276static void cy_start(struct tty_struct *);
277static void cy_set_line_char(struct cyclades_port *, struct tty_struct *);
278static int cyz_issue_cmd(struct cyclades_card *, __u32, __u8, __u32);
279#ifdef CONFIG_ISA
280static unsigned detect_isa_irq(void __iomem *);
281#endif
282
283#ifndef CONFIG_CYZ_INTR
284static void cyz_poll(unsigned long);
285
286
287static long cyz_polling_cycle = CZ_DEF_POLL;
288
289static DEFINE_TIMER(cyz_timerlist, cyz_poll, 0, 0);
290
291#else
292static void cyz_rx_restart(unsigned long);
293static struct timer_list cyz_rx_full_timer[NR_PORTS];
294#endif
295
296static inline void cyy_writeb(struct cyclades_port *port, u32 reg, u8 val)
297{
298 struct cyclades_card *card = port->card;
299
300 cy_writeb(port->u.cyy.base_addr + (reg << card->bus_index), val);
301}
302
303static inline u8 cyy_readb(struct cyclades_port *port, u32 reg)
304{
305 struct cyclades_card *card = port->card;
306
307 return readb(port->u.cyy.base_addr + (reg << card->bus_index));
308}
309
310static inline bool cy_is_Z(struct cyclades_card *card)
311{
312 return card->num_chips == (unsigned int)-1;
313}
314
315static inline bool __cyz_fpga_loaded(struct RUNTIME_9060 __iomem *ctl_addr)
316{
317 return readl(&ctl_addr->init_ctrl) & (1 << 17);
318}
319
320static inline bool cyz_fpga_loaded(struct cyclades_card *card)
321{
322 return __cyz_fpga_loaded(card->ctl_addr.p9060);
323}
324
325static inline bool cyz_is_loaded(struct cyclades_card *card)
326{
327 struct FIRM_ID __iomem *fw_id = card->base_addr + ID_ADDRESS;
328
329 return (card->hw_ver == ZO_V1 || cyz_fpga_loaded(card)) &&
330 readl(&fw_id->signature) == ZFIRM_ID;
331}
332
333static inline int serial_paranoia_check(struct cyclades_port *info,
334 const char *name, const char *routine)
335{
336#ifdef SERIAL_PARANOIA_CHECK
337 if (!info) {
338 printk(KERN_WARNING "cyc Warning: null cyclades_port for (%s) "
339 "in %s\n", name, routine);
340 return 1;
341 }
342
343 if (info->magic != CYCLADES_MAGIC) {
344 printk(KERN_WARNING "cyc Warning: bad magic number for serial "
345 "struct (%s) in %s\n", name, routine);
346 return 1;
347 }
348#endif
349 return 0;
350}
351
352
353
354
355
356
357
358
359
360
361
362static int __cyy_issue_cmd(void __iomem *base_addr, u8 cmd, int index)
363{
364 void __iomem *ccr = base_addr + (CyCCR << index);
365 unsigned int i;
366
367
368 for (i = 0; i < 100; i++) {
369 if (readb(ccr) == 0)
370 break;
371 udelay(10L);
372 }
373
374
375 if (i == 100)
376 return -1;
377
378
379 cy_writeb(ccr, cmd);
380
381 return 0;
382}
383
384static inline int cyy_issue_cmd(struct cyclades_port *port, u8 cmd)
385{
386 return __cyy_issue_cmd(port->u.cyy.base_addr, cmd,
387 port->card->bus_index);
388}
389
390#ifdef CONFIG_ISA
391
392static unsigned detect_isa_irq(void __iomem *address)
393{
394 int irq;
395 unsigned long irqs, flags;
396 int save_xir, save_car;
397 int index = 0;
398
399
400 irq = probe_irq_off(probe_irq_on());
401
402
403 cy_writeb(address + (Cy_ClrIntr << index), 0);
404
405
406 irqs = probe_irq_on();
407
408 msleep(5);
409
410
411 local_irq_save(flags);
412 cy_writeb(address + (CyCAR << index), 0);
413 __cyy_issue_cmd(address, CyCHAN_CTL | CyENB_XMTR, index);
414
415 cy_writeb(address + (CyCAR << index), 0);
416 cy_writeb(address + (CySRER << index),
417 readb(address + (CySRER << index)) | CyTxRdy);
418 local_irq_restore(flags);
419
420
421 msleep(5);
422
423
424 irq = probe_irq_off(irqs);
425
426
427 save_xir = (u_char) readb(address + (CyTIR << index));
428 save_car = readb(address + (CyCAR << index));
429 cy_writeb(address + (CyCAR << index), (save_xir & 0x3));
430 cy_writeb(address + (CySRER << index),
431 readb(address + (CySRER << index)) & ~CyTxRdy);
432 cy_writeb(address + (CyTIR << index), (save_xir & 0x3f));
433 cy_writeb(address + (CyCAR << index), (save_car));
434 cy_writeb(address + (Cy_ClrIntr << index), 0);
435
436
437 return (irq > 0) ? irq : 0;
438}
439#endif
440
441static void cyy_chip_rx(struct cyclades_card *cinfo, int chip,
442 void __iomem *base_addr)
443{
444 struct cyclades_port *info;
445 struct tty_struct *tty;
446 int len, index = cinfo->bus_index;
447 u8 ivr, save_xir, channel, save_car, data, char_count;
448
449#ifdef CY_DEBUG_INTERRUPTS
450 printk(KERN_DEBUG "cyy_interrupt: rcvd intr, chip %d\n", chip);
451#endif
452
453 save_xir = readb(base_addr + (CyRIR << index));
454 channel = save_xir & CyIRChannel;
455 info = &cinfo->ports[channel + chip * 4];
456 save_car = cyy_readb(info, CyCAR);
457 cyy_writeb(info, CyCAR, save_xir);
458 ivr = cyy_readb(info, CyRIVR) & CyIVRMask;
459
460 tty = tty_port_tty_get(&info->port);
461
462 if (tty == NULL) {
463 if (ivr == CyIVRRxEx) {
464 data = cyy_readb(info, CyRDSR);
465 } else {
466 char_count = cyy_readb(info, CyRDCR);
467 while (char_count--)
468 data = cyy_readb(info, CyRDSR);
469 }
470 goto end;
471 }
472
473 if (ivr == CyIVRRxEx) {
474 data = cyy_readb(info, CyRDSR);
475
476
477 if (data & CyBREAK)
478 info->icount.brk++;
479 else if (data & CyFRAME)
480 info->icount.frame++;
481 else if (data & CyPARITY)
482 info->icount.parity++;
483 else if (data & CyOVERRUN)
484 info->icount.overrun++;
485
486 if (data & info->ignore_status_mask) {
487 info->icount.rx++;
488 tty_kref_put(tty);
489 return;
490 }
491 if (tty_buffer_request_room(tty, 1)) {
492 if (data & info->read_status_mask) {
493 if (data & CyBREAK) {
494 tty_insert_flip_char(tty,
495 cyy_readb(info, CyRDSR),
496 TTY_BREAK);
497 info->icount.rx++;
498 if (info->port.flags & ASYNC_SAK)
499 do_SAK(tty);
500 } else if (data & CyFRAME) {
501 tty_insert_flip_char(tty,
502 cyy_readb(info, CyRDSR),
503 TTY_FRAME);
504 info->icount.rx++;
505 info->idle_stats.frame_errs++;
506 } else if (data & CyPARITY) {
507
508 tty_insert_flip_char(tty,
509 cyy_readb(info, CyRDSR),
510 TTY_PARITY);
511 info->icount.rx++;
512 info->idle_stats.parity_errs++;
513 } else if (data & CyOVERRUN) {
514 tty_insert_flip_char(tty, 0,
515 TTY_OVERRUN);
516 info->icount.rx++;
517
518
519
520
521 tty_insert_flip_char(tty,
522 cyy_readb(info, CyRDSR),
523 TTY_FRAME);
524 info->icount.rx++;
525 info->idle_stats.overruns++;
526
527
528
529
530 } else {
531 tty_insert_flip_char(tty, 0,
532 TTY_NORMAL);
533 info->icount.rx++;
534 }
535 } else {
536 tty_insert_flip_char(tty, 0, TTY_NORMAL);
537 info->icount.rx++;
538 }
539 } else {
540
541
542 info->icount.buf_overrun++;
543 info->idle_stats.overruns++;
544 }
545 } else {
546
547 char_count = cyy_readb(info, CyRDCR);
548
549#ifdef CY_ENABLE_MONITORING
550 ++info->mon.int_count;
551 info->mon.char_count += char_count;
552 if (char_count > info->mon.char_max)
553 info->mon.char_max = char_count;
554 info->mon.char_last = char_count;
555#endif
556 len = tty_buffer_request_room(tty, char_count);
557 while (len--) {
558 data = cyy_readb(info, CyRDSR);
559 tty_insert_flip_char(tty, data, TTY_NORMAL);
560 info->idle_stats.recv_bytes++;
561 info->icount.rx++;
562#ifdef CY_16Y_HACK
563 udelay(10L);
564#endif
565 }
566 info->idle_stats.recv_idle = jiffies;
567 }
568 tty_schedule_flip(tty);
569 tty_kref_put(tty);
570end:
571
572 cyy_writeb(info, CyRIR, save_xir & 0x3f);
573 cyy_writeb(info, CyCAR, save_car);
574}
575
576static void cyy_chip_tx(struct cyclades_card *cinfo, unsigned int chip,
577 void __iomem *base_addr)
578{
579 struct cyclades_port *info;
580 struct tty_struct *tty;
581 int char_count, index = cinfo->bus_index;
582 u8 save_xir, channel, save_car, outch;
583
584
585
586
587#ifdef CY_DEBUG_INTERRUPTS
588 printk(KERN_DEBUG "cyy_interrupt: xmit intr, chip %d\n", chip);
589#endif
590
591
592 save_xir = readb(base_addr + (CyTIR << index));
593 channel = save_xir & CyIRChannel;
594 save_car = readb(base_addr + (CyCAR << index));
595 cy_writeb(base_addr + (CyCAR << index), save_xir);
596
597 info = &cinfo->ports[channel + chip * 4];
598 tty = tty_port_tty_get(&info->port);
599 if (tty == NULL) {
600 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyTxRdy);
601 goto end;
602 }
603
604
605 char_count = info->xmit_fifo_size;
606
607 if (info->x_char) {
608 outch = info->x_char;
609 cyy_writeb(info, CyTDR, outch);
610 char_count--;
611 info->icount.tx++;
612 info->x_char = 0;
613 }
614
615 if (info->breakon || info->breakoff) {
616 if (info->breakon) {
617 cyy_writeb(info, CyTDR, 0);
618 cyy_writeb(info, CyTDR, 0x81);
619 info->breakon = 0;
620 char_count -= 2;
621 }
622 if (info->breakoff) {
623 cyy_writeb(info, CyTDR, 0);
624 cyy_writeb(info, CyTDR, 0x83);
625 info->breakoff = 0;
626 char_count -= 2;
627 }
628 }
629
630 while (char_count-- > 0) {
631 if (!info->xmit_cnt) {
632 if (cyy_readb(info, CySRER) & CyTxMpty) {
633 cyy_writeb(info, CySRER,
634 cyy_readb(info, CySRER) & ~CyTxMpty);
635 } else {
636 cyy_writeb(info, CySRER, CyTxMpty |
637 (cyy_readb(info, CySRER) & ~CyTxRdy));
638 }
639 goto done;
640 }
641 if (info->port.xmit_buf == NULL) {
642 cyy_writeb(info, CySRER,
643 cyy_readb(info, CySRER) & ~CyTxRdy);
644 goto done;
645 }
646 if (tty->stopped || tty->hw_stopped) {
647 cyy_writeb(info, CySRER,
648 cyy_readb(info, CySRER) & ~CyTxRdy);
649 goto done;
650 }
651
652
653
654
655
656
657
658
659
660 outch = info->port.xmit_buf[info->xmit_tail];
661 if (outch) {
662 info->xmit_cnt--;
663 info->xmit_tail = (info->xmit_tail + 1) &
664 (SERIAL_XMIT_SIZE - 1);
665 cyy_writeb(info, CyTDR, outch);
666 info->icount.tx++;
667 } else {
668 if (char_count > 1) {
669 info->xmit_cnt--;
670 info->xmit_tail = (info->xmit_tail + 1) &
671 (SERIAL_XMIT_SIZE - 1);
672 cyy_writeb(info, CyTDR, outch);
673 cyy_writeb(info, CyTDR, 0);
674 info->icount.tx++;
675 char_count--;
676 }
677 }
678 }
679
680done:
681 tty_wakeup(tty);
682 tty_kref_put(tty);
683end:
684
685 cyy_writeb(info, CyTIR, save_xir & 0x3f);
686 cyy_writeb(info, CyCAR, save_car);
687}
688
689static void cyy_chip_modem(struct cyclades_card *cinfo, int chip,
690 void __iomem *base_addr)
691{
692 struct cyclades_port *info;
693 struct tty_struct *tty;
694 int index = cinfo->bus_index;
695 u8 save_xir, channel, save_car, mdm_change, mdm_status;
696
697
698 save_xir = readb(base_addr + (CyMIR << index));
699 channel = save_xir & CyIRChannel;
700 info = &cinfo->ports[channel + chip * 4];
701 save_car = cyy_readb(info, CyCAR);
702 cyy_writeb(info, CyCAR, save_xir);
703
704 mdm_change = cyy_readb(info, CyMISR);
705 mdm_status = cyy_readb(info, CyMSVR1);
706
707 tty = tty_port_tty_get(&info->port);
708 if (!tty)
709 goto end;
710
711 if (mdm_change & CyANY_DELTA) {
712
713 if (mdm_change & CyDCD)
714 info->icount.dcd++;
715 if (mdm_change & CyCTS)
716 info->icount.cts++;
717 if (mdm_change & CyDSR)
718 info->icount.dsr++;
719 if (mdm_change & CyRI)
720 info->icount.rng++;
721
722 wake_up_interruptible(&info->port.delta_msr_wait);
723 }
724
725 if ((mdm_change & CyDCD) && (info->port.flags & ASYNC_CHECK_CD)) {
726 if (mdm_status & CyDCD)
727 wake_up_interruptible(&info->port.open_wait);
728 else
729 tty_hangup(tty);
730 }
731 if ((mdm_change & CyCTS) && (info->port.flags & ASYNC_CTS_FLOW)) {
732 if (tty->hw_stopped) {
733 if (mdm_status & CyCTS) {
734
735
736 tty->hw_stopped = 0;
737 cyy_writeb(info, CySRER,
738 cyy_readb(info, CySRER) | CyTxRdy);
739 tty_wakeup(tty);
740 }
741 } else {
742 if (!(mdm_status & CyCTS)) {
743
744
745 tty->hw_stopped = 1;
746 cyy_writeb(info, CySRER,
747 cyy_readb(info, CySRER) & ~CyTxRdy);
748 }
749 }
750 }
751
752
753
754
755 tty_kref_put(tty);
756end:
757
758 cyy_writeb(info, CyMIR, save_xir & 0x3f);
759 cyy_writeb(info, CyCAR, save_car);
760}
761
762
763
764
765
766static irqreturn_t cyy_interrupt(int irq, void *dev_id)
767{
768 int status;
769 struct cyclades_card *cinfo = dev_id;
770 void __iomem *base_addr, *card_base_addr;
771 unsigned int chip, too_many, had_work;
772 int index;
773
774 if (unlikely(cinfo == NULL)) {
775#ifdef CY_DEBUG_INTERRUPTS
776 printk(KERN_DEBUG "cyy_interrupt: spurious interrupt %d\n",
777 irq);
778#endif
779 return IRQ_NONE;
780 }
781
782 card_base_addr = cinfo->base_addr;
783 index = cinfo->bus_index;
784
785
786 if (unlikely(card_base_addr == NULL))
787 return IRQ_HANDLED;
788
789
790
791
792
793
794 do {
795 had_work = 0;
796 for (chip = 0; chip < cinfo->num_chips; chip++) {
797 base_addr = cinfo->base_addr +
798 (cy_chip_offset[chip] << index);
799 too_many = 0;
800 while ((status = readb(base_addr +
801 (CySVRR << index))) != 0x00) {
802 had_work++;
803
804
805
806
807
808 if (1000 < too_many++)
809 break;
810 spin_lock(&cinfo->card_lock);
811 if (status & CySRReceive)
812 cyy_chip_rx(cinfo, chip, base_addr);
813 if (status & CySRTransmit)
814 cyy_chip_tx(cinfo, chip, base_addr);
815 if (status & CySRModem)
816 cyy_chip_modem(cinfo, chip, base_addr);
817 spin_unlock(&cinfo->card_lock);
818 }
819 }
820 } while (had_work);
821
822
823 spin_lock(&cinfo->card_lock);
824 cy_writeb(card_base_addr + (Cy_ClrIntr << index), 0);
825
826 spin_unlock(&cinfo->card_lock);
827 return IRQ_HANDLED;
828}
829
830static void cyy_change_rts_dtr(struct cyclades_port *info, unsigned int set,
831 unsigned int clear)
832{
833 struct cyclades_card *card = info->card;
834 int channel = info->line - card->first_line;
835 u32 rts, dtr, msvrr, msvrd;
836
837 channel &= 0x03;
838
839 if (info->rtsdtr_inv) {
840 msvrr = CyMSVR2;
841 msvrd = CyMSVR1;
842 rts = CyDTR;
843 dtr = CyRTS;
844 } else {
845 msvrr = CyMSVR1;
846 msvrd = CyMSVR2;
847 rts = CyRTS;
848 dtr = CyDTR;
849 }
850 if (set & TIOCM_RTS) {
851 cyy_writeb(info, CyCAR, channel);
852 cyy_writeb(info, msvrr, rts);
853 }
854 if (clear & TIOCM_RTS) {
855 cyy_writeb(info, CyCAR, channel);
856 cyy_writeb(info, msvrr, ~rts);
857 }
858 if (set & TIOCM_DTR) {
859 cyy_writeb(info, CyCAR, channel);
860 cyy_writeb(info, msvrd, dtr);
861#ifdef CY_DEBUG_DTR
862 printk(KERN_DEBUG "cyc:set_modem_info raising DTR\n");
863 printk(KERN_DEBUG " status: 0x%x, 0x%x\n",
864 cyy_readb(info, CyMSVR1),
865 cyy_readb(info, CyMSVR2));
866#endif
867 }
868 if (clear & TIOCM_DTR) {
869 cyy_writeb(info, CyCAR, channel);
870 cyy_writeb(info, msvrd, ~dtr);
871#ifdef CY_DEBUG_DTR
872 printk(KERN_DEBUG "cyc:set_modem_info dropping DTR\n");
873 printk(KERN_DEBUG " status: 0x%x, 0x%x\n",
874 cyy_readb(info, CyMSVR1),
875 cyy_readb(info, CyMSVR2));
876#endif
877 }
878}
879
880
881
882
883
884
885static int
886cyz_fetch_msg(struct cyclades_card *cinfo,
887 __u32 *channel, __u8 *cmd, __u32 *param)
888{
889 struct BOARD_CTRL __iomem *board_ctrl = cinfo->board_ctrl;
890 unsigned long loc_doorbell;
891
892 loc_doorbell = readl(&cinfo->ctl_addr.p9060->loc_doorbell);
893 if (loc_doorbell) {
894 *cmd = (char)(0xff & loc_doorbell);
895 *channel = readl(&board_ctrl->fwcmd_channel);
896 *param = (__u32) readl(&board_ctrl->fwcmd_param);
897 cy_writel(&cinfo->ctl_addr.p9060->loc_doorbell, 0xffffffff);
898 return 1;
899 }
900 return 0;
901}
902
903static int
904cyz_issue_cmd(struct cyclades_card *cinfo,
905 __u32 channel, __u8 cmd, __u32 param)
906{
907 struct BOARD_CTRL __iomem *board_ctrl = cinfo->board_ctrl;
908 __u32 __iomem *pci_doorbell;
909 unsigned int index;
910
911 if (!cyz_is_loaded(cinfo))
912 return -1;
913
914 index = 0;
915 pci_doorbell = &cinfo->ctl_addr.p9060->pci_doorbell;
916 while ((readl(pci_doorbell) & 0xff) != 0) {
917 if (index++ == 1000)
918 return (int)(readl(pci_doorbell) & 0xff);
919 udelay(50L);
920 }
921 cy_writel(&board_ctrl->hcmd_channel, channel);
922 cy_writel(&board_ctrl->hcmd_param, param);
923 cy_writel(pci_doorbell, (long)cmd);
924
925 return 0;
926}
927
928static void cyz_handle_rx(struct cyclades_port *info, struct tty_struct *tty)
929{
930 struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
931 struct cyclades_card *cinfo = info->card;
932 unsigned int char_count;
933 int len;
934#ifdef BLOCKMOVE
935 unsigned char *buf;
936#else
937 char data;
938#endif
939 __u32 rx_put, rx_get, new_rx_get, rx_bufsize, rx_bufaddr;
940
941 rx_get = new_rx_get = readl(&buf_ctrl->rx_get);
942 rx_put = readl(&buf_ctrl->rx_put);
943 rx_bufsize = readl(&buf_ctrl->rx_bufsize);
944 rx_bufaddr = readl(&buf_ctrl->rx_bufaddr);
945 if (rx_put >= rx_get)
946 char_count = rx_put - rx_get;
947 else
948 char_count = rx_put - rx_get + rx_bufsize;
949
950 if (char_count) {
951#ifdef CY_ENABLE_MONITORING
952 info->mon.int_count++;
953 info->mon.char_count += char_count;
954 if (char_count > info->mon.char_max)
955 info->mon.char_max = char_count;
956 info->mon.char_last = char_count;
957#endif
958 if (tty == NULL) {
959
960 new_rx_get = (new_rx_get + char_count) &
961 (rx_bufsize - 1);
962 info->rflush_count++;
963 } else {
964#ifdef BLOCKMOVE
965
966
967
968 while (1) {
969 len = tty_prepare_flip_string(tty, &buf,
970 char_count);
971 if (!len)
972 break;
973
974 len = min_t(unsigned int, min(len, char_count),
975 rx_bufsize - new_rx_get);
976
977 memcpy_fromio(buf, cinfo->base_addr +
978 rx_bufaddr + new_rx_get, len);
979
980 new_rx_get = (new_rx_get + len) &
981 (rx_bufsize - 1);
982 char_count -= len;
983 info->icount.rx += len;
984 info->idle_stats.recv_bytes += len;
985 }
986#else
987 len = tty_buffer_request_room(tty, char_count);
988 while (len--) {
989 data = readb(cinfo->base_addr + rx_bufaddr +
990 new_rx_get);
991 new_rx_get = (new_rx_get + 1) &
992 (rx_bufsize - 1);
993 tty_insert_flip_char(tty, data, TTY_NORMAL);
994 info->idle_stats.recv_bytes++;
995 info->icount.rx++;
996 }
997#endif
998#ifdef CONFIG_CYZ_INTR
999
1000
1001 rx_put = readl(&buf_ctrl->rx_put);
1002 if (rx_put >= rx_get)
1003 char_count = rx_put - rx_get;
1004 else
1005 char_count = rx_put - rx_get + rx_bufsize;
1006 if (char_count >= readl(&buf_ctrl->rx_threshold) &&
1007 !timer_pending(&cyz_rx_full_timer[
1008 info->line]))
1009 mod_timer(&cyz_rx_full_timer[info->line],
1010 jiffies + 1);
1011#endif
1012 info->idle_stats.recv_idle = jiffies;
1013 tty_schedule_flip(tty);
1014 }
1015
1016 cy_writel(&buf_ctrl->rx_get, new_rx_get);
1017 }
1018}
1019
1020static void cyz_handle_tx(struct cyclades_port *info, struct tty_struct *tty)
1021{
1022 struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
1023 struct cyclades_card *cinfo = info->card;
1024 u8 data;
1025 unsigned int char_count;
1026#ifdef BLOCKMOVE
1027 int small_count;
1028#endif
1029 __u32 tx_put, tx_get, tx_bufsize, tx_bufaddr;
1030
1031 if (info->xmit_cnt <= 0)
1032 return;
1033
1034 tx_get = readl(&buf_ctrl->tx_get);
1035 tx_put = readl(&buf_ctrl->tx_put);
1036 tx_bufsize = readl(&buf_ctrl->tx_bufsize);
1037 tx_bufaddr = readl(&buf_ctrl->tx_bufaddr);
1038 if (tx_put >= tx_get)
1039 char_count = tx_get - tx_put - 1 + tx_bufsize;
1040 else
1041 char_count = tx_get - tx_put - 1;
1042
1043 if (char_count) {
1044
1045 if (tty == NULL)
1046 goto ztxdone;
1047
1048 if (info->x_char) {
1049 data = info->x_char;
1050
1051 cy_writeb(cinfo->base_addr + tx_bufaddr + tx_put, data);
1052 tx_put = (tx_put + 1) & (tx_bufsize - 1);
1053 info->x_char = 0;
1054 char_count--;
1055 info->icount.tx++;
1056 }
1057#ifdef BLOCKMOVE
1058 while (0 < (small_count = min_t(unsigned int,
1059 tx_bufsize - tx_put, min_t(unsigned int,
1060 (SERIAL_XMIT_SIZE - info->xmit_tail),
1061 min_t(unsigned int, info->xmit_cnt,
1062 char_count))))) {
1063
1064 memcpy_toio((char *)(cinfo->base_addr + tx_bufaddr +
1065 tx_put),
1066 &info->port.xmit_buf[info->xmit_tail],
1067 small_count);
1068
1069 tx_put = (tx_put + small_count) & (tx_bufsize - 1);
1070 char_count -= small_count;
1071 info->icount.tx += small_count;
1072 info->xmit_cnt -= small_count;
1073 info->xmit_tail = (info->xmit_tail + small_count) &
1074 (SERIAL_XMIT_SIZE - 1);
1075 }
1076#else
1077 while (info->xmit_cnt && char_count) {
1078 data = info->port.xmit_buf[info->xmit_tail];
1079 info->xmit_cnt--;
1080 info->xmit_tail = (info->xmit_tail + 1) &
1081 (SERIAL_XMIT_SIZE - 1);
1082
1083 cy_writeb(cinfo->base_addr + tx_bufaddr + tx_put, data);
1084 tx_put = (tx_put + 1) & (tx_bufsize - 1);
1085 char_count--;
1086 info->icount.tx++;
1087 }
1088#endif
1089 tty_wakeup(tty);
1090ztxdone:
1091
1092 cy_writel(&buf_ctrl->tx_put, tx_put);
1093 }
1094}
1095
1096static void cyz_handle_cmd(struct cyclades_card *cinfo)
1097{
1098 struct BOARD_CTRL __iomem *board_ctrl = cinfo->board_ctrl;
1099 struct tty_struct *tty;
1100 struct cyclades_port *info;
1101 __u32 channel, param, fw_ver;
1102 __u8 cmd;
1103 int special_count;
1104 int delta_count;
1105
1106 fw_ver = readl(&board_ctrl->fw_version);
1107
1108 while (cyz_fetch_msg(cinfo, &channel, &cmd, ¶m) == 1) {
1109 special_count = 0;
1110 delta_count = 0;
1111 info = &cinfo->ports[channel];
1112 tty = tty_port_tty_get(&info->port);
1113 if (tty == NULL)
1114 continue;
1115
1116 switch (cmd) {
1117 case C_CM_PR_ERROR:
1118 tty_insert_flip_char(tty, 0, TTY_PARITY);
1119 info->icount.rx++;
1120 special_count++;
1121 break;
1122 case C_CM_FR_ERROR:
1123 tty_insert_flip_char(tty, 0, TTY_FRAME);
1124 info->icount.rx++;
1125 special_count++;
1126 break;
1127 case C_CM_RXBRK:
1128 tty_insert_flip_char(tty, 0, TTY_BREAK);
1129 info->icount.rx++;
1130 special_count++;
1131 break;
1132 case C_CM_MDCD:
1133 info->icount.dcd++;
1134 delta_count++;
1135 if (info->port.flags & ASYNC_CHECK_CD) {
1136 u32 dcd = fw_ver > 241 ? param :
1137 readl(&info->u.cyz.ch_ctrl->rs_status);
1138 if (dcd & C_RS_DCD)
1139 wake_up_interruptible(&info->port.open_wait);
1140 else
1141 tty_hangup(tty);
1142 }
1143 break;
1144 case C_CM_MCTS:
1145 info->icount.cts++;
1146 delta_count++;
1147 break;
1148 case C_CM_MRI:
1149 info->icount.rng++;
1150 delta_count++;
1151 break;
1152 case C_CM_MDSR:
1153 info->icount.dsr++;
1154 delta_count++;
1155 break;
1156#ifdef Z_WAKE
1157 case C_CM_IOCTLW:
1158 complete(&info->shutdown_wait);
1159 break;
1160#endif
1161#ifdef CONFIG_CYZ_INTR
1162 case C_CM_RXHIWM:
1163 case C_CM_RXNNDT:
1164 case C_CM_INTBACK2:
1165
1166#ifdef CY_DEBUG_INTERRUPTS
1167 printk(KERN_DEBUG "cyz_interrupt: rcvd intr, card %d, "
1168 "port %ld\n", info->card, channel);
1169#endif
1170 cyz_handle_rx(info, tty);
1171 break;
1172 case C_CM_TXBEMPTY:
1173 case C_CM_TXLOWWM:
1174 case C_CM_INTBACK:
1175
1176#ifdef CY_DEBUG_INTERRUPTS
1177 printk(KERN_DEBUG "cyz_interrupt: xmit intr, card %d, "
1178 "port %ld\n", info->card, channel);
1179#endif
1180 cyz_handle_tx(info, tty);
1181 break;
1182#endif
1183 case C_CM_FATAL:
1184
1185 break;
1186 default:
1187 break;
1188 }
1189 if (delta_count)
1190 wake_up_interruptible(&info->port.delta_msr_wait);
1191 if (special_count)
1192 tty_schedule_flip(tty);
1193 tty_kref_put(tty);
1194 }
1195}
1196
1197#ifdef CONFIG_CYZ_INTR
1198static irqreturn_t cyz_interrupt(int irq, void *dev_id)
1199{
1200 struct cyclades_card *cinfo = dev_id;
1201
1202 if (unlikely(!cyz_is_loaded(cinfo))) {
1203#ifdef CY_DEBUG_INTERRUPTS
1204 printk(KERN_DEBUG "cyz_interrupt: board not yet loaded "
1205 "(IRQ%d).\n", irq);
1206#endif
1207 return IRQ_NONE;
1208 }
1209
1210
1211 cyz_handle_cmd(cinfo);
1212
1213 return IRQ_HANDLED;
1214}
1215
1216static void cyz_rx_restart(unsigned long arg)
1217{
1218 struct cyclades_port *info = (struct cyclades_port *)arg;
1219 struct cyclades_card *card = info->card;
1220 int retval;
1221 __u32 channel = info->line - card->first_line;
1222 unsigned long flags;
1223
1224 spin_lock_irqsave(&card->card_lock, flags);
1225 retval = cyz_issue_cmd(card, channel, C_CM_INTBACK2, 0L);
1226 if (retval != 0) {
1227 printk(KERN_ERR "cyc:cyz_rx_restart retval on ttyC%d was %x\n",
1228 info->line, retval);
1229 }
1230 spin_unlock_irqrestore(&card->card_lock, flags);
1231}
1232
1233#else
1234
1235static void cyz_poll(unsigned long arg)
1236{
1237 struct cyclades_card *cinfo;
1238 struct cyclades_port *info;
1239 unsigned long expires = jiffies + HZ;
1240 unsigned int port, card;
1241
1242 for (card = 0; card < NR_CARDS; card++) {
1243 cinfo = &cy_card[card];
1244
1245 if (!cy_is_Z(cinfo))
1246 continue;
1247 if (!cyz_is_loaded(cinfo))
1248 continue;
1249
1250
1251 if (!cinfo->intr_enabled) {
1252 cinfo->intr_enabled = 1;
1253 continue;
1254 }
1255
1256 cyz_handle_cmd(cinfo);
1257
1258 for (port = 0; port < cinfo->nports; port++) {
1259 struct tty_struct *tty;
1260
1261 info = &cinfo->ports[port];
1262 tty = tty_port_tty_get(&info->port);
1263
1264
1265
1266 if (!info->throttle)
1267 cyz_handle_rx(info, tty);
1268 cyz_handle_tx(info, tty);
1269 tty_kref_put(tty);
1270 }
1271
1272 expires = jiffies + cyz_polling_cycle;
1273 }
1274 mod_timer(&cyz_timerlist, expires);
1275}
1276
1277#endif
1278
1279
1280
1281
1282
1283
1284
1285static int cy_startup(struct cyclades_port *info, struct tty_struct *tty)
1286{
1287 struct cyclades_card *card;
1288 unsigned long flags;
1289 int retval = 0;
1290 int channel;
1291 unsigned long page;
1292
1293 card = info->card;
1294 channel = info->line - card->first_line;
1295
1296 page = get_zeroed_page(GFP_KERNEL);
1297 if (!page)
1298 return -ENOMEM;
1299
1300 spin_lock_irqsave(&card->card_lock, flags);
1301
1302 if (info->port.flags & ASYNC_INITIALIZED)
1303 goto errout;
1304
1305 if (!info->type) {
1306 set_bit(TTY_IO_ERROR, &tty->flags);
1307 goto errout;
1308 }
1309
1310 if (info->port.xmit_buf)
1311 free_page(page);
1312 else
1313 info->port.xmit_buf = (unsigned char *)page;
1314
1315 spin_unlock_irqrestore(&card->card_lock, flags);
1316
1317 cy_set_line_char(info, tty);
1318
1319 if (!cy_is_Z(card)) {
1320 channel &= 0x03;
1321
1322 spin_lock_irqsave(&card->card_lock, flags);
1323
1324 cyy_writeb(info, CyCAR, channel);
1325
1326 cyy_writeb(info, CyRTPR,
1327 (info->default_timeout ? info->default_timeout : 0x02));
1328
1329
1330 cyy_issue_cmd(info, CyCHAN_CTL | CyENB_RCVR | CyENB_XMTR);
1331
1332 cyy_change_rts_dtr(info, TIOCM_RTS | TIOCM_DTR, 0);
1333
1334 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyRxData);
1335 } else {
1336 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
1337
1338 if (!cyz_is_loaded(card))
1339 return -ENODEV;
1340
1341#ifdef CY_DEBUG_OPEN
1342 printk(KERN_DEBUG "cyc startup Z card %d, channel %d, "
1343 "base_addr %p\n", card, channel, card->base_addr);
1344#endif
1345 spin_lock_irqsave(&card->card_lock, flags);
1346
1347 cy_writel(&ch_ctrl->op_mode, C_CH_ENABLE);
1348#ifdef Z_WAKE
1349#ifdef CONFIG_CYZ_INTR
1350 cy_writel(&ch_ctrl->intr_enable,
1351 C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM |
1352 C_IN_RXNNDT | C_IN_IOCTLW | C_IN_MDCD);
1353#else
1354 cy_writel(&ch_ctrl->intr_enable,
1355 C_IN_IOCTLW | C_IN_MDCD);
1356#endif
1357#else
1358#ifdef CONFIG_CYZ_INTR
1359 cy_writel(&ch_ctrl->intr_enable,
1360 C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM |
1361 C_IN_RXNNDT | C_IN_MDCD);
1362#else
1363 cy_writel(&ch_ctrl->intr_enable, C_IN_MDCD);
1364#endif
1365#endif
1366
1367 retval = cyz_issue_cmd(card, channel, C_CM_IOCTL, 0L);
1368 if (retval != 0) {
1369 printk(KERN_ERR "cyc:startup(1) retval on ttyC%d was "
1370 "%x\n", info->line, retval);
1371 }
1372
1373
1374 retval = cyz_issue_cmd(card, channel, C_CM_FLUSH_RX, 0L);
1375 if (retval != 0) {
1376 printk(KERN_ERR "cyc:startup(2) retval on ttyC%d was "
1377 "%x\n", info->line, retval);
1378 }
1379
1380
1381
1382 tty_port_raise_dtr_rts(&info->port);
1383
1384
1385 }
1386
1387 info->port.flags |= ASYNC_INITIALIZED;
1388
1389 clear_bit(TTY_IO_ERROR, &tty->flags);
1390 info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1391 info->breakon = info->breakoff = 0;
1392 memset((char *)&info->idle_stats, 0, sizeof(info->idle_stats));
1393 info->idle_stats.in_use =
1394 info->idle_stats.recv_idle =
1395 info->idle_stats.xmit_idle = jiffies;
1396
1397 spin_unlock_irqrestore(&card->card_lock, flags);
1398
1399#ifdef CY_DEBUG_OPEN
1400 printk(KERN_DEBUG "cyc startup done\n");
1401#endif
1402 return 0;
1403
1404errout:
1405 spin_unlock_irqrestore(&card->card_lock, flags);
1406 free_page(page);
1407 return retval;
1408}
1409
1410static void start_xmit(struct cyclades_port *info)
1411{
1412 struct cyclades_card *card = info->card;
1413 unsigned long flags;
1414 int channel = info->line - card->first_line;
1415
1416 if (!cy_is_Z(card)) {
1417 spin_lock_irqsave(&card->card_lock, flags);
1418 cyy_writeb(info, CyCAR, channel & 0x03);
1419 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyTxRdy);
1420 spin_unlock_irqrestore(&card->card_lock, flags);
1421 } else {
1422#ifdef CONFIG_CYZ_INTR
1423 int retval;
1424
1425 spin_lock_irqsave(&card->card_lock, flags);
1426 retval = cyz_issue_cmd(card, channel, C_CM_INTBACK, 0L);
1427 if (retval != 0) {
1428 printk(KERN_ERR "cyc:start_xmit retval on ttyC%d was "
1429 "%x\n", info->line, retval);
1430 }
1431 spin_unlock_irqrestore(&card->card_lock, flags);
1432#else
1433
1434#endif
1435 }
1436}
1437
1438
1439
1440
1441
1442static void cy_shutdown(struct cyclades_port *info, struct tty_struct *tty)
1443{
1444 struct cyclades_card *card;
1445 unsigned long flags;
1446
1447 if (!(info->port.flags & ASYNC_INITIALIZED))
1448 return;
1449
1450 card = info->card;
1451 if (!cy_is_Z(card)) {
1452 spin_lock_irqsave(&card->card_lock, flags);
1453
1454
1455 wake_up_interruptible(&info->port.delta_msr_wait);
1456
1457 if (info->port.xmit_buf) {
1458 unsigned char *temp;
1459 temp = info->port.xmit_buf;
1460 info->port.xmit_buf = NULL;
1461 free_page((unsigned long)temp);
1462 }
1463 if (tty->termios->c_cflag & HUPCL)
1464 cyy_change_rts_dtr(info, 0, TIOCM_RTS | TIOCM_DTR);
1465
1466 cyy_issue_cmd(info, CyCHAN_CTL | CyDIS_RCVR);
1467
1468
1469
1470 set_bit(TTY_IO_ERROR, &tty->flags);
1471 info->port.flags &= ~ASYNC_INITIALIZED;
1472 spin_unlock_irqrestore(&card->card_lock, flags);
1473 } else {
1474#ifdef CY_DEBUG_OPEN
1475 int channel = info->line - card->first_line;
1476 printk(KERN_DEBUG "cyc shutdown Z card %d, channel %d, "
1477 "base_addr %p\n", card, channel, card->base_addr);
1478#endif
1479
1480 if (!cyz_is_loaded(card))
1481 return;
1482
1483 spin_lock_irqsave(&card->card_lock, flags);
1484
1485 if (info->port.xmit_buf) {
1486 unsigned char *temp;
1487 temp = info->port.xmit_buf;
1488 info->port.xmit_buf = NULL;
1489 free_page((unsigned long)temp);
1490 }
1491
1492 if (tty->termios->c_cflag & HUPCL)
1493 tty_port_lower_dtr_rts(&info->port);
1494
1495 set_bit(TTY_IO_ERROR, &tty->flags);
1496 info->port.flags &= ~ASYNC_INITIALIZED;
1497
1498 spin_unlock_irqrestore(&card->card_lock, flags);
1499 }
1500
1501#ifdef CY_DEBUG_OPEN
1502 printk(KERN_DEBUG "cyc shutdown done\n");
1503#endif
1504}
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516static int cy_open(struct tty_struct *tty, struct file *filp)
1517{
1518 struct cyclades_port *info;
1519 unsigned int i, line;
1520 int retval;
1521
1522 line = tty->index;
1523 if (tty->index < 0 || NR_PORTS <= line)
1524 return -ENODEV;
1525
1526 for (i = 0; i < NR_CARDS; i++)
1527 if (line < cy_card[i].first_line + cy_card[i].nports &&
1528 line >= cy_card[i].first_line)
1529 break;
1530 if (i >= NR_CARDS)
1531 return -ENODEV;
1532 info = &cy_card[i].ports[line - cy_card[i].first_line];
1533 if (info->line < 0)
1534 return -ENODEV;
1535
1536
1537
1538
1539
1540 if (cy_is_Z(info->card)) {
1541 struct cyclades_card *cinfo = info->card;
1542 struct FIRM_ID __iomem *firm_id = cinfo->base_addr + ID_ADDRESS;
1543
1544 if (!cyz_is_loaded(cinfo)) {
1545 if (cinfo->hw_ver == ZE_V1 && cyz_fpga_loaded(cinfo) &&
1546 readl(&firm_id->signature) ==
1547 ZFIRM_HLT) {
1548 printk(KERN_ERR "cyc:Cyclades-Z Error: you "
1549 "need an external power supply for "
1550 "this number of ports.\nFirmware "
1551 "halted.\n");
1552 } else {
1553 printk(KERN_ERR "cyc:Cyclades-Z firmware not "
1554 "yet loaded\n");
1555 }
1556 return -ENODEV;
1557 }
1558#ifdef CONFIG_CYZ_INTR
1559 else {
1560
1561
1562
1563 if (!cinfo->intr_enabled) {
1564 u16 intr;
1565
1566
1567 intr = readw(&cinfo->ctl_addr.p9060->
1568 intr_ctrl_stat) | 0x0900;
1569 cy_writew(&cinfo->ctl_addr.p9060->
1570 intr_ctrl_stat, intr);
1571
1572 retval = cyz_issue_cmd(cinfo, 0,
1573 C_CM_IRQ_ENBL, 0L);
1574 if (retval != 0) {
1575 printk(KERN_ERR "cyc:IRQ enable retval "
1576 "was %x\n", retval);
1577 }
1578 cinfo->intr_enabled = 1;
1579 }
1580 }
1581#endif
1582
1583 if (info->line > (cinfo->first_line + cinfo->nports - 1))
1584 return -ENODEV;
1585 }
1586#ifdef CY_DEBUG_OTHER
1587 printk(KERN_DEBUG "cyc:cy_open ttyC%d\n", info->line);
1588#endif
1589 tty->driver_data = info;
1590 if (serial_paranoia_check(info, tty->name, "cy_open"))
1591 return -ENODEV;
1592
1593#ifdef CY_DEBUG_OPEN
1594 printk(KERN_DEBUG "cyc:cy_open ttyC%d, count = %d\n", info->line,
1595 info->port.count);
1596#endif
1597 info->port.count++;
1598#ifdef CY_DEBUG_COUNT
1599 printk(KERN_DEBUG "cyc:cy_open (%d): incrementing count to %d\n",
1600 current->pid, info->port.count);
1601#endif
1602
1603
1604
1605
1606 if (tty_hung_up_p(filp) || (info->port.flags & ASYNC_CLOSING)) {
1607 wait_event_interruptible_tty(info->port.close_wait,
1608 !(info->port.flags & ASYNC_CLOSING));
1609 return (info->port.flags & ASYNC_HUP_NOTIFY) ? -EAGAIN: -ERESTARTSYS;
1610 }
1611
1612
1613
1614
1615 retval = cy_startup(info, tty);
1616 if (retval)
1617 return retval;
1618
1619 retval = tty_port_block_til_ready(&info->port, tty, filp);
1620 if (retval) {
1621#ifdef CY_DEBUG_OPEN
1622 printk(KERN_DEBUG "cyc:cy_open returning after block_til_ready "
1623 "with %d\n", retval);
1624#endif
1625 return retval;
1626 }
1627
1628 info->throttle = 0;
1629 tty_port_tty_set(&info->port, tty);
1630
1631#ifdef CY_DEBUG_OPEN
1632 printk(KERN_DEBUG "cyc:cy_open done\n");
1633#endif
1634 return 0;
1635}
1636
1637
1638
1639
1640static void cy_wait_until_sent(struct tty_struct *tty, int timeout)
1641{
1642 struct cyclades_card *card;
1643 struct cyclades_port *info = tty->driver_data;
1644 unsigned long orig_jiffies;
1645 int char_time;
1646
1647 if (serial_paranoia_check(info, tty->name, "cy_wait_until_sent"))
1648 return;
1649
1650 if (info->xmit_fifo_size == 0)
1651 return;
1652
1653 orig_jiffies = jiffies;
1654
1655
1656
1657
1658
1659
1660
1661
1662 char_time = (info->timeout - HZ / 50) / info->xmit_fifo_size;
1663 char_time = char_time / 5;
1664 if (char_time <= 0)
1665 char_time = 1;
1666 if (timeout < 0)
1667 timeout = 0;
1668 if (timeout)
1669 char_time = min(char_time, timeout);
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679 if (!timeout || timeout > 2 * info->timeout)
1680 timeout = 2 * info->timeout;
1681#ifdef CY_DEBUG_WAIT_UNTIL_SENT
1682 printk(KERN_DEBUG "In cy_wait_until_sent(%d) check=%d, jiff=%lu...",
1683 timeout, char_time, jiffies);
1684#endif
1685 card = info->card;
1686 if (!cy_is_Z(card)) {
1687 while (cyy_readb(info, CySRER) & CyTxRdy) {
1688#ifdef CY_DEBUG_WAIT_UNTIL_SENT
1689 printk(KERN_DEBUG "Not clean (jiff=%lu)...", jiffies);
1690#endif
1691 if (msleep_interruptible(jiffies_to_msecs(char_time)))
1692 break;
1693 if (timeout && time_after(jiffies, orig_jiffies +
1694 timeout))
1695 break;
1696 }
1697 }
1698
1699 msleep_interruptible(jiffies_to_msecs(char_time * 5));
1700#ifdef CY_DEBUG_WAIT_UNTIL_SENT
1701 printk(KERN_DEBUG "Clean (jiff=%lu)...done\n", jiffies);
1702#endif
1703}
1704
1705static void cy_flush_buffer(struct tty_struct *tty)
1706{
1707 struct cyclades_port *info = tty->driver_data;
1708 struct cyclades_card *card;
1709 int channel, retval;
1710 unsigned long flags;
1711
1712#ifdef CY_DEBUG_IO
1713 printk(KERN_DEBUG "cyc:cy_flush_buffer ttyC%d\n", info->line);
1714#endif
1715
1716 if (serial_paranoia_check(info, tty->name, "cy_flush_buffer"))
1717 return;
1718
1719 card = info->card;
1720 channel = info->line - card->first_line;
1721
1722 spin_lock_irqsave(&card->card_lock, flags);
1723 info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1724 spin_unlock_irqrestore(&card->card_lock, flags);
1725
1726 if (cy_is_Z(card)) {
1727
1728 spin_lock_irqsave(&card->card_lock, flags);
1729 retval = cyz_issue_cmd(card, channel, C_CM_FLUSH_TX, 0L);
1730 if (retval != 0) {
1731 printk(KERN_ERR "cyc: flush_buffer retval on ttyC%d "
1732 "was %x\n", info->line, retval);
1733 }
1734 spin_unlock_irqrestore(&card->card_lock, flags);
1735 }
1736 tty_wakeup(tty);
1737}
1738
1739
1740static void cy_do_close(struct tty_port *port)
1741{
1742 struct cyclades_port *info = container_of(port, struct cyclades_port,
1743 port);
1744 struct cyclades_card *card;
1745 unsigned long flags;
1746 int channel;
1747
1748 card = info->card;
1749 channel = info->line - card->first_line;
1750 spin_lock_irqsave(&card->card_lock, flags);
1751
1752 if (!cy_is_Z(card)) {
1753
1754 cyy_writeb(info, CyCAR, channel & 0x03);
1755 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyRxData);
1756 if (info->port.flags & ASYNC_INITIALIZED) {
1757
1758
1759 spin_unlock_irqrestore(&card->card_lock, flags);
1760 cy_wait_until_sent(port->tty, info->timeout);
1761 spin_lock_irqsave(&card->card_lock, flags);
1762 }
1763 } else {
1764#ifdef Z_WAKE
1765
1766
1767 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
1768 int retval;
1769
1770 if (readl(&ch_ctrl->flow_status) != C_FS_TXIDLE) {
1771 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLW, 0L);
1772 if (retval != 0) {
1773 printk(KERN_DEBUG "cyc:cy_close retval on "
1774 "ttyC%d was %x\n", info->line, retval);
1775 }
1776 spin_unlock_irqrestore(&card->card_lock, flags);
1777 wait_for_completion_interruptible(&info->shutdown_wait);
1778 spin_lock_irqsave(&card->card_lock, flags);
1779 }
1780#endif
1781 }
1782 spin_unlock_irqrestore(&card->card_lock, flags);
1783 cy_shutdown(info, port->tty);
1784}
1785
1786
1787
1788
1789static void cy_close(struct tty_struct *tty, struct file *filp)
1790{
1791 struct cyclades_port *info = tty->driver_data;
1792 if (!info || serial_paranoia_check(info, tty->name, "cy_close"))
1793 return;
1794 tty_port_close(&info->port, tty, filp);
1795}
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810static int cy_write(struct tty_struct *tty, const unsigned char *buf, int count)
1811{
1812 struct cyclades_port *info = tty->driver_data;
1813 unsigned long flags;
1814 int c, ret = 0;
1815
1816#ifdef CY_DEBUG_IO
1817 printk(KERN_DEBUG "cyc:cy_write ttyC%d\n", info->line);
1818#endif
1819
1820 if (serial_paranoia_check(info, tty->name, "cy_write"))
1821 return 0;
1822
1823 if (!info->port.xmit_buf)
1824 return 0;
1825
1826 spin_lock_irqsave(&info->card->card_lock, flags);
1827 while (1) {
1828 c = min(count, (int)(SERIAL_XMIT_SIZE - info->xmit_cnt - 1));
1829 c = min(c, (int)(SERIAL_XMIT_SIZE - info->xmit_head));
1830
1831 if (c <= 0)
1832 break;
1833
1834 memcpy(info->port.xmit_buf + info->xmit_head, buf, c);
1835 info->xmit_head = (info->xmit_head + c) &
1836 (SERIAL_XMIT_SIZE - 1);
1837 info->xmit_cnt += c;
1838 buf += c;
1839 count -= c;
1840 ret += c;
1841 }
1842 spin_unlock_irqrestore(&info->card->card_lock, flags);
1843
1844 info->idle_stats.xmit_bytes += ret;
1845 info->idle_stats.xmit_idle = jiffies;
1846
1847 if (info->xmit_cnt && !tty->stopped && !tty->hw_stopped)
1848 start_xmit(info);
1849
1850 return ret;
1851}
1852
1853
1854
1855
1856
1857
1858
1859
1860static int cy_put_char(struct tty_struct *tty, unsigned char ch)
1861{
1862 struct cyclades_port *info = tty->driver_data;
1863 unsigned long flags;
1864
1865#ifdef CY_DEBUG_IO
1866 printk(KERN_DEBUG "cyc:cy_put_char ttyC%d\n", info->line);
1867#endif
1868
1869 if (serial_paranoia_check(info, tty->name, "cy_put_char"))
1870 return 0;
1871
1872 if (!info->port.xmit_buf)
1873 return 0;
1874
1875 spin_lock_irqsave(&info->card->card_lock, flags);
1876 if (info->xmit_cnt >= (int)(SERIAL_XMIT_SIZE - 1)) {
1877 spin_unlock_irqrestore(&info->card->card_lock, flags);
1878 return 0;
1879 }
1880
1881 info->port.xmit_buf[info->xmit_head++] = ch;
1882 info->xmit_head &= SERIAL_XMIT_SIZE - 1;
1883 info->xmit_cnt++;
1884 info->idle_stats.xmit_bytes++;
1885 info->idle_stats.xmit_idle = jiffies;
1886 spin_unlock_irqrestore(&info->card->card_lock, flags);
1887 return 1;
1888}
1889
1890
1891
1892
1893
1894static void cy_flush_chars(struct tty_struct *tty)
1895{
1896 struct cyclades_port *info = tty->driver_data;
1897
1898#ifdef CY_DEBUG_IO
1899 printk(KERN_DEBUG "cyc:cy_flush_chars ttyC%d\n", info->line);
1900#endif
1901
1902 if (serial_paranoia_check(info, tty->name, "cy_flush_chars"))
1903 return;
1904
1905 if (info->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
1906 !info->port.xmit_buf)
1907 return;
1908
1909 start_xmit(info);
1910}
1911
1912
1913
1914
1915
1916
1917
1918static int cy_write_room(struct tty_struct *tty)
1919{
1920 struct cyclades_port *info = tty->driver_data;
1921 int ret;
1922
1923#ifdef CY_DEBUG_IO
1924 printk(KERN_DEBUG "cyc:cy_write_room ttyC%d\n", info->line);
1925#endif
1926
1927 if (serial_paranoia_check(info, tty->name, "cy_write_room"))
1928 return 0;
1929 ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1;
1930 if (ret < 0)
1931 ret = 0;
1932 return ret;
1933}
1934
1935static int cy_chars_in_buffer(struct tty_struct *tty)
1936{
1937 struct cyclades_port *info = tty->driver_data;
1938
1939 if (serial_paranoia_check(info, tty->name, "cy_chars_in_buffer"))
1940 return 0;
1941
1942#ifdef Z_EXT_CHARS_IN_BUFFER
1943 if (!cy_is_Z(info->card)) {
1944#endif
1945#ifdef CY_DEBUG_IO
1946 printk(KERN_DEBUG "cyc:cy_chars_in_buffer ttyC%d %d\n",
1947 info->line, info->xmit_cnt);
1948#endif
1949 return info->xmit_cnt;
1950#ifdef Z_EXT_CHARS_IN_BUFFER
1951 } else {
1952 struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
1953 int char_count;
1954 __u32 tx_put, tx_get, tx_bufsize;
1955
1956 tx_get = readl(&buf_ctrl->tx_get);
1957 tx_put = readl(&buf_ctrl->tx_put);
1958 tx_bufsize = readl(&buf_ctrl->tx_bufsize);
1959 if (tx_put >= tx_get)
1960 char_count = tx_put - tx_get;
1961 else
1962 char_count = tx_put - tx_get + tx_bufsize;
1963#ifdef CY_DEBUG_IO
1964 printk(KERN_DEBUG "cyc:cy_chars_in_buffer ttyC%d %d\n",
1965 info->line, info->xmit_cnt + char_count);
1966#endif
1967 return info->xmit_cnt + char_count;
1968 }
1969#endif
1970}
1971
1972
1973
1974
1975
1976
1977
1978static void cyy_baud_calc(struct cyclades_port *info, __u32 baud)
1979{
1980 int co, co_val, bpr;
1981 __u32 cy_clock = ((info->chip_rev >= CD1400_REV_J) ? 60000000 :
1982 25000000);
1983
1984 if (baud == 0) {
1985 info->tbpr = info->tco = info->rbpr = info->rco = 0;
1986 return;
1987 }
1988
1989
1990 for (co = 4, co_val = 2048; co; co--, co_val >>= 2) {
1991 if (cy_clock / co_val / baud > 63)
1992 break;
1993 }
1994
1995 bpr = (cy_clock / co_val * 2 / baud + 1) / 2;
1996 if (bpr > 255)
1997 bpr = 255;
1998
1999 info->tbpr = info->rbpr = bpr;
2000 info->tco = info->rco = co;
2001}
2002
2003
2004
2005
2006
2007static void cy_set_line_char(struct cyclades_port *info, struct tty_struct *tty)
2008{
2009 struct cyclades_card *card;
2010 unsigned long flags;
2011 int channel;
2012 unsigned cflag, iflag;
2013 int baud, baud_rate = 0;
2014 int i;
2015
2016 if (!tty->termios)
2017 return;
2018
2019 if (info->line == -1)
2020 return;
2021
2022 cflag = tty->termios->c_cflag;
2023 iflag = tty->termios->c_iflag;
2024
2025
2026
2027
2028 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
2029 tty->alt_speed = 57600;
2030 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
2031 tty->alt_speed = 115200;
2032 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
2033 tty->alt_speed = 230400;
2034 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
2035 tty->alt_speed = 460800;
2036
2037 card = info->card;
2038 channel = info->line - card->first_line;
2039
2040 if (!cy_is_Z(card)) {
2041 u32 cflags;
2042
2043
2044 baud = tty_get_baud_rate(tty);
2045 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2046 ASYNC_SPD_CUST) {
2047 if (info->custom_divisor)
2048 baud_rate = info->baud / info->custom_divisor;
2049 else
2050 baud_rate = info->baud;
2051 } else if (baud > CD1400_MAX_SPEED) {
2052 baud = CD1400_MAX_SPEED;
2053 }
2054
2055 for (i = 0; i < 20; i++) {
2056 if (baud == baud_table[i])
2057 break;
2058 }
2059 if (i == 20)
2060 i = 19;
2061
2062 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2063 ASYNC_SPD_CUST) {
2064 cyy_baud_calc(info, baud_rate);
2065 } else {
2066 if (info->chip_rev >= CD1400_REV_J) {
2067
2068 info->tbpr = baud_bpr_60[i];
2069 info->tco = baud_co_60[i];
2070 info->rbpr = baud_bpr_60[i];
2071 info->rco = baud_co_60[i];
2072 } else {
2073 info->tbpr = baud_bpr_25[i];
2074 info->tco = baud_co_25[i];
2075 info->rbpr = baud_bpr_25[i];
2076 info->rco = baud_co_25[i];
2077 }
2078 }
2079 if (baud_table[i] == 134) {
2080
2081 info->timeout = (info->xmit_fifo_size * HZ * 30 / 269) +
2082 2;
2083 } else if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2084 ASYNC_SPD_CUST) {
2085 info->timeout = (info->xmit_fifo_size * HZ * 15 /
2086 baud_rate) + 2;
2087 } else if (baud_table[i]) {
2088 info->timeout = (info->xmit_fifo_size * HZ * 15 /
2089 baud_table[i]) + 2;
2090
2091 } else {
2092 info->timeout = 0;
2093 }
2094
2095
2096
2097
2098
2099 info->cor5 = 0;
2100 info->cor4 = 0;
2101
2102 info->cor3 = (info->default_threshold ?
2103 info->default_threshold : baud_cor3[i]);
2104 info->cor2 = CyETC;
2105 switch (cflag & CSIZE) {
2106 case CS5:
2107 info->cor1 = Cy_5_BITS;
2108 break;
2109 case CS6:
2110 info->cor1 = Cy_6_BITS;
2111 break;
2112 case CS7:
2113 info->cor1 = Cy_7_BITS;
2114 break;
2115 case CS8:
2116 info->cor1 = Cy_8_BITS;
2117 break;
2118 }
2119 if (cflag & CSTOPB)
2120 info->cor1 |= Cy_2_STOP;
2121
2122 if (cflag & PARENB) {
2123 if (cflag & PARODD)
2124 info->cor1 |= CyPARITY_O;
2125 else
2126 info->cor1 |= CyPARITY_E;
2127 } else
2128 info->cor1 |= CyPARITY_NONE;
2129
2130
2131 if (cflag & CRTSCTS) {
2132 info->port.flags |= ASYNC_CTS_FLOW;
2133 info->cor2 |= CyCtsAE;
2134 } else {
2135 info->port.flags &= ~ASYNC_CTS_FLOW;
2136 info->cor2 &= ~CyCtsAE;
2137 }
2138 if (cflag & CLOCAL)
2139 info->port.flags &= ~ASYNC_CHECK_CD;
2140 else
2141 info->port.flags |= ASYNC_CHECK_CD;
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153 channel &= 0x03;
2154
2155 spin_lock_irqsave(&card->card_lock, flags);
2156 cyy_writeb(info, CyCAR, channel);
2157
2158
2159
2160 cyy_writeb(info, CyTCOR, info->tco);
2161 cyy_writeb(info, CyTBPR, info->tbpr);
2162 cyy_writeb(info, CyRCOR, info->rco);
2163 cyy_writeb(info, CyRBPR, info->rbpr);
2164
2165
2166
2167 cyy_writeb(info, CySCHR1, START_CHAR(tty));
2168 cyy_writeb(info, CySCHR2, STOP_CHAR(tty));
2169 cyy_writeb(info, CyCOR1, info->cor1);
2170 cyy_writeb(info, CyCOR2, info->cor2);
2171 cyy_writeb(info, CyCOR3, info->cor3);
2172 cyy_writeb(info, CyCOR4, info->cor4);
2173 cyy_writeb(info, CyCOR5, info->cor5);
2174
2175 cyy_issue_cmd(info, CyCOR_CHANGE | CyCOR1ch | CyCOR2ch |
2176 CyCOR3ch);
2177
2178
2179 cyy_writeb(info, CyCAR, channel);
2180 cyy_writeb(info, CyRTPR,
2181 (info->default_timeout ? info->default_timeout : 0x02));
2182
2183
2184 cflags = CyCTS;
2185 if (!C_CLOCAL(tty))
2186 cflags |= CyDSR | CyRI | CyDCD;
2187
2188 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyMdmCh);
2189
2190 if ((cflag & CRTSCTS) && info->rflow)
2191 cyy_writeb(info, CyMCOR1, cflags | rflow_thr[i]);
2192 else
2193 cyy_writeb(info, CyMCOR1, cflags);
2194
2195 cyy_writeb(info, CyMCOR2, cflags);
2196
2197 if (i == 0)
2198 cyy_change_rts_dtr(info, 0, TIOCM_DTR);
2199 else
2200 cyy_change_rts_dtr(info, TIOCM_DTR, 0);
2201
2202 clear_bit(TTY_IO_ERROR, &tty->flags);
2203 spin_unlock_irqrestore(&card->card_lock, flags);
2204
2205 } else {
2206 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
2207 __u32 sw_flow;
2208 int retval;
2209
2210 if (!cyz_is_loaded(card))
2211 return;
2212
2213
2214 baud = tty_get_baud_rate(tty);
2215 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2216 ASYNC_SPD_CUST) {
2217 if (info->custom_divisor)
2218 baud_rate = info->baud / info->custom_divisor;
2219 else
2220 baud_rate = info->baud;
2221 } else if (baud > CYZ_MAX_SPEED) {
2222 baud = CYZ_MAX_SPEED;
2223 }
2224 cy_writel(&ch_ctrl->comm_baud, baud);
2225
2226 if (baud == 134) {
2227
2228 info->timeout = (info->xmit_fifo_size * HZ * 30 / 269) +
2229 2;
2230 } else if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2231 ASYNC_SPD_CUST) {
2232 info->timeout = (info->xmit_fifo_size * HZ * 15 /
2233 baud_rate) + 2;
2234 } else if (baud) {
2235 info->timeout = (info->xmit_fifo_size * HZ * 15 /
2236 baud) + 2;
2237
2238 } else {
2239 info->timeout = 0;
2240 }
2241
2242
2243 switch (cflag & CSIZE) {
2244 case CS5:
2245 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS5);
2246 break;
2247 case CS6:
2248 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS6);
2249 break;
2250 case CS7:
2251 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS7);
2252 break;
2253 case CS8:
2254 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS8);
2255 break;
2256 }
2257 if (cflag & CSTOPB) {
2258 cy_writel(&ch_ctrl->comm_data_l,
2259 readl(&ch_ctrl->comm_data_l) | C_DL_2STOP);
2260 } else {
2261 cy_writel(&ch_ctrl->comm_data_l,
2262 readl(&ch_ctrl->comm_data_l) | C_DL_1STOP);
2263 }
2264 if (cflag & PARENB) {
2265 if (cflag & PARODD)
2266 cy_writel(&ch_ctrl->comm_parity, C_PR_ODD);
2267 else
2268 cy_writel(&ch_ctrl->comm_parity, C_PR_EVEN);
2269 } else
2270 cy_writel(&ch_ctrl->comm_parity, C_PR_NONE);
2271
2272
2273 if (cflag & CRTSCTS) {
2274 cy_writel(&ch_ctrl->hw_flow,
2275 readl(&ch_ctrl->hw_flow) | C_RS_CTS | C_RS_RTS);
2276 } else {
2277 cy_writel(&ch_ctrl->hw_flow, readl(&ch_ctrl->hw_flow) &
2278 ~(C_RS_CTS | C_RS_RTS));
2279 }
2280
2281
2282 info->port.flags &= ~ASYNC_CTS_FLOW;
2283
2284
2285 sw_flow = 0;
2286 if (iflag & IXON) {
2287 sw_flow |= C_FL_OXX;
2288 if (iflag & IXANY)
2289 sw_flow |= C_FL_OIXANY;
2290 }
2291 cy_writel(&ch_ctrl->sw_flow, sw_flow);
2292
2293 retval = cyz_issue_cmd(card, channel, C_CM_IOCTL, 0L);
2294 if (retval != 0) {
2295 printk(KERN_ERR "cyc:set_line_char retval on ttyC%d "
2296 "was %x\n", info->line, retval);
2297 }
2298
2299
2300 if (cflag & CLOCAL)
2301 info->port.flags &= ~ASYNC_CHECK_CD;
2302 else
2303 info->port.flags |= ASYNC_CHECK_CD;
2304
2305 if (baud == 0) {
2306 cy_writel(&ch_ctrl->rs_control,
2307 readl(&ch_ctrl->rs_control) & ~C_RS_DTR);
2308#ifdef CY_DEBUG_DTR
2309 printk(KERN_DEBUG "cyc:set_line_char dropping Z DTR\n");
2310#endif
2311 } else {
2312 cy_writel(&ch_ctrl->rs_control,
2313 readl(&ch_ctrl->rs_control) | C_RS_DTR);
2314#ifdef CY_DEBUG_DTR
2315 printk(KERN_DEBUG "cyc:set_line_char raising Z DTR\n");
2316#endif
2317 }
2318
2319 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLM, 0L);
2320 if (retval != 0) {
2321 printk(KERN_ERR "cyc:set_line_char(2) retval on ttyC%d "
2322 "was %x\n", info->line, retval);
2323 }
2324
2325 clear_bit(TTY_IO_ERROR, &tty->flags);
2326 }
2327}
2328
2329static int cy_get_serial_info(struct cyclades_port *info,
2330 struct serial_struct __user *retinfo)
2331{
2332 struct cyclades_card *cinfo = info->card;
2333 struct serial_struct tmp = {
2334 .type = info->type,
2335 .line = info->line,
2336 .port = (info->card - cy_card) * 0x100 + info->line -
2337 cinfo->first_line,
2338 .irq = cinfo->irq,
2339 .flags = info->port.flags,
2340 .close_delay = info->port.close_delay,
2341 .closing_wait = info->port.closing_wait,
2342 .baud_base = info->baud,
2343 .custom_divisor = info->custom_divisor,
2344 .hub6 = 0,
2345 };
2346 return copy_to_user(retinfo, &tmp, sizeof(*retinfo)) ? -EFAULT : 0;
2347}
2348
2349static int
2350cy_set_serial_info(struct cyclades_port *info, struct tty_struct *tty,
2351 struct serial_struct __user *new_info)
2352{
2353 struct serial_struct new_serial;
2354 int ret;
2355
2356 if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
2357 return -EFAULT;
2358
2359 mutex_lock(&info->port.mutex);
2360 if (!capable(CAP_SYS_ADMIN)) {
2361 if (new_serial.close_delay != info->port.close_delay ||
2362 new_serial.baud_base != info->baud ||
2363 (new_serial.flags & ASYNC_FLAGS &
2364 ~ASYNC_USR_MASK) !=
2365 (info->port.flags & ASYNC_FLAGS & ~ASYNC_USR_MASK))
2366 {
2367 mutex_unlock(&info->port.mutex);
2368 return -EPERM;
2369 }
2370 info->port.flags = (info->port.flags & ~ASYNC_USR_MASK) |
2371 (new_serial.flags & ASYNC_USR_MASK);
2372 info->baud = new_serial.baud_base;
2373 info->custom_divisor = new_serial.custom_divisor;
2374 goto check_and_exit;
2375 }
2376
2377
2378
2379
2380
2381
2382 info->baud = new_serial.baud_base;
2383 info->custom_divisor = new_serial.custom_divisor;
2384 info->port.flags = (info->port.flags & ~ASYNC_FLAGS) |
2385 (new_serial.flags & ASYNC_FLAGS);
2386 info->port.close_delay = new_serial.close_delay * HZ / 100;
2387 info->port.closing_wait = new_serial.closing_wait * HZ / 100;
2388
2389check_and_exit:
2390 if (info->port.flags & ASYNC_INITIALIZED) {
2391 cy_set_line_char(info, tty);
2392 ret = 0;
2393 } else {
2394 ret = cy_startup(info, tty);
2395 }
2396 mutex_unlock(&info->port.mutex);
2397 return ret;
2398}
2399
2400
2401
2402
2403
2404
2405
2406
2407
2408
2409
2410static int get_lsr_info(struct cyclades_port *info, unsigned int __user *value)
2411{
2412 struct cyclades_card *card = info->card;
2413 unsigned int result;
2414 unsigned long flags;
2415 u8 status;
2416
2417 if (!cy_is_Z(card)) {
2418 spin_lock_irqsave(&card->card_lock, flags);
2419 status = cyy_readb(info, CySRER) & (CyTxRdy | CyTxMpty);
2420 spin_unlock_irqrestore(&card->card_lock, flags);
2421 result = (status ? 0 : TIOCSER_TEMT);
2422 } else {
2423
2424 return -EINVAL;
2425 }
2426 return put_user(result, (unsigned long __user *)value);
2427}
2428
2429static int cy_tiocmget(struct tty_struct *tty)
2430{
2431 struct cyclades_port *info = tty->driver_data;
2432 struct cyclades_card *card;
2433 int result;
2434
2435 if (serial_paranoia_check(info, tty->name, __func__))
2436 return -ENODEV;
2437
2438 card = info->card;
2439
2440 if (!cy_is_Z(card)) {
2441 unsigned long flags;
2442 int channel = info->line - card->first_line;
2443 u8 status;
2444
2445 spin_lock_irqsave(&card->card_lock, flags);
2446 cyy_writeb(info, CyCAR, channel & 0x03);
2447 status = cyy_readb(info, CyMSVR1);
2448 status |= cyy_readb(info, CyMSVR2);
2449 spin_unlock_irqrestore(&card->card_lock, flags);
2450
2451 if (info->rtsdtr_inv) {
2452 result = ((status & CyRTS) ? TIOCM_DTR : 0) |
2453 ((status & CyDTR) ? TIOCM_RTS : 0);
2454 } else {
2455 result = ((status & CyRTS) ? TIOCM_RTS : 0) |
2456 ((status & CyDTR) ? TIOCM_DTR : 0);
2457 }
2458 result |= ((status & CyDCD) ? TIOCM_CAR : 0) |
2459 ((status & CyRI) ? TIOCM_RNG : 0) |
2460 ((status & CyDSR) ? TIOCM_DSR : 0) |
2461 ((status & CyCTS) ? TIOCM_CTS : 0);
2462 } else {
2463 u32 lstatus;
2464
2465 if (!cyz_is_loaded(card)) {
2466 result = -ENODEV;
2467 goto end;
2468 }
2469
2470 lstatus = readl(&info->u.cyz.ch_ctrl->rs_status);
2471 result = ((lstatus & C_RS_RTS) ? TIOCM_RTS : 0) |
2472 ((lstatus & C_RS_DTR) ? TIOCM_DTR : 0) |
2473 ((lstatus & C_RS_DCD) ? TIOCM_CAR : 0) |
2474 ((lstatus & C_RS_RI) ? TIOCM_RNG : 0) |
2475 ((lstatus & C_RS_DSR) ? TIOCM_DSR : 0) |
2476 ((lstatus & C_RS_CTS) ? TIOCM_CTS : 0);
2477 }
2478end:
2479 return result;
2480}
2481
2482static int
2483cy_tiocmset(struct tty_struct *tty,
2484 unsigned int set, unsigned int clear)
2485{
2486 struct cyclades_port *info = tty->driver_data;
2487 struct cyclades_card *card;
2488 unsigned long flags;
2489
2490 if (serial_paranoia_check(info, tty->name, __func__))
2491 return -ENODEV;
2492
2493 card = info->card;
2494 if (!cy_is_Z(card)) {
2495 spin_lock_irqsave(&card->card_lock, flags);
2496 cyy_change_rts_dtr(info, set, clear);
2497 spin_unlock_irqrestore(&card->card_lock, flags);
2498 } else {
2499 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
2500 int retval, channel = info->line - card->first_line;
2501 u32 rs;
2502
2503 if (!cyz_is_loaded(card))
2504 return -ENODEV;
2505
2506 spin_lock_irqsave(&card->card_lock, flags);
2507 rs = readl(&ch_ctrl->rs_control);
2508 if (set & TIOCM_RTS)
2509 rs |= C_RS_RTS;
2510 if (clear & TIOCM_RTS)
2511 rs &= ~C_RS_RTS;
2512 if (set & TIOCM_DTR) {
2513 rs |= C_RS_DTR;
2514#ifdef CY_DEBUG_DTR
2515 printk(KERN_DEBUG "cyc:set_modem_info raising Z DTR\n");
2516#endif
2517 }
2518 if (clear & TIOCM_DTR) {
2519 rs &= ~C_RS_DTR;
2520#ifdef CY_DEBUG_DTR
2521 printk(KERN_DEBUG "cyc:set_modem_info clearing "
2522 "Z DTR\n");
2523#endif
2524 }
2525 cy_writel(&ch_ctrl->rs_control, rs);
2526 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLM, 0L);
2527 spin_unlock_irqrestore(&card->card_lock, flags);
2528 if (retval != 0) {
2529 printk(KERN_ERR "cyc:set_modem_info retval on ttyC%d "
2530 "was %x\n", info->line, retval);
2531 }
2532 }
2533 return 0;
2534}
2535
2536
2537
2538
2539static int cy_break(struct tty_struct *tty, int break_state)
2540{
2541 struct cyclades_port *info = tty->driver_data;
2542 struct cyclades_card *card;
2543 unsigned long flags;
2544 int retval = 0;
2545
2546 if (serial_paranoia_check(info, tty->name, "cy_break"))
2547 return -EINVAL;
2548
2549 card = info->card;
2550
2551 spin_lock_irqsave(&card->card_lock, flags);
2552 if (!cy_is_Z(card)) {
2553
2554
2555
2556 if (break_state == -1) {
2557 if (!info->breakon) {
2558 info->breakon = 1;
2559 if (!info->xmit_cnt) {
2560 spin_unlock_irqrestore(&card->card_lock, flags);
2561 start_xmit(info);
2562 spin_lock_irqsave(&card->card_lock, flags);
2563 }
2564 }
2565 } else {
2566 if (!info->breakoff) {
2567 info->breakoff = 1;
2568 if (!info->xmit_cnt) {
2569 spin_unlock_irqrestore(&card->card_lock, flags);
2570 start_xmit(info);
2571 spin_lock_irqsave(&card->card_lock, flags);
2572 }
2573 }
2574 }
2575 } else {
2576 if (break_state == -1) {
2577 retval = cyz_issue_cmd(card,
2578 info->line - card->first_line,
2579 C_CM_SET_BREAK, 0L);
2580 if (retval != 0) {
2581 printk(KERN_ERR "cyc:cy_break (set) retval on "
2582 "ttyC%d was %x\n", info->line, retval);
2583 }
2584 } else {
2585 retval = cyz_issue_cmd(card,
2586 info->line - card->first_line,
2587 C_CM_CLR_BREAK, 0L);
2588 if (retval != 0) {
2589 printk(KERN_DEBUG "cyc:cy_break (clr) retval "
2590 "on ttyC%d was %x\n", info->line,
2591 retval);
2592 }
2593 }
2594 }
2595 spin_unlock_irqrestore(&card->card_lock, flags);
2596 return retval;
2597}
2598
2599static int set_threshold(struct cyclades_port *info, unsigned long value)
2600{
2601 struct cyclades_card *card = info->card;
2602 unsigned long flags;
2603
2604 if (!cy_is_Z(card)) {
2605 info->cor3 &= ~CyREC_FIFO;
2606 info->cor3 |= value & CyREC_FIFO;
2607
2608 spin_lock_irqsave(&card->card_lock, flags);
2609 cyy_writeb(info, CyCOR3, info->cor3);
2610 cyy_issue_cmd(info, CyCOR_CHANGE | CyCOR3ch);
2611 spin_unlock_irqrestore(&card->card_lock, flags);
2612 }
2613 return 0;
2614}
2615
2616static int get_threshold(struct cyclades_port *info,
2617 unsigned long __user *value)
2618{
2619 struct cyclades_card *card = info->card;
2620
2621 if (!cy_is_Z(card)) {
2622 u8 tmp = cyy_readb(info, CyCOR3) & CyREC_FIFO;
2623 return put_user(tmp, value);
2624 }
2625 return 0;
2626}
2627
2628static int set_timeout(struct cyclades_port *info, unsigned long value)
2629{
2630 struct cyclades_card *card = info->card;
2631 unsigned long flags;
2632
2633 if (!cy_is_Z(card)) {
2634 spin_lock_irqsave(&card->card_lock, flags);
2635 cyy_writeb(info, CyRTPR, value & 0xff);
2636 spin_unlock_irqrestore(&card->card_lock, flags);
2637 }
2638 return 0;
2639}
2640
2641static int get_timeout(struct cyclades_port *info,
2642 unsigned long __user *value)
2643{
2644 struct cyclades_card *card = info->card;
2645
2646 if (!cy_is_Z(card)) {
2647 u8 tmp = cyy_readb(info, CyRTPR);
2648 return put_user(tmp, value);
2649 }
2650 return 0;
2651}
2652
2653static int cy_cflags_changed(struct cyclades_port *info, unsigned long arg,
2654 struct cyclades_icount *cprev)
2655{
2656 struct cyclades_icount cnow;
2657 unsigned long flags;
2658 int ret;
2659
2660 spin_lock_irqsave(&info->card->card_lock, flags);
2661 cnow = info->icount;
2662 spin_unlock_irqrestore(&info->card->card_lock, flags);
2663
2664 ret = ((arg & TIOCM_RNG) && (cnow.rng != cprev->rng)) ||
2665 ((arg & TIOCM_DSR) && (cnow.dsr != cprev->dsr)) ||
2666 ((arg & TIOCM_CD) && (cnow.dcd != cprev->dcd)) ||
2667 ((arg & TIOCM_CTS) && (cnow.cts != cprev->cts));
2668
2669 *cprev = cnow;
2670
2671 return ret;
2672}
2673
2674
2675
2676
2677
2678
2679static int
2680cy_ioctl(struct tty_struct *tty,
2681 unsigned int cmd, unsigned long arg)
2682{
2683 struct cyclades_port *info = tty->driver_data;
2684 struct cyclades_icount cnow;
2685 int ret_val = 0;
2686 unsigned long flags;
2687 void __user *argp = (void __user *)arg;
2688
2689 if (serial_paranoia_check(info, tty->name, "cy_ioctl"))
2690 return -ENODEV;
2691
2692#ifdef CY_DEBUG_OTHER
2693 printk(KERN_DEBUG "cyc:cy_ioctl ttyC%d, cmd = %x arg = %lx\n",
2694 info->line, cmd, arg);
2695#endif
2696
2697 switch (cmd) {
2698 case CYGETMON:
2699 if (copy_to_user(argp, &info->mon, sizeof(info->mon))) {
2700 ret_val = -EFAULT;
2701 break;
2702 }
2703 memset(&info->mon, 0, sizeof(info->mon));
2704 break;
2705 case CYGETTHRESH:
2706 ret_val = get_threshold(info, argp);
2707 break;
2708 case CYSETTHRESH:
2709 ret_val = set_threshold(info, arg);
2710 break;
2711 case CYGETDEFTHRESH:
2712 ret_val = put_user(info->default_threshold,
2713 (unsigned long __user *)argp);
2714 break;
2715 case CYSETDEFTHRESH:
2716 info->default_threshold = arg & 0x0f;
2717 break;
2718 case CYGETTIMEOUT:
2719 ret_val = get_timeout(info, argp);
2720 break;
2721 case CYSETTIMEOUT:
2722 ret_val = set_timeout(info, arg);
2723 break;
2724 case CYGETDEFTIMEOUT:
2725 ret_val = put_user(info->default_timeout,
2726 (unsigned long __user *)argp);
2727 break;
2728 case CYSETDEFTIMEOUT:
2729 info->default_timeout = arg & 0xff;
2730 break;
2731 case CYSETRFLOW:
2732 info->rflow = (int)arg;
2733 break;
2734 case CYGETRFLOW:
2735 ret_val = info->rflow;
2736 break;
2737 case CYSETRTSDTR_INV:
2738 info->rtsdtr_inv = (int)arg;
2739 break;
2740 case CYGETRTSDTR_INV:
2741 ret_val = info->rtsdtr_inv;
2742 break;
2743 case CYGETCD1400VER:
2744 ret_val = info->chip_rev;
2745 break;
2746#ifndef CONFIG_CYZ_INTR
2747 case CYZSETPOLLCYCLE:
2748 cyz_polling_cycle = (arg * HZ) / 1000;
2749 break;
2750 case CYZGETPOLLCYCLE:
2751 ret_val = (cyz_polling_cycle * 1000) / HZ;
2752 break;
2753#endif
2754 case CYSETWAIT:
2755 info->port.closing_wait = (unsigned short)arg * HZ / 100;
2756 break;
2757 case CYGETWAIT:
2758 ret_val = info->port.closing_wait / (HZ / 100);
2759 break;
2760 case TIOCGSERIAL:
2761 ret_val = cy_get_serial_info(info, argp);
2762 break;
2763 case TIOCSSERIAL:
2764 ret_val = cy_set_serial_info(info, tty, argp);
2765 break;
2766 case TIOCSERGETLSR:
2767 ret_val = get_lsr_info(info, argp);
2768 break;
2769
2770
2771
2772
2773
2774
2775 case TIOCMIWAIT:
2776 spin_lock_irqsave(&info->card->card_lock, flags);
2777
2778 cnow = info->icount;
2779 spin_unlock_irqrestore(&info->card->card_lock, flags);
2780 ret_val = wait_event_interruptible(info->port.delta_msr_wait,
2781 cy_cflags_changed(info, arg, &cnow));
2782 break;
2783
2784
2785
2786
2787
2788
2789
2790 default:
2791 ret_val = -ENOIOCTLCMD;
2792 }
2793
2794#ifdef CY_DEBUG_OTHER
2795 printk(KERN_DEBUG "cyc:cy_ioctl done\n");
2796#endif
2797 return ret_val;
2798}
2799
2800static int cy_get_icount(struct tty_struct *tty,
2801 struct serial_icounter_struct *sic)
2802{
2803 struct cyclades_port *info = tty->driver_data;
2804 struct cyclades_icount cnow;
2805 unsigned long flags;
2806
2807 spin_lock_irqsave(&info->card->card_lock, flags);
2808 cnow = info->icount;
2809 spin_unlock_irqrestore(&info->card->card_lock, flags);
2810
2811 sic->cts = cnow.cts;
2812 sic->dsr = cnow.dsr;
2813 sic->rng = cnow.rng;
2814 sic->dcd = cnow.dcd;
2815 sic->rx = cnow.rx;
2816 sic->tx = cnow.tx;
2817 sic->frame = cnow.frame;
2818 sic->overrun = cnow.overrun;
2819 sic->parity = cnow.parity;
2820 sic->brk = cnow.brk;
2821 sic->buf_overrun = cnow.buf_overrun;
2822 return 0;
2823}
2824
2825
2826
2827
2828
2829
2830
2831static void cy_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
2832{
2833 struct cyclades_port *info = tty->driver_data;
2834
2835#ifdef CY_DEBUG_OTHER
2836 printk(KERN_DEBUG "cyc:cy_set_termios ttyC%d\n", info->line);
2837#endif
2838
2839 cy_set_line_char(info, tty);
2840
2841 if ((old_termios->c_cflag & CRTSCTS) &&
2842 !(tty->termios->c_cflag & CRTSCTS)) {
2843 tty->hw_stopped = 0;
2844 cy_start(tty);
2845 }
2846#if 0
2847
2848
2849
2850
2851
2852
2853 if (!(old_termios->c_cflag & CLOCAL) &&
2854 (tty->termios->c_cflag & CLOCAL))
2855 wake_up_interruptible(&info->port.open_wait);
2856#endif
2857}
2858
2859
2860
2861
2862static void cy_send_xchar(struct tty_struct *tty, char ch)
2863{
2864 struct cyclades_port *info = tty->driver_data;
2865 struct cyclades_card *card;
2866 int channel;
2867
2868 if (serial_paranoia_check(info, tty->name, "cy_send_xchar"))
2869 return;
2870
2871 info->x_char = ch;
2872
2873 if (ch)
2874 cy_start(tty);
2875
2876 card = info->card;
2877 channel = info->line - card->first_line;
2878
2879 if (cy_is_Z(card)) {
2880 if (ch == STOP_CHAR(tty))
2881 cyz_issue_cmd(card, channel, C_CM_SENDXOFF, 0L);
2882 else if (ch == START_CHAR(tty))
2883 cyz_issue_cmd(card, channel, C_CM_SENDXON, 0L);
2884 }
2885}
2886
2887
2888
2889
2890
2891static void cy_throttle(struct tty_struct *tty)
2892{
2893 struct cyclades_port *info = tty->driver_data;
2894 struct cyclades_card *card;
2895 unsigned long flags;
2896
2897#ifdef CY_DEBUG_THROTTLE
2898 char buf[64];
2899
2900 printk(KERN_DEBUG "cyc:throttle %s: %ld...ttyC%d\n", tty_name(tty, buf),
2901 tty->ldisc.chars_in_buffer(tty), info->line);
2902#endif
2903
2904 if (serial_paranoia_check(info, tty->name, "cy_throttle"))
2905 return;
2906
2907 card = info->card;
2908
2909 if (I_IXOFF(tty)) {
2910 if (!cy_is_Z(card))
2911 cy_send_xchar(tty, STOP_CHAR(tty));
2912 else
2913 info->throttle = 1;
2914 }
2915
2916 if (tty->termios->c_cflag & CRTSCTS) {
2917 if (!cy_is_Z(card)) {
2918 spin_lock_irqsave(&card->card_lock, flags);
2919 cyy_change_rts_dtr(info, 0, TIOCM_RTS);
2920 spin_unlock_irqrestore(&card->card_lock, flags);
2921 } else {
2922 info->throttle = 1;
2923 }
2924 }
2925}
2926
2927
2928
2929
2930
2931
2932static void cy_unthrottle(struct tty_struct *tty)
2933{
2934 struct cyclades_port *info = tty->driver_data;
2935 struct cyclades_card *card;
2936 unsigned long flags;
2937
2938#ifdef CY_DEBUG_THROTTLE
2939 char buf[64];
2940
2941 printk(KERN_DEBUG "cyc:unthrottle %s: %ld...ttyC%d\n",
2942 tty_name(tty, buf), tty_chars_in_buffer(tty), info->line);
2943#endif
2944
2945 if (serial_paranoia_check(info, tty->name, "cy_unthrottle"))
2946 return;
2947
2948 if (I_IXOFF(tty)) {
2949 if (info->x_char)
2950 info->x_char = 0;
2951 else
2952 cy_send_xchar(tty, START_CHAR(tty));
2953 }
2954
2955 if (tty->termios->c_cflag & CRTSCTS) {
2956 card = info->card;
2957 if (!cy_is_Z(card)) {
2958 spin_lock_irqsave(&card->card_lock, flags);
2959 cyy_change_rts_dtr(info, TIOCM_RTS, 0);
2960 spin_unlock_irqrestore(&card->card_lock, flags);
2961 } else {
2962 info->throttle = 0;
2963 }
2964 }
2965}
2966
2967
2968
2969
2970static void cy_stop(struct tty_struct *tty)
2971{
2972 struct cyclades_card *cinfo;
2973 struct cyclades_port *info = tty->driver_data;
2974 int channel;
2975 unsigned long flags;
2976
2977#ifdef CY_DEBUG_OTHER
2978 printk(KERN_DEBUG "cyc:cy_stop ttyC%d\n", info->line);
2979#endif
2980
2981 if (serial_paranoia_check(info, tty->name, "cy_stop"))
2982 return;
2983
2984 cinfo = info->card;
2985 channel = info->line - cinfo->first_line;
2986 if (!cy_is_Z(cinfo)) {
2987 spin_lock_irqsave(&cinfo->card_lock, flags);
2988 cyy_writeb(info, CyCAR, channel & 0x03);
2989 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyTxRdy);
2990 spin_unlock_irqrestore(&cinfo->card_lock, flags);
2991 }
2992}
2993
2994static void cy_start(struct tty_struct *tty)
2995{
2996 struct cyclades_card *cinfo;
2997 struct cyclades_port *info = tty->driver_data;
2998 int channel;
2999 unsigned long flags;
3000
3001#ifdef CY_DEBUG_OTHER
3002 printk(KERN_DEBUG "cyc:cy_start ttyC%d\n", info->line);
3003#endif
3004
3005 if (serial_paranoia_check(info, tty->name, "cy_start"))
3006 return;
3007
3008 cinfo = info->card;
3009 channel = info->line - cinfo->first_line;
3010 if (!cy_is_Z(cinfo)) {
3011 spin_lock_irqsave(&cinfo->card_lock, flags);
3012 cyy_writeb(info, CyCAR, channel & 0x03);
3013 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyTxRdy);
3014 spin_unlock_irqrestore(&cinfo->card_lock, flags);
3015 }
3016}
3017
3018
3019
3020
3021static void cy_hangup(struct tty_struct *tty)
3022{
3023 struct cyclades_port *info = tty->driver_data;
3024
3025#ifdef CY_DEBUG_OTHER
3026 printk(KERN_DEBUG "cyc:cy_hangup ttyC%d\n", info->line);
3027#endif
3028
3029 if (serial_paranoia_check(info, tty->name, "cy_hangup"))
3030 return;
3031
3032 cy_flush_buffer(tty);
3033 cy_shutdown(info, tty);
3034 tty_port_hangup(&info->port);
3035}
3036
3037static int cyy_carrier_raised(struct tty_port *port)
3038{
3039 struct cyclades_port *info = container_of(port, struct cyclades_port,
3040 port);
3041 struct cyclades_card *cinfo = info->card;
3042 unsigned long flags;
3043 int channel = info->line - cinfo->first_line;
3044 u32 cd;
3045
3046 spin_lock_irqsave(&cinfo->card_lock, flags);
3047 cyy_writeb(info, CyCAR, channel & 0x03);
3048 cd = cyy_readb(info, CyMSVR1) & CyDCD;
3049 spin_unlock_irqrestore(&cinfo->card_lock, flags);
3050
3051 return cd;
3052}
3053
3054static void cyy_dtr_rts(struct tty_port *port, int raise)
3055{
3056 struct cyclades_port *info = container_of(port, struct cyclades_port,
3057 port);
3058 struct cyclades_card *cinfo = info->card;
3059 unsigned long flags;
3060
3061 spin_lock_irqsave(&cinfo->card_lock, flags);
3062 cyy_change_rts_dtr(info, raise ? TIOCM_RTS | TIOCM_DTR : 0,
3063 raise ? 0 : TIOCM_RTS | TIOCM_DTR);
3064 spin_unlock_irqrestore(&cinfo->card_lock, flags);
3065}
3066
3067static int cyz_carrier_raised(struct tty_port *port)
3068{
3069 struct cyclades_port *info = container_of(port, struct cyclades_port,
3070 port);
3071
3072 return readl(&info->u.cyz.ch_ctrl->rs_status) & C_RS_DCD;
3073}
3074
3075static void cyz_dtr_rts(struct tty_port *port, int raise)
3076{
3077 struct cyclades_port *info = container_of(port, struct cyclades_port,
3078 port);
3079 struct cyclades_card *cinfo = info->card;
3080 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
3081 int ret, channel = info->line - cinfo->first_line;
3082 u32 rs;
3083
3084 rs = readl(&ch_ctrl->rs_control);
3085 if (raise)
3086 rs |= C_RS_RTS | C_RS_DTR;
3087 else
3088 rs &= ~(C_RS_RTS | C_RS_DTR);
3089 cy_writel(&ch_ctrl->rs_control, rs);
3090 ret = cyz_issue_cmd(cinfo, channel, C_CM_IOCTLM, 0L);
3091 if (ret != 0)
3092 printk(KERN_ERR "%s: retval on ttyC%d was %x\n",
3093 __func__, info->line, ret);
3094#ifdef CY_DEBUG_DTR
3095 printk(KERN_DEBUG "%s: raising Z DTR\n", __func__);
3096#endif
3097}
3098
3099static const struct tty_port_operations cyy_port_ops = {
3100 .carrier_raised = cyy_carrier_raised,
3101 .dtr_rts = cyy_dtr_rts,
3102 .shutdown = cy_do_close,
3103};
3104
3105static const struct tty_port_operations cyz_port_ops = {
3106 .carrier_raised = cyz_carrier_raised,
3107 .dtr_rts = cyz_dtr_rts,
3108 .shutdown = cy_do_close,
3109};
3110
3111
3112
3113
3114
3115
3116
3117
3118
3119static int __devinit cy_init_card(struct cyclades_card *cinfo)
3120{
3121 struct cyclades_port *info;
3122 unsigned int channel, port;
3123
3124 spin_lock_init(&cinfo->card_lock);
3125 cinfo->intr_enabled = 0;
3126
3127 cinfo->ports = kcalloc(cinfo->nports, sizeof(*cinfo->ports),
3128 GFP_KERNEL);
3129 if (cinfo->ports == NULL) {
3130 printk(KERN_ERR "Cyclades: cannot allocate ports\n");
3131 return -ENOMEM;
3132 }
3133
3134 for (channel = 0, port = cinfo->first_line; channel < cinfo->nports;
3135 channel++, port++) {
3136 info = &cinfo->ports[channel];
3137 tty_port_init(&info->port);
3138 info->magic = CYCLADES_MAGIC;
3139 info->card = cinfo;
3140 info->line = port;
3141
3142 info->port.closing_wait = CLOSING_WAIT_DELAY;
3143 info->port.close_delay = 5 * HZ / 10;
3144 info->port.flags = STD_COM_FLAGS;
3145 init_completion(&info->shutdown_wait);
3146
3147 if (cy_is_Z(cinfo)) {
3148 struct FIRM_ID *firm_id = cinfo->base_addr + ID_ADDRESS;
3149 struct ZFW_CTRL *zfw_ctrl;
3150
3151 info->port.ops = &cyz_port_ops;
3152 info->type = PORT_STARTECH;
3153
3154 zfw_ctrl = cinfo->base_addr +
3155 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
3156 info->u.cyz.ch_ctrl = &zfw_ctrl->ch_ctrl[channel];
3157 info->u.cyz.buf_ctrl = &zfw_ctrl->buf_ctrl[channel];
3158
3159 if (cinfo->hw_ver == ZO_V1)
3160 info->xmit_fifo_size = CYZ_FIFO_SIZE;
3161 else
3162 info->xmit_fifo_size = 4 * CYZ_FIFO_SIZE;
3163#ifdef CONFIG_CYZ_INTR
3164 setup_timer(&cyz_rx_full_timer[port],
3165 cyz_rx_restart, (unsigned long)info);
3166#endif
3167 } else {
3168 unsigned short chip_number;
3169 int index = cinfo->bus_index;
3170
3171 info->port.ops = &cyy_port_ops;
3172 info->type = PORT_CIRRUS;
3173 info->xmit_fifo_size = CyMAX_CHAR_FIFO;
3174 info->cor1 = CyPARITY_NONE | Cy_1_STOP | Cy_8_BITS;
3175 info->cor2 = CyETC;
3176 info->cor3 = 0x08;
3177
3178 chip_number = channel / CyPORTS_PER_CHIP;
3179 info->u.cyy.base_addr = cinfo->base_addr +
3180 (cy_chip_offset[chip_number] << index);
3181 info->chip_rev = cyy_readb(info, CyGFRCR);
3182
3183 if (info->chip_rev >= CD1400_REV_J) {
3184
3185 info->tbpr = baud_bpr_60[13];
3186 info->tco = baud_co_60[13];
3187 info->rbpr = baud_bpr_60[13];
3188 info->rco = baud_co_60[13];
3189 info->rtsdtr_inv = 1;
3190 } else {
3191 info->tbpr = baud_bpr_25[13];
3192 info->tco = baud_co_25[13];
3193 info->rbpr = baud_bpr_25[13];
3194 info->rco = baud_co_25[13];
3195 info->rtsdtr_inv = 0;
3196 }
3197 info->read_status_mask = CyTIMEOUT | CySPECHAR |
3198 CyBREAK | CyPARITY | CyFRAME | CyOVERRUN;
3199 }
3200
3201 }
3202
3203#ifndef CONFIG_CYZ_INTR
3204 if (cy_is_Z(cinfo) && !timer_pending(&cyz_timerlist)) {
3205 mod_timer(&cyz_timerlist, jiffies + 1);
3206#ifdef CY_PCI_DEBUG
3207 printk(KERN_DEBUG "Cyclades-Z polling initialized\n");
3208#endif
3209 }
3210#endif
3211 return 0;
3212}
3213
3214
3215
3216static unsigned short __devinit cyy_init_card(void __iomem *true_base_addr,
3217 int index)
3218{
3219 unsigned int chip_number;
3220 void __iomem *base_addr;
3221
3222 cy_writeb(true_base_addr + (Cy_HwReset << index), 0);
3223
3224 cy_writeb(true_base_addr + (Cy_ClrIntr << index), 0);
3225
3226 udelay(500L);
3227
3228 for (chip_number = 0; chip_number < CyMAX_CHIPS_PER_CARD;
3229 chip_number++) {
3230 base_addr =
3231 true_base_addr + (cy_chip_offset[chip_number] << index);
3232 mdelay(1);
3233 if (readb(base_addr + (CyCCR << index)) != 0x00) {
3234
3235
3236
3237
3238 return chip_number;
3239 }
3240
3241 cy_writeb(base_addr + (CyGFRCR << index), 0);
3242 udelay(10L);
3243
3244
3245
3246
3247
3248
3249
3250 if (chip_number == 4 && readb(true_base_addr +
3251 (cy_chip_offset[0] << index) +
3252 (CyGFRCR << index)) == 0) {
3253 return chip_number;
3254 }
3255
3256 cy_writeb(base_addr + (CyCCR << index), CyCHIP_RESET);
3257 mdelay(1);
3258
3259 if (readb(base_addr + (CyGFRCR << index)) == 0x00) {
3260
3261
3262
3263
3264
3265 return chip_number;
3266 }
3267 if ((0xf0 & (readb(base_addr + (CyGFRCR << index)))) !=
3268 0x40) {
3269
3270
3271
3272
3273
3274
3275 return chip_number;
3276 }
3277 cy_writeb(base_addr + (CyGCR << index), CyCH0_SERIAL);
3278 if (readb(base_addr + (CyGFRCR << index)) >= CD1400_REV_J) {
3279
3280
3281
3282 cy_writeb(base_addr + (CyPPR << index), CyCLOCK_60_2MS);
3283 } else {
3284
3285 cy_writeb(base_addr + (CyPPR << index), CyCLOCK_25_5MS);
3286 }
3287
3288
3289
3290
3291
3292
3293 }
3294 return chip_number;
3295}
3296
3297
3298
3299
3300
3301
3302
3303static int __init cy_detect_isa(void)
3304{
3305#ifdef CONFIG_ISA
3306 unsigned short cy_isa_irq, nboard;
3307 void __iomem *cy_isa_address;
3308 unsigned short i, j, cy_isa_nchan;
3309 int isparam = 0;
3310
3311 nboard = 0;
3312
3313
3314 for (i = 0; i < NR_CARDS; i++) {
3315 if (maddr[i] || i) {
3316 isparam = 1;
3317 cy_isa_addresses[i] = maddr[i];
3318 }
3319 if (!maddr[i])
3320 break;
3321 }
3322
3323
3324 for (i = 0; i < NR_ISA_ADDRS; i++) {
3325 unsigned int isa_address = cy_isa_addresses[i];
3326 if (isa_address == 0x0000)
3327 return nboard;
3328
3329
3330 cy_isa_address = ioremap_nocache(isa_address, CyISA_Ywin);
3331 if (cy_isa_address == NULL) {
3332 printk(KERN_ERR "Cyclom-Y/ISA: can't remap base "
3333 "address\n");
3334 continue;
3335 }
3336 cy_isa_nchan = CyPORTS_PER_CHIP *
3337 cyy_init_card(cy_isa_address, 0);
3338 if (cy_isa_nchan == 0) {
3339 iounmap(cy_isa_address);
3340 continue;
3341 }
3342
3343 if (isparam && i < NR_CARDS && irq[i])
3344 cy_isa_irq = irq[i];
3345 else
3346
3347 cy_isa_irq = detect_isa_irq(cy_isa_address);
3348 if (cy_isa_irq == 0) {
3349 printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but the "
3350 "IRQ could not be detected.\n",
3351 (unsigned long)cy_isa_address);
3352 iounmap(cy_isa_address);
3353 continue;
3354 }
3355
3356 if ((cy_next_channel + cy_isa_nchan) > NR_PORTS) {
3357 printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but no "
3358 "more channels are available. Change NR_PORTS "
3359 "in cyclades.c and recompile kernel.\n",
3360 (unsigned long)cy_isa_address);
3361 iounmap(cy_isa_address);
3362 return nboard;
3363 }
3364
3365 for (j = 0; j < NR_CARDS; j++) {
3366 if (cy_card[j].base_addr == NULL)
3367 break;
3368 }
3369 if (j == NR_CARDS) {
3370 printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but no "
3371 "more cards can be used. Change NR_CARDS in "
3372 "cyclades.c and recompile kernel.\n",
3373 (unsigned long)cy_isa_address);
3374 iounmap(cy_isa_address);
3375 return nboard;
3376 }
3377
3378
3379 if (request_irq(cy_isa_irq, cyy_interrupt,
3380 IRQF_DISABLED, "Cyclom-Y", &cy_card[j])) {
3381 printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but "
3382 "could not allocate IRQ#%d.\n",
3383 (unsigned long)cy_isa_address, cy_isa_irq);
3384 iounmap(cy_isa_address);
3385 return nboard;
3386 }
3387
3388
3389 cy_card[j].base_addr = cy_isa_address;
3390 cy_card[j].ctl_addr.p9050 = NULL;
3391 cy_card[j].irq = (int)cy_isa_irq;
3392 cy_card[j].bus_index = 0;
3393 cy_card[j].first_line = cy_next_channel;
3394 cy_card[j].num_chips = cy_isa_nchan / CyPORTS_PER_CHIP;
3395 cy_card[j].nports = cy_isa_nchan;
3396 if (cy_init_card(&cy_card[j])) {
3397 cy_card[j].base_addr = NULL;
3398 free_irq(cy_isa_irq, &cy_card[j]);
3399 iounmap(cy_isa_address);
3400 continue;
3401 }
3402 nboard++;
3403
3404 printk(KERN_INFO "Cyclom-Y/ISA #%d: 0x%lx-0x%lx, IRQ%d found: "
3405 "%d channels starting from port %d\n",
3406 j + 1, (unsigned long)cy_isa_address,
3407 (unsigned long)(cy_isa_address + (CyISA_Ywin - 1)),
3408 cy_isa_irq, cy_isa_nchan, cy_next_channel);
3409
3410 for (j = cy_next_channel;
3411 j < cy_next_channel + cy_isa_nchan; j++)
3412 tty_register_device(cy_serial_driver, j, NULL);
3413 cy_next_channel += cy_isa_nchan;
3414 }
3415 return nboard;
3416#else
3417 return 0;
3418#endif
3419}
3420
3421#ifdef CONFIG_PCI
3422static inline int __devinit cyc_isfwstr(const char *str, unsigned int size)
3423{
3424 unsigned int a;
3425
3426 for (a = 0; a < size && *str; a++, str++)
3427 if (*str & 0x80)
3428 return -EINVAL;
3429
3430 for (; a < size; a++, str++)
3431 if (*str)
3432 return -EINVAL;
3433
3434 return 0;
3435}
3436
3437static inline void __devinit cyz_fpga_copy(void __iomem *fpga, const u8 *data,
3438 unsigned int size)
3439{
3440 for (; size > 0; size--) {
3441 cy_writel(fpga, *data++);
3442 udelay(10);
3443 }
3444}
3445
3446static void __devinit plx_init(struct pci_dev *pdev, int irq,
3447 struct RUNTIME_9060 __iomem *addr)
3448{
3449
3450 cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) | 0x40000000);
3451 udelay(100L);
3452 cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) & ~0x40000000);
3453
3454
3455 cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) | 0x20000000);
3456 udelay(100L);
3457 cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) & ~0x20000000);
3458
3459
3460
3461
3462
3463 pci_write_config_byte(pdev, PCI_INTERRUPT_LINE, irq);
3464}
3465
3466static int __devinit __cyz_load_fw(const struct firmware *fw,
3467 const char *name, const u32 mailbox, void __iomem *base,
3468 void __iomem *fpga)
3469{
3470 const void *ptr = fw->data;
3471 const struct zfile_header *h = ptr;
3472 const struct zfile_config *c, *cs;
3473 const struct zfile_block *b, *bs;
3474 unsigned int a, tmp, len = fw->size;
3475#define BAD_FW KERN_ERR "Bad firmware: "
3476 if (len < sizeof(*h)) {
3477 printk(BAD_FW "too short: %u<%zu\n", len, sizeof(*h));
3478 return -EINVAL;
3479 }
3480
3481 cs = ptr + h->config_offset;
3482 bs = ptr + h->block_offset;
3483
3484 if ((void *)(cs + h->n_config) > ptr + len ||
3485 (void *)(bs + h->n_blocks) > ptr + len) {
3486 printk(BAD_FW "too short");
3487 return -EINVAL;
3488 }
3489
3490 if (cyc_isfwstr(h->name, sizeof(h->name)) ||
3491 cyc_isfwstr(h->date, sizeof(h->date))) {
3492 printk(BAD_FW "bad formatted header string\n");
3493 return -EINVAL;
3494 }
3495
3496 if (strncmp(name, h->name, sizeof(h->name))) {
3497 printk(BAD_FW "bad name '%s' (expected '%s')\n", h->name, name);
3498 return -EINVAL;
3499 }
3500
3501 tmp = 0;
3502 for (c = cs; c < cs + h->n_config; c++) {
3503 for (a = 0; a < c->n_blocks; a++)
3504 if (c->block_list[a] > h->n_blocks) {
3505 printk(BAD_FW "bad block ref number in cfgs\n");
3506 return -EINVAL;
3507 }
3508 if (c->mailbox == mailbox && c->function == 0)
3509 tmp++;
3510 }
3511 if (!tmp) {
3512 printk(BAD_FW "nothing appropriate\n");
3513 return -EINVAL;
3514 }
3515
3516 for (b = bs; b < bs + h->n_blocks; b++)
3517 if (b->file_offset + b->size > len) {
3518 printk(BAD_FW "bad block data offset\n");
3519 return -EINVAL;
3520 }
3521
3522
3523 for (c = cs; c < cs + h->n_config; c++)
3524 if (c->mailbox == mailbox && c->function == 0)
3525 break;
3526
3527 for (a = 0; a < c->n_blocks; a++) {
3528 b = &bs[c->block_list[a]];
3529 if (b->type == ZBLOCK_FPGA) {
3530 if (fpga != NULL)
3531 cyz_fpga_copy(fpga, ptr + b->file_offset,
3532 b->size);
3533 } else {
3534 if (base != NULL)
3535 memcpy_toio(base + b->ram_offset,
3536 ptr + b->file_offset, b->size);
3537 }
3538 }
3539#undef BAD_FW
3540 return 0;
3541}
3542
3543static int __devinit cyz_load_fw(struct pci_dev *pdev, void __iomem *base_addr,
3544 struct RUNTIME_9060 __iomem *ctl_addr, int irq)
3545{
3546 const struct firmware *fw;
3547 struct FIRM_ID __iomem *fid = base_addr + ID_ADDRESS;
3548 struct CUSTOM_REG __iomem *cust = base_addr;
3549 struct ZFW_CTRL __iomem *pt_zfwctrl;
3550 void __iomem *tmp;
3551 u32 mailbox, status, nchan;
3552 unsigned int i;
3553 int retval;
3554
3555 retval = request_firmware(&fw, "cyzfirm.bin", &pdev->dev);
3556 if (retval) {
3557 dev_err(&pdev->dev, "can't get firmware\n");
3558 goto err;
3559 }
3560
3561
3562
3563 if (__cyz_fpga_loaded(ctl_addr) && readl(&fid->signature) == ZFIRM_ID) {
3564 u32 cntval = readl(base_addr + 0x190);
3565
3566 udelay(100);
3567 if (cntval != readl(base_addr + 0x190)) {
3568
3569 dev_dbg(&pdev->dev, "Cyclades-Z FW already loaded. "
3570 "Skipping board.\n");
3571 retval = 0;
3572 goto err_rel;
3573 }
3574 }
3575
3576
3577 cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) &
3578 ~0x00030800UL);
3579
3580 mailbox = readl(&ctl_addr->mail_box_0);
3581
3582 if (mailbox == 0 || __cyz_fpga_loaded(ctl_addr)) {
3583
3584 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3585 cy_writel(&cust->cpu_stop, 0);
3586 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3587 udelay(100);
3588 }
3589
3590 plx_init(pdev, irq, ctl_addr);
3591
3592 if (mailbox != 0) {
3593
3594 retval = __cyz_load_fw(fw, "Cyclom-Z", mailbox, NULL,
3595 base_addr);
3596 if (retval)
3597 goto err_rel;
3598 if (!__cyz_fpga_loaded(ctl_addr)) {
3599 dev_err(&pdev->dev, "fw upload successful, but fw is "
3600 "not loaded\n");
3601 goto err_rel;
3602 }
3603 }
3604
3605
3606 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3607 cy_writel(&cust->cpu_stop, 0);
3608 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3609 udelay(100);
3610
3611
3612 for (tmp = base_addr; tmp < base_addr + RAM_SIZE; tmp++)
3613 cy_writeb(tmp, 255);
3614 if (mailbox != 0) {
3615
3616 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM + RAM_SIZE);
3617 for (tmp = base_addr; tmp < base_addr + RAM_SIZE; tmp++)
3618 cy_writeb(tmp, 255);
3619
3620 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3621 }
3622
3623 retval = __cyz_load_fw(fw, "Cyclom-Z", mailbox, base_addr, NULL);
3624 release_firmware(fw);
3625 if (retval)
3626 goto err;
3627
3628
3629 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3630 cy_writel(&cust->cpu_start, 0);
3631 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3632 i = 0;
3633 while ((status = readl(&fid->signature)) != ZFIRM_ID && i++ < 40)
3634 msleep(100);
3635 if (status != ZFIRM_ID) {
3636 if (status == ZFIRM_HLT) {
3637 dev_err(&pdev->dev, "you need an external power supply "
3638 "for this number of ports. Firmware halted and "
3639 "board reset.\n");
3640 retval = -EIO;
3641 goto err;
3642 }
3643 dev_warn(&pdev->dev, "fid->signature = 0x%x... Waiting "
3644 "some more time\n", status);
3645 while ((status = readl(&fid->signature)) != ZFIRM_ID &&
3646 i++ < 200)
3647 msleep(100);
3648 if (status != ZFIRM_ID) {
3649 dev_err(&pdev->dev, "Board not started in 20 seconds! "
3650 "Giving up. (fid->signature = 0x%x)\n",
3651 status);
3652 dev_info(&pdev->dev, "*** Warning ***: if you are "
3653 "upgrading the FW, please power cycle the "
3654 "system before loading the new FW to the "
3655 "Cyclades-Z.\n");
3656
3657 if (__cyz_fpga_loaded(ctl_addr))
3658 plx_init(pdev, irq, ctl_addr);
3659
3660 retval = -EIO;
3661 goto err;
3662 }
3663 dev_dbg(&pdev->dev, "Firmware started after %d seconds.\n",
3664 i / 10);
3665 }
3666 pt_zfwctrl = base_addr + readl(&fid->zfwctrl_addr);
3667
3668 dev_dbg(&pdev->dev, "fid=> %p, zfwctrl_addr=> %x, npt_zfwctrl=> %p\n",
3669 base_addr + ID_ADDRESS, readl(&fid->zfwctrl_addr),
3670 base_addr + readl(&fid->zfwctrl_addr));
3671
3672 nchan = readl(&pt_zfwctrl->board_ctrl.n_channel);
3673 dev_info(&pdev->dev, "Cyclades-Z FW loaded: version = %x, ports = %u\n",
3674 readl(&pt_zfwctrl->board_ctrl.fw_version), nchan);
3675
3676 if (nchan == 0) {
3677 dev_warn(&pdev->dev, "no Cyclades-Z ports were found. Please "
3678 "check the connection between the Z host card and the "
3679 "serial expanders.\n");
3680
3681 if (__cyz_fpga_loaded(ctl_addr))
3682 plx_init(pdev, irq, ctl_addr);
3683
3684 dev_info(&pdev->dev, "Null number of ports detected. Board "
3685 "reset.\n");
3686 retval = 0;
3687 goto err;
3688 }
3689
3690 cy_writel(&pt_zfwctrl->board_ctrl.op_system, C_OS_LINUX);
3691 cy_writel(&pt_zfwctrl->board_ctrl.dr_version, DRIVER_VERSION);
3692
3693
3694
3695
3696
3697 cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) |
3698 (1 << 17));
3699 cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) |
3700 0x00030800UL);
3701
3702 return nchan;
3703err_rel:
3704 release_firmware(fw);
3705err:
3706 return retval;
3707}
3708
3709static int __devinit cy_pci_probe(struct pci_dev *pdev,
3710 const struct pci_device_id *ent)
3711{
3712 void __iomem *addr0 = NULL, *addr2 = NULL;
3713 char *card_name = NULL;
3714 u32 uninitialized_var(mailbox);
3715 unsigned int device_id, nchan = 0, card_no, i;
3716 unsigned char plx_ver;
3717 int retval, irq;
3718
3719 retval = pci_enable_device(pdev);
3720 if (retval) {
3721 dev_err(&pdev->dev, "cannot enable device\n");
3722 goto err;
3723 }
3724
3725
3726 irq = pdev->irq;
3727 device_id = pdev->device & ~PCI_DEVICE_ID_MASK;
3728
3729#if defined(__alpha__)
3730 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo) {
3731 dev_err(&pdev->dev, "Cyclom-Y/PCI not supported for low "
3732 "addresses on Alpha systems.\n");
3733 retval = -EIO;
3734 goto err_dis;
3735 }
3736#endif
3737 if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Lo) {
3738 dev_err(&pdev->dev, "Cyclades-Z/PCI not supported for low "
3739 "addresses\n");
3740 retval = -EIO;
3741 goto err_dis;
3742 }
3743
3744 if (pci_resource_flags(pdev, 2) & IORESOURCE_IO) {
3745 dev_warn(&pdev->dev, "PCI I/O bit incorrectly set. Ignoring "
3746 "it...\n");
3747 pdev->resource[2].flags &= ~IORESOURCE_IO;
3748 }
3749
3750 retval = pci_request_regions(pdev, "cyclades");
3751 if (retval) {
3752 dev_err(&pdev->dev, "failed to reserve resources\n");
3753 goto err_dis;
3754 }
3755
3756 retval = -EIO;
3757 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3758 device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
3759 card_name = "Cyclom-Y";
3760
3761 addr0 = ioremap_nocache(pci_resource_start(pdev, 0),
3762 CyPCI_Yctl);
3763 if (addr0 == NULL) {
3764 dev_err(&pdev->dev, "can't remap ctl region\n");
3765 goto err_reg;
3766 }
3767 addr2 = ioremap_nocache(pci_resource_start(pdev, 2),
3768 CyPCI_Ywin);
3769 if (addr2 == NULL) {
3770 dev_err(&pdev->dev, "can't remap base region\n");
3771 goto err_unmap;
3772 }
3773
3774 nchan = CyPORTS_PER_CHIP * cyy_init_card(addr2, 1);
3775 if (nchan == 0) {
3776 dev_err(&pdev->dev, "Cyclom-Y PCI host card with no "
3777 "Serial-Modules\n");
3778 goto err_unmap;
3779 }
3780 } else if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Hi) {
3781 struct RUNTIME_9060 __iomem *ctl_addr;
3782
3783 ctl_addr = addr0 = ioremap_nocache(pci_resource_start(pdev, 0),
3784 CyPCI_Zctl);
3785 if (addr0 == NULL) {
3786 dev_err(&pdev->dev, "can't remap ctl region\n");
3787 goto err_reg;
3788 }
3789
3790
3791 cy_writew(&ctl_addr->intr_ctrl_stat,
3792 readw(&ctl_addr->intr_ctrl_stat) & ~0x0900);
3793
3794 plx_init(pdev, irq, addr0);
3795
3796 mailbox = readl(&ctl_addr->mail_box_0);
3797
3798 addr2 = ioremap_nocache(pci_resource_start(pdev, 2),
3799 mailbox == ZE_V1 ? CyPCI_Ze_win : CyPCI_Zwin);
3800 if (addr2 == NULL) {
3801 dev_err(&pdev->dev, "can't remap base region\n");
3802 goto err_unmap;
3803 }
3804
3805 if (mailbox == ZE_V1) {
3806 card_name = "Cyclades-Ze";
3807 } else {
3808 card_name = "Cyclades-8Zo";
3809#ifdef CY_PCI_DEBUG
3810 if (mailbox == ZO_V1) {
3811 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3812 dev_info(&pdev->dev, "Cyclades-8Zo/PCI: FPGA "
3813 "id %lx, ver %lx\n", (ulong)(0xff &
3814 readl(&((struct CUSTOM_REG *)addr2)->
3815 fpga_id)), (ulong)(0xff &
3816 readl(&((struct CUSTOM_REG *)addr2)->
3817 fpga_version)));
3818 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3819 } else {
3820 dev_info(&pdev->dev, "Cyclades-Z/PCI: New "
3821 "Cyclades-Z board. FPGA not loaded\n");
3822 }
3823#endif
3824
3825
3826
3827
3828 if ((mailbox == ZO_V1) || (mailbox == ZO_V2))
3829 cy_writel(addr2 + ID_ADDRESS, 0L);
3830 }
3831
3832 retval = cyz_load_fw(pdev, addr2, addr0, irq);
3833 if (retval <= 0)
3834 goto err_unmap;
3835 nchan = retval;
3836 }
3837
3838 if ((cy_next_channel + nchan) > NR_PORTS) {
3839 dev_err(&pdev->dev, "Cyclades-8Zo/PCI found, but no "
3840 "channels are available. Change NR_PORTS in "
3841 "cyclades.c and recompile kernel.\n");
3842 goto err_unmap;
3843 }
3844
3845 for (card_no = 0; card_no < NR_CARDS; card_no++) {
3846 if (cy_card[card_no].base_addr == NULL)
3847 break;
3848 }
3849 if (card_no == NR_CARDS) {
3850 dev_err(&pdev->dev, "Cyclades-8Zo/PCI found, but no "
3851 "more cards can be used. Change NR_CARDS in "
3852 "cyclades.c and recompile kernel.\n");
3853 goto err_unmap;
3854 }
3855
3856 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3857 device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
3858
3859 retval = request_irq(irq, cyy_interrupt,
3860 IRQF_SHARED, "Cyclom-Y", &cy_card[card_no]);
3861 if (retval) {
3862 dev_err(&pdev->dev, "could not allocate IRQ\n");
3863 goto err_unmap;
3864 }
3865 cy_card[card_no].num_chips = nchan / CyPORTS_PER_CHIP;
3866 } else {
3867 struct FIRM_ID __iomem *firm_id = addr2 + ID_ADDRESS;
3868 struct ZFW_CTRL __iomem *zfw_ctrl;
3869
3870 zfw_ctrl = addr2 + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
3871
3872 cy_card[card_no].hw_ver = mailbox;
3873 cy_card[card_no].num_chips = (unsigned int)-1;
3874 cy_card[card_no].board_ctrl = &zfw_ctrl->board_ctrl;
3875#ifdef CONFIG_CYZ_INTR
3876
3877 if (irq != 0 && irq != 255) {
3878 retval = request_irq(irq, cyz_interrupt,
3879 IRQF_SHARED, "Cyclades-Z",
3880 &cy_card[card_no]);
3881 if (retval) {
3882 dev_err(&pdev->dev, "could not allocate IRQ\n");
3883 goto err_unmap;
3884 }
3885 }
3886#endif
3887 }
3888
3889
3890 cy_card[card_no].base_addr = addr2;
3891 cy_card[card_no].ctl_addr.p9050 = addr0;
3892 cy_card[card_no].irq = irq;
3893 cy_card[card_no].bus_index = 1;
3894 cy_card[card_no].first_line = cy_next_channel;
3895 cy_card[card_no].nports = nchan;
3896 retval = cy_init_card(&cy_card[card_no]);
3897 if (retval)
3898 goto err_null;
3899
3900 pci_set_drvdata(pdev, &cy_card[card_no]);
3901
3902 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3903 device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
3904
3905 plx_ver = readb(addr2 + CyPLX_VER) & 0x0f;
3906 switch (plx_ver) {
3907 case PLX_9050:
3908 cy_writeb(addr0 + 0x4c, 0x43);
3909 break;
3910
3911 case PLX_9060:
3912 case PLX_9080:
3913 default:
3914 {
3915 struct RUNTIME_9060 __iomem *ctl_addr = addr0;
3916 plx_init(pdev, irq, ctl_addr);
3917 cy_writew(&ctl_addr->intr_ctrl_stat,
3918 readw(&ctl_addr->intr_ctrl_stat) | 0x0900);
3919 break;
3920 }
3921 }
3922 }
3923
3924 dev_info(&pdev->dev, "%s/PCI #%d found: %d channels starting from "
3925 "port %d.\n", card_name, card_no + 1, nchan, cy_next_channel);
3926 for (i = cy_next_channel; i < cy_next_channel + nchan; i++)
3927 tty_register_device(cy_serial_driver, i, &pdev->dev);
3928 cy_next_channel += nchan;
3929
3930 return 0;
3931err_null:
3932 cy_card[card_no].base_addr = NULL;
3933 free_irq(irq, &cy_card[card_no]);
3934err_unmap:
3935 iounmap(addr0);
3936 if (addr2)
3937 iounmap(addr2);
3938err_reg:
3939 pci_release_regions(pdev);
3940err_dis:
3941 pci_disable_device(pdev);
3942err:
3943 return retval;
3944}
3945
3946static void __devexit cy_pci_remove(struct pci_dev *pdev)
3947{
3948 struct cyclades_card *cinfo = pci_get_drvdata(pdev);
3949 unsigned int i;
3950
3951
3952 if (!cy_is_Z(cinfo) && (readb(cinfo->base_addr + CyPLX_VER) & 0x0f) ==
3953 PLX_9050)
3954 cy_writeb(cinfo->ctl_addr.p9050 + 0x4c, 0);
3955 else
3956#ifndef CONFIG_CYZ_INTR
3957 if (!cy_is_Z(cinfo))
3958#endif
3959 cy_writew(&cinfo->ctl_addr.p9060->intr_ctrl_stat,
3960 readw(&cinfo->ctl_addr.p9060->intr_ctrl_stat) &
3961 ~0x0900);
3962
3963 iounmap(cinfo->base_addr);
3964 if (cinfo->ctl_addr.p9050)
3965 iounmap(cinfo->ctl_addr.p9050);
3966 if (cinfo->irq
3967#ifndef CONFIG_CYZ_INTR
3968 && !cy_is_Z(cinfo)
3969#endif
3970 )
3971 free_irq(cinfo->irq, cinfo);
3972 pci_release_regions(pdev);
3973
3974 cinfo->base_addr = NULL;
3975 for (i = cinfo->first_line; i < cinfo->first_line +
3976 cinfo->nports; i++)
3977 tty_unregister_device(cy_serial_driver, i);
3978 cinfo->nports = 0;
3979 kfree(cinfo->ports);
3980}
3981
3982static struct pci_driver cy_pci_driver = {
3983 .name = "cyclades",
3984 .id_table = cy_pci_dev_id,
3985 .probe = cy_pci_probe,
3986 .remove = __devexit_p(cy_pci_remove)
3987};
3988#endif
3989
3990static int cyclades_proc_show(struct seq_file *m, void *v)
3991{
3992 struct cyclades_port *info;
3993 unsigned int i, j;
3994 __u32 cur_jifs = jiffies;
3995
3996 seq_puts(m, "Dev TimeOpen BytesOut IdleOut BytesIn "
3997 "IdleIn Overruns Ldisc\n");
3998
3999
4000 for (i = 0; i < NR_CARDS; i++)
4001 for (j = 0; j < cy_card[i].nports; j++) {
4002 info = &cy_card[i].ports[j];
4003
4004 if (info->port.count) {
4005
4006 struct tty_struct *tty;
4007 struct tty_ldisc *ld;
4008 int num = 0;
4009 tty = tty_port_tty_get(&info->port);
4010 if (tty) {
4011 ld = tty_ldisc_ref(tty);
4012 if (ld) {
4013 num = ld->ops->num;
4014 tty_ldisc_deref(ld);
4015 }
4016 tty_kref_put(tty);
4017 }
4018 seq_printf(m, "%3d %8lu %10lu %8lu "
4019 "%10lu %8lu %9lu %6d\n", info->line,
4020 (cur_jifs - info->idle_stats.in_use) /
4021 HZ, info->idle_stats.xmit_bytes,
4022 (cur_jifs - info->idle_stats.xmit_idle)/
4023 HZ, info->idle_stats.recv_bytes,
4024 (cur_jifs - info->idle_stats.recv_idle)/
4025 HZ, info->idle_stats.overruns,
4026 num);
4027 } else
4028 seq_printf(m, "%3d %8lu %10lu %8lu "
4029 "%10lu %8lu %9lu %6ld\n",
4030 info->line, 0L, 0L, 0L, 0L, 0L, 0L, 0L);
4031 }
4032 return 0;
4033}
4034
4035static int cyclades_proc_open(struct inode *inode, struct file *file)
4036{
4037 return single_open(file, cyclades_proc_show, NULL);
4038}
4039
4040static const struct file_operations cyclades_proc_fops = {
4041 .owner = THIS_MODULE,
4042 .open = cyclades_proc_open,
4043 .read = seq_read,
4044 .llseek = seq_lseek,
4045 .release = single_release,
4046};
4047
4048
4049
4050
4051
4052
4053
4054
4055
4056
4057
4058
4059
4060
4061
4062
4063
4064
4065
4066static const struct tty_operations cy_ops = {
4067 .open = cy_open,
4068 .close = cy_close,
4069 .write = cy_write,
4070 .put_char = cy_put_char,
4071 .flush_chars = cy_flush_chars,
4072 .write_room = cy_write_room,
4073 .chars_in_buffer = cy_chars_in_buffer,
4074 .flush_buffer = cy_flush_buffer,
4075 .ioctl = cy_ioctl,
4076 .throttle = cy_throttle,
4077 .unthrottle = cy_unthrottle,
4078 .set_termios = cy_set_termios,
4079 .stop = cy_stop,
4080 .start = cy_start,
4081 .hangup = cy_hangup,
4082 .break_ctl = cy_break,
4083 .wait_until_sent = cy_wait_until_sent,
4084 .tiocmget = cy_tiocmget,
4085 .tiocmset = cy_tiocmset,
4086 .get_icount = cy_get_icount,
4087 .proc_fops = &cyclades_proc_fops,
4088};
4089
4090static int __init cy_init(void)
4091{
4092 unsigned int nboards;
4093 int retval = -ENOMEM;
4094
4095 cy_serial_driver = alloc_tty_driver(NR_PORTS);
4096 if (!cy_serial_driver)
4097 goto err;
4098
4099 printk(KERN_INFO "Cyclades driver " CY_VERSION "\n");
4100
4101
4102
4103 cy_serial_driver->owner = THIS_MODULE;
4104 cy_serial_driver->driver_name = "cyclades";
4105 cy_serial_driver->name = "ttyC";
4106 cy_serial_driver->major = CYCLADES_MAJOR;
4107 cy_serial_driver->minor_start = 0;
4108 cy_serial_driver->type = TTY_DRIVER_TYPE_SERIAL;
4109 cy_serial_driver->subtype = SERIAL_TYPE_NORMAL;
4110 cy_serial_driver->init_termios = tty_std_termios;
4111 cy_serial_driver->init_termios.c_cflag =
4112 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
4113 cy_serial_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
4114 tty_set_operations(cy_serial_driver, &cy_ops);
4115
4116 retval = tty_register_driver(cy_serial_driver);
4117 if (retval) {
4118 printk(KERN_ERR "Couldn't register Cyclades serial driver\n");
4119 goto err_frtty;
4120 }
4121
4122
4123
4124
4125
4126
4127
4128
4129
4130 nboards = cy_detect_isa();
4131
4132#ifdef CONFIG_PCI
4133
4134 retval = pci_register_driver(&cy_pci_driver);
4135 if (retval && !nboards) {
4136 tty_unregister_driver(cy_serial_driver);
4137 goto err_frtty;
4138 }
4139#endif
4140
4141 return 0;
4142err_frtty:
4143 put_tty_driver(cy_serial_driver);
4144err:
4145 return retval;
4146}
4147
4148static void __exit cy_cleanup_module(void)
4149{
4150 struct cyclades_card *card;
4151 unsigned int i, e1;
4152
4153#ifndef CONFIG_CYZ_INTR
4154 del_timer_sync(&cyz_timerlist);
4155#endif
4156
4157 e1 = tty_unregister_driver(cy_serial_driver);
4158 if (e1)
4159 printk(KERN_ERR "failed to unregister Cyclades serial "
4160 "driver(%d)\n", e1);
4161
4162#ifdef CONFIG_PCI
4163 pci_unregister_driver(&cy_pci_driver);
4164#endif
4165
4166 for (i = 0; i < NR_CARDS; i++) {
4167 card = &cy_card[i];
4168 if (card->base_addr) {
4169
4170 cy_writeb(card->base_addr + Cy_ClrIntr, 0);
4171 iounmap(card->base_addr);
4172 if (card->ctl_addr.p9050)
4173 iounmap(card->ctl_addr.p9050);
4174 if (card->irq
4175#ifndef CONFIG_CYZ_INTR
4176 && !cy_is_Z(card)
4177#endif
4178 )
4179 free_irq(card->irq, card);
4180 for (e1 = card->first_line; e1 < card->first_line +
4181 card->nports; e1++)
4182 tty_unregister_device(cy_serial_driver, e1);
4183 kfree(card->ports);
4184 }
4185 }
4186
4187 put_tty_driver(cy_serial_driver);
4188}
4189
4190module_init(cy_init);
4191module_exit(cy_cleanup_module);
4192
4193MODULE_LICENSE("GPL");
4194MODULE_VERSION(CY_VERSION);
4195MODULE_ALIAS_CHARDEV_MAJOR(CYCLADES_MAJOR);
4196MODULE_FIRMWARE("cyzfirm.bin");
4197