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