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