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