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