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