blob: 4254457d391186429590769d05334d01c459bd75 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001#undef BLOCKMOVE
2#define Z_WAKE
3#undef Z_EXT_CHARS_IN_BUFFER
Linus Torvalds1da177e2005-04-16 15:20:36 -07004
5/*
6 * linux/drivers/char/cyclades.c
7 *
8 * This file contains the driver for the Cyclades async multiport
9 * serial boards.
10 *
11 * Initially written by Randolph Bentson <bentson@grieg.seaslug.org>.
12 * Modified and maintained by Marcio Saito <marcio@cyclades.com>.
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 *
Jiri Slabyebdb5132009-09-19 13:13:14 -070014 * Copyright (C) 2007-2009 Jiri Slaby <jirislaby@gmail.com>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015 *
16 * Much of the design and some of the code came from serial.c
17 * which was copyright (C) 1991, 1992 Linus Torvalds. It was
18 * extensively rewritten by Theodore Ts'o, 8/16/92 -- 9/14/92,
19 * and then fixed as suggested by Michael K. Johnson 12/12/92.
Jiri Slabyc8e16932007-05-08 00:37:05 -070020 * Converted to pci probing and cleaned up by Jiri Slaby.
Linus Torvalds1da177e2005-04-16 15:20:36 -070021 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070022 */
23
Jiri Slabyebdb5132009-09-19 13:13:14 -070024#define CY_VERSION "2.6"
Jiri Slaby096dcfc2006-12-08 02:39:30 -080025
Linus Torvalds1da177e2005-04-16 15:20:36 -070026/* If you need to install more boards than NR_CARDS, change the constant
27 in the definition below. No other change is necessary to support up to
28 eight boards. Beyond that you'll have to extend cy_isa_addresses. */
29
Jiri Slaby02f11752006-12-08 02:39:28 -080030#define NR_CARDS 4
Linus Torvalds1da177e2005-04-16 15:20:36 -070031
32/*
33 If the total number of ports is larger than NR_PORTS, change this
34 constant in the definition below. No other change is necessary to
35 support more boards/ports. */
36
Jiri Slaby02f11752006-12-08 02:39:28 -080037#define NR_PORTS 256
Linus Torvalds1da177e2005-04-16 15:20:36 -070038
Linus Torvalds1da177e2005-04-16 15:20:36 -070039#define ZO_V1 0
40#define ZO_V2 1
41#define ZE_V1 2
42
43#define SERIAL_PARANOIA_CHECK
44#undef CY_DEBUG_OPEN
45#undef CY_DEBUG_THROTTLE
46#undef CY_DEBUG_OTHER
47#undef CY_DEBUG_IO
48#undef CY_DEBUG_COUNT
49#undef CY_DEBUG_DTR
50#undef CY_DEBUG_WAIT_UNTIL_SENT
51#undef CY_DEBUG_INTERRUPTS
52#undef CY_16Y_HACK
53#undef CY_ENABLE_MONITORING
54#undef CY_PCI_DEBUG
55
Linus Torvalds1da177e2005-04-16 15:20:36 -070056/*
Alan Cox15ed6cc2008-04-30 00:53:55 -070057 * Include section
Linus Torvalds1da177e2005-04-16 15:20:36 -070058 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070059#include <linux/module.h>
60#include <linux/errno.h>
61#include <linux/signal.h>
62#include <linux/sched.h>
63#include <linux/timer.h>
64#include <linux/interrupt.h>
65#include <linux/tty.h>
Alan Cox33f0f882006-01-09 20:54:13 -080066#include <linux/tty_flip.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070067#include <linux/serial.h>
Alexey Dobriyan405f5572009-07-11 22:08:37 +040068#include <linux/smp_lock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070069#include <linux/major.h>
70#include <linux/string.h>
71#include <linux/fcntl.h>
72#include <linux/ptrace.h>
73#include <linux/cyclades.h>
74#include <linux/mm.h>
75#include <linux/ioport.h>
76#include <linux/init.h>
77#include <linux/delay.h>
78#include <linux/spinlock.h>
79#include <linux/bitops.h>
Jiri Slaby054f5b02007-07-17 04:05:16 -070080#include <linux/firmware.h>
Scott James Remnant9f56fad72009-04-06 17:33:04 +010081#include <linux/device.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070082
Alan Cox15ed6cc2008-04-30 00:53:55 -070083#include <linux/io.h>
Alan Cox15ed6cc2008-04-30 00:53:55 -070084#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070085
Linus Torvalds1da177e2005-04-16 15:20:36 -070086#include <linux/kernel.h>
87#include <linux/pci.h>
88
89#include <linux/stat.h>
90#include <linux/proc_fs.h>
Alexey Dobriyan444697d2009-03-31 15:19:15 -070091#include <linux/seq_file.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070092
Jiri Slaby02f11752006-12-08 02:39:28 -080093static void cy_send_xchar(struct tty_struct *tty, char ch);
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
Linus Torvalds1da177e2005-04-16 15:20:36 -070095#ifndef SERIAL_XMIT_SIZE
96#define SERIAL_XMIT_SIZE (min(PAGE_SIZE, 4096))
97#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070098
99#define STD_COM_FLAGS (0)
100
Jiri Slaby054f5b02007-07-17 04:05:16 -0700101/* firmware stuff */
102#define ZL_MAX_BLOCKS 16
103#define DRIVER_VERSION 0x02010203
104#define RAM_SIZE 0x80000
105
Jiri Slaby054f5b02007-07-17 04:05:16 -0700106enum zblock_type {
107 ZBLOCK_PRG = 0,
108 ZBLOCK_FPGA = 1
109};
110
111struct zfile_header {
112 char name[64];
113 char date[32];
114 char aux[32];
115 u32 n_config;
116 u32 config_offset;
117 u32 n_blocks;
118 u32 block_offset;
119 u32 reserved[9];
120} __attribute__ ((packed));
121
122struct zfile_config {
123 char name[64];
124 u32 mailbox;
125 u32 function;
126 u32 n_blocks;
127 u32 block_list[ZL_MAX_BLOCKS];
128} __attribute__ ((packed));
129
130struct zfile_block {
131 u32 type;
132 u32 file_offset;
133 u32 ram_offset;
134 u32 size;
135} __attribute__ ((packed));
136
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137static struct tty_driver *cy_serial_driver;
138
139#ifdef CONFIG_ISA
140/* This is the address lookup table. The driver will probe for
141 Cyclom-Y/ISA boards at all addresses in here. If you want the
142 driver to probe addresses at a different address, add it to
143 this table. If the driver is probing some other board and
144 causing problems, remove the offending address from this table.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145*/
146
147static unsigned int cy_isa_addresses[] = {
Jiri Slaby02f11752006-12-08 02:39:28 -0800148 0xD0000,
149 0xD2000,
150 0xD4000,
151 0xD6000,
152 0xD8000,
153 0xDA000,
154 0xDC000,
155 0xDE000,
156 0, 0, 0, 0, 0, 0, 0, 0
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157};
Jiri Slaby02f11752006-12-08 02:39:28 -0800158
Tobias Klauserfe971072006-01-09 20:54:02 -0800159#define NR_ISA_ADDRS ARRAY_SIZE(cy_isa_addresses)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160
161#ifdef MODULE
Jiri Slaby3046d502007-05-08 00:36:46 -0700162static long maddr[NR_CARDS];
163static int irq[NR_CARDS];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164
165module_param_array(maddr, long, NULL, 0);
166module_param_array(irq, int, NULL, 0);
167#endif
168
Jiri Slaby02f11752006-12-08 02:39:28 -0800169#endif /* CONFIG_ISA */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170
171/* This is the per-card data structure containing address, irq, number of
172 channels, etc. This driver supports a maximum of NR_CARDS cards.
173*/
174static struct cyclades_card cy_card[NR_CARDS];
175
Jiri Slaby02f11752006-12-08 02:39:28 -0800176static int cy_next_channel; /* next minor available */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177
178/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 * This is used to look up the divisor speeds and the timeouts
180 * We're normally limited to 15 distinct baud rates. The extra
Alan Cox77451e52008-07-16 21:57:02 +0100181 * are accessed via settings in info->port.flags.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 * 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
183 * 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
184 * HI VHI
185 * 20
186 */
Jiri Slabyebdb5132009-09-19 13:13:14 -0700187static const int baud_table[] = {
Jiri Slaby02f11752006-12-08 02:39:28 -0800188 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
189 1800, 2400, 4800, 9600, 19200, 38400, 57600, 76800, 115200, 150000,
190 230400, 0
191};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192
Jiri Slabyebdb5132009-09-19 13:13:14 -0700193static const char baud_co_25[] = { /* 25 MHz clock option table */
Jiri Slaby02f11752006-12-08 02:39:28 -0800194 /* value => 00 01 02 03 04 */
195 /* divide by 8 32 128 512 2048 */
196 0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x02,
197 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
198};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199
Jiri Slabyebdb5132009-09-19 13:13:14 -0700200static const char baud_bpr_25[] = { /* 25 MHz baud rate period table */
Jiri Slaby02f11752006-12-08 02:39:28 -0800201 0x00, 0xf5, 0xa3, 0x6f, 0x5c, 0x51, 0xf5, 0xa3, 0x51, 0xa3,
202 0x6d, 0x51, 0xa3, 0x51, 0xa3, 0x51, 0x36, 0x29, 0x1b, 0x15
203};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204
Jiri Slabyebdb5132009-09-19 13:13:14 -0700205static const char baud_co_60[] = { /* 60 MHz clock option table (CD1400 J) */
Jiri Slaby02f11752006-12-08 02:39:28 -0800206 /* value => 00 01 02 03 04 */
207 /* divide by 8 32 128 512 2048 */
208 0x00, 0x00, 0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03,
209 0x03, 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
210 0x00
211};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212
Jiri Slabyebdb5132009-09-19 13:13:14 -0700213static const char baud_bpr_60[] = { /* 60 MHz baud rate period table (CD1400 J) */
Jiri Slaby02f11752006-12-08 02:39:28 -0800214 0x00, 0x82, 0x21, 0xff, 0xdb, 0xc3, 0x92, 0x62, 0xc3, 0x62,
215 0x41, 0xc3, 0x62, 0xc3, 0x62, 0xc3, 0x82, 0x62, 0x41, 0x32,
216 0x21
217};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218
Jiri Slabyebdb5132009-09-19 13:13:14 -0700219static const char baud_cor3[] = { /* receive threshold */
Jiri Slaby02f11752006-12-08 02:39:28 -0800220 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
221 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x07,
222 0x07
223};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224
225/*
226 * The Cyclades driver implements HW flow control as any serial driver.
Alan Cox15ed6cc2008-04-30 00:53:55 -0700227 * The cyclades_port structure member rflow and the vector rflow_thr
228 * allows us to take advantage of a special feature in the CD1400 to avoid
229 * data loss even when the system interrupt latency is too high. These flags
230 * are to be used only with very special applications. Setting these flags
231 * requires the use of a special cable (DTR and RTS reversed). In the new
232 * CD1400-based boards (rev. 6.00 or later), there is no need for special
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 * cables.
234 */
235
Jiri Slabyebdb5132009-09-19 13:13:14 -0700236static const char rflow_thr[] = { /* rflow threshold */
Jiri Slaby02f11752006-12-08 02:39:28 -0800237 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
238 0x00, 0x00, 0x00, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
239 0x0a
240};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241
242/* The Cyclom-Ye has placed the sequential chips in non-sequential
243 * address order. This look-up table overcomes that problem.
244 */
Jiri Slabyf0eefdc2009-09-19 13:13:13 -0700245static const unsigned int cy_chip_offset[] = { 0x0000,
Jiri Slaby02f11752006-12-08 02:39:28 -0800246 0x0400,
247 0x0800,
248 0x0C00,
249 0x0200,
250 0x0600,
251 0x0A00,
252 0x0E00
253};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254
255/* PCI related definitions */
256
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257#ifdef CONFIG_PCI
Jiri Slabyebdb5132009-09-19 13:13:14 -0700258static const struct pci_device_id cy_pci_dev_id[] = {
Alan Cox15ed6cc2008-04-30 00:53:55 -0700259 /* PCI < 1Mb */
260 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Y_Lo) },
261 /* PCI > 1Mb */
262 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Y_Hi) },
263 /* 4Y PCI < 1Mb */
264 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_4Y_Lo) },
265 /* 4Y PCI > 1Mb */
266 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_4Y_Hi) },
267 /* 8Y PCI < 1Mb */
268 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_8Y_Lo) },
269 /* 8Y PCI > 1Mb */
270 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_8Y_Hi) },
271 /* Z PCI < 1Mb */
272 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Z_Lo) },
273 /* Z PCI > 1Mb */
274 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Z_Hi) },
Jiri Slaby893de2d2007-02-12 00:51:49 -0800275 { } /* end of table */
Jiri Slaby02f11752006-12-08 02:39:28 -0800276};
Jiri Slaby893de2d2007-02-12 00:51:49 -0800277MODULE_DEVICE_TABLE(pci, cy_pci_dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278#endif
279
280static void cy_start(struct tty_struct *);
Jiri Slabyd13549f2009-09-19 13:13:12 -0700281static void cy_set_line_char(struct cyclades_port *, struct tty_struct *);
Klaus Kudielka1a86b5e2007-05-08 00:26:26 -0700282static int cyz_issue_cmd(struct cyclades_card *, __u32, __u8, __u32);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283#ifdef CONFIG_ISA
284static unsigned detect_isa_irq(void __iomem *);
Jiri Slaby02f11752006-12-08 02:39:28 -0800285#endif /* CONFIG_ISA */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287#ifndef CONFIG_CYZ_INTR
288static void cyz_poll(unsigned long);
289
290/* The Cyclades-Z polling cycle is defined by this variable */
291static long cyz_polling_cycle = CZ_DEF_POLL;
292
Ingo Molnar8d06afa2005-09-09 13:10:40 -0700293static DEFINE_TIMER(cyz_timerlist, cyz_poll, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294
Jiri Slaby02f11752006-12-08 02:39:28 -0800295#else /* CONFIG_CYZ_INTR */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296static void cyz_rx_restart(unsigned long);
297static struct timer_list cyz_rx_full_timer[NR_PORTS];
Jiri Slaby02f11752006-12-08 02:39:28 -0800298#endif /* CONFIG_CYZ_INTR */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700300static inline void cyy_writeb(struct cyclades_port *port, u32 reg, u8 val)
301{
302 struct cyclades_card *card = port->card;
303
304 cy_writeb(port->u.cyy.base_addr + (reg << card->bus_index), val);
305}
306
307static inline u8 cyy_readb(struct cyclades_port *port, u32 reg)
308{
309 struct cyclades_card *card = port->card;
310
311 return readb(port->u.cyy.base_addr + (reg << card->bus_index));
312}
313
Jiri Slaby2693f482009-06-11 12:31:06 +0100314static inline bool cy_is_Z(struct cyclades_card *card)
315{
316 return card->num_chips == (unsigned int)-1;
317}
318
319static inline bool __cyz_fpga_loaded(struct RUNTIME_9060 __iomem *ctl_addr)
320{
321 return readl(&ctl_addr->init_ctrl) & (1 << 17);
322}
323
324static inline bool cyz_fpga_loaded(struct cyclades_card *card)
325{
326 return __cyz_fpga_loaded(card->ctl_addr.p9060);
327}
328
329static inline bool cyz_is_loaded(struct cyclades_card *card)
330{
331 struct FIRM_ID __iomem *fw_id = card->base_addr + ID_ADDRESS;
332
333 return (card->hw_ver == ZO_V1 || cyz_fpga_loaded(card)) &&
334 readl(&fw_id->signature) == ZFIRM_ID;
335}
336
Jiri Slaby02f11752006-12-08 02:39:28 -0800337static inline int serial_paranoia_check(struct cyclades_port *info,
Jiri Slabyebdb5132009-09-19 13:13:14 -0700338 const char *name, const char *routine)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339{
340#ifdef SERIAL_PARANOIA_CHECK
Jiri Slaby02f11752006-12-08 02:39:28 -0800341 if (!info) {
Jiri Slaby21719192007-05-08 00:36:42 -0700342 printk(KERN_WARNING "cyc Warning: null cyclades_port for (%s) "
343 "in %s\n", name, routine);
Jiri Slaby02f11752006-12-08 02:39:28 -0800344 return 1;
345 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346
Jiri Slaby02f11752006-12-08 02:39:28 -0800347 if (info->magic != CYCLADES_MAGIC) {
Jiri Slaby21719192007-05-08 00:36:42 -0700348 printk(KERN_WARNING "cyc Warning: bad magic number for serial "
349 "struct (%s) in %s\n", name, routine);
Jiri Slaby02f11752006-12-08 02:39:28 -0800350 return 1;
351 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352#endif
Jiri Slaby02f11752006-12-08 02:39:28 -0800353 return 0;
Jiri Slabyebdb5132009-09-19 13:13:14 -0700354}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356/***********************************************************/
357/********* Start of block of Cyclom-Y specific code ********/
358
359/* This routine waits up to 1000 micro-seconds for the previous
360 command to the Cirrus chip to complete and then issues the
361 new command. An error is returned if the previous command
362 didn't finish within the time limit.
363
364 This function is only called from inside spinlock-protected code.
365 */
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700366static int __cyy_issue_cmd(void __iomem *base_addr, u8 cmd, int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367{
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700368 void __iomem *ccr = base_addr + (CyCCR << index);
Jiri Slabyad39c302007-05-08 00:35:49 -0700369 unsigned int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370
Jiri Slaby02f11752006-12-08 02:39:28 -0800371 /* Check to see that the previous command has completed */
372 for (i = 0; i < 100; i++) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700373 if (readb(ccr) == 0)
Jiri Slaby02f11752006-12-08 02:39:28 -0800374 break;
Jiri Slaby02f11752006-12-08 02:39:28 -0800375 udelay(10L);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 }
Jiri Slaby02f11752006-12-08 02:39:28 -0800377 /* if the CCR never cleared, the previous command
378 didn't finish within the "reasonable time" */
379 if (i == 100)
Jiri Slaby096dcfc2006-12-08 02:39:30 -0800380 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381
Jiri Slaby02f11752006-12-08 02:39:28 -0800382 /* Issue the new command */
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700383 cy_writeb(ccr, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384
Jiri Slaby096dcfc2006-12-08 02:39:30 -0800385 return 0;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700386}
387
388static inline int cyy_issue_cmd(struct cyclades_port *port, u8 cmd)
389{
390 return __cyy_issue_cmd(port->u.cyy.base_addr, cmd,
391 port->card->bus_index);
392}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393
394#ifdef CONFIG_ISA
395/* ISA interrupt detection code */
Alan Cox15ed6cc2008-04-30 00:53:55 -0700396static unsigned detect_isa_irq(void __iomem *address)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397{
Jiri Slaby02f11752006-12-08 02:39:28 -0800398 int irq;
399 unsigned long irqs, flags;
400 int save_xir, save_car;
401 int index = 0; /* IRQ probing is only for ISA */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402
Jiri Slaby02f11752006-12-08 02:39:28 -0800403 /* forget possible initially masked and pending IRQ */
404 irq = probe_irq_off(probe_irq_on());
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405
Jiri Slaby02f11752006-12-08 02:39:28 -0800406 /* Clear interrupts on the board first */
407 cy_writeb(address + (Cy_ClrIntr << index), 0);
408 /* Cy_ClrIntr is 0x1800 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409
Jiri Slaby02f11752006-12-08 02:39:28 -0800410 irqs = probe_irq_on();
411 /* Wait ... */
Jiri Slabyf6e208c2009-09-19 13:13:14 -0700412 msleep(5);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413
Jiri Slaby02f11752006-12-08 02:39:28 -0800414 /* Enable the Tx interrupts on the CD1400 */
415 local_irq_save(flags);
416 cy_writeb(address + (CyCAR << index), 0);
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700417 __cyy_issue_cmd(address, CyCHAN_CTL | CyENB_XMTR, index);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418
Jiri Slaby02f11752006-12-08 02:39:28 -0800419 cy_writeb(address + (CyCAR << index), 0);
420 cy_writeb(address + (CySRER << index),
Jiri Slabydb05c3b2007-05-08 00:35:46 -0700421 readb(address + (CySRER << index)) | CyTxRdy);
Jiri Slaby02f11752006-12-08 02:39:28 -0800422 local_irq_restore(flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423
Jiri Slaby02f11752006-12-08 02:39:28 -0800424 /* Wait ... */
Jiri Slabyf6e208c2009-09-19 13:13:14 -0700425 msleep(5);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426
Jiri Slaby02f11752006-12-08 02:39:28 -0800427 /* Check which interrupt is in use */
428 irq = probe_irq_off(irqs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429
Jiri Slaby02f11752006-12-08 02:39:28 -0800430 /* Clean up */
Jiri Slabydb05c3b2007-05-08 00:35:46 -0700431 save_xir = (u_char) readb(address + (CyTIR << index));
432 save_car = readb(address + (CyCAR << index));
Jiri Slaby02f11752006-12-08 02:39:28 -0800433 cy_writeb(address + (CyCAR << index), (save_xir & 0x3));
434 cy_writeb(address + (CySRER << index),
Jiri Slabydb05c3b2007-05-08 00:35:46 -0700435 readb(address + (CySRER << index)) & ~CyTxRdy);
Jiri Slaby02f11752006-12-08 02:39:28 -0800436 cy_writeb(address + (CyTIR << index), (save_xir & 0x3f));
437 cy_writeb(address + (CyCAR << index), (save_car));
438 cy_writeb(address + (Cy_ClrIntr << index), 0);
439 /* Cy_ClrIntr is 0x1800 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440
Jiri Slaby02f11752006-12-08 02:39:28 -0800441 return (irq > 0) ? irq : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442}
Jiri Slaby02f11752006-12-08 02:39:28 -0800443#endif /* CONFIG_ISA */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444
Jiri Slabyce97a092007-10-18 03:06:21 -0700445static void cyy_chip_rx(struct cyclades_card *cinfo, int chip,
446 void __iomem *base_addr)
Jiri Slabye9410272006-12-08 02:39:28 -0800447{
448 struct cyclades_port *info;
449 struct tty_struct *tty;
Jiri Slaby65f76a82007-10-18 03:06:22 -0700450 int len, index = cinfo->bus_index;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700451 u8 ivr, save_xir, channel, save_car, data, char_count;
Jiri Slabye9410272006-12-08 02:39:28 -0800452
Jiri Slabye9410272006-12-08 02:39:28 -0800453#ifdef CY_DEBUG_INTERRUPTS
Jiri Slabyce97a092007-10-18 03:06:21 -0700454 printk(KERN_DEBUG "cyy_interrupt: rcvd intr, chip %d\n", chip);
Jiri Slabye9410272006-12-08 02:39:28 -0800455#endif
Jiri Slabyce97a092007-10-18 03:06:21 -0700456 /* determine the channel & change to that context */
Jiri Slaby65f76a82007-10-18 03:06:22 -0700457 save_xir = readb(base_addr + (CyRIR << index));
458 channel = save_xir & CyIRChannel;
Jiri Slabyce97a092007-10-18 03:06:21 -0700459 info = &cinfo->ports[channel + chip * 4];
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700460 save_car = cyy_readb(info, CyCAR);
461 cyy_writeb(info, CyCAR, save_xir);
462 ivr = cyy_readb(info, CyRIVR) & CyIVRMask;
Jiri Slabye9410272006-12-08 02:39:28 -0800463
Jiri Slabyd13549f2009-09-19 13:13:12 -0700464 tty = tty_port_tty_get(&info->port);
Jiri Slabyce97a092007-10-18 03:06:21 -0700465 /* if there is nowhere to put the data, discard it */
Jiri Slabyd13549f2009-09-19 13:13:12 -0700466 if (tty == NULL) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700467 if (ivr == CyIVRRxEx) { /* exception */
468 data = cyy_readb(info, CyRDSR);
Jiri Slabyce97a092007-10-18 03:06:21 -0700469 } else { /* normal character reception */
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700470 char_count = cyy_readb(info, CyRDCR);
Jiri Slabyce97a092007-10-18 03:06:21 -0700471 while (char_count--)
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700472 data = cyy_readb(info, CyRDSR);
Jiri Slabyce97a092007-10-18 03:06:21 -0700473 }
474 goto end;
475 }
476 /* there is an open port for this data */
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700477 if (ivr == CyIVRRxEx) { /* exception */
478 data = cyy_readb(info, CyRDSR);
Jiri Slaby02f11752006-12-08 02:39:28 -0800479
Jiri Slabyce97a092007-10-18 03:06:21 -0700480 /* For statistics only */
481 if (data & CyBREAK)
482 info->icount.brk++;
483 else if (data & CyFRAME)
484 info->icount.frame++;
485 else if (data & CyPARITY)
486 info->icount.parity++;
487 else if (data & CyOVERRUN)
488 info->icount.overrun++;
Jiri Slaby02f11752006-12-08 02:39:28 -0800489
Jiri Slabyce97a092007-10-18 03:06:21 -0700490 if (data & info->ignore_status_mask) {
491 info->icount.rx++;
Jiri Slabyd13549f2009-09-19 13:13:12 -0700492 tty_kref_put(tty);
Jiri Slabyce97a092007-10-18 03:06:21 -0700493 return;
494 }
495 if (tty_buffer_request_room(tty, 1)) {
496 if (data & info->read_status_mask) {
497 if (data & CyBREAK) {
498 tty_insert_flip_char(tty,
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700499 cyy_readb(info, CyRDSR),
500 TTY_BREAK);
Jiri Slaby02f11752006-12-08 02:39:28 -0800501 info->icount.rx++;
Alan Cox77451e52008-07-16 21:57:02 +0100502 if (info->port.flags & ASYNC_SAK)
Jiri Slabyce97a092007-10-18 03:06:21 -0700503 do_SAK(tty);
504 } else if (data & CyFRAME) {
Alan Cox15ed6cc2008-04-30 00:53:55 -0700505 tty_insert_flip_char(tty,
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700506 cyy_readb(info, CyRDSR),
507 TTY_FRAME);
Jiri Slabyce97a092007-10-18 03:06:21 -0700508 info->icount.rx++;
509 info->idle_stats.frame_errs++;
510 } else if (data & CyPARITY) {
511 /* Pieces of seven... */
512 tty_insert_flip_char(tty,
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700513 cyy_readb(info, CyRDSR),
514 TTY_PARITY);
Jiri Slabyce97a092007-10-18 03:06:21 -0700515 info->icount.rx++;
516 info->idle_stats.parity_errs++;
517 } else if (data & CyOVERRUN) {
518 tty_insert_flip_char(tty, 0,
519 TTY_OVERRUN);
520 info->icount.rx++;
521 /* If the flip buffer itself is
522 overflowing, we still lose
523 the next incoming character.
524 */
525 tty_insert_flip_char(tty,
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700526 cyy_readb(info, CyRDSR),
527 TTY_FRAME);
Jiri Slabyce97a092007-10-18 03:06:21 -0700528 info->icount.rx++;
Jiri Slaby02f11752006-12-08 02:39:28 -0800529 info->idle_stats.overruns++;
Jiri Slabyce97a092007-10-18 03:06:21 -0700530 /* These two conditions may imply */
531 /* a normal read should be done. */
532 /* } else if(data & CyTIMEOUT) { */
533 /* } else if(data & CySPECHAR) { */
534 } else {
535 tty_insert_flip_char(tty, 0,
536 TTY_NORMAL);
537 info->icount.rx++;
Jiri Slaby02f11752006-12-08 02:39:28 -0800538 }
Jiri Slabyce97a092007-10-18 03:06:21 -0700539 } else {
540 tty_insert_flip_char(tty, 0, TTY_NORMAL);
541 info->icount.rx++;
542 }
543 } else {
544 /* there was a software buffer overrun and nothing
545 * could be done about it!!! */
546 info->icount.buf_overrun++;
547 info->idle_stats.overruns++;
548 }
549 } else { /* normal character reception */
550 /* load # chars available from the chip */
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700551 char_count = cyy_readb(info, CyRDCR);
Jiri Slabye9410272006-12-08 02:39:28 -0800552
553#ifdef CY_ENABLE_MONITORING
Jiri Slabyce97a092007-10-18 03:06:21 -0700554 ++info->mon.int_count;
555 info->mon.char_count += char_count;
556 if (char_count > info->mon.char_max)
557 info->mon.char_max = char_count;
558 info->mon.char_last = char_count;
Jiri Slabye9410272006-12-08 02:39:28 -0800559#endif
Jiri Slabyce97a092007-10-18 03:06:21 -0700560 len = tty_buffer_request_room(tty, char_count);
561 while (len--) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700562 data = cyy_readb(info, CyRDSR);
Jiri Slabyce97a092007-10-18 03:06:21 -0700563 tty_insert_flip_char(tty, data, TTY_NORMAL);
564 info->idle_stats.recv_bytes++;
565 info->icount.rx++;
Jiri Slabye9410272006-12-08 02:39:28 -0800566#ifdef CY_16Y_HACK
Jiri Slabyce97a092007-10-18 03:06:21 -0700567 udelay(10L);
Jiri Slabye9410272006-12-08 02:39:28 -0800568#endif
Jiri Slabye9410272006-12-08 02:39:28 -0800569 }
Jiri Slabyce97a092007-10-18 03:06:21 -0700570 info->idle_stats.recv_idle = jiffies;
571 }
572 tty_schedule_flip(tty);
Jiri Slabyd13549f2009-09-19 13:13:12 -0700573 tty_kref_put(tty);
Jiri Slabyce97a092007-10-18 03:06:21 -0700574end:
575 /* end of service */
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700576 cyy_writeb(info, CyRIR, save_xir & 0x3f);
577 cyy_writeb(info, CyCAR, save_car);
Jiri Slabyce97a092007-10-18 03:06:21 -0700578}
579
Jiri Slaby65f76a82007-10-18 03:06:22 -0700580static void cyy_chip_tx(struct cyclades_card *cinfo, unsigned int chip,
Jiri Slabyce97a092007-10-18 03:06:21 -0700581 void __iomem *base_addr)
582{
583 struct cyclades_port *info;
Jiri Slabyd13549f2009-09-19 13:13:12 -0700584 struct tty_struct *tty;
Jiri Slaby65f76a82007-10-18 03:06:22 -0700585 int char_count, index = cinfo->bus_index;
586 u8 save_xir, channel, save_car, outch;
Jiri Slabyce97a092007-10-18 03:06:21 -0700587
588 /* Since we only get here when the transmit buffer
589 is empty, we know we can always stuff a dozen
590 characters. */
591#ifdef CY_DEBUG_INTERRUPTS
592 printk(KERN_DEBUG "cyy_interrupt: xmit intr, chip %d\n", chip);
593#endif
594
595 /* determine the channel & change to that context */
Jiri Slaby65f76a82007-10-18 03:06:22 -0700596 save_xir = readb(base_addr + (CyTIR << index));
597 channel = save_xir & CyIRChannel;
Jiri Slabyce97a092007-10-18 03:06:21 -0700598 save_car = readb(base_addr + (CyCAR << index));
599 cy_writeb(base_addr + (CyCAR << index), save_xir);
600
601 /* validate the port# (as configured and open) */
602 if (channel + chip * 4 >= cinfo->nports) {
603 cy_writeb(base_addr + (CySRER << index),
604 readb(base_addr + (CySRER << index)) & ~CyTxRdy);
605 goto end;
606 }
607 info = &cinfo->ports[channel + chip * 4];
Jiri Slabyd13549f2009-09-19 13:13:12 -0700608 tty = tty_port_tty_get(&info->port);
609 if (tty == NULL) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700610 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyTxRdy);
Jiri Slabyce97a092007-10-18 03:06:21 -0700611 goto end;
Jiri Slabye9410272006-12-08 02:39:28 -0800612 }
613
Jiri Slabyce97a092007-10-18 03:06:21 -0700614 /* load the on-chip space for outbound data */
615 char_count = info->xmit_fifo_size;
Jiri Slabye9410272006-12-08 02:39:28 -0800616
Jiri Slabyce97a092007-10-18 03:06:21 -0700617 if (info->x_char) { /* send special char */
618 outch = info->x_char;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700619 cyy_writeb(info, CyTDR, outch);
Jiri Slabyce97a092007-10-18 03:06:21 -0700620 char_count--;
621 info->icount.tx++;
622 info->x_char = 0;
623 }
Jiri Slabye9410272006-12-08 02:39:28 -0800624
Jiri Slabyce97a092007-10-18 03:06:21 -0700625 if (info->breakon || info->breakoff) {
626 if (info->breakon) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700627 cyy_writeb(info, CyTDR, 0);
628 cyy_writeb(info, CyTDR, 0x81);
Jiri Slabyce97a092007-10-18 03:06:21 -0700629 info->breakon = 0;
630 char_count -= 2;
Jiri Slaby02f11752006-12-08 02:39:28 -0800631 }
Jiri Slabyce97a092007-10-18 03:06:21 -0700632 if (info->breakoff) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700633 cyy_writeb(info, CyTDR, 0);
634 cyy_writeb(info, CyTDR, 0x83);
Jiri Slabyce97a092007-10-18 03:06:21 -0700635 info->breakoff = 0;
636 char_count -= 2;
Jiri Slaby02f11752006-12-08 02:39:28 -0800637 }
Jiri Slabyce97a092007-10-18 03:06:21 -0700638 }
Jiri Slabye9410272006-12-08 02:39:28 -0800639
Jiri Slabyce97a092007-10-18 03:06:21 -0700640 while (char_count-- > 0) {
641 if (!info->xmit_cnt) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700642 if (cyy_readb(info, CySRER) & CyTxMpty) {
643 cyy_writeb(info, CySRER,
644 cyy_readb(info, CySRER) & ~CyTxMpty);
Jiri Slabyce97a092007-10-18 03:06:21 -0700645 } else {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700646 cyy_writeb(info, CySRER, CyTxMpty |
647 (cyy_readb(info, CySRER) & ~CyTxRdy));
Jiri Slaby02f11752006-12-08 02:39:28 -0800648 }
Jiri Slabyce97a092007-10-18 03:06:21 -0700649 goto done;
650 }
Alan Cox77451e52008-07-16 21:57:02 +0100651 if (info->port.xmit_buf == NULL) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700652 cyy_writeb(info, CySRER,
653 cyy_readb(info, CySRER) & ~CyTxRdy);
Jiri Slabyce97a092007-10-18 03:06:21 -0700654 goto done;
655 }
Jiri Slabyd13549f2009-09-19 13:13:12 -0700656 if (tty->stopped || tty->hw_stopped) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700657 cyy_writeb(info, CySRER,
658 cyy_readb(info, CySRER) & ~CyTxRdy);
Jiri Slabyce97a092007-10-18 03:06:21 -0700659 goto done;
660 }
661 /* Because the Embedded Transmit Commands have been enabled,
662 * we must check to see if the escape character, NULL, is being
663 * sent. If it is, we must ensure that there is room for it to
664 * be doubled in the output stream. Therefore we no longer
665 * advance the pointer when the character is fetched, but
666 * rather wait until after the check for a NULL output
667 * character. This is necessary because there may not be room
668 * for the two chars needed to send a NULL.)
669 */
Alan Cox77451e52008-07-16 21:57:02 +0100670 outch = info->port.xmit_buf[info->xmit_tail];
Jiri Slabyce97a092007-10-18 03:06:21 -0700671 if (outch) {
672 info->xmit_cnt--;
673 info->xmit_tail = (info->xmit_tail + 1) &
674 (SERIAL_XMIT_SIZE - 1);
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700675 cyy_writeb(info, CyTDR, outch);
Jiri Slabyce97a092007-10-18 03:06:21 -0700676 info->icount.tx++;
677 } else {
678 if (char_count > 1) {
Jiri Slaby02f11752006-12-08 02:39:28 -0800679 info->xmit_cnt--;
680 info->xmit_tail = (info->xmit_tail + 1) &
Jiri Slabyce97a092007-10-18 03:06:21 -0700681 (SERIAL_XMIT_SIZE - 1);
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700682 cyy_writeb(info, CyTDR, outch);
683 cyy_writeb(info, CyTDR, 0);
Jiri Slaby02f11752006-12-08 02:39:28 -0800684 info->icount.tx++;
Jiri Slabyce97a092007-10-18 03:06:21 -0700685 char_count--;
Jiri Slaby02f11752006-12-08 02:39:28 -0800686 }
687 }
Jiri Slabye9410272006-12-08 02:39:28 -0800688 }
689
Jiri Slabyce97a092007-10-18 03:06:21 -0700690done:
Jiri Slabyd13549f2009-09-19 13:13:12 -0700691 tty_wakeup(tty);
692 tty_kref_put(tty);
Jiri Slabyce97a092007-10-18 03:06:21 -0700693end:
694 /* end of service */
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700695 cyy_writeb(info, CyTIR, save_xir & 0x3f);
696 cyy_writeb(info, CyCAR, save_car);
Jiri Slabyce97a092007-10-18 03:06:21 -0700697}
Jiri Slabye9410272006-12-08 02:39:28 -0800698
Jiri Slabyce97a092007-10-18 03:06:21 -0700699static void cyy_chip_modem(struct cyclades_card *cinfo, int chip,
700 void __iomem *base_addr)
701{
702 struct cyclades_port *info;
Jiri Slabyd13549f2009-09-19 13:13:12 -0700703 struct tty_struct *tty;
Jiri Slaby65f76a82007-10-18 03:06:22 -0700704 int index = cinfo->bus_index;
705 u8 save_xir, channel, save_car, mdm_change, mdm_status;
Jiri Slabye9410272006-12-08 02:39:28 -0800706
Jiri Slabyce97a092007-10-18 03:06:21 -0700707 /* determine the channel & change to that context */
Jiri Slaby65f76a82007-10-18 03:06:22 -0700708 save_xir = readb(base_addr + (CyMIR << index));
709 channel = save_xir & CyIRChannel;
Jiri Slabyce97a092007-10-18 03:06:21 -0700710 info = &cinfo->ports[channel + chip * 4];
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700711 save_car = cyy_readb(info, CyCAR);
712 cyy_writeb(info, CyCAR, save_xir);
Jiri Slabye9410272006-12-08 02:39:28 -0800713
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700714 mdm_change = cyy_readb(info, CyMISR);
715 mdm_status = cyy_readb(info, CyMSVR1);
Jiri Slabye9410272006-12-08 02:39:28 -0800716
Jiri Slabyd13549f2009-09-19 13:13:12 -0700717 tty = tty_port_tty_get(&info->port);
718 if (!tty)
Jiri Slabyce97a092007-10-18 03:06:21 -0700719 goto end;
Jiri Slaby02f11752006-12-08 02:39:28 -0800720
Jiri Slabyce97a092007-10-18 03:06:21 -0700721 if (mdm_change & CyANY_DELTA) {
722 /* For statistics only */
723 if (mdm_change & CyDCD)
724 info->icount.dcd++;
725 if (mdm_change & CyCTS)
726 info->icount.cts++;
727 if (mdm_change & CyDSR)
728 info->icount.dsr++;
729 if (mdm_change & CyRI)
730 info->icount.rng++;
731
Alan Coxbdc04e32009-09-19 13:13:31 -0700732 wake_up_interruptible(&info->port.delta_msr_wait);
Jiri Slabyce97a092007-10-18 03:06:21 -0700733 }
734
Alan Cox77451e52008-07-16 21:57:02 +0100735 if ((mdm_change & CyDCD) && (info->port.flags & ASYNC_CHECK_CD)) {
Jiri Slaby174e6fe2009-09-19 13:13:13 -0700736 if (mdm_status & CyDCD)
737 wake_up_interruptible(&info->port.open_wait);
738 else
Jiri Slabyd13549f2009-09-19 13:13:12 -0700739 tty_hangup(tty);
Jiri Slabye9410272006-12-08 02:39:28 -0800740 }
Alan Cox77451e52008-07-16 21:57:02 +0100741 if ((mdm_change & CyCTS) && (info->port.flags & ASYNC_CTS_FLOW)) {
Jiri Slabyd13549f2009-09-19 13:13:12 -0700742 if (tty->hw_stopped) {
Jiri Slabyce97a092007-10-18 03:06:21 -0700743 if (mdm_status & CyCTS) {
744 /* cy_start isn't used
745 because... !!! */
Jiri Slabyd13549f2009-09-19 13:13:12 -0700746 tty->hw_stopped = 0;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700747 cyy_writeb(info, CySRER,
748 cyy_readb(info, CySRER) | CyTxRdy);
Jiri Slabyd13549f2009-09-19 13:13:12 -0700749 tty_wakeup(tty);
Jiri Slabyce97a092007-10-18 03:06:21 -0700750 }
751 } else {
752 if (!(mdm_status & CyCTS)) {
753 /* cy_stop isn't used
754 because ... !!! */
Jiri Slabyd13549f2009-09-19 13:13:12 -0700755 tty->hw_stopped = 1;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700756 cyy_writeb(info, CySRER,
757 cyy_readb(info, CySRER) & ~CyTxRdy);
Jiri Slabyce97a092007-10-18 03:06:21 -0700758 }
759 }
760 }
761/* if (mdm_change & CyDSR) {
762 }
763 if (mdm_change & CyRI) {
764 }*/
Jiri Slabyd13549f2009-09-19 13:13:12 -0700765 tty_kref_put(tty);
Jiri Slabyce97a092007-10-18 03:06:21 -0700766end:
767 /* end of service */
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700768 cyy_writeb(info, CyMIR, save_xir & 0x3f);
769 cyy_writeb(info, CyCAR, save_car);
Jiri Slabye9410272006-12-08 02:39:28 -0800770}
771
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772/* The real interrupt service routine is called
773 whenever the card wants its hand held--chars
774 received, out buffer empty, modem change, etc.
775 */
Jiri Slaby02f11752006-12-08 02:39:28 -0800776static irqreturn_t cyy_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777{
Jiri Slaby02f11752006-12-08 02:39:28 -0800778 int status;
Jiri Slabyf7429032007-05-08 00:36:59 -0700779 struct cyclades_card *cinfo = dev_id;
Jiri Slaby02f11752006-12-08 02:39:28 -0800780 void __iomem *base_addr, *card_base_addr;
Jiri Slaby65f76a82007-10-18 03:06:22 -0700781 unsigned int chip, too_many, had_work;
Jiri Slaby02f11752006-12-08 02:39:28 -0800782 int index;
Jiri Slabye9410272006-12-08 02:39:28 -0800783
Jiri Slabyf7429032007-05-08 00:36:59 -0700784 if (unlikely(cinfo == NULL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785#ifdef CY_DEBUG_INTERRUPTS
Alan Cox15ed6cc2008-04-30 00:53:55 -0700786 printk(KERN_DEBUG "cyy_interrupt: spurious interrupt %d\n",
787 irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788#endif
Jiri Slaby02f11752006-12-08 02:39:28 -0800789 return IRQ_NONE; /* spurious interrupt */
790 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791
Jiri Slaby02f11752006-12-08 02:39:28 -0800792 card_base_addr = cinfo->base_addr;
793 index = cinfo->bus_index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794
Jiri Slabyf1e83c62007-05-08 00:36:24 -0700795 /* card was not initialized yet (e.g. DEBUG_SHIRQ) */
796 if (unlikely(card_base_addr == NULL))
797 return IRQ_HANDLED;
798
Jiri Slaby02f11752006-12-08 02:39:28 -0800799 /* This loop checks all chips in the card. Make a note whenever
800 _any_ chip had some work to do, as this is considered an
801 indication that there will be more to do. Only when no chip
802 has any work does this outermost loop exit.
803 */
804 do {
805 had_work = 0;
806 for (chip = 0; chip < cinfo->num_chips; chip++) {
807 base_addr = cinfo->base_addr +
808 (cy_chip_offset[chip] << index);
809 too_many = 0;
Jiri Slabydb05c3b2007-05-08 00:35:46 -0700810 while ((status = readb(base_addr +
Jiri Slaby02f11752006-12-08 02:39:28 -0800811 (CySVRR << index))) != 0x00) {
812 had_work++;
813 /* The purpose of the following test is to ensure that
814 no chip can monopolize the driver. This forces the
815 chips to be checked in a round-robin fashion (after
816 draining each of a bunch (1000) of characters).
817 */
Jiri Slabyce97a092007-10-18 03:06:21 -0700818 if (1000 < too_many++)
Jiri Slaby02f11752006-12-08 02:39:28 -0800819 break;
Jiri Slaby1c0a3872007-10-18 03:06:22 -0700820 spin_lock(&cinfo->card_lock);
Jiri Slabyce97a092007-10-18 03:06:21 -0700821 if (status & CySRReceive) /* rx intr */
822 cyy_chip_rx(cinfo, chip, base_addr);
823 if (status & CySRTransmit) /* tx intr */
824 cyy_chip_tx(cinfo, chip, base_addr);
825 if (status & CySRModem) /* modem intr */
826 cyy_chip_modem(cinfo, chip, base_addr);
Jiri Slaby1c0a3872007-10-18 03:06:22 -0700827 spin_unlock(&cinfo->card_lock);
Jiri Slaby02f11752006-12-08 02:39:28 -0800828 }
829 }
830 } while (had_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831
Jiri Slaby02f11752006-12-08 02:39:28 -0800832 /* clear interrupts */
833 spin_lock(&cinfo->card_lock);
834 cy_writeb(card_base_addr + (Cy_ClrIntr << index), 0);
835 /* Cy_ClrIntr is 0x1800 */
836 spin_unlock(&cinfo->card_lock);
837 return IRQ_HANDLED;
838} /* cyy_interrupt */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839
Jiri Slaby4d768202009-09-19 13:13:15 -0700840static void cyy_change_rts_dtr(struct cyclades_port *info, unsigned int set,
841 unsigned int clear)
842{
843 struct cyclades_card *card = info->card;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700844 int channel = info->line - card->first_line;
Jiri Slaby0d348722009-09-19 13:13:16 -0700845 u32 rts, dtr, msvrr, msvrd;
Jiri Slaby4d768202009-09-19 13:13:15 -0700846
Jiri Slaby4d768202009-09-19 13:13:15 -0700847 channel &= 0x03;
Jiri Slaby4d768202009-09-19 13:13:15 -0700848
Jiri Slaby0d348722009-09-19 13:13:16 -0700849 if (info->rtsdtr_inv) {
850 msvrr = CyMSVR2;
851 msvrd = CyMSVR1;
852 rts = CyDTR;
853 dtr = CyRTS;
854 } else {
855 msvrr = CyMSVR1;
856 msvrd = CyMSVR2;
857 rts = CyRTS;
858 dtr = CyDTR;
859 }
Jiri Slaby4d768202009-09-19 13:13:15 -0700860 if (set & TIOCM_RTS) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700861 cyy_writeb(info, CyCAR, channel);
862 cyy_writeb(info, msvrr, rts);
Jiri Slaby4d768202009-09-19 13:13:15 -0700863 }
864 if (clear & TIOCM_RTS) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700865 cyy_writeb(info, CyCAR, channel);
866 cyy_writeb(info, msvrr, ~rts);
Jiri Slaby4d768202009-09-19 13:13:15 -0700867 }
868 if (set & TIOCM_DTR) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700869 cyy_writeb(info, CyCAR, channel);
870 cyy_writeb(info, msvrd, dtr);
Jiri Slaby4d768202009-09-19 13:13:15 -0700871#ifdef CY_DEBUG_DTR
872 printk(KERN_DEBUG "cyc:set_modem_info raising DTR\n");
873 printk(KERN_DEBUG " status: 0x%x, 0x%x\n",
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700874 cyy_readb(info, CyMSVR1),
875 cyy_readb(info, CyMSVR2));
Jiri Slaby4d768202009-09-19 13:13:15 -0700876#endif
877 }
878 if (clear & TIOCM_DTR) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700879 cyy_writeb(info, CyCAR, channel);
880 cyy_writeb(info, msvrd, ~dtr);
Jiri Slaby4d768202009-09-19 13:13:15 -0700881#ifdef CY_DEBUG_DTR
882 printk(KERN_DEBUG "cyc:set_modem_info dropping DTR\n");
883 printk(KERN_DEBUG " status: 0x%x, 0x%x\n",
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700884 cyy_readb(info, CyMSVR1),
885 cyy_readb(info, CyMSVR2));
Jiri Slaby4d768202009-09-19 13:13:15 -0700886#endif
887 }
888}
889
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890/***********************************************************/
891/********* End of block of Cyclom-Y specific code **********/
Alan Cox15ed6cc2008-04-30 00:53:55 -0700892/******** Start of block of Cyclades-Z specific code *******/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893/***********************************************************/
894
895static int
Jiri Slaby02f11752006-12-08 02:39:28 -0800896cyz_fetch_msg(struct cyclades_card *cinfo,
Alan Cox15ed6cc2008-04-30 00:53:55 -0700897 __u32 *channel, __u8 *cmd, __u32 *param)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898{
Jiri Slabyf0eefdc2009-09-19 13:13:13 -0700899 struct BOARD_CTRL __iomem *board_ctrl = cinfo->board_ctrl;
Jiri Slaby02f11752006-12-08 02:39:28 -0800900 unsigned long loc_doorbell;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901
Jiri Slaby97e87f82009-06-11 12:29:27 +0100902 loc_doorbell = readl(&cinfo->ctl_addr.p9060->loc_doorbell);
Jiri Slaby02f11752006-12-08 02:39:28 -0800903 if (loc_doorbell) {
904 *cmd = (char)(0xff & loc_doorbell);
Jiri Slabydb05c3b2007-05-08 00:35:46 -0700905 *channel = readl(&board_ctrl->fwcmd_channel);
906 *param = (__u32) readl(&board_ctrl->fwcmd_param);
Jiri Slaby97e87f82009-06-11 12:29:27 +0100907 cy_writel(&cinfo->ctl_addr.p9060->loc_doorbell, 0xffffffff);
Jiri Slaby02f11752006-12-08 02:39:28 -0800908 return 1;
909 }
910 return 0;
911} /* cyz_fetch_msg */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912
913static int
Jiri Slaby02f11752006-12-08 02:39:28 -0800914cyz_issue_cmd(struct cyclades_card *cinfo,
Klaus Kudielka1a86b5e2007-05-08 00:26:26 -0700915 __u32 channel, __u8 cmd, __u32 param)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916{
Jiri Slabyf0eefdc2009-09-19 13:13:13 -0700917 struct BOARD_CTRL __iomem *board_ctrl = cinfo->board_ctrl;
Klaus Kudielka1a86b5e2007-05-08 00:26:26 -0700918 __u32 __iomem *pci_doorbell;
Jiri Slaby65f76a82007-10-18 03:06:22 -0700919 unsigned int index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920
Jiri Slaby2693f482009-06-11 12:31:06 +0100921 if (!cyz_is_loaded(cinfo))
Jiri Slaby096dcfc2006-12-08 02:39:30 -0800922 return -1;
Alan Cox15ed6cc2008-04-30 00:53:55 -0700923
Jiri Slaby02f11752006-12-08 02:39:28 -0800924 index = 0;
Jiri Slaby97e87f82009-06-11 12:29:27 +0100925 pci_doorbell = &cinfo->ctl_addr.p9060->pci_doorbell;
Jiri Slabydb05c3b2007-05-08 00:35:46 -0700926 while ((readl(pci_doorbell) & 0xff) != 0) {
Alan Cox15ed6cc2008-04-30 00:53:55 -0700927 if (index++ == 1000)
Jiri Slabydb05c3b2007-05-08 00:35:46 -0700928 return (int)(readl(pci_doorbell) & 0xff);
Jiri Slaby02f11752006-12-08 02:39:28 -0800929 udelay(50L);
930 }
931 cy_writel(&board_ctrl->hcmd_channel, channel);
932 cy_writel(&board_ctrl->hcmd_param, param);
933 cy_writel(pci_doorbell, (long)cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934
Jiri Slaby096dcfc2006-12-08 02:39:30 -0800935 return 0;
Jiri Slaby02f11752006-12-08 02:39:28 -0800936} /* cyz_issue_cmd */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937
Jiri Slabyf0eefdc2009-09-19 13:13:13 -0700938static void cyz_handle_rx(struct cyclades_port *info, struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939{
Jiri Slabyf0eefdc2009-09-19 13:13:13 -0700940 struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
Jiri Slaby875b2062007-05-08 00:36:49 -0700941 struct cyclades_card *cinfo = info->card;
Jiri Slaby65f76a82007-10-18 03:06:22 -0700942 unsigned int char_count;
Jiri Slaby02f11752006-12-08 02:39:28 -0800943 int len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944#ifdef BLOCKMOVE
Jiri Slabyce71b0f2007-05-08 00:36:53 -0700945 unsigned char *buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946#else
Jiri Slaby02f11752006-12-08 02:39:28 -0800947 char data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948#endif
Jiri Slabyad39c302007-05-08 00:35:49 -0700949 __u32 rx_put, rx_get, new_rx_get, rx_bufsize, rx_bufaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950
Jiri Slabydb05c3b2007-05-08 00:35:46 -0700951 rx_get = new_rx_get = readl(&buf_ctrl->rx_get);
952 rx_put = readl(&buf_ctrl->rx_put);
953 rx_bufsize = readl(&buf_ctrl->rx_bufsize);
954 rx_bufaddr = readl(&buf_ctrl->rx_bufaddr);
Jiri Slaby02f11752006-12-08 02:39:28 -0800955 if (rx_put >= rx_get)
956 char_count = rx_put - rx_get;
957 else
958 char_count = rx_put - rx_get + rx_bufsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959
Jiri Slaby02f11752006-12-08 02:39:28 -0800960 if (char_count) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961#ifdef CY_ENABLE_MONITORING
Jiri Slaby02f11752006-12-08 02:39:28 -0800962 info->mon.int_count++;
963 info->mon.char_count += char_count;
964 if (char_count > info->mon.char_max)
965 info->mon.char_max = char_count;
966 info->mon.char_last = char_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967#endif
Jiri Slabyf7429032007-05-08 00:36:59 -0700968 if (tty == NULL) {
Jiri Slaby02f11752006-12-08 02:39:28 -0800969 /* flush received characters */
970 new_rx_get = (new_rx_get + char_count) &
971 (rx_bufsize - 1);
972 info->rflush_count++;
973 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974#ifdef BLOCKMOVE
Jiri Slaby02f11752006-12-08 02:39:28 -0800975 /* we'd like to use memcpy(t, f, n) and memset(s, c, count)
976 for performance, but because of buffer boundaries, there
977 may be several steps to the operation */
Jiri Slabyce71b0f2007-05-08 00:36:53 -0700978 while (1) {
979 len = tty_prepare_flip_string(tty, &buf,
980 char_count);
981 if (!len)
982 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983
Jiri Slabyce71b0f2007-05-08 00:36:53 -0700984 len = min_t(unsigned int, min(len, char_count),
985 rx_bufsize - new_rx_get);
986
987 memcpy_fromio(buf, cinfo->base_addr +
988 rx_bufaddr + new_rx_get, len);
989
990 new_rx_get = (new_rx_get + len) &
Jiri Slaby02f11752006-12-08 02:39:28 -0800991 (rx_bufsize - 1);
Jiri Slabyce71b0f2007-05-08 00:36:53 -0700992 char_count -= len;
993 info->icount.rx += len;
994 info->idle_stats.recv_bytes += len;
Jiri Slaby02f11752006-12-08 02:39:28 -0800995 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996#else
Jiri Slaby02f11752006-12-08 02:39:28 -0800997 len = tty_buffer_request_room(tty, char_count);
998 while (len--) {
Jiri Slabydb05c3b2007-05-08 00:35:46 -0700999 data = readb(cinfo->base_addr + rx_bufaddr +
Jiri Slaby02f11752006-12-08 02:39:28 -08001000 new_rx_get);
Alan Cox15ed6cc2008-04-30 00:53:55 -07001001 new_rx_get = (new_rx_get + 1) &
1002 (rx_bufsize - 1);
Jiri Slaby02f11752006-12-08 02:39:28 -08001003 tty_insert_flip_char(tty, data, TTY_NORMAL);
1004 info->idle_stats.recv_bytes++;
1005 info->icount.rx++;
1006 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007#endif
1008#ifdef CONFIG_CYZ_INTR
Jiri Slaby02f11752006-12-08 02:39:28 -08001009 /* Recalculate the number of chars in the RX buffer and issue
1010 a cmd in case it's higher than the RX high water mark */
Jiri Slabydb05c3b2007-05-08 00:35:46 -07001011 rx_put = readl(&buf_ctrl->rx_put);
Jiri Slaby02f11752006-12-08 02:39:28 -08001012 if (rx_put >= rx_get)
1013 char_count = rx_put - rx_get;
1014 else
1015 char_count = rx_put - rx_get + rx_bufsize;
Jiri Slaby65f76a82007-10-18 03:06:22 -07001016 if (char_count >= readl(&buf_ctrl->rx_threshold) &&
Jiri Slabyebafeef2007-10-18 03:06:20 -07001017 !timer_pending(&cyz_rx_full_timer[
1018 info->line]))
1019 mod_timer(&cyz_rx_full_timer[info->line],
1020 jiffies + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021#endif
Jiri Slaby02f11752006-12-08 02:39:28 -08001022 info->idle_stats.recv_idle = jiffies;
1023 tty_schedule_flip(tty);
1024 }
1025 /* Update rx_get */
1026 cy_writel(&buf_ctrl->rx_get, new_rx_get);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028}
1029
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001030static void cyz_handle_tx(struct cyclades_port *info, struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031{
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001032 struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
Jiri Slaby875b2062007-05-08 00:36:49 -07001033 struct cyclades_card *cinfo = info->card;
Jiri Slaby65f76a82007-10-18 03:06:22 -07001034 u8 data;
1035 unsigned int char_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036#ifdef BLOCKMOVE
Jiri Slaby02f11752006-12-08 02:39:28 -08001037 int small_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038#endif
Jiri Slabyad39c302007-05-08 00:35:49 -07001039 __u32 tx_put, tx_get, tx_bufsize, tx_bufaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040
Jiri Slaby02f11752006-12-08 02:39:28 -08001041 if (info->xmit_cnt <= 0) /* Nothing to transmit */
1042 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043
Jiri Slabydb05c3b2007-05-08 00:35:46 -07001044 tx_get = readl(&buf_ctrl->tx_get);
1045 tx_put = readl(&buf_ctrl->tx_put);
1046 tx_bufsize = readl(&buf_ctrl->tx_bufsize);
1047 tx_bufaddr = readl(&buf_ctrl->tx_bufaddr);
Jiri Slaby02f11752006-12-08 02:39:28 -08001048 if (tx_put >= tx_get)
1049 char_count = tx_get - tx_put - 1 + tx_bufsize;
1050 else
1051 char_count = tx_get - tx_put - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052
Jiri Slaby02f11752006-12-08 02:39:28 -08001053 if (char_count) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054
Jiri Slabyf7429032007-05-08 00:36:59 -07001055 if (tty == NULL)
Jiri Slaby02f11752006-12-08 02:39:28 -08001056 goto ztxdone;
Jiri Slaby02f11752006-12-08 02:39:28 -08001057
1058 if (info->x_char) { /* send special char */
1059 data = info->x_char;
1060
1061 cy_writeb(cinfo->base_addr + tx_bufaddr + tx_put, data);
1062 tx_put = (tx_put + 1) & (tx_bufsize - 1);
1063 info->x_char = 0;
1064 char_count--;
1065 info->icount.tx++;
Jiri Slaby02f11752006-12-08 02:39:28 -08001066 }
1067#ifdef BLOCKMOVE
1068 while (0 < (small_count = min_t(unsigned int,
1069 tx_bufsize - tx_put, min_t(unsigned int,
1070 (SERIAL_XMIT_SIZE - info->xmit_tail),
1071 min_t(unsigned int, info->xmit_cnt,
1072 char_count))))) {
1073
1074 memcpy_toio((char *)(cinfo->base_addr + tx_bufaddr +
1075 tx_put),
Alan Cox77451e52008-07-16 21:57:02 +01001076 &info->port.xmit_buf[info->xmit_tail],
Jiri Slaby02f11752006-12-08 02:39:28 -08001077 small_count);
1078
1079 tx_put = (tx_put + small_count) & (tx_bufsize - 1);
1080 char_count -= small_count;
1081 info->icount.tx += small_count;
1082 info->xmit_cnt -= small_count;
1083 info->xmit_tail = (info->xmit_tail + small_count) &
1084 (SERIAL_XMIT_SIZE - 1);
Jiri Slaby02f11752006-12-08 02:39:28 -08001085 }
1086#else
1087 while (info->xmit_cnt && char_count) {
Alan Cox77451e52008-07-16 21:57:02 +01001088 data = info->port.xmit_buf[info->xmit_tail];
Jiri Slaby02f11752006-12-08 02:39:28 -08001089 info->xmit_cnt--;
1090 info->xmit_tail = (info->xmit_tail + 1) &
1091 (SERIAL_XMIT_SIZE - 1);
1092
1093 cy_writeb(cinfo->base_addr + tx_bufaddr + tx_put, data);
1094 tx_put = (tx_put + 1) & (tx_bufsize - 1);
1095 char_count--;
1096 info->icount.tx++;
Jiri Slaby02f11752006-12-08 02:39:28 -08001097 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098#endif
Jiri Slabyebafeef2007-10-18 03:06:20 -07001099 tty_wakeup(tty);
Jiri Slaby7fa57a02007-10-22 20:45:13 -07001100ztxdone:
Jiri Slaby02f11752006-12-08 02:39:28 -08001101 /* Update tx_put */
1102 cy_writel(&buf_ctrl->tx_put, tx_put);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104}
1105
Jiri Slaby02f11752006-12-08 02:39:28 -08001106static void cyz_handle_cmd(struct cyclades_card *cinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107{
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001108 struct BOARD_CTRL __iomem *board_ctrl = cinfo->board_ctrl;
Jiri Slaby02f11752006-12-08 02:39:28 -08001109 struct tty_struct *tty;
1110 struct cyclades_port *info;
Jiri Slaby101b8152009-06-11 12:30:10 +01001111 __u32 channel, param, fw_ver;
Klaus Kudielka1a86b5e2007-05-08 00:26:26 -07001112 __u8 cmd;
Jiri Slaby02f11752006-12-08 02:39:28 -08001113 int special_count;
1114 int delta_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115
Jiri Slabydb05c3b2007-05-08 00:35:46 -07001116 fw_ver = readl(&board_ctrl->fw_version);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117
Jiri Slaby02f11752006-12-08 02:39:28 -08001118 while (cyz_fetch_msg(cinfo, &channel, &cmd, &param) == 1) {
1119 special_count = 0;
1120 delta_count = 0;
Jiri Slabydd025c02007-05-08 00:37:02 -07001121 info = &cinfo->ports[channel];
Jiri Slabyd13549f2009-09-19 13:13:12 -07001122 tty = tty_port_tty_get(&info->port);
Alan Cox15ed6cc2008-04-30 00:53:55 -07001123 if (tty == NULL)
Jiri Slaby02f11752006-12-08 02:39:28 -08001124 continue;
Jiri Slabyf7429032007-05-08 00:36:59 -07001125
Jiri Slaby02f11752006-12-08 02:39:28 -08001126 switch (cmd) {
1127 case C_CM_PR_ERROR:
1128 tty_insert_flip_char(tty, 0, TTY_PARITY);
1129 info->icount.rx++;
1130 special_count++;
1131 break;
1132 case C_CM_FR_ERROR:
1133 tty_insert_flip_char(tty, 0, TTY_FRAME);
1134 info->icount.rx++;
1135 special_count++;
1136 break;
1137 case C_CM_RXBRK:
1138 tty_insert_flip_char(tty, 0, TTY_BREAK);
1139 info->icount.rx++;
1140 special_count++;
1141 break;
1142 case C_CM_MDCD:
1143 info->icount.dcd++;
1144 delta_count++;
Alan Cox77451e52008-07-16 21:57:02 +01001145 if (info->port.flags & ASYNC_CHECK_CD) {
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001146 u32 dcd = fw_ver > 241 ? param :
1147 readl(&info->u.cyz.ch_ctrl->rs_status);
Jiri Slaby174e6fe2009-09-19 13:13:13 -07001148 if (dcd & C_RS_DCD)
Alan Cox77451e52008-07-16 21:57:02 +01001149 wake_up_interruptible(&info->port.open_wait);
Jiri Slaby174e6fe2009-09-19 13:13:13 -07001150 else
Jiri Slabyd13549f2009-09-19 13:13:12 -07001151 tty_hangup(tty);
Jiri Slaby02f11752006-12-08 02:39:28 -08001152 }
1153 break;
1154 case C_CM_MCTS:
1155 info->icount.cts++;
1156 delta_count++;
1157 break;
1158 case C_CM_MRI:
1159 info->icount.rng++;
1160 delta_count++;
1161 break;
1162 case C_CM_MDSR:
1163 info->icount.dsr++;
1164 delta_count++;
1165 break;
1166#ifdef Z_WAKE
1167 case C_CM_IOCTLW:
Jiri Slabyebafeef2007-10-18 03:06:20 -07001168 complete(&info->shutdown_wait);
Jiri Slaby02f11752006-12-08 02:39:28 -08001169 break;
1170#endif
1171#ifdef CONFIG_CYZ_INTR
1172 case C_CM_RXHIWM:
1173 case C_CM_RXNNDT:
1174 case C_CM_INTBACK2:
1175 /* Reception Interrupt */
1176#ifdef CY_DEBUG_INTERRUPTS
Jiri Slaby21719192007-05-08 00:36:42 -07001177 printk(KERN_DEBUG "cyz_interrupt: rcvd intr, card %d, "
1178 "port %ld\n", info->card, channel);
Jiri Slaby02f11752006-12-08 02:39:28 -08001179#endif
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001180 cyz_handle_rx(info, tty);
Jiri Slaby02f11752006-12-08 02:39:28 -08001181 break;
1182 case C_CM_TXBEMPTY:
1183 case C_CM_TXLOWWM:
1184 case C_CM_INTBACK:
1185 /* Transmission Interrupt */
1186#ifdef CY_DEBUG_INTERRUPTS
Jiri Slaby21719192007-05-08 00:36:42 -07001187 printk(KERN_DEBUG "cyz_interrupt: xmit intr, card %d, "
1188 "port %ld\n", info->card, channel);
Jiri Slaby02f11752006-12-08 02:39:28 -08001189#endif
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001190 cyz_handle_tx(info, tty);
Jiri Slaby02f11752006-12-08 02:39:28 -08001191 break;
1192#endif /* CONFIG_CYZ_INTR */
1193 case C_CM_FATAL:
1194 /* should do something with this !!! */
1195 break;
1196 default:
1197 break;
1198 }
1199 if (delta_count)
Alan Coxbdc04e32009-09-19 13:13:31 -07001200 wake_up_interruptible(&info->port.delta_msr_wait);
Jiri Slaby02f11752006-12-08 02:39:28 -08001201 if (special_count)
1202 tty_schedule_flip(tty);
Jiri Slabyd13549f2009-09-19 13:13:12 -07001203 tty_kref_put(tty);
Jiri Slaby02f11752006-12-08 02:39:28 -08001204 }
1205}
1206
1207#ifdef CONFIG_CYZ_INTR
1208static irqreturn_t cyz_interrupt(int irq, void *dev_id)
1209{
Jiri Slabyf7429032007-05-08 00:36:59 -07001210 struct cyclades_card *cinfo = dev_id;
Jiri Slaby02f11752006-12-08 02:39:28 -08001211
Jiri Slaby2693f482009-06-11 12:31:06 +01001212 if (unlikely(!cyz_is_loaded(cinfo))) {
Jiri Slaby02f11752006-12-08 02:39:28 -08001213#ifdef CY_DEBUG_INTERRUPTS
Jiri Slaby21719192007-05-08 00:36:42 -07001214 printk(KERN_DEBUG "cyz_interrupt: board not yet loaded "
1215 "(IRQ%d).\n", irq);
Jiri Slaby02f11752006-12-08 02:39:28 -08001216#endif
1217 return IRQ_NONE;
1218 }
1219
1220 /* Handle the interrupts */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 cyz_handle_cmd(cinfo);
1222
Jiri Slaby02f11752006-12-08 02:39:28 -08001223 return IRQ_HANDLED;
1224} /* cyz_interrupt */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225
Jiri Slaby02f11752006-12-08 02:39:28 -08001226static void cyz_rx_restart(unsigned long arg)
1227{
1228 struct cyclades_port *info = (struct cyclades_port *)arg;
Jiri Slaby875b2062007-05-08 00:36:49 -07001229 struct cyclades_card *card = info->card;
Jiri Slaby02f11752006-12-08 02:39:28 -08001230 int retval;
Jiri Slaby875b2062007-05-08 00:36:49 -07001231 __u32 channel = info->line - card->first_line;
Jiri Slaby02f11752006-12-08 02:39:28 -08001232 unsigned long flags;
1233
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001234 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby875b2062007-05-08 00:36:49 -07001235 retval = cyz_issue_cmd(card, channel, C_CM_INTBACK2, 0L);
Jiri Slaby02f11752006-12-08 02:39:28 -08001236 if (retval != 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07001237 printk(KERN_ERR "cyc:cyz_rx_restart retval on ttyC%d was %x\n",
Jiri Slaby02f11752006-12-08 02:39:28 -08001238 info->line, retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239 }
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001240 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08001241}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242
Jiri Slaby02f11752006-12-08 02:39:28 -08001243#else /* CONFIG_CYZ_INTR */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244
Jiri Slaby02f11752006-12-08 02:39:28 -08001245static void cyz_poll(unsigned long arg)
1246{
1247 struct cyclades_card *cinfo;
1248 struct cyclades_port *info;
Jiri Slabyb7050902007-05-08 00:35:48 -07001249 unsigned long expires = jiffies + HZ;
Jiri Slaby65f76a82007-10-18 03:06:22 -07001250 unsigned int port, card;
Jiri Slaby02f11752006-12-08 02:39:28 -08001251
Jiri Slaby02f11752006-12-08 02:39:28 -08001252 for (card = 0; card < NR_CARDS; card++) {
1253 cinfo = &cy_card[card];
1254
Jiri Slaby2693f482009-06-11 12:31:06 +01001255 if (!cy_is_Z(cinfo))
Jiri Slaby02f11752006-12-08 02:39:28 -08001256 continue;
Jiri Slaby2693f482009-06-11 12:31:06 +01001257 if (!cyz_is_loaded(cinfo))
Jiri Slaby02f11752006-12-08 02:39:28 -08001258 continue;
1259
Jiri Slaby02f11752006-12-08 02:39:28 -08001260 /* Skip first polling cycle to avoid racing conditions with the FW */
1261 if (!cinfo->intr_enabled) {
Jiri Slaby02f11752006-12-08 02:39:28 -08001262 cinfo->intr_enabled = 1;
1263 continue;
1264 }
1265
1266 cyz_handle_cmd(cinfo);
1267
1268 for (port = 0; port < cinfo->nports; port++) {
Jiri Slabyd13549f2009-09-19 13:13:12 -07001269 struct tty_struct *tty;
1270
Jiri Slabydd025c02007-05-08 00:37:02 -07001271 info = &cinfo->ports[port];
Jiri Slabyd13549f2009-09-19 13:13:12 -07001272 tty = tty_port_tty_get(&info->port);
1273 /* OK to pass NULL to the handle functions below.
1274 They need to drop the data in that case. */
1275
Jiri Slaby02f11752006-12-08 02:39:28 -08001276 if (!info->throttle)
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001277 cyz_handle_rx(info, tty);
1278 cyz_handle_tx(info, tty);
Jiri Slabyd13549f2009-09-19 13:13:12 -07001279 tty_kref_put(tty);
Jiri Slaby02f11752006-12-08 02:39:28 -08001280 }
1281 /* poll every 'cyz_polling_cycle' period */
Jiri Slabyb7050902007-05-08 00:35:48 -07001282 expires = jiffies + cyz_polling_cycle;
Jiri Slaby02f11752006-12-08 02:39:28 -08001283 }
Jiri Slabyb7050902007-05-08 00:35:48 -07001284 mod_timer(&cyz_timerlist, expires);
Jiri Slaby02f11752006-12-08 02:39:28 -08001285} /* cyz_poll */
1286
1287#endif /* CONFIG_CYZ_INTR */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288
1289/********** End of block of Cyclades-Z specific code *********/
1290/***********************************************************/
1291
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292/* This is called whenever a port becomes active;
1293 interrupts are enabled and DTR & RTS are turned on.
1294 */
Jiri Slabyd13549f2009-09-19 13:13:12 -07001295static int cy_startup(struct cyclades_port *info, struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296{
Jiri Slaby875b2062007-05-08 00:36:49 -07001297 struct cyclades_card *card;
Jiri Slaby02f11752006-12-08 02:39:28 -08001298 unsigned long flags;
1299 int retval = 0;
Jiri Slabycc7fdf42009-09-19 13:13:15 -07001300 int channel;
Jiri Slaby02f11752006-12-08 02:39:28 -08001301 unsigned long page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302
Jiri Slaby02f11752006-12-08 02:39:28 -08001303 card = info->card;
Jiri Slaby875b2062007-05-08 00:36:49 -07001304 channel = info->line - card->first_line;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305
Jiri Slaby02f11752006-12-08 02:39:28 -08001306 page = get_zeroed_page(GFP_KERNEL);
1307 if (!page)
1308 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001310 spin_lock_irqsave(&card->card_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311
Jiri Slabycc7fdf42009-09-19 13:13:15 -07001312 if (info->port.flags & ASYNC_INITIALIZED)
Jiri Slaby02f11752006-12-08 02:39:28 -08001313 goto errout;
Jiri Slaby02f11752006-12-08 02:39:28 -08001314
1315 if (!info->type) {
Jiri Slabyd13549f2009-09-19 13:13:12 -07001316 set_bit(TTY_IO_ERROR, &tty->flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08001317 goto errout;
1318 }
1319
Alan Cox77451e52008-07-16 21:57:02 +01001320 if (info->port.xmit_buf)
Jiri Slaby02f11752006-12-08 02:39:28 -08001321 free_page(page);
1322 else
Alan Cox77451e52008-07-16 21:57:02 +01001323 info->port.xmit_buf = (unsigned char *)page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001325 spin_unlock_irqrestore(&card->card_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326
Jiri Slabyd13549f2009-09-19 13:13:12 -07001327 cy_set_line_char(info, tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328
Jiri Slaby2693f482009-06-11 12:31:06 +01001329 if (!cy_is_Z(card)) {
Jiri Slaby02f11752006-12-08 02:39:28 -08001330 channel &= 0x03;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001332 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08001333
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07001334 cyy_writeb(info, CyCAR, channel);
Jiri Slaby02f11752006-12-08 02:39:28 -08001335
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07001336 cyy_writeb(info, CyRTPR,
Jiri Slaby02f11752006-12-08 02:39:28 -08001337 (info->default_timeout ? info->default_timeout : 0x02));
1338 /* 10ms rx timeout */
1339
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07001340 cyy_issue_cmd(info, CyCHAN_CTL | CyENB_RCVR | CyENB_XMTR);
Jiri Slaby02f11752006-12-08 02:39:28 -08001341
Jiri Slaby4d768202009-09-19 13:13:15 -07001342 cyy_change_rts_dtr(info, TIOCM_RTS | TIOCM_DTR, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07001344 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyRxData);
Jiri Slaby02f11752006-12-08 02:39:28 -08001345 } else {
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001346 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
Jiri Slaby02f11752006-12-08 02:39:28 -08001347
Jiri Slaby2693f482009-06-11 12:31:06 +01001348 if (!cyz_is_loaded(card))
Jiri Slaby02f11752006-12-08 02:39:28 -08001349 return -ENODEV;
Jiri Slaby02f11752006-12-08 02:39:28 -08001350
Jiri Slaby02f11752006-12-08 02:39:28 -08001351#ifdef CY_DEBUG_OPEN
Jiri Slaby21719192007-05-08 00:36:42 -07001352 printk(KERN_DEBUG "cyc startup Z card %d, channel %d, "
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001353 "base_addr %p\n", card, channel, card->base_addr);
Jiri Slaby02f11752006-12-08 02:39:28 -08001354#endif
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001355 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08001356
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001357 cy_writel(&ch_ctrl->op_mode, C_CH_ENABLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358#ifdef Z_WAKE
1359#ifdef CONFIG_CYZ_INTR
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001360 cy_writel(&ch_ctrl->intr_enable,
Jiri Slaby02f11752006-12-08 02:39:28 -08001361 C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM |
1362 C_IN_RXNNDT | C_IN_IOCTLW | C_IN_MDCD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363#else
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001364 cy_writel(&ch_ctrl->intr_enable,
Jiri Slaby02f11752006-12-08 02:39:28 -08001365 C_IN_IOCTLW | C_IN_MDCD);
1366#endif /* CONFIG_CYZ_INTR */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367#else
1368#ifdef CONFIG_CYZ_INTR
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001369 cy_writel(&ch_ctrl->intr_enable,
Jiri Slaby02f11752006-12-08 02:39:28 -08001370 C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM |
1371 C_IN_RXNNDT | C_IN_MDCD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372#else
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001373 cy_writel(&ch_ctrl->intr_enable, C_IN_MDCD);
Jiri Slaby02f11752006-12-08 02:39:28 -08001374#endif /* CONFIG_CYZ_INTR */
1375#endif /* Z_WAKE */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376
Jiri Slaby875b2062007-05-08 00:36:49 -07001377 retval = cyz_issue_cmd(card, channel, C_CM_IOCTL, 0L);
Jiri Slaby02f11752006-12-08 02:39:28 -08001378 if (retval != 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07001379 printk(KERN_ERR "cyc:startup(1) retval on ttyC%d was "
1380 "%x\n", info->line, retval);
Jiri Slaby02f11752006-12-08 02:39:28 -08001381 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382
Jiri Slaby02f11752006-12-08 02:39:28 -08001383 /* Flush RX buffers before raising DTR and RTS */
Jiri Slaby875b2062007-05-08 00:36:49 -07001384 retval = cyz_issue_cmd(card, channel, C_CM_FLUSH_RX, 0L);
Jiri Slaby02f11752006-12-08 02:39:28 -08001385 if (retval != 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07001386 printk(KERN_ERR "cyc:startup(2) retval on ttyC%d was "
1387 "%x\n", info->line, retval);
Jiri Slaby02f11752006-12-08 02:39:28 -08001388 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389
Jiri Slaby02f11752006-12-08 02:39:28 -08001390 /* set timeout !!! */
1391 /* set RTS and DTR !!! */
Jiri Slaby4d768202009-09-19 13:13:15 -07001392 tty_port_raise_dtr_rts(&info->port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393
Jiri Slaby02f11752006-12-08 02:39:28 -08001394 /* enable send, recv, modem !!! */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396
Jiri Slabycc7fdf42009-09-19 13:13:15 -07001397 info->port.flags |= ASYNC_INITIALIZED;
1398
1399 clear_bit(TTY_IO_ERROR, &tty->flags);
1400 info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1401 info->breakon = info->breakoff = 0;
1402 memset((char *)&info->idle_stats, 0, sizeof(info->idle_stats));
1403 info->idle_stats.in_use =
1404 info->idle_stats.recv_idle =
1405 info->idle_stats.xmit_idle = jiffies;
1406
1407 spin_unlock_irqrestore(&card->card_lock, flags);
1408
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409#ifdef CY_DEBUG_OPEN
Jiri Slaby21719192007-05-08 00:36:42 -07001410 printk(KERN_DEBUG "cyc startup done\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411#endif
1412 return 0;
1413
1414errout:
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001415 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slabycc7fdf42009-09-19 13:13:15 -07001416 free_page(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417 return retval;
Jiri Slaby02f11752006-12-08 02:39:28 -08001418} /* startup */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419
Jiri Slaby02f11752006-12-08 02:39:28 -08001420static void start_xmit(struct cyclades_port *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421{
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07001422 struct cyclades_card *card = info->card;
Jiri Slaby02f11752006-12-08 02:39:28 -08001423 unsigned long flags;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07001424 int channel = info->line - card->first_line;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425
Jiri Slaby2693f482009-06-11 12:31:06 +01001426 if (!cy_is_Z(card)) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001427 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07001428 cyy_writeb(info, CyCAR, channel & 0x03);
1429 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyTxRdy);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001430 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08001431 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432#ifdef CONFIG_CYZ_INTR
Jiri Slaby02f11752006-12-08 02:39:28 -08001433 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001435 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby875b2062007-05-08 00:36:49 -07001436 retval = cyz_issue_cmd(card, channel, C_CM_INTBACK, 0L);
Jiri Slaby02f11752006-12-08 02:39:28 -08001437 if (retval != 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07001438 printk(KERN_ERR "cyc:start_xmit retval on ttyC%d was "
1439 "%x\n", info->line, retval);
Jiri Slaby02f11752006-12-08 02:39:28 -08001440 }
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001441 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08001442#else /* CONFIG_CYZ_INTR */
1443 /* Don't have to do anything at this time */
1444#endif /* CONFIG_CYZ_INTR */
1445 }
1446} /* start_xmit */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447
1448/*
1449 * This routine shuts down a serial port; interrupts are disabled,
1450 * and DTR is dropped if the hangup on close termio flag is on.
1451 */
Jiri Slabyd13549f2009-09-19 13:13:12 -07001452static void cy_shutdown(struct cyclades_port *info, struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453{
Jiri Slaby875b2062007-05-08 00:36:49 -07001454 struct cyclades_card *card;
Jiri Slaby02f11752006-12-08 02:39:28 -08001455 unsigned long flags;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07001456 int channel;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457
Alan Cox77451e52008-07-16 21:57:02 +01001458 if (!(info->port.flags & ASYNC_INITIALIZED))
Jiri Slaby02f11752006-12-08 02:39:28 -08001459 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460
Jiri Slaby02f11752006-12-08 02:39:28 -08001461 card = info->card;
Jiri Slaby875b2062007-05-08 00:36:49 -07001462 channel = info->line - card->first_line;
Jiri Slaby2693f482009-06-11 12:31:06 +01001463 if (!cy_is_Z(card)) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001464 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08001465
1466 /* Clear delta_msr_wait queue to avoid mem leaks. */
Alan Coxbdc04e32009-09-19 13:13:31 -07001467 wake_up_interruptible(&info->port.delta_msr_wait);
Jiri Slaby02f11752006-12-08 02:39:28 -08001468
Alan Cox77451e52008-07-16 21:57:02 +01001469 if (info->port.xmit_buf) {
Jiri Slaby02f11752006-12-08 02:39:28 -08001470 unsigned char *temp;
Alan Cox77451e52008-07-16 21:57:02 +01001471 temp = info->port.xmit_buf;
1472 info->port.xmit_buf = NULL;
Jiri Slaby02f11752006-12-08 02:39:28 -08001473 free_page((unsigned long)temp);
1474 }
Jiri Slaby4d768202009-09-19 13:13:15 -07001475 if (tty->termios->c_cflag & HUPCL)
1476 cyy_change_rts_dtr(info, 0, TIOCM_RTS | TIOCM_DTR);
1477
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07001478 cyy_issue_cmd(info, CyCHAN_CTL | CyDIS_RCVR);
Jiri Slaby02f11752006-12-08 02:39:28 -08001479 /* it may be appropriate to clear _XMIT at
1480 some later date (after testing)!!! */
1481
Jiri Slabyd13549f2009-09-19 13:13:12 -07001482 set_bit(TTY_IO_ERROR, &tty->flags);
Alan Cox77451e52008-07-16 21:57:02 +01001483 info->port.flags &= ~ASYNC_INITIALIZED;
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001484 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08001485 } else {
Jiri Slaby02f11752006-12-08 02:39:28 -08001486#ifdef CY_DEBUG_OPEN
Jiri Slaby21719192007-05-08 00:36:42 -07001487 printk(KERN_DEBUG "cyc shutdown Z card %d, channel %d, "
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001488 "base_addr %p\n", card, channel, card->base_addr);
Jiri Slaby02f11752006-12-08 02:39:28 -08001489#endif
1490
Jiri Slaby2693f482009-06-11 12:31:06 +01001491 if (!cyz_is_loaded(card))
Jiri Slaby02f11752006-12-08 02:39:28 -08001492 return;
Jiri Slaby02f11752006-12-08 02:39:28 -08001493
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001494 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08001495
Alan Cox77451e52008-07-16 21:57:02 +01001496 if (info->port.xmit_buf) {
Jiri Slaby02f11752006-12-08 02:39:28 -08001497 unsigned char *temp;
Alan Cox77451e52008-07-16 21:57:02 +01001498 temp = info->port.xmit_buf;
1499 info->port.xmit_buf = NULL;
Jiri Slaby02f11752006-12-08 02:39:28 -08001500 free_page((unsigned long)temp);
1501 }
1502
Jiri Slaby4d768202009-09-19 13:13:15 -07001503 if (tty->termios->c_cflag & HUPCL)
1504 tty_port_lower_dtr_rts(&info->port);
Jiri Slaby02f11752006-12-08 02:39:28 -08001505
Jiri Slabyd13549f2009-09-19 13:13:12 -07001506 set_bit(TTY_IO_ERROR, &tty->flags);
Alan Cox77451e52008-07-16 21:57:02 +01001507 info->port.flags &= ~ASYNC_INITIALIZED;
Jiri Slaby02f11752006-12-08 02:39:28 -08001508
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001509 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08001510 }
1511
1512#ifdef CY_DEBUG_OPEN
Jiri Slaby21719192007-05-08 00:36:42 -07001513 printk(KERN_DEBUG "cyc shutdown done\n");
Jiri Slaby02f11752006-12-08 02:39:28 -08001514#endif
Jiri Slaby02f11752006-12-08 02:39:28 -08001515} /* shutdown */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516
1517/*
1518 * ------------------------------------------------------------
1519 * cy_open() and friends
1520 * ------------------------------------------------------------
1521 */
1522
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523/*
1524 * This routine is called whenever a serial port is opened. It
1525 * performs the serial-specific initialization for the tty structure.
1526 */
Jiri Slaby02f11752006-12-08 02:39:28 -08001527static int cy_open(struct tty_struct *tty, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528{
Jiri Slaby02f11752006-12-08 02:39:28 -08001529 struct cyclades_port *info;
Jiri Slaby65f76a82007-10-18 03:06:22 -07001530 unsigned int i, line;
1531 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532
Jiri Slaby02f11752006-12-08 02:39:28 -08001533 line = tty->index;
Alan Cox15ed6cc2008-04-30 00:53:55 -07001534 if (tty->index < 0 || NR_PORTS <= line)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535 return -ENODEV;
Alan Cox15ed6cc2008-04-30 00:53:55 -07001536
Jiri Slabydd025c02007-05-08 00:37:02 -07001537 for (i = 0; i < NR_CARDS; i++)
1538 if (line < cy_card[i].first_line + cy_card[i].nports &&
1539 line >= cy_card[i].first_line)
1540 break;
1541 if (i >= NR_CARDS)
1542 return -ENODEV;
1543 info = &cy_card[i].ports[line - cy_card[i].first_line];
Alan Cox15ed6cc2008-04-30 00:53:55 -07001544 if (info->line < 0)
Jiri Slaby02f11752006-12-08 02:39:28 -08001545 return -ENODEV;
Jiri Slaby02f11752006-12-08 02:39:28 -08001546
1547 /* If the card's firmware hasn't been loaded,
1548 treat it as absent from the system. This
1549 will make the user pay attention.
1550 */
Jiri Slaby2693f482009-06-11 12:31:06 +01001551 if (cy_is_Z(info->card)) {
Jiri Slaby875b2062007-05-08 00:36:49 -07001552 struct cyclades_card *cinfo = info->card;
Jiri Slaby02f11752006-12-08 02:39:28 -08001553 struct FIRM_ID __iomem *firm_id = cinfo->base_addr + ID_ADDRESS;
1554
Jiri Slaby2693f482009-06-11 12:31:06 +01001555 if (!cyz_is_loaded(cinfo)) {
1556 if (cinfo->hw_ver == ZE_V1 && cyz_fpga_loaded(cinfo) &&
Jiri Slaby101b8152009-06-11 12:30:10 +01001557 readl(&firm_id->signature) ==
1558 ZFIRM_HLT) {
Jiri Slaby21719192007-05-08 00:36:42 -07001559 printk(KERN_ERR "cyc:Cyclades-Z Error: you "
1560 "need an external power supply for "
1561 "this number of ports.\nFirmware "
1562 "halted.\n");
Jiri Slaby02f11752006-12-08 02:39:28 -08001563 } else {
Jiri Slaby21719192007-05-08 00:36:42 -07001564 printk(KERN_ERR "cyc:Cyclades-Z firmware not "
1565 "yet loaded\n");
Jiri Slaby02f11752006-12-08 02:39:28 -08001566 }
1567 return -ENODEV;
1568 }
1569#ifdef CONFIG_CYZ_INTR
1570 else {
1571 /* In case this Z board is operating in interrupt mode, its
1572 interrupts should be enabled as soon as the first open
1573 happens to one of its ports. */
1574 if (!cinfo->intr_enabled) {
Jiri Slaby97e87f82009-06-11 12:29:27 +01001575 u16 intr;
Jiri Slaby02f11752006-12-08 02:39:28 -08001576
Jiri Slaby02f11752006-12-08 02:39:28 -08001577 /* Enable interrupts on the PLX chip */
Jiri Slaby97e87f82009-06-11 12:29:27 +01001578 intr = readw(&cinfo->ctl_addr.p9060->
1579 intr_ctrl_stat) | 0x0900;
1580 cy_writew(&cinfo->ctl_addr.p9060->
1581 intr_ctrl_stat, intr);
Jiri Slaby02f11752006-12-08 02:39:28 -08001582 /* Enable interrupts on the FW */
1583 retval = cyz_issue_cmd(cinfo, 0,
1584 C_CM_IRQ_ENBL, 0L);
1585 if (retval != 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07001586 printk(KERN_ERR "cyc:IRQ enable retval "
1587 "was %x\n", retval);
Jiri Slaby02f11752006-12-08 02:39:28 -08001588 }
Jiri Slaby02f11752006-12-08 02:39:28 -08001589 cinfo->intr_enabled = 1;
1590 }
1591 }
1592#endif /* CONFIG_CYZ_INTR */
1593 /* Make sure this Z port really exists in hardware */
1594 if (info->line > (cinfo->first_line + cinfo->nports - 1))
1595 return -ENODEV;
1596 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001597#ifdef CY_DEBUG_OTHER
Jiri Slaby21719192007-05-08 00:36:42 -07001598 printk(KERN_DEBUG "cyc:cy_open ttyC%d\n", info->line);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599#endif
Jiri Slaby02f11752006-12-08 02:39:28 -08001600 tty->driver_data = info;
Alan Cox15ed6cc2008-04-30 00:53:55 -07001601 if (serial_paranoia_check(info, tty->name, "cy_open"))
Jiri Slaby02f11752006-12-08 02:39:28 -08001602 return -ENODEV;
Alan Cox15ed6cc2008-04-30 00:53:55 -07001603
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604#ifdef CY_DEBUG_OPEN
Jiri Slaby21719192007-05-08 00:36:42 -07001605 printk(KERN_DEBUG "cyc:cy_open ttyC%d, count = %d\n", info->line,
Alan Cox77451e52008-07-16 21:57:02 +01001606 info->port.count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607#endif
Alan Cox77451e52008-07-16 21:57:02 +01001608 info->port.count++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609#ifdef CY_DEBUG_COUNT
Jiri Slaby21719192007-05-08 00:36:42 -07001610 printk(KERN_DEBUG "cyc:cy_open (%d): incrementing count to %d\n",
Alan Cox77451e52008-07-16 21:57:02 +01001611 current->pid, info->port.count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001612#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613
Jiri Slaby02f11752006-12-08 02:39:28 -08001614 /*
1615 * If the port is the middle of closing, bail out now
1616 */
Alan Cox77451e52008-07-16 21:57:02 +01001617 if (tty_hung_up_p(filp) || (info->port.flags & ASYNC_CLOSING)) {
1618 wait_event_interruptible(info->port.close_wait,
1619 !(info->port.flags & ASYNC_CLOSING));
1620 return (info->port.flags & ASYNC_HUP_NOTIFY) ? -EAGAIN: -ERESTARTSYS;
Jiri Slaby02f11752006-12-08 02:39:28 -08001621 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622
Jiri Slaby02f11752006-12-08 02:39:28 -08001623 /*
1624 * Start up serial port
1625 */
Jiri Slabyd13549f2009-09-19 13:13:12 -07001626 retval = cy_startup(info, tty);
Alan Cox15ed6cc2008-04-30 00:53:55 -07001627 if (retval)
Jiri Slaby02f11752006-12-08 02:39:28 -08001628 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629
Jiri Slabyf0737572009-09-19 13:13:12 -07001630 retval = tty_port_block_til_ready(&info->port, tty, filp);
Jiri Slaby02f11752006-12-08 02:39:28 -08001631 if (retval) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632#ifdef CY_DEBUG_OPEN
Jiri Slaby21719192007-05-08 00:36:42 -07001633 printk(KERN_DEBUG "cyc:cy_open returning after block_til_ready "
1634 "with %d\n", retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635#endif
Jiri Slaby02f11752006-12-08 02:39:28 -08001636 return retval;
1637 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001638
Jiri Slaby02f11752006-12-08 02:39:28 -08001639 info->throttle = 0;
Jiri Slabyd13549f2009-09-19 13:13:12 -07001640 tty_port_tty_set(&info->port, tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641
1642#ifdef CY_DEBUG_OPEN
Jiri Slaby21719192007-05-08 00:36:42 -07001643 printk(KERN_DEBUG "cyc:cy_open done\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644#endif
Jiri Slaby02f11752006-12-08 02:39:28 -08001645 return 0;
1646} /* cy_open */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647
1648/*
1649 * cy_wait_until_sent() --- wait until the transmitter is empty
1650 */
Jiri Slaby02f11752006-12-08 02:39:28 -08001651static void cy_wait_until_sent(struct tty_struct *tty, int timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652{
Jiri Slaby875b2062007-05-08 00:36:49 -07001653 struct cyclades_card *card;
Jiri Slabycab9bdd2007-05-08 00:35:51 -07001654 struct cyclades_port *info = tty->driver_data;
Jiri Slaby02f11752006-12-08 02:39:28 -08001655 unsigned long orig_jiffies;
1656 int char_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657
Jiri Slaby02f11752006-12-08 02:39:28 -08001658 if (serial_paranoia_check(info, tty->name, "cy_wait_until_sent"))
1659 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660
Jiri Slaby02f11752006-12-08 02:39:28 -08001661 if (info->xmit_fifo_size == 0)
1662 return; /* Just in case.... */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663
Jiri Slaby02f11752006-12-08 02:39:28 -08001664 orig_jiffies = jiffies;
Alan Cox978e5952008-04-30 00:53:59 -07001665 lock_kernel();
Jiri Slaby02f11752006-12-08 02:39:28 -08001666 /*
1667 * Set the check interval to be 1/5 of the estimated time to
1668 * send a single character, and make it at least 1. The check
1669 * interval should also be less than the timeout.
1670 *
1671 * Note: we have to use pretty tight timings here to satisfy
1672 * the NIST-PCTS.
1673 */
1674 char_time = (info->timeout - HZ / 50) / info->xmit_fifo_size;
1675 char_time = char_time / 5;
1676 if (char_time <= 0)
1677 char_time = 1;
1678 if (timeout < 0)
1679 timeout = 0;
1680 if (timeout)
1681 char_time = min(char_time, timeout);
1682 /*
1683 * If the transmitter hasn't cleared in twice the approximate
1684 * amount of time to send the entire FIFO, it probably won't
1685 * ever clear. This assumes the UART isn't doing flow
1686 * control, which is currently the case. Hence, if it ever
1687 * takes longer than info->timeout, this is probably due to a
1688 * UART bug of some kind. So, we clamp the timeout parameter at
1689 * 2*info->timeout.
1690 */
1691 if (!timeout || timeout > 2 * info->timeout)
1692 timeout = 2 * info->timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001693#ifdef CY_DEBUG_WAIT_UNTIL_SENT
Jiri Slaby21719192007-05-08 00:36:42 -07001694 printk(KERN_DEBUG "In cy_wait_until_sent(%d) check=%d, jiff=%lu...",
1695 timeout, char_time, jiffies);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001696#endif
Jiri Slaby02f11752006-12-08 02:39:28 -08001697 card = info->card;
Jiri Slaby2693f482009-06-11 12:31:06 +01001698 if (!cy_is_Z(card)) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07001699 while (cyy_readb(info, CySRER) & CyTxRdy) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001700#ifdef CY_DEBUG_WAIT_UNTIL_SENT
Jiri Slaby21719192007-05-08 00:36:42 -07001701 printk(KERN_DEBUG "Not clean (jiff=%lu)...", jiffies);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001702#endif
Jiri Slaby02f11752006-12-08 02:39:28 -08001703 if (msleep_interruptible(jiffies_to_msecs(char_time)))
1704 break;
1705 if (timeout && time_after(jiffies, orig_jiffies +
1706 timeout))
1707 break;
1708 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001709 }
Jiri Slaby02f11752006-12-08 02:39:28 -08001710 /* Run one more char cycle */
1711 msleep_interruptible(jiffies_to_msecs(char_time * 5));
Alan Cox978e5952008-04-30 00:53:59 -07001712 unlock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713#ifdef CY_DEBUG_WAIT_UNTIL_SENT
Jiri Slaby21719192007-05-08 00:36:42 -07001714 printk(KERN_DEBUG "Clean (jiff=%lu)...done\n", jiffies);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715#endif
1716}
1717
Alan Cox978e5952008-04-30 00:53:59 -07001718static void cy_flush_buffer(struct tty_struct *tty)
1719{
1720 struct cyclades_port *info = tty->driver_data;
1721 struct cyclades_card *card;
1722 int channel, retval;
1723 unsigned long flags;
1724
1725#ifdef CY_DEBUG_IO
1726 printk(KERN_DEBUG "cyc:cy_flush_buffer ttyC%d\n", info->line);
1727#endif
1728
1729 if (serial_paranoia_check(info, tty->name, "cy_flush_buffer"))
1730 return;
1731
1732 card = info->card;
1733 channel = info->line - card->first_line;
1734
1735 spin_lock_irqsave(&card->card_lock, flags);
1736 info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1737 spin_unlock_irqrestore(&card->card_lock, flags);
1738
Jiri Slaby2693f482009-06-11 12:31:06 +01001739 if (cy_is_Z(card)) { /* If it is a Z card, flush the on-board
Alan Cox978e5952008-04-30 00:53:59 -07001740 buffers as well */
1741 spin_lock_irqsave(&card->card_lock, flags);
1742 retval = cyz_issue_cmd(card, channel, C_CM_FLUSH_TX, 0L);
1743 if (retval != 0) {
1744 printk(KERN_ERR "cyc: flush_buffer retval on ttyC%d "
1745 "was %x\n", info->line, retval);
1746 }
1747 spin_unlock_irqrestore(&card->card_lock, flags);
1748 }
1749 tty_wakeup(tty);
1750} /* cy_flush_buffer */
1751
1752
Alan Coxe936ffd2009-09-19 13:13:22 -07001753static void cy_do_close(struct tty_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754{
Alan Coxe936ffd2009-09-19 13:13:22 -07001755 struct cyclades_port *info = container_of(port, struct cyclades_port,
1756 port);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001757 struct cyclades_card *card;
Jiri Slaby02f11752006-12-08 02:39:28 -08001758 unsigned long flags;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07001759 int channel;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001761 card = info->card;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07001762 channel = info->line - card->first_line;
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001763 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08001764
Jiri Slaby2693f482009-06-11 12:31:06 +01001765 if (!cy_is_Z(card)) {
Jiri Slaby02f11752006-12-08 02:39:28 -08001766 /* Stop accepting input */
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07001767 cyy_writeb(info, CyCAR, channel & 0x03);
1768 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyRxData);
Alan Cox77451e52008-07-16 21:57:02 +01001769 if (info->port.flags & ASYNC_INITIALIZED) {
Alan Cox15ed6cc2008-04-30 00:53:55 -07001770 /* Waiting for on-board buffers to be empty before
1771 closing the port */
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001772 spin_unlock_irqrestore(&card->card_lock, flags);
Alan Coxe936ffd2009-09-19 13:13:22 -07001773 cy_wait_until_sent(port->tty, info->timeout);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001774 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08001775 }
1776 } else {
1777#ifdef Z_WAKE
Alan Cox15ed6cc2008-04-30 00:53:55 -07001778 /* Waiting for on-board buffers to be empty before closing
1779 the port */
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001780 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
Jiri Slaby02f11752006-12-08 02:39:28 -08001781 int retval;
1782
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001783 if (readl(&ch_ctrl->flow_status) != C_FS_TXIDLE) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001784 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLW, 0L);
Jiri Slaby02f11752006-12-08 02:39:28 -08001785 if (retval != 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07001786 printk(KERN_DEBUG "cyc:cy_close retval on "
1787 "ttyC%d was %x\n", info->line, retval);
Jiri Slaby02f11752006-12-08 02:39:28 -08001788 }
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001789 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby2c7fea92007-05-08 00:36:51 -07001790 wait_for_completion_interruptible(&info->shutdown_wait);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001791 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08001792 }
1793#endif
1794 }
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001795 spin_unlock_irqrestore(&card->card_lock, flags);
Alan Coxe936ffd2009-09-19 13:13:22 -07001796 cy_shutdown(info, port->tty);
1797}
Jiri Slaby02f11752006-12-08 02:39:28 -08001798
Alan Coxe936ffd2009-09-19 13:13:22 -07001799/*
1800 * This routine is called when a particular tty device is closed.
1801 */
1802static void cy_close(struct tty_struct *tty, struct file *filp)
1803{
1804 struct cyclades_port *info = tty->driver_data;
1805 if (!info || serial_paranoia_check(info, tty->name, "cy_close"))
1806 return;
1807 tty_port_close(&info->port, tty, filp);
Jiri Slaby02f11752006-12-08 02:39:28 -08001808} /* cy_close */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001809
1810/* This routine gets called when tty_write has put something into
1811 * the write_queue. The characters may come from user space or
1812 * kernel space.
1813 *
1814 * This routine will return the number of characters actually
1815 * accepted for writing.
1816 *
1817 * If the port is not already transmitting stuff, start it off by
1818 * enabling interrupts. The interrupt service routine will then
1819 * ensure that the characters are sent.
1820 * If the port is already active, there is no need to kick it.
1821 *
1822 */
Jiri Slaby02f11752006-12-08 02:39:28 -08001823static int cy_write(struct tty_struct *tty, const unsigned char *buf, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001824{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07001825 struct cyclades_port *info = tty->driver_data;
Jiri Slaby02f11752006-12-08 02:39:28 -08001826 unsigned long flags;
1827 int c, ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828
1829#ifdef CY_DEBUG_IO
Jiri Slaby21719192007-05-08 00:36:42 -07001830 printk(KERN_DEBUG "cyc:cy_write ttyC%d\n", info->line);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001831#endif
1832
Alan Cox15ed6cc2008-04-30 00:53:55 -07001833 if (serial_paranoia_check(info, tty->name, "cy_write"))
Jiri Slaby02f11752006-12-08 02:39:28 -08001834 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835
Alan Cox77451e52008-07-16 21:57:02 +01001836 if (!info->port.xmit_buf)
Jiri Slaby02f11752006-12-08 02:39:28 -08001837 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001839 spin_lock_irqsave(&info->card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08001840 while (1) {
Harvey Harrison1a4e2352008-04-30 00:53:52 -07001841 c = min(count, (int)(SERIAL_XMIT_SIZE - info->xmit_cnt - 1));
1842 c = min(c, (int)(SERIAL_XMIT_SIZE - info->xmit_head));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001843
Jiri Slaby02f11752006-12-08 02:39:28 -08001844 if (c <= 0)
1845 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846
Alan Cox77451e52008-07-16 21:57:02 +01001847 memcpy(info->port.xmit_buf + info->xmit_head, buf, c);
Jiri Slaby02f11752006-12-08 02:39:28 -08001848 info->xmit_head = (info->xmit_head + c) &
1849 (SERIAL_XMIT_SIZE - 1);
1850 info->xmit_cnt += c;
1851 buf += c;
1852 count -= c;
1853 ret += c;
1854 }
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001855 spin_unlock_irqrestore(&info->card->card_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856
Jiri Slaby02f11752006-12-08 02:39:28 -08001857 info->idle_stats.xmit_bytes += ret;
1858 info->idle_stats.xmit_idle = jiffies;
1859
Alan Cox15ed6cc2008-04-30 00:53:55 -07001860 if (info->xmit_cnt && !tty->stopped && !tty->hw_stopped)
Jiri Slaby02f11752006-12-08 02:39:28 -08001861 start_xmit(info);
Alan Cox15ed6cc2008-04-30 00:53:55 -07001862
Jiri Slaby02f11752006-12-08 02:39:28 -08001863 return ret;
1864} /* cy_write */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865
1866/*
1867 * This routine is called by the kernel to write a single
1868 * character to the tty device. If the kernel uses this routine,
1869 * it must call the flush_chars() routine (if defined) when it is
1870 * done stuffing characters into the driver. If there is no room
1871 * in the queue, the character is ignored.
1872 */
Alan Cox76b25a52008-04-30 00:54:03 -07001873static int cy_put_char(struct tty_struct *tty, unsigned char ch)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001874{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07001875 struct cyclades_port *info = tty->driver_data;
Jiri Slaby02f11752006-12-08 02:39:28 -08001876 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877
1878#ifdef CY_DEBUG_IO
Jiri Slaby21719192007-05-08 00:36:42 -07001879 printk(KERN_DEBUG "cyc:cy_put_char ttyC%d\n", info->line);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880#endif
1881
Jiri Slaby02f11752006-12-08 02:39:28 -08001882 if (serial_paranoia_check(info, tty->name, "cy_put_char"))
Alan Cox76b25a52008-04-30 00:54:03 -07001883 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001884
Alan Cox77451e52008-07-16 21:57:02 +01001885 if (!info->port.xmit_buf)
Alan Cox76b25a52008-04-30 00:54:03 -07001886 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001888 spin_lock_irqsave(&info->card->card_lock, flags);
Jiri Slaby90cc3012006-12-08 02:39:31 -08001889 if (info->xmit_cnt >= (int)(SERIAL_XMIT_SIZE - 1)) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001890 spin_unlock_irqrestore(&info->card->card_lock, flags);
Alan Cox76b25a52008-04-30 00:54:03 -07001891 return 0;
Jiri Slaby02f11752006-12-08 02:39:28 -08001892 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893
Alan Cox77451e52008-07-16 21:57:02 +01001894 info->port.xmit_buf[info->xmit_head++] = ch;
Jiri Slaby02f11752006-12-08 02:39:28 -08001895 info->xmit_head &= SERIAL_XMIT_SIZE - 1;
1896 info->xmit_cnt++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897 info->idle_stats.xmit_bytes++;
1898 info->idle_stats.xmit_idle = jiffies;
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001899 spin_unlock_irqrestore(&info->card->card_lock, flags);
Alan Cox76b25a52008-04-30 00:54:03 -07001900 return 1;
Jiri Slaby02f11752006-12-08 02:39:28 -08001901} /* cy_put_char */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902
1903/*
1904 * This routine is called by the kernel after it has written a
Alan Cox15ed6cc2008-04-30 00:53:55 -07001905 * series of characters to the tty device using put_char().
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906 */
Jiri Slaby02f11752006-12-08 02:39:28 -08001907static void cy_flush_chars(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07001909 struct cyclades_port *info = tty->driver_data;
Jiri Slaby02f11752006-12-08 02:39:28 -08001910
Linus Torvalds1da177e2005-04-16 15:20:36 -07001911#ifdef CY_DEBUG_IO
Jiri Slaby21719192007-05-08 00:36:42 -07001912 printk(KERN_DEBUG "cyc:cy_flush_chars ttyC%d\n", info->line);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913#endif
1914
Jiri Slaby02f11752006-12-08 02:39:28 -08001915 if (serial_paranoia_check(info, tty->name, "cy_flush_chars"))
1916 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917
Jiri Slaby02f11752006-12-08 02:39:28 -08001918 if (info->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
Alan Cox77451e52008-07-16 21:57:02 +01001919 !info->port.xmit_buf)
Jiri Slaby02f11752006-12-08 02:39:28 -08001920 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921
Jiri Slaby02f11752006-12-08 02:39:28 -08001922 start_xmit(info);
1923} /* cy_flush_chars */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001924
1925/*
1926 * This routine returns the numbers of characters the tty driver
1927 * will accept for queuing to be written. This number is subject
1928 * to change as output buffers get emptied, or if the output flow
1929 * control is activated.
1930 */
Jiri Slaby02f11752006-12-08 02:39:28 -08001931static int cy_write_room(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001932{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07001933 struct cyclades_port *info = tty->driver_data;
Jiri Slaby02f11752006-12-08 02:39:28 -08001934 int ret;
1935
Linus Torvalds1da177e2005-04-16 15:20:36 -07001936#ifdef CY_DEBUG_IO
Jiri Slaby21719192007-05-08 00:36:42 -07001937 printk(KERN_DEBUG "cyc:cy_write_room ttyC%d\n", info->line);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001938#endif
1939
Jiri Slaby02f11752006-12-08 02:39:28 -08001940 if (serial_paranoia_check(info, tty->name, "cy_write_room"))
1941 return 0;
1942 ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1;
1943 if (ret < 0)
1944 ret = 0;
1945 return ret;
1946} /* cy_write_room */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001947
Jiri Slaby02f11752006-12-08 02:39:28 -08001948static int cy_chars_in_buffer(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07001950 struct cyclades_port *info = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951
Jiri Slaby02f11752006-12-08 02:39:28 -08001952 if (serial_paranoia_check(info, tty->name, "cy_chars_in_buffer"))
1953 return 0;
1954
Linus Torvalds1da177e2005-04-16 15:20:36 -07001955#ifdef Z_EXT_CHARS_IN_BUFFER
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001956 if (!cy_is_Z(info->card)) {
Jiri Slaby02f11752006-12-08 02:39:28 -08001957#endif /* Z_EXT_CHARS_IN_BUFFER */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001958#ifdef CY_DEBUG_IO
Jiri Slaby21719192007-05-08 00:36:42 -07001959 printk(KERN_DEBUG "cyc:cy_chars_in_buffer ttyC%d %d\n",
1960 info->line, info->xmit_cnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961#endif
Jiri Slaby02f11752006-12-08 02:39:28 -08001962 return info->xmit_cnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001963#ifdef Z_EXT_CHARS_IN_BUFFER
Jiri Slaby02f11752006-12-08 02:39:28 -08001964 } else {
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001965 struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
Jiri Slaby02f11752006-12-08 02:39:28 -08001966 int char_count;
Jiri Slabyad39c302007-05-08 00:35:49 -07001967 __u32 tx_put, tx_get, tx_bufsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968
Alan Cox978e5952008-04-30 00:53:59 -07001969 lock_kernel();
Jiri Slabydb05c3b2007-05-08 00:35:46 -07001970 tx_get = readl(&buf_ctrl->tx_get);
1971 tx_put = readl(&buf_ctrl->tx_put);
1972 tx_bufsize = readl(&buf_ctrl->tx_bufsize);
Jiri Slaby02f11752006-12-08 02:39:28 -08001973 if (tx_put >= tx_get)
1974 char_count = tx_put - tx_get;
1975 else
1976 char_count = tx_put - tx_get + tx_bufsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001977#ifdef CY_DEBUG_IO
Jiri Slaby21719192007-05-08 00:36:42 -07001978 printk(KERN_DEBUG "cyc:cy_chars_in_buffer ttyC%d %d\n",
1979 info->line, info->xmit_cnt + char_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001980#endif
Alan Cox978e5952008-04-30 00:53:59 -07001981 unlock_kernel();
Jiri Slaby096dcfc2006-12-08 02:39:30 -08001982 return info->xmit_cnt + char_count;
Jiri Slaby02f11752006-12-08 02:39:28 -08001983 }
1984#endif /* Z_EXT_CHARS_IN_BUFFER */
1985} /* cy_chars_in_buffer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001986
1987/*
1988 * ------------------------------------------------------------
1989 * cy_ioctl() and friends
1990 * ------------------------------------------------------------
1991 */
1992
Klaus Kudielka1a86b5e2007-05-08 00:26:26 -07001993static void cyy_baud_calc(struct cyclades_port *info, __u32 baud)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001994{
Jiri Slaby02f11752006-12-08 02:39:28 -08001995 int co, co_val, bpr;
Klaus Kudielka1a86b5e2007-05-08 00:26:26 -07001996 __u32 cy_clock = ((info->chip_rev >= CD1400_REV_J) ? 60000000 :
Jiri Slaby02f11752006-12-08 02:39:28 -08001997 25000000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001998
Jiri Slaby02f11752006-12-08 02:39:28 -08001999 if (baud == 0) {
2000 info->tbpr = info->tco = info->rbpr = info->rco = 0;
2001 return;
2002 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002003
Jiri Slaby02f11752006-12-08 02:39:28 -08002004 /* determine which prescaler to use */
2005 for (co = 4, co_val = 2048; co; co--, co_val >>= 2) {
2006 if (cy_clock / co_val / baud > 63)
2007 break;
2008 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002009
Jiri Slaby02f11752006-12-08 02:39:28 -08002010 bpr = (cy_clock / co_val * 2 / baud + 1) / 2;
2011 if (bpr > 255)
2012 bpr = 255;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002013
Jiri Slaby02f11752006-12-08 02:39:28 -08002014 info->tbpr = info->rbpr = bpr;
2015 info->tco = info->rco = co;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002016}
2017
2018/*
2019 * This routine finds or computes the various line characteristics.
2020 * It used to be called config_setup
2021 */
Jiri Slabyd13549f2009-09-19 13:13:12 -07002022static void cy_set_line_char(struct cyclades_port *info, struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002023{
Jiri Slaby875b2062007-05-08 00:36:49 -07002024 struct cyclades_card *card;
Jiri Slaby02f11752006-12-08 02:39:28 -08002025 unsigned long flags;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002026 int channel;
Jiri Slaby02f11752006-12-08 02:39:28 -08002027 unsigned cflag, iflag;
Jiri Slaby02f11752006-12-08 02:39:28 -08002028 int baud, baud_rate = 0;
2029 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002030
Jiri Slabyd13549f2009-09-19 13:13:12 -07002031 if (!tty->termios) /* XXX can this happen at all? */
Jiri Slaby02f11752006-12-08 02:39:28 -08002032 return;
Alan Cox15ed6cc2008-04-30 00:53:55 -07002033
2034 if (info->line == -1)
Jiri Slaby02f11752006-12-08 02:39:28 -08002035 return;
Alan Cox15ed6cc2008-04-30 00:53:55 -07002036
Jiri Slabyd13549f2009-09-19 13:13:12 -07002037 cflag = tty->termios->c_cflag;
2038 iflag = tty->termios->c_iflag;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002039
Jiri Slaby02f11752006-12-08 02:39:28 -08002040 /*
2041 * Set up the tty->alt_speed kludge
2042 */
Jiri Slabyd13549f2009-09-19 13:13:12 -07002043 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
2044 tty->alt_speed = 57600;
2045 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
2046 tty->alt_speed = 115200;
2047 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
2048 tty->alt_speed = 230400;
2049 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
2050 tty->alt_speed = 460800;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002051
Jiri Slaby02f11752006-12-08 02:39:28 -08002052 card = info->card;
Jiri Slaby875b2062007-05-08 00:36:49 -07002053 channel = info->line - card->first_line;
Jiri Slaby02f11752006-12-08 02:39:28 -08002054
Jiri Slaby2693f482009-06-11 12:31:06 +01002055 if (!cy_is_Z(card)) {
Jiri Slaby46fb7822009-09-19 13:13:17 -07002056 u32 cflags;
2057
Jiri Slaby02f11752006-12-08 02:39:28 -08002058 /* baud rate */
Jiri Slabyd13549f2009-09-19 13:13:12 -07002059 baud = tty_get_baud_rate(tty);
Alan Cox77451e52008-07-16 21:57:02 +01002060 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
Jiri Slaby02f11752006-12-08 02:39:28 -08002061 ASYNC_SPD_CUST) {
2062 if (info->custom_divisor)
2063 baud_rate = info->baud / info->custom_divisor;
2064 else
2065 baud_rate = info->baud;
2066 } else if (baud > CD1400_MAX_SPEED) {
2067 baud = CD1400_MAX_SPEED;
2068 }
2069 /* find the baud index */
2070 for (i = 0; i < 20; i++) {
Alan Cox15ed6cc2008-04-30 00:53:55 -07002071 if (baud == baud_table[i])
Jiri Slaby02f11752006-12-08 02:39:28 -08002072 break;
Jiri Slaby02f11752006-12-08 02:39:28 -08002073 }
Alan Cox15ed6cc2008-04-30 00:53:55 -07002074 if (i == 20)
Jiri Slaby02f11752006-12-08 02:39:28 -08002075 i = 19; /* CD1400_MAX_SPEED */
Jiri Slaby02f11752006-12-08 02:39:28 -08002076
Alan Cox77451e52008-07-16 21:57:02 +01002077 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
Jiri Slaby02f11752006-12-08 02:39:28 -08002078 ASYNC_SPD_CUST) {
2079 cyy_baud_calc(info, baud_rate);
2080 } else {
2081 if (info->chip_rev >= CD1400_REV_J) {
2082 /* It is a CD1400 rev. J or later */
2083 info->tbpr = baud_bpr_60[i]; /* Tx BPR */
2084 info->tco = baud_co_60[i]; /* Tx CO */
2085 info->rbpr = baud_bpr_60[i]; /* Rx BPR */
2086 info->rco = baud_co_60[i]; /* Rx CO */
2087 } else {
2088 info->tbpr = baud_bpr_25[i]; /* Tx BPR */
2089 info->tco = baud_co_25[i]; /* Tx CO */
2090 info->rbpr = baud_bpr_25[i]; /* Rx BPR */
2091 info->rco = baud_co_25[i]; /* Rx CO */
2092 }
2093 }
2094 if (baud_table[i] == 134) {
2095 /* get it right for 134.5 baud */
2096 info->timeout = (info->xmit_fifo_size * HZ * 30 / 269) +
2097 2;
Alan Cox77451e52008-07-16 21:57:02 +01002098 } else if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
Jiri Slaby02f11752006-12-08 02:39:28 -08002099 ASYNC_SPD_CUST) {
2100 info->timeout = (info->xmit_fifo_size * HZ * 15 /
2101 baud_rate) + 2;
2102 } else if (baud_table[i]) {
2103 info->timeout = (info->xmit_fifo_size * HZ * 15 /
2104 baud_table[i]) + 2;
2105 /* this needs to be propagated into the card info */
2106 } else {
2107 info->timeout = 0;
2108 }
2109 /* By tradition (is it a standard?) a baud rate of zero
2110 implies the line should be/has been closed. A bit
2111 later in this routine such a test is performed. */
2112
2113 /* byte size and parity */
2114 info->cor5 = 0;
2115 info->cor4 = 0;
2116 /* receive threshold */
2117 info->cor3 = (info->default_threshold ?
2118 info->default_threshold : baud_cor3[i]);
2119 info->cor2 = CyETC;
2120 switch (cflag & CSIZE) {
2121 case CS5:
2122 info->cor1 = Cy_5_BITS;
2123 break;
2124 case CS6:
2125 info->cor1 = Cy_6_BITS;
2126 break;
2127 case CS7:
2128 info->cor1 = Cy_7_BITS;
2129 break;
2130 case CS8:
2131 info->cor1 = Cy_8_BITS;
2132 break;
2133 }
Alan Cox15ed6cc2008-04-30 00:53:55 -07002134 if (cflag & CSTOPB)
Jiri Slaby02f11752006-12-08 02:39:28 -08002135 info->cor1 |= Cy_2_STOP;
Alan Cox15ed6cc2008-04-30 00:53:55 -07002136
Jiri Slaby02f11752006-12-08 02:39:28 -08002137 if (cflag & PARENB) {
Alan Cox15ed6cc2008-04-30 00:53:55 -07002138 if (cflag & PARODD)
Jiri Slaby02f11752006-12-08 02:39:28 -08002139 info->cor1 |= CyPARITY_O;
Alan Cox15ed6cc2008-04-30 00:53:55 -07002140 else
Jiri Slaby02f11752006-12-08 02:39:28 -08002141 info->cor1 |= CyPARITY_E;
Alan Cox15ed6cc2008-04-30 00:53:55 -07002142 } else
Jiri Slaby02f11752006-12-08 02:39:28 -08002143 info->cor1 |= CyPARITY_NONE;
Jiri Slaby02f11752006-12-08 02:39:28 -08002144
2145 /* CTS flow control flag */
2146 if (cflag & CRTSCTS) {
Alan Cox77451e52008-07-16 21:57:02 +01002147 info->port.flags |= ASYNC_CTS_FLOW;
Jiri Slaby02f11752006-12-08 02:39:28 -08002148 info->cor2 |= CyCtsAE;
2149 } else {
Alan Cox77451e52008-07-16 21:57:02 +01002150 info->port.flags &= ~ASYNC_CTS_FLOW;
Jiri Slaby02f11752006-12-08 02:39:28 -08002151 info->cor2 &= ~CyCtsAE;
2152 }
2153 if (cflag & CLOCAL)
Alan Cox77451e52008-07-16 21:57:02 +01002154 info->port.flags &= ~ASYNC_CHECK_CD;
Jiri Slaby02f11752006-12-08 02:39:28 -08002155 else
Alan Cox77451e52008-07-16 21:57:02 +01002156 info->port.flags |= ASYNC_CHECK_CD;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002157
2158 /***********************************************
2159 The hardware option, CyRtsAO, presents RTS when
2160 the chip has characters to send. Since most modems
2161 use RTS as reverse (inbound) flow control, this
2162 option is not used. If inbound flow control is
2163 necessary, DTR can be programmed to provide the
2164 appropriate signals for use with a non-standard
2165 cable. Contact Marcio Saito for details.
2166 ***********************************************/
2167
Jiri Slaby02f11752006-12-08 02:39:28 -08002168 channel &= 0x03;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002169
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002170 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002171 cyy_writeb(info, CyCAR, channel);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002172
Jiri Slaby02f11752006-12-08 02:39:28 -08002173 /* tx and rx baud rate */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002174
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002175 cyy_writeb(info, CyTCOR, info->tco);
2176 cyy_writeb(info, CyTBPR, info->tbpr);
2177 cyy_writeb(info, CyRCOR, info->rco);
2178 cyy_writeb(info, CyRBPR, info->rbpr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002179
Jiri Slaby02f11752006-12-08 02:39:28 -08002180 /* set line characteristics according configuration */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002181
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002182 cyy_writeb(info, CySCHR1, START_CHAR(tty));
2183 cyy_writeb(info, CySCHR2, STOP_CHAR(tty));
2184 cyy_writeb(info, CyCOR1, info->cor1);
2185 cyy_writeb(info, CyCOR2, info->cor2);
2186 cyy_writeb(info, CyCOR3, info->cor3);
2187 cyy_writeb(info, CyCOR4, info->cor4);
2188 cyy_writeb(info, CyCOR5, info->cor5);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002189
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002190 cyy_issue_cmd(info, CyCOR_CHANGE | CyCOR1ch | CyCOR2ch |
2191 CyCOR3ch);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002192
Alan Cox15ed6cc2008-04-30 00:53:55 -07002193 /* !!! Is this needed? */
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002194 cyy_writeb(info, CyCAR, channel);
2195 cyy_writeb(info, CyRTPR,
Jiri Slaby02f11752006-12-08 02:39:28 -08002196 (info->default_timeout ? info->default_timeout : 0x02));
2197 /* 10ms rx timeout */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002198
Jiri Slaby46fb7822009-09-19 13:13:17 -07002199 cflags = CyCTS;
2200 if (!C_CLOCAL(tty))
2201 cflags |= CyDSR | CyRI | CyDCD;
2202 /* without modem intr */
2203 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyMdmCh);
2204 /* act on 1->0 modem transitions */
2205 if ((cflag & CRTSCTS) && info->rflow)
2206 cyy_writeb(info, CyMCOR1, cflags | rflow_thr[i]);
2207 else
2208 cyy_writeb(info, CyMCOR1, cflags);
2209 /* act on 0->1 modem transitions */
2210 cyy_writeb(info, CyMCOR2, cflags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002211
Jiri Slaby4d768202009-09-19 13:13:15 -07002212 if (i == 0) /* baud rate is zero, turn off line */
2213 cyy_change_rts_dtr(info, 0, TIOCM_DTR);
2214 else
2215 cyy_change_rts_dtr(info, TIOCM_DTR, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002216
Jiri Slabyd13549f2009-09-19 13:13:12 -07002217 clear_bit(TTY_IO_ERROR, &tty->flags);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002218 spin_unlock_irqrestore(&card->card_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002219
Linus Torvalds1da177e2005-04-16 15:20:36 -07002220 } else {
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07002221 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
Klaus Kudielka1a86b5e2007-05-08 00:26:26 -07002222 __u32 sw_flow;
Jiri Slaby02f11752006-12-08 02:39:28 -08002223 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002224
Jiri Slaby2693f482009-06-11 12:31:06 +01002225 if (!cyz_is_loaded(card))
Jiri Slaby02f11752006-12-08 02:39:28 -08002226 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002227
Jiri Slaby02f11752006-12-08 02:39:28 -08002228 /* baud rate */
Jiri Slabyd13549f2009-09-19 13:13:12 -07002229 baud = tty_get_baud_rate(tty);
Alan Cox77451e52008-07-16 21:57:02 +01002230 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
Jiri Slaby02f11752006-12-08 02:39:28 -08002231 ASYNC_SPD_CUST) {
2232 if (info->custom_divisor)
2233 baud_rate = info->baud / info->custom_divisor;
2234 else
2235 baud_rate = info->baud;
2236 } else if (baud > CYZ_MAX_SPEED) {
2237 baud = CYZ_MAX_SPEED;
2238 }
2239 cy_writel(&ch_ctrl->comm_baud, baud);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002240
Jiri Slaby02f11752006-12-08 02:39:28 -08002241 if (baud == 134) {
2242 /* get it right for 134.5 baud */
2243 info->timeout = (info->xmit_fifo_size * HZ * 30 / 269) +
2244 2;
Alan Cox77451e52008-07-16 21:57:02 +01002245 } else if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
Jiri Slaby02f11752006-12-08 02:39:28 -08002246 ASYNC_SPD_CUST) {
2247 info->timeout = (info->xmit_fifo_size * HZ * 15 /
2248 baud_rate) + 2;
2249 } else if (baud) {
2250 info->timeout = (info->xmit_fifo_size * HZ * 15 /
2251 baud) + 2;
2252 /* this needs to be propagated into the card info */
2253 } else {
2254 info->timeout = 0;
2255 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002256
Jiri Slaby02f11752006-12-08 02:39:28 -08002257 /* byte size and parity */
2258 switch (cflag & CSIZE) {
2259 case CS5:
2260 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS5);
2261 break;
2262 case CS6:
2263 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS6);
2264 break;
2265 case CS7:
2266 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS7);
2267 break;
2268 case CS8:
2269 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS8);
2270 break;
2271 }
2272 if (cflag & CSTOPB) {
2273 cy_writel(&ch_ctrl->comm_data_l,
Jiri Slabydb05c3b2007-05-08 00:35:46 -07002274 readl(&ch_ctrl->comm_data_l) | C_DL_2STOP);
Jiri Slaby02f11752006-12-08 02:39:28 -08002275 } else {
2276 cy_writel(&ch_ctrl->comm_data_l,
Jiri Slabydb05c3b2007-05-08 00:35:46 -07002277 readl(&ch_ctrl->comm_data_l) | C_DL_1STOP);
Jiri Slaby02f11752006-12-08 02:39:28 -08002278 }
2279 if (cflag & PARENB) {
Alan Cox15ed6cc2008-04-30 00:53:55 -07002280 if (cflag & PARODD)
Jiri Slaby02f11752006-12-08 02:39:28 -08002281 cy_writel(&ch_ctrl->comm_parity, C_PR_ODD);
Alan Cox15ed6cc2008-04-30 00:53:55 -07002282 else
Jiri Slaby02f11752006-12-08 02:39:28 -08002283 cy_writel(&ch_ctrl->comm_parity, C_PR_EVEN);
Alan Cox15ed6cc2008-04-30 00:53:55 -07002284 } else
Jiri Slaby02f11752006-12-08 02:39:28 -08002285 cy_writel(&ch_ctrl->comm_parity, C_PR_NONE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002286
Jiri Slaby02f11752006-12-08 02:39:28 -08002287 /* CTS flow control flag */
2288 if (cflag & CRTSCTS) {
2289 cy_writel(&ch_ctrl->hw_flow,
Jiri Slabydb05c3b2007-05-08 00:35:46 -07002290 readl(&ch_ctrl->hw_flow) | C_RS_CTS | C_RS_RTS);
Jiri Slaby02f11752006-12-08 02:39:28 -08002291 } else {
Jiri Slabydb05c3b2007-05-08 00:35:46 -07002292 cy_writel(&ch_ctrl->hw_flow, readl(&ch_ctrl->hw_flow) &
2293 ~(C_RS_CTS | C_RS_RTS));
Jiri Slaby02f11752006-12-08 02:39:28 -08002294 }
2295 /* As the HW flow control is done in firmware, the driver
2296 doesn't need to care about it */
Alan Cox77451e52008-07-16 21:57:02 +01002297 info->port.flags &= ~ASYNC_CTS_FLOW;
Jiri Slaby02f11752006-12-08 02:39:28 -08002298
2299 /* XON/XOFF/XANY flow control flags */
2300 sw_flow = 0;
2301 if (iflag & IXON) {
2302 sw_flow |= C_FL_OXX;
2303 if (iflag & IXANY)
2304 sw_flow |= C_FL_OIXANY;
2305 }
2306 cy_writel(&ch_ctrl->sw_flow, sw_flow);
2307
Jiri Slaby875b2062007-05-08 00:36:49 -07002308 retval = cyz_issue_cmd(card, channel, C_CM_IOCTL, 0L);
Jiri Slaby02f11752006-12-08 02:39:28 -08002309 if (retval != 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07002310 printk(KERN_ERR "cyc:set_line_char retval on ttyC%d "
2311 "was %x\n", info->line, retval);
Jiri Slaby02f11752006-12-08 02:39:28 -08002312 }
2313
2314 /* CD sensitivity */
Alan Cox15ed6cc2008-04-30 00:53:55 -07002315 if (cflag & CLOCAL)
Alan Cox77451e52008-07-16 21:57:02 +01002316 info->port.flags &= ~ASYNC_CHECK_CD;
Alan Cox15ed6cc2008-04-30 00:53:55 -07002317 else
Alan Cox77451e52008-07-16 21:57:02 +01002318 info->port.flags |= ASYNC_CHECK_CD;
Jiri Slaby02f11752006-12-08 02:39:28 -08002319
2320 if (baud == 0) { /* baud rate is zero, turn off line */
2321 cy_writel(&ch_ctrl->rs_control,
Jiri Slabydb05c3b2007-05-08 00:35:46 -07002322 readl(&ch_ctrl->rs_control) & ~C_RS_DTR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002323#ifdef CY_DEBUG_DTR
Jiri Slaby21719192007-05-08 00:36:42 -07002324 printk(KERN_DEBUG "cyc:set_line_char dropping Z DTR\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002325#endif
Jiri Slaby02f11752006-12-08 02:39:28 -08002326 } else {
2327 cy_writel(&ch_ctrl->rs_control,
Jiri Slabydb05c3b2007-05-08 00:35:46 -07002328 readl(&ch_ctrl->rs_control) | C_RS_DTR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002329#ifdef CY_DEBUG_DTR
Jiri Slaby21719192007-05-08 00:36:42 -07002330 printk(KERN_DEBUG "cyc:set_line_char raising Z DTR\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002331#endif
Jiri Slaby02f11752006-12-08 02:39:28 -08002332 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002333
Alan Cox15ed6cc2008-04-30 00:53:55 -07002334 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLM, 0L);
Jiri Slaby02f11752006-12-08 02:39:28 -08002335 if (retval != 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07002336 printk(KERN_ERR "cyc:set_line_char(2) retval on ttyC%d "
2337 "was %x\n", info->line, retval);
Jiri Slaby02f11752006-12-08 02:39:28 -08002338 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002339
Jiri Slabyd13549f2009-09-19 13:13:12 -07002340 clear_bit(TTY_IO_ERROR, &tty->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002341 }
Jiri Slaby02f11752006-12-08 02:39:28 -08002342} /* set_line_char */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002343
Jiri Slaby6c281812009-09-19 13:13:15 -07002344static int cy_get_serial_info(struct cyclades_port *info,
Alan Cox15ed6cc2008-04-30 00:53:55 -07002345 struct serial_struct __user *retinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002346{
Jiri Slaby875b2062007-05-08 00:36:49 -07002347 struct cyclades_card *cinfo = info->card;
Jiri Slaby6c281812009-09-19 13:13:15 -07002348 struct serial_struct tmp = {
2349 .type = info->type,
2350 .line = info->line,
2351 .port = (info->card - cy_card) * 0x100 + info->line -
2352 cinfo->first_line,
2353 .irq = cinfo->irq,
2354 .flags = info->port.flags,
2355 .close_delay = info->port.close_delay,
2356 .closing_wait = info->port.closing_wait,
2357 .baud_base = info->baud,
2358 .custom_divisor = info->custom_divisor,
2359 .hub6 = 0, /*!!! */
2360 };
Jiri Slaby02f11752006-12-08 02:39:28 -08002361 return copy_to_user(retinfo, &tmp, sizeof(*retinfo)) ? -EFAULT : 0;
Jiri Slaby6c281812009-09-19 13:13:15 -07002362}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002363
2364static int
Jiri Slabyd13549f2009-09-19 13:13:12 -07002365cy_set_serial_info(struct cyclades_port *info, struct tty_struct *tty,
Alan Cox15ed6cc2008-04-30 00:53:55 -07002366 struct serial_struct __user *new_info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002367{
Jiri Slaby02f11752006-12-08 02:39:28 -08002368 struct serial_struct new_serial;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002369
Jiri Slaby02f11752006-12-08 02:39:28 -08002370 if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
2371 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002372
Jiri Slaby02f11752006-12-08 02:39:28 -08002373 if (!capable(CAP_SYS_ADMIN)) {
Alan Cox44b7d1b2008-07-16 21:57:18 +01002374 if (new_serial.close_delay != info->port.close_delay ||
Jiri Slaby02f11752006-12-08 02:39:28 -08002375 new_serial.baud_base != info->baud ||
2376 (new_serial.flags & ASYNC_FLAGS &
2377 ~ASYNC_USR_MASK) !=
Alan Cox77451e52008-07-16 21:57:02 +01002378 (info->port.flags & ASYNC_FLAGS & ~ASYNC_USR_MASK))
Jiri Slaby02f11752006-12-08 02:39:28 -08002379 return -EPERM;
Alan Cox77451e52008-07-16 21:57:02 +01002380 info->port.flags = (info->port.flags & ~ASYNC_USR_MASK) |
Jiri Slaby02f11752006-12-08 02:39:28 -08002381 (new_serial.flags & ASYNC_USR_MASK);
2382 info->baud = new_serial.baud_base;
2383 info->custom_divisor = new_serial.custom_divisor;
2384 goto check_and_exit;
2385 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002386
Jiri Slaby02f11752006-12-08 02:39:28 -08002387 /*
2388 * OK, past this point, all the error checking has been done.
2389 * At this point, we start making changes.....
2390 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002391
Jiri Slaby02f11752006-12-08 02:39:28 -08002392 info->baud = new_serial.baud_base;
2393 info->custom_divisor = new_serial.custom_divisor;
Alan Cox77451e52008-07-16 21:57:02 +01002394 info->port.flags = (info->port.flags & ~ASYNC_FLAGS) |
Jiri Slaby02f11752006-12-08 02:39:28 -08002395 (new_serial.flags & ASYNC_FLAGS);
Alan Cox44b7d1b2008-07-16 21:57:18 +01002396 info->port.close_delay = new_serial.close_delay * HZ / 100;
2397 info->port.closing_wait = new_serial.closing_wait * HZ / 100;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002398
2399check_and_exit:
Alan Cox77451e52008-07-16 21:57:02 +01002400 if (info->port.flags & ASYNC_INITIALIZED) {
Jiri Slabyd13549f2009-09-19 13:13:12 -07002401 cy_set_line_char(info, tty);
Jiri Slaby02f11752006-12-08 02:39:28 -08002402 return 0;
2403 } else {
Jiri Slabyd13549f2009-09-19 13:13:12 -07002404 return cy_startup(info, tty);
Jiri Slaby02f11752006-12-08 02:39:28 -08002405 }
2406} /* set_serial_info */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002407
2408/*
2409 * get_lsr_info - get line status register info
2410 *
2411 * Purpose: Let user call ioctl() to get info when the UART physically
2412 * is emptied. On bus types like RS485, the transmitter must
2413 * release the bus after transmitting. This must be done when
2414 * the transmit shift register is empty, not be done when the
2415 * transmit holding register is empty. This functionality
2416 * allows an RS485 driver to be written in user space.
2417 */
Alan Cox15ed6cc2008-04-30 00:53:55 -07002418static int get_lsr_info(struct cyclades_port *info, unsigned int __user *value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002419{
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002420 struct cyclades_card *card = info->card;
Jiri Slaby02f11752006-12-08 02:39:28 -08002421 unsigned int result;
2422 unsigned long flags;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002423 u8 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002424
Jiri Slaby2693f482009-06-11 12:31:06 +01002425 if (!cy_is_Z(card)) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002426 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002427 status = cyy_readb(info, CySRER) & (CyTxRdy | CyTxMpty);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002428 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002429 result = (status ? 0 : TIOCSER_TEMT);
2430 } else {
2431 /* Not supported yet */
2432 return -EINVAL;
2433 }
2434 return put_user(result, (unsigned long __user *)value);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002435}
2436
Jiri Slaby02f11752006-12-08 02:39:28 -08002437static int cy_tiocmget(struct tty_struct *tty, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002438{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07002439 struct cyclades_port *info = tty->driver_data;
Jiri Slaby875b2062007-05-08 00:36:49 -07002440 struct cyclades_card *card;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002441 int result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002442
Harvey Harrisonbf9d8922008-04-30 00:55:10 -07002443 if (serial_paranoia_check(info, tty->name, __func__))
Jiri Slaby02f11752006-12-08 02:39:28 -08002444 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002445
Jiri Slaby02f11752006-12-08 02:39:28 -08002446 card = info->card;
Jiri Slaby0d348722009-09-19 13:13:16 -07002447
2448 lock_kernel();
Jiri Slaby2693f482009-06-11 12:31:06 +01002449 if (!cy_is_Z(card)) {
Jiri Slaby0d348722009-09-19 13:13:16 -07002450 unsigned long flags;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002451 int channel = info->line - card->first_line;
2452 u8 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002453
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002454 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002455 cyy_writeb(info, CyCAR, channel & 0x03);
2456 status = cyy_readb(info, CyMSVR1);
2457 status |= cyy_readb(info, CyMSVR2);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002458 spin_unlock_irqrestore(&card->card_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002459
Jiri Slaby02f11752006-12-08 02:39:28 -08002460 if (info->rtsdtr_inv) {
2461 result = ((status & CyRTS) ? TIOCM_DTR : 0) |
2462 ((status & CyDTR) ? TIOCM_RTS : 0);
2463 } else {
2464 result = ((status & CyRTS) ? TIOCM_RTS : 0) |
2465 ((status & CyDTR) ? TIOCM_DTR : 0);
2466 }
2467 result |= ((status & CyDCD) ? TIOCM_CAR : 0) |
2468 ((status & CyRI) ? TIOCM_RNG : 0) |
2469 ((status & CyDSR) ? TIOCM_DSR : 0) |
2470 ((status & CyCTS) ? TIOCM_CTS : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002471 } else {
Jiri Slaby0d348722009-09-19 13:13:16 -07002472 u32 lstatus;
2473
2474 if (!cyz_is_loaded(card)) {
2475 result = -ENODEV;
2476 goto end;
Jiri Slaby02f11752006-12-08 02:39:28 -08002477 }
2478
Jiri Slaby0d348722009-09-19 13:13:16 -07002479 lstatus = readl(&info->u.cyz.ch_ctrl->rs_status);
2480 result = ((lstatus & C_RS_RTS) ? TIOCM_RTS : 0) |
2481 ((lstatus & C_RS_DTR) ? TIOCM_DTR : 0) |
2482 ((lstatus & C_RS_DCD) ? TIOCM_CAR : 0) |
2483 ((lstatus & C_RS_RI) ? TIOCM_RNG : 0) |
2484 ((lstatus & C_RS_DSR) ? TIOCM_DSR : 0) |
2485 ((lstatus & C_RS_CTS) ? TIOCM_CTS : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002486 }
Jiri Slaby0d348722009-09-19 13:13:16 -07002487end:
Alan Cox7b130c02008-04-30 00:53:16 -07002488 unlock_kernel();
Jiri Slaby02f11752006-12-08 02:39:28 -08002489 return result;
2490} /* cy_tiomget */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002491
2492static int
2493cy_tiocmset(struct tty_struct *tty, struct file *file,
Jiri Slaby02f11752006-12-08 02:39:28 -08002494 unsigned int set, unsigned int clear)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002495{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07002496 struct cyclades_port *info = tty->driver_data;
Jiri Slaby875b2062007-05-08 00:36:49 -07002497 struct cyclades_card *card;
Jiri Slaby02f11752006-12-08 02:39:28 -08002498 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002499
Harvey Harrisonbf9d8922008-04-30 00:55:10 -07002500 if (serial_paranoia_check(info, tty->name, __func__))
Jiri Slaby02f11752006-12-08 02:39:28 -08002501 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002502
Jiri Slaby02f11752006-12-08 02:39:28 -08002503 card = info->card;
Jiri Slaby2693f482009-06-11 12:31:06 +01002504 if (!cy_is_Z(card)) {
Jiri Slaby4d768202009-09-19 13:13:15 -07002505 spin_lock_irqsave(&card->card_lock, flags);
2506 cyy_change_rts_dtr(info, set, clear);
2507 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002508 } else {
Jiri Slaby0d348722009-09-19 13:13:16 -07002509 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
2510 int retval, channel = info->line - card->first_line;
2511 u32 rs;
Jiri Slaby02f11752006-12-08 02:39:28 -08002512
Jiri Slaby0d348722009-09-19 13:13:16 -07002513 if (!cyz_is_loaded(card))
Jiri Slaby02f11752006-12-08 02:39:28 -08002514 return -ENODEV;
Jiri Slaby0d348722009-09-19 13:13:16 -07002515
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002516 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby0d348722009-09-19 13:13:16 -07002517 rs = readl(&ch_ctrl->rs_control);
2518 if (set & TIOCM_RTS)
2519 rs |= C_RS_RTS;
2520 if (clear & TIOCM_RTS)
2521 rs &= ~C_RS_RTS;
2522 if (set & TIOCM_DTR) {
2523 rs |= C_RS_DTR;
2524#ifdef CY_DEBUG_DTR
2525 printk(KERN_DEBUG "cyc:set_modem_info raising Z DTR\n");
2526#endif
2527 }
2528 if (clear & TIOCM_DTR) {
2529 rs &= ~C_RS_DTR;
2530#ifdef CY_DEBUG_DTR
2531 printk(KERN_DEBUG "cyc:set_modem_info clearing "
2532 "Z DTR\n");
2533#endif
2534 }
2535 cy_writel(&ch_ctrl->rs_control, rs);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002536 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLM, 0L);
Jiri Slaby0d348722009-09-19 13:13:16 -07002537 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002538 if (retval != 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07002539 printk(KERN_ERR "cyc:set_modem_info retval on ttyC%d "
2540 "was %x\n", info->line, retval);
Jiri Slaby02f11752006-12-08 02:39:28 -08002541 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002542 }
Jiri Slaby02f11752006-12-08 02:39:28 -08002543 return 0;
Jiri Slaby0d348722009-09-19 13:13:16 -07002544}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002545
2546/*
2547 * cy_break() --- routine which turns the break handling on or off
2548 */
Alan Cox9e989662008-07-22 11:18:03 +01002549static int cy_break(struct tty_struct *tty, int break_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002550{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07002551 struct cyclades_port *info = tty->driver_data;
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002552 struct cyclades_card *card;
Jiri Slaby02f11752006-12-08 02:39:28 -08002553 unsigned long flags;
Alan Cox9e989662008-07-22 11:18:03 +01002554 int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002555
Jiri Slaby02f11752006-12-08 02:39:28 -08002556 if (serial_paranoia_check(info, tty->name, "cy_break"))
Alan Cox9e989662008-07-22 11:18:03 +01002557 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002558
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002559 card = info->card;
2560
2561 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby2693f482009-06-11 12:31:06 +01002562 if (!cy_is_Z(card)) {
Jiri Slaby02f11752006-12-08 02:39:28 -08002563 /* Let the transmit ISR take care of this (since it
2564 requires stuffing characters into the output stream).
2565 */
2566 if (break_state == -1) {
2567 if (!info->breakon) {
2568 info->breakon = 1;
2569 if (!info->xmit_cnt) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002570 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002571 start_xmit(info);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002572 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002573 }
2574 }
2575 } else {
2576 if (!info->breakoff) {
2577 info->breakoff = 1;
2578 if (!info->xmit_cnt) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002579 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002580 start_xmit(info);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002581 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002582 }
2583 }
2584 }
2585 } else {
Jiri Slaby02f11752006-12-08 02:39:28 -08002586 if (break_state == -1) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002587 retval = cyz_issue_cmd(card,
2588 info->line - card->first_line,
Jiri Slaby02f11752006-12-08 02:39:28 -08002589 C_CM_SET_BREAK, 0L);
2590 if (retval != 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07002591 printk(KERN_ERR "cyc:cy_break (set) retval on "
2592 "ttyC%d was %x\n", info->line, retval);
Jiri Slaby02f11752006-12-08 02:39:28 -08002593 }
2594 } else {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002595 retval = cyz_issue_cmd(card,
2596 info->line - card->first_line,
Jiri Slaby02f11752006-12-08 02:39:28 -08002597 C_CM_CLR_BREAK, 0L);
2598 if (retval != 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07002599 printk(KERN_DEBUG "cyc:cy_break (clr) retval "
2600 "on ttyC%d was %x\n", info->line,
2601 retval);
Jiri Slaby02f11752006-12-08 02:39:28 -08002602 }
2603 }
2604 }
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002605 spin_unlock_irqrestore(&card->card_lock, flags);
Alan Cox9e989662008-07-22 11:18:03 +01002606 return retval;
Jiri Slaby02f11752006-12-08 02:39:28 -08002607} /* cy_break */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002608
Jiri Slaby02f11752006-12-08 02:39:28 -08002609static int set_threshold(struct cyclades_port *info, unsigned long value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002610{
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002611 struct cyclades_card *card = info->card;
Jiri Slaby02f11752006-12-08 02:39:28 -08002612 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002613
Jiri Slaby2693f482009-06-11 12:31:06 +01002614 if (!cy_is_Z(card)) {
Jiri Slaby02f11752006-12-08 02:39:28 -08002615 info->cor3 &= ~CyREC_FIFO;
2616 info->cor3 |= value & CyREC_FIFO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002617
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002618 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002619 cyy_writeb(info, CyCOR3, info->cor3);
2620 cyy_issue_cmd(info, CyCOR_CHANGE | CyCOR3ch);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002621 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002622 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002623 return 0;
Jiri Slaby02f11752006-12-08 02:39:28 -08002624} /* set_threshold */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002625
Alan Cox15ed6cc2008-04-30 00:53:55 -07002626static int get_threshold(struct cyclades_port *info,
2627 unsigned long __user *value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002628{
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002629 struct cyclades_card *card = info->card;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002630
Jiri Slaby2693f482009-06-11 12:31:06 +01002631 if (!cy_is_Z(card)) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002632 u8 tmp = cyy_readb(info, CyCOR3) & CyREC_FIFO;
Jiri Slaby02f11752006-12-08 02:39:28 -08002633 return put_user(tmp, value);
Jiri Slaby02f11752006-12-08 02:39:28 -08002634 }
Jiri Slabyf7429032007-05-08 00:36:59 -07002635 return 0;
Jiri Slaby02f11752006-12-08 02:39:28 -08002636} /* get_threshold */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002637
Jiri Slaby02f11752006-12-08 02:39:28 -08002638static int set_timeout(struct cyclades_port *info, unsigned long value)
2639{
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002640 struct cyclades_card *card = info->card;
Jiri Slaby02f11752006-12-08 02:39:28 -08002641 unsigned long flags;
2642
Jiri Slaby2693f482009-06-11 12:31:06 +01002643 if (!cy_is_Z(card)) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002644 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002645 cyy_writeb(info, CyRTPR, value & 0xff);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002646 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002647 }
2648 return 0;
2649} /* set_timeout */
2650
Alan Cox15ed6cc2008-04-30 00:53:55 -07002651static int get_timeout(struct cyclades_port *info,
2652 unsigned long __user *value)
Jiri Slaby02f11752006-12-08 02:39:28 -08002653{
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002654 struct cyclades_card *card = info->card;
Jiri Slaby02f11752006-12-08 02:39:28 -08002655
Jiri Slaby2693f482009-06-11 12:31:06 +01002656 if (!cy_is_Z(card)) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002657 u8 tmp = cyy_readb(info, CyRTPR);
Jiri Slaby02f11752006-12-08 02:39:28 -08002658 return put_user(tmp, value);
Jiri Slaby02f11752006-12-08 02:39:28 -08002659 }
Jiri Slabyf7429032007-05-08 00:36:59 -07002660 return 0;
Jiri Slaby02f11752006-12-08 02:39:28 -08002661} /* get_timeout */
2662
Jiri Slaby6c281812009-09-19 13:13:15 -07002663static int cy_cflags_changed(struct cyclades_port *info, unsigned long arg,
2664 struct cyclades_icount *cprev)
Jiri Slaby02f11752006-12-08 02:39:28 -08002665{
Jiri Slaby6c281812009-09-19 13:13:15 -07002666 struct cyclades_icount cnow;
2667 unsigned long flags;
2668 int ret;
Jiri Slaby02f11752006-12-08 02:39:28 -08002669
Jiri Slaby6c281812009-09-19 13:13:15 -07002670 spin_lock_irqsave(&info->card->card_lock, flags);
2671 cnow = info->icount; /* atomic copy */
2672 spin_unlock_irqrestore(&info->card->card_lock, flags);
2673
2674 ret = ((arg & TIOCM_RNG) && (cnow.rng != cprev->rng)) ||
2675 ((arg & TIOCM_DSR) && (cnow.dsr != cprev->dsr)) ||
2676 ((arg & TIOCM_CD) && (cnow.dcd != cprev->dcd)) ||
2677 ((arg & TIOCM_CTS) && (cnow.cts != cprev->cts));
2678
2679 *cprev = cnow;
2680
2681 return ret;
2682}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002683
2684/*
2685 * This routine allows the tty driver to implement device-
2686 * specific ioctl's. If the ioctl number passed in cmd is
2687 * not recognized by the driver, it should return ENOIOCTLCMD.
2688 */
2689static int
Jiri Slaby02f11752006-12-08 02:39:28 -08002690cy_ioctl(struct tty_struct *tty, struct file *file,
2691 unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002692{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07002693 struct cyclades_port *info = tty->driver_data;
Jiri Slaby6c281812009-09-19 13:13:15 -07002694 struct cyclades_icount cnow; /* kernel counter temps */
Jiri Slaby02f11752006-12-08 02:39:28 -08002695 int ret_val = 0;
2696 unsigned long flags;
2697 void __user *argp = (void __user *)arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002698
Jiri Slaby02f11752006-12-08 02:39:28 -08002699 if (serial_paranoia_check(info, tty->name, "cy_ioctl"))
2700 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002701
2702#ifdef CY_DEBUG_OTHER
Jiri Slaby21719192007-05-08 00:36:42 -07002703 printk(KERN_DEBUG "cyc:cy_ioctl ttyC%d, cmd = %x arg = %lx\n",
2704 info->line, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002705#endif
Alan Cox7b130c02008-04-30 00:53:16 -07002706 lock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002707
Jiri Slaby02f11752006-12-08 02:39:28 -08002708 switch (cmd) {
2709 case CYGETMON:
Jiri Slaby6c281812009-09-19 13:13:15 -07002710 if (copy_to_user(argp, &info->mon, sizeof(info->mon))) {
2711 ret_val = -EFAULT;
2712 break;
2713 }
2714 memset(&info->mon, 0, sizeof(info->mon));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002715 break;
Jiri Slaby02f11752006-12-08 02:39:28 -08002716 case CYGETTHRESH:
2717 ret_val = get_threshold(info, argp);
2718 break;
2719 case CYSETTHRESH:
2720 ret_val = set_threshold(info, arg);
2721 break;
2722 case CYGETDEFTHRESH:
Jiri Slaby6c281812009-09-19 13:13:15 -07002723 ret_val = put_user(info->default_threshold,
2724 (unsigned long __user *)argp);
Jiri Slaby02f11752006-12-08 02:39:28 -08002725 break;
2726 case CYSETDEFTHRESH:
Jiri Slaby6c281812009-09-19 13:13:15 -07002727 info->default_threshold = arg & 0x0f;
Jiri Slaby02f11752006-12-08 02:39:28 -08002728 break;
2729 case CYGETTIMEOUT:
2730 ret_val = get_timeout(info, argp);
2731 break;
2732 case CYSETTIMEOUT:
2733 ret_val = set_timeout(info, arg);
2734 break;
2735 case CYGETDEFTIMEOUT:
Jiri Slaby6c281812009-09-19 13:13:15 -07002736 ret_val = put_user(info->default_timeout,
2737 (unsigned long __user *)argp);
Jiri Slaby02f11752006-12-08 02:39:28 -08002738 break;
2739 case CYSETDEFTIMEOUT:
Jiri Slaby6c281812009-09-19 13:13:15 -07002740 info->default_timeout = arg & 0xff;
Jiri Slaby02f11752006-12-08 02:39:28 -08002741 break;
2742 case CYSETRFLOW:
2743 info->rflow = (int)arg;
Jiri Slaby02f11752006-12-08 02:39:28 -08002744 break;
2745 case CYGETRFLOW:
2746 ret_val = info->rflow;
2747 break;
2748 case CYSETRTSDTR_INV:
2749 info->rtsdtr_inv = (int)arg;
Jiri Slaby02f11752006-12-08 02:39:28 -08002750 break;
2751 case CYGETRTSDTR_INV:
2752 ret_val = info->rtsdtr_inv;
2753 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002754 case CYGETCD1400VER:
Jiri Slaby02f11752006-12-08 02:39:28 -08002755 ret_val = info->chip_rev;
2756 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002757#ifndef CONFIG_CYZ_INTR
2758 case CYZSETPOLLCYCLE:
Jiri Slaby02f11752006-12-08 02:39:28 -08002759 cyz_polling_cycle = (arg * HZ) / 1000;
Jiri Slaby02f11752006-12-08 02:39:28 -08002760 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002761 case CYZGETPOLLCYCLE:
Jiri Slaby02f11752006-12-08 02:39:28 -08002762 ret_val = (cyz_polling_cycle * 1000) / HZ;
2763 break;
2764#endif /* CONFIG_CYZ_INTR */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002765 case CYSETWAIT:
Alan Cox44b7d1b2008-07-16 21:57:18 +01002766 info->port.closing_wait = (unsigned short)arg * HZ / 100;
Jiri Slaby02f11752006-12-08 02:39:28 -08002767 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002768 case CYGETWAIT:
Alan Cox44b7d1b2008-07-16 21:57:18 +01002769 ret_val = info->port.closing_wait / (HZ / 100);
Jiri Slaby02f11752006-12-08 02:39:28 -08002770 break;
2771 case TIOCGSERIAL:
Jiri Slaby6c281812009-09-19 13:13:15 -07002772 ret_val = cy_get_serial_info(info, argp);
Jiri Slaby02f11752006-12-08 02:39:28 -08002773 break;
2774 case TIOCSSERIAL:
Jiri Slabyd13549f2009-09-19 13:13:12 -07002775 ret_val = cy_set_serial_info(info, tty, argp);
Jiri Slaby02f11752006-12-08 02:39:28 -08002776 break;
2777 case TIOCSERGETLSR: /* Get line status register */
2778 ret_val = get_lsr_info(info, argp);
2779 break;
2780 /*
2781 * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
2782 * - mask passed in arg for lines of interest
2783 * (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
2784 * Caller should use TIOCGICOUNT to see which one it was
2785 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002786 case TIOCMIWAIT:
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002787 spin_lock_irqsave(&info->card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002788 /* note the counters on entry */
Jiri Slaby2c7fea92007-05-08 00:36:51 -07002789 cnow = info->icount;
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002790 spin_unlock_irqrestore(&info->card->card_lock, flags);
Alan Coxbdc04e32009-09-19 13:13:31 -07002791 ret_val = wait_event_interruptible(info->port.delta_msr_wait,
Jiri Slaby6c281812009-09-19 13:13:15 -07002792 cy_cflags_changed(info, arg, &cnow));
Jiri Slaby2c7fea92007-05-08 00:36:51 -07002793 break;
Jiri Slaby02f11752006-12-08 02:39:28 -08002794
2795 /*
2796 * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
2797 * Return: write counters to the user passed counter struct
2798 * NB: both 1->0 and 0->1 transitions are counted except for
2799 * RI where only 0->1 is counted.
2800 */
Jiri Slaby6c281812009-09-19 13:13:15 -07002801 case TIOCGICOUNT: {
2802 struct serial_icounter_struct sic = { };
2803
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002804 spin_lock_irqsave(&info->card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002805 cnow = info->icount;
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002806 spin_unlock_irqrestore(&info->card->card_lock, flags);
Jiri Slaby6c281812009-09-19 13:13:15 -07002807
2808 sic.cts = cnow.cts;
2809 sic.dsr = cnow.dsr;
2810 sic.rng = cnow.rng;
2811 sic.dcd = cnow.dcd;
2812 sic.rx = cnow.rx;
2813 sic.tx = cnow.tx;
2814 sic.frame = cnow.frame;
2815 sic.overrun = cnow.overrun;
2816 sic.parity = cnow.parity;
2817 sic.brk = cnow.brk;
2818 sic.buf_overrun = cnow.buf_overrun;
2819
2820 if (copy_to_user(argp, &sic, sizeof(sic)))
2821 ret_val = -EFAULT;
Jiri Slaby02f11752006-12-08 02:39:28 -08002822 break;
Jiri Slaby6c281812009-09-19 13:13:15 -07002823 }
Jiri Slaby02f11752006-12-08 02:39:28 -08002824 default:
2825 ret_val = -ENOIOCTLCMD;
2826 }
Alan Cox7b130c02008-04-30 00:53:16 -07002827 unlock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002828
2829#ifdef CY_DEBUG_OTHER
Jiri Slaby21719192007-05-08 00:36:42 -07002830 printk(KERN_DEBUG "cyc:cy_ioctl done\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002831#endif
Jiri Slaby02f11752006-12-08 02:39:28 -08002832 return ret_val;
2833} /* cy_ioctl */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002834
2835/*
2836 * This routine allows the tty driver to be notified when
2837 * device's termios settings have changed. Note that a
2838 * well-designed tty driver should be prepared to accept the case
2839 * where old == NULL, and try to do something rational.
2840 */
Jiri Slaby02f11752006-12-08 02:39:28 -08002841static void cy_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002842{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07002843 struct cyclades_port *info = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002844
2845#ifdef CY_DEBUG_OTHER
Jiri Slaby21719192007-05-08 00:36:42 -07002846 printk(KERN_DEBUG "cyc:cy_set_termios ttyC%d\n", info->line);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002847#endif
2848
Jiri Slabyd13549f2009-09-19 13:13:12 -07002849 cy_set_line_char(info, tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002850
Jiri Slaby02f11752006-12-08 02:39:28 -08002851 if ((old_termios->c_cflag & CRTSCTS) &&
2852 !(tty->termios->c_cflag & CRTSCTS)) {
2853 tty->hw_stopped = 0;
2854 cy_start(tty);
2855 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002856#if 0
Jiri Slaby02f11752006-12-08 02:39:28 -08002857 /*
2858 * No need to wake up processes in open wait, since they
2859 * sample the CLOCAL flag once, and don't recheck it.
2860 * XXX It's not clear whether the current behavior is correct
2861 * or not. Hence, this may change.....
2862 */
2863 if (!(old_termios->c_cflag & CLOCAL) &&
2864 (tty->termios->c_cflag & CLOCAL))
Alan Cox77451e52008-07-16 21:57:02 +01002865 wake_up_interruptible(&info->port.open_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002866#endif
Jiri Slaby02f11752006-12-08 02:39:28 -08002867} /* cy_set_termios */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002868
2869/* This function is used to send a high-priority XON/XOFF character to
2870 the device.
2871*/
Jiri Slaby02f11752006-12-08 02:39:28 -08002872static void cy_send_xchar(struct tty_struct *tty, char ch)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002873{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07002874 struct cyclades_port *info = tty->driver_data;
Jiri Slaby875b2062007-05-08 00:36:49 -07002875 struct cyclades_card *card;
2876 int channel;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002877
Jiri Slaby02f11752006-12-08 02:39:28 -08002878 if (serial_paranoia_check(info, tty->name, "cy_send_xchar"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002879 return;
2880
Jiri Slaby02f11752006-12-08 02:39:28 -08002881 info->x_char = ch;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002882
2883 if (ch)
Jiri Slaby02f11752006-12-08 02:39:28 -08002884 cy_start(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002885
2886 card = info->card;
Jiri Slaby875b2062007-05-08 00:36:49 -07002887 channel = info->line - card->first_line;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002888
Jiri Slaby2693f482009-06-11 12:31:06 +01002889 if (cy_is_Z(card)) {
Jiri Slaby02f11752006-12-08 02:39:28 -08002890 if (ch == STOP_CHAR(tty))
Jiri Slaby875b2062007-05-08 00:36:49 -07002891 cyz_issue_cmd(card, channel, C_CM_SENDXOFF, 0L);
Jiri Slaby02f11752006-12-08 02:39:28 -08002892 else if (ch == START_CHAR(tty))
Jiri Slaby875b2062007-05-08 00:36:49 -07002893 cyz_issue_cmd(card, channel, C_CM_SENDXON, 0L);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002894 }
2895}
2896
2897/* This routine is called by the upper-layer tty layer to signal
2898 that incoming characters should be throttled because the input
2899 buffers are close to full.
2900 */
Jiri Slaby02f11752006-12-08 02:39:28 -08002901static void cy_throttle(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002902{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07002903 struct cyclades_port *info = tty->driver_data;
Jiri Slaby875b2062007-05-08 00:36:49 -07002904 struct cyclades_card *card;
Jiri Slaby02f11752006-12-08 02:39:28 -08002905 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002906
2907#ifdef CY_DEBUG_THROTTLE
Jiri Slaby02f11752006-12-08 02:39:28 -08002908 char buf[64];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002909
Jiri Slaby21719192007-05-08 00:36:42 -07002910 printk(KERN_DEBUG "cyc:throttle %s: %ld...ttyC%d\n", tty_name(tty, buf),
Jiri Slaby02f11752006-12-08 02:39:28 -08002911 tty->ldisc.chars_in_buffer(tty), info->line);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002912#endif
2913
Alan Cox15ed6cc2008-04-30 00:53:55 -07002914 if (serial_paranoia_check(info, tty->name, "cy_throttle"))
Jiri Slaby02f11752006-12-08 02:39:28 -08002915 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002916
Jiri Slaby02f11752006-12-08 02:39:28 -08002917 card = info->card;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002918
Jiri Slaby02f11752006-12-08 02:39:28 -08002919 if (I_IXOFF(tty)) {
Jiri Slaby2693f482009-06-11 12:31:06 +01002920 if (!cy_is_Z(card))
Jiri Slaby02f11752006-12-08 02:39:28 -08002921 cy_send_xchar(tty, STOP_CHAR(tty));
2922 else
2923 info->throttle = 1;
2924 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002925
Jiri Slaby02f11752006-12-08 02:39:28 -08002926 if (tty->termios->c_cflag & CRTSCTS) {
Jiri Slaby2693f482009-06-11 12:31:06 +01002927 if (!cy_is_Z(card)) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002928 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby4d768202009-09-19 13:13:15 -07002929 cyy_change_rts_dtr(info, 0, TIOCM_RTS);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002930 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002931 } else {
2932 info->throttle = 1;
2933 }
2934 }
Jiri Slaby02f11752006-12-08 02:39:28 -08002935} /* cy_throttle */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002936
2937/*
2938 * This routine notifies the tty driver that it should signal
2939 * that characters can now be sent to the tty without fear of
2940 * overrunning the input buffers of the line disciplines.
2941 */
Jiri Slaby02f11752006-12-08 02:39:28 -08002942static void cy_unthrottle(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002943{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07002944 struct cyclades_port *info = tty->driver_data;
Jiri Slaby875b2062007-05-08 00:36:49 -07002945 struct cyclades_card *card;
Jiri Slaby02f11752006-12-08 02:39:28 -08002946 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002947
2948#ifdef CY_DEBUG_THROTTLE
Jiri Slaby02f11752006-12-08 02:39:28 -08002949 char buf[64];
2950
Jiri Slaby21719192007-05-08 00:36:42 -07002951 printk(KERN_DEBUG "cyc:unthrottle %s: %ld...ttyC%d\n",
Alan Cox15ed6cc2008-04-30 00:53:55 -07002952 tty_name(tty, buf), tty_chars_in_buffer(tty), info->line);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002953#endif
2954
Alan Cox15ed6cc2008-04-30 00:53:55 -07002955 if (serial_paranoia_check(info, tty->name, "cy_unthrottle"))
Jiri Slaby02f11752006-12-08 02:39:28 -08002956 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002957
Jiri Slaby02f11752006-12-08 02:39:28 -08002958 if (I_IXOFF(tty)) {
2959 if (info->x_char)
2960 info->x_char = 0;
2961 else
2962 cy_send_xchar(tty, START_CHAR(tty));
2963 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002964
Jiri Slaby02f11752006-12-08 02:39:28 -08002965 if (tty->termios->c_cflag & CRTSCTS) {
2966 card = info->card;
Jiri Slaby2693f482009-06-11 12:31:06 +01002967 if (!cy_is_Z(card)) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002968 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby4d768202009-09-19 13:13:15 -07002969 cyy_change_rts_dtr(info, TIOCM_RTS, 0);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002970 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002971 } else {
2972 info->throttle = 0;
2973 }
2974 }
Jiri Slaby02f11752006-12-08 02:39:28 -08002975} /* cy_unthrottle */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002976
2977/* cy_start and cy_stop provide software output flow control as a
2978 function of XON/XOFF, software CTS, and other such stuff.
2979*/
Jiri Slaby02f11752006-12-08 02:39:28 -08002980static void cy_stop(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002981{
Jiri Slaby02f11752006-12-08 02:39:28 -08002982 struct cyclades_card *cinfo;
Jiri Slabycab9bdd2007-05-08 00:35:51 -07002983 struct cyclades_port *info = tty->driver_data;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002984 int channel;
Jiri Slaby02f11752006-12-08 02:39:28 -08002985 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002986
2987#ifdef CY_DEBUG_OTHER
Jiri Slaby21719192007-05-08 00:36:42 -07002988 printk(KERN_DEBUG "cyc:cy_stop ttyC%d\n", info->line);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002989#endif
2990
Jiri Slaby02f11752006-12-08 02:39:28 -08002991 if (serial_paranoia_check(info, tty->name, "cy_stop"))
2992 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002993
Jiri Slaby875b2062007-05-08 00:36:49 -07002994 cinfo = info->card;
Jiri Slaby02f11752006-12-08 02:39:28 -08002995 channel = info->line - cinfo->first_line;
Jiri Slaby2693f482009-06-11 12:31:06 +01002996 if (!cy_is_Z(cinfo)) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002997 spin_lock_irqsave(&cinfo->card_lock, flags);
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002998 cyy_writeb(info, CyCAR, channel & 0x03);
2999 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyTxRdy);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07003000 spin_unlock_irqrestore(&cinfo->card_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003001 }
Jiri Slaby02f11752006-12-08 02:39:28 -08003002} /* cy_stop */
3003
3004static void cy_start(struct tty_struct *tty)
3005{
3006 struct cyclades_card *cinfo;
Jiri Slabycab9bdd2007-05-08 00:35:51 -07003007 struct cyclades_port *info = tty->driver_data;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07003008 int channel;
Jiri Slaby02f11752006-12-08 02:39:28 -08003009 unsigned long flags;
3010
3011#ifdef CY_DEBUG_OTHER
Jiri Slaby21719192007-05-08 00:36:42 -07003012 printk(KERN_DEBUG "cyc:cy_start ttyC%d\n", info->line);
Jiri Slaby02f11752006-12-08 02:39:28 -08003013#endif
3014
3015 if (serial_paranoia_check(info, tty->name, "cy_start"))
3016 return;
3017
Jiri Slaby875b2062007-05-08 00:36:49 -07003018 cinfo = info->card;
Jiri Slaby02f11752006-12-08 02:39:28 -08003019 channel = info->line - cinfo->first_line;
Jiri Slaby2693f482009-06-11 12:31:06 +01003020 if (!cy_is_Z(cinfo)) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07003021 spin_lock_irqsave(&cinfo->card_lock, flags);
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07003022 cyy_writeb(info, CyCAR, channel & 0x03);
3023 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyTxRdy);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07003024 spin_unlock_irqrestore(&cinfo->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08003025 }
Jiri Slaby02f11752006-12-08 02:39:28 -08003026} /* cy_start */
3027
Linus Torvalds1da177e2005-04-16 15:20:36 -07003028/*
3029 * cy_hangup() --- called by tty_hangup() when a hangup is signaled.
3030 */
Jiri Slaby02f11752006-12-08 02:39:28 -08003031static void cy_hangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003032{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07003033 struct cyclades_port *info = tty->driver_data;
Jiri Slaby02f11752006-12-08 02:39:28 -08003034
Linus Torvalds1da177e2005-04-16 15:20:36 -07003035#ifdef CY_DEBUG_OTHER
Jiri Slaby21719192007-05-08 00:36:42 -07003036 printk(KERN_DEBUG "cyc:cy_hangup ttyC%d\n", info->line);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003037#endif
3038
Jiri Slaby02f11752006-12-08 02:39:28 -08003039 if (serial_paranoia_check(info, tty->name, "cy_hangup"))
3040 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003041
Jiri Slaby02f11752006-12-08 02:39:28 -08003042 cy_flush_buffer(tty);
Jiri Slabyd13549f2009-09-19 13:13:12 -07003043 cy_shutdown(info, tty);
Jiri Slaby174e6fe2009-09-19 13:13:13 -07003044 tty_port_hangup(&info->port);
Jiri Slaby02f11752006-12-08 02:39:28 -08003045} /* cy_hangup */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003046
Jiri Slabyf0737572009-09-19 13:13:12 -07003047static int cyy_carrier_raised(struct tty_port *port)
3048{
3049 struct cyclades_port *info = container_of(port, struct cyclades_port,
3050 port);
3051 struct cyclades_card *cinfo = info->card;
Jiri Slabyf0737572009-09-19 13:13:12 -07003052 unsigned long flags;
3053 int channel = info->line - cinfo->first_line;
Jiri Slabyf0737572009-09-19 13:13:12 -07003054 u32 cd;
3055
Jiri Slabyf0737572009-09-19 13:13:12 -07003056 spin_lock_irqsave(&cinfo->card_lock, flags);
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07003057 cyy_writeb(info, CyCAR, channel & 0x03);
3058 cd = cyy_readb(info, CyMSVR1) & CyDCD;
Jiri Slabyf0737572009-09-19 13:13:12 -07003059 spin_unlock_irqrestore(&cinfo->card_lock, flags);
3060
3061 return cd;
3062}
3063
3064static void cyy_dtr_rts(struct tty_port *port, int raise)
3065{
3066 struct cyclades_port *info = container_of(port, struct cyclades_port,
3067 port);
3068 struct cyclades_card *cinfo = info->card;
Jiri Slabyf0737572009-09-19 13:13:12 -07003069 unsigned long flags;
Jiri Slabyf0737572009-09-19 13:13:12 -07003070
3071 spin_lock_irqsave(&cinfo->card_lock, flags);
Jiri Slaby4d768202009-09-19 13:13:15 -07003072 cyy_change_rts_dtr(info, raise ? TIOCM_RTS | TIOCM_DTR : 0,
3073 raise ? 0 : TIOCM_RTS | TIOCM_DTR);
Jiri Slabyf0737572009-09-19 13:13:12 -07003074 spin_unlock_irqrestore(&cinfo->card_lock, flags);
3075}
3076
3077static int cyz_carrier_raised(struct tty_port *port)
3078{
3079 struct cyclades_port *info = container_of(port, struct cyclades_port,
3080 port);
Jiri Slabyf0737572009-09-19 13:13:12 -07003081
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003082 return readl(&info->u.cyz.ch_ctrl->rs_status) & C_RS_DCD;
Jiri Slabyf0737572009-09-19 13:13:12 -07003083}
3084
3085static void cyz_dtr_rts(struct tty_port *port, int raise)
3086{
3087 struct cyclades_port *info = container_of(port, struct cyclades_port,
3088 port);
3089 struct cyclades_card *cinfo = info->card;
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003090 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
Jiri Slabyf0737572009-09-19 13:13:12 -07003091 int ret, channel = info->line - cinfo->first_line;
3092 u32 rs;
3093
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003094 rs = readl(&ch_ctrl->rs_control);
Jiri Slabyf0737572009-09-19 13:13:12 -07003095 if (raise)
3096 rs |= C_RS_RTS | C_RS_DTR;
3097 else
3098 rs &= ~(C_RS_RTS | C_RS_DTR);
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003099 cy_writel(&ch_ctrl->rs_control, rs);
Jiri Slabyf0737572009-09-19 13:13:12 -07003100 ret = cyz_issue_cmd(cinfo, channel, C_CM_IOCTLM, 0L);
3101 if (ret != 0)
3102 printk(KERN_ERR "%s: retval on ttyC%d was %x\n",
3103 __func__, info->line, ret);
3104#ifdef CY_DEBUG_DTR
3105 printk(KERN_DEBUG "%s: raising Z DTR\n", __func__);
3106#endif
3107}
3108
3109static const struct tty_port_operations cyy_port_ops = {
3110 .carrier_raised = cyy_carrier_raised,
3111 .dtr_rts = cyy_dtr_rts,
Alan Coxe936ffd2009-09-19 13:13:22 -07003112 .shutdown = cy_do_close,
Jiri Slabyf0737572009-09-19 13:13:12 -07003113};
3114
3115static const struct tty_port_operations cyz_port_ops = {
3116 .carrier_raised = cyz_carrier_raised,
3117 .dtr_rts = cyz_dtr_rts,
Alan Coxe936ffd2009-09-19 13:13:22 -07003118 .shutdown = cy_do_close,
Jiri Slabyf0737572009-09-19 13:13:12 -07003119};
3120
Linus Torvalds1da177e2005-04-16 15:20:36 -07003121/*
3122 * ---------------------------------------------------------------------
3123 * cy_init() and friends
3124 *
3125 * cy_init() is called at boot-time to initialize the serial driver.
3126 * ---------------------------------------------------------------------
3127 */
3128
Jiri Slabydd025c02007-05-08 00:37:02 -07003129static int __devinit cy_init_card(struct cyclades_card *cinfo)
Jiri Slaby0809e262007-05-08 00:36:14 -07003130{
3131 struct cyclades_port *info;
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003132 unsigned int channel, port;
Jiri Slaby0809e262007-05-08 00:36:14 -07003133
Jiri Slaby3046d502007-05-08 00:36:46 -07003134 spin_lock_init(&cinfo->card_lock);
Jiri Slaby963118e2009-06-11 12:34:27 +01003135 cinfo->intr_enabled = 0;
Jiri Slaby3046d502007-05-08 00:36:46 -07003136
Jiri Slaby963118e2009-06-11 12:34:27 +01003137 cinfo->ports = kcalloc(cinfo->nports, sizeof(*cinfo->ports),
3138 GFP_KERNEL);
Jiri Slabydd025c02007-05-08 00:37:02 -07003139 if (cinfo->ports == NULL) {
3140 printk(KERN_ERR "Cyclades: cannot allocate ports\n");
3141 return -ENOMEM;
3142 }
3143
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003144 for (channel = 0, port = cinfo->first_line; channel < cinfo->nports;
3145 channel++, port++) {
3146 info = &cinfo->ports[channel];
Alan Cox44b7d1b2008-07-16 21:57:18 +01003147 tty_port_init(&info->port);
Jiri Slaby3046d502007-05-08 00:36:46 -07003148 info->magic = CYCLADES_MAGIC;
Jiri Slaby875b2062007-05-08 00:36:49 -07003149 info->card = cinfo;
Jiri Slaby3046d502007-05-08 00:36:46 -07003150 info->line = port;
Jiri Slaby3046d502007-05-08 00:36:46 -07003151
Alan Cox44b7d1b2008-07-16 21:57:18 +01003152 info->port.closing_wait = CLOSING_WAIT_DELAY;
3153 info->port.close_delay = 5 * HZ / 10;
Alan Cox77451e52008-07-16 21:57:02 +01003154 info->port.flags = STD_COM_FLAGS;
Jiri Slaby2c7fea92007-05-08 00:36:51 -07003155 init_completion(&info->shutdown_wait);
Jiri Slaby3046d502007-05-08 00:36:46 -07003156
Jiri Slaby2693f482009-06-11 12:31:06 +01003157 if (cy_is_Z(cinfo)) {
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003158 struct FIRM_ID *firm_id = cinfo->base_addr + ID_ADDRESS;
3159 struct ZFW_CTRL *zfw_ctrl;
3160
Jiri Slabyf0737572009-09-19 13:13:12 -07003161 info->port.ops = &cyz_port_ops;
Jiri Slaby0809e262007-05-08 00:36:14 -07003162 info->type = PORT_STARTECH;
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003163
3164 zfw_ctrl = cinfo->base_addr +
3165 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
3166 info->u.cyz.ch_ctrl = &zfw_ctrl->ch_ctrl[channel];
3167 info->u.cyz.buf_ctrl = &zfw_ctrl->buf_ctrl[channel];
3168
Jiri Slaby101b8152009-06-11 12:30:10 +01003169 if (cinfo->hw_ver == ZO_V1)
Jiri Slaby0809e262007-05-08 00:36:14 -07003170 info->xmit_fifo_size = CYZ_FIFO_SIZE;
3171 else
Jiri Slaby3046d502007-05-08 00:36:46 -07003172 info->xmit_fifo_size = 4 * CYZ_FIFO_SIZE;
Jiri Slaby0809e262007-05-08 00:36:14 -07003173#ifdef CONFIG_CYZ_INTR
Jiri Slaby39914282007-05-08 00:36:54 -07003174 setup_timer(&cyz_rx_full_timer[port],
3175 cyz_rx_restart, (unsigned long)info);
Jiri Slaby0809e262007-05-08 00:36:14 -07003176#endif
Jiri Slaby3046d502007-05-08 00:36:46 -07003177 } else {
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003178 unsigned short chip_number;
Jiri Slaby963118e2009-06-11 12:34:27 +01003179 int index = cinfo->bus_index;
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003180
Jiri Slabyf0737572009-09-19 13:13:12 -07003181 info->port.ops = &cyy_port_ops;
Jiri Slaby0809e262007-05-08 00:36:14 -07003182 info->type = PORT_CIRRUS;
Jiri Slaby0809e262007-05-08 00:36:14 -07003183 info->xmit_fifo_size = CyMAX_CHAR_FIFO;
Jiri Slaby3046d502007-05-08 00:36:46 -07003184 info->cor1 = CyPARITY_NONE | Cy_1_STOP | Cy_8_BITS;
Jiri Slaby0809e262007-05-08 00:36:14 -07003185 info->cor2 = CyETC;
3186 info->cor3 = 0x08; /* _very_ small rcv threshold */
Jiri Slaby3046d502007-05-08 00:36:46 -07003187
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003188 chip_number = channel / CyPORTS_PER_CHIP;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07003189 info->u.cyy.base_addr = cinfo->base_addr +
3190 (cy_chip_offset[chip_number] << index);
3191 info->chip_rev = cyy_readb(info, CyGFRCR);
Alan Cox15ed6cc2008-04-30 00:53:55 -07003192
3193 if (info->chip_rev >= CD1400_REV_J) {
Jiri Slaby0809e262007-05-08 00:36:14 -07003194 /* It is a CD1400 rev. J or later */
3195 info->tbpr = baud_bpr_60[13]; /* Tx BPR */
3196 info->tco = baud_co_60[13]; /* Tx CO */
3197 info->rbpr = baud_bpr_60[13]; /* Rx BPR */
3198 info->rco = baud_co_60[13]; /* Rx CO */
Jiri Slaby0809e262007-05-08 00:36:14 -07003199 info->rtsdtr_inv = 1;
3200 } else {
3201 info->tbpr = baud_bpr_25[13]; /* Tx BPR */
3202 info->tco = baud_co_25[13]; /* Tx CO */
3203 info->rbpr = baud_bpr_25[13]; /* Rx BPR */
3204 info->rco = baud_co_25[13]; /* Rx CO */
Jiri Slaby0809e262007-05-08 00:36:14 -07003205 info->rtsdtr_inv = 0;
3206 }
Jiri Slaby3046d502007-05-08 00:36:46 -07003207 info->read_status_mask = CyTIMEOUT | CySPECHAR |
3208 CyBREAK | CyPARITY | CyFRAME | CyOVERRUN;
Jiri Slaby0809e262007-05-08 00:36:14 -07003209 }
Jiri Slaby3046d502007-05-08 00:36:46 -07003210
Jiri Slaby0809e262007-05-08 00:36:14 -07003211 }
Jiri Slaby3046d502007-05-08 00:36:46 -07003212
3213#ifndef CONFIG_CYZ_INTR
Jiri Slaby2693f482009-06-11 12:31:06 +01003214 if (cy_is_Z(cinfo) && !timer_pending(&cyz_timerlist)) {
Jiri Slaby3046d502007-05-08 00:36:46 -07003215 mod_timer(&cyz_timerlist, jiffies + 1);
3216#ifdef CY_PCI_DEBUG
3217 printk(KERN_DEBUG "Cyclades-Z polling initialized\n");
3218#endif
3219 }
3220#endif
Jiri Slabydd025c02007-05-08 00:37:02 -07003221 return 0;
Jiri Slaby0809e262007-05-08 00:36:14 -07003222}
3223
Linus Torvalds1da177e2005-04-16 15:20:36 -07003224/* initialize chips on Cyclom-Y card -- return number of valid
3225 chips (which is number of ports/4) */
Jiri Slaby31b4f0a2007-05-08 00:36:44 -07003226static unsigned short __devinit cyy_init_card(void __iomem *true_base_addr,
3227 int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003228{
Jiri Slaby02f11752006-12-08 02:39:28 -08003229 unsigned int chip_number;
3230 void __iomem *base_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003231
Jiri Slaby02f11752006-12-08 02:39:28 -08003232 cy_writeb(true_base_addr + (Cy_HwReset << index), 0);
3233 /* Cy_HwReset is 0x1400 */
3234 cy_writeb(true_base_addr + (Cy_ClrIntr << index), 0);
3235 /* Cy_ClrIntr is 0x1800 */
3236 udelay(500L);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003237
Alan Cox15ed6cc2008-04-30 00:53:55 -07003238 for (chip_number = 0; chip_number < CyMAX_CHIPS_PER_CARD;
3239 chip_number++) {
Jiri Slaby02f11752006-12-08 02:39:28 -08003240 base_addr =
3241 true_base_addr + (cy_chip_offset[chip_number] << index);
3242 mdelay(1);
Jiri Slabydb05c3b2007-05-08 00:35:46 -07003243 if (readb(base_addr + (CyCCR << index)) != 0x00) {
Jiri Slaby02f11752006-12-08 02:39:28 -08003244 /*************
3245 printk(" chip #%d at %#6lx is never idle (CCR != 0)\n",
3246 chip_number, (unsigned long)base_addr);
3247 *************/
3248 return chip_number;
3249 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003250
Jiri Slaby02f11752006-12-08 02:39:28 -08003251 cy_writeb(base_addr + (CyGFRCR << index), 0);
3252 udelay(10L);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003253
Jiri Slaby02f11752006-12-08 02:39:28 -08003254 /* The Cyclom-16Y does not decode address bit 9 and therefore
3255 cannot distinguish between references to chip 0 and a non-
3256 existent chip 4. If the preceding clearing of the supposed
3257 chip 4 GFRCR register appears at chip 0, there is no chip 4
3258 and this must be a Cyclom-16Y, not a Cyclom-32Ye.
3259 */
Jiri Slabydb05c3b2007-05-08 00:35:46 -07003260 if (chip_number == 4 && readb(true_base_addr +
Jiri Slaby02f11752006-12-08 02:39:28 -08003261 (cy_chip_offset[0] << index) +
3262 (CyGFRCR << index)) == 0) {
3263 return chip_number;
3264 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003265
Jiri Slaby02f11752006-12-08 02:39:28 -08003266 cy_writeb(base_addr + (CyCCR << index), CyCHIP_RESET);
3267 mdelay(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003268
Jiri Slabydb05c3b2007-05-08 00:35:46 -07003269 if (readb(base_addr + (CyGFRCR << index)) == 0x00) {
Jiri Slaby02f11752006-12-08 02:39:28 -08003270 /*
3271 printk(" chip #%d at %#6lx is not responding ",
3272 chip_number, (unsigned long)base_addr);
3273 printk("(GFRCR stayed 0)\n",
3274 */
3275 return chip_number;
3276 }
Jiri Slabydb05c3b2007-05-08 00:35:46 -07003277 if ((0xf0 & (readb(base_addr + (CyGFRCR << index)))) !=
Jiri Slaby02f11752006-12-08 02:39:28 -08003278 0x40) {
3279 /*
3280 printk(" chip #%d at %#6lx is not valid (GFRCR == "
3281 "%#2x)\n",
3282 chip_number, (unsigned long)base_addr,
3283 base_addr[CyGFRCR<<index]);
3284 */
3285 return chip_number;
3286 }
3287 cy_writeb(base_addr + (CyGCR << index), CyCH0_SERIAL);
Jiri Slabydb05c3b2007-05-08 00:35:46 -07003288 if (readb(base_addr + (CyGFRCR << index)) >= CD1400_REV_J) {
Jiri Slaby02f11752006-12-08 02:39:28 -08003289 /* It is a CD1400 rev. J or later */
3290 /* Impossible to reach 5ms with this chip.
3291 Changed to 2ms instead (f = 500 Hz). */
3292 cy_writeb(base_addr + (CyPPR << index), CyCLOCK_60_2MS);
3293 } else {
3294 /* f = 200 Hz */
3295 cy_writeb(base_addr + (CyPPR << index), CyCLOCK_25_5MS);
3296 }
3297
3298 /*
3299 printk(" chip #%d at %#6lx is rev 0x%2x\n",
3300 chip_number, (unsigned long)base_addr,
Jiri Slabydb05c3b2007-05-08 00:35:46 -07003301 readb(base_addr+(CyGFRCR<<index)));
Jiri Slaby02f11752006-12-08 02:39:28 -08003302 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003303 }
Jiri Slaby02f11752006-12-08 02:39:28 -08003304 return chip_number;
3305} /* cyy_init_card */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003306
3307/*
3308 * ---------------------------------------------------------------------
3309 * cy_detect_isa() - Probe for Cyclom-Y/ISA boards.
3310 * sets global variables and return the number of ISA boards found.
3311 * ---------------------------------------------------------------------
3312 */
Jiri Slaby02f11752006-12-08 02:39:28 -08003313static int __init cy_detect_isa(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003314{
3315#ifdef CONFIG_ISA
Jiri Slaby02f11752006-12-08 02:39:28 -08003316 unsigned short cy_isa_irq, nboard;
3317 void __iomem *cy_isa_address;
3318 unsigned short i, j, cy_isa_nchan;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003319#ifdef MODULE
Jiri Slaby02f11752006-12-08 02:39:28 -08003320 int isparam = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003321#endif
3322
Jiri Slaby02f11752006-12-08 02:39:28 -08003323 nboard = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003324
3325#ifdef MODULE
3326 /* Check for module parameters */
Jiri Slaby02f11752006-12-08 02:39:28 -08003327 for (i = 0; i < NR_CARDS; i++) {
3328 if (maddr[i] || i) {
3329 isparam = 1;
3330 cy_isa_addresses[i] = maddr[i];
3331 }
3332 if (!maddr[i])
3333 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003334 }
3335#endif
3336
Jiri Slaby02f11752006-12-08 02:39:28 -08003337 /* scan the address table probing for Cyclom-Y/ISA boards */
3338 for (i = 0; i < NR_ISA_ADDRS; i++) {
3339 unsigned int isa_address = cy_isa_addresses[i];
Alan Cox15ed6cc2008-04-30 00:53:55 -07003340 if (isa_address == 0x0000)
Jiri Slaby096dcfc2006-12-08 02:39:30 -08003341 return nboard;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003342
Jiri Slaby02f11752006-12-08 02:39:28 -08003343 /* probe for CD1400... */
Alan Coxcd989b32008-04-30 00:53:56 -07003344 cy_isa_address = ioremap_nocache(isa_address, CyISA_Ywin);
Jiri Slaby31375532007-05-08 00:37:04 -07003345 if (cy_isa_address == NULL) {
3346 printk(KERN_ERR "Cyclom-Y/ISA: can't remap base "
3347 "address\n");
3348 continue;
3349 }
Jiri Slaby02f11752006-12-08 02:39:28 -08003350 cy_isa_nchan = CyPORTS_PER_CHIP *
3351 cyy_init_card(cy_isa_address, 0);
3352 if (cy_isa_nchan == 0) {
Jiri Slaby31375532007-05-08 00:37:04 -07003353 iounmap(cy_isa_address);
Jiri Slaby02f11752006-12-08 02:39:28 -08003354 continue;
3355 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003356#ifdef MODULE
Roel Kluin196b3162009-10-01 15:44:24 -07003357 if (isparam && i < NR_CARDS && irq[i])
Jiri Slaby02f11752006-12-08 02:39:28 -08003358 cy_isa_irq = irq[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07003359 else
3360#endif
Jiri Slaby02f11752006-12-08 02:39:28 -08003361 /* find out the board's irq by probing */
3362 cy_isa_irq = detect_isa_irq(cy_isa_address);
3363 if (cy_isa_irq == 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07003364 printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but the "
3365 "IRQ could not be detected.\n",
Jiri Slaby02f11752006-12-08 02:39:28 -08003366 (unsigned long)cy_isa_address);
Jiri Slaby31375532007-05-08 00:37:04 -07003367 iounmap(cy_isa_address);
Jiri Slaby02f11752006-12-08 02:39:28 -08003368 continue;
3369 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003370
Jiri Slaby02f11752006-12-08 02:39:28 -08003371 if ((cy_next_channel + cy_isa_nchan) > NR_PORTS) {
Jiri Slaby21719192007-05-08 00:36:42 -07003372 printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but no "
3373 "more channels are available. Change NR_PORTS "
3374 "in cyclades.c and recompile kernel.\n",
Jiri Slaby02f11752006-12-08 02:39:28 -08003375 (unsigned long)cy_isa_address);
Jiri Slaby31375532007-05-08 00:37:04 -07003376 iounmap(cy_isa_address);
Jiri Slaby096dcfc2006-12-08 02:39:30 -08003377 return nboard;
Jiri Slaby02f11752006-12-08 02:39:28 -08003378 }
3379 /* fill the next cy_card structure available */
3380 for (j = 0; j < NR_CARDS; j++) {
Jiri Slabyf7429032007-05-08 00:36:59 -07003381 if (cy_card[j].base_addr == NULL)
Jiri Slaby02f11752006-12-08 02:39:28 -08003382 break;
3383 }
3384 if (j == NR_CARDS) { /* no more cy_cards available */
Jiri Slaby21719192007-05-08 00:36:42 -07003385 printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but no "
3386 "more cards can be used. Change NR_CARDS in "
3387 "cyclades.c and recompile kernel.\n",
Jiri Slaby02f11752006-12-08 02:39:28 -08003388 (unsigned long)cy_isa_address);
Jiri Slaby31375532007-05-08 00:37:04 -07003389 iounmap(cy_isa_address);
Jiri Slaby096dcfc2006-12-08 02:39:30 -08003390 return nboard;
Jiri Slaby02f11752006-12-08 02:39:28 -08003391 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003392
Jiri Slaby02f11752006-12-08 02:39:28 -08003393 /* allocate IRQ */
3394 if (request_irq(cy_isa_irq, cyy_interrupt,
3395 IRQF_DISABLED, "Cyclom-Y", &cy_card[j])) {
Jiri Slaby21719192007-05-08 00:36:42 -07003396 printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but "
3397 "could not allocate IRQ#%d.\n",
3398 (unsigned long)cy_isa_address, cy_isa_irq);
Jiri Slaby31375532007-05-08 00:37:04 -07003399 iounmap(cy_isa_address);
Jiri Slaby096dcfc2006-12-08 02:39:30 -08003400 return nboard;
Jiri Slaby02f11752006-12-08 02:39:28 -08003401 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003402
Jiri Slaby02f11752006-12-08 02:39:28 -08003403 /* set cy_card */
3404 cy_card[j].base_addr = cy_isa_address;
Jiri Slaby97e87f82009-06-11 12:29:27 +01003405 cy_card[j].ctl_addr.p9050 = NULL;
Jiri Slaby02f11752006-12-08 02:39:28 -08003406 cy_card[j].irq = (int)cy_isa_irq;
3407 cy_card[j].bus_index = 0;
3408 cy_card[j].first_line = cy_next_channel;
Jiri Slaby963118e2009-06-11 12:34:27 +01003409 cy_card[j].num_chips = cy_isa_nchan / CyPORTS_PER_CHIP;
3410 cy_card[j].nports = cy_isa_nchan;
Jiri Slaby31375532007-05-08 00:37:04 -07003411 if (cy_init_card(&cy_card[j])) {
3412 cy_card[j].base_addr = NULL;
3413 free_irq(cy_isa_irq, &cy_card[j]);
3414 iounmap(cy_isa_address);
3415 continue;
3416 }
Jiri Slaby02f11752006-12-08 02:39:28 -08003417 nboard++;
3418
Jiri Slaby21719192007-05-08 00:36:42 -07003419 printk(KERN_INFO "Cyclom-Y/ISA #%d: 0x%lx-0x%lx, IRQ%d found: "
3420 "%d channels starting from port %d\n",
Jiri Slaby02f11752006-12-08 02:39:28 -08003421 j + 1, (unsigned long)cy_isa_address,
3422 (unsigned long)(cy_isa_address + (CyISA_Ywin - 1)),
Jiri Slaby21719192007-05-08 00:36:42 -07003423 cy_isa_irq, cy_isa_nchan, cy_next_channel);
3424
Jiri Slaby6ad1ccc2007-05-08 00:36:22 -07003425 for (j = cy_next_channel;
3426 j < cy_next_channel + cy_isa_nchan; j++)
3427 tty_register_device(cy_serial_driver, j, NULL);
Jiri Slaby02f11752006-12-08 02:39:28 -08003428 cy_next_channel += cy_isa_nchan;
3429 }
Jiri Slaby096dcfc2006-12-08 02:39:30 -08003430 return nboard;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003431#else
Jiri Slaby096dcfc2006-12-08 02:39:30 -08003432 return 0;
Jiri Slaby02f11752006-12-08 02:39:28 -08003433#endif /* CONFIG_ISA */
3434} /* cy_detect_isa */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003435
Jiri Slaby58936d82007-05-08 00:36:13 -07003436#ifdef CONFIG_PCI
Jiri Slaby054f5b02007-07-17 04:05:16 -07003437static inline int __devinit cyc_isfwstr(const char *str, unsigned int size)
3438{
3439 unsigned int a;
3440
3441 for (a = 0; a < size && *str; a++, str++)
3442 if (*str & 0x80)
3443 return -EINVAL;
3444
3445 for (; a < size; a++, str++)
3446 if (*str)
3447 return -EINVAL;
3448
3449 return 0;
3450}
3451
David Woodhousef61e7612008-05-23 23:57:19 +01003452static inline void __devinit cyz_fpga_copy(void __iomem *fpga, const u8 *data,
Jiri Slaby054f5b02007-07-17 04:05:16 -07003453 unsigned int size)
3454{
3455 for (; size > 0; size--) {
3456 cy_writel(fpga, *data++);
3457 udelay(10);
3458 }
3459}
3460
3461static void __devinit plx_init(struct pci_dev *pdev, int irq,
3462 struct RUNTIME_9060 __iomem *addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003463{
Jiri Slaby02f11752006-12-08 02:39:28 -08003464 /* Reset PLX */
Jiri Slaby054f5b02007-07-17 04:05:16 -07003465 cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) | 0x40000000);
Jiri Slaby02f11752006-12-08 02:39:28 -08003466 udelay(100L);
Jiri Slaby054f5b02007-07-17 04:05:16 -07003467 cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) & ~0x40000000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003468
Jiri Slaby02f11752006-12-08 02:39:28 -08003469 /* Reload Config. Registers from EEPROM */
Jiri Slaby054f5b02007-07-17 04:05:16 -07003470 cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) | 0x20000000);
Jiri Slaby02f11752006-12-08 02:39:28 -08003471 udelay(100L);
Jiri Slaby054f5b02007-07-17 04:05:16 -07003472 cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) & ~0x20000000);
3473
3474 /* For some yet unknown reason, once the PLX9060 reloads the EEPROM,
3475 * the IRQ is lost and, thus, we have to re-write it to the PCI config.
3476 * registers. This will remain here until we find a permanent fix.
3477 */
3478 pci_write_config_byte(pdev, PCI_INTERRUPT_LINE, irq);
3479}
3480
3481static int __devinit __cyz_load_fw(const struct firmware *fw,
3482 const char *name, const u32 mailbox, void __iomem *base,
3483 void __iomem *fpga)
3484{
David Woodhousef61e7612008-05-23 23:57:19 +01003485 const void *ptr = fw->data;
3486 const struct zfile_header *h = ptr;
3487 const struct zfile_config *c, *cs;
3488 const struct zfile_block *b, *bs;
Jiri Slaby054f5b02007-07-17 04:05:16 -07003489 unsigned int a, tmp, len = fw->size;
3490#define BAD_FW KERN_ERR "Bad firmware: "
3491 if (len < sizeof(*h)) {
3492 printk(BAD_FW "too short: %u<%zu\n", len, sizeof(*h));
3493 return -EINVAL;
3494 }
3495
3496 cs = ptr + h->config_offset;
3497 bs = ptr + h->block_offset;
3498
3499 if ((void *)(cs + h->n_config) > ptr + len ||
3500 (void *)(bs + h->n_blocks) > ptr + len) {
3501 printk(BAD_FW "too short");
3502 return -EINVAL;
3503 }
3504
3505 if (cyc_isfwstr(h->name, sizeof(h->name)) ||
3506 cyc_isfwstr(h->date, sizeof(h->date))) {
3507 printk(BAD_FW "bad formatted header string\n");
3508 return -EINVAL;
3509 }
3510
3511 if (strncmp(name, h->name, sizeof(h->name))) {
3512 printk(BAD_FW "bad name '%s' (expected '%s')\n", h->name, name);
3513 return -EINVAL;
3514 }
3515
3516 tmp = 0;
3517 for (c = cs; c < cs + h->n_config; c++) {
3518 for (a = 0; a < c->n_blocks; a++)
3519 if (c->block_list[a] > h->n_blocks) {
3520 printk(BAD_FW "bad block ref number in cfgs\n");
3521 return -EINVAL;
3522 }
3523 if (c->mailbox == mailbox && c->function == 0) /* 0 is normal */
3524 tmp++;
3525 }
3526 if (!tmp) {
3527 printk(BAD_FW "nothing appropriate\n");
3528 return -EINVAL;
3529 }
3530
3531 for (b = bs; b < bs + h->n_blocks; b++)
3532 if (b->file_offset + b->size > len) {
3533 printk(BAD_FW "bad block data offset\n");
3534 return -EINVAL;
3535 }
3536
3537 /* everything is OK, let's seek'n'load it */
3538 for (c = cs; c < cs + h->n_config; c++)
3539 if (c->mailbox == mailbox && c->function == 0)
3540 break;
3541
3542 for (a = 0; a < c->n_blocks; a++) {
3543 b = &bs[c->block_list[a]];
3544 if (b->type == ZBLOCK_FPGA) {
3545 if (fpga != NULL)
3546 cyz_fpga_copy(fpga, ptr + b->file_offset,
3547 b->size);
3548 } else {
3549 if (base != NULL)
3550 memcpy_toio(base + b->ram_offset,
3551 ptr + b->file_offset, b->size);
3552 }
3553 }
3554#undef BAD_FW
3555 return 0;
3556}
3557
3558static int __devinit cyz_load_fw(struct pci_dev *pdev, void __iomem *base_addr,
3559 struct RUNTIME_9060 __iomem *ctl_addr, int irq)
3560{
3561 const struct firmware *fw;
3562 struct FIRM_ID __iomem *fid = base_addr + ID_ADDRESS;
3563 struct CUSTOM_REG __iomem *cust = base_addr;
3564 struct ZFW_CTRL __iomem *pt_zfwctrl;
Jiri Slabyc4923b42007-07-17 04:05:17 -07003565 void __iomem *tmp;
Jiri Slaby963118e2009-06-11 12:34:27 +01003566 u32 mailbox, status, nchan;
Jiri Slaby054f5b02007-07-17 04:05:16 -07003567 unsigned int i;
3568 int retval;
3569
3570 retval = request_firmware(&fw, "cyzfirm.bin", &pdev->dev);
3571 if (retval) {
3572 dev_err(&pdev->dev, "can't get firmware\n");
3573 goto err;
3574 }
3575
3576 /* Check whether the firmware is already loaded and running. If
3577 positive, skip this board */
Jiri Slaby2693f482009-06-11 12:31:06 +01003578 if (__cyz_fpga_loaded(ctl_addr) && readl(&fid->signature) == ZFIRM_ID) {
Jiri Slaby054f5b02007-07-17 04:05:16 -07003579 u32 cntval = readl(base_addr + 0x190);
3580
3581 udelay(100);
3582 if (cntval != readl(base_addr + 0x190)) {
3583 /* FW counter is working, FW is running */
3584 dev_dbg(&pdev->dev, "Cyclades-Z FW already loaded. "
3585 "Skipping board.\n");
3586 retval = 0;
3587 goto err_rel;
3588 }
3589 }
3590
3591 /* start boot */
3592 cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) &
3593 ~0x00030800UL);
3594
3595 mailbox = readl(&ctl_addr->mail_box_0);
3596
Jiri Slaby2693f482009-06-11 12:31:06 +01003597 if (mailbox == 0 || __cyz_fpga_loaded(ctl_addr)) {
Jiri Slaby054f5b02007-07-17 04:05:16 -07003598 /* stops CPU and set window to beginning of RAM */
3599 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3600 cy_writel(&cust->cpu_stop, 0);
3601 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3602 udelay(100);
3603 }
3604
3605 plx_init(pdev, irq, ctl_addr);
3606
3607 if (mailbox != 0) {
3608 /* load FPGA */
3609 retval = __cyz_load_fw(fw, "Cyclom-Z", mailbox, NULL,
3610 base_addr);
3611 if (retval)
3612 goto err_rel;
Jiri Slaby2693f482009-06-11 12:31:06 +01003613 if (!__cyz_fpga_loaded(ctl_addr)) {
Jiri Slaby054f5b02007-07-17 04:05:16 -07003614 dev_err(&pdev->dev, "fw upload successful, but fw is "
3615 "not loaded\n");
3616 goto err_rel;
3617 }
3618 }
3619
3620 /* stops CPU and set window to beginning of RAM */
3621 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3622 cy_writel(&cust->cpu_stop, 0);
3623 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3624 udelay(100);
3625
3626 /* clear memory */
Jiri Slabyc4923b42007-07-17 04:05:17 -07003627 for (tmp = base_addr; tmp < base_addr + RAM_SIZE; tmp++)
Jiri Slaby054f5b02007-07-17 04:05:16 -07003628 cy_writeb(tmp, 255);
3629 if (mailbox != 0) {
3630 /* set window to last 512K of RAM */
3631 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM + RAM_SIZE);
Jiri Slabyc4923b42007-07-17 04:05:17 -07003632 for (tmp = base_addr; tmp < base_addr + RAM_SIZE; tmp++)
Jiri Slaby054f5b02007-07-17 04:05:16 -07003633 cy_writeb(tmp, 255);
3634 /* set window to beginning of RAM */
3635 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
Jiri Slaby054f5b02007-07-17 04:05:16 -07003636 }
3637
3638 retval = __cyz_load_fw(fw, "Cyclom-Z", mailbox, base_addr, NULL);
3639 release_firmware(fw);
3640 if (retval)
3641 goto err;
3642
3643 /* finish boot and start boards */
3644 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3645 cy_writel(&cust->cpu_start, 0);
3646 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3647 i = 0;
3648 while ((status = readl(&fid->signature)) != ZFIRM_ID && i++ < 40)
3649 msleep(100);
3650 if (status != ZFIRM_ID) {
3651 if (status == ZFIRM_HLT) {
3652 dev_err(&pdev->dev, "you need an external power supply "
3653 "for this number of ports. Firmware halted and "
3654 "board reset.\n");
3655 retval = -EIO;
3656 goto err;
3657 }
3658 dev_warn(&pdev->dev, "fid->signature = 0x%x... Waiting "
3659 "some more time\n", status);
3660 while ((status = readl(&fid->signature)) != ZFIRM_ID &&
3661 i++ < 200)
3662 msleep(100);
3663 if (status != ZFIRM_ID) {
3664 dev_err(&pdev->dev, "Board not started in 20 seconds! "
3665 "Giving up. (fid->signature = 0x%x)\n",
3666 status);
3667 dev_info(&pdev->dev, "*** Warning ***: if you are "
3668 "upgrading the FW, please power cycle the "
3669 "system before loading the new FW to the "
3670 "Cyclades-Z.\n");
3671
Jiri Slaby2693f482009-06-11 12:31:06 +01003672 if (__cyz_fpga_loaded(ctl_addr))
Jiri Slaby054f5b02007-07-17 04:05:16 -07003673 plx_init(pdev, irq, ctl_addr);
3674
3675 retval = -EIO;
3676 goto err;
3677 }
3678 dev_dbg(&pdev->dev, "Firmware started after %d seconds.\n",
3679 i / 10);
3680 }
3681 pt_zfwctrl = base_addr + readl(&fid->zfwctrl_addr);
3682
3683 dev_dbg(&pdev->dev, "fid=> %p, zfwctrl_addr=> %x, npt_zfwctrl=> %p\n",
3684 base_addr + ID_ADDRESS, readl(&fid->zfwctrl_addr),
3685 base_addr + readl(&fid->zfwctrl_addr));
3686
Jiri Slaby963118e2009-06-11 12:34:27 +01003687 nchan = readl(&pt_zfwctrl->board_ctrl.n_channel);
Jiri Slaby054f5b02007-07-17 04:05:16 -07003688 dev_info(&pdev->dev, "Cyclades-Z FW loaded: version = %x, ports = %u\n",
Jiri Slaby963118e2009-06-11 12:34:27 +01003689 readl(&pt_zfwctrl->board_ctrl.fw_version), nchan);
Jiri Slaby054f5b02007-07-17 04:05:16 -07003690
Jiri Slaby963118e2009-06-11 12:34:27 +01003691 if (nchan == 0) {
Jiri Slaby054f5b02007-07-17 04:05:16 -07003692 dev_warn(&pdev->dev, "no Cyclades-Z ports were found. Please "
3693 "check the connection between the Z host card and the "
3694 "serial expanders.\n");
3695
Jiri Slaby2693f482009-06-11 12:31:06 +01003696 if (__cyz_fpga_loaded(ctl_addr))
Jiri Slaby054f5b02007-07-17 04:05:16 -07003697 plx_init(pdev, irq, ctl_addr);
3698
3699 dev_info(&pdev->dev, "Null number of ports detected. Board "
3700 "reset.\n");
3701 retval = 0;
3702 goto err;
3703 }
3704
3705 cy_writel(&pt_zfwctrl->board_ctrl.op_system, C_OS_LINUX);
3706 cy_writel(&pt_zfwctrl->board_ctrl.dr_version, DRIVER_VERSION);
3707
3708 /*
3709 Early firmware failed to start looking for commands.
3710 This enables firmware interrupts for those commands.
3711 */
3712 cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) |
3713 (1 << 17));
3714 cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) |
3715 0x00030800UL);
3716
Jiri Slaby963118e2009-06-11 12:34:27 +01003717 return nchan;
Jiri Slaby054f5b02007-07-17 04:05:16 -07003718err_rel:
3719 release_firmware(fw);
3720err:
3721 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003722}
3723
Jiri Slaby58936d82007-05-08 00:36:13 -07003724static int __devinit cy_pci_probe(struct pci_dev *pdev,
3725 const struct pci_device_id *ent)
3726{
Jiri Slaby31375532007-05-08 00:37:04 -07003727 void __iomem *addr0 = NULL, *addr2 = NULL;
3728 char *card_name = NULL;
Jiri Slaby101b8152009-06-11 12:30:10 +01003729 u32 uninitialized_var(mailbox);
Jiri Slaby31375532007-05-08 00:37:04 -07003730 unsigned int device_id, nchan = 0, card_no, i;
3731 unsigned char plx_ver;
3732 int retval, irq;
Jiri Slaby58936d82007-05-08 00:36:13 -07003733
3734 retval = pci_enable_device(pdev);
3735 if (retval) {
3736 dev_err(&pdev->dev, "cannot enable device\n");
Jiri Slaby31375532007-05-08 00:37:04 -07003737 goto err;
Jiri Slaby58936d82007-05-08 00:36:13 -07003738 }
3739
3740 /* read PCI configuration area */
Jiri Slaby31375532007-05-08 00:37:04 -07003741 irq = pdev->irq;
Jiri Slaby58936d82007-05-08 00:36:13 -07003742 device_id = pdev->device & ~PCI_DEVICE_ID_MASK;
3743
Jiri Slaby31375532007-05-08 00:37:04 -07003744#if defined(__alpha__)
3745 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo) { /* below 1M? */
3746 dev_err(&pdev->dev, "Cyclom-Y/PCI not supported for low "
3747 "addresses on Alpha systems.\n");
3748 retval = -EIO;
3749 goto err_dis;
3750 }
3751#endif
3752 if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Lo) {
3753 dev_err(&pdev->dev, "Cyclades-Z/PCI not supported for low "
3754 "addresses\n");
3755 retval = -EIO;
3756 goto err_dis;
3757 }
3758
3759 if (pci_resource_flags(pdev, 2) & IORESOURCE_IO) {
3760 dev_warn(&pdev->dev, "PCI I/O bit incorrectly set. Ignoring "
3761 "it...\n");
3762 pdev->resource[2].flags &= ~IORESOURCE_IO;
3763 }
3764
3765 retval = pci_request_regions(pdev, "cyclades");
3766 if (retval) {
3767 dev_err(&pdev->dev, "failed to reserve resources\n");
3768 goto err_dis;
3769 }
3770
3771 retval = -EIO;
Jiri Slaby58936d82007-05-08 00:36:13 -07003772 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3773 device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
Jiri Slaby31375532007-05-08 00:37:04 -07003774 card_name = "Cyclom-Y";
Jiri Slaby58936d82007-05-08 00:36:13 -07003775
Jiri Slaby24e6fd42008-10-13 10:34:09 +01003776 addr0 = ioremap_nocache(pci_resource_start(pdev, 0),
3777 CyPCI_Yctl);
Jiri Slaby31375532007-05-08 00:37:04 -07003778 if (addr0 == NULL) {
3779 dev_err(&pdev->dev, "can't remap ctl region\n");
3780 goto err_reg;
3781 }
Jiri Slaby24e6fd42008-10-13 10:34:09 +01003782 addr2 = ioremap_nocache(pci_resource_start(pdev, 2),
3783 CyPCI_Ywin);
Jiri Slaby31375532007-05-08 00:37:04 -07003784 if (addr2 == NULL) {
3785 dev_err(&pdev->dev, "can't remap base region\n");
3786 goto err_unmap;
Jiri Slaby58936d82007-05-08 00:36:13 -07003787 }
3788
Jiri Slaby31375532007-05-08 00:37:04 -07003789 nchan = CyPORTS_PER_CHIP * cyy_init_card(addr2, 1);
3790 if (nchan == 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07003791 dev_err(&pdev->dev, "Cyclom-Y PCI host card with no "
3792 "Serial-Modules\n");
Andrew Mortonc847d472009-01-02 13:50:07 +00003793 goto err_unmap;
Jiri Slaby58936d82007-05-08 00:36:13 -07003794 }
Jiri Slaby31375532007-05-08 00:37:04 -07003795 } else if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Hi) {
3796 struct RUNTIME_9060 __iomem *ctl_addr;
3797
Jiri Slaby24e6fd42008-10-13 10:34:09 +01003798 ctl_addr = addr0 = ioremap_nocache(pci_resource_start(pdev, 0),
3799 CyPCI_Zctl);
Jiri Slaby31375532007-05-08 00:37:04 -07003800 if (addr0 == NULL) {
3801 dev_err(&pdev->dev, "can't remap ctl region\n");
3802 goto err_reg;
Jiri Slaby58936d82007-05-08 00:36:13 -07003803 }
3804
Jiri Slaby31375532007-05-08 00:37:04 -07003805 /* Disable interrupts on the PLX before resetting it */
Jiri Slaby97e87f82009-06-11 12:29:27 +01003806 cy_writew(&ctl_addr->intr_ctrl_stat,
3807 readw(&ctl_addr->intr_ctrl_stat) & ~0x0900);
Jiri Slaby31375532007-05-08 00:37:04 -07003808
Jiri Slaby054f5b02007-07-17 04:05:16 -07003809 plx_init(pdev, irq, addr0);
Jiri Slaby31375532007-05-08 00:37:04 -07003810
Jiri Slaby101b8152009-06-11 12:30:10 +01003811 mailbox = readl(&ctl_addr->mail_box_0);
Jiri Slaby31375532007-05-08 00:37:04 -07003812
Jiri Slaby24e6fd42008-10-13 10:34:09 +01003813 addr2 = ioremap_nocache(pci_resource_start(pdev, 2),
3814 mailbox == ZE_V1 ? CyPCI_Ze_win : CyPCI_Zwin);
Jiri Slaby31375532007-05-08 00:37:04 -07003815 if (addr2 == NULL) {
3816 dev_err(&pdev->dev, "can't remap base region\n");
3817 goto err_unmap;
3818 }
3819
3820 if (mailbox == ZE_V1) {
3821 card_name = "Cyclades-Ze";
Jiri Slaby31375532007-05-08 00:37:04 -07003822 } else {
3823 card_name = "Cyclades-8Zo";
Jiri Slaby31375532007-05-08 00:37:04 -07003824#ifdef CY_PCI_DEBUG
3825 if (mailbox == ZO_V1) {
3826 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3827 dev_info(&pdev->dev, "Cyclades-8Zo/PCI: FPGA "
3828 "id %lx, ver %lx\n", (ulong)(0xff &
3829 readl(&((struct CUSTOM_REG *)addr2)->
3830 fpga_id)), (ulong)(0xff &
3831 readl(&((struct CUSTOM_REG *)addr2)->
3832 fpga_version)));
3833 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3834 } else {
3835 dev_info(&pdev->dev, "Cyclades-Z/PCI: New "
3836 "Cyclades-Z board. FPGA not loaded\n");
3837 }
3838#endif
3839 /* The following clears the firmware id word. This
3840 ensures that the driver will not attempt to talk to
3841 the board until it has been properly initialized.
3842 */
3843 if ((mailbox == ZO_V1) || (mailbox == ZO_V2))
3844 cy_writel(addr2 + ID_ADDRESS, 0L);
Jiri Slaby31375532007-05-08 00:37:04 -07003845 }
Jiri Slabyace08c32009-06-11 12:20:38 +01003846
3847 retval = cyz_load_fw(pdev, addr2, addr0, irq);
Jiri Slaby963118e2009-06-11 12:34:27 +01003848 if (retval <= 0)
Jiri Slabyace08c32009-06-11 12:20:38 +01003849 goto err_unmap;
Jiri Slaby963118e2009-06-11 12:34:27 +01003850 nchan = retval;
Jiri Slaby31375532007-05-08 00:37:04 -07003851 }
3852
3853 if ((cy_next_channel + nchan) > NR_PORTS) {
3854 dev_err(&pdev->dev, "Cyclades-8Zo/PCI found, but no "
3855 "channels are available. Change NR_PORTS in "
3856 "cyclades.c and recompile kernel.\n");
3857 goto err_unmap;
3858 }
3859 /* fill the next cy_card structure available */
3860 for (card_no = 0; card_no < NR_CARDS; card_no++) {
3861 if (cy_card[card_no].base_addr == NULL)
3862 break;
3863 }
3864 if (card_no == NR_CARDS) { /* no more cy_cards available */
3865 dev_err(&pdev->dev, "Cyclades-8Zo/PCI found, but no "
3866 "more cards can be used. Change NR_CARDS in "
3867 "cyclades.c and recompile kernel.\n");
3868 goto err_unmap;
3869 }
3870
3871 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3872 device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
Jiri Slaby58936d82007-05-08 00:36:13 -07003873 /* allocate IRQ */
Jiri Slaby31375532007-05-08 00:37:04 -07003874 retval = request_irq(irq, cyy_interrupt,
3875 IRQF_SHARED, "Cyclom-Y", &cy_card[card_no]);
Jiri Slaby58936d82007-05-08 00:36:13 -07003876 if (retval) {
Jiri Slaby21719192007-05-08 00:36:42 -07003877 dev_err(&pdev->dev, "could not allocate IRQ\n");
Jiri Slaby31375532007-05-08 00:37:04 -07003878 goto err_unmap;
Jiri Slaby58936d82007-05-08 00:36:13 -07003879 }
Jiri Slaby963118e2009-06-11 12:34:27 +01003880 cy_card[card_no].num_chips = nchan / CyPORTS_PER_CHIP;
Jiri Slaby31375532007-05-08 00:37:04 -07003881 } else {
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003882 struct FIRM_ID __iomem *firm_id = addr2 + ID_ADDRESS;
3883 struct ZFW_CTRL __iomem *zfw_ctrl;
3884
3885 zfw_ctrl = addr2 + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
3886
Jiri Slaby101b8152009-06-11 12:30:10 +01003887 cy_card[card_no].hw_ver = mailbox;
3888 cy_card[card_no].num_chips = (unsigned int)-1;
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003889 cy_card[card_no].board_ctrl = &zfw_ctrl->board_ctrl;
Jiri Slaby31375532007-05-08 00:37:04 -07003890#ifdef CONFIG_CYZ_INTR
3891 /* allocate IRQ only if board has an IRQ */
3892 if (irq != 0 && irq != 255) {
3893 retval = request_irq(irq, cyz_interrupt,
3894 IRQF_SHARED, "Cyclades-Z",
3895 &cy_card[card_no]);
3896 if (retval) {
3897 dev_err(&pdev->dev, "could not allocate IRQ\n");
3898 goto err_unmap;
3899 }
3900 }
3901#endif /* CONFIG_CYZ_INTR */
Jiri Slaby31375532007-05-08 00:37:04 -07003902 }
Jiri Slaby58936d82007-05-08 00:36:13 -07003903
Jiri Slaby31375532007-05-08 00:37:04 -07003904 /* set cy_card */
3905 cy_card[card_no].base_addr = addr2;
Jiri Slaby97e87f82009-06-11 12:29:27 +01003906 cy_card[card_no].ctl_addr.p9050 = addr0;
Jiri Slaby31375532007-05-08 00:37:04 -07003907 cy_card[card_no].irq = irq;
3908 cy_card[card_no].bus_index = 1;
3909 cy_card[card_no].first_line = cy_next_channel;
Jiri Slaby963118e2009-06-11 12:34:27 +01003910 cy_card[card_no].nports = nchan;
Jiri Slaby31375532007-05-08 00:37:04 -07003911 retval = cy_init_card(&cy_card[card_no]);
3912 if (retval)
3913 goto err_null;
Jiri Slaby58936d82007-05-08 00:36:13 -07003914
Jiri Slaby31375532007-05-08 00:37:04 -07003915 pci_set_drvdata(pdev, &cy_card[card_no]);
3916
3917 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3918 device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
Jiri Slaby58936d82007-05-08 00:36:13 -07003919 /* enable interrupts in the PCI interface */
Jiri Slaby31375532007-05-08 00:37:04 -07003920 plx_ver = readb(addr2 + CyPLX_VER) & 0x0f;
Jiri Slaby58936d82007-05-08 00:36:13 -07003921 switch (plx_ver) {
3922 case PLX_9050:
Jiri Slaby31375532007-05-08 00:37:04 -07003923 cy_writeb(addr0 + 0x4c, 0x43);
Jiri Slaby58936d82007-05-08 00:36:13 -07003924 break;
3925
3926 case PLX_9060:
3927 case PLX_9080:
3928 default: /* Old boards, use PLX_9060 */
Jiri Slaby97e87f82009-06-11 12:29:27 +01003929 {
3930 struct RUNTIME_9060 __iomem *ctl_addr = addr0;
3931 plx_init(pdev, irq, ctl_addr);
3932 cy_writew(&ctl_addr->intr_ctrl_stat,
3933 readw(&ctl_addr->intr_ctrl_stat) | 0x0900);
Jiri Slaby58936d82007-05-08 00:36:13 -07003934 break;
3935 }
Jiri Slaby97e87f82009-06-11 12:29:27 +01003936 }
Jiri Slaby58936d82007-05-08 00:36:13 -07003937 }
3938
Jiri Slaby31375532007-05-08 00:37:04 -07003939 dev_info(&pdev->dev, "%s/PCI #%d found: %d channels starting from "
3940 "port %d.\n", card_name, card_no + 1, nchan, cy_next_channel);
3941 for (i = cy_next_channel; i < cy_next_channel + nchan; i++)
3942 tty_register_device(cy_serial_driver, i, &pdev->dev);
3943 cy_next_channel += nchan;
3944
Jiri Slaby58936d82007-05-08 00:36:13 -07003945 return 0;
Jiri Slaby31375532007-05-08 00:37:04 -07003946err_null:
3947 cy_card[card_no].base_addr = NULL;
3948 free_irq(irq, &cy_card[card_no]);
3949err_unmap:
Jiri Slaby24e6fd42008-10-13 10:34:09 +01003950 iounmap(addr0);
Jiri Slaby31375532007-05-08 00:37:04 -07003951 if (addr2)
Jiri Slaby24e6fd42008-10-13 10:34:09 +01003952 iounmap(addr2);
Jiri Slaby31375532007-05-08 00:37:04 -07003953err_reg:
3954 pci_release_regions(pdev);
3955err_dis:
3956 pci_disable_device(pdev);
3957err:
3958 return retval;
Jiri Slaby58936d82007-05-08 00:36:13 -07003959}
Jiri Slaby58936d82007-05-08 00:36:13 -07003960
Jiri Slaby6747cd92007-05-08 00:36:34 -07003961static void __devexit cy_pci_remove(struct pci_dev *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003962{
Jiri Slaby38d09092007-05-08 00:36:10 -07003963 struct cyclades_card *cinfo = pci_get_drvdata(pdev);
Jiri Slabyf3851e72007-05-08 00:36:16 -07003964 unsigned int i;
Jiri Slaby38d09092007-05-08 00:36:10 -07003965
Jiri Slaby85c93fa2007-05-08 00:36:23 -07003966 /* non-Z with old PLX */
Jiri Slaby2693f482009-06-11 12:31:06 +01003967 if (!cy_is_Z(cinfo) && (readb(cinfo->base_addr + CyPLX_VER) & 0x0f) ==
Jiri Slabyc2ad4c72007-05-08 00:36:32 -07003968 PLX_9050)
Jiri Slaby97e87f82009-06-11 12:29:27 +01003969 cy_writeb(cinfo->ctl_addr.p9050 + 0x4c, 0);
Jiri Slaby85c93fa2007-05-08 00:36:23 -07003970 else
3971#ifndef CONFIG_CYZ_INTR
Jiri Slaby2693f482009-06-11 12:31:06 +01003972 if (!cy_is_Z(cinfo))
Jiri Slaby85c93fa2007-05-08 00:36:23 -07003973#endif
Jiri Slaby97e87f82009-06-11 12:29:27 +01003974 cy_writew(&cinfo->ctl_addr.p9060->intr_ctrl_stat,
3975 readw(&cinfo->ctl_addr.p9060->intr_ctrl_stat) &
3976 ~0x0900);
Jiri Slaby85c93fa2007-05-08 00:36:23 -07003977
Jiri Slaby24e6fd42008-10-13 10:34:09 +01003978 iounmap(cinfo->base_addr);
Jiri Slaby97e87f82009-06-11 12:29:27 +01003979 if (cinfo->ctl_addr.p9050)
3980 iounmap(cinfo->ctl_addr.p9050);
Jiri Slaby38d09092007-05-08 00:36:10 -07003981 if (cinfo->irq
3982#ifndef CONFIG_CYZ_INTR
Jiri Slaby2693f482009-06-11 12:31:06 +01003983 && !cy_is_Z(cinfo)
Jiri Slaby38d09092007-05-08 00:36:10 -07003984#endif /* CONFIG_CYZ_INTR */
3985 )
3986 free_irq(cinfo->irq, cinfo);
3987 pci_release_regions(pdev);
3988
3989 cinfo->base_addr = NULL;
Jiri Slaby6ad1ccc2007-05-08 00:36:22 -07003990 for (i = cinfo->first_line; i < cinfo->first_line +
3991 cinfo->nports; i++)
3992 tty_unregister_device(cy_serial_driver, i);
Jiri Slabydd025c02007-05-08 00:37:02 -07003993 cinfo->nports = 0;
3994 kfree(cinfo->ports);
Jiri Slaby38d09092007-05-08 00:36:10 -07003995}
3996
Jiri Slaby6747cd92007-05-08 00:36:34 -07003997static struct pci_driver cy_pci_driver = {
3998 .name = "cyclades",
3999 .id_table = cy_pci_dev_id,
4000 .probe = cy_pci_probe,
4001 .remove = __devexit_p(cy_pci_remove)
4002};
4003#endif
4004
Alexey Dobriyan444697d2009-03-31 15:19:15 -07004005static int cyclades_proc_show(struct seq_file *m, void *v)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004006{
Jiri Slaby02f11752006-12-08 02:39:28 -08004007 struct cyclades_port *info;
Jiri Slabydd025c02007-05-08 00:37:02 -07004008 unsigned int i, j;
Jiri Slaby02f11752006-12-08 02:39:28 -08004009 __u32 cur_jifs = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004010
Alexey Dobriyan444697d2009-03-31 15:19:15 -07004011 seq_puts(m, "Dev TimeOpen BytesOut IdleOut BytesIn "
Jiri Slaby02f11752006-12-08 02:39:28 -08004012 "IdleIn Overruns Ldisc\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004013
Jiri Slaby02f11752006-12-08 02:39:28 -08004014 /* Output one line for each known port */
Jiri Slabydd025c02007-05-08 00:37:02 -07004015 for (i = 0; i < NR_CARDS; i++)
4016 for (j = 0; j < cy_card[i].nports; j++) {
4017 info = &cy_card[i].ports[j];
Jiri Slaby02f11752006-12-08 02:39:28 -08004018
Jiri Slabyd13549f2009-09-19 13:13:12 -07004019 if (info->port.count) {
4020 /* XXX is the ldisc num worth this? */
4021 struct tty_struct *tty;
4022 struct tty_ldisc *ld;
4023 int num = 0;
4024 tty = tty_port_tty_get(&info->port);
4025 if (tty) {
4026 ld = tty_ldisc_ref(tty);
4027 if (ld) {
4028 num = ld->ops->num;
4029 tty_ldisc_deref(ld);
4030 }
4031 tty_kref_put(tty);
4032 }
Alexey Dobriyan444697d2009-03-31 15:19:15 -07004033 seq_printf(m, "%3d %8lu %10lu %8lu "
Jiri Slabyd13549f2009-09-19 13:13:12 -07004034 "%10lu %8lu %9lu %6d\n", info->line,
Jiri Slabydd025c02007-05-08 00:37:02 -07004035 (cur_jifs - info->idle_stats.in_use) /
4036 HZ, info->idle_stats.xmit_bytes,
4037 (cur_jifs - info->idle_stats.xmit_idle)/
4038 HZ, info->idle_stats.recv_bytes,
4039 (cur_jifs - info->idle_stats.recv_idle)/
4040 HZ, info->idle_stats.overruns,
Jiri Slabyd13549f2009-09-19 13:13:12 -07004041 num);
4042 } else
Alexey Dobriyan444697d2009-03-31 15:19:15 -07004043 seq_printf(m, "%3d %8lu %10lu %8lu "
Jiri Slabydd025c02007-05-08 00:37:02 -07004044 "%10lu %8lu %9lu %6ld\n",
4045 info->line, 0L, 0L, 0L, 0L, 0L, 0L, 0L);
Jiri Slaby02f11752006-12-08 02:39:28 -08004046 }
Alexey Dobriyan444697d2009-03-31 15:19:15 -07004047 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004048}
4049
Alexey Dobriyan444697d2009-03-31 15:19:15 -07004050static int cyclades_proc_open(struct inode *inode, struct file *file)
4051{
4052 return single_open(file, cyclades_proc_show, NULL);
4053}
4054
4055static const struct file_operations cyclades_proc_fops = {
4056 .owner = THIS_MODULE,
4057 .open = cyclades_proc_open,
4058 .read = seq_read,
4059 .llseek = seq_lseek,
4060 .release = single_release,
4061};
4062
Linus Torvalds1da177e2005-04-16 15:20:36 -07004063/* The serial driver boot-time initialization code!
4064 Hardware I/O ports are mapped to character special devices on a
4065 first found, first allocated manner. That is, this code searches
4066 for Cyclom cards in the system. As each is found, it is probed
4067 to discover how many chips (and thus how many ports) are present.
4068 These ports are mapped to the tty ports 32 and upward in monotonic
4069 fashion. If an 8-port card is replaced with a 16-port card, the
4070 port mapping on a following card will shift.
4071
4072 This approach is different from what is used in the other serial
4073 device driver because the Cyclom is more properly a multiplexer,
4074 not just an aggregation of serial ports on one card.
4075
4076 If there are more cards with more ports than have been
4077 statically allocated above, a warning is printed and the
4078 extra ports are ignored.
4079 */
4080
Jeff Dikeb68e31d2006-10-02 02:17:18 -07004081static const struct tty_operations cy_ops = {
Jiri Slaby02f11752006-12-08 02:39:28 -08004082 .open = cy_open,
4083 .close = cy_close,
4084 .write = cy_write,
4085 .put_char = cy_put_char,
4086 .flush_chars = cy_flush_chars,
4087 .write_room = cy_write_room,
4088 .chars_in_buffer = cy_chars_in_buffer,
4089 .flush_buffer = cy_flush_buffer,
4090 .ioctl = cy_ioctl,
4091 .throttle = cy_throttle,
4092 .unthrottle = cy_unthrottle,
4093 .set_termios = cy_set_termios,
4094 .stop = cy_stop,
4095 .start = cy_start,
4096 .hangup = cy_hangup,
4097 .break_ctl = cy_break,
4098 .wait_until_sent = cy_wait_until_sent,
Jiri Slaby02f11752006-12-08 02:39:28 -08004099 .tiocmget = cy_tiocmget,
4100 .tiocmset = cy_tiocmset,
Alexey Dobriyan444697d2009-03-31 15:19:15 -07004101 .proc_fops = &cyclades_proc_fops,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004102};
4103
Jiri Slaby02f11752006-12-08 02:39:28 -08004104static int __init cy_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004105{
Jiri Slabydd025c02007-05-08 00:37:02 -07004106 unsigned int nboards;
Jiri Slaby9dacf3b2007-05-08 00:36:20 -07004107 int retval = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004108
Jiri Slaby02f11752006-12-08 02:39:28 -08004109 cy_serial_driver = alloc_tty_driver(NR_PORTS);
4110 if (!cy_serial_driver)
Jiri Slaby9dacf3b2007-05-08 00:36:20 -07004111 goto err;
Jiri Slaby21719192007-05-08 00:36:42 -07004112
4113 printk(KERN_INFO "Cyclades driver " CY_VERSION " (built %s %s)\n",
4114 __DATE__, __TIME__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004115
Jiri Slaby02f11752006-12-08 02:39:28 -08004116 /* Initialize the tty_driver structure */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004117
Jiri Slaby02f11752006-12-08 02:39:28 -08004118 cy_serial_driver->owner = THIS_MODULE;
4119 cy_serial_driver->driver_name = "cyclades";
4120 cy_serial_driver->name = "ttyC";
4121 cy_serial_driver->major = CYCLADES_MAJOR;
4122 cy_serial_driver->minor_start = 0;
4123 cy_serial_driver->type = TTY_DRIVER_TYPE_SERIAL;
4124 cy_serial_driver->subtype = SERIAL_TYPE_NORMAL;
4125 cy_serial_driver->init_termios = tty_std_termios;
4126 cy_serial_driver->init_termios.c_cflag =
4127 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
Jiri Slaby6ad1ccc2007-05-08 00:36:22 -07004128 cy_serial_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
Jiri Slaby02f11752006-12-08 02:39:28 -08004129 tty_set_operations(cy_serial_driver, &cy_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004130
Jiri Slaby9dacf3b2007-05-08 00:36:20 -07004131 retval = tty_register_driver(cy_serial_driver);
4132 if (retval) {
4133 printk(KERN_ERR "Couldn't register Cyclades serial driver\n");
4134 goto err_frtty;
4135 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004136
Jiri Slaby02f11752006-12-08 02:39:28 -08004137 /* the code below is responsible to find the boards. Each different
4138 type of board has its own detection routine. If a board is found,
4139 the next cy_card structure available is set by the detection
4140 routine. These functions are responsible for checking the
4141 availability of cy_card and cy_port data structures and updating
4142 the cy_next_channel. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004143
Jiri Slaby02f11752006-12-08 02:39:28 -08004144 /* look for isa boards */
Jiri Slaby14a55a62007-05-08 00:36:18 -07004145 nboards = cy_detect_isa();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004146
Jiri Slaby6747cd92007-05-08 00:36:34 -07004147#ifdef CONFIG_PCI
Jiri Slaby02f11752006-12-08 02:39:28 -08004148 /* look for pci boards */
Jiri Slaby6747cd92007-05-08 00:36:34 -07004149 retval = pci_register_driver(&cy_pci_driver);
Jesper Juhld941ea72007-10-18 03:06:23 -07004150 if (retval && !nboards) {
4151 tty_unregister_driver(cy_serial_driver);
4152 goto err_frtty;
4153 }
Jiri Slaby6747cd92007-05-08 00:36:34 -07004154#endif
Jiri Slaby9dacf3b2007-05-08 00:36:20 -07004155
4156 return 0;
Jiri Slaby9dacf3b2007-05-08 00:36:20 -07004157err_frtty:
4158 put_tty_driver(cy_serial_driver);
4159err:
4160 return retval;
Jiri Slaby02f11752006-12-08 02:39:28 -08004161} /* cy_init */
4162
4163static void __exit cy_cleanup_module(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004164{
Jiri Slabydd025c02007-05-08 00:37:02 -07004165 struct cyclades_card *card;
Jiri Slaby65f76a82007-10-18 03:06:22 -07004166 unsigned int i, e1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004167
4168#ifndef CONFIG_CYZ_INTR
Jiri Slabyb7050902007-05-08 00:35:48 -07004169 del_timer_sync(&cyz_timerlist);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004170#endif /* CONFIG_CYZ_INTR */
4171
Alan Cox15ed6cc2008-04-30 00:53:55 -07004172 e1 = tty_unregister_driver(cy_serial_driver);
4173 if (e1)
Jiri Slaby21719192007-05-08 00:36:42 -07004174 printk(KERN_ERR "failed to unregister Cyclades serial "
4175 "driver(%d)\n", e1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004176
Jiri Slaby6747cd92007-05-08 00:36:34 -07004177#ifdef CONFIG_PCI
4178 pci_unregister_driver(&cy_pci_driver);
4179#endif
4180
Jiri Slaby02f11752006-12-08 02:39:28 -08004181 for (i = 0; i < NR_CARDS; i++) {
Jiri Slabydd025c02007-05-08 00:37:02 -07004182 card = &cy_card[i];
4183 if (card->base_addr) {
Jiri Slaby85c93fa2007-05-08 00:36:23 -07004184 /* clear interrupt */
Jiri Slabydd025c02007-05-08 00:37:02 -07004185 cy_writeb(card->base_addr + Cy_ClrIntr, 0);
4186 iounmap(card->base_addr);
Jiri Slaby97e87f82009-06-11 12:29:27 +01004187 if (card->ctl_addr.p9050)
4188 iounmap(card->ctl_addr.p9050);
Jiri Slabydd025c02007-05-08 00:37:02 -07004189 if (card->irq
Linus Torvalds1da177e2005-04-16 15:20:36 -07004190#ifndef CONFIG_CYZ_INTR
Jiri Slaby2693f482009-06-11 12:31:06 +01004191 && !cy_is_Z(card)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004192#endif /* CONFIG_CYZ_INTR */
Jiri Slaby02f11752006-12-08 02:39:28 -08004193 )
Jiri Slabydd025c02007-05-08 00:37:02 -07004194 free_irq(card->irq, card);
Jiri Slaby65f76a82007-10-18 03:06:22 -07004195 for (e1 = card->first_line; e1 < card->first_line +
Jiri Slabydd025c02007-05-08 00:37:02 -07004196 card->nports; e1++)
Jiri Slaby6ad1ccc2007-05-08 00:36:22 -07004197 tty_unregister_device(cy_serial_driver, e1);
Jiri Slabydd025c02007-05-08 00:37:02 -07004198 kfree(card->ports);
Jiri Slaby02f11752006-12-08 02:39:28 -08004199 }
4200 }
Jiri Slabyf2462bf2007-05-08 00:37:01 -07004201
4202 put_tty_driver(cy_serial_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004203} /* cy_cleanup_module */
4204
4205module_init(cy_init);
4206module_exit(cy_cleanup_module);
4207
4208MODULE_LICENSE("GPL");
Jiri Slabyc8e16932007-05-08 00:37:05 -07004209MODULE_VERSION(CY_VERSION);
Scott James Remnant9f56fad72009-04-06 17:33:04 +01004210MODULE_ALIAS_CHARDEV_MAJOR(CYCLADES_MAJOR);