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