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