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