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