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