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