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