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