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