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