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