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