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