projects / deliverable / linux.git / blob
? search:


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