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