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