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