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