blob: fd66f57390d048a049568d465f818d76847214d0 [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/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 * This file contains the driver for the Cyclades async multiport
7 * serial boards.
8 *
9 * Initially written by Randolph Bentson <bentson@grieg.seaslug.org>.
10 * Modified and maintained by Marcio Saito <marcio@cyclades.com>.
Linus Torvalds1da177e2005-04-16 15:20:36 -070011 *
Jiri Slabyebdb5132009-09-19 13:13:14 -070012 * Copyright (C) 2007-2009 Jiri Slaby <jirislaby@gmail.com>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 *
14 * Much of the design and some of the code came from serial.c
15 * which was copyright (C) 1991, 1992 Linus Torvalds. It was
16 * extensively rewritten by Theodore Ts'o, 8/16/92 -- 9/14/92,
17 * and then fixed as suggested by Michael K. Johnson 12/12/92.
Jiri Slabyc8e16932007-05-08 00:37:05 -070018 * Converted to pci probing and cleaned up by Jiri Slaby.
Linus Torvalds1da177e2005-04-16 15:20:36 -070019 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070020 */
21
Jiri Slabyebdb5132009-09-19 13:13:14 -070022#define CY_VERSION "2.6"
Jiri Slaby096dcfc2006-12-08 02:39:30 -080023
Linus Torvalds1da177e2005-04-16 15:20:36 -070024/* If you need to install more boards than NR_CARDS, change the constant
25 in the definition below. No other change is necessary to support up to
26 eight boards. Beyond that you'll have to extend cy_isa_addresses. */
27
Jiri Slaby02f11752006-12-08 02:39:28 -080028#define NR_CARDS 4
Linus Torvalds1da177e2005-04-16 15:20:36 -070029
30/*
31 If the total number of ports is larger than NR_PORTS, change this
32 constant in the definition below. No other change is necessary to
33 support more boards/ports. */
34
Jiri Slaby02f11752006-12-08 02:39:28 -080035#define NR_PORTS 256
Linus Torvalds1da177e2005-04-16 15:20:36 -070036
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#define ZO_V1 0
38#define ZO_V2 1
39#define ZE_V1 2
40
41#define SERIAL_PARANOIA_CHECK
42#undef CY_DEBUG_OPEN
43#undef CY_DEBUG_THROTTLE
44#undef CY_DEBUG_OTHER
45#undef CY_DEBUG_IO
46#undef CY_DEBUG_COUNT
47#undef CY_DEBUG_DTR
Linus Torvalds1da177e2005-04-16 15:20:36 -070048#undef CY_DEBUG_INTERRUPTS
49#undef CY_16Y_HACK
50#undef CY_ENABLE_MONITORING
51#undef CY_PCI_DEBUG
52
Linus Torvalds1da177e2005-04-16 15:20:36 -070053/*
Alan Cox15ed6cc2008-04-30 00:53:55 -070054 * Include section
Linus Torvalds1da177e2005-04-16 15:20:36 -070055 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070056#include <linux/module.h>
57#include <linux/errno.h>
58#include <linux/signal.h>
59#include <linux/sched.h>
60#include <linux/timer.h>
61#include <linux/interrupt.h>
62#include <linux/tty.h>
Alan Cox33f0f882006-01-09 20:54:13 -080063#include <linux/tty_flip.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070064#include <linux/serial.h>
65#include <linux/major.h>
66#include <linux/string.h>
67#include <linux/fcntl.h>
68#include <linux/ptrace.h>
69#include <linux/cyclades.h>
70#include <linux/mm.h>
71#include <linux/ioport.h>
72#include <linux/init.h>
73#include <linux/delay.h>
74#include <linux/spinlock.h>
75#include <linux/bitops.h>
Jiri Slaby054f5b02007-07-17 04:05:16 -070076#include <linux/firmware.h>
Scott James Remnant9f56fad2009-04-06 17:33:04 +010077#include <linux/device.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090078#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
Alan Cox15ed6cc2008-04-30 00:53:55 -070080#include <linux/io.h>
Alan Cox15ed6cc2008-04-30 00:53:55 -070081#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070082
Linus Torvalds1da177e2005-04-16 15:20:36 -070083#include <linux/kernel.h>
84#include <linux/pci.h>
85
86#include <linux/stat.h>
87#include <linux/proc_fs.h>
Alexey Dobriyan444697d2009-03-31 15:19:15 -070088#include <linux/seq_file.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070089
Jiri Slaby02f11752006-12-08 02:39:28 -080090static void cy_send_xchar(struct tty_struct *tty, char ch);
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
Linus Torvalds1da177e2005-04-16 15:20:36 -070092#ifndef SERIAL_XMIT_SIZE
93#define SERIAL_XMIT_SIZE (min(PAGE_SIZE, 4096))
94#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070095
96#define STD_COM_FLAGS (0)
97
Jiri Slaby054f5b02007-07-17 04:05:16 -070098/* firmware stuff */
99#define ZL_MAX_BLOCKS 16
100#define DRIVER_VERSION 0x02010203
101#define RAM_SIZE 0x80000
102
Jiri Slaby054f5b02007-07-17 04:05:16 -0700103enum zblock_type {
104 ZBLOCK_PRG = 0,
105 ZBLOCK_FPGA = 1
106};
107
108struct zfile_header {
109 char name[64];
110 char date[32];
111 char aux[32];
112 u32 n_config;
113 u32 config_offset;
114 u32 n_blocks;
115 u32 block_offset;
116 u32 reserved[9];
117} __attribute__ ((packed));
118
119struct zfile_config {
120 char name[64];
121 u32 mailbox;
122 u32 function;
123 u32 n_blocks;
124 u32 block_list[ZL_MAX_BLOCKS];
125} __attribute__ ((packed));
126
127struct zfile_block {
128 u32 type;
129 u32 file_offset;
130 u32 ram_offset;
131 u32 size;
132} __attribute__ ((packed));
133
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134static struct tty_driver *cy_serial_driver;
135
136#ifdef CONFIG_ISA
137/* This is the address lookup table. The driver will probe for
138 Cyclom-Y/ISA boards at all addresses in here. If you want the
139 driver to probe addresses at a different address, add it to
140 this table. If the driver is probing some other board and
141 causing problems, remove the offending address from this table.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142*/
143
144static unsigned int cy_isa_addresses[] = {
Jiri Slaby02f11752006-12-08 02:39:28 -0800145 0xD0000,
146 0xD2000,
147 0xD4000,
148 0xD6000,
149 0xD8000,
150 0xDA000,
151 0xDC000,
152 0xDE000,
153 0, 0, 0, 0, 0, 0, 0, 0
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154};
Jiri Slaby02f11752006-12-08 02:39:28 -0800155
Tobias Klauserfe971072006-01-09 20:54:02 -0800156#define NR_ISA_ADDRS ARRAY_SIZE(cy_isa_addresses)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157
Jiri Slaby3046d502007-05-08 00:36:46 -0700158static long maddr[NR_CARDS];
159static int irq[NR_CARDS];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160
161module_param_array(maddr, long, NULL, 0);
162module_param_array(irq, int, NULL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163
Jiri Slaby02f11752006-12-08 02:39:28 -0800164#endif /* CONFIG_ISA */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165
166/* This is the per-card data structure containing address, irq, number of
167 channels, etc. This driver supports a maximum of NR_CARDS cards.
168*/
169static struct cyclades_card cy_card[NR_CARDS];
170
Jiri Slaby02f11752006-12-08 02:39:28 -0800171static int cy_next_channel; /* next minor available */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172
173/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 * This is used to look up the divisor speeds and the timeouts
175 * We're normally limited to 15 distinct baud rates. The extra
Alan Cox77451e52008-07-16 21:57:02 +0100176 * are accessed via settings in info->port.flags.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 * 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
178 * 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
179 * HI VHI
180 * 20
181 */
Jiri Slabyebdb5132009-09-19 13:13:14 -0700182static const int baud_table[] = {
Jiri Slaby02f11752006-12-08 02:39:28 -0800183 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
184 1800, 2400, 4800, 9600, 19200, 38400, 57600, 76800, 115200, 150000,
185 230400, 0
186};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187
Jiri Slabyebdb5132009-09-19 13:13:14 -0700188static const char baud_co_25[] = { /* 25 MHz clock option table */
Jiri Slaby02f11752006-12-08 02:39:28 -0800189 /* value => 00 01 02 03 04 */
190 /* divide by 8 32 128 512 2048 */
191 0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x02,
192 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
193};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194
Jiri Slabyebdb5132009-09-19 13:13:14 -0700195static const char baud_bpr_25[] = { /* 25 MHz baud rate period table */
Jiri Slaby02f11752006-12-08 02:39:28 -0800196 0x00, 0xf5, 0xa3, 0x6f, 0x5c, 0x51, 0xf5, 0xa3, 0x51, 0xa3,
197 0x6d, 0x51, 0xa3, 0x51, 0xa3, 0x51, 0x36, 0x29, 0x1b, 0x15
198};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199
Jiri Slabyebdb5132009-09-19 13:13:14 -0700200static const char baud_co_60[] = { /* 60 MHz clock option table (CD1400 J) */
Jiri Slaby02f11752006-12-08 02:39:28 -0800201 /* value => 00 01 02 03 04 */
202 /* divide by 8 32 128 512 2048 */
203 0x00, 0x00, 0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03,
204 0x03, 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
205 0x00
206};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207
Jiri Slabyebdb5132009-09-19 13:13:14 -0700208static const char baud_bpr_60[] = { /* 60 MHz baud rate period table (CD1400 J) */
Jiri Slaby02f11752006-12-08 02:39:28 -0800209 0x00, 0x82, 0x21, 0xff, 0xdb, 0xc3, 0x92, 0x62, 0xc3, 0x62,
210 0x41, 0xc3, 0x62, 0xc3, 0x62, 0xc3, 0x82, 0x62, 0x41, 0x32,
211 0x21
212};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213
Jiri Slabyebdb5132009-09-19 13:13:14 -0700214static const char baud_cor3[] = { /* receive threshold */
Jiri Slaby02f11752006-12-08 02:39:28 -0800215 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
216 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x07,
217 0x07
218};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219
220/*
221 * The Cyclades driver implements HW flow control as any serial driver.
Alan Cox15ed6cc2008-04-30 00:53:55 -0700222 * The cyclades_port structure member rflow and the vector rflow_thr
223 * allows us to take advantage of a special feature in the CD1400 to avoid
224 * data loss even when the system interrupt latency is too high. These flags
225 * are to be used only with very special applications. Setting these flags
226 * requires the use of a special cable (DTR and RTS reversed). In the new
227 * CD1400-based boards (rev. 6.00 or later), there is no need for special
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 * cables.
229 */
230
Jiri Slabyebdb5132009-09-19 13:13:14 -0700231static const char rflow_thr[] = { /* rflow threshold */
Jiri Slaby02f11752006-12-08 02:39:28 -0800232 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
233 0x00, 0x00, 0x00, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
234 0x0a
235};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236
237/* The Cyclom-Ye has placed the sequential chips in non-sequential
238 * address order. This look-up table overcomes that problem.
239 */
Jiri Slabyf0eefdc2009-09-19 13:13:13 -0700240static const unsigned int cy_chip_offset[] = { 0x0000,
Jiri Slaby02f11752006-12-08 02:39:28 -0800241 0x0400,
242 0x0800,
243 0x0C00,
244 0x0200,
245 0x0600,
246 0x0A00,
247 0x0E00
248};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249
250/* PCI related definitions */
251
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252#ifdef CONFIG_PCI
Jiri Slabyebdb5132009-09-19 13:13:14 -0700253static const struct pci_device_id cy_pci_dev_id[] = {
Alan Cox15ed6cc2008-04-30 00:53:55 -0700254 /* PCI < 1Mb */
255 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Y_Lo) },
256 /* PCI > 1Mb */
257 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Y_Hi) },
258 /* 4Y PCI < 1Mb */
259 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_4Y_Lo) },
260 /* 4Y PCI > 1Mb */
261 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_4Y_Hi) },
262 /* 8Y PCI < 1Mb */
263 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_8Y_Lo) },
264 /* 8Y PCI > 1Mb */
265 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_8Y_Hi) },
266 /* Z PCI < 1Mb */
267 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Z_Lo) },
268 /* Z PCI > 1Mb */
269 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Z_Hi) },
Jiri Slaby893de2d2007-02-12 00:51:49 -0800270 { } /* end of table */
Jiri Slaby02f11752006-12-08 02:39:28 -0800271};
Jiri Slaby893de2d2007-02-12 00:51:49 -0800272MODULE_DEVICE_TABLE(pci, cy_pci_dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273#endif
274
275static void cy_start(struct tty_struct *);
Jiri Slabyd13549f2009-09-19 13:13:12 -0700276static void cy_set_line_char(struct cyclades_port *, struct tty_struct *);
Klaus Kudielka1a86b5e2007-05-08 00:26:26 -0700277static int cyz_issue_cmd(struct cyclades_card *, __u32, __u8, __u32);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278#ifdef CONFIG_ISA
279static unsigned detect_isa_irq(void __iomem *);
Jiri Slaby02f11752006-12-08 02:39:28 -0800280#endif /* CONFIG_ISA */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282#ifndef CONFIG_CYZ_INTR
283static void cyz_poll(unsigned long);
284
285/* The Cyclades-Z polling cycle is defined by this variable */
286static long cyz_polling_cycle = CZ_DEF_POLL;
287
Ingo Molnar8d06afa2005-09-09 13:10:40 -0700288static DEFINE_TIMER(cyz_timerlist, cyz_poll, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289
Jiri Slaby02f11752006-12-08 02:39:28 -0800290#else /* CONFIG_CYZ_INTR */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291static void cyz_rx_restart(unsigned long);
292static struct timer_list cyz_rx_full_timer[NR_PORTS];
Jiri Slaby02f11752006-12-08 02:39:28 -0800293#endif /* CONFIG_CYZ_INTR */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700295static inline void cyy_writeb(struct cyclades_port *port, u32 reg, u8 val)
296{
297 struct cyclades_card *card = port->card;
298
299 cy_writeb(port->u.cyy.base_addr + (reg << card->bus_index), val);
300}
301
302static inline u8 cyy_readb(struct cyclades_port *port, u32 reg)
303{
304 struct cyclades_card *card = port->card;
305
306 return readb(port->u.cyy.base_addr + (reg << card->bus_index));
307}
308
Jiri Slaby2693f482009-06-11 12:31:06 +0100309static inline bool cy_is_Z(struct cyclades_card *card)
310{
311 return card->num_chips == (unsigned int)-1;
312}
313
314static inline bool __cyz_fpga_loaded(struct RUNTIME_9060 __iomem *ctl_addr)
315{
316 return readl(&ctl_addr->init_ctrl) & (1 << 17);
317}
318
319static inline bool cyz_fpga_loaded(struct cyclades_card *card)
320{
321 return __cyz_fpga_loaded(card->ctl_addr.p9060);
322}
323
324static inline bool cyz_is_loaded(struct cyclades_card *card)
325{
326 struct FIRM_ID __iomem *fw_id = card->base_addr + ID_ADDRESS;
327
328 return (card->hw_ver == ZO_V1 || cyz_fpga_loaded(card)) &&
329 readl(&fw_id->signature) == ZFIRM_ID;
330}
331
Jiri Slaby02f11752006-12-08 02:39:28 -0800332static inline int serial_paranoia_check(struct cyclades_port *info,
Jiri Slabyebdb5132009-09-19 13:13:14 -0700333 const char *name, const char *routine)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334{
335#ifdef SERIAL_PARANOIA_CHECK
Jiri Slaby02f11752006-12-08 02:39:28 -0800336 if (!info) {
Jiri Slaby21719192007-05-08 00:36:42 -0700337 printk(KERN_WARNING "cyc Warning: null cyclades_port for (%s) "
338 "in %s\n", name, routine);
Jiri Slaby02f11752006-12-08 02:39:28 -0800339 return 1;
340 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341
Jiri Slaby02f11752006-12-08 02:39:28 -0800342 if (info->magic != CYCLADES_MAGIC) {
Jiri Slaby21719192007-05-08 00:36:42 -0700343 printk(KERN_WARNING "cyc Warning: bad magic number for serial "
344 "struct (%s) in %s\n", name, routine);
Jiri Slaby02f11752006-12-08 02:39:28 -0800345 return 1;
346 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347#endif
Jiri Slaby02f11752006-12-08 02:39:28 -0800348 return 0;
Jiri Slabyebdb5132009-09-19 13:13:14 -0700349}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351/***********************************************************/
352/********* Start of block of Cyclom-Y specific code ********/
353
354/* This routine waits up to 1000 micro-seconds for the previous
355 command to the Cirrus chip to complete and then issues the
356 new command. An error is returned if the previous command
357 didn't finish within the time limit.
358
359 This function is only called from inside spinlock-protected code.
360 */
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700361static int __cyy_issue_cmd(void __iomem *base_addr, u8 cmd, int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362{
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700363 void __iomem *ccr = base_addr + (CyCCR << index);
Jiri Slabyad39c302007-05-08 00:35:49 -0700364 unsigned int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365
Jiri Slaby02f11752006-12-08 02:39:28 -0800366 /* Check to see that the previous command has completed */
367 for (i = 0; i < 100; i++) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700368 if (readb(ccr) == 0)
Jiri Slaby02f11752006-12-08 02:39:28 -0800369 break;
Jiri Slaby02f11752006-12-08 02:39:28 -0800370 udelay(10L);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 }
Jiri Slaby02f11752006-12-08 02:39:28 -0800372 /* if the CCR never cleared, the previous command
373 didn't finish within the "reasonable time" */
374 if (i == 100)
Jiri Slaby096dcfc2006-12-08 02:39:30 -0800375 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376
Jiri Slaby02f11752006-12-08 02:39:28 -0800377 /* Issue the new command */
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700378 cy_writeb(ccr, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379
Jiri Slaby096dcfc2006-12-08 02:39:30 -0800380 return 0;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700381}
382
383static inline int cyy_issue_cmd(struct cyclades_port *port, u8 cmd)
384{
385 return __cyy_issue_cmd(port->u.cyy.base_addr, cmd,
386 port->card->bus_index);
387}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388
389#ifdef CONFIG_ISA
390/* ISA interrupt detection code */
Alan Cox15ed6cc2008-04-30 00:53:55 -0700391static unsigned detect_isa_irq(void __iomem *address)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392{
Jiri Slaby02f11752006-12-08 02:39:28 -0800393 int irq;
394 unsigned long irqs, flags;
395 int save_xir, save_car;
396 int index = 0; /* IRQ probing is only for ISA */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397
Jiri Slaby02f11752006-12-08 02:39:28 -0800398 /* forget possible initially masked and pending IRQ */
399 irq = probe_irq_off(probe_irq_on());
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400
Jiri Slaby02f11752006-12-08 02:39:28 -0800401 /* Clear interrupts on the board first */
402 cy_writeb(address + (Cy_ClrIntr << index), 0);
403 /* Cy_ClrIntr is 0x1800 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404
Jiri Slaby02f11752006-12-08 02:39:28 -0800405 irqs = probe_irq_on();
406 /* Wait ... */
Jiri Slabyf6e208c2009-09-19 13:13:14 -0700407 msleep(5);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408
Jiri Slaby02f11752006-12-08 02:39:28 -0800409 /* Enable the Tx interrupts on the CD1400 */
410 local_irq_save(flags);
411 cy_writeb(address + (CyCAR << index), 0);
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700412 __cyy_issue_cmd(address, CyCHAN_CTL | CyENB_XMTR, index);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413
Jiri Slaby02f11752006-12-08 02:39:28 -0800414 cy_writeb(address + (CyCAR << index), 0);
415 cy_writeb(address + (CySRER << index),
Jiri Slabydb05c3b2007-05-08 00:35:46 -0700416 readb(address + (CySRER << index)) | CyTxRdy);
Jiri Slaby02f11752006-12-08 02:39:28 -0800417 local_irq_restore(flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418
Jiri Slaby02f11752006-12-08 02:39:28 -0800419 /* Wait ... */
Jiri Slabyf6e208c2009-09-19 13:13:14 -0700420 msleep(5);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421
Jiri Slaby02f11752006-12-08 02:39:28 -0800422 /* Check which interrupt is in use */
423 irq = probe_irq_off(irqs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424
Jiri Slaby02f11752006-12-08 02:39:28 -0800425 /* Clean up */
Jiri Slabydb05c3b2007-05-08 00:35:46 -0700426 save_xir = (u_char) readb(address + (CyTIR << index));
427 save_car = readb(address + (CyCAR << index));
Jiri Slaby02f11752006-12-08 02:39:28 -0800428 cy_writeb(address + (CyCAR << index), (save_xir & 0x3));
429 cy_writeb(address + (CySRER << index),
Jiri Slabydb05c3b2007-05-08 00:35:46 -0700430 readb(address + (CySRER << index)) & ~CyTxRdy);
Jiri Slaby02f11752006-12-08 02:39:28 -0800431 cy_writeb(address + (CyTIR << index), (save_xir & 0x3f));
432 cy_writeb(address + (CyCAR << index), (save_car));
433 cy_writeb(address + (Cy_ClrIntr << index), 0);
434 /* Cy_ClrIntr is 0x1800 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435
Jiri Slaby02f11752006-12-08 02:39:28 -0800436 return (irq > 0) ? irq : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437}
Jiri Slaby02f11752006-12-08 02:39:28 -0800438#endif /* CONFIG_ISA */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439
Jiri Slabyce97a092007-10-18 03:06:21 -0700440static void cyy_chip_rx(struct cyclades_card *cinfo, int chip,
441 void __iomem *base_addr)
Jiri Slabye9410272006-12-08 02:39:28 -0800442{
443 struct cyclades_port *info;
Jiri Slaby227434f2013-01-03 15:53:01 +0100444 struct tty_port *port;
Jiri Slaby65f76a82007-10-18 03:06:22 -0700445 int len, index = cinfo->bus_index;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700446 u8 ivr, save_xir, channel, save_car, data, char_count;
Jiri Slabye9410272006-12-08 02:39:28 -0800447
Jiri Slabye9410272006-12-08 02:39:28 -0800448#ifdef CY_DEBUG_INTERRUPTS
Jiri Slabyce97a092007-10-18 03:06:21 -0700449 printk(KERN_DEBUG "cyy_interrupt: rcvd intr, chip %d\n", chip);
Jiri Slabye9410272006-12-08 02:39:28 -0800450#endif
Jiri Slabyce97a092007-10-18 03:06:21 -0700451 /* determine the channel & change to that context */
Jiri Slaby65f76a82007-10-18 03:06:22 -0700452 save_xir = readb(base_addr + (CyRIR << index));
453 channel = save_xir & CyIRChannel;
Jiri Slabyce97a092007-10-18 03:06:21 -0700454 info = &cinfo->ports[channel + chip * 4];
Jiri Slaby227434f2013-01-03 15:53:01 +0100455 port = &info->port;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700456 save_car = cyy_readb(info, CyCAR);
457 cyy_writeb(info, CyCAR, save_xir);
458 ivr = cyy_readb(info, CyRIVR) & CyIVRMask;
Jiri Slabye9410272006-12-08 02:39:28 -0800459
Jiri Slabyce97a092007-10-18 03:06:21 -0700460 /* there is an open port for this data */
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700461 if (ivr == CyIVRRxEx) { /* exception */
462 data = cyy_readb(info, CyRDSR);
Jiri Slaby02f11752006-12-08 02:39:28 -0800463
Jiri Slabyce97a092007-10-18 03:06:21 -0700464 /* For statistics only */
465 if (data & CyBREAK)
466 info->icount.brk++;
467 else if (data & CyFRAME)
468 info->icount.frame++;
469 else if (data & CyPARITY)
470 info->icount.parity++;
471 else if (data & CyOVERRUN)
472 info->icount.overrun++;
Jiri Slaby02f11752006-12-08 02:39:28 -0800473
Jiri Slabyce97a092007-10-18 03:06:21 -0700474 if (data & info->ignore_status_mask) {
475 info->icount.rx++;
Jiri Slabyce97a092007-10-18 03:06:21 -0700476 return;
477 }
Jiri Slaby227434f2013-01-03 15:53:01 +0100478 if (tty_buffer_request_room(port, 1)) {
Jiri Slabyce97a092007-10-18 03:06:21 -0700479 if (data & info->read_status_mask) {
480 if (data & CyBREAK) {
Jiri Slaby92a19f92013-01-03 15:53:03 +0100481 tty_insert_flip_char(port,
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700482 cyy_readb(info, CyRDSR),
483 TTY_BREAK);
Jiri Slaby02f11752006-12-08 02:39:28 -0800484 info->icount.rx++;
Jiri Slaby6732c8b2013-01-03 15:53:07 +0100485 if (port->flags & ASYNC_SAK) {
486 struct tty_struct *tty =
487 tty_port_tty_get(port);
488 if (tty) {
489 do_SAK(tty);
490 tty_kref_put(tty);
491 }
492 }
Jiri Slabyce97a092007-10-18 03:06:21 -0700493 } else if (data & CyFRAME) {
Jiri Slaby92a19f92013-01-03 15:53:03 +0100494 tty_insert_flip_char(port,
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700495 cyy_readb(info, CyRDSR),
496 TTY_FRAME);
Jiri Slabyce97a092007-10-18 03:06:21 -0700497 info->icount.rx++;
498 info->idle_stats.frame_errs++;
499 } else if (data & CyPARITY) {
500 /* Pieces of seven... */
Jiri Slaby92a19f92013-01-03 15:53:03 +0100501 tty_insert_flip_char(port,
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700502 cyy_readb(info, CyRDSR),
503 TTY_PARITY);
Jiri Slabyce97a092007-10-18 03:06:21 -0700504 info->icount.rx++;
505 info->idle_stats.parity_errs++;
506 } else if (data & CyOVERRUN) {
Jiri Slaby92a19f92013-01-03 15:53:03 +0100507 tty_insert_flip_char(port, 0,
Jiri Slabyce97a092007-10-18 03:06:21 -0700508 TTY_OVERRUN);
509 info->icount.rx++;
510 /* If the flip buffer itself is
511 overflowing, we still lose
512 the next incoming character.
513 */
Jiri Slaby92a19f92013-01-03 15:53:03 +0100514 tty_insert_flip_char(port,
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700515 cyy_readb(info, CyRDSR),
516 TTY_FRAME);
Jiri Slabyce97a092007-10-18 03:06:21 -0700517 info->icount.rx++;
Jiri Slaby02f11752006-12-08 02:39:28 -0800518 info->idle_stats.overruns++;
Jiri Slabyce97a092007-10-18 03:06:21 -0700519 /* These two conditions may imply */
520 /* a normal read should be done. */
521 /* } else if(data & CyTIMEOUT) { */
522 /* } else if(data & CySPECHAR) { */
523 } else {
Jiri Slaby92a19f92013-01-03 15:53:03 +0100524 tty_insert_flip_char(port, 0,
Jiri Slabyce97a092007-10-18 03:06:21 -0700525 TTY_NORMAL);
526 info->icount.rx++;
Jiri Slaby02f11752006-12-08 02:39:28 -0800527 }
Jiri Slabyce97a092007-10-18 03:06:21 -0700528 } else {
Jiri Slaby92a19f92013-01-03 15:53:03 +0100529 tty_insert_flip_char(port, 0, TTY_NORMAL);
Jiri Slabyce97a092007-10-18 03:06:21 -0700530 info->icount.rx++;
531 }
532 } else {
533 /* there was a software buffer overrun and nothing
534 * could be done about it!!! */
535 info->icount.buf_overrun++;
536 info->idle_stats.overruns++;
537 }
538 } else { /* normal character reception */
539 /* load # chars available from the chip */
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700540 char_count = cyy_readb(info, CyRDCR);
Jiri Slabye9410272006-12-08 02:39:28 -0800541
542#ifdef CY_ENABLE_MONITORING
Jiri Slabyce97a092007-10-18 03:06:21 -0700543 ++info->mon.int_count;
544 info->mon.char_count += char_count;
545 if (char_count > info->mon.char_max)
546 info->mon.char_max = char_count;
547 info->mon.char_last = char_count;
Jiri Slabye9410272006-12-08 02:39:28 -0800548#endif
Jiri Slaby227434f2013-01-03 15:53:01 +0100549 len = tty_buffer_request_room(port, char_count);
Jiri Slabyce97a092007-10-18 03:06:21 -0700550 while (len--) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700551 data = cyy_readb(info, CyRDSR);
Jiri Slaby92a19f92013-01-03 15:53:03 +0100552 tty_insert_flip_char(port, data, TTY_NORMAL);
Jiri Slabyce97a092007-10-18 03:06:21 -0700553 info->idle_stats.recv_bytes++;
554 info->icount.rx++;
Jiri Slabye9410272006-12-08 02:39:28 -0800555#ifdef CY_16Y_HACK
Jiri Slabyce97a092007-10-18 03:06:21 -0700556 udelay(10L);
Jiri Slabye9410272006-12-08 02:39:28 -0800557#endif
Jiri Slabye9410272006-12-08 02:39:28 -0800558 }
Jiri Slabyce97a092007-10-18 03:06:21 -0700559 info->idle_stats.recv_idle = jiffies;
560 }
Jiri Slaby6732c8b2013-01-03 15:53:07 +0100561 tty_schedule_flip(port);
562
Jiri Slabyce97a092007-10-18 03:06:21 -0700563 /* end of service */
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700564 cyy_writeb(info, CyRIR, save_xir & 0x3f);
565 cyy_writeb(info, CyCAR, save_car);
Jiri Slabyce97a092007-10-18 03:06:21 -0700566}
567
Jiri Slaby65f76a82007-10-18 03:06:22 -0700568static void cyy_chip_tx(struct cyclades_card *cinfo, unsigned int chip,
Jiri Slabyce97a092007-10-18 03:06:21 -0700569 void __iomem *base_addr)
570{
571 struct cyclades_port *info;
Jiri Slabyd13549f2009-09-19 13:13:12 -0700572 struct tty_struct *tty;
Jiri Slaby65f76a82007-10-18 03:06:22 -0700573 int char_count, index = cinfo->bus_index;
574 u8 save_xir, channel, save_car, outch;
Jiri Slabyce97a092007-10-18 03:06:21 -0700575
576 /* Since we only get here when the transmit buffer
577 is empty, we know we can always stuff a dozen
578 characters. */
579#ifdef CY_DEBUG_INTERRUPTS
580 printk(KERN_DEBUG "cyy_interrupt: xmit intr, chip %d\n", chip);
581#endif
582
583 /* determine the channel & change to that context */
Jiri Slaby65f76a82007-10-18 03:06:22 -0700584 save_xir = readb(base_addr + (CyTIR << index));
585 channel = save_xir & CyIRChannel;
Jiri Slabyce97a092007-10-18 03:06:21 -0700586 save_car = readb(base_addr + (CyCAR << index));
587 cy_writeb(base_addr + (CyCAR << index), save_xir);
588
Jiri Slabyce97a092007-10-18 03:06:21 -0700589 info = &cinfo->ports[channel + chip * 4];
Jiri Slabyd13549f2009-09-19 13:13:12 -0700590 tty = tty_port_tty_get(&info->port);
591 if (tty == NULL) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700592 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyTxRdy);
Jiri Slabyce97a092007-10-18 03:06:21 -0700593 goto end;
Jiri Slabye9410272006-12-08 02:39:28 -0800594 }
595
Jiri Slabyce97a092007-10-18 03:06:21 -0700596 /* load the on-chip space for outbound data */
597 char_count = info->xmit_fifo_size;
Jiri Slabye9410272006-12-08 02:39:28 -0800598
Jiri Slabyce97a092007-10-18 03:06:21 -0700599 if (info->x_char) { /* send special char */
600 outch = info->x_char;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700601 cyy_writeb(info, CyTDR, outch);
Jiri Slabyce97a092007-10-18 03:06:21 -0700602 char_count--;
603 info->icount.tx++;
604 info->x_char = 0;
605 }
Jiri Slabye9410272006-12-08 02:39:28 -0800606
Jiri Slabyce97a092007-10-18 03:06:21 -0700607 if (info->breakon || info->breakoff) {
608 if (info->breakon) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700609 cyy_writeb(info, CyTDR, 0);
610 cyy_writeb(info, CyTDR, 0x81);
Jiri Slabyce97a092007-10-18 03:06:21 -0700611 info->breakon = 0;
612 char_count -= 2;
Jiri Slaby02f11752006-12-08 02:39:28 -0800613 }
Jiri Slabyce97a092007-10-18 03:06:21 -0700614 if (info->breakoff) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700615 cyy_writeb(info, CyTDR, 0);
616 cyy_writeb(info, CyTDR, 0x83);
Jiri Slabyce97a092007-10-18 03:06:21 -0700617 info->breakoff = 0;
618 char_count -= 2;
Jiri Slaby02f11752006-12-08 02:39:28 -0800619 }
Jiri Slabyce97a092007-10-18 03:06:21 -0700620 }
Jiri Slabye9410272006-12-08 02:39:28 -0800621
Jiri Slabyce97a092007-10-18 03:06:21 -0700622 while (char_count-- > 0) {
623 if (!info->xmit_cnt) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700624 if (cyy_readb(info, CySRER) & CyTxMpty) {
625 cyy_writeb(info, CySRER,
626 cyy_readb(info, CySRER) & ~CyTxMpty);
Jiri Slabyce97a092007-10-18 03:06:21 -0700627 } else {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700628 cyy_writeb(info, CySRER, CyTxMpty |
629 (cyy_readb(info, CySRER) & ~CyTxRdy));
Jiri Slaby02f11752006-12-08 02:39:28 -0800630 }
Jiri Slabyce97a092007-10-18 03:06:21 -0700631 goto done;
632 }
Alan Cox77451e52008-07-16 21:57:02 +0100633 if (info->port.xmit_buf == NULL) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700634 cyy_writeb(info, CySRER,
635 cyy_readb(info, CySRER) & ~CyTxRdy);
Jiri Slabyce97a092007-10-18 03:06:21 -0700636 goto done;
637 }
Jiri Slabyd13549f2009-09-19 13:13:12 -0700638 if (tty->stopped || tty->hw_stopped) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700639 cyy_writeb(info, CySRER,
640 cyy_readb(info, CySRER) & ~CyTxRdy);
Jiri Slabyce97a092007-10-18 03:06:21 -0700641 goto done;
642 }
643 /* Because the Embedded Transmit Commands have been enabled,
644 * we must check to see if the escape character, NULL, is being
645 * sent. If it is, we must ensure that there is room for it to
646 * be doubled in the output stream. Therefore we no longer
647 * advance the pointer when the character is fetched, but
648 * rather wait until after the check for a NULL output
649 * character. This is necessary because there may not be room
650 * for the two chars needed to send a NULL.)
651 */
Alan Cox77451e52008-07-16 21:57:02 +0100652 outch = info->port.xmit_buf[info->xmit_tail];
Jiri Slabyce97a092007-10-18 03:06:21 -0700653 if (outch) {
654 info->xmit_cnt--;
655 info->xmit_tail = (info->xmit_tail + 1) &
656 (SERIAL_XMIT_SIZE - 1);
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700657 cyy_writeb(info, CyTDR, outch);
Jiri Slabyce97a092007-10-18 03:06:21 -0700658 info->icount.tx++;
659 } else {
660 if (char_count > 1) {
Jiri Slaby02f11752006-12-08 02:39:28 -0800661 info->xmit_cnt--;
662 info->xmit_tail = (info->xmit_tail + 1) &
Jiri Slabyce97a092007-10-18 03:06:21 -0700663 (SERIAL_XMIT_SIZE - 1);
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700664 cyy_writeb(info, CyTDR, outch);
665 cyy_writeb(info, CyTDR, 0);
Jiri Slaby02f11752006-12-08 02:39:28 -0800666 info->icount.tx++;
Jiri Slabyce97a092007-10-18 03:06:21 -0700667 char_count--;
Jiri Slaby02f11752006-12-08 02:39:28 -0800668 }
669 }
Jiri Slabye9410272006-12-08 02:39:28 -0800670 }
671
Jiri Slabyce97a092007-10-18 03:06:21 -0700672done:
Jiri Slabyd13549f2009-09-19 13:13:12 -0700673 tty_wakeup(tty);
674 tty_kref_put(tty);
Jiri Slabyce97a092007-10-18 03:06:21 -0700675end:
676 /* end of service */
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700677 cyy_writeb(info, CyTIR, save_xir & 0x3f);
678 cyy_writeb(info, CyCAR, save_car);
Jiri Slabyce97a092007-10-18 03:06:21 -0700679}
Jiri Slabye9410272006-12-08 02:39:28 -0800680
Jiri Slabyce97a092007-10-18 03:06:21 -0700681static void cyy_chip_modem(struct cyclades_card *cinfo, int chip,
682 void __iomem *base_addr)
683{
684 struct cyclades_port *info;
Jiri Slabyd13549f2009-09-19 13:13:12 -0700685 struct tty_struct *tty;
Jiri Slaby65f76a82007-10-18 03:06:22 -0700686 int index = cinfo->bus_index;
687 u8 save_xir, channel, save_car, mdm_change, mdm_status;
Jiri Slabye9410272006-12-08 02:39:28 -0800688
Jiri Slabyce97a092007-10-18 03:06:21 -0700689 /* determine the channel & change to that context */
Jiri Slaby65f76a82007-10-18 03:06:22 -0700690 save_xir = readb(base_addr + (CyMIR << index));
691 channel = save_xir & CyIRChannel;
Jiri Slabyce97a092007-10-18 03:06:21 -0700692 info = &cinfo->ports[channel + chip * 4];
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700693 save_car = cyy_readb(info, CyCAR);
694 cyy_writeb(info, CyCAR, save_xir);
Jiri Slabye9410272006-12-08 02:39:28 -0800695
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700696 mdm_change = cyy_readb(info, CyMISR);
697 mdm_status = cyy_readb(info, CyMSVR1);
Jiri Slabye9410272006-12-08 02:39:28 -0800698
Jiri Slabyd13549f2009-09-19 13:13:12 -0700699 tty = tty_port_tty_get(&info->port);
700 if (!tty)
Jiri Slabyce97a092007-10-18 03:06:21 -0700701 goto end;
Jiri Slaby02f11752006-12-08 02:39:28 -0800702
Jiri Slabyce97a092007-10-18 03:06:21 -0700703 if (mdm_change & CyANY_DELTA) {
704 /* For statistics only */
705 if (mdm_change & CyDCD)
706 info->icount.dcd++;
707 if (mdm_change & CyCTS)
708 info->icount.cts++;
709 if (mdm_change & CyDSR)
710 info->icount.dsr++;
711 if (mdm_change & CyRI)
712 info->icount.rng++;
713
Alan Coxbdc04e32009-09-19 13:13:31 -0700714 wake_up_interruptible(&info->port.delta_msr_wait);
Jiri Slabyce97a092007-10-18 03:06:21 -0700715 }
716
Alan Cox77451e52008-07-16 21:57:02 +0100717 if ((mdm_change & CyDCD) && (info->port.flags & ASYNC_CHECK_CD)) {
Jiri Slaby174e6fe2009-09-19 13:13:13 -0700718 if (mdm_status & CyDCD)
719 wake_up_interruptible(&info->port.open_wait);
720 else
Jiri Slabyd13549f2009-09-19 13:13:12 -0700721 tty_hangup(tty);
Jiri Slabye9410272006-12-08 02:39:28 -0800722 }
Huang Shijief21ec3d2012-08-22 22:13:36 -0400723 if ((mdm_change & CyCTS) && tty_port_cts_enabled(&info->port)) {
Jiri Slabyd13549f2009-09-19 13:13:12 -0700724 if (tty->hw_stopped) {
Jiri Slabyce97a092007-10-18 03:06:21 -0700725 if (mdm_status & CyCTS) {
726 /* cy_start isn't used
727 because... !!! */
Jiri Slabyd13549f2009-09-19 13:13:12 -0700728 tty->hw_stopped = 0;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700729 cyy_writeb(info, CySRER,
730 cyy_readb(info, CySRER) | CyTxRdy);
Jiri Slabyd13549f2009-09-19 13:13:12 -0700731 tty_wakeup(tty);
Jiri Slabyce97a092007-10-18 03:06:21 -0700732 }
733 } else {
734 if (!(mdm_status & CyCTS)) {
735 /* cy_stop isn't used
736 because ... !!! */
Jiri Slabyd13549f2009-09-19 13:13:12 -0700737 tty->hw_stopped = 1;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700738 cyy_writeb(info, CySRER,
739 cyy_readb(info, CySRER) & ~CyTxRdy);
Jiri Slabyce97a092007-10-18 03:06:21 -0700740 }
741 }
742 }
743/* if (mdm_change & CyDSR) {
744 }
745 if (mdm_change & CyRI) {
746 }*/
Jiri Slabyd13549f2009-09-19 13:13:12 -0700747 tty_kref_put(tty);
Jiri Slabyce97a092007-10-18 03:06:21 -0700748end:
749 /* end of service */
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700750 cyy_writeb(info, CyMIR, save_xir & 0x3f);
751 cyy_writeb(info, CyCAR, save_car);
Jiri Slabye9410272006-12-08 02:39:28 -0800752}
753
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754/* The real interrupt service routine is called
755 whenever the card wants its hand held--chars
756 received, out buffer empty, modem change, etc.
757 */
Jiri Slaby02f11752006-12-08 02:39:28 -0800758static irqreturn_t cyy_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759{
Jiri Slaby02f11752006-12-08 02:39:28 -0800760 int status;
Jiri Slabyf7429032007-05-08 00:36:59 -0700761 struct cyclades_card *cinfo = dev_id;
Jiri Slaby02f11752006-12-08 02:39:28 -0800762 void __iomem *base_addr, *card_base_addr;
Jiri Slaby65f76a82007-10-18 03:06:22 -0700763 unsigned int chip, too_many, had_work;
Jiri Slaby02f11752006-12-08 02:39:28 -0800764 int index;
Jiri Slabye9410272006-12-08 02:39:28 -0800765
Jiri Slabyf7429032007-05-08 00:36:59 -0700766 if (unlikely(cinfo == NULL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767#ifdef CY_DEBUG_INTERRUPTS
Alan Cox15ed6cc2008-04-30 00:53:55 -0700768 printk(KERN_DEBUG "cyy_interrupt: spurious interrupt %d\n",
769 irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770#endif
Jiri Slaby02f11752006-12-08 02:39:28 -0800771 return IRQ_NONE; /* spurious interrupt */
772 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773
Jiri Slaby02f11752006-12-08 02:39:28 -0800774 card_base_addr = cinfo->base_addr;
775 index = cinfo->bus_index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776
Jiri Slabyf1e83c62007-05-08 00:36:24 -0700777 /* card was not initialized yet (e.g. DEBUG_SHIRQ) */
778 if (unlikely(card_base_addr == NULL))
779 return IRQ_HANDLED;
780
Jiri Slaby02f11752006-12-08 02:39:28 -0800781 /* This loop checks all chips in the card. Make a note whenever
782 _any_ chip had some work to do, as this is considered an
783 indication that there will be more to do. Only when no chip
784 has any work does this outermost loop exit.
785 */
786 do {
787 had_work = 0;
788 for (chip = 0; chip < cinfo->num_chips; chip++) {
789 base_addr = cinfo->base_addr +
790 (cy_chip_offset[chip] << index);
791 too_many = 0;
Jiri Slabydb05c3b2007-05-08 00:35:46 -0700792 while ((status = readb(base_addr +
Jiri Slaby02f11752006-12-08 02:39:28 -0800793 (CySVRR << index))) != 0x00) {
794 had_work++;
795 /* The purpose of the following test is to ensure that
796 no chip can monopolize the driver. This forces the
797 chips to be checked in a round-robin fashion (after
798 draining each of a bunch (1000) of characters).
799 */
Jiri Slabyce97a092007-10-18 03:06:21 -0700800 if (1000 < too_many++)
Jiri Slaby02f11752006-12-08 02:39:28 -0800801 break;
Jiri Slaby1c0a3872007-10-18 03:06:22 -0700802 spin_lock(&cinfo->card_lock);
Jiri Slabyce97a092007-10-18 03:06:21 -0700803 if (status & CySRReceive) /* rx intr */
804 cyy_chip_rx(cinfo, chip, base_addr);
805 if (status & CySRTransmit) /* tx intr */
806 cyy_chip_tx(cinfo, chip, base_addr);
807 if (status & CySRModem) /* modem intr */
808 cyy_chip_modem(cinfo, chip, base_addr);
Jiri Slaby1c0a3872007-10-18 03:06:22 -0700809 spin_unlock(&cinfo->card_lock);
Jiri Slaby02f11752006-12-08 02:39:28 -0800810 }
811 }
812 } while (had_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813
Jiri Slaby02f11752006-12-08 02:39:28 -0800814 /* clear interrupts */
815 spin_lock(&cinfo->card_lock);
816 cy_writeb(card_base_addr + (Cy_ClrIntr << index), 0);
817 /* Cy_ClrIntr is 0x1800 */
818 spin_unlock(&cinfo->card_lock);
819 return IRQ_HANDLED;
820} /* cyy_interrupt */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821
Jiri Slaby4d768202009-09-19 13:13:15 -0700822static void cyy_change_rts_dtr(struct cyclades_port *info, unsigned int set,
823 unsigned int clear)
824{
825 struct cyclades_card *card = info->card;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700826 int channel = info->line - card->first_line;
Jiri Slaby0d348722009-09-19 13:13:16 -0700827 u32 rts, dtr, msvrr, msvrd;
Jiri Slaby4d768202009-09-19 13:13:15 -0700828
Jiri Slaby4d768202009-09-19 13:13:15 -0700829 channel &= 0x03;
Jiri Slaby4d768202009-09-19 13:13:15 -0700830
Jiri Slaby0d348722009-09-19 13:13:16 -0700831 if (info->rtsdtr_inv) {
832 msvrr = CyMSVR2;
833 msvrd = CyMSVR1;
834 rts = CyDTR;
835 dtr = CyRTS;
836 } else {
837 msvrr = CyMSVR1;
838 msvrd = CyMSVR2;
839 rts = CyRTS;
840 dtr = CyDTR;
841 }
Jiri Slaby4d768202009-09-19 13:13:15 -0700842 if (set & TIOCM_RTS) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700843 cyy_writeb(info, CyCAR, channel);
844 cyy_writeb(info, msvrr, rts);
Jiri Slaby4d768202009-09-19 13:13:15 -0700845 }
846 if (clear & TIOCM_RTS) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700847 cyy_writeb(info, CyCAR, channel);
848 cyy_writeb(info, msvrr, ~rts);
Jiri Slaby4d768202009-09-19 13:13:15 -0700849 }
850 if (set & TIOCM_DTR) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700851 cyy_writeb(info, CyCAR, channel);
852 cyy_writeb(info, msvrd, dtr);
Jiri Slaby4d768202009-09-19 13:13:15 -0700853#ifdef CY_DEBUG_DTR
854 printk(KERN_DEBUG "cyc:set_modem_info raising DTR\n");
855 printk(KERN_DEBUG " status: 0x%x, 0x%x\n",
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700856 cyy_readb(info, CyMSVR1),
857 cyy_readb(info, CyMSVR2));
Jiri Slaby4d768202009-09-19 13:13:15 -0700858#endif
859 }
860 if (clear & TIOCM_DTR) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700861 cyy_writeb(info, CyCAR, channel);
862 cyy_writeb(info, msvrd, ~dtr);
Jiri Slaby4d768202009-09-19 13:13:15 -0700863#ifdef CY_DEBUG_DTR
864 printk(KERN_DEBUG "cyc:set_modem_info dropping DTR\n");
865 printk(KERN_DEBUG " status: 0x%x, 0x%x\n",
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700866 cyy_readb(info, CyMSVR1),
867 cyy_readb(info, CyMSVR2));
Jiri Slaby4d768202009-09-19 13:13:15 -0700868#endif
869 }
870}
871
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872/***********************************************************/
873/********* End of block of Cyclom-Y specific code **********/
Alan Cox15ed6cc2008-04-30 00:53:55 -0700874/******** Start of block of Cyclades-Z specific code *******/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875/***********************************************************/
876
877static int
Jiri Slaby02f11752006-12-08 02:39:28 -0800878cyz_fetch_msg(struct cyclades_card *cinfo,
Alan Cox15ed6cc2008-04-30 00:53:55 -0700879 __u32 *channel, __u8 *cmd, __u32 *param)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880{
Jiri Slabyf0eefdc2009-09-19 13:13:13 -0700881 struct BOARD_CTRL __iomem *board_ctrl = cinfo->board_ctrl;
Jiri Slaby02f11752006-12-08 02:39:28 -0800882 unsigned long loc_doorbell;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883
Jiri Slaby97e87f82009-06-11 12:29:27 +0100884 loc_doorbell = readl(&cinfo->ctl_addr.p9060->loc_doorbell);
Jiri Slaby02f11752006-12-08 02:39:28 -0800885 if (loc_doorbell) {
886 *cmd = (char)(0xff & loc_doorbell);
Jiri Slabydb05c3b2007-05-08 00:35:46 -0700887 *channel = readl(&board_ctrl->fwcmd_channel);
888 *param = (__u32) readl(&board_ctrl->fwcmd_param);
Jiri Slaby97e87f82009-06-11 12:29:27 +0100889 cy_writel(&cinfo->ctl_addr.p9060->loc_doorbell, 0xffffffff);
Jiri Slaby02f11752006-12-08 02:39:28 -0800890 return 1;
891 }
892 return 0;
893} /* cyz_fetch_msg */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894
895static int
Jiri Slaby02f11752006-12-08 02:39:28 -0800896cyz_issue_cmd(struct cyclades_card *cinfo,
Klaus Kudielka1a86b5e2007-05-08 00:26:26 -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;
Klaus Kudielka1a86b5e2007-05-08 00:26:26 -0700900 __u32 __iomem *pci_doorbell;
Jiri Slaby65f76a82007-10-18 03:06:22 -0700901 unsigned int index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902
Jiri Slaby2693f482009-06-11 12:31:06 +0100903 if (!cyz_is_loaded(cinfo))
Jiri Slaby096dcfc2006-12-08 02:39:30 -0800904 return -1;
Alan Cox15ed6cc2008-04-30 00:53:55 -0700905
Jiri Slaby02f11752006-12-08 02:39:28 -0800906 index = 0;
Jiri Slaby97e87f82009-06-11 12:29:27 +0100907 pci_doorbell = &cinfo->ctl_addr.p9060->pci_doorbell;
Jiri Slabydb05c3b2007-05-08 00:35:46 -0700908 while ((readl(pci_doorbell) & 0xff) != 0) {
Alan Cox15ed6cc2008-04-30 00:53:55 -0700909 if (index++ == 1000)
Jiri Slabydb05c3b2007-05-08 00:35:46 -0700910 return (int)(readl(pci_doorbell) & 0xff);
Jiri Slaby02f11752006-12-08 02:39:28 -0800911 udelay(50L);
912 }
913 cy_writel(&board_ctrl->hcmd_channel, channel);
914 cy_writel(&board_ctrl->hcmd_param, param);
915 cy_writel(pci_doorbell, (long)cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916
Jiri Slaby096dcfc2006-12-08 02:39:30 -0800917 return 0;
Jiri Slaby02f11752006-12-08 02:39:28 -0800918} /* cyz_issue_cmd */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919
Jiri Slabydabe2c12013-01-03 15:53:08 +0100920static void cyz_handle_rx(struct cyclades_port *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921{
Jiri Slabyf0eefdc2009-09-19 13:13:13 -0700922 struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
Jiri Slaby875b2062007-05-08 00:36:49 -0700923 struct cyclades_card *cinfo = info->card;
Jiri Slaby227434f2013-01-03 15:53:01 +0100924 struct tty_port *port = &info->port;
Jiri Slaby65f76a82007-10-18 03:06:22 -0700925 unsigned int char_count;
Jiri Slaby02f11752006-12-08 02:39:28 -0800926 int len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927#ifdef BLOCKMOVE
Jiri Slabyce71b0f2007-05-08 00:36:53 -0700928 unsigned char *buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929#else
Jiri Slaby02f11752006-12-08 02:39:28 -0800930 char data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931#endif
Jiri Slabyad39c302007-05-08 00:35:49 -0700932 __u32 rx_put, rx_get, new_rx_get, rx_bufsize, rx_bufaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933
Jiri Slabydb05c3b2007-05-08 00:35:46 -0700934 rx_get = new_rx_get = readl(&buf_ctrl->rx_get);
935 rx_put = readl(&buf_ctrl->rx_put);
936 rx_bufsize = readl(&buf_ctrl->rx_bufsize);
937 rx_bufaddr = readl(&buf_ctrl->rx_bufaddr);
Jiri Slaby02f11752006-12-08 02:39:28 -0800938 if (rx_put >= rx_get)
939 char_count = rx_put - rx_get;
940 else
941 char_count = rx_put - rx_get + rx_bufsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942
Jiri Slabydabe2c12013-01-03 15:53:08 +0100943 if (!char_count)
944 return;
945
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946#ifdef CY_ENABLE_MONITORING
Jiri Slabydabe2c12013-01-03 15:53:08 +0100947 info->mon.int_count++;
948 info->mon.char_count += char_count;
949 if (char_count > info->mon.char_max)
950 info->mon.char_max = char_count;
951 info->mon.char_last = char_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952#endif
Jiri Slabydabe2c12013-01-03 15:53:08 +0100953
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954#ifdef BLOCKMOVE
Jiri Slabydabe2c12013-01-03 15:53:08 +0100955 /* we'd like to use memcpy(t, f, n) and memset(s, c, count)
956 for performance, but because of buffer boundaries, there
957 may be several steps to the operation */
958 while (1) {
959 len = tty_prepare_flip_string(port, &buf,
960 char_count);
961 if (!len)
962 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963
Jiri Slabydabe2c12013-01-03 15:53:08 +0100964 len = min_t(unsigned int, min(len, char_count),
965 rx_bufsize - new_rx_get);
Jiri Slabyce71b0f2007-05-08 00:36:53 -0700966
Jiri Slabydabe2c12013-01-03 15:53:08 +0100967 memcpy_fromio(buf, cinfo->base_addr +
968 rx_bufaddr + new_rx_get, len);
Jiri Slabyce71b0f2007-05-08 00:36:53 -0700969
Jiri Slabydabe2c12013-01-03 15:53:08 +0100970 new_rx_get = (new_rx_get + len) &
971 (rx_bufsize - 1);
972 char_count -= len;
973 info->icount.rx += len;
974 info->idle_stats.recv_bytes += len;
975 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976#else
Jiri Slabydabe2c12013-01-03 15:53:08 +0100977 len = tty_buffer_request_room(port, char_count);
978 while (len--) {
979 data = readb(cinfo->base_addr + rx_bufaddr +
980 new_rx_get);
981 new_rx_get = (new_rx_get + 1) &
982 (rx_bufsize - 1);
983 tty_insert_flip_char(port, data, TTY_NORMAL);
984 info->idle_stats.recv_bytes++;
985 info->icount.rx++;
986 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987#endif
988#ifdef CONFIG_CYZ_INTR
Jiri Slabydabe2c12013-01-03 15:53:08 +0100989 /* Recalculate the number of chars in the RX buffer and issue
990 a cmd in case it's higher than the RX high water mark */
991 rx_put = readl(&buf_ctrl->rx_put);
992 if (rx_put >= rx_get)
993 char_count = rx_put - rx_get;
994 else
995 char_count = rx_put - rx_get + rx_bufsize;
996 if (char_count >= readl(&buf_ctrl->rx_threshold) &&
997 !timer_pending(&cyz_rx_full_timer[
998 info->line]))
999 mod_timer(&cyz_rx_full_timer[info->line],
1000 jiffies + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001#endif
Jiri Slabydabe2c12013-01-03 15:53:08 +01001002 info->idle_stats.recv_idle = jiffies;
1003 tty_schedule_flip(&info->port);
1004
1005 /* Update rx_get */
1006 cy_writel(&buf_ctrl->rx_get, new_rx_get);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007}
1008
Jiri Slabydabe2c12013-01-03 15:53:08 +01001009static void cyz_handle_tx(struct cyclades_port *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010{
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001011 struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
Jiri Slaby875b2062007-05-08 00:36:49 -07001012 struct cyclades_card *cinfo = info->card;
Jiri Slabydabe2c12013-01-03 15:53:08 +01001013 struct tty_struct *tty;
Jiri Slaby65f76a82007-10-18 03:06:22 -07001014 u8 data;
1015 unsigned int char_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016#ifdef BLOCKMOVE
Jiri Slaby02f11752006-12-08 02:39:28 -08001017 int small_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018#endif
Jiri Slabyad39c302007-05-08 00:35:49 -07001019 __u32 tx_put, tx_get, tx_bufsize, tx_bufaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020
Jiri Slaby02f11752006-12-08 02:39:28 -08001021 if (info->xmit_cnt <= 0) /* Nothing to transmit */
1022 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023
Jiri Slabydb05c3b2007-05-08 00:35:46 -07001024 tx_get = readl(&buf_ctrl->tx_get);
1025 tx_put = readl(&buf_ctrl->tx_put);
1026 tx_bufsize = readl(&buf_ctrl->tx_bufsize);
1027 tx_bufaddr = readl(&buf_ctrl->tx_bufaddr);
Jiri Slaby02f11752006-12-08 02:39:28 -08001028 if (tx_put >= tx_get)
1029 char_count = tx_get - tx_put - 1 + tx_bufsize;
1030 else
1031 char_count = tx_get - tx_put - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032
Jiri Slabydabe2c12013-01-03 15:53:08 +01001033 if (!char_count)
1034 return;
1035
1036 tty = tty_port_tty_get(&info->port);
1037 if (tty == NULL)
1038 goto ztxdone;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039
Jiri Slabydabe2c12013-01-03 15:53:08 +01001040 if (info->x_char) { /* send special char */
1041 data = info->x_char;
Jiri Slaby02f11752006-12-08 02:39:28 -08001042
Jiri Slabydabe2c12013-01-03 15:53:08 +01001043 cy_writeb(cinfo->base_addr + tx_bufaddr + tx_put, data);
1044 tx_put = (tx_put + 1) & (tx_bufsize - 1);
1045 info->x_char = 0;
1046 char_count--;
1047 info->icount.tx++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048 }
Jiri Slabydabe2c12013-01-03 15:53:08 +01001049#ifdef BLOCKMOVE
1050 while (0 < (small_count = min_t(unsigned int,
1051 tx_bufsize - tx_put, min_t(unsigned int,
1052 (SERIAL_XMIT_SIZE - info->xmit_tail),
1053 min_t(unsigned int, info->xmit_cnt,
1054 char_count))))) {
1055
1056 memcpy_toio((char *)(cinfo->base_addr + tx_bufaddr + tx_put),
1057 &info->port.xmit_buf[info->xmit_tail],
1058 small_count);
1059
1060 tx_put = (tx_put + small_count) & (tx_bufsize - 1);
1061 char_count -= small_count;
1062 info->icount.tx += small_count;
1063 info->xmit_cnt -= small_count;
1064 info->xmit_tail = (info->xmit_tail + small_count) &
1065 (SERIAL_XMIT_SIZE - 1);
1066 }
1067#else
1068 while (info->xmit_cnt && char_count) {
1069 data = info->port.xmit_buf[info->xmit_tail];
1070 info->xmit_cnt--;
1071 info->xmit_tail = (info->xmit_tail + 1) &
1072 (SERIAL_XMIT_SIZE - 1);
1073
1074 cy_writeb(cinfo->base_addr + tx_bufaddr + tx_put, data);
1075 tx_put = (tx_put + 1) & (tx_bufsize - 1);
1076 char_count--;
1077 info->icount.tx++;
1078 }
1079#endif
1080 tty_wakeup(tty);
1081 tty_kref_put(tty);
1082ztxdone:
1083 /* Update tx_put */
1084 cy_writel(&buf_ctrl->tx_put, tx_put);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085}
1086
Jiri Slaby02f11752006-12-08 02:39:28 -08001087static void cyz_handle_cmd(struct cyclades_card *cinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088{
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001089 struct BOARD_CTRL __iomem *board_ctrl = cinfo->board_ctrl;
Jiri Slaby02f11752006-12-08 02:39:28 -08001090 struct cyclades_port *info;
Jiri Slaby101b8152009-06-11 12:30:10 +01001091 __u32 channel, param, fw_ver;
Klaus Kudielka1a86b5e2007-05-08 00:26:26 -07001092 __u8 cmd;
Jiri Slaby02f11752006-12-08 02:39:28 -08001093 int special_count;
1094 int delta_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095
Jiri Slabydb05c3b2007-05-08 00:35:46 -07001096 fw_ver = readl(&board_ctrl->fw_version);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097
Jiri Slaby02f11752006-12-08 02:39:28 -08001098 while (cyz_fetch_msg(cinfo, &channel, &cmd, &param) == 1) {
1099 special_count = 0;
1100 delta_count = 0;
Jiri Slabydd025c02007-05-08 00:37:02 -07001101 info = &cinfo->ports[channel];
Jiri Slabyf7429032007-05-08 00:36:59 -07001102
Jiri Slaby02f11752006-12-08 02:39:28 -08001103 switch (cmd) {
1104 case C_CM_PR_ERROR:
Jiri Slaby92a19f92013-01-03 15:53:03 +01001105 tty_insert_flip_char(&info->port, 0, TTY_PARITY);
Jiri Slaby02f11752006-12-08 02:39:28 -08001106 info->icount.rx++;
1107 special_count++;
1108 break;
1109 case C_CM_FR_ERROR:
Jiri Slaby92a19f92013-01-03 15:53:03 +01001110 tty_insert_flip_char(&info->port, 0, TTY_FRAME);
Jiri Slaby02f11752006-12-08 02:39:28 -08001111 info->icount.rx++;
1112 special_count++;
1113 break;
1114 case C_CM_RXBRK:
Jiri Slaby92a19f92013-01-03 15:53:03 +01001115 tty_insert_flip_char(&info->port, 0, TTY_BREAK);
Jiri Slaby02f11752006-12-08 02:39:28 -08001116 info->icount.rx++;
1117 special_count++;
1118 break;
1119 case C_CM_MDCD:
1120 info->icount.dcd++;
1121 delta_count++;
Alan Cox77451e52008-07-16 21:57:02 +01001122 if (info->port.flags & ASYNC_CHECK_CD) {
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001123 u32 dcd = fw_ver > 241 ? param :
1124 readl(&info->u.cyz.ch_ctrl->rs_status);
Jiri Slaby174e6fe2009-09-19 13:13:13 -07001125 if (dcd & C_RS_DCD)
Alan Cox77451e52008-07-16 21:57:02 +01001126 wake_up_interruptible(&info->port.open_wait);
Jiri Slabyaa27a092013-03-07 13:12:30 +01001127 else
1128 tty_port_tty_hangup(&info->port, false);
Jiri Slaby02f11752006-12-08 02:39:28 -08001129 }
1130 break;
1131 case C_CM_MCTS:
1132 info->icount.cts++;
1133 delta_count++;
1134 break;
1135 case C_CM_MRI:
1136 info->icount.rng++;
1137 delta_count++;
1138 break;
1139 case C_CM_MDSR:
1140 info->icount.dsr++;
1141 delta_count++;
1142 break;
1143#ifdef Z_WAKE
1144 case C_CM_IOCTLW:
Jiri Slabyebafeef2007-10-18 03:06:20 -07001145 complete(&info->shutdown_wait);
Jiri Slaby02f11752006-12-08 02:39:28 -08001146 break;
1147#endif
1148#ifdef CONFIG_CYZ_INTR
1149 case C_CM_RXHIWM:
1150 case C_CM_RXNNDT:
1151 case C_CM_INTBACK2:
1152 /* Reception Interrupt */
1153#ifdef CY_DEBUG_INTERRUPTS
Jiri Slaby21719192007-05-08 00:36:42 -07001154 printk(KERN_DEBUG "cyz_interrupt: rcvd intr, card %d, "
1155 "port %ld\n", info->card, channel);
Jiri Slaby02f11752006-12-08 02:39:28 -08001156#endif
Jiri Slabydabe2c12013-01-03 15:53:08 +01001157 cyz_handle_rx(info);
Jiri Slaby02f11752006-12-08 02:39:28 -08001158 break;
1159 case C_CM_TXBEMPTY:
1160 case C_CM_TXLOWWM:
1161 case C_CM_INTBACK:
1162 /* Transmission Interrupt */
1163#ifdef CY_DEBUG_INTERRUPTS
Jiri Slaby21719192007-05-08 00:36:42 -07001164 printk(KERN_DEBUG "cyz_interrupt: xmit intr, card %d, "
1165 "port %ld\n", info->card, channel);
Jiri Slaby02f11752006-12-08 02:39:28 -08001166#endif
Jiri Slabydabe2c12013-01-03 15:53:08 +01001167 cyz_handle_tx(info);
Jiri Slaby02f11752006-12-08 02:39:28 -08001168 break;
1169#endif /* CONFIG_CYZ_INTR */
1170 case C_CM_FATAL:
1171 /* should do something with this !!! */
1172 break;
1173 default:
1174 break;
1175 }
1176 if (delta_count)
Alan Coxbdc04e32009-09-19 13:13:31 -07001177 wake_up_interruptible(&info->port.delta_msr_wait);
Jiri Slaby02f11752006-12-08 02:39:28 -08001178 if (special_count)
Jiri Slaby6732c8b2013-01-03 15:53:07 +01001179 tty_schedule_flip(&info->port);
Jiri Slaby02f11752006-12-08 02:39:28 -08001180 }
1181}
1182
1183#ifdef CONFIG_CYZ_INTR
1184static irqreturn_t cyz_interrupt(int irq, void *dev_id)
1185{
Jiri Slabyf7429032007-05-08 00:36:59 -07001186 struct cyclades_card *cinfo = dev_id;
Jiri Slaby02f11752006-12-08 02:39:28 -08001187
Jiri Slaby2693f482009-06-11 12:31:06 +01001188 if (unlikely(!cyz_is_loaded(cinfo))) {
Jiri Slaby02f11752006-12-08 02:39:28 -08001189#ifdef CY_DEBUG_INTERRUPTS
Jiri Slaby21719192007-05-08 00:36:42 -07001190 printk(KERN_DEBUG "cyz_interrupt: board not yet loaded "
1191 "(IRQ%d).\n", irq);
Jiri Slaby02f11752006-12-08 02:39:28 -08001192#endif
1193 return IRQ_NONE;
1194 }
1195
1196 /* Handle the interrupts */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197 cyz_handle_cmd(cinfo);
1198
Jiri Slaby02f11752006-12-08 02:39:28 -08001199 return IRQ_HANDLED;
1200} /* cyz_interrupt */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201
Jiri Slaby02f11752006-12-08 02:39:28 -08001202static void cyz_rx_restart(unsigned long arg)
1203{
1204 struct cyclades_port *info = (struct cyclades_port *)arg;
Jiri Slaby875b2062007-05-08 00:36:49 -07001205 struct cyclades_card *card = info->card;
Jiri Slaby02f11752006-12-08 02:39:28 -08001206 int retval;
Jiri Slaby875b2062007-05-08 00:36:49 -07001207 __u32 channel = info->line - card->first_line;
Jiri Slaby02f11752006-12-08 02:39:28 -08001208 unsigned long flags;
1209
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001210 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby875b2062007-05-08 00:36:49 -07001211 retval = cyz_issue_cmd(card, channel, C_CM_INTBACK2, 0L);
Jiri Slaby02f11752006-12-08 02:39:28 -08001212 if (retval != 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07001213 printk(KERN_ERR "cyc:cyz_rx_restart retval on ttyC%d was %x\n",
Jiri Slaby02f11752006-12-08 02:39:28 -08001214 info->line, retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 }
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001216 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08001217}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218
Jiri Slaby02f11752006-12-08 02:39:28 -08001219#else /* CONFIG_CYZ_INTR */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220
Jiri Slaby02f11752006-12-08 02:39:28 -08001221static void cyz_poll(unsigned long arg)
1222{
1223 struct cyclades_card *cinfo;
1224 struct cyclades_port *info;
Jiri Slabyb7050902007-05-08 00:35:48 -07001225 unsigned long expires = jiffies + HZ;
Jiri Slaby65f76a82007-10-18 03:06:22 -07001226 unsigned int port, card;
Jiri Slaby02f11752006-12-08 02:39:28 -08001227
Jiri Slaby02f11752006-12-08 02:39:28 -08001228 for (card = 0; card < NR_CARDS; card++) {
1229 cinfo = &cy_card[card];
1230
Jiri Slaby2693f482009-06-11 12:31:06 +01001231 if (!cy_is_Z(cinfo))
Jiri Slaby02f11752006-12-08 02:39:28 -08001232 continue;
Jiri Slaby2693f482009-06-11 12:31:06 +01001233 if (!cyz_is_loaded(cinfo))
Jiri Slaby02f11752006-12-08 02:39:28 -08001234 continue;
1235
Jiri Slaby02f11752006-12-08 02:39:28 -08001236 /* Skip first polling cycle to avoid racing conditions with the FW */
1237 if (!cinfo->intr_enabled) {
Jiri Slaby02f11752006-12-08 02:39:28 -08001238 cinfo->intr_enabled = 1;
1239 continue;
1240 }
1241
1242 cyz_handle_cmd(cinfo);
1243
1244 for (port = 0; port < cinfo->nports; port++) {
Jiri Slabydd025c02007-05-08 00:37:02 -07001245 info = &cinfo->ports[port];
Jiri Slabyd13549f2009-09-19 13:13:12 -07001246
Jiri Slaby02f11752006-12-08 02:39:28 -08001247 if (!info->throttle)
Jiri Slabydabe2c12013-01-03 15:53:08 +01001248 cyz_handle_rx(info);
1249 cyz_handle_tx(info);
Jiri Slaby02f11752006-12-08 02:39:28 -08001250 }
1251 /* poll every 'cyz_polling_cycle' period */
Jiri Slabyb7050902007-05-08 00:35:48 -07001252 expires = jiffies + cyz_polling_cycle;
Jiri Slaby02f11752006-12-08 02:39:28 -08001253 }
Jiri Slabyb7050902007-05-08 00:35:48 -07001254 mod_timer(&cyz_timerlist, expires);
Jiri Slaby02f11752006-12-08 02:39:28 -08001255} /* cyz_poll */
1256
1257#endif /* CONFIG_CYZ_INTR */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258
1259/********** End of block of Cyclades-Z specific code *********/
1260/***********************************************************/
1261
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262/* This is called whenever a port becomes active;
1263 interrupts are enabled and DTR & RTS are turned on.
1264 */
Jiri Slabyd13549f2009-09-19 13:13:12 -07001265static int cy_startup(struct cyclades_port *info, struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266{
Jiri Slaby875b2062007-05-08 00:36:49 -07001267 struct cyclades_card *card;
Jiri Slaby02f11752006-12-08 02:39:28 -08001268 unsigned long flags;
1269 int retval = 0;
Jiri Slabycc7fdf42009-09-19 13:13:15 -07001270 int channel;
Jiri Slaby02f11752006-12-08 02:39:28 -08001271 unsigned long page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272
Jiri Slaby02f11752006-12-08 02:39:28 -08001273 card = info->card;
Jiri Slaby875b2062007-05-08 00:36:49 -07001274 channel = info->line - card->first_line;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275
Jiri Slaby02f11752006-12-08 02:39:28 -08001276 page = get_zeroed_page(GFP_KERNEL);
1277 if (!page)
1278 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001280 spin_lock_irqsave(&card->card_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281
Jiri Slabycc7fdf42009-09-19 13:13:15 -07001282 if (info->port.flags & ASYNC_INITIALIZED)
Jiri Slaby02f11752006-12-08 02:39:28 -08001283 goto errout;
Jiri Slaby02f11752006-12-08 02:39:28 -08001284
1285 if (!info->type) {
Jiri Slabyd13549f2009-09-19 13:13:12 -07001286 set_bit(TTY_IO_ERROR, &tty->flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08001287 goto errout;
1288 }
1289
Alan Cox77451e52008-07-16 21:57:02 +01001290 if (info->port.xmit_buf)
Jiri Slaby02f11752006-12-08 02:39:28 -08001291 free_page(page);
1292 else
Alan Cox77451e52008-07-16 21:57:02 +01001293 info->port.xmit_buf = (unsigned char *)page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001295 spin_unlock_irqrestore(&card->card_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296
Jiri Slabyd13549f2009-09-19 13:13:12 -07001297 cy_set_line_char(info, tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298
Jiri Slaby2693f482009-06-11 12:31:06 +01001299 if (!cy_is_Z(card)) {
Jiri Slaby02f11752006-12-08 02:39:28 -08001300 channel &= 0x03;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001302 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08001303
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07001304 cyy_writeb(info, CyCAR, channel);
Jiri Slaby02f11752006-12-08 02:39:28 -08001305
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07001306 cyy_writeb(info, CyRTPR,
Jiri Slaby02f11752006-12-08 02:39:28 -08001307 (info->default_timeout ? info->default_timeout : 0x02));
1308 /* 10ms rx timeout */
1309
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07001310 cyy_issue_cmd(info, CyCHAN_CTL | CyENB_RCVR | CyENB_XMTR);
Jiri Slaby02f11752006-12-08 02:39:28 -08001311
Jiri Slaby4d768202009-09-19 13:13:15 -07001312 cyy_change_rts_dtr(info, TIOCM_RTS | TIOCM_DTR, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07001314 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyRxData);
Jiri Slaby02f11752006-12-08 02:39:28 -08001315 } else {
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001316 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
Jiri Slaby02f11752006-12-08 02:39:28 -08001317
Jiri Slaby2693f482009-06-11 12:31:06 +01001318 if (!cyz_is_loaded(card))
Jiri Slaby02f11752006-12-08 02:39:28 -08001319 return -ENODEV;
Jiri Slaby02f11752006-12-08 02:39:28 -08001320
Jiri Slaby02f11752006-12-08 02:39:28 -08001321#ifdef CY_DEBUG_OPEN
Jiri Slaby21719192007-05-08 00:36:42 -07001322 printk(KERN_DEBUG "cyc startup Z card %d, channel %d, "
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001323 "base_addr %p\n", card, channel, card->base_addr);
Jiri Slaby02f11752006-12-08 02:39:28 -08001324#endif
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001325 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08001326
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001327 cy_writel(&ch_ctrl->op_mode, C_CH_ENABLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328#ifdef Z_WAKE
1329#ifdef CONFIG_CYZ_INTR
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001330 cy_writel(&ch_ctrl->intr_enable,
Jiri Slaby02f11752006-12-08 02:39:28 -08001331 C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM |
1332 C_IN_RXNNDT | C_IN_IOCTLW | C_IN_MDCD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333#else
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001334 cy_writel(&ch_ctrl->intr_enable,
Jiri Slaby02f11752006-12-08 02:39:28 -08001335 C_IN_IOCTLW | C_IN_MDCD);
1336#endif /* CONFIG_CYZ_INTR */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337#else
1338#ifdef CONFIG_CYZ_INTR
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001339 cy_writel(&ch_ctrl->intr_enable,
Jiri Slaby02f11752006-12-08 02:39:28 -08001340 C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM |
1341 C_IN_RXNNDT | C_IN_MDCD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342#else
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001343 cy_writel(&ch_ctrl->intr_enable, C_IN_MDCD);
Jiri Slaby02f11752006-12-08 02:39:28 -08001344#endif /* CONFIG_CYZ_INTR */
1345#endif /* Z_WAKE */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346
Jiri Slaby875b2062007-05-08 00:36:49 -07001347 retval = cyz_issue_cmd(card, channel, C_CM_IOCTL, 0L);
Jiri Slaby02f11752006-12-08 02:39:28 -08001348 if (retval != 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07001349 printk(KERN_ERR "cyc:startup(1) retval on ttyC%d was "
1350 "%x\n", info->line, retval);
Jiri Slaby02f11752006-12-08 02:39:28 -08001351 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352
Jiri Slaby02f11752006-12-08 02:39:28 -08001353 /* Flush RX buffers before raising DTR and RTS */
Jiri Slaby875b2062007-05-08 00:36:49 -07001354 retval = cyz_issue_cmd(card, channel, C_CM_FLUSH_RX, 0L);
Jiri Slaby02f11752006-12-08 02:39:28 -08001355 if (retval != 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07001356 printk(KERN_ERR "cyc:startup(2) retval on ttyC%d was "
1357 "%x\n", info->line, retval);
Jiri Slaby02f11752006-12-08 02:39:28 -08001358 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359
Jiri Slaby02f11752006-12-08 02:39:28 -08001360 /* set timeout !!! */
1361 /* set RTS and DTR !!! */
Jiri Slaby4d768202009-09-19 13:13:15 -07001362 tty_port_raise_dtr_rts(&info->port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363
Jiri Slaby02f11752006-12-08 02:39:28 -08001364 /* enable send, recv, modem !!! */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366
Jiri Slabycc7fdf42009-09-19 13:13:15 -07001367 info->port.flags |= ASYNC_INITIALIZED;
1368
1369 clear_bit(TTY_IO_ERROR, &tty->flags);
1370 info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1371 info->breakon = info->breakoff = 0;
1372 memset((char *)&info->idle_stats, 0, sizeof(info->idle_stats));
1373 info->idle_stats.in_use =
1374 info->idle_stats.recv_idle =
1375 info->idle_stats.xmit_idle = jiffies;
1376
1377 spin_unlock_irqrestore(&card->card_lock, flags);
1378
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379#ifdef CY_DEBUG_OPEN
Jiri Slaby21719192007-05-08 00:36:42 -07001380 printk(KERN_DEBUG "cyc startup done\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381#endif
1382 return 0;
1383
1384errout:
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001385 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slabycc7fdf42009-09-19 13:13:15 -07001386 free_page(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387 return retval;
Jiri Slaby02f11752006-12-08 02:39:28 -08001388} /* startup */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389
Jiri Slaby02f11752006-12-08 02:39:28 -08001390static void start_xmit(struct cyclades_port *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391{
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07001392 struct cyclades_card *card = info->card;
Jiri Slaby02f11752006-12-08 02:39:28 -08001393 unsigned long flags;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07001394 int channel = info->line - card->first_line;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395
Jiri Slaby2693f482009-06-11 12:31:06 +01001396 if (!cy_is_Z(card)) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001397 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07001398 cyy_writeb(info, CyCAR, channel & 0x03);
1399 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyTxRdy);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001400 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08001401 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402#ifdef CONFIG_CYZ_INTR
Jiri Slaby02f11752006-12-08 02:39:28 -08001403 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001405 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby875b2062007-05-08 00:36:49 -07001406 retval = cyz_issue_cmd(card, channel, C_CM_INTBACK, 0L);
Jiri Slaby02f11752006-12-08 02:39:28 -08001407 if (retval != 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07001408 printk(KERN_ERR "cyc:start_xmit retval on ttyC%d was "
1409 "%x\n", info->line, retval);
Jiri Slaby02f11752006-12-08 02:39:28 -08001410 }
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001411 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08001412#else /* CONFIG_CYZ_INTR */
1413 /* Don't have to do anything at this time */
1414#endif /* CONFIG_CYZ_INTR */
1415 }
1416} /* start_xmit */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417
1418/*
1419 * This routine shuts down a serial port; interrupts are disabled,
1420 * and DTR is dropped if the hangup on close termio flag is on.
1421 */
Jiri Slabyd13549f2009-09-19 13:13:12 -07001422static void cy_shutdown(struct cyclades_port *info, struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423{
Jiri Slaby875b2062007-05-08 00:36:49 -07001424 struct cyclades_card *card;
Jiri Slaby02f11752006-12-08 02:39:28 -08001425 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426
Alan Cox77451e52008-07-16 21:57:02 +01001427 if (!(info->port.flags & ASYNC_INITIALIZED))
Jiri Slaby02f11752006-12-08 02:39:28 -08001428 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429
Jiri Slaby02f11752006-12-08 02:39:28 -08001430 card = info->card;
Jiri Slaby2693f482009-06-11 12:31:06 +01001431 if (!cy_is_Z(card)) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001432 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08001433
1434 /* Clear delta_msr_wait queue to avoid mem leaks. */
Alan Coxbdc04e32009-09-19 13:13:31 -07001435 wake_up_interruptible(&info->port.delta_msr_wait);
Jiri Slaby02f11752006-12-08 02:39:28 -08001436
Alan Cox77451e52008-07-16 21:57:02 +01001437 if (info->port.xmit_buf) {
Jiri Slaby02f11752006-12-08 02:39:28 -08001438 unsigned char *temp;
Alan Cox77451e52008-07-16 21:57:02 +01001439 temp = info->port.xmit_buf;
1440 info->port.xmit_buf = NULL;
Jiri Slaby02f11752006-12-08 02:39:28 -08001441 free_page((unsigned long)temp);
1442 }
Alan Coxadc8d742012-07-14 15:31:47 +01001443 if (tty->termios.c_cflag & HUPCL)
Jiri Slaby4d768202009-09-19 13:13:15 -07001444 cyy_change_rts_dtr(info, 0, TIOCM_RTS | TIOCM_DTR);
1445
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07001446 cyy_issue_cmd(info, CyCHAN_CTL | CyDIS_RCVR);
Jiri Slaby02f11752006-12-08 02:39:28 -08001447 /* it may be appropriate to clear _XMIT at
1448 some later date (after testing)!!! */
1449
Jiri Slabyd13549f2009-09-19 13:13:12 -07001450 set_bit(TTY_IO_ERROR, &tty->flags);
Alan Cox77451e52008-07-16 21:57:02 +01001451 info->port.flags &= ~ASYNC_INITIALIZED;
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001452 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08001453 } else {
Jiri Slaby02f11752006-12-08 02:39:28 -08001454#ifdef CY_DEBUG_OPEN
Jiri Slaby0e7f4192011-03-23 09:49:56 +01001455 int channel = info->line - card->first_line;
Jiri Slaby21719192007-05-08 00:36:42 -07001456 printk(KERN_DEBUG "cyc shutdown Z card %d, channel %d, "
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001457 "base_addr %p\n", card, channel, card->base_addr);
Jiri Slaby02f11752006-12-08 02:39:28 -08001458#endif
1459
Jiri Slaby2693f482009-06-11 12:31:06 +01001460 if (!cyz_is_loaded(card))
Jiri Slaby02f11752006-12-08 02:39:28 -08001461 return;
Jiri Slaby02f11752006-12-08 02:39:28 -08001462
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001463 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08001464
Alan Cox77451e52008-07-16 21:57:02 +01001465 if (info->port.xmit_buf) {
Jiri Slaby02f11752006-12-08 02:39:28 -08001466 unsigned char *temp;
Alan Cox77451e52008-07-16 21:57:02 +01001467 temp = info->port.xmit_buf;
1468 info->port.xmit_buf = NULL;
Jiri Slaby02f11752006-12-08 02:39:28 -08001469 free_page((unsigned long)temp);
1470 }
1471
Alan Coxadc8d742012-07-14 15:31:47 +01001472 if (tty->termios.c_cflag & HUPCL)
Jiri Slaby4d768202009-09-19 13:13:15 -07001473 tty_port_lower_dtr_rts(&info->port);
Jiri Slaby02f11752006-12-08 02:39:28 -08001474
Jiri Slabyd13549f2009-09-19 13:13:12 -07001475 set_bit(TTY_IO_ERROR, &tty->flags);
Alan Cox77451e52008-07-16 21:57:02 +01001476 info->port.flags &= ~ASYNC_INITIALIZED;
Jiri Slaby02f11752006-12-08 02:39:28 -08001477
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001478 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08001479 }
1480
1481#ifdef CY_DEBUG_OPEN
Jiri Slaby21719192007-05-08 00:36:42 -07001482 printk(KERN_DEBUG "cyc shutdown done\n");
Jiri Slaby02f11752006-12-08 02:39:28 -08001483#endif
Jiri Slaby02f11752006-12-08 02:39:28 -08001484} /* shutdown */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485
1486/*
1487 * ------------------------------------------------------------
1488 * cy_open() and friends
1489 * ------------------------------------------------------------
1490 */
1491
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492/*
1493 * This routine is called whenever a serial port is opened. It
1494 * performs the serial-specific initialization for the tty structure.
1495 */
Jiri Slaby02f11752006-12-08 02:39:28 -08001496static int cy_open(struct tty_struct *tty, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497{
Jiri Slaby02f11752006-12-08 02:39:28 -08001498 struct cyclades_port *info;
Jiri Slaby410235f2012-03-05 14:52:01 +01001499 unsigned int i, line = tty->index;
Jiri Slaby65f76a82007-10-18 03:06:22 -07001500 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501
Jiri Slabydd025c02007-05-08 00:37:02 -07001502 for (i = 0; i < NR_CARDS; i++)
1503 if (line < cy_card[i].first_line + cy_card[i].nports &&
1504 line >= cy_card[i].first_line)
1505 break;
1506 if (i >= NR_CARDS)
1507 return -ENODEV;
1508 info = &cy_card[i].ports[line - cy_card[i].first_line];
Alan Cox15ed6cc2008-04-30 00:53:55 -07001509 if (info->line < 0)
Jiri Slaby02f11752006-12-08 02:39:28 -08001510 return -ENODEV;
Jiri Slaby02f11752006-12-08 02:39:28 -08001511
1512 /* If the card's firmware hasn't been loaded,
1513 treat it as absent from the system. This
1514 will make the user pay attention.
1515 */
Jiri Slaby2693f482009-06-11 12:31:06 +01001516 if (cy_is_Z(info->card)) {
Jiri Slaby875b2062007-05-08 00:36:49 -07001517 struct cyclades_card *cinfo = info->card;
Jiri Slaby02f11752006-12-08 02:39:28 -08001518 struct FIRM_ID __iomem *firm_id = cinfo->base_addr + ID_ADDRESS;
1519
Jiri Slaby2693f482009-06-11 12:31:06 +01001520 if (!cyz_is_loaded(cinfo)) {
1521 if (cinfo->hw_ver == ZE_V1 && cyz_fpga_loaded(cinfo) &&
Jiri Slaby101b8152009-06-11 12:30:10 +01001522 readl(&firm_id->signature) ==
1523 ZFIRM_HLT) {
Jiri Slaby21719192007-05-08 00:36:42 -07001524 printk(KERN_ERR "cyc:Cyclades-Z Error: you "
1525 "need an external power supply for "
1526 "this number of ports.\nFirmware "
1527 "halted.\n");
Jiri Slaby02f11752006-12-08 02:39:28 -08001528 } else {
Jiri Slaby21719192007-05-08 00:36:42 -07001529 printk(KERN_ERR "cyc:Cyclades-Z firmware not "
1530 "yet loaded\n");
Jiri Slaby02f11752006-12-08 02:39:28 -08001531 }
1532 return -ENODEV;
1533 }
1534#ifdef CONFIG_CYZ_INTR
1535 else {
1536 /* In case this Z board is operating in interrupt mode, its
1537 interrupts should be enabled as soon as the first open
1538 happens to one of its ports. */
1539 if (!cinfo->intr_enabled) {
Jiri Slaby97e87f82009-06-11 12:29:27 +01001540 u16 intr;
Jiri Slaby02f11752006-12-08 02:39:28 -08001541
Jiri Slaby02f11752006-12-08 02:39:28 -08001542 /* Enable interrupts on the PLX chip */
Jiri Slaby97e87f82009-06-11 12:29:27 +01001543 intr = readw(&cinfo->ctl_addr.p9060->
1544 intr_ctrl_stat) | 0x0900;
1545 cy_writew(&cinfo->ctl_addr.p9060->
1546 intr_ctrl_stat, intr);
Jiri Slaby02f11752006-12-08 02:39:28 -08001547 /* Enable interrupts on the FW */
1548 retval = cyz_issue_cmd(cinfo, 0,
1549 C_CM_IRQ_ENBL, 0L);
1550 if (retval != 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07001551 printk(KERN_ERR "cyc:IRQ enable retval "
1552 "was %x\n", retval);
Jiri Slaby02f11752006-12-08 02:39:28 -08001553 }
Jiri Slaby02f11752006-12-08 02:39:28 -08001554 cinfo->intr_enabled = 1;
1555 }
1556 }
1557#endif /* CONFIG_CYZ_INTR */
1558 /* Make sure this Z port really exists in hardware */
1559 if (info->line > (cinfo->first_line + cinfo->nports - 1))
1560 return -ENODEV;
1561 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562#ifdef CY_DEBUG_OTHER
Jiri Slaby21719192007-05-08 00:36:42 -07001563 printk(KERN_DEBUG "cyc:cy_open ttyC%d\n", info->line);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564#endif
Jiri Slaby02f11752006-12-08 02:39:28 -08001565 tty->driver_data = info;
Alan Cox15ed6cc2008-04-30 00:53:55 -07001566 if (serial_paranoia_check(info, tty->name, "cy_open"))
Jiri Slaby02f11752006-12-08 02:39:28 -08001567 return -ENODEV;
Alan Cox15ed6cc2008-04-30 00:53:55 -07001568
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569#ifdef CY_DEBUG_OPEN
Jiri Slaby21719192007-05-08 00:36:42 -07001570 printk(KERN_DEBUG "cyc:cy_open ttyC%d, count = %d\n", info->line,
Alan Cox77451e52008-07-16 21:57:02 +01001571 info->port.count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001572#endif
Alan Cox77451e52008-07-16 21:57:02 +01001573 info->port.count++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574#ifdef CY_DEBUG_COUNT
Jiri Slaby21719192007-05-08 00:36:42 -07001575 printk(KERN_DEBUG "cyc:cy_open (%d): incrementing count to %d\n",
Alan Cox77451e52008-07-16 21:57:02 +01001576 current->pid, info->port.count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578
Jiri Slaby02f11752006-12-08 02:39:28 -08001579 /*
1580 * If the port is the middle of closing, bail out now
1581 */
Peter Hurleye359a4e2014-06-16 09:17:06 -04001582 if (info->port.flags & ASYNC_CLOSING) {
Alan Cox89c8d912012-08-08 16:30:13 +01001583 wait_event_interruptible_tty(tty, info->port.close_wait,
Alan Cox77451e52008-07-16 21:57:02 +01001584 !(info->port.flags & ASYNC_CLOSING));
1585 return (info->port.flags & ASYNC_HUP_NOTIFY) ? -EAGAIN: -ERESTARTSYS;
Jiri Slaby02f11752006-12-08 02:39:28 -08001586 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587
Jiri Slaby02f11752006-12-08 02:39:28 -08001588 /*
1589 * Start up serial port
1590 */
Jiri Slabyd13549f2009-09-19 13:13:12 -07001591 retval = cy_startup(info, tty);
Alan Cox15ed6cc2008-04-30 00:53:55 -07001592 if (retval)
Jiri Slaby02f11752006-12-08 02:39:28 -08001593 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594
Jiri Slabyf0737572009-09-19 13:13:12 -07001595 retval = tty_port_block_til_ready(&info->port, tty, filp);
Jiri Slaby02f11752006-12-08 02:39:28 -08001596 if (retval) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001597#ifdef CY_DEBUG_OPEN
Jiri Slaby21719192007-05-08 00:36:42 -07001598 printk(KERN_DEBUG "cyc:cy_open returning after block_til_ready "
1599 "with %d\n", retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001600#endif
Jiri Slaby02f11752006-12-08 02:39:28 -08001601 return retval;
1602 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603
Jiri Slaby02f11752006-12-08 02:39:28 -08001604 info->throttle = 0;
Jiri Slabyd13549f2009-09-19 13:13:12 -07001605 tty_port_tty_set(&info->port, tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606
1607#ifdef CY_DEBUG_OPEN
Jiri Slaby21719192007-05-08 00:36:42 -07001608 printk(KERN_DEBUG "cyc:cy_open done\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609#endif
Jiri Slaby02f11752006-12-08 02:39:28 -08001610 return 0;
1611} /* cy_open */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001612
1613/*
1614 * cy_wait_until_sent() --- wait until the transmitter is empty
1615 */
Jiri Slaby02f11752006-12-08 02:39:28 -08001616static void cy_wait_until_sent(struct tty_struct *tty, int timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617{
Jiri Slaby875b2062007-05-08 00:36:49 -07001618 struct cyclades_card *card;
Jiri Slabycab9bdd2007-05-08 00:35:51 -07001619 struct cyclades_port *info = tty->driver_data;
Jiri Slaby02f11752006-12-08 02:39:28 -08001620 unsigned long orig_jiffies;
1621 int char_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622
Jiri Slaby02f11752006-12-08 02:39:28 -08001623 if (serial_paranoia_check(info, tty->name, "cy_wait_until_sent"))
1624 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625
Jiri Slaby02f11752006-12-08 02:39:28 -08001626 if (info->xmit_fifo_size == 0)
1627 return; /* Just in case.... */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001628
Jiri Slaby02f11752006-12-08 02:39:28 -08001629 orig_jiffies = jiffies;
1630 /*
1631 * Set the check interval to be 1/5 of the estimated time to
1632 * send a single character, and make it at least 1. The check
1633 * interval should also be less than the timeout.
1634 *
1635 * Note: we have to use pretty tight timings here to satisfy
1636 * the NIST-PCTS.
1637 */
1638 char_time = (info->timeout - HZ / 50) / info->xmit_fifo_size;
1639 char_time = char_time / 5;
1640 if (char_time <= 0)
1641 char_time = 1;
1642 if (timeout < 0)
1643 timeout = 0;
1644 if (timeout)
1645 char_time = min(char_time, timeout);
1646 /*
1647 * If the transmitter hasn't cleared in twice the approximate
1648 * amount of time to send the entire FIFO, it probably won't
1649 * ever clear. This assumes the UART isn't doing flow
1650 * control, which is currently the case. Hence, if it ever
1651 * takes longer than info->timeout, this is probably due to a
1652 * UART bug of some kind. So, we clamp the timeout parameter at
1653 * 2*info->timeout.
1654 */
1655 if (!timeout || timeout > 2 * info->timeout)
1656 timeout = 2 * info->timeout;
Jiri Slaby8bab5342011-07-14 14:35:15 +02001657
Jiri Slaby02f11752006-12-08 02:39:28 -08001658 card = info->card;
Jiri Slaby2693f482009-06-11 12:31:06 +01001659 if (!cy_is_Z(card)) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07001660 while (cyy_readb(info, CySRER) & CyTxRdy) {
Jiri Slaby02f11752006-12-08 02:39:28 -08001661 if (msleep_interruptible(jiffies_to_msecs(char_time)))
1662 break;
1663 if (timeout && time_after(jiffies, orig_jiffies +
1664 timeout))
1665 break;
1666 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667 }
Jiri Slaby02f11752006-12-08 02:39:28 -08001668 /* Run one more char cycle */
1669 msleep_interruptible(jiffies_to_msecs(char_time * 5));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670}
1671
Alan Cox978e5952008-04-30 00:53:59 -07001672static void cy_flush_buffer(struct tty_struct *tty)
1673{
1674 struct cyclades_port *info = tty->driver_data;
1675 struct cyclades_card *card;
1676 int channel, retval;
1677 unsigned long flags;
1678
1679#ifdef CY_DEBUG_IO
1680 printk(KERN_DEBUG "cyc:cy_flush_buffer ttyC%d\n", info->line);
1681#endif
1682
1683 if (serial_paranoia_check(info, tty->name, "cy_flush_buffer"))
1684 return;
1685
1686 card = info->card;
1687 channel = info->line - card->first_line;
1688
1689 spin_lock_irqsave(&card->card_lock, flags);
1690 info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1691 spin_unlock_irqrestore(&card->card_lock, flags);
1692
Jiri Slaby2693f482009-06-11 12:31:06 +01001693 if (cy_is_Z(card)) { /* If it is a Z card, flush the on-board
Alan Cox978e5952008-04-30 00:53:59 -07001694 buffers as well */
1695 spin_lock_irqsave(&card->card_lock, flags);
1696 retval = cyz_issue_cmd(card, channel, C_CM_FLUSH_TX, 0L);
1697 if (retval != 0) {
1698 printk(KERN_ERR "cyc: flush_buffer retval on ttyC%d "
1699 "was %x\n", info->line, retval);
1700 }
1701 spin_unlock_irqrestore(&card->card_lock, flags);
1702 }
1703 tty_wakeup(tty);
1704} /* cy_flush_buffer */
1705
1706
Alan Coxe936ffd2009-09-19 13:13:22 -07001707static void cy_do_close(struct tty_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001708{
Alan Coxe936ffd2009-09-19 13:13:22 -07001709 struct cyclades_port *info = container_of(port, struct cyclades_port,
1710 port);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001711 struct cyclades_card *card;
Jiri Slaby02f11752006-12-08 02:39:28 -08001712 unsigned long flags;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07001713 int channel;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001715 card = info->card;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07001716 channel = info->line - card->first_line;
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001717 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08001718
Jiri Slaby2693f482009-06-11 12:31:06 +01001719 if (!cy_is_Z(card)) {
Jiri Slaby02f11752006-12-08 02:39:28 -08001720 /* Stop accepting input */
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07001721 cyy_writeb(info, CyCAR, channel & 0x03);
1722 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyRxData);
Alan Cox77451e52008-07-16 21:57:02 +01001723 if (info->port.flags & ASYNC_INITIALIZED) {
Alan Cox15ed6cc2008-04-30 00:53:55 -07001724 /* Waiting for on-board buffers to be empty before
1725 closing the port */
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001726 spin_unlock_irqrestore(&card->card_lock, flags);
Alan Coxe936ffd2009-09-19 13:13:22 -07001727 cy_wait_until_sent(port->tty, info->timeout);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001728 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08001729 }
1730 } else {
1731#ifdef Z_WAKE
Alan Cox15ed6cc2008-04-30 00:53:55 -07001732 /* Waiting for on-board buffers to be empty before closing
1733 the port */
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001734 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
Jiri Slaby02f11752006-12-08 02:39:28 -08001735 int retval;
1736
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001737 if (readl(&ch_ctrl->flow_status) != C_FS_TXIDLE) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001738 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLW, 0L);
Jiri Slaby02f11752006-12-08 02:39:28 -08001739 if (retval != 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07001740 printk(KERN_DEBUG "cyc:cy_close retval on "
1741 "ttyC%d was %x\n", info->line, retval);
Jiri Slaby02f11752006-12-08 02:39:28 -08001742 }
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001743 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby2c7fea92007-05-08 00:36:51 -07001744 wait_for_completion_interruptible(&info->shutdown_wait);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001745 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08001746 }
1747#endif
1748 }
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001749 spin_unlock_irqrestore(&card->card_lock, flags);
Alan Coxe936ffd2009-09-19 13:13:22 -07001750 cy_shutdown(info, port->tty);
1751}
Jiri Slaby02f11752006-12-08 02:39:28 -08001752
Alan Coxe936ffd2009-09-19 13:13:22 -07001753/*
1754 * This routine is called when a particular tty device is closed.
1755 */
1756static void cy_close(struct tty_struct *tty, struct file *filp)
1757{
1758 struct cyclades_port *info = tty->driver_data;
1759 if (!info || serial_paranoia_check(info, tty->name, "cy_close"))
1760 return;
1761 tty_port_close(&info->port, tty, filp);
Jiri Slaby02f11752006-12-08 02:39:28 -08001762} /* cy_close */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001763
1764/* This routine gets called when tty_write has put something into
1765 * the write_queue. The characters may come from user space or
1766 * kernel space.
1767 *
1768 * This routine will return the number of characters actually
1769 * accepted for writing.
1770 *
1771 * If the port is not already transmitting stuff, start it off by
1772 * enabling interrupts. The interrupt service routine will then
1773 * ensure that the characters are sent.
1774 * If the port is already active, there is no need to kick it.
1775 *
1776 */
Jiri Slaby02f11752006-12-08 02:39:28 -08001777static int cy_write(struct tty_struct *tty, const unsigned char *buf, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07001779 struct cyclades_port *info = tty->driver_data;
Jiri Slaby02f11752006-12-08 02:39:28 -08001780 unsigned long flags;
1781 int c, ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001782
1783#ifdef CY_DEBUG_IO
Jiri Slaby21719192007-05-08 00:36:42 -07001784 printk(KERN_DEBUG "cyc:cy_write ttyC%d\n", info->line);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785#endif
1786
Alan Cox15ed6cc2008-04-30 00:53:55 -07001787 if (serial_paranoia_check(info, tty->name, "cy_write"))
Jiri Slaby02f11752006-12-08 02:39:28 -08001788 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789
Alan Cox77451e52008-07-16 21:57:02 +01001790 if (!info->port.xmit_buf)
Jiri Slaby02f11752006-12-08 02:39:28 -08001791 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001793 spin_lock_irqsave(&info->card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08001794 while (1) {
Harvey Harrison1a4e2352008-04-30 00:53:52 -07001795 c = min(count, (int)(SERIAL_XMIT_SIZE - info->xmit_cnt - 1));
1796 c = min(c, (int)(SERIAL_XMIT_SIZE - info->xmit_head));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797
Jiri Slaby02f11752006-12-08 02:39:28 -08001798 if (c <= 0)
1799 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001800
Alan Cox77451e52008-07-16 21:57:02 +01001801 memcpy(info->port.xmit_buf + info->xmit_head, buf, c);
Jiri Slaby02f11752006-12-08 02:39:28 -08001802 info->xmit_head = (info->xmit_head + c) &
1803 (SERIAL_XMIT_SIZE - 1);
1804 info->xmit_cnt += c;
1805 buf += c;
1806 count -= c;
1807 ret += c;
1808 }
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001809 spin_unlock_irqrestore(&info->card->card_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810
Jiri Slaby02f11752006-12-08 02:39:28 -08001811 info->idle_stats.xmit_bytes += ret;
1812 info->idle_stats.xmit_idle = jiffies;
1813
Alan Cox15ed6cc2008-04-30 00:53:55 -07001814 if (info->xmit_cnt && !tty->stopped && !tty->hw_stopped)
Jiri Slaby02f11752006-12-08 02:39:28 -08001815 start_xmit(info);
Alan Cox15ed6cc2008-04-30 00:53:55 -07001816
Jiri Slaby02f11752006-12-08 02:39:28 -08001817 return ret;
1818} /* cy_write */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001819
1820/*
1821 * This routine is called by the kernel to write a single
1822 * character to the tty device. If the kernel uses this routine,
1823 * it must call the flush_chars() routine (if defined) when it is
1824 * done stuffing characters into the driver. If there is no room
1825 * in the queue, the character is ignored.
1826 */
Alan Cox76b25a52008-04-30 00:54:03 -07001827static int cy_put_char(struct tty_struct *tty, unsigned char ch)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07001829 struct cyclades_port *info = tty->driver_data;
Jiri Slaby02f11752006-12-08 02:39:28 -08001830 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001831
1832#ifdef CY_DEBUG_IO
Jiri Slaby21719192007-05-08 00:36:42 -07001833 printk(KERN_DEBUG "cyc:cy_put_char ttyC%d\n", info->line);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834#endif
1835
Jiri Slaby02f11752006-12-08 02:39:28 -08001836 if (serial_paranoia_check(info, tty->name, "cy_put_char"))
Alan Cox76b25a52008-04-30 00:54:03 -07001837 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838
Alan Cox77451e52008-07-16 21:57:02 +01001839 if (!info->port.xmit_buf)
Alan Cox76b25a52008-04-30 00:54:03 -07001840 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001841
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001842 spin_lock_irqsave(&info->card->card_lock, flags);
Jiri Slaby90cc3012006-12-08 02:39:31 -08001843 if (info->xmit_cnt >= (int)(SERIAL_XMIT_SIZE - 1)) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001844 spin_unlock_irqrestore(&info->card->card_lock, flags);
Alan Cox76b25a52008-04-30 00:54:03 -07001845 return 0;
Jiri Slaby02f11752006-12-08 02:39:28 -08001846 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847
Alan Cox77451e52008-07-16 21:57:02 +01001848 info->port.xmit_buf[info->xmit_head++] = ch;
Jiri Slaby02f11752006-12-08 02:39:28 -08001849 info->xmit_head &= SERIAL_XMIT_SIZE - 1;
1850 info->xmit_cnt++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001851 info->idle_stats.xmit_bytes++;
1852 info->idle_stats.xmit_idle = jiffies;
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001853 spin_unlock_irqrestore(&info->card->card_lock, flags);
Alan Cox76b25a52008-04-30 00:54:03 -07001854 return 1;
Jiri Slaby02f11752006-12-08 02:39:28 -08001855} /* cy_put_char */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856
1857/*
1858 * This routine is called by the kernel after it has written a
Alan Cox15ed6cc2008-04-30 00:53:55 -07001859 * series of characters to the tty device using put_char().
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860 */
Jiri Slaby02f11752006-12-08 02:39:28 -08001861static void cy_flush_chars(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07001863 struct cyclades_port *info = tty->driver_data;
Jiri Slaby02f11752006-12-08 02:39:28 -08001864
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865#ifdef CY_DEBUG_IO
Jiri Slaby21719192007-05-08 00:36:42 -07001866 printk(KERN_DEBUG "cyc:cy_flush_chars ttyC%d\n", info->line);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001867#endif
1868
Jiri Slaby02f11752006-12-08 02:39:28 -08001869 if (serial_paranoia_check(info, tty->name, "cy_flush_chars"))
1870 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001871
Jiri Slaby02f11752006-12-08 02:39:28 -08001872 if (info->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
Alan Cox77451e52008-07-16 21:57:02 +01001873 !info->port.xmit_buf)
Jiri Slaby02f11752006-12-08 02:39:28 -08001874 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875
Jiri Slaby02f11752006-12-08 02:39:28 -08001876 start_xmit(info);
1877} /* cy_flush_chars */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001878
1879/*
1880 * This routine returns the numbers of characters the tty driver
1881 * will accept for queuing to be written. This number is subject
1882 * to change as output buffers get emptied, or if the output flow
1883 * control is activated.
1884 */
Jiri Slaby02f11752006-12-08 02:39:28 -08001885static int cy_write_room(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001886{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07001887 struct cyclades_port *info = tty->driver_data;
Jiri Slaby02f11752006-12-08 02:39:28 -08001888 int ret;
1889
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890#ifdef CY_DEBUG_IO
Jiri Slaby21719192007-05-08 00:36:42 -07001891 printk(KERN_DEBUG "cyc:cy_write_room ttyC%d\n", info->line);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892#endif
1893
Jiri Slaby02f11752006-12-08 02:39:28 -08001894 if (serial_paranoia_check(info, tty->name, "cy_write_room"))
1895 return 0;
1896 ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1;
1897 if (ret < 0)
1898 ret = 0;
1899 return ret;
1900} /* cy_write_room */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001901
Jiri Slaby02f11752006-12-08 02:39:28 -08001902static int cy_chars_in_buffer(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07001904 struct cyclades_port *info = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001905
Jiri Slaby02f11752006-12-08 02:39:28 -08001906 if (serial_paranoia_check(info, tty->name, "cy_chars_in_buffer"))
1907 return 0;
1908
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909#ifdef Z_EXT_CHARS_IN_BUFFER
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001910 if (!cy_is_Z(info->card)) {
Jiri Slaby02f11752006-12-08 02:39:28 -08001911#endif /* Z_EXT_CHARS_IN_BUFFER */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912#ifdef CY_DEBUG_IO
Jiri Slaby21719192007-05-08 00:36:42 -07001913 printk(KERN_DEBUG "cyc:cy_chars_in_buffer ttyC%d %d\n",
1914 info->line, info->xmit_cnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915#endif
Jiri Slaby02f11752006-12-08 02:39:28 -08001916 return info->xmit_cnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917#ifdef Z_EXT_CHARS_IN_BUFFER
Jiri Slaby02f11752006-12-08 02:39:28 -08001918 } else {
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001919 struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
Jiri Slaby02f11752006-12-08 02:39:28 -08001920 int char_count;
Jiri Slabyad39c302007-05-08 00:35:49 -07001921 __u32 tx_put, tx_get, tx_bufsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922
Jiri Slabydb05c3b2007-05-08 00:35:46 -07001923 tx_get = readl(&buf_ctrl->tx_get);
1924 tx_put = readl(&buf_ctrl->tx_put);
1925 tx_bufsize = readl(&buf_ctrl->tx_bufsize);
Jiri Slaby02f11752006-12-08 02:39:28 -08001926 if (tx_put >= tx_get)
1927 char_count = tx_put - tx_get;
1928 else
1929 char_count = tx_put - tx_get + tx_bufsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930#ifdef CY_DEBUG_IO
Jiri Slaby21719192007-05-08 00:36:42 -07001931 printk(KERN_DEBUG "cyc:cy_chars_in_buffer ttyC%d %d\n",
1932 info->line, info->xmit_cnt + char_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001933#endif
Jiri Slaby096dcfc2006-12-08 02:39:30 -08001934 return info->xmit_cnt + char_count;
Jiri Slaby02f11752006-12-08 02:39:28 -08001935 }
1936#endif /* Z_EXT_CHARS_IN_BUFFER */
1937} /* cy_chars_in_buffer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001938
1939/*
1940 * ------------------------------------------------------------
1941 * cy_ioctl() and friends
1942 * ------------------------------------------------------------
1943 */
1944
Klaus Kudielka1a86b5e2007-05-08 00:26:26 -07001945static void cyy_baud_calc(struct cyclades_port *info, __u32 baud)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946{
Jiri Slaby02f11752006-12-08 02:39:28 -08001947 int co, co_val, bpr;
Klaus Kudielka1a86b5e2007-05-08 00:26:26 -07001948 __u32 cy_clock = ((info->chip_rev >= CD1400_REV_J) ? 60000000 :
Jiri Slaby02f11752006-12-08 02:39:28 -08001949 25000000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001950
Jiri Slaby02f11752006-12-08 02:39:28 -08001951 if (baud == 0) {
1952 info->tbpr = info->tco = info->rbpr = info->rco = 0;
1953 return;
1954 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001955
Jiri Slaby02f11752006-12-08 02:39:28 -08001956 /* determine which prescaler to use */
1957 for (co = 4, co_val = 2048; co; co--, co_val >>= 2) {
1958 if (cy_clock / co_val / baud > 63)
1959 break;
1960 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961
Jiri Slaby02f11752006-12-08 02:39:28 -08001962 bpr = (cy_clock / co_val * 2 / baud + 1) / 2;
1963 if (bpr > 255)
1964 bpr = 255;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001965
Jiri Slaby02f11752006-12-08 02:39:28 -08001966 info->tbpr = info->rbpr = bpr;
1967 info->tco = info->rco = co;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968}
1969
1970/*
1971 * This routine finds or computes the various line characteristics.
1972 * It used to be called config_setup
1973 */
Jiri Slabyd13549f2009-09-19 13:13:12 -07001974static void cy_set_line_char(struct cyclades_port *info, struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975{
Jiri Slaby875b2062007-05-08 00:36:49 -07001976 struct cyclades_card *card;
Jiri Slaby02f11752006-12-08 02:39:28 -08001977 unsigned long flags;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07001978 int channel;
Jiri Slaby02f11752006-12-08 02:39:28 -08001979 unsigned cflag, iflag;
Jiri Slaby02f11752006-12-08 02:39:28 -08001980 int baud, baud_rate = 0;
1981 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001982
Alan Cox15ed6cc2008-04-30 00:53:55 -07001983 if (info->line == -1)
Jiri Slaby02f11752006-12-08 02:39:28 -08001984 return;
Alan Cox15ed6cc2008-04-30 00:53:55 -07001985
Alan Coxadc8d742012-07-14 15:31:47 +01001986 cflag = tty->termios.c_cflag;
1987 iflag = tty->termios.c_iflag;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001988
Jiri Slaby02f11752006-12-08 02:39:28 -08001989 /*
1990 * Set up the tty->alt_speed kludge
1991 */
Jiri Slabyd13549f2009-09-19 13:13:12 -07001992 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
1993 tty->alt_speed = 57600;
1994 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
1995 tty->alt_speed = 115200;
1996 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
1997 tty->alt_speed = 230400;
1998 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
1999 tty->alt_speed = 460800;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000
Jiri Slaby02f11752006-12-08 02:39:28 -08002001 card = info->card;
Jiri Slaby875b2062007-05-08 00:36:49 -07002002 channel = info->line - card->first_line;
Jiri Slaby02f11752006-12-08 02:39:28 -08002003
Jiri Slaby2693f482009-06-11 12:31:06 +01002004 if (!cy_is_Z(card)) {
Jiri Slaby46fb7822009-09-19 13:13:17 -07002005 u32 cflags;
2006
Jiri Slaby02f11752006-12-08 02:39:28 -08002007 /* baud rate */
Jiri Slabyd13549f2009-09-19 13:13:12 -07002008 baud = tty_get_baud_rate(tty);
Alan Cox77451e52008-07-16 21:57:02 +01002009 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
Jiri Slaby02f11752006-12-08 02:39:28 -08002010 ASYNC_SPD_CUST) {
2011 if (info->custom_divisor)
2012 baud_rate = info->baud / info->custom_divisor;
2013 else
2014 baud_rate = info->baud;
2015 } else if (baud > CD1400_MAX_SPEED) {
2016 baud = CD1400_MAX_SPEED;
2017 }
2018 /* find the baud index */
2019 for (i = 0; i < 20; i++) {
Alan Cox15ed6cc2008-04-30 00:53:55 -07002020 if (baud == baud_table[i])
Jiri Slaby02f11752006-12-08 02:39:28 -08002021 break;
Jiri Slaby02f11752006-12-08 02:39:28 -08002022 }
Alan Cox15ed6cc2008-04-30 00:53:55 -07002023 if (i == 20)
Jiri Slaby02f11752006-12-08 02:39:28 -08002024 i = 19; /* CD1400_MAX_SPEED */
Jiri Slaby02f11752006-12-08 02:39:28 -08002025
Alan Cox77451e52008-07-16 21:57:02 +01002026 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
Jiri Slaby02f11752006-12-08 02:39:28 -08002027 ASYNC_SPD_CUST) {
2028 cyy_baud_calc(info, baud_rate);
2029 } else {
2030 if (info->chip_rev >= CD1400_REV_J) {
2031 /* It is a CD1400 rev. J or later */
2032 info->tbpr = baud_bpr_60[i]; /* Tx BPR */
2033 info->tco = baud_co_60[i]; /* Tx CO */
2034 info->rbpr = baud_bpr_60[i]; /* Rx BPR */
2035 info->rco = baud_co_60[i]; /* Rx CO */
2036 } else {
2037 info->tbpr = baud_bpr_25[i]; /* Tx BPR */
2038 info->tco = baud_co_25[i]; /* Tx CO */
2039 info->rbpr = baud_bpr_25[i]; /* Rx BPR */
2040 info->rco = baud_co_25[i]; /* Rx CO */
2041 }
2042 }
2043 if (baud_table[i] == 134) {
2044 /* get it right for 134.5 baud */
2045 info->timeout = (info->xmit_fifo_size * HZ * 30 / 269) +
2046 2;
Alan Cox77451e52008-07-16 21:57:02 +01002047 } else if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
Jiri Slaby02f11752006-12-08 02:39:28 -08002048 ASYNC_SPD_CUST) {
2049 info->timeout = (info->xmit_fifo_size * HZ * 15 /
2050 baud_rate) + 2;
2051 } else if (baud_table[i]) {
2052 info->timeout = (info->xmit_fifo_size * HZ * 15 /
2053 baud_table[i]) + 2;
2054 /* this needs to be propagated into the card info */
2055 } else {
2056 info->timeout = 0;
2057 }
2058 /* By tradition (is it a standard?) a baud rate of zero
2059 implies the line should be/has been closed. A bit
2060 later in this routine such a test is performed. */
2061
2062 /* byte size and parity */
2063 info->cor5 = 0;
2064 info->cor4 = 0;
2065 /* receive threshold */
2066 info->cor3 = (info->default_threshold ?
2067 info->default_threshold : baud_cor3[i]);
2068 info->cor2 = CyETC;
2069 switch (cflag & CSIZE) {
2070 case CS5:
2071 info->cor1 = Cy_5_BITS;
2072 break;
2073 case CS6:
2074 info->cor1 = Cy_6_BITS;
2075 break;
2076 case CS7:
2077 info->cor1 = Cy_7_BITS;
2078 break;
2079 case CS8:
2080 info->cor1 = Cy_8_BITS;
2081 break;
2082 }
Alan Cox15ed6cc2008-04-30 00:53:55 -07002083 if (cflag & CSTOPB)
Jiri Slaby02f11752006-12-08 02:39:28 -08002084 info->cor1 |= Cy_2_STOP;
Alan Cox15ed6cc2008-04-30 00:53:55 -07002085
Jiri Slaby02f11752006-12-08 02:39:28 -08002086 if (cflag & PARENB) {
Alan Cox15ed6cc2008-04-30 00:53:55 -07002087 if (cflag & PARODD)
Jiri Slaby02f11752006-12-08 02:39:28 -08002088 info->cor1 |= CyPARITY_O;
Alan Cox15ed6cc2008-04-30 00:53:55 -07002089 else
Jiri Slaby02f11752006-12-08 02:39:28 -08002090 info->cor1 |= CyPARITY_E;
Alan Cox15ed6cc2008-04-30 00:53:55 -07002091 } else
Jiri Slaby02f11752006-12-08 02:39:28 -08002092 info->cor1 |= CyPARITY_NONE;
Jiri Slaby02f11752006-12-08 02:39:28 -08002093
2094 /* CTS flow control flag */
2095 if (cflag & CRTSCTS) {
Alan Cox77451e52008-07-16 21:57:02 +01002096 info->port.flags |= ASYNC_CTS_FLOW;
Jiri Slaby02f11752006-12-08 02:39:28 -08002097 info->cor2 |= CyCtsAE;
2098 } else {
Alan Cox77451e52008-07-16 21:57:02 +01002099 info->port.flags &= ~ASYNC_CTS_FLOW;
Jiri Slaby02f11752006-12-08 02:39:28 -08002100 info->cor2 &= ~CyCtsAE;
2101 }
2102 if (cflag & CLOCAL)
Alan Cox77451e52008-07-16 21:57:02 +01002103 info->port.flags &= ~ASYNC_CHECK_CD;
Jiri Slaby02f11752006-12-08 02:39:28 -08002104 else
Alan Cox77451e52008-07-16 21:57:02 +01002105 info->port.flags |= ASYNC_CHECK_CD;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002106
2107 /***********************************************
2108 The hardware option, CyRtsAO, presents RTS when
2109 the chip has characters to send. Since most modems
2110 use RTS as reverse (inbound) flow control, this
2111 option is not used. If inbound flow control is
2112 necessary, DTR can be programmed to provide the
2113 appropriate signals for use with a non-standard
2114 cable. Contact Marcio Saito for details.
2115 ***********************************************/
2116
Jiri Slaby02f11752006-12-08 02:39:28 -08002117 channel &= 0x03;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002118
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002119 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002120 cyy_writeb(info, CyCAR, channel);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121
Jiri Slaby02f11752006-12-08 02:39:28 -08002122 /* tx and rx baud rate */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002123
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002124 cyy_writeb(info, CyTCOR, info->tco);
2125 cyy_writeb(info, CyTBPR, info->tbpr);
2126 cyy_writeb(info, CyRCOR, info->rco);
2127 cyy_writeb(info, CyRBPR, info->rbpr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002128
Jiri Slaby02f11752006-12-08 02:39:28 -08002129 /* set line characteristics according configuration */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002130
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002131 cyy_writeb(info, CySCHR1, START_CHAR(tty));
2132 cyy_writeb(info, CySCHR2, STOP_CHAR(tty));
2133 cyy_writeb(info, CyCOR1, info->cor1);
2134 cyy_writeb(info, CyCOR2, info->cor2);
2135 cyy_writeb(info, CyCOR3, info->cor3);
2136 cyy_writeb(info, CyCOR4, info->cor4);
2137 cyy_writeb(info, CyCOR5, info->cor5);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002138
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002139 cyy_issue_cmd(info, CyCOR_CHANGE | CyCOR1ch | CyCOR2ch |
2140 CyCOR3ch);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002141
Alan Cox15ed6cc2008-04-30 00:53:55 -07002142 /* !!! Is this needed? */
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002143 cyy_writeb(info, CyCAR, channel);
2144 cyy_writeb(info, CyRTPR,
Jiri Slaby02f11752006-12-08 02:39:28 -08002145 (info->default_timeout ? info->default_timeout : 0x02));
2146 /* 10ms rx timeout */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002147
Jiri Slaby46fb7822009-09-19 13:13:17 -07002148 cflags = CyCTS;
2149 if (!C_CLOCAL(tty))
2150 cflags |= CyDSR | CyRI | CyDCD;
2151 /* without modem intr */
2152 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyMdmCh);
2153 /* act on 1->0 modem transitions */
2154 if ((cflag & CRTSCTS) && info->rflow)
2155 cyy_writeb(info, CyMCOR1, cflags | rflow_thr[i]);
2156 else
2157 cyy_writeb(info, CyMCOR1, cflags);
2158 /* act on 0->1 modem transitions */
2159 cyy_writeb(info, CyMCOR2, cflags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002160
Jiri Slaby4d768202009-09-19 13:13:15 -07002161 if (i == 0) /* baud rate is zero, turn off line */
2162 cyy_change_rts_dtr(info, 0, TIOCM_DTR);
2163 else
2164 cyy_change_rts_dtr(info, TIOCM_DTR, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002165
Jiri Slabyd13549f2009-09-19 13:13:12 -07002166 clear_bit(TTY_IO_ERROR, &tty->flags);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002167 spin_unlock_irqrestore(&card->card_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002168
Linus Torvalds1da177e2005-04-16 15:20:36 -07002169 } else {
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07002170 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
Klaus Kudielka1a86b5e2007-05-08 00:26:26 -07002171 __u32 sw_flow;
Jiri Slaby02f11752006-12-08 02:39:28 -08002172 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002173
Jiri Slaby2693f482009-06-11 12:31:06 +01002174 if (!cyz_is_loaded(card))
Jiri Slaby02f11752006-12-08 02:39:28 -08002175 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002176
Jiri Slaby02f11752006-12-08 02:39:28 -08002177 /* baud rate */
Jiri Slabyd13549f2009-09-19 13:13:12 -07002178 baud = tty_get_baud_rate(tty);
Alan Cox77451e52008-07-16 21:57:02 +01002179 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
Jiri Slaby02f11752006-12-08 02:39:28 -08002180 ASYNC_SPD_CUST) {
2181 if (info->custom_divisor)
2182 baud_rate = info->baud / info->custom_divisor;
2183 else
2184 baud_rate = info->baud;
2185 } else if (baud > CYZ_MAX_SPEED) {
2186 baud = CYZ_MAX_SPEED;
2187 }
2188 cy_writel(&ch_ctrl->comm_baud, baud);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002189
Jiri Slaby02f11752006-12-08 02:39:28 -08002190 if (baud == 134) {
2191 /* get it right for 134.5 baud */
2192 info->timeout = (info->xmit_fifo_size * HZ * 30 / 269) +
2193 2;
Alan Cox77451e52008-07-16 21:57:02 +01002194 } else if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
Jiri Slaby02f11752006-12-08 02:39:28 -08002195 ASYNC_SPD_CUST) {
2196 info->timeout = (info->xmit_fifo_size * HZ * 15 /
2197 baud_rate) + 2;
2198 } else if (baud) {
2199 info->timeout = (info->xmit_fifo_size * HZ * 15 /
2200 baud) + 2;
2201 /* this needs to be propagated into the card info */
2202 } else {
2203 info->timeout = 0;
2204 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002205
Jiri Slaby02f11752006-12-08 02:39:28 -08002206 /* byte size and parity */
2207 switch (cflag & CSIZE) {
2208 case CS5:
2209 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS5);
2210 break;
2211 case CS6:
2212 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS6);
2213 break;
2214 case CS7:
2215 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS7);
2216 break;
2217 case CS8:
2218 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS8);
2219 break;
2220 }
2221 if (cflag & CSTOPB) {
2222 cy_writel(&ch_ctrl->comm_data_l,
Jiri Slabydb05c3b2007-05-08 00:35:46 -07002223 readl(&ch_ctrl->comm_data_l) | C_DL_2STOP);
Jiri Slaby02f11752006-12-08 02:39:28 -08002224 } else {
2225 cy_writel(&ch_ctrl->comm_data_l,
Jiri Slabydb05c3b2007-05-08 00:35:46 -07002226 readl(&ch_ctrl->comm_data_l) | C_DL_1STOP);
Jiri Slaby02f11752006-12-08 02:39:28 -08002227 }
2228 if (cflag & PARENB) {
Alan Cox15ed6cc2008-04-30 00:53:55 -07002229 if (cflag & PARODD)
Jiri Slaby02f11752006-12-08 02:39:28 -08002230 cy_writel(&ch_ctrl->comm_parity, C_PR_ODD);
Alan Cox15ed6cc2008-04-30 00:53:55 -07002231 else
Jiri Slaby02f11752006-12-08 02:39:28 -08002232 cy_writel(&ch_ctrl->comm_parity, C_PR_EVEN);
Alan Cox15ed6cc2008-04-30 00:53:55 -07002233 } else
Jiri Slaby02f11752006-12-08 02:39:28 -08002234 cy_writel(&ch_ctrl->comm_parity, C_PR_NONE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002235
Jiri Slaby02f11752006-12-08 02:39:28 -08002236 /* CTS flow control flag */
2237 if (cflag & CRTSCTS) {
2238 cy_writel(&ch_ctrl->hw_flow,
Jiri Slabydb05c3b2007-05-08 00:35:46 -07002239 readl(&ch_ctrl->hw_flow) | C_RS_CTS | C_RS_RTS);
Jiri Slaby02f11752006-12-08 02:39:28 -08002240 } else {
Jiri Slabydb05c3b2007-05-08 00:35:46 -07002241 cy_writel(&ch_ctrl->hw_flow, readl(&ch_ctrl->hw_flow) &
2242 ~(C_RS_CTS | C_RS_RTS));
Jiri Slaby02f11752006-12-08 02:39:28 -08002243 }
2244 /* As the HW flow control is done in firmware, the driver
2245 doesn't need to care about it */
Alan Cox77451e52008-07-16 21:57:02 +01002246 info->port.flags &= ~ASYNC_CTS_FLOW;
Jiri Slaby02f11752006-12-08 02:39:28 -08002247
2248 /* XON/XOFF/XANY flow control flags */
2249 sw_flow = 0;
2250 if (iflag & IXON) {
2251 sw_flow |= C_FL_OXX;
2252 if (iflag & IXANY)
2253 sw_flow |= C_FL_OIXANY;
2254 }
2255 cy_writel(&ch_ctrl->sw_flow, sw_flow);
2256
Jiri Slaby875b2062007-05-08 00:36:49 -07002257 retval = cyz_issue_cmd(card, channel, C_CM_IOCTL, 0L);
Jiri Slaby02f11752006-12-08 02:39:28 -08002258 if (retval != 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07002259 printk(KERN_ERR "cyc:set_line_char retval on ttyC%d "
2260 "was %x\n", info->line, retval);
Jiri Slaby02f11752006-12-08 02:39:28 -08002261 }
2262
2263 /* CD sensitivity */
Alan Cox15ed6cc2008-04-30 00:53:55 -07002264 if (cflag & CLOCAL)
Alan Cox77451e52008-07-16 21:57:02 +01002265 info->port.flags &= ~ASYNC_CHECK_CD;
Alan Cox15ed6cc2008-04-30 00:53:55 -07002266 else
Alan Cox77451e52008-07-16 21:57:02 +01002267 info->port.flags |= ASYNC_CHECK_CD;
Jiri Slaby02f11752006-12-08 02:39:28 -08002268
2269 if (baud == 0) { /* baud rate is zero, turn off line */
2270 cy_writel(&ch_ctrl->rs_control,
Jiri Slabydb05c3b2007-05-08 00:35:46 -07002271 readl(&ch_ctrl->rs_control) & ~C_RS_DTR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002272#ifdef CY_DEBUG_DTR
Jiri Slaby21719192007-05-08 00:36:42 -07002273 printk(KERN_DEBUG "cyc:set_line_char dropping Z DTR\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002274#endif
Jiri Slaby02f11752006-12-08 02:39:28 -08002275 } else {
2276 cy_writel(&ch_ctrl->rs_control,
Jiri Slabydb05c3b2007-05-08 00:35:46 -07002277 readl(&ch_ctrl->rs_control) | C_RS_DTR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002278#ifdef CY_DEBUG_DTR
Jiri Slaby21719192007-05-08 00:36:42 -07002279 printk(KERN_DEBUG "cyc:set_line_char raising Z DTR\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002280#endif
Jiri Slaby02f11752006-12-08 02:39:28 -08002281 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002282
Alan Cox15ed6cc2008-04-30 00:53:55 -07002283 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLM, 0L);
Jiri Slaby02f11752006-12-08 02:39:28 -08002284 if (retval != 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07002285 printk(KERN_ERR "cyc:set_line_char(2) retval on ttyC%d "
2286 "was %x\n", info->line, retval);
Jiri Slaby02f11752006-12-08 02:39:28 -08002287 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002288
Jiri Slabyd13549f2009-09-19 13:13:12 -07002289 clear_bit(TTY_IO_ERROR, &tty->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002290 }
Jiri Slaby02f11752006-12-08 02:39:28 -08002291} /* set_line_char */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002292
Jiri Slaby6c281812009-09-19 13:13:15 -07002293static int cy_get_serial_info(struct cyclades_port *info,
Alan Cox15ed6cc2008-04-30 00:53:55 -07002294 struct serial_struct __user *retinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002295{
Jiri Slaby875b2062007-05-08 00:36:49 -07002296 struct cyclades_card *cinfo = info->card;
Jiri Slaby6c281812009-09-19 13:13:15 -07002297 struct serial_struct tmp = {
2298 .type = info->type,
2299 .line = info->line,
2300 .port = (info->card - cy_card) * 0x100 + info->line -
2301 cinfo->first_line,
2302 .irq = cinfo->irq,
2303 .flags = info->port.flags,
2304 .close_delay = info->port.close_delay,
2305 .closing_wait = info->port.closing_wait,
2306 .baud_base = info->baud,
2307 .custom_divisor = info->custom_divisor,
2308 .hub6 = 0, /*!!! */
2309 };
Jiri Slaby02f11752006-12-08 02:39:28 -08002310 return copy_to_user(retinfo, &tmp, sizeof(*retinfo)) ? -EFAULT : 0;
Jiri Slaby6c281812009-09-19 13:13:15 -07002311}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002312
2313static int
Jiri Slabyd13549f2009-09-19 13:13:12 -07002314cy_set_serial_info(struct cyclades_port *info, struct tty_struct *tty,
Alan Cox15ed6cc2008-04-30 00:53:55 -07002315 struct serial_struct __user *new_info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002316{
Jiri Slaby02f11752006-12-08 02:39:28 -08002317 struct serial_struct new_serial;
Alan Cox25c3cdf2010-06-01 22:52:47 +02002318 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002319
Jiri Slaby02f11752006-12-08 02:39:28 -08002320 if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
2321 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002322
Alan Cox25c3cdf2010-06-01 22:52:47 +02002323 mutex_lock(&info->port.mutex);
Jiri Slaby02f11752006-12-08 02:39:28 -08002324 if (!capable(CAP_SYS_ADMIN)) {
Alan Cox44b7d1b2008-07-16 21:57:18 +01002325 if (new_serial.close_delay != info->port.close_delay ||
Jiri Slaby02f11752006-12-08 02:39:28 -08002326 new_serial.baud_base != info->baud ||
2327 (new_serial.flags & ASYNC_FLAGS &
2328 ~ASYNC_USR_MASK) !=
Alan Cox77451e52008-07-16 21:57:02 +01002329 (info->port.flags & ASYNC_FLAGS & ~ASYNC_USR_MASK))
Alan Cox25c3cdf2010-06-01 22:52:47 +02002330 {
2331 mutex_unlock(&info->port.mutex);
Jiri Slaby02f11752006-12-08 02:39:28 -08002332 return -EPERM;
Alan Cox25c3cdf2010-06-01 22:52:47 +02002333 }
Alan Cox77451e52008-07-16 21:57:02 +01002334 info->port.flags = (info->port.flags & ~ASYNC_USR_MASK) |
Jiri Slaby02f11752006-12-08 02:39:28 -08002335 (new_serial.flags & ASYNC_USR_MASK);
2336 info->baud = new_serial.baud_base;
2337 info->custom_divisor = new_serial.custom_divisor;
2338 goto check_and_exit;
2339 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002340
Jiri Slaby02f11752006-12-08 02:39:28 -08002341 /*
2342 * OK, past this point, all the error checking has been done.
2343 * At this point, we start making changes.....
2344 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002345
Jiri Slaby02f11752006-12-08 02:39:28 -08002346 info->baud = new_serial.baud_base;
2347 info->custom_divisor = new_serial.custom_divisor;
Alan Cox77451e52008-07-16 21:57:02 +01002348 info->port.flags = (info->port.flags & ~ASYNC_FLAGS) |
Jiri Slaby02f11752006-12-08 02:39:28 -08002349 (new_serial.flags & ASYNC_FLAGS);
Alan Cox44b7d1b2008-07-16 21:57:18 +01002350 info->port.close_delay = new_serial.close_delay * HZ / 100;
2351 info->port.closing_wait = new_serial.closing_wait * HZ / 100;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002352
2353check_and_exit:
Alan Cox77451e52008-07-16 21:57:02 +01002354 if (info->port.flags & ASYNC_INITIALIZED) {
Jiri Slabyd13549f2009-09-19 13:13:12 -07002355 cy_set_line_char(info, tty);
Alan Cox25c3cdf2010-06-01 22:52:47 +02002356 ret = 0;
Jiri Slaby02f11752006-12-08 02:39:28 -08002357 } else {
Alan Cox25c3cdf2010-06-01 22:52:47 +02002358 ret = cy_startup(info, tty);
Jiri Slaby02f11752006-12-08 02:39:28 -08002359 }
Alan Cox25c3cdf2010-06-01 22:52:47 +02002360 mutex_unlock(&info->port.mutex);
2361 return ret;
Jiri Slaby02f11752006-12-08 02:39:28 -08002362} /* set_serial_info */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002363
2364/*
2365 * get_lsr_info - get line status register info
2366 *
2367 * Purpose: Let user call ioctl() to get info when the UART physically
2368 * is emptied. On bus types like RS485, the transmitter must
2369 * release the bus after transmitting. This must be done when
2370 * the transmit shift register is empty, not be done when the
2371 * transmit holding register is empty. This functionality
2372 * allows an RS485 driver to be written in user space.
2373 */
Alan Cox15ed6cc2008-04-30 00:53:55 -07002374static int get_lsr_info(struct cyclades_port *info, unsigned int __user *value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002375{
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002376 struct cyclades_card *card = info->card;
Jiri Slaby02f11752006-12-08 02:39:28 -08002377 unsigned int result;
2378 unsigned long flags;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002379 u8 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002380
Jiri Slaby2693f482009-06-11 12:31:06 +01002381 if (!cy_is_Z(card)) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002382 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002383 status = cyy_readb(info, CySRER) & (CyTxRdy | CyTxMpty);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002384 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002385 result = (status ? 0 : TIOCSER_TEMT);
2386 } else {
2387 /* Not supported yet */
2388 return -EINVAL;
2389 }
Dan Carpenterdbca36e2012-03-05 21:07:11 +03002390 return put_user(result, value);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002391}
2392
Alan Cox60b33c12011-02-14 16:26:14 +00002393static int cy_tiocmget(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002394{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07002395 struct cyclades_port *info = tty->driver_data;
Jiri Slaby875b2062007-05-08 00:36:49 -07002396 struct cyclades_card *card;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002397 int result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002398
Harvey Harrisonbf9d8922008-04-30 00:55:10 -07002399 if (serial_paranoia_check(info, tty->name, __func__))
Jiri Slaby02f11752006-12-08 02:39:28 -08002400 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002401
Jiri Slaby02f11752006-12-08 02:39:28 -08002402 card = info->card;
Jiri Slaby0d348722009-09-19 13:13:16 -07002403
Jiri Slaby2693f482009-06-11 12:31:06 +01002404 if (!cy_is_Z(card)) {
Jiri Slaby0d348722009-09-19 13:13:16 -07002405 unsigned long flags;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002406 int channel = info->line - card->first_line;
2407 u8 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002408
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002409 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002410 cyy_writeb(info, CyCAR, channel & 0x03);
2411 status = cyy_readb(info, CyMSVR1);
2412 status |= cyy_readb(info, CyMSVR2);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002413 spin_unlock_irqrestore(&card->card_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002414
Jiri Slaby02f11752006-12-08 02:39:28 -08002415 if (info->rtsdtr_inv) {
2416 result = ((status & CyRTS) ? TIOCM_DTR : 0) |
2417 ((status & CyDTR) ? TIOCM_RTS : 0);
2418 } else {
2419 result = ((status & CyRTS) ? TIOCM_RTS : 0) |
2420 ((status & CyDTR) ? TIOCM_DTR : 0);
2421 }
2422 result |= ((status & CyDCD) ? TIOCM_CAR : 0) |
2423 ((status & CyRI) ? TIOCM_RNG : 0) |
2424 ((status & CyDSR) ? TIOCM_DSR : 0) |
2425 ((status & CyCTS) ? TIOCM_CTS : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002426 } else {
Jiri Slaby0d348722009-09-19 13:13:16 -07002427 u32 lstatus;
2428
2429 if (!cyz_is_loaded(card)) {
2430 result = -ENODEV;
2431 goto end;
Jiri Slaby02f11752006-12-08 02:39:28 -08002432 }
2433
Jiri Slaby0d348722009-09-19 13:13:16 -07002434 lstatus = readl(&info->u.cyz.ch_ctrl->rs_status);
2435 result = ((lstatus & C_RS_RTS) ? TIOCM_RTS : 0) |
2436 ((lstatus & C_RS_DTR) ? TIOCM_DTR : 0) |
2437 ((lstatus & C_RS_DCD) ? TIOCM_CAR : 0) |
2438 ((lstatus & C_RS_RI) ? TIOCM_RNG : 0) |
2439 ((lstatus & C_RS_DSR) ? TIOCM_DSR : 0) |
2440 ((lstatus & C_RS_CTS) ? TIOCM_CTS : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002441 }
Jiri Slaby0d348722009-09-19 13:13:16 -07002442end:
Jiri Slaby02f11752006-12-08 02:39:28 -08002443 return result;
2444} /* cy_tiomget */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002445
2446static int
Alan Cox20b9d172011-02-14 16:26:50 +00002447cy_tiocmset(struct tty_struct *tty,
Jiri Slaby02f11752006-12-08 02:39:28 -08002448 unsigned int set, unsigned int clear)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002449{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07002450 struct cyclades_port *info = tty->driver_data;
Jiri Slaby875b2062007-05-08 00:36:49 -07002451 struct cyclades_card *card;
Jiri Slaby02f11752006-12-08 02:39:28 -08002452 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002453
Harvey Harrisonbf9d8922008-04-30 00:55:10 -07002454 if (serial_paranoia_check(info, tty->name, __func__))
Jiri Slaby02f11752006-12-08 02:39:28 -08002455 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002456
Jiri Slaby02f11752006-12-08 02:39:28 -08002457 card = info->card;
Jiri Slaby2693f482009-06-11 12:31:06 +01002458 if (!cy_is_Z(card)) {
Jiri Slaby4d768202009-09-19 13:13:15 -07002459 spin_lock_irqsave(&card->card_lock, flags);
2460 cyy_change_rts_dtr(info, set, clear);
2461 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002462 } else {
Jiri Slaby0d348722009-09-19 13:13:16 -07002463 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
2464 int retval, channel = info->line - card->first_line;
2465 u32 rs;
Jiri Slaby02f11752006-12-08 02:39:28 -08002466
Jiri Slaby0d348722009-09-19 13:13:16 -07002467 if (!cyz_is_loaded(card))
Jiri Slaby02f11752006-12-08 02:39:28 -08002468 return -ENODEV;
Jiri Slaby0d348722009-09-19 13:13:16 -07002469
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002470 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby0d348722009-09-19 13:13:16 -07002471 rs = readl(&ch_ctrl->rs_control);
2472 if (set & TIOCM_RTS)
2473 rs |= C_RS_RTS;
2474 if (clear & TIOCM_RTS)
2475 rs &= ~C_RS_RTS;
2476 if (set & TIOCM_DTR) {
2477 rs |= C_RS_DTR;
2478#ifdef CY_DEBUG_DTR
2479 printk(KERN_DEBUG "cyc:set_modem_info raising Z DTR\n");
2480#endif
2481 }
2482 if (clear & TIOCM_DTR) {
2483 rs &= ~C_RS_DTR;
2484#ifdef CY_DEBUG_DTR
2485 printk(KERN_DEBUG "cyc:set_modem_info clearing "
2486 "Z DTR\n");
2487#endif
2488 }
2489 cy_writel(&ch_ctrl->rs_control, rs);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002490 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLM, 0L);
Jiri Slaby0d348722009-09-19 13:13:16 -07002491 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002492 if (retval != 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07002493 printk(KERN_ERR "cyc:set_modem_info retval on ttyC%d "
2494 "was %x\n", info->line, retval);
Jiri Slaby02f11752006-12-08 02:39:28 -08002495 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002496 }
Jiri Slaby02f11752006-12-08 02:39:28 -08002497 return 0;
Jiri Slaby0d348722009-09-19 13:13:16 -07002498}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002499
2500/*
2501 * cy_break() --- routine which turns the break handling on or off
2502 */
Alan Cox9e989662008-07-22 11:18:03 +01002503static int cy_break(struct tty_struct *tty, int break_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002504{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07002505 struct cyclades_port *info = tty->driver_data;
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002506 struct cyclades_card *card;
Jiri Slaby02f11752006-12-08 02:39:28 -08002507 unsigned long flags;
Alan Cox9e989662008-07-22 11:18:03 +01002508 int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002509
Jiri Slaby02f11752006-12-08 02:39:28 -08002510 if (serial_paranoia_check(info, tty->name, "cy_break"))
Alan Cox9e989662008-07-22 11:18:03 +01002511 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002512
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002513 card = info->card;
2514
2515 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby2693f482009-06-11 12:31:06 +01002516 if (!cy_is_Z(card)) {
Jiri Slaby02f11752006-12-08 02:39:28 -08002517 /* Let the transmit ISR take care of this (since it
2518 requires stuffing characters into the output stream).
2519 */
2520 if (break_state == -1) {
2521 if (!info->breakon) {
2522 info->breakon = 1;
2523 if (!info->xmit_cnt) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002524 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002525 start_xmit(info);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002526 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002527 }
2528 }
2529 } else {
2530 if (!info->breakoff) {
2531 info->breakoff = 1;
2532 if (!info->xmit_cnt) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002533 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002534 start_xmit(info);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002535 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002536 }
2537 }
2538 }
2539 } else {
Jiri Slaby02f11752006-12-08 02:39:28 -08002540 if (break_state == -1) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002541 retval = cyz_issue_cmd(card,
2542 info->line - card->first_line,
Jiri Slaby02f11752006-12-08 02:39:28 -08002543 C_CM_SET_BREAK, 0L);
2544 if (retval != 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07002545 printk(KERN_ERR "cyc:cy_break (set) retval on "
2546 "ttyC%d was %x\n", info->line, retval);
Jiri Slaby02f11752006-12-08 02:39:28 -08002547 }
2548 } else {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002549 retval = cyz_issue_cmd(card,
2550 info->line - card->first_line,
Jiri Slaby02f11752006-12-08 02:39:28 -08002551 C_CM_CLR_BREAK, 0L);
2552 if (retval != 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07002553 printk(KERN_DEBUG "cyc:cy_break (clr) retval "
2554 "on ttyC%d was %x\n", info->line,
2555 retval);
Jiri Slaby02f11752006-12-08 02:39:28 -08002556 }
2557 }
2558 }
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002559 spin_unlock_irqrestore(&card->card_lock, flags);
Alan Cox9e989662008-07-22 11:18:03 +01002560 return retval;
Jiri Slaby02f11752006-12-08 02:39:28 -08002561} /* cy_break */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002562
Jiri Slaby02f11752006-12-08 02:39:28 -08002563static int set_threshold(struct cyclades_port *info, unsigned long value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002564{
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002565 struct cyclades_card *card = info->card;
Jiri Slaby02f11752006-12-08 02:39:28 -08002566 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002567
Jiri Slaby2693f482009-06-11 12:31:06 +01002568 if (!cy_is_Z(card)) {
Jiri Slaby02f11752006-12-08 02:39:28 -08002569 info->cor3 &= ~CyREC_FIFO;
2570 info->cor3 |= value & CyREC_FIFO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002571
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002572 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002573 cyy_writeb(info, CyCOR3, info->cor3);
2574 cyy_issue_cmd(info, CyCOR_CHANGE | CyCOR3ch);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002575 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002576 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002577 return 0;
Jiri Slaby02f11752006-12-08 02:39:28 -08002578} /* set_threshold */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002579
Alan Cox15ed6cc2008-04-30 00:53:55 -07002580static int get_threshold(struct cyclades_port *info,
2581 unsigned long __user *value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002582{
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002583 struct cyclades_card *card = info->card;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002584
Jiri Slaby2693f482009-06-11 12:31:06 +01002585 if (!cy_is_Z(card)) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002586 u8 tmp = cyy_readb(info, CyCOR3) & CyREC_FIFO;
Jiri Slaby02f11752006-12-08 02:39:28 -08002587 return put_user(tmp, value);
Jiri Slaby02f11752006-12-08 02:39:28 -08002588 }
Jiri Slabyf7429032007-05-08 00:36:59 -07002589 return 0;
Jiri Slaby02f11752006-12-08 02:39:28 -08002590} /* get_threshold */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002591
Jiri Slaby02f11752006-12-08 02:39:28 -08002592static int set_timeout(struct cyclades_port *info, unsigned long value)
2593{
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002594 struct cyclades_card *card = info->card;
Jiri Slaby02f11752006-12-08 02:39:28 -08002595 unsigned long flags;
2596
Jiri Slaby2693f482009-06-11 12:31:06 +01002597 if (!cy_is_Z(card)) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002598 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002599 cyy_writeb(info, CyRTPR, value & 0xff);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002600 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002601 }
2602 return 0;
2603} /* set_timeout */
2604
Alan Cox15ed6cc2008-04-30 00:53:55 -07002605static int get_timeout(struct cyclades_port *info,
2606 unsigned long __user *value)
Jiri Slaby02f11752006-12-08 02:39:28 -08002607{
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002608 struct cyclades_card *card = info->card;
Jiri Slaby02f11752006-12-08 02:39:28 -08002609
Jiri Slaby2693f482009-06-11 12:31:06 +01002610 if (!cy_is_Z(card)) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002611 u8 tmp = cyy_readb(info, CyRTPR);
Jiri Slaby02f11752006-12-08 02:39:28 -08002612 return put_user(tmp, value);
Jiri Slaby02f11752006-12-08 02:39:28 -08002613 }
Jiri Slabyf7429032007-05-08 00:36:59 -07002614 return 0;
Jiri Slaby02f11752006-12-08 02:39:28 -08002615} /* get_timeout */
2616
Jiri Slaby6c281812009-09-19 13:13:15 -07002617static int cy_cflags_changed(struct cyclades_port *info, unsigned long arg,
2618 struct cyclades_icount *cprev)
Jiri Slaby02f11752006-12-08 02:39:28 -08002619{
Jiri Slaby6c281812009-09-19 13:13:15 -07002620 struct cyclades_icount cnow;
2621 unsigned long flags;
2622 int ret;
Jiri Slaby02f11752006-12-08 02:39:28 -08002623
Jiri Slaby6c281812009-09-19 13:13:15 -07002624 spin_lock_irqsave(&info->card->card_lock, flags);
2625 cnow = info->icount; /* atomic copy */
2626 spin_unlock_irqrestore(&info->card->card_lock, flags);
2627
2628 ret = ((arg & TIOCM_RNG) && (cnow.rng != cprev->rng)) ||
2629 ((arg & TIOCM_DSR) && (cnow.dsr != cprev->dsr)) ||
2630 ((arg & TIOCM_CD) && (cnow.dcd != cprev->dcd)) ||
2631 ((arg & TIOCM_CTS) && (cnow.cts != cprev->cts));
2632
2633 *cprev = cnow;
2634
2635 return ret;
2636}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002637
2638/*
2639 * This routine allows the tty driver to implement device-
2640 * specific ioctl's. If the ioctl number passed in cmd is
2641 * not recognized by the driver, it should return ENOIOCTLCMD.
2642 */
2643static int
Alan Cox6caa76b2011-02-14 16:27:22 +00002644cy_ioctl(struct tty_struct *tty,
Jiri Slaby02f11752006-12-08 02:39:28 -08002645 unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002646{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07002647 struct cyclades_port *info = tty->driver_data;
Jiri Slaby6c281812009-09-19 13:13:15 -07002648 struct cyclades_icount cnow; /* kernel counter temps */
Jiri Slaby02f11752006-12-08 02:39:28 -08002649 int ret_val = 0;
2650 unsigned long flags;
2651 void __user *argp = (void __user *)arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002652
Jiri Slaby02f11752006-12-08 02:39:28 -08002653 if (serial_paranoia_check(info, tty->name, "cy_ioctl"))
2654 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002655
2656#ifdef CY_DEBUG_OTHER
Jiri Slaby21719192007-05-08 00:36:42 -07002657 printk(KERN_DEBUG "cyc:cy_ioctl ttyC%d, cmd = %x arg = %lx\n",
2658 info->line, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002659#endif
2660
Jiri Slaby02f11752006-12-08 02:39:28 -08002661 switch (cmd) {
2662 case CYGETMON:
Jiri Slaby6c281812009-09-19 13:13:15 -07002663 if (copy_to_user(argp, &info->mon, sizeof(info->mon))) {
2664 ret_val = -EFAULT;
2665 break;
2666 }
2667 memset(&info->mon, 0, sizeof(info->mon));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002668 break;
Jiri Slaby02f11752006-12-08 02:39:28 -08002669 case CYGETTHRESH:
2670 ret_val = get_threshold(info, argp);
2671 break;
2672 case CYSETTHRESH:
2673 ret_val = set_threshold(info, arg);
2674 break;
2675 case CYGETDEFTHRESH:
Jiri Slaby6c281812009-09-19 13:13:15 -07002676 ret_val = put_user(info->default_threshold,
2677 (unsigned long __user *)argp);
Jiri Slaby02f11752006-12-08 02:39:28 -08002678 break;
2679 case CYSETDEFTHRESH:
Jiri Slaby6c281812009-09-19 13:13:15 -07002680 info->default_threshold = arg & 0x0f;
Jiri Slaby02f11752006-12-08 02:39:28 -08002681 break;
2682 case CYGETTIMEOUT:
2683 ret_val = get_timeout(info, argp);
2684 break;
2685 case CYSETTIMEOUT:
2686 ret_val = set_timeout(info, arg);
2687 break;
2688 case CYGETDEFTIMEOUT:
Jiri Slaby6c281812009-09-19 13:13:15 -07002689 ret_val = put_user(info->default_timeout,
2690 (unsigned long __user *)argp);
Jiri Slaby02f11752006-12-08 02:39:28 -08002691 break;
2692 case CYSETDEFTIMEOUT:
Jiri Slaby6c281812009-09-19 13:13:15 -07002693 info->default_timeout = arg & 0xff;
Jiri Slaby02f11752006-12-08 02:39:28 -08002694 break;
2695 case CYSETRFLOW:
2696 info->rflow = (int)arg;
Jiri Slaby02f11752006-12-08 02:39:28 -08002697 break;
2698 case CYGETRFLOW:
2699 ret_val = info->rflow;
2700 break;
2701 case CYSETRTSDTR_INV:
2702 info->rtsdtr_inv = (int)arg;
Jiri Slaby02f11752006-12-08 02:39:28 -08002703 break;
2704 case CYGETRTSDTR_INV:
2705 ret_val = info->rtsdtr_inv;
2706 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002707 case CYGETCD1400VER:
Jiri Slaby02f11752006-12-08 02:39:28 -08002708 ret_val = info->chip_rev;
2709 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002710#ifndef CONFIG_CYZ_INTR
2711 case CYZSETPOLLCYCLE:
Qixue Xiao351d6202013-12-20 17:51:12 +08002712 if (arg > LONG_MAX / HZ)
2713 return -ENODEV;
Jiri Slaby02f11752006-12-08 02:39:28 -08002714 cyz_polling_cycle = (arg * HZ) / 1000;
Jiri Slaby02f11752006-12-08 02:39:28 -08002715 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002716 case CYZGETPOLLCYCLE:
Jiri Slaby02f11752006-12-08 02:39:28 -08002717 ret_val = (cyz_polling_cycle * 1000) / HZ;
2718 break;
2719#endif /* CONFIG_CYZ_INTR */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002720 case CYSETWAIT:
Alan Cox44b7d1b2008-07-16 21:57:18 +01002721 info->port.closing_wait = (unsigned short)arg * HZ / 100;
Jiri Slaby02f11752006-12-08 02:39:28 -08002722 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002723 case CYGETWAIT:
Alan Cox44b7d1b2008-07-16 21:57:18 +01002724 ret_val = info->port.closing_wait / (HZ / 100);
Jiri Slaby02f11752006-12-08 02:39:28 -08002725 break;
2726 case TIOCGSERIAL:
Jiri Slaby6c281812009-09-19 13:13:15 -07002727 ret_val = cy_get_serial_info(info, argp);
Jiri Slaby02f11752006-12-08 02:39:28 -08002728 break;
2729 case TIOCSSERIAL:
Jiri Slabyd13549f2009-09-19 13:13:12 -07002730 ret_val = cy_set_serial_info(info, tty, argp);
Jiri Slaby02f11752006-12-08 02:39:28 -08002731 break;
2732 case TIOCSERGETLSR: /* Get line status register */
2733 ret_val = get_lsr_info(info, argp);
2734 break;
2735 /*
2736 * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
2737 * - mask passed in arg for lines of interest
2738 * (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
2739 * Caller should use TIOCGICOUNT to see which one it was
2740 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002741 case TIOCMIWAIT:
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002742 spin_lock_irqsave(&info->card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002743 /* note the counters on entry */
Jiri Slaby2c7fea92007-05-08 00:36:51 -07002744 cnow = info->icount;
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002745 spin_unlock_irqrestore(&info->card->card_lock, flags);
Alan Coxbdc04e32009-09-19 13:13:31 -07002746 ret_val = wait_event_interruptible(info->port.delta_msr_wait,
Jiri Slaby6c281812009-09-19 13:13:15 -07002747 cy_cflags_changed(info, arg, &cnow));
Jiri Slaby2c7fea92007-05-08 00:36:51 -07002748 break;
Jiri Slaby02f11752006-12-08 02:39:28 -08002749
2750 /*
2751 * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
2752 * Return: write counters to the user passed counter struct
2753 * NB: both 1->0 and 0->1 transitions are counted except for
2754 * RI where only 0->1 is counted.
2755 */
Jiri Slaby02f11752006-12-08 02:39:28 -08002756 default:
2757 ret_val = -ENOIOCTLCMD;
2758 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002759
2760#ifdef CY_DEBUG_OTHER
Jiri Slaby21719192007-05-08 00:36:42 -07002761 printk(KERN_DEBUG "cyc:cy_ioctl done\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002762#endif
Jiri Slaby02f11752006-12-08 02:39:28 -08002763 return ret_val;
2764} /* cy_ioctl */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002765
Alan Cox05871022010-09-16 18:21:52 +01002766static int cy_get_icount(struct tty_struct *tty,
2767 struct serial_icounter_struct *sic)
2768{
2769 struct cyclades_port *info = tty->driver_data;
2770 struct cyclades_icount cnow; /* Used to snapshot */
2771 unsigned long flags;
2772
2773 spin_lock_irqsave(&info->card->card_lock, flags);
2774 cnow = info->icount;
2775 spin_unlock_irqrestore(&info->card->card_lock, flags);
2776
2777 sic->cts = cnow.cts;
2778 sic->dsr = cnow.dsr;
2779 sic->rng = cnow.rng;
2780 sic->dcd = cnow.dcd;
2781 sic->rx = cnow.rx;
2782 sic->tx = cnow.tx;
2783 sic->frame = cnow.frame;
2784 sic->overrun = cnow.overrun;
2785 sic->parity = cnow.parity;
2786 sic->brk = cnow.brk;
2787 sic->buf_overrun = cnow.buf_overrun;
2788 return 0;
2789}
2790
Linus Torvalds1da177e2005-04-16 15:20:36 -07002791/*
2792 * This routine allows the tty driver to be notified when
2793 * device's termios settings have changed. Note that a
2794 * well-designed tty driver should be prepared to accept the case
2795 * where old == NULL, and try to do something rational.
2796 */
Jiri Slaby02f11752006-12-08 02:39:28 -08002797static void cy_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002798{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07002799 struct cyclades_port *info = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002800
2801#ifdef CY_DEBUG_OTHER
Jiri Slaby21719192007-05-08 00:36:42 -07002802 printk(KERN_DEBUG "cyc:cy_set_termios ttyC%d\n", info->line);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002803#endif
2804
Jiri Slabyd13549f2009-09-19 13:13:12 -07002805 cy_set_line_char(info, tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002806
Jiri Slaby02f11752006-12-08 02:39:28 -08002807 if ((old_termios->c_cflag & CRTSCTS) &&
Alan Coxadc8d742012-07-14 15:31:47 +01002808 !(tty->termios.c_cflag & CRTSCTS)) {
Jiri Slaby02f11752006-12-08 02:39:28 -08002809 tty->hw_stopped = 0;
2810 cy_start(tty);
2811 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002812#if 0
Jiri Slaby02f11752006-12-08 02:39:28 -08002813 /*
2814 * No need to wake up processes in open wait, since they
2815 * sample the CLOCAL flag once, and don't recheck it.
2816 * XXX It's not clear whether the current behavior is correct
2817 * or not. Hence, this may change.....
2818 */
2819 if (!(old_termios->c_cflag & CLOCAL) &&
Alan Coxadc8d742012-07-14 15:31:47 +01002820 (tty->termios.c_cflag & CLOCAL))
Alan Cox77451e52008-07-16 21:57:02 +01002821 wake_up_interruptible(&info->port.open_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002822#endif
Jiri Slaby02f11752006-12-08 02:39:28 -08002823} /* cy_set_termios */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002824
2825/* This function is used to send a high-priority XON/XOFF character to
2826 the device.
2827*/
Jiri Slaby02f11752006-12-08 02:39:28 -08002828static void cy_send_xchar(struct tty_struct *tty, char ch)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002829{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07002830 struct cyclades_port *info = tty->driver_data;
Jiri Slaby875b2062007-05-08 00:36:49 -07002831 struct cyclades_card *card;
2832 int channel;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002833
Jiri Slaby02f11752006-12-08 02:39:28 -08002834 if (serial_paranoia_check(info, tty->name, "cy_send_xchar"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002835 return;
2836
Jiri Slaby02f11752006-12-08 02:39:28 -08002837 info->x_char = ch;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002838
2839 if (ch)
Jiri Slaby02f11752006-12-08 02:39:28 -08002840 cy_start(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002841
2842 card = info->card;
Jiri Slaby875b2062007-05-08 00:36:49 -07002843 channel = info->line - card->first_line;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002844
Jiri Slaby2693f482009-06-11 12:31:06 +01002845 if (cy_is_Z(card)) {
Jiri Slaby02f11752006-12-08 02:39:28 -08002846 if (ch == STOP_CHAR(tty))
Jiri Slaby875b2062007-05-08 00:36:49 -07002847 cyz_issue_cmd(card, channel, C_CM_SENDXOFF, 0L);
Jiri Slaby02f11752006-12-08 02:39:28 -08002848 else if (ch == START_CHAR(tty))
Jiri Slaby875b2062007-05-08 00:36:49 -07002849 cyz_issue_cmd(card, channel, C_CM_SENDXON, 0L);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002850 }
2851}
2852
2853/* This routine is called by the upper-layer tty layer to signal
2854 that incoming characters should be throttled because the input
2855 buffers are close to full.
2856 */
Jiri Slaby02f11752006-12-08 02:39:28 -08002857static void cy_throttle(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002858{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07002859 struct cyclades_port *info = tty->driver_data;
Jiri Slaby875b2062007-05-08 00:36:49 -07002860 struct cyclades_card *card;
Jiri Slaby02f11752006-12-08 02:39:28 -08002861 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002862
2863#ifdef CY_DEBUG_THROTTLE
Jiri Slaby02f11752006-12-08 02:39:28 -08002864 char buf[64];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002865
Jiri Slaby21719192007-05-08 00:36:42 -07002866 printk(KERN_DEBUG "cyc:throttle %s: %ld...ttyC%d\n", tty_name(tty, buf),
Jiri Slaby02f11752006-12-08 02:39:28 -08002867 tty->ldisc.chars_in_buffer(tty), info->line);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002868#endif
2869
Alan Cox15ed6cc2008-04-30 00:53:55 -07002870 if (serial_paranoia_check(info, tty->name, "cy_throttle"))
Jiri Slaby02f11752006-12-08 02:39:28 -08002871 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002872
Jiri Slaby02f11752006-12-08 02:39:28 -08002873 card = info->card;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002874
Jiri Slaby02f11752006-12-08 02:39:28 -08002875 if (I_IXOFF(tty)) {
Jiri Slaby2693f482009-06-11 12:31:06 +01002876 if (!cy_is_Z(card))
Jiri Slaby02f11752006-12-08 02:39:28 -08002877 cy_send_xchar(tty, STOP_CHAR(tty));
2878 else
2879 info->throttle = 1;
2880 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002881
Alan Coxadc8d742012-07-14 15:31:47 +01002882 if (tty->termios.c_cflag & CRTSCTS) {
Jiri Slaby2693f482009-06-11 12:31:06 +01002883 if (!cy_is_Z(card)) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002884 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby4d768202009-09-19 13:13:15 -07002885 cyy_change_rts_dtr(info, 0, TIOCM_RTS);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002886 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002887 } else {
2888 info->throttle = 1;
2889 }
2890 }
Jiri Slaby02f11752006-12-08 02:39:28 -08002891} /* cy_throttle */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002892
2893/*
2894 * This routine notifies the tty driver that it should signal
2895 * that characters can now be sent to the tty without fear of
2896 * overrunning the input buffers of the line disciplines.
2897 */
Jiri Slaby02f11752006-12-08 02:39:28 -08002898static void cy_unthrottle(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002899{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07002900 struct cyclades_port *info = tty->driver_data;
Jiri Slaby875b2062007-05-08 00:36:49 -07002901 struct cyclades_card *card;
Jiri Slaby02f11752006-12-08 02:39:28 -08002902 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002903
2904#ifdef CY_DEBUG_THROTTLE
Jiri Slaby02f11752006-12-08 02:39:28 -08002905 char buf[64];
2906
Jiri Slaby21719192007-05-08 00:36:42 -07002907 printk(KERN_DEBUG "cyc:unthrottle %s: %ld...ttyC%d\n",
Alan Cox15ed6cc2008-04-30 00:53:55 -07002908 tty_name(tty, buf), tty_chars_in_buffer(tty), info->line);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002909#endif
2910
Alan Cox15ed6cc2008-04-30 00:53:55 -07002911 if (serial_paranoia_check(info, tty->name, "cy_unthrottle"))
Jiri Slaby02f11752006-12-08 02:39:28 -08002912 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002913
Jiri Slaby02f11752006-12-08 02:39:28 -08002914 if (I_IXOFF(tty)) {
2915 if (info->x_char)
2916 info->x_char = 0;
2917 else
2918 cy_send_xchar(tty, START_CHAR(tty));
2919 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002920
Alan Coxadc8d742012-07-14 15:31:47 +01002921 if (tty->termios.c_cflag & CRTSCTS) {
Jiri Slaby02f11752006-12-08 02:39:28 -08002922 card = info->card;
Jiri Slaby2693f482009-06-11 12:31:06 +01002923 if (!cy_is_Z(card)) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002924 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby4d768202009-09-19 13:13:15 -07002925 cyy_change_rts_dtr(info, TIOCM_RTS, 0);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002926 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002927 } else {
2928 info->throttle = 0;
2929 }
2930 }
Jiri Slaby02f11752006-12-08 02:39:28 -08002931} /* cy_unthrottle */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002932
2933/* cy_start and cy_stop provide software output flow control as a
2934 function of XON/XOFF, software CTS, and other such stuff.
2935*/
Jiri Slaby02f11752006-12-08 02:39:28 -08002936static void cy_stop(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002937{
Jiri Slaby02f11752006-12-08 02:39:28 -08002938 struct cyclades_card *cinfo;
Jiri Slabycab9bdd2007-05-08 00:35:51 -07002939 struct cyclades_port *info = tty->driver_data;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002940 int channel;
Jiri Slaby02f11752006-12-08 02:39:28 -08002941 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002942
2943#ifdef CY_DEBUG_OTHER
Jiri Slaby21719192007-05-08 00:36:42 -07002944 printk(KERN_DEBUG "cyc:cy_stop ttyC%d\n", info->line);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002945#endif
2946
Jiri Slaby02f11752006-12-08 02:39:28 -08002947 if (serial_paranoia_check(info, tty->name, "cy_stop"))
2948 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002949
Jiri Slaby875b2062007-05-08 00:36:49 -07002950 cinfo = info->card;
Jiri Slaby02f11752006-12-08 02:39:28 -08002951 channel = info->line - cinfo->first_line;
Jiri Slaby2693f482009-06-11 12:31:06 +01002952 if (!cy_is_Z(cinfo)) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002953 spin_lock_irqsave(&cinfo->card_lock, flags);
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002954 cyy_writeb(info, CyCAR, channel & 0x03);
2955 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyTxRdy);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002956 spin_unlock_irqrestore(&cinfo->card_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002957 }
Jiri Slaby02f11752006-12-08 02:39:28 -08002958} /* cy_stop */
2959
2960static void cy_start(struct tty_struct *tty)
2961{
2962 struct cyclades_card *cinfo;
Jiri Slabycab9bdd2007-05-08 00:35:51 -07002963 struct cyclades_port *info = tty->driver_data;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002964 int channel;
Jiri Slaby02f11752006-12-08 02:39:28 -08002965 unsigned long flags;
2966
2967#ifdef CY_DEBUG_OTHER
Jiri Slaby21719192007-05-08 00:36:42 -07002968 printk(KERN_DEBUG "cyc:cy_start ttyC%d\n", info->line);
Jiri Slaby02f11752006-12-08 02:39:28 -08002969#endif
2970
2971 if (serial_paranoia_check(info, tty->name, "cy_start"))
2972 return;
2973
Jiri Slaby875b2062007-05-08 00:36:49 -07002974 cinfo = info->card;
Jiri Slaby02f11752006-12-08 02:39:28 -08002975 channel = info->line - cinfo->first_line;
Jiri Slaby2693f482009-06-11 12:31:06 +01002976 if (!cy_is_Z(cinfo)) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002977 spin_lock_irqsave(&cinfo->card_lock, flags);
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002978 cyy_writeb(info, CyCAR, channel & 0x03);
2979 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyTxRdy);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002980 spin_unlock_irqrestore(&cinfo->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002981 }
Jiri Slaby02f11752006-12-08 02:39:28 -08002982} /* cy_start */
2983
Linus Torvalds1da177e2005-04-16 15:20:36 -07002984/*
2985 * cy_hangup() --- called by tty_hangup() when a hangup is signaled.
2986 */
Jiri Slaby02f11752006-12-08 02:39:28 -08002987static void cy_hangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002988{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07002989 struct cyclades_port *info = tty->driver_data;
Jiri Slaby02f11752006-12-08 02:39:28 -08002990
Linus Torvalds1da177e2005-04-16 15:20:36 -07002991#ifdef CY_DEBUG_OTHER
Jiri Slaby21719192007-05-08 00:36:42 -07002992 printk(KERN_DEBUG "cyc:cy_hangup ttyC%d\n", info->line);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002993#endif
2994
Jiri Slaby02f11752006-12-08 02:39:28 -08002995 if (serial_paranoia_check(info, tty->name, "cy_hangup"))
2996 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002997
Jiri Slaby02f11752006-12-08 02:39:28 -08002998 cy_flush_buffer(tty);
Jiri Slabyd13549f2009-09-19 13:13:12 -07002999 cy_shutdown(info, tty);
Jiri Slaby174e6fe2009-09-19 13:13:13 -07003000 tty_port_hangup(&info->port);
Jiri Slaby02f11752006-12-08 02:39:28 -08003001} /* cy_hangup */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003002
Jiri Slabyf0737572009-09-19 13:13:12 -07003003static int cyy_carrier_raised(struct tty_port *port)
3004{
3005 struct cyclades_port *info = container_of(port, struct cyclades_port,
3006 port);
3007 struct cyclades_card *cinfo = info->card;
Jiri Slabyf0737572009-09-19 13:13:12 -07003008 unsigned long flags;
3009 int channel = info->line - cinfo->first_line;
Jiri Slabyf0737572009-09-19 13:13:12 -07003010 u32 cd;
3011
Jiri Slabyf0737572009-09-19 13:13:12 -07003012 spin_lock_irqsave(&cinfo->card_lock, flags);
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07003013 cyy_writeb(info, CyCAR, channel & 0x03);
3014 cd = cyy_readb(info, CyMSVR1) & CyDCD;
Jiri Slabyf0737572009-09-19 13:13:12 -07003015 spin_unlock_irqrestore(&cinfo->card_lock, flags);
3016
3017 return cd;
3018}
3019
3020static void cyy_dtr_rts(struct tty_port *port, int raise)
3021{
3022 struct cyclades_port *info = container_of(port, struct cyclades_port,
3023 port);
3024 struct cyclades_card *cinfo = info->card;
Jiri Slabyf0737572009-09-19 13:13:12 -07003025 unsigned long flags;
Jiri Slabyf0737572009-09-19 13:13:12 -07003026
3027 spin_lock_irqsave(&cinfo->card_lock, flags);
Jiri Slaby4d768202009-09-19 13:13:15 -07003028 cyy_change_rts_dtr(info, raise ? TIOCM_RTS | TIOCM_DTR : 0,
3029 raise ? 0 : TIOCM_RTS | TIOCM_DTR);
Jiri Slabyf0737572009-09-19 13:13:12 -07003030 spin_unlock_irqrestore(&cinfo->card_lock, flags);
3031}
3032
3033static int cyz_carrier_raised(struct tty_port *port)
3034{
3035 struct cyclades_port *info = container_of(port, struct cyclades_port,
3036 port);
Jiri Slabyf0737572009-09-19 13:13:12 -07003037
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003038 return readl(&info->u.cyz.ch_ctrl->rs_status) & C_RS_DCD;
Jiri Slabyf0737572009-09-19 13:13:12 -07003039}
3040
3041static void cyz_dtr_rts(struct tty_port *port, int raise)
3042{
3043 struct cyclades_port *info = container_of(port, struct cyclades_port,
3044 port);
3045 struct cyclades_card *cinfo = info->card;
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003046 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
Jiri Slabyf0737572009-09-19 13:13:12 -07003047 int ret, channel = info->line - cinfo->first_line;
3048 u32 rs;
3049
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003050 rs = readl(&ch_ctrl->rs_control);
Jiri Slabyf0737572009-09-19 13:13:12 -07003051 if (raise)
3052 rs |= C_RS_RTS | C_RS_DTR;
3053 else
3054 rs &= ~(C_RS_RTS | C_RS_DTR);
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003055 cy_writel(&ch_ctrl->rs_control, rs);
Jiri Slabyf0737572009-09-19 13:13:12 -07003056 ret = cyz_issue_cmd(cinfo, channel, C_CM_IOCTLM, 0L);
3057 if (ret != 0)
3058 printk(KERN_ERR "%s: retval on ttyC%d was %x\n",
3059 __func__, info->line, ret);
3060#ifdef CY_DEBUG_DTR
3061 printk(KERN_DEBUG "%s: raising Z DTR\n", __func__);
3062#endif
3063}
3064
3065static const struct tty_port_operations cyy_port_ops = {
3066 .carrier_raised = cyy_carrier_raised,
3067 .dtr_rts = cyy_dtr_rts,
Alan Coxe936ffd2009-09-19 13:13:22 -07003068 .shutdown = cy_do_close,
Jiri Slabyf0737572009-09-19 13:13:12 -07003069};
3070
3071static const struct tty_port_operations cyz_port_ops = {
3072 .carrier_raised = cyz_carrier_raised,
3073 .dtr_rts = cyz_dtr_rts,
Alan Coxe936ffd2009-09-19 13:13:22 -07003074 .shutdown = cy_do_close,
Jiri Slabyf0737572009-09-19 13:13:12 -07003075};
3076
Linus Torvalds1da177e2005-04-16 15:20:36 -07003077/*
3078 * ---------------------------------------------------------------------
3079 * cy_init() and friends
3080 *
3081 * cy_init() is called at boot-time to initialize the serial driver.
3082 * ---------------------------------------------------------------------
3083 */
3084
Bill Pemberton9671f092012-11-19 13:21:50 -05003085static int cy_init_card(struct cyclades_card *cinfo)
Jiri Slaby0809e262007-05-08 00:36:14 -07003086{
3087 struct cyclades_port *info;
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003088 unsigned int channel, port;
Jiri Slaby0809e262007-05-08 00:36:14 -07003089
Jiri Slaby3046d502007-05-08 00:36:46 -07003090 spin_lock_init(&cinfo->card_lock);
Jiri Slaby963118e2009-06-11 12:34:27 +01003091 cinfo->intr_enabled = 0;
Jiri Slaby3046d502007-05-08 00:36:46 -07003092
Jiri Slaby963118e2009-06-11 12:34:27 +01003093 cinfo->ports = kcalloc(cinfo->nports, sizeof(*cinfo->ports),
3094 GFP_KERNEL);
Jiri Slabydd025c02007-05-08 00:37:02 -07003095 if (cinfo->ports == NULL) {
3096 printk(KERN_ERR "Cyclades: cannot allocate ports\n");
3097 return -ENOMEM;
3098 }
3099
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003100 for (channel = 0, port = cinfo->first_line; channel < cinfo->nports;
3101 channel++, port++) {
3102 info = &cinfo->ports[channel];
Alan Cox44b7d1b2008-07-16 21:57:18 +01003103 tty_port_init(&info->port);
Jiri Slaby3046d502007-05-08 00:36:46 -07003104 info->magic = CYCLADES_MAGIC;
Jiri Slaby875b2062007-05-08 00:36:49 -07003105 info->card = cinfo;
Jiri Slaby3046d502007-05-08 00:36:46 -07003106 info->line = port;
Jiri Slaby3046d502007-05-08 00:36:46 -07003107
Alan Cox44b7d1b2008-07-16 21:57:18 +01003108 info->port.closing_wait = CLOSING_WAIT_DELAY;
3109 info->port.close_delay = 5 * HZ / 10;
Alan Cox77451e52008-07-16 21:57:02 +01003110 info->port.flags = STD_COM_FLAGS;
Jiri Slaby2c7fea92007-05-08 00:36:51 -07003111 init_completion(&info->shutdown_wait);
Jiri Slaby3046d502007-05-08 00:36:46 -07003112
Jiri Slaby2693f482009-06-11 12:31:06 +01003113 if (cy_is_Z(cinfo)) {
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003114 struct FIRM_ID *firm_id = cinfo->base_addr + ID_ADDRESS;
3115 struct ZFW_CTRL *zfw_ctrl;
3116
Jiri Slabyf0737572009-09-19 13:13:12 -07003117 info->port.ops = &cyz_port_ops;
Jiri Slaby0809e262007-05-08 00:36:14 -07003118 info->type = PORT_STARTECH;
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003119
3120 zfw_ctrl = cinfo->base_addr +
3121 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
3122 info->u.cyz.ch_ctrl = &zfw_ctrl->ch_ctrl[channel];
3123 info->u.cyz.buf_ctrl = &zfw_ctrl->buf_ctrl[channel];
3124
Jiri Slaby101b8152009-06-11 12:30:10 +01003125 if (cinfo->hw_ver == ZO_V1)
Jiri Slaby0809e262007-05-08 00:36:14 -07003126 info->xmit_fifo_size = CYZ_FIFO_SIZE;
3127 else
Jiri Slaby3046d502007-05-08 00:36:46 -07003128 info->xmit_fifo_size = 4 * CYZ_FIFO_SIZE;
Jiri Slaby0809e262007-05-08 00:36:14 -07003129#ifdef CONFIG_CYZ_INTR
Jiri Slaby39914282007-05-08 00:36:54 -07003130 setup_timer(&cyz_rx_full_timer[port],
3131 cyz_rx_restart, (unsigned long)info);
Jiri Slaby0809e262007-05-08 00:36:14 -07003132#endif
Jiri Slaby3046d502007-05-08 00:36:46 -07003133 } else {
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003134 unsigned short chip_number;
Jiri Slaby963118e2009-06-11 12:34:27 +01003135 int index = cinfo->bus_index;
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003136
Jiri Slabyf0737572009-09-19 13:13:12 -07003137 info->port.ops = &cyy_port_ops;
Jiri Slaby0809e262007-05-08 00:36:14 -07003138 info->type = PORT_CIRRUS;
Jiri Slaby0809e262007-05-08 00:36:14 -07003139 info->xmit_fifo_size = CyMAX_CHAR_FIFO;
Jiri Slaby3046d502007-05-08 00:36:46 -07003140 info->cor1 = CyPARITY_NONE | Cy_1_STOP | Cy_8_BITS;
Jiri Slaby0809e262007-05-08 00:36:14 -07003141 info->cor2 = CyETC;
3142 info->cor3 = 0x08; /* _very_ small rcv threshold */
Jiri Slaby3046d502007-05-08 00:36:46 -07003143
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003144 chip_number = channel / CyPORTS_PER_CHIP;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07003145 info->u.cyy.base_addr = cinfo->base_addr +
3146 (cy_chip_offset[chip_number] << index);
3147 info->chip_rev = cyy_readb(info, CyGFRCR);
Alan Cox15ed6cc2008-04-30 00:53:55 -07003148
3149 if (info->chip_rev >= CD1400_REV_J) {
Jiri Slaby0809e262007-05-08 00:36:14 -07003150 /* It is a CD1400 rev. J or later */
3151 info->tbpr = baud_bpr_60[13]; /* Tx BPR */
3152 info->tco = baud_co_60[13]; /* Tx CO */
3153 info->rbpr = baud_bpr_60[13]; /* Rx BPR */
3154 info->rco = baud_co_60[13]; /* Rx CO */
Jiri Slaby0809e262007-05-08 00:36:14 -07003155 info->rtsdtr_inv = 1;
3156 } else {
3157 info->tbpr = baud_bpr_25[13]; /* Tx BPR */
3158 info->tco = baud_co_25[13]; /* Tx CO */
3159 info->rbpr = baud_bpr_25[13]; /* Rx BPR */
3160 info->rco = baud_co_25[13]; /* Rx CO */
Jiri Slaby0809e262007-05-08 00:36:14 -07003161 info->rtsdtr_inv = 0;
3162 }
Jiri Slaby3046d502007-05-08 00:36:46 -07003163 info->read_status_mask = CyTIMEOUT | CySPECHAR |
3164 CyBREAK | CyPARITY | CyFRAME | CyOVERRUN;
Jiri Slaby0809e262007-05-08 00:36:14 -07003165 }
Jiri Slaby3046d502007-05-08 00:36:46 -07003166
Jiri Slaby0809e262007-05-08 00:36:14 -07003167 }
Jiri Slaby3046d502007-05-08 00:36:46 -07003168
3169#ifndef CONFIG_CYZ_INTR
Jiri Slaby2693f482009-06-11 12:31:06 +01003170 if (cy_is_Z(cinfo) && !timer_pending(&cyz_timerlist)) {
Jiri Slaby3046d502007-05-08 00:36:46 -07003171 mod_timer(&cyz_timerlist, jiffies + 1);
3172#ifdef CY_PCI_DEBUG
3173 printk(KERN_DEBUG "Cyclades-Z polling initialized\n");
3174#endif
3175 }
3176#endif
Jiri Slabydd025c02007-05-08 00:37:02 -07003177 return 0;
Jiri Slaby0809e262007-05-08 00:36:14 -07003178}
3179
Linus Torvalds1da177e2005-04-16 15:20:36 -07003180/* initialize chips on Cyclom-Y card -- return number of valid
3181 chips (which is number of ports/4) */
Bill Pemberton9671f092012-11-19 13:21:50 -05003182static unsigned short cyy_init_card(void __iomem *true_base_addr,
Jiri Slaby31b4f0a2007-05-08 00:36:44 -07003183 int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003184{
Jiri Slaby02f11752006-12-08 02:39:28 -08003185 unsigned int chip_number;
3186 void __iomem *base_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003187
Jiri Slaby02f11752006-12-08 02:39:28 -08003188 cy_writeb(true_base_addr + (Cy_HwReset << index), 0);
3189 /* Cy_HwReset is 0x1400 */
3190 cy_writeb(true_base_addr + (Cy_ClrIntr << index), 0);
3191 /* Cy_ClrIntr is 0x1800 */
3192 udelay(500L);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003193
Alan Cox15ed6cc2008-04-30 00:53:55 -07003194 for (chip_number = 0; chip_number < CyMAX_CHIPS_PER_CARD;
3195 chip_number++) {
Jiri Slaby02f11752006-12-08 02:39:28 -08003196 base_addr =
3197 true_base_addr + (cy_chip_offset[chip_number] << index);
3198 mdelay(1);
Jiri Slabydb05c3b2007-05-08 00:35:46 -07003199 if (readb(base_addr + (CyCCR << index)) != 0x00) {
Jiri Slaby02f11752006-12-08 02:39:28 -08003200 /*************
3201 printk(" chip #%d at %#6lx is never idle (CCR != 0)\n",
3202 chip_number, (unsigned long)base_addr);
3203 *************/
3204 return chip_number;
3205 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003206
Jiri Slaby02f11752006-12-08 02:39:28 -08003207 cy_writeb(base_addr + (CyGFRCR << index), 0);
3208 udelay(10L);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003209
Jiri Slaby02f11752006-12-08 02:39:28 -08003210 /* The Cyclom-16Y does not decode address bit 9 and therefore
3211 cannot distinguish between references to chip 0 and a non-
3212 existent chip 4. If the preceding clearing of the supposed
3213 chip 4 GFRCR register appears at chip 0, there is no chip 4
3214 and this must be a Cyclom-16Y, not a Cyclom-32Ye.
3215 */
Jiri Slabydb05c3b2007-05-08 00:35:46 -07003216 if (chip_number == 4 && readb(true_base_addr +
Jiri Slaby02f11752006-12-08 02:39:28 -08003217 (cy_chip_offset[0] << index) +
3218 (CyGFRCR << index)) == 0) {
3219 return chip_number;
3220 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003221
Jiri Slaby02f11752006-12-08 02:39:28 -08003222 cy_writeb(base_addr + (CyCCR << index), CyCHIP_RESET);
3223 mdelay(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003224
Jiri Slabydb05c3b2007-05-08 00:35:46 -07003225 if (readb(base_addr + (CyGFRCR << index)) == 0x00) {
Jiri Slaby02f11752006-12-08 02:39:28 -08003226 /*
3227 printk(" chip #%d at %#6lx is not responding ",
3228 chip_number, (unsigned long)base_addr);
3229 printk("(GFRCR stayed 0)\n",
3230 */
3231 return chip_number;
3232 }
Jiri Slabydb05c3b2007-05-08 00:35:46 -07003233 if ((0xf0 & (readb(base_addr + (CyGFRCR << index)))) !=
Jiri Slaby02f11752006-12-08 02:39:28 -08003234 0x40) {
3235 /*
3236 printk(" chip #%d at %#6lx is not valid (GFRCR == "
3237 "%#2x)\n",
3238 chip_number, (unsigned long)base_addr,
3239 base_addr[CyGFRCR<<index]);
3240 */
3241 return chip_number;
3242 }
3243 cy_writeb(base_addr + (CyGCR << index), CyCH0_SERIAL);
Jiri Slabydb05c3b2007-05-08 00:35:46 -07003244 if (readb(base_addr + (CyGFRCR << index)) >= CD1400_REV_J) {
Jiri Slaby02f11752006-12-08 02:39:28 -08003245 /* It is a CD1400 rev. J or later */
3246 /* Impossible to reach 5ms with this chip.
3247 Changed to 2ms instead (f = 500 Hz). */
3248 cy_writeb(base_addr + (CyPPR << index), CyCLOCK_60_2MS);
3249 } else {
3250 /* f = 200 Hz */
3251 cy_writeb(base_addr + (CyPPR << index), CyCLOCK_25_5MS);
3252 }
3253
3254 /*
3255 printk(" chip #%d at %#6lx is rev 0x%2x\n",
3256 chip_number, (unsigned long)base_addr,
Jiri Slabydb05c3b2007-05-08 00:35:46 -07003257 readb(base_addr+(CyGFRCR<<index)));
Jiri Slaby02f11752006-12-08 02:39:28 -08003258 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003259 }
Jiri Slaby02f11752006-12-08 02:39:28 -08003260 return chip_number;
3261} /* cyy_init_card */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003262
3263/*
3264 * ---------------------------------------------------------------------
3265 * cy_detect_isa() - Probe for Cyclom-Y/ISA boards.
3266 * sets global variables and return the number of ISA boards found.
3267 * ---------------------------------------------------------------------
3268 */
Jiri Slaby02f11752006-12-08 02:39:28 -08003269static int __init cy_detect_isa(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003270{
3271#ifdef CONFIG_ISA
Jiri Slaby718c4ca2012-06-04 13:35:15 +02003272 struct cyclades_card *card;
Jiri Slaby02f11752006-12-08 02:39:28 -08003273 unsigned short cy_isa_irq, nboard;
3274 void __iomem *cy_isa_address;
Jiri Slaby734cc172012-08-07 21:47:47 +02003275 unsigned short i, j, k, cy_isa_nchan;
Jiri Slaby02f11752006-12-08 02:39:28 -08003276 int isparam = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003277
Jiri Slaby02f11752006-12-08 02:39:28 -08003278 nboard = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003279
Linus Torvalds1da177e2005-04-16 15:20:36 -07003280 /* Check for module parameters */
Jiri Slaby02f11752006-12-08 02:39:28 -08003281 for (i = 0; i < NR_CARDS; i++) {
3282 if (maddr[i] || i) {
3283 isparam = 1;
3284 cy_isa_addresses[i] = maddr[i];
3285 }
3286 if (!maddr[i])
3287 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003288 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003289
Jiri Slaby02f11752006-12-08 02:39:28 -08003290 /* scan the address table probing for Cyclom-Y/ISA boards */
3291 for (i = 0; i < NR_ISA_ADDRS; i++) {
3292 unsigned int isa_address = cy_isa_addresses[i];
Alan Cox15ed6cc2008-04-30 00:53:55 -07003293 if (isa_address == 0x0000)
Jiri Slaby096dcfc2006-12-08 02:39:30 -08003294 return nboard;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003295
Jiri Slaby02f11752006-12-08 02:39:28 -08003296 /* probe for CD1400... */
Alan Coxcd989b32008-04-30 00:53:56 -07003297 cy_isa_address = ioremap_nocache(isa_address, CyISA_Ywin);
Jiri Slaby31375532007-05-08 00:37:04 -07003298 if (cy_isa_address == NULL) {
3299 printk(KERN_ERR "Cyclom-Y/ISA: can't remap base "
3300 "address\n");
3301 continue;
3302 }
Jiri Slaby02f11752006-12-08 02:39:28 -08003303 cy_isa_nchan = CyPORTS_PER_CHIP *
3304 cyy_init_card(cy_isa_address, 0);
3305 if (cy_isa_nchan == 0) {
Jiri Slaby31375532007-05-08 00:37:04 -07003306 iounmap(cy_isa_address);
Jiri Slaby02f11752006-12-08 02:39:28 -08003307 continue;
3308 }
Bartlomiej Zolnierkiewicz20904362009-12-09 12:34:14 -08003309
Roel Kluin196b3162009-10-01 15:44:24 -07003310 if (isparam && i < NR_CARDS && irq[i])
Jiri Slaby02f11752006-12-08 02:39:28 -08003311 cy_isa_irq = irq[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07003312 else
Jiri Slaby02f11752006-12-08 02:39:28 -08003313 /* find out the board's irq by probing */
3314 cy_isa_irq = detect_isa_irq(cy_isa_address);
3315 if (cy_isa_irq == 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07003316 printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but the "
3317 "IRQ could not be detected.\n",
Jiri Slaby02f11752006-12-08 02:39:28 -08003318 (unsigned long)cy_isa_address);
Jiri Slaby31375532007-05-08 00:37:04 -07003319 iounmap(cy_isa_address);
Jiri Slaby02f11752006-12-08 02:39:28 -08003320 continue;
3321 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003322
Jiri Slaby02f11752006-12-08 02:39:28 -08003323 if ((cy_next_channel + cy_isa_nchan) > NR_PORTS) {
Jiri Slaby21719192007-05-08 00:36:42 -07003324 printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but no "
3325 "more channels are available. Change NR_PORTS "
3326 "in cyclades.c and recompile kernel.\n",
Jiri Slaby02f11752006-12-08 02:39:28 -08003327 (unsigned long)cy_isa_address);
Jiri Slaby31375532007-05-08 00:37:04 -07003328 iounmap(cy_isa_address);
Jiri Slaby096dcfc2006-12-08 02:39:30 -08003329 return nboard;
Jiri Slaby02f11752006-12-08 02:39:28 -08003330 }
3331 /* fill the next cy_card structure available */
3332 for (j = 0; j < NR_CARDS; j++) {
Jiri Slaby718c4ca2012-06-04 13:35:15 +02003333 card = &cy_card[j];
3334 if (card->base_addr == NULL)
Jiri Slaby02f11752006-12-08 02:39:28 -08003335 break;
3336 }
3337 if (j == NR_CARDS) { /* no more cy_cards available */
Jiri Slaby21719192007-05-08 00:36:42 -07003338 printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but no "
3339 "more cards can be used. Change NR_CARDS in "
3340 "cyclades.c and recompile kernel.\n",
Jiri Slaby02f11752006-12-08 02:39:28 -08003341 (unsigned long)cy_isa_address);
Jiri Slaby31375532007-05-08 00:37:04 -07003342 iounmap(cy_isa_address);
Jiri Slaby096dcfc2006-12-08 02:39:30 -08003343 return nboard;
Jiri Slaby02f11752006-12-08 02:39:28 -08003344 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003345
Jiri Slaby02f11752006-12-08 02:39:28 -08003346 /* allocate IRQ */
3347 if (request_irq(cy_isa_irq, cyy_interrupt,
Jiri Slaby718c4ca2012-06-04 13:35:15 +02003348 0, "Cyclom-Y", card)) {
Jiri Slaby21719192007-05-08 00:36:42 -07003349 printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but "
3350 "could not allocate IRQ#%d.\n",
3351 (unsigned long)cy_isa_address, cy_isa_irq);
Jiri Slaby31375532007-05-08 00:37:04 -07003352 iounmap(cy_isa_address);
Jiri Slaby096dcfc2006-12-08 02:39:30 -08003353 return nboard;
Jiri Slaby02f11752006-12-08 02:39:28 -08003354 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003355
Jiri Slaby02f11752006-12-08 02:39:28 -08003356 /* set cy_card */
Jiri Slaby718c4ca2012-06-04 13:35:15 +02003357 card->base_addr = cy_isa_address;
3358 card->ctl_addr.p9050 = NULL;
3359 card->irq = (int)cy_isa_irq;
3360 card->bus_index = 0;
3361 card->first_line = cy_next_channel;
3362 card->num_chips = cy_isa_nchan / CyPORTS_PER_CHIP;
3363 card->nports = cy_isa_nchan;
3364 if (cy_init_card(card)) {
3365 card->base_addr = NULL;
3366 free_irq(cy_isa_irq, card);
Jiri Slaby31375532007-05-08 00:37:04 -07003367 iounmap(cy_isa_address);
3368 continue;
3369 }
Jiri Slaby02f11752006-12-08 02:39:28 -08003370 nboard++;
3371
Jiri Slaby21719192007-05-08 00:36:42 -07003372 printk(KERN_INFO "Cyclom-Y/ISA #%d: 0x%lx-0x%lx, IRQ%d found: "
3373 "%d channels starting from port %d\n",
Jiri Slaby02f11752006-12-08 02:39:28 -08003374 j + 1, (unsigned long)cy_isa_address,
3375 (unsigned long)(cy_isa_address + (CyISA_Ywin - 1)),
Jiri Slaby21719192007-05-08 00:36:42 -07003376 cy_isa_irq, cy_isa_nchan, cy_next_channel);
3377
Jiri Slaby734cc172012-08-07 21:47:47 +02003378 for (k = 0, j = cy_next_channel;
3379 j < cy_next_channel + cy_isa_nchan; j++, k++)
3380 tty_port_register_device(&card->ports[k].port,
3381 cy_serial_driver, j, NULL);
Jiri Slaby02f11752006-12-08 02:39:28 -08003382 cy_next_channel += cy_isa_nchan;
3383 }
Jiri Slaby096dcfc2006-12-08 02:39:30 -08003384 return nboard;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003385#else
Jiri Slaby096dcfc2006-12-08 02:39:30 -08003386 return 0;
Jiri Slaby02f11752006-12-08 02:39:28 -08003387#endif /* CONFIG_ISA */
3388} /* cy_detect_isa */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003389
Jiri Slaby58936d82007-05-08 00:36:13 -07003390#ifdef CONFIG_PCI
Bill Pemberton9671f092012-11-19 13:21:50 -05003391static inline int cyc_isfwstr(const char *str, unsigned int size)
Jiri Slaby054f5b02007-07-17 04:05:16 -07003392{
3393 unsigned int a;
3394
3395 for (a = 0; a < size && *str; a++, str++)
3396 if (*str & 0x80)
3397 return -EINVAL;
3398
3399 for (; a < size; a++, str++)
3400 if (*str)
3401 return -EINVAL;
3402
3403 return 0;
3404}
3405
Bill Pemberton9671f092012-11-19 13:21:50 -05003406static inline void cyz_fpga_copy(void __iomem *fpga, const u8 *data,
Jiri Slaby054f5b02007-07-17 04:05:16 -07003407 unsigned int size)
3408{
3409 for (; size > 0; size--) {
3410 cy_writel(fpga, *data++);
3411 udelay(10);
3412 }
3413}
3414
Bill Pemberton9671f092012-11-19 13:21:50 -05003415static void plx_init(struct pci_dev *pdev, int irq,
Jiri Slaby054f5b02007-07-17 04:05:16 -07003416 struct RUNTIME_9060 __iomem *addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003417{
Jiri Slaby02f11752006-12-08 02:39:28 -08003418 /* Reset PLX */
Jiri Slaby054f5b02007-07-17 04:05:16 -07003419 cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) | 0x40000000);
Jiri Slaby02f11752006-12-08 02:39:28 -08003420 udelay(100L);
Jiri Slaby054f5b02007-07-17 04:05:16 -07003421 cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) & ~0x40000000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003422
Jiri Slaby02f11752006-12-08 02:39:28 -08003423 /* Reload Config. Registers from EEPROM */
Jiri Slaby054f5b02007-07-17 04:05:16 -07003424 cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) | 0x20000000);
Jiri Slaby02f11752006-12-08 02:39:28 -08003425 udelay(100L);
Jiri Slaby054f5b02007-07-17 04:05:16 -07003426 cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) & ~0x20000000);
3427
3428 /* For some yet unknown reason, once the PLX9060 reloads the EEPROM,
3429 * the IRQ is lost and, thus, we have to re-write it to the PCI config.
3430 * registers. This will remain here until we find a permanent fix.
3431 */
3432 pci_write_config_byte(pdev, PCI_INTERRUPT_LINE, irq);
3433}
3434
Bill Pemberton9671f092012-11-19 13:21:50 -05003435static int __cyz_load_fw(const struct firmware *fw,
Jiri Slaby054f5b02007-07-17 04:05:16 -07003436 const char *name, const u32 mailbox, void __iomem *base,
3437 void __iomem *fpga)
3438{
David Woodhousef61e7612008-05-23 23:57:19 +01003439 const void *ptr = fw->data;
3440 const struct zfile_header *h = ptr;
3441 const struct zfile_config *c, *cs;
3442 const struct zfile_block *b, *bs;
Jiri Slaby054f5b02007-07-17 04:05:16 -07003443 unsigned int a, tmp, len = fw->size;
3444#define BAD_FW KERN_ERR "Bad firmware: "
3445 if (len < sizeof(*h)) {
3446 printk(BAD_FW "too short: %u<%zu\n", len, sizeof(*h));
3447 return -EINVAL;
3448 }
3449
3450 cs = ptr + h->config_offset;
3451 bs = ptr + h->block_offset;
3452
3453 if ((void *)(cs + h->n_config) > ptr + len ||
3454 (void *)(bs + h->n_blocks) > ptr + len) {
3455 printk(BAD_FW "too short");
3456 return -EINVAL;
3457 }
3458
3459 if (cyc_isfwstr(h->name, sizeof(h->name)) ||
3460 cyc_isfwstr(h->date, sizeof(h->date))) {
3461 printk(BAD_FW "bad formatted header string\n");
3462 return -EINVAL;
3463 }
3464
3465 if (strncmp(name, h->name, sizeof(h->name))) {
3466 printk(BAD_FW "bad name '%s' (expected '%s')\n", h->name, name);
3467 return -EINVAL;
3468 }
3469
3470 tmp = 0;
3471 for (c = cs; c < cs + h->n_config; c++) {
3472 for (a = 0; a < c->n_blocks; a++)
3473 if (c->block_list[a] > h->n_blocks) {
3474 printk(BAD_FW "bad block ref number in cfgs\n");
3475 return -EINVAL;
3476 }
3477 if (c->mailbox == mailbox && c->function == 0) /* 0 is normal */
3478 tmp++;
3479 }
3480 if (!tmp) {
3481 printk(BAD_FW "nothing appropriate\n");
3482 return -EINVAL;
3483 }
3484
3485 for (b = bs; b < bs + h->n_blocks; b++)
3486 if (b->file_offset + b->size > len) {
3487 printk(BAD_FW "bad block data offset\n");
3488 return -EINVAL;
3489 }
3490
3491 /* everything is OK, let's seek'n'load it */
3492 for (c = cs; c < cs + h->n_config; c++)
3493 if (c->mailbox == mailbox && c->function == 0)
3494 break;
3495
3496 for (a = 0; a < c->n_blocks; a++) {
3497 b = &bs[c->block_list[a]];
3498 if (b->type == ZBLOCK_FPGA) {
3499 if (fpga != NULL)
3500 cyz_fpga_copy(fpga, ptr + b->file_offset,
3501 b->size);
3502 } else {
3503 if (base != NULL)
3504 memcpy_toio(base + b->ram_offset,
3505 ptr + b->file_offset, b->size);
3506 }
3507 }
3508#undef BAD_FW
3509 return 0;
3510}
3511
Bill Pemberton9671f092012-11-19 13:21:50 -05003512static int cyz_load_fw(struct pci_dev *pdev, void __iomem *base_addr,
Jiri Slaby054f5b02007-07-17 04:05:16 -07003513 struct RUNTIME_9060 __iomem *ctl_addr, int irq)
3514{
3515 const struct firmware *fw;
3516 struct FIRM_ID __iomem *fid = base_addr + ID_ADDRESS;
3517 struct CUSTOM_REG __iomem *cust = base_addr;
3518 struct ZFW_CTRL __iomem *pt_zfwctrl;
Jiri Slabyc4923b42007-07-17 04:05:17 -07003519 void __iomem *tmp;
Jiri Slaby963118e2009-06-11 12:34:27 +01003520 u32 mailbox, status, nchan;
Jiri Slaby054f5b02007-07-17 04:05:16 -07003521 unsigned int i;
3522 int retval;
3523
3524 retval = request_firmware(&fw, "cyzfirm.bin", &pdev->dev);
3525 if (retval) {
3526 dev_err(&pdev->dev, "can't get firmware\n");
3527 goto err;
3528 }
3529
3530 /* Check whether the firmware is already loaded and running. If
3531 positive, skip this board */
Jiri Slaby2693f482009-06-11 12:31:06 +01003532 if (__cyz_fpga_loaded(ctl_addr) && readl(&fid->signature) == ZFIRM_ID) {
Jiri Slaby054f5b02007-07-17 04:05:16 -07003533 u32 cntval = readl(base_addr + 0x190);
3534
3535 udelay(100);
3536 if (cntval != readl(base_addr + 0x190)) {
3537 /* FW counter is working, FW is running */
3538 dev_dbg(&pdev->dev, "Cyclades-Z FW already loaded. "
3539 "Skipping board.\n");
3540 retval = 0;
3541 goto err_rel;
3542 }
3543 }
3544
3545 /* start boot */
3546 cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) &
3547 ~0x00030800UL);
3548
3549 mailbox = readl(&ctl_addr->mail_box_0);
3550
Jiri Slaby2693f482009-06-11 12:31:06 +01003551 if (mailbox == 0 || __cyz_fpga_loaded(ctl_addr)) {
Jiri Slaby054f5b02007-07-17 04:05:16 -07003552 /* stops CPU and set window to beginning of RAM */
3553 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3554 cy_writel(&cust->cpu_stop, 0);
3555 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3556 udelay(100);
3557 }
3558
3559 plx_init(pdev, irq, ctl_addr);
3560
3561 if (mailbox != 0) {
3562 /* load FPGA */
3563 retval = __cyz_load_fw(fw, "Cyclom-Z", mailbox, NULL,
3564 base_addr);
3565 if (retval)
3566 goto err_rel;
Jiri Slaby2693f482009-06-11 12:31:06 +01003567 if (!__cyz_fpga_loaded(ctl_addr)) {
Jiri Slaby054f5b02007-07-17 04:05:16 -07003568 dev_err(&pdev->dev, "fw upload successful, but fw is "
3569 "not loaded\n");
3570 goto err_rel;
3571 }
3572 }
3573
3574 /* stops CPU and set window to beginning of RAM */
3575 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3576 cy_writel(&cust->cpu_stop, 0);
3577 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3578 udelay(100);
3579
3580 /* clear memory */
Jiri Slabyc4923b42007-07-17 04:05:17 -07003581 for (tmp = base_addr; tmp < base_addr + RAM_SIZE; tmp++)
Jiri Slaby054f5b02007-07-17 04:05:16 -07003582 cy_writeb(tmp, 255);
3583 if (mailbox != 0) {
3584 /* set window to last 512K of RAM */
3585 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM + RAM_SIZE);
Jiri Slabyc4923b42007-07-17 04:05:17 -07003586 for (tmp = base_addr; tmp < base_addr + RAM_SIZE; tmp++)
Jiri Slaby054f5b02007-07-17 04:05:16 -07003587 cy_writeb(tmp, 255);
3588 /* set window to beginning of RAM */
3589 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
Jiri Slaby054f5b02007-07-17 04:05:16 -07003590 }
3591
3592 retval = __cyz_load_fw(fw, "Cyclom-Z", mailbox, base_addr, NULL);
3593 release_firmware(fw);
3594 if (retval)
3595 goto err;
3596
3597 /* finish boot and start boards */
3598 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3599 cy_writel(&cust->cpu_start, 0);
3600 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3601 i = 0;
3602 while ((status = readl(&fid->signature)) != ZFIRM_ID && i++ < 40)
3603 msleep(100);
3604 if (status != ZFIRM_ID) {
3605 if (status == ZFIRM_HLT) {
3606 dev_err(&pdev->dev, "you need an external power supply "
3607 "for this number of ports. Firmware halted and "
3608 "board reset.\n");
3609 retval = -EIO;
3610 goto err;
3611 }
3612 dev_warn(&pdev->dev, "fid->signature = 0x%x... Waiting "
3613 "some more time\n", status);
3614 while ((status = readl(&fid->signature)) != ZFIRM_ID &&
3615 i++ < 200)
3616 msleep(100);
3617 if (status != ZFIRM_ID) {
3618 dev_err(&pdev->dev, "Board not started in 20 seconds! "
3619 "Giving up. (fid->signature = 0x%x)\n",
3620 status);
3621 dev_info(&pdev->dev, "*** Warning ***: if you are "
3622 "upgrading the FW, please power cycle the "
3623 "system before loading the new FW to the "
3624 "Cyclades-Z.\n");
3625
Jiri Slaby2693f482009-06-11 12:31:06 +01003626 if (__cyz_fpga_loaded(ctl_addr))
Jiri Slaby054f5b02007-07-17 04:05:16 -07003627 plx_init(pdev, irq, ctl_addr);
3628
3629 retval = -EIO;
3630 goto err;
3631 }
3632 dev_dbg(&pdev->dev, "Firmware started after %d seconds.\n",
3633 i / 10);
3634 }
3635 pt_zfwctrl = base_addr + readl(&fid->zfwctrl_addr);
3636
3637 dev_dbg(&pdev->dev, "fid=> %p, zfwctrl_addr=> %x, npt_zfwctrl=> %p\n",
3638 base_addr + ID_ADDRESS, readl(&fid->zfwctrl_addr),
3639 base_addr + readl(&fid->zfwctrl_addr));
3640
Jiri Slaby963118e2009-06-11 12:34:27 +01003641 nchan = readl(&pt_zfwctrl->board_ctrl.n_channel);
Jiri Slaby054f5b02007-07-17 04:05:16 -07003642 dev_info(&pdev->dev, "Cyclades-Z FW loaded: version = %x, ports = %u\n",
Jiri Slaby963118e2009-06-11 12:34:27 +01003643 readl(&pt_zfwctrl->board_ctrl.fw_version), nchan);
Jiri Slaby054f5b02007-07-17 04:05:16 -07003644
Jiri Slaby963118e2009-06-11 12:34:27 +01003645 if (nchan == 0) {
Jiri Slaby054f5b02007-07-17 04:05:16 -07003646 dev_warn(&pdev->dev, "no Cyclades-Z ports were found. Please "
3647 "check the connection between the Z host card and the "
3648 "serial expanders.\n");
3649
Jiri Slaby2693f482009-06-11 12:31:06 +01003650 if (__cyz_fpga_loaded(ctl_addr))
Jiri Slaby054f5b02007-07-17 04:05:16 -07003651 plx_init(pdev, irq, ctl_addr);
3652
3653 dev_info(&pdev->dev, "Null number of ports detected. Board "
3654 "reset.\n");
3655 retval = 0;
3656 goto err;
3657 }
3658
3659 cy_writel(&pt_zfwctrl->board_ctrl.op_system, C_OS_LINUX);
3660 cy_writel(&pt_zfwctrl->board_ctrl.dr_version, DRIVER_VERSION);
3661
3662 /*
3663 Early firmware failed to start looking for commands.
3664 This enables firmware interrupts for those commands.
3665 */
3666 cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) |
3667 (1 << 17));
3668 cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) |
3669 0x00030800UL);
3670
Jiri Slaby963118e2009-06-11 12:34:27 +01003671 return nchan;
Jiri Slaby054f5b02007-07-17 04:05:16 -07003672err_rel:
3673 release_firmware(fw);
3674err:
3675 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003676}
3677
Bill Pemberton9671f092012-11-19 13:21:50 -05003678static int cy_pci_probe(struct pci_dev *pdev,
Jiri Slaby58936d82007-05-08 00:36:13 -07003679 const struct pci_device_id *ent)
3680{
Jiri Slaby718c4ca2012-06-04 13:35:15 +02003681 struct cyclades_card *card;
Jiri Slaby31375532007-05-08 00:37:04 -07003682 void __iomem *addr0 = NULL, *addr2 = NULL;
3683 char *card_name = NULL;
Jiri Slaby101b8152009-06-11 12:30:10 +01003684 u32 uninitialized_var(mailbox);
Jiri Slaby734cc172012-08-07 21:47:47 +02003685 unsigned int device_id, nchan = 0, card_no, i, j;
Jiri Slaby31375532007-05-08 00:37:04 -07003686 unsigned char plx_ver;
3687 int retval, irq;
Jiri Slaby58936d82007-05-08 00:36:13 -07003688
3689 retval = pci_enable_device(pdev);
3690 if (retval) {
3691 dev_err(&pdev->dev, "cannot enable device\n");
Jiri Slaby31375532007-05-08 00:37:04 -07003692 goto err;
Jiri Slaby58936d82007-05-08 00:36:13 -07003693 }
3694
3695 /* read PCI configuration area */
Jiri Slaby31375532007-05-08 00:37:04 -07003696 irq = pdev->irq;
Jiri Slaby58936d82007-05-08 00:36:13 -07003697 device_id = pdev->device & ~PCI_DEVICE_ID_MASK;
3698
Jiri Slaby31375532007-05-08 00:37:04 -07003699#if defined(__alpha__)
3700 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo) { /* below 1M? */
3701 dev_err(&pdev->dev, "Cyclom-Y/PCI not supported for low "
3702 "addresses on Alpha systems.\n");
3703 retval = -EIO;
3704 goto err_dis;
3705 }
3706#endif
3707 if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Lo) {
3708 dev_err(&pdev->dev, "Cyclades-Z/PCI not supported for low "
3709 "addresses\n");
3710 retval = -EIO;
3711 goto err_dis;
3712 }
3713
3714 if (pci_resource_flags(pdev, 2) & IORESOURCE_IO) {
3715 dev_warn(&pdev->dev, "PCI I/O bit incorrectly set. Ignoring "
3716 "it...\n");
3717 pdev->resource[2].flags &= ~IORESOURCE_IO;
3718 }
3719
3720 retval = pci_request_regions(pdev, "cyclades");
3721 if (retval) {
3722 dev_err(&pdev->dev, "failed to reserve resources\n");
3723 goto err_dis;
3724 }
3725
3726 retval = -EIO;
Jiri Slaby58936d82007-05-08 00:36:13 -07003727 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3728 device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
Jiri Slaby31375532007-05-08 00:37:04 -07003729 card_name = "Cyclom-Y";
Jiri Slaby58936d82007-05-08 00:36:13 -07003730
Jiri Slaby24e6fd42008-10-13 10:34:09 +01003731 addr0 = ioremap_nocache(pci_resource_start(pdev, 0),
3732 CyPCI_Yctl);
Jiri Slaby31375532007-05-08 00:37:04 -07003733 if (addr0 == NULL) {
3734 dev_err(&pdev->dev, "can't remap ctl region\n");
3735 goto err_reg;
3736 }
Jiri Slaby24e6fd42008-10-13 10:34:09 +01003737 addr2 = ioremap_nocache(pci_resource_start(pdev, 2),
3738 CyPCI_Ywin);
Jiri Slaby31375532007-05-08 00:37:04 -07003739 if (addr2 == NULL) {
3740 dev_err(&pdev->dev, "can't remap base region\n");
3741 goto err_unmap;
Jiri Slaby58936d82007-05-08 00:36:13 -07003742 }
3743
Jiri Slaby31375532007-05-08 00:37:04 -07003744 nchan = CyPORTS_PER_CHIP * cyy_init_card(addr2, 1);
3745 if (nchan == 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07003746 dev_err(&pdev->dev, "Cyclom-Y PCI host card with no "
3747 "Serial-Modules\n");
Andrew Mortonc847d472009-01-02 13:50:07 +00003748 goto err_unmap;
Jiri Slaby58936d82007-05-08 00:36:13 -07003749 }
Jiri Slaby31375532007-05-08 00:37:04 -07003750 } else if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Hi) {
3751 struct RUNTIME_9060 __iomem *ctl_addr;
3752
Jiri Slaby24e6fd42008-10-13 10:34:09 +01003753 ctl_addr = addr0 = ioremap_nocache(pci_resource_start(pdev, 0),
3754 CyPCI_Zctl);
Jiri Slaby31375532007-05-08 00:37:04 -07003755 if (addr0 == NULL) {
3756 dev_err(&pdev->dev, "can't remap ctl region\n");
3757 goto err_reg;
Jiri Slaby58936d82007-05-08 00:36:13 -07003758 }
3759
Jiri Slaby31375532007-05-08 00:37:04 -07003760 /* Disable interrupts on the PLX before resetting it */
Jiri Slaby97e87f82009-06-11 12:29:27 +01003761 cy_writew(&ctl_addr->intr_ctrl_stat,
3762 readw(&ctl_addr->intr_ctrl_stat) & ~0x0900);
Jiri Slaby31375532007-05-08 00:37:04 -07003763
Jiri Slaby054f5b02007-07-17 04:05:16 -07003764 plx_init(pdev, irq, addr0);
Jiri Slaby31375532007-05-08 00:37:04 -07003765
Jiri Slaby101b8152009-06-11 12:30:10 +01003766 mailbox = readl(&ctl_addr->mail_box_0);
Jiri Slaby31375532007-05-08 00:37:04 -07003767
Jiri Slaby24e6fd42008-10-13 10:34:09 +01003768 addr2 = ioremap_nocache(pci_resource_start(pdev, 2),
3769 mailbox == ZE_V1 ? CyPCI_Ze_win : CyPCI_Zwin);
Jiri Slaby31375532007-05-08 00:37:04 -07003770 if (addr2 == NULL) {
3771 dev_err(&pdev->dev, "can't remap base region\n");
3772 goto err_unmap;
3773 }
3774
3775 if (mailbox == ZE_V1) {
3776 card_name = "Cyclades-Ze";
Jiri Slaby31375532007-05-08 00:37:04 -07003777 } else {
3778 card_name = "Cyclades-8Zo";
Jiri Slaby31375532007-05-08 00:37:04 -07003779#ifdef CY_PCI_DEBUG
3780 if (mailbox == ZO_V1) {
3781 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3782 dev_info(&pdev->dev, "Cyclades-8Zo/PCI: FPGA "
3783 "id %lx, ver %lx\n", (ulong)(0xff &
3784 readl(&((struct CUSTOM_REG *)addr2)->
3785 fpga_id)), (ulong)(0xff &
3786 readl(&((struct CUSTOM_REG *)addr2)->
3787 fpga_version)));
3788 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3789 } else {
3790 dev_info(&pdev->dev, "Cyclades-Z/PCI: New "
3791 "Cyclades-Z board. FPGA not loaded\n");
3792 }
3793#endif
3794 /* The following clears the firmware id word. This
3795 ensures that the driver will not attempt to talk to
3796 the board until it has been properly initialized.
3797 */
3798 if ((mailbox == ZO_V1) || (mailbox == ZO_V2))
3799 cy_writel(addr2 + ID_ADDRESS, 0L);
Jiri Slaby31375532007-05-08 00:37:04 -07003800 }
Jiri Slabyace08c32009-06-11 12:20:38 +01003801
3802 retval = cyz_load_fw(pdev, addr2, addr0, irq);
Jiri Slaby963118e2009-06-11 12:34:27 +01003803 if (retval <= 0)
Jiri Slabyace08c32009-06-11 12:20:38 +01003804 goto err_unmap;
Jiri Slaby963118e2009-06-11 12:34:27 +01003805 nchan = retval;
Jiri Slaby31375532007-05-08 00:37:04 -07003806 }
3807
3808 if ((cy_next_channel + nchan) > NR_PORTS) {
3809 dev_err(&pdev->dev, "Cyclades-8Zo/PCI found, but no "
3810 "channels are available. Change NR_PORTS in "
3811 "cyclades.c and recompile kernel.\n");
3812 goto err_unmap;
3813 }
3814 /* fill the next cy_card structure available */
3815 for (card_no = 0; card_no < NR_CARDS; card_no++) {
Jiri Slaby718c4ca2012-06-04 13:35:15 +02003816 card = &cy_card[card_no];
3817 if (card->base_addr == NULL)
Jiri Slaby31375532007-05-08 00:37:04 -07003818 break;
3819 }
3820 if (card_no == NR_CARDS) { /* no more cy_cards available */
3821 dev_err(&pdev->dev, "Cyclades-8Zo/PCI found, but no "
3822 "more cards can be used. Change NR_CARDS in "
3823 "cyclades.c and recompile kernel.\n");
3824 goto err_unmap;
3825 }
3826
3827 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3828 device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
Jiri Slaby58936d82007-05-08 00:36:13 -07003829 /* allocate IRQ */
Jiri Slaby31375532007-05-08 00:37:04 -07003830 retval = request_irq(irq, cyy_interrupt,
Jiri Slaby718c4ca2012-06-04 13:35:15 +02003831 IRQF_SHARED, "Cyclom-Y", card);
Jiri Slaby58936d82007-05-08 00:36:13 -07003832 if (retval) {
Jiri Slaby21719192007-05-08 00:36:42 -07003833 dev_err(&pdev->dev, "could not allocate IRQ\n");
Jiri Slaby31375532007-05-08 00:37:04 -07003834 goto err_unmap;
Jiri Slaby58936d82007-05-08 00:36:13 -07003835 }
Jiri Slaby718c4ca2012-06-04 13:35:15 +02003836 card->num_chips = nchan / CyPORTS_PER_CHIP;
Jiri Slaby31375532007-05-08 00:37:04 -07003837 } else {
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003838 struct FIRM_ID __iomem *firm_id = addr2 + ID_ADDRESS;
3839 struct ZFW_CTRL __iomem *zfw_ctrl;
3840
3841 zfw_ctrl = addr2 + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
3842
Jiri Slaby718c4ca2012-06-04 13:35:15 +02003843 card->hw_ver = mailbox;
3844 card->num_chips = (unsigned int)-1;
3845 card->board_ctrl = &zfw_ctrl->board_ctrl;
Jiri Slaby31375532007-05-08 00:37:04 -07003846#ifdef CONFIG_CYZ_INTR
3847 /* allocate IRQ only if board has an IRQ */
3848 if (irq != 0 && irq != 255) {
3849 retval = request_irq(irq, cyz_interrupt,
Jiri Slaby718c4ca2012-06-04 13:35:15 +02003850 IRQF_SHARED, "Cyclades-Z", card);
Jiri Slaby31375532007-05-08 00:37:04 -07003851 if (retval) {
3852 dev_err(&pdev->dev, "could not allocate IRQ\n");
3853 goto err_unmap;
3854 }
3855 }
3856#endif /* CONFIG_CYZ_INTR */
Jiri Slaby31375532007-05-08 00:37:04 -07003857 }
Jiri Slaby58936d82007-05-08 00:36:13 -07003858
Jiri Slaby31375532007-05-08 00:37:04 -07003859 /* set cy_card */
Jiri Slaby718c4ca2012-06-04 13:35:15 +02003860 card->base_addr = addr2;
3861 card->ctl_addr.p9050 = addr0;
3862 card->irq = irq;
3863 card->bus_index = 1;
3864 card->first_line = cy_next_channel;
3865 card->nports = nchan;
3866 retval = cy_init_card(card);
Jiri Slaby31375532007-05-08 00:37:04 -07003867 if (retval)
3868 goto err_null;
Jiri Slaby58936d82007-05-08 00:36:13 -07003869
Jiri Slaby718c4ca2012-06-04 13:35:15 +02003870 pci_set_drvdata(pdev, card);
Jiri Slaby31375532007-05-08 00:37:04 -07003871
3872 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3873 device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
Jiri Slaby58936d82007-05-08 00:36:13 -07003874 /* enable interrupts in the PCI interface */
Jiri Slaby31375532007-05-08 00:37:04 -07003875 plx_ver = readb(addr2 + CyPLX_VER) & 0x0f;
Jiri Slaby58936d82007-05-08 00:36:13 -07003876 switch (plx_ver) {
3877 case PLX_9050:
Jiri Slaby31375532007-05-08 00:37:04 -07003878 cy_writeb(addr0 + 0x4c, 0x43);
Jiri Slaby58936d82007-05-08 00:36:13 -07003879 break;
3880
3881 case PLX_9060:
3882 case PLX_9080:
3883 default: /* Old boards, use PLX_9060 */
Jiri Slaby97e87f82009-06-11 12:29:27 +01003884 {
3885 struct RUNTIME_9060 __iomem *ctl_addr = addr0;
3886 plx_init(pdev, irq, ctl_addr);
3887 cy_writew(&ctl_addr->intr_ctrl_stat,
3888 readw(&ctl_addr->intr_ctrl_stat) | 0x0900);
Jiri Slaby58936d82007-05-08 00:36:13 -07003889 break;
3890 }
Jiri Slaby97e87f82009-06-11 12:29:27 +01003891 }
Jiri Slaby58936d82007-05-08 00:36:13 -07003892 }
3893
Jiri Slaby31375532007-05-08 00:37:04 -07003894 dev_info(&pdev->dev, "%s/PCI #%d found: %d channels starting from "
3895 "port %d.\n", card_name, card_no + 1, nchan, cy_next_channel);
Jiri Slaby734cc172012-08-07 21:47:47 +02003896 for (j = 0, i = cy_next_channel; i < cy_next_channel + nchan; i++, j++)
3897 tty_port_register_device(&card->ports[j].port,
3898 cy_serial_driver, i, &pdev->dev);
Jiri Slaby31375532007-05-08 00:37:04 -07003899 cy_next_channel += nchan;
3900
Jiri Slaby58936d82007-05-08 00:36:13 -07003901 return 0;
Jiri Slaby31375532007-05-08 00:37:04 -07003902err_null:
Jiri Slaby718c4ca2012-06-04 13:35:15 +02003903 card->base_addr = NULL;
3904 free_irq(irq, card);
Jiri Slaby31375532007-05-08 00:37:04 -07003905err_unmap:
Jiri Slaby24e6fd42008-10-13 10:34:09 +01003906 iounmap(addr0);
Jiri Slaby31375532007-05-08 00:37:04 -07003907 if (addr2)
Jiri Slaby24e6fd42008-10-13 10:34:09 +01003908 iounmap(addr2);
Jiri Slaby31375532007-05-08 00:37:04 -07003909err_reg:
3910 pci_release_regions(pdev);
3911err_dis:
3912 pci_disable_device(pdev);
3913err:
3914 return retval;
Jiri Slaby58936d82007-05-08 00:36:13 -07003915}
Jiri Slaby58936d82007-05-08 00:36:13 -07003916
Bill Pembertonae8d8a12012-11-19 13:26:18 -05003917static void cy_pci_remove(struct pci_dev *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003918{
Jiri Slaby38d09092007-05-08 00:36:10 -07003919 struct cyclades_card *cinfo = pci_get_drvdata(pdev);
Jiri Slaby191c5f12012-11-15 09:49:56 +01003920 unsigned int i, channel;
Jiri Slaby38d09092007-05-08 00:36:10 -07003921
Jiri Slaby85c93fa2007-05-08 00:36:23 -07003922 /* non-Z with old PLX */
Jiri Slaby2693f482009-06-11 12:31:06 +01003923 if (!cy_is_Z(cinfo) && (readb(cinfo->base_addr + CyPLX_VER) & 0x0f) ==
Jiri Slabyc2ad4c72007-05-08 00:36:32 -07003924 PLX_9050)
Jiri Slaby97e87f82009-06-11 12:29:27 +01003925 cy_writeb(cinfo->ctl_addr.p9050 + 0x4c, 0);
Jiri Slaby85c93fa2007-05-08 00:36:23 -07003926 else
3927#ifndef CONFIG_CYZ_INTR
Jiri Slaby2693f482009-06-11 12:31:06 +01003928 if (!cy_is_Z(cinfo))
Jiri Slaby85c93fa2007-05-08 00:36:23 -07003929#endif
Jiri Slaby97e87f82009-06-11 12:29:27 +01003930 cy_writew(&cinfo->ctl_addr.p9060->intr_ctrl_stat,
3931 readw(&cinfo->ctl_addr.p9060->intr_ctrl_stat) &
3932 ~0x0900);
Jiri Slaby85c93fa2007-05-08 00:36:23 -07003933
Jiri Slaby24e6fd42008-10-13 10:34:09 +01003934 iounmap(cinfo->base_addr);
Jiri Slaby97e87f82009-06-11 12:29:27 +01003935 if (cinfo->ctl_addr.p9050)
3936 iounmap(cinfo->ctl_addr.p9050);
Jiri Slaby38d09092007-05-08 00:36:10 -07003937 if (cinfo->irq
3938#ifndef CONFIG_CYZ_INTR
Jiri Slaby2693f482009-06-11 12:31:06 +01003939 && !cy_is_Z(cinfo)
Jiri Slaby38d09092007-05-08 00:36:10 -07003940#endif /* CONFIG_CYZ_INTR */
3941 )
3942 free_irq(cinfo->irq, cinfo);
3943 pci_release_regions(pdev);
3944
3945 cinfo->base_addr = NULL;
Jiri Slaby191c5f12012-11-15 09:49:56 +01003946 for (channel = 0, i = cinfo->first_line; i < cinfo->first_line +
3947 cinfo->nports; i++, channel++) {
Jiri Slaby6ad1ccc2007-05-08 00:36:22 -07003948 tty_unregister_device(cy_serial_driver, i);
Jiri Slaby191c5f12012-11-15 09:49:56 +01003949 tty_port_destroy(&cinfo->ports[channel].port);
3950 }
Jiri Slabydd025c02007-05-08 00:37:02 -07003951 cinfo->nports = 0;
3952 kfree(cinfo->ports);
Jiri Slaby38d09092007-05-08 00:36:10 -07003953}
3954
Jiri Slaby6747cd92007-05-08 00:36:34 -07003955static struct pci_driver cy_pci_driver = {
3956 .name = "cyclades",
3957 .id_table = cy_pci_dev_id,
3958 .probe = cy_pci_probe,
Bill Pemberton91116cb2012-11-19 13:21:06 -05003959 .remove = cy_pci_remove
Jiri Slaby6747cd92007-05-08 00:36:34 -07003960};
3961#endif
3962
Alexey Dobriyan444697d2009-03-31 15:19:15 -07003963static int cyclades_proc_show(struct seq_file *m, void *v)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003964{
Jiri Slaby02f11752006-12-08 02:39:28 -08003965 struct cyclades_port *info;
Jiri Slabydd025c02007-05-08 00:37:02 -07003966 unsigned int i, j;
Jiri Slaby02f11752006-12-08 02:39:28 -08003967 __u32 cur_jifs = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003968
Alexey Dobriyan444697d2009-03-31 15:19:15 -07003969 seq_puts(m, "Dev TimeOpen BytesOut IdleOut BytesIn "
Jiri Slaby02f11752006-12-08 02:39:28 -08003970 "IdleIn Overruns Ldisc\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003971
Jiri Slaby02f11752006-12-08 02:39:28 -08003972 /* Output one line for each known port */
Jiri Slabydd025c02007-05-08 00:37:02 -07003973 for (i = 0; i < NR_CARDS; i++)
3974 for (j = 0; j < cy_card[i].nports; j++) {
3975 info = &cy_card[i].ports[j];
Jiri Slaby02f11752006-12-08 02:39:28 -08003976
Jiri Slabyd13549f2009-09-19 13:13:12 -07003977 if (info->port.count) {
3978 /* XXX is the ldisc num worth this? */
3979 struct tty_struct *tty;
3980 struct tty_ldisc *ld;
3981 int num = 0;
3982 tty = tty_port_tty_get(&info->port);
3983 if (tty) {
3984 ld = tty_ldisc_ref(tty);
3985 if (ld) {
3986 num = ld->ops->num;
3987 tty_ldisc_deref(ld);
3988 }
3989 tty_kref_put(tty);
3990 }
Alexey Dobriyan444697d2009-03-31 15:19:15 -07003991 seq_printf(m, "%3d %8lu %10lu %8lu "
Jiri Slabyd13549f2009-09-19 13:13:12 -07003992 "%10lu %8lu %9lu %6d\n", info->line,
Jiri Slabydd025c02007-05-08 00:37:02 -07003993 (cur_jifs - info->idle_stats.in_use) /
3994 HZ, info->idle_stats.xmit_bytes,
3995 (cur_jifs - info->idle_stats.xmit_idle)/
3996 HZ, info->idle_stats.recv_bytes,
3997 (cur_jifs - info->idle_stats.recv_idle)/
3998 HZ, info->idle_stats.overruns,
Jiri Slabyd13549f2009-09-19 13:13:12 -07003999 num);
4000 } else
Alexey Dobriyan444697d2009-03-31 15:19:15 -07004001 seq_printf(m, "%3d %8lu %10lu %8lu "
Jiri Slabydd025c02007-05-08 00:37:02 -07004002 "%10lu %8lu %9lu %6ld\n",
4003 info->line, 0L, 0L, 0L, 0L, 0L, 0L, 0L);
Jiri Slaby02f11752006-12-08 02:39:28 -08004004 }
Alexey Dobriyan444697d2009-03-31 15:19:15 -07004005 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004006}
4007
Alexey Dobriyan444697d2009-03-31 15:19:15 -07004008static int cyclades_proc_open(struct inode *inode, struct file *file)
4009{
4010 return single_open(file, cyclades_proc_show, NULL);
4011}
4012
4013static const struct file_operations cyclades_proc_fops = {
4014 .owner = THIS_MODULE,
4015 .open = cyclades_proc_open,
4016 .read = seq_read,
4017 .llseek = seq_lseek,
4018 .release = single_release,
4019};
4020
Linus Torvalds1da177e2005-04-16 15:20:36 -07004021/* The serial driver boot-time initialization code!
4022 Hardware I/O ports are mapped to character special devices on a
4023 first found, first allocated manner. That is, this code searches
4024 for Cyclom cards in the system. As each is found, it is probed
4025 to discover how many chips (and thus how many ports) are present.
4026 These ports are mapped to the tty ports 32 and upward in monotonic
4027 fashion. If an 8-port card is replaced with a 16-port card, the
4028 port mapping on a following card will shift.
4029
4030 This approach is different from what is used in the other serial
4031 device driver because the Cyclom is more properly a multiplexer,
4032 not just an aggregation of serial ports on one card.
4033
4034 If there are more cards with more ports than have been
4035 statically allocated above, a warning is printed and the
4036 extra ports are ignored.
4037 */
4038
Jeff Dikeb68e31d2006-10-02 02:17:18 -07004039static const struct tty_operations cy_ops = {
Jiri Slaby02f11752006-12-08 02:39:28 -08004040 .open = cy_open,
4041 .close = cy_close,
4042 .write = cy_write,
4043 .put_char = cy_put_char,
4044 .flush_chars = cy_flush_chars,
4045 .write_room = cy_write_room,
4046 .chars_in_buffer = cy_chars_in_buffer,
4047 .flush_buffer = cy_flush_buffer,
4048 .ioctl = cy_ioctl,
4049 .throttle = cy_throttle,
4050 .unthrottle = cy_unthrottle,
4051 .set_termios = cy_set_termios,
4052 .stop = cy_stop,
4053 .start = cy_start,
4054 .hangup = cy_hangup,
4055 .break_ctl = cy_break,
4056 .wait_until_sent = cy_wait_until_sent,
Jiri Slaby02f11752006-12-08 02:39:28 -08004057 .tiocmget = cy_tiocmget,
4058 .tiocmset = cy_tiocmset,
Alan Cox05871022010-09-16 18:21:52 +01004059 .get_icount = cy_get_icount,
Alexey Dobriyan444697d2009-03-31 15:19:15 -07004060 .proc_fops = &cyclades_proc_fops,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004061};
4062
Jiri Slaby02f11752006-12-08 02:39:28 -08004063static int __init cy_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004064{
Jiri Slabydd025c02007-05-08 00:37:02 -07004065 unsigned int nboards;
Jiri Slaby9dacf3b2007-05-08 00:36:20 -07004066 int retval = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004067
Jiri Slaby02f11752006-12-08 02:39:28 -08004068 cy_serial_driver = alloc_tty_driver(NR_PORTS);
4069 if (!cy_serial_driver)
Jiri Slaby9dacf3b2007-05-08 00:36:20 -07004070 goto err;
Jiri Slaby21719192007-05-08 00:36:42 -07004071
Michal Marek64a14b52011-04-01 12:41:20 +02004072 printk(KERN_INFO "Cyclades driver " CY_VERSION "\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004073
Jiri Slaby02f11752006-12-08 02:39:28 -08004074 /* Initialize the tty_driver structure */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004075
Jiri Slaby02f11752006-12-08 02:39:28 -08004076 cy_serial_driver->driver_name = "cyclades";
4077 cy_serial_driver->name = "ttyC";
4078 cy_serial_driver->major = CYCLADES_MAJOR;
4079 cy_serial_driver->minor_start = 0;
4080 cy_serial_driver->type = TTY_DRIVER_TYPE_SERIAL;
4081 cy_serial_driver->subtype = SERIAL_TYPE_NORMAL;
4082 cy_serial_driver->init_termios = tty_std_termios;
4083 cy_serial_driver->init_termios.c_cflag =
4084 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
Jiri Slaby6ad1ccc2007-05-08 00:36:22 -07004085 cy_serial_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
Jiri Slaby02f11752006-12-08 02:39:28 -08004086 tty_set_operations(cy_serial_driver, &cy_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004087
Jiri Slaby9dacf3b2007-05-08 00:36:20 -07004088 retval = tty_register_driver(cy_serial_driver);
4089 if (retval) {
4090 printk(KERN_ERR "Couldn't register Cyclades serial driver\n");
4091 goto err_frtty;
4092 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004093
Jiri Slaby02f11752006-12-08 02:39:28 -08004094 /* the code below is responsible to find the boards. Each different
4095 type of board has its own detection routine. If a board is found,
4096 the next cy_card structure available is set by the detection
4097 routine. These functions are responsible for checking the
4098 availability of cy_card and cy_port data structures and updating
4099 the cy_next_channel. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004100
Jiri Slaby02f11752006-12-08 02:39:28 -08004101 /* look for isa boards */
Jiri Slaby14a55a62007-05-08 00:36:18 -07004102 nboards = cy_detect_isa();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004103
Jiri Slaby6747cd92007-05-08 00:36:34 -07004104#ifdef CONFIG_PCI
Jiri Slaby02f11752006-12-08 02:39:28 -08004105 /* look for pci boards */
Jiri Slaby6747cd92007-05-08 00:36:34 -07004106 retval = pci_register_driver(&cy_pci_driver);
Jesper Juhld941ea72007-10-18 03:06:23 -07004107 if (retval && !nboards) {
4108 tty_unregister_driver(cy_serial_driver);
4109 goto err_frtty;
4110 }
Jiri Slaby6747cd92007-05-08 00:36:34 -07004111#endif
Jiri Slaby9dacf3b2007-05-08 00:36:20 -07004112
4113 return 0;
Jiri Slaby9dacf3b2007-05-08 00:36:20 -07004114err_frtty:
4115 put_tty_driver(cy_serial_driver);
4116err:
4117 return retval;
Jiri Slaby02f11752006-12-08 02:39:28 -08004118} /* cy_init */
4119
4120static void __exit cy_cleanup_module(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004121{
Jiri Slabydd025c02007-05-08 00:37:02 -07004122 struct cyclades_card *card;
Jiri Slaby65f76a82007-10-18 03:06:22 -07004123 unsigned int i, e1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004124
4125#ifndef CONFIG_CYZ_INTR
Jiri Slabyb7050902007-05-08 00:35:48 -07004126 del_timer_sync(&cyz_timerlist);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004127#endif /* CONFIG_CYZ_INTR */
4128
Alan Cox15ed6cc2008-04-30 00:53:55 -07004129 e1 = tty_unregister_driver(cy_serial_driver);
4130 if (e1)
Jiri Slaby21719192007-05-08 00:36:42 -07004131 printk(KERN_ERR "failed to unregister Cyclades serial "
4132 "driver(%d)\n", e1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004133
Jiri Slaby6747cd92007-05-08 00:36:34 -07004134#ifdef CONFIG_PCI
4135 pci_unregister_driver(&cy_pci_driver);
4136#endif
4137
Jiri Slaby02f11752006-12-08 02:39:28 -08004138 for (i = 0; i < NR_CARDS; i++) {
Jiri Slabydd025c02007-05-08 00:37:02 -07004139 card = &cy_card[i];
4140 if (card->base_addr) {
Jiri Slaby85c93fa2007-05-08 00:36:23 -07004141 /* clear interrupt */
Jiri Slabydd025c02007-05-08 00:37:02 -07004142 cy_writeb(card->base_addr + Cy_ClrIntr, 0);
4143 iounmap(card->base_addr);
Jiri Slaby97e87f82009-06-11 12:29:27 +01004144 if (card->ctl_addr.p9050)
4145 iounmap(card->ctl_addr.p9050);
Jiri Slabydd025c02007-05-08 00:37:02 -07004146 if (card->irq
Linus Torvalds1da177e2005-04-16 15:20:36 -07004147#ifndef CONFIG_CYZ_INTR
Jiri Slaby2693f482009-06-11 12:31:06 +01004148 && !cy_is_Z(card)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004149#endif /* CONFIG_CYZ_INTR */
Jiri Slaby02f11752006-12-08 02:39:28 -08004150 )
Jiri Slabydd025c02007-05-08 00:37:02 -07004151 free_irq(card->irq, card);
Jiri Slaby65f76a82007-10-18 03:06:22 -07004152 for (e1 = card->first_line; e1 < card->first_line +
Jiri Slabydd025c02007-05-08 00:37:02 -07004153 card->nports; e1++)
Jiri Slaby6ad1ccc2007-05-08 00:36:22 -07004154 tty_unregister_device(cy_serial_driver, e1);
Jiri Slabydd025c02007-05-08 00:37:02 -07004155 kfree(card->ports);
Jiri Slaby02f11752006-12-08 02:39:28 -08004156 }
4157 }
Jiri Slabyf2462bf2007-05-08 00:37:01 -07004158
4159 put_tty_driver(cy_serial_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004160} /* cy_cleanup_module */
4161
4162module_init(cy_init);
4163module_exit(cy_cleanup_module);
4164
4165MODULE_LICENSE("GPL");
Jiri Slabyc8e16932007-05-08 00:37:05 -07004166MODULE_VERSION(CY_VERSION);
Scott James Remnant9f56fad2009-04-06 17:33:04 +01004167MODULE_ALIAS_CHARDEV_MAJOR(CYCLADES_MAJOR);
Ben Hutchingse6c4ef92010-01-13 23:34:18 +00004168MODULE_FIRMWARE("cyzfirm.bin");