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