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