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