blob: d67e542bab1cee0a43f9b83342e99fe03e83f8d0 [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
Denys Vlasenkof25d5962015-10-27 17:39:56 +0100295static void cyy_writeb(struct cyclades_port *port, u32 reg, u8 val)
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700296{
297 struct cyclades_card *card = port->card;
298
299 cy_writeb(port->u.cyy.base_addr + (reg << card->bus_index), val);
300}
301
Denys Vlasenkof88d8682015-10-27 17:39:55 +0100302static u8 cyy_readb(struct cyclades_port *port, u32 reg)
Jiri Slaby3aeea5b2009-09-19 13:13:16 -0700303{
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
Denys Vlasenko1c823632015-10-27 18:46:33 +0100324static bool cyz_is_loaded(struct cyclades_card *card)
Jiri Slaby2693f482009-06-11 12:31:06 +0100325{
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
Denys Vlasenko8c6ba002015-10-27 17:39:57 +0100332static 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 }
Peter Hurley9db276f2016-01-10 20:36:15 -08001443 if (C_HUPCL(tty))
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
Peter Hurley9db276f2016-01-10 20:36:15 -08001472 if (C_HUPCL(tty))
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 /*
Jiri Slaby02f11752006-12-08 02:39:28 -08001580 * Start up serial port
1581 */
Jiri Slabyd13549f2009-09-19 13:13:12 -07001582 retval = cy_startup(info, tty);
Alan Cox15ed6cc2008-04-30 00:53:55 -07001583 if (retval)
Jiri Slaby02f11752006-12-08 02:39:28 -08001584 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585
Jiri Slabyf0737572009-09-19 13:13:12 -07001586 retval = tty_port_block_til_ready(&info->port, tty, filp);
Jiri Slaby02f11752006-12-08 02:39:28 -08001587 if (retval) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588#ifdef CY_DEBUG_OPEN
Jiri Slaby21719192007-05-08 00:36:42 -07001589 printk(KERN_DEBUG "cyc:cy_open returning after block_til_ready "
1590 "with %d\n", retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591#endif
Jiri Slaby02f11752006-12-08 02:39:28 -08001592 return retval;
1593 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594
Jiri Slaby02f11752006-12-08 02:39:28 -08001595 info->throttle = 0;
Jiri Slabyd13549f2009-09-19 13:13:12 -07001596 tty_port_tty_set(&info->port, tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001597
1598#ifdef CY_DEBUG_OPEN
Jiri Slaby21719192007-05-08 00:36:42 -07001599 printk(KERN_DEBUG "cyc:cy_open done\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001600#endif
Jiri Slaby02f11752006-12-08 02:39:28 -08001601 return 0;
1602} /* cy_open */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603
1604/*
1605 * cy_wait_until_sent() --- wait until the transmitter is empty
1606 */
Jiri Slaby02f11752006-12-08 02:39:28 -08001607static void cy_wait_until_sent(struct tty_struct *tty, int timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608{
Jiri Slaby875b2062007-05-08 00:36:49 -07001609 struct cyclades_card *card;
Jiri Slabycab9bdd2007-05-08 00:35:51 -07001610 struct cyclades_port *info = tty->driver_data;
Jiri Slaby02f11752006-12-08 02:39:28 -08001611 unsigned long orig_jiffies;
1612 int char_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613
Jiri Slaby02f11752006-12-08 02:39:28 -08001614 if (serial_paranoia_check(info, tty->name, "cy_wait_until_sent"))
1615 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616
Jiri Slaby02f11752006-12-08 02:39:28 -08001617 if (info->xmit_fifo_size == 0)
1618 return; /* Just in case.... */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619
Jiri Slaby02f11752006-12-08 02:39:28 -08001620 orig_jiffies = jiffies;
1621 /*
1622 * Set the check interval to be 1/5 of the estimated time to
1623 * send a single character, and make it at least 1. The check
1624 * interval should also be less than the timeout.
1625 *
1626 * Note: we have to use pretty tight timings here to satisfy
1627 * the NIST-PCTS.
1628 */
1629 char_time = (info->timeout - HZ / 50) / info->xmit_fifo_size;
1630 char_time = char_time / 5;
1631 if (char_time <= 0)
1632 char_time = 1;
1633 if (timeout < 0)
1634 timeout = 0;
1635 if (timeout)
1636 char_time = min(char_time, timeout);
1637 /*
1638 * If the transmitter hasn't cleared in twice the approximate
1639 * amount of time to send the entire FIFO, it probably won't
1640 * ever clear. This assumes the UART isn't doing flow
1641 * control, which is currently the case. Hence, if it ever
1642 * takes longer than info->timeout, this is probably due to a
1643 * UART bug of some kind. So, we clamp the timeout parameter at
1644 * 2*info->timeout.
1645 */
1646 if (!timeout || timeout > 2 * info->timeout)
1647 timeout = 2 * info->timeout;
Jiri Slaby8bab5342011-07-14 14:35:15 +02001648
Jiri Slaby02f11752006-12-08 02:39:28 -08001649 card = info->card;
Jiri Slaby2693f482009-06-11 12:31:06 +01001650 if (!cy_is_Z(card)) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07001651 while (cyy_readb(info, CySRER) & CyTxRdy) {
Jiri Slaby02f11752006-12-08 02:39:28 -08001652 if (msleep_interruptible(jiffies_to_msecs(char_time)))
1653 break;
1654 if (timeout && time_after(jiffies, orig_jiffies +
1655 timeout))
1656 break;
1657 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658 }
Jiri Slaby02f11752006-12-08 02:39:28 -08001659 /* Run one more char cycle */
1660 msleep_interruptible(jiffies_to_msecs(char_time * 5));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661}
1662
Alan Cox978e5952008-04-30 00:53:59 -07001663static void cy_flush_buffer(struct tty_struct *tty)
1664{
1665 struct cyclades_port *info = tty->driver_data;
1666 struct cyclades_card *card;
1667 int channel, retval;
1668 unsigned long flags;
1669
1670#ifdef CY_DEBUG_IO
1671 printk(KERN_DEBUG "cyc:cy_flush_buffer ttyC%d\n", info->line);
1672#endif
1673
1674 if (serial_paranoia_check(info, tty->name, "cy_flush_buffer"))
1675 return;
1676
1677 card = info->card;
1678 channel = info->line - card->first_line;
1679
1680 spin_lock_irqsave(&card->card_lock, flags);
1681 info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1682 spin_unlock_irqrestore(&card->card_lock, flags);
1683
Jiri Slaby2693f482009-06-11 12:31:06 +01001684 if (cy_is_Z(card)) { /* If it is a Z card, flush the on-board
Alan Cox978e5952008-04-30 00:53:59 -07001685 buffers as well */
1686 spin_lock_irqsave(&card->card_lock, flags);
1687 retval = cyz_issue_cmd(card, channel, C_CM_FLUSH_TX, 0L);
1688 if (retval != 0) {
1689 printk(KERN_ERR "cyc: flush_buffer retval on ttyC%d "
1690 "was %x\n", info->line, retval);
1691 }
1692 spin_unlock_irqrestore(&card->card_lock, flags);
1693 }
1694 tty_wakeup(tty);
1695} /* cy_flush_buffer */
1696
1697
Alan Coxe936ffd2009-09-19 13:13:22 -07001698static void cy_do_close(struct tty_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699{
Alan Coxe936ffd2009-09-19 13:13:22 -07001700 struct cyclades_port *info = container_of(port, struct cyclades_port,
1701 port);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001702 struct cyclades_card *card;
Jiri Slaby02f11752006-12-08 02:39:28 -08001703 unsigned long flags;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07001704 int channel;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001705
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001706 card = info->card;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07001707 channel = info->line - card->first_line;
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001708 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08001709
Jiri Slaby2693f482009-06-11 12:31:06 +01001710 if (!cy_is_Z(card)) {
Jiri Slaby02f11752006-12-08 02:39:28 -08001711 /* Stop accepting input */
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07001712 cyy_writeb(info, CyCAR, channel & 0x03);
1713 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyRxData);
Alan Cox77451e52008-07-16 21:57:02 +01001714 if (info->port.flags & ASYNC_INITIALIZED) {
Alan Cox15ed6cc2008-04-30 00:53:55 -07001715 /* Waiting for on-board buffers to be empty before
1716 closing the port */
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001717 spin_unlock_irqrestore(&card->card_lock, flags);
Alan Coxe936ffd2009-09-19 13:13:22 -07001718 cy_wait_until_sent(port->tty, info->timeout);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001719 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08001720 }
1721 } else {
1722#ifdef Z_WAKE
Alan Cox15ed6cc2008-04-30 00:53:55 -07001723 /* Waiting for on-board buffers to be empty before closing
1724 the port */
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001725 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
Jiri Slaby02f11752006-12-08 02:39:28 -08001726 int retval;
1727
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001728 if (readl(&ch_ctrl->flow_status) != C_FS_TXIDLE) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001729 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLW, 0L);
Jiri Slaby02f11752006-12-08 02:39:28 -08001730 if (retval != 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07001731 printk(KERN_DEBUG "cyc:cy_close retval on "
1732 "ttyC%d was %x\n", info->line, retval);
Jiri Slaby02f11752006-12-08 02:39:28 -08001733 }
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001734 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby2c7fea92007-05-08 00:36:51 -07001735 wait_for_completion_interruptible(&info->shutdown_wait);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001736 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08001737 }
1738#endif
1739 }
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001740 spin_unlock_irqrestore(&card->card_lock, flags);
Alan Coxe936ffd2009-09-19 13:13:22 -07001741 cy_shutdown(info, port->tty);
1742}
Jiri Slaby02f11752006-12-08 02:39:28 -08001743
Alan Coxe936ffd2009-09-19 13:13:22 -07001744/*
1745 * This routine is called when a particular tty device is closed.
1746 */
1747static void cy_close(struct tty_struct *tty, struct file *filp)
1748{
1749 struct cyclades_port *info = tty->driver_data;
1750 if (!info || serial_paranoia_check(info, tty->name, "cy_close"))
1751 return;
1752 tty_port_close(&info->port, tty, filp);
Jiri Slaby02f11752006-12-08 02:39:28 -08001753} /* cy_close */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754
1755/* This routine gets called when tty_write has put something into
1756 * the write_queue. The characters may come from user space or
1757 * kernel space.
1758 *
1759 * This routine will return the number of characters actually
1760 * accepted for writing.
1761 *
1762 * If the port is not already transmitting stuff, start it off by
1763 * enabling interrupts. The interrupt service routine will then
1764 * ensure that the characters are sent.
1765 * If the port is already active, there is no need to kick it.
1766 *
1767 */
Jiri Slaby02f11752006-12-08 02:39:28 -08001768static int cy_write(struct tty_struct *tty, const unsigned char *buf, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07001770 struct cyclades_port *info = tty->driver_data;
Jiri Slaby02f11752006-12-08 02:39:28 -08001771 unsigned long flags;
1772 int c, ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001773
1774#ifdef CY_DEBUG_IO
Jiri Slaby21719192007-05-08 00:36:42 -07001775 printk(KERN_DEBUG "cyc:cy_write ttyC%d\n", info->line);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776#endif
1777
Alan Cox15ed6cc2008-04-30 00:53:55 -07001778 if (serial_paranoia_check(info, tty->name, "cy_write"))
Jiri Slaby02f11752006-12-08 02:39:28 -08001779 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001780
Alan Cox77451e52008-07-16 21:57:02 +01001781 if (!info->port.xmit_buf)
Jiri Slaby02f11752006-12-08 02:39:28 -08001782 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001784 spin_lock_irqsave(&info->card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08001785 while (1) {
Harvey Harrison1a4e2352008-04-30 00:53:52 -07001786 c = min(count, (int)(SERIAL_XMIT_SIZE - info->xmit_cnt - 1));
1787 c = min(c, (int)(SERIAL_XMIT_SIZE - info->xmit_head));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788
Jiri Slaby02f11752006-12-08 02:39:28 -08001789 if (c <= 0)
1790 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791
Alan Cox77451e52008-07-16 21:57:02 +01001792 memcpy(info->port.xmit_buf + info->xmit_head, buf, c);
Jiri Slaby02f11752006-12-08 02:39:28 -08001793 info->xmit_head = (info->xmit_head + c) &
1794 (SERIAL_XMIT_SIZE - 1);
1795 info->xmit_cnt += c;
1796 buf += c;
1797 count -= c;
1798 ret += c;
1799 }
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001800 spin_unlock_irqrestore(&info->card->card_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801
Jiri Slaby02f11752006-12-08 02:39:28 -08001802 info->idle_stats.xmit_bytes += ret;
1803 info->idle_stats.xmit_idle = jiffies;
1804
Alan Cox15ed6cc2008-04-30 00:53:55 -07001805 if (info->xmit_cnt && !tty->stopped && !tty->hw_stopped)
Jiri Slaby02f11752006-12-08 02:39:28 -08001806 start_xmit(info);
Alan Cox15ed6cc2008-04-30 00:53:55 -07001807
Jiri Slaby02f11752006-12-08 02:39:28 -08001808 return ret;
1809} /* cy_write */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810
1811/*
1812 * This routine is called by the kernel to write a single
1813 * character to the tty device. If the kernel uses this routine,
1814 * it must call the flush_chars() routine (if defined) when it is
1815 * done stuffing characters into the driver. If there is no room
1816 * in the queue, the character is ignored.
1817 */
Alan Cox76b25a52008-04-30 00:54:03 -07001818static int cy_put_char(struct tty_struct *tty, unsigned char ch)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001819{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07001820 struct cyclades_port *info = tty->driver_data;
Jiri Slaby02f11752006-12-08 02:39:28 -08001821 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001822
1823#ifdef CY_DEBUG_IO
Jiri Slaby21719192007-05-08 00:36:42 -07001824 printk(KERN_DEBUG "cyc:cy_put_char ttyC%d\n", info->line);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825#endif
1826
Jiri Slaby02f11752006-12-08 02:39:28 -08001827 if (serial_paranoia_check(info, tty->name, "cy_put_char"))
Alan Cox76b25a52008-04-30 00:54:03 -07001828 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829
Alan Cox77451e52008-07-16 21:57:02 +01001830 if (!info->port.xmit_buf)
Alan Cox76b25a52008-04-30 00:54:03 -07001831 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001832
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001833 spin_lock_irqsave(&info->card->card_lock, flags);
Jiri Slaby90cc3012006-12-08 02:39:31 -08001834 if (info->xmit_cnt >= (int)(SERIAL_XMIT_SIZE - 1)) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07001835 spin_unlock_irqrestore(&info->card->card_lock, flags);
Alan Cox76b25a52008-04-30 00:54:03 -07001836 return 0;
Jiri Slaby02f11752006-12-08 02:39:28 -08001837 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838
Alan Cox77451e52008-07-16 21:57:02 +01001839 info->port.xmit_buf[info->xmit_head++] = ch;
Jiri Slaby02f11752006-12-08 02:39:28 -08001840 info->xmit_head &= SERIAL_XMIT_SIZE - 1;
1841 info->xmit_cnt++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842 info->idle_stats.xmit_bytes++;
1843 info->idle_stats.xmit_idle = jiffies;
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 1;
Jiri Slaby02f11752006-12-08 02:39:28 -08001846} /* cy_put_char */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847
1848/*
1849 * This routine is called by the kernel after it has written a
Alan Cox15ed6cc2008-04-30 00:53:55 -07001850 * series of characters to the tty device using put_char().
Linus Torvalds1da177e2005-04-16 15:20:36 -07001851 */
Jiri Slaby02f11752006-12-08 02:39:28 -08001852static void cy_flush_chars(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07001854 struct cyclades_port *info = tty->driver_data;
Jiri Slaby02f11752006-12-08 02:39:28 -08001855
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856#ifdef CY_DEBUG_IO
Jiri Slaby21719192007-05-08 00:36:42 -07001857 printk(KERN_DEBUG "cyc:cy_flush_chars ttyC%d\n", info->line);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001858#endif
1859
Jiri Slaby02f11752006-12-08 02:39:28 -08001860 if (serial_paranoia_check(info, tty->name, "cy_flush_chars"))
1861 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862
Jiri Slaby02f11752006-12-08 02:39:28 -08001863 if (info->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
Alan Cox77451e52008-07-16 21:57:02 +01001864 !info->port.xmit_buf)
Jiri Slaby02f11752006-12-08 02:39:28 -08001865 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866
Jiri Slaby02f11752006-12-08 02:39:28 -08001867 start_xmit(info);
1868} /* cy_flush_chars */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001869
1870/*
1871 * This routine returns the numbers of characters the tty driver
1872 * will accept for queuing to be written. This number is subject
1873 * to change as output buffers get emptied, or if the output flow
1874 * control is activated.
1875 */
Jiri Slaby02f11752006-12-08 02:39:28 -08001876static int cy_write_room(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07001878 struct cyclades_port *info = tty->driver_data;
Jiri Slaby02f11752006-12-08 02:39:28 -08001879 int ret;
1880
Linus Torvalds1da177e2005-04-16 15:20:36 -07001881#ifdef CY_DEBUG_IO
Jiri Slaby21719192007-05-08 00:36:42 -07001882 printk(KERN_DEBUG "cyc:cy_write_room ttyC%d\n", info->line);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883#endif
1884
Jiri Slaby02f11752006-12-08 02:39:28 -08001885 if (serial_paranoia_check(info, tty->name, "cy_write_room"))
1886 return 0;
1887 ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1;
1888 if (ret < 0)
1889 ret = 0;
1890 return ret;
1891} /* cy_write_room */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892
Jiri Slaby02f11752006-12-08 02:39:28 -08001893static int cy_chars_in_buffer(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07001895 struct cyclades_port *info = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001896
Jiri Slaby02f11752006-12-08 02:39:28 -08001897 if (serial_paranoia_check(info, tty->name, "cy_chars_in_buffer"))
1898 return 0;
1899
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900#ifdef Z_EXT_CHARS_IN_BUFFER
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001901 if (!cy_is_Z(info->card)) {
Jiri Slaby02f11752006-12-08 02:39:28 -08001902#endif /* Z_EXT_CHARS_IN_BUFFER */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903#ifdef CY_DEBUG_IO
Jiri Slaby21719192007-05-08 00:36:42 -07001904 printk(KERN_DEBUG "cyc:cy_chars_in_buffer ttyC%d %d\n",
1905 info->line, info->xmit_cnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906#endif
Jiri Slaby02f11752006-12-08 02:39:28 -08001907 return info->xmit_cnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908#ifdef Z_EXT_CHARS_IN_BUFFER
Jiri Slaby02f11752006-12-08 02:39:28 -08001909 } else {
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07001910 struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
Jiri Slaby02f11752006-12-08 02:39:28 -08001911 int char_count;
Jiri Slabyad39c302007-05-08 00:35:49 -07001912 __u32 tx_put, tx_get, tx_bufsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913
Jiri Slabydb05c3b2007-05-08 00:35:46 -07001914 tx_get = readl(&buf_ctrl->tx_get);
1915 tx_put = readl(&buf_ctrl->tx_put);
1916 tx_bufsize = readl(&buf_ctrl->tx_bufsize);
Jiri Slaby02f11752006-12-08 02:39:28 -08001917 if (tx_put >= tx_get)
1918 char_count = tx_put - tx_get;
1919 else
1920 char_count = tx_put - tx_get + tx_bufsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921#ifdef CY_DEBUG_IO
Jiri Slaby21719192007-05-08 00:36:42 -07001922 printk(KERN_DEBUG "cyc:cy_chars_in_buffer ttyC%d %d\n",
1923 info->line, info->xmit_cnt + char_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001924#endif
Jiri Slaby096dcfc2006-12-08 02:39:30 -08001925 return info->xmit_cnt + char_count;
Jiri Slaby02f11752006-12-08 02:39:28 -08001926 }
1927#endif /* Z_EXT_CHARS_IN_BUFFER */
1928} /* cy_chars_in_buffer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001929
1930/*
1931 * ------------------------------------------------------------
1932 * cy_ioctl() and friends
1933 * ------------------------------------------------------------
1934 */
1935
Klaus Kudielka1a86b5e2007-05-08 00:26:26 -07001936static void cyy_baud_calc(struct cyclades_port *info, __u32 baud)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937{
Jiri Slaby02f11752006-12-08 02:39:28 -08001938 int co, co_val, bpr;
Klaus Kudielka1a86b5e2007-05-08 00:26:26 -07001939 __u32 cy_clock = ((info->chip_rev >= CD1400_REV_J) ? 60000000 :
Jiri Slaby02f11752006-12-08 02:39:28 -08001940 25000000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001941
Jiri Slaby02f11752006-12-08 02:39:28 -08001942 if (baud == 0) {
1943 info->tbpr = info->tco = info->rbpr = info->rco = 0;
1944 return;
1945 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946
Jiri Slaby02f11752006-12-08 02:39:28 -08001947 /* determine which prescaler to use */
1948 for (co = 4, co_val = 2048; co; co--, co_val >>= 2) {
1949 if (cy_clock / co_val / baud > 63)
1950 break;
1951 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001952
Jiri Slaby02f11752006-12-08 02:39:28 -08001953 bpr = (cy_clock / co_val * 2 / baud + 1) / 2;
1954 if (bpr > 255)
1955 bpr = 255;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001956
Jiri Slaby02f11752006-12-08 02:39:28 -08001957 info->tbpr = info->rbpr = bpr;
1958 info->tco = info->rco = co;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001959}
1960
1961/*
1962 * This routine finds or computes the various line characteristics.
1963 * It used to be called config_setup
1964 */
Jiri Slabyd13549f2009-09-19 13:13:12 -07001965static void cy_set_line_char(struct cyclades_port *info, struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001966{
Jiri Slaby875b2062007-05-08 00:36:49 -07001967 struct cyclades_card *card;
Jiri Slaby02f11752006-12-08 02:39:28 -08001968 unsigned long flags;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07001969 int channel;
Jiri Slaby02f11752006-12-08 02:39:28 -08001970 unsigned cflag, iflag;
Jiri Slaby02f11752006-12-08 02:39:28 -08001971 int baud, baud_rate = 0;
1972 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001973
Alan Cox15ed6cc2008-04-30 00:53:55 -07001974 if (info->line == -1)
Jiri Slaby02f11752006-12-08 02:39:28 -08001975 return;
Alan Cox15ed6cc2008-04-30 00:53:55 -07001976
Alan Coxadc8d742012-07-14 15:31:47 +01001977 cflag = tty->termios.c_cflag;
1978 iflag = tty->termios.c_iflag;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979
Jiri Slaby02f11752006-12-08 02:39:28 -08001980 /*
1981 * Set up the tty->alt_speed kludge
1982 */
Jiri Slabyd13549f2009-09-19 13:13:12 -07001983 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
1984 tty->alt_speed = 57600;
1985 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
1986 tty->alt_speed = 115200;
1987 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
1988 tty->alt_speed = 230400;
1989 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
1990 tty->alt_speed = 460800;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991
Jiri Slaby02f11752006-12-08 02:39:28 -08001992 card = info->card;
Jiri Slaby875b2062007-05-08 00:36:49 -07001993 channel = info->line - card->first_line;
Jiri Slaby02f11752006-12-08 02:39:28 -08001994
Jiri Slaby2693f482009-06-11 12:31:06 +01001995 if (!cy_is_Z(card)) {
Jiri Slaby46fb7822009-09-19 13:13:17 -07001996 u32 cflags;
1997
Jiri Slaby02f11752006-12-08 02:39:28 -08001998 /* baud rate */
Jiri Slabyd13549f2009-09-19 13:13:12 -07001999 baud = tty_get_baud_rate(tty);
Alan Cox77451e52008-07-16 21:57:02 +01002000 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
Jiri Slaby02f11752006-12-08 02:39:28 -08002001 ASYNC_SPD_CUST) {
2002 if (info->custom_divisor)
2003 baud_rate = info->baud / info->custom_divisor;
2004 else
2005 baud_rate = info->baud;
2006 } else if (baud > CD1400_MAX_SPEED) {
2007 baud = CD1400_MAX_SPEED;
2008 }
2009 /* find the baud index */
2010 for (i = 0; i < 20; i++) {
Alan Cox15ed6cc2008-04-30 00:53:55 -07002011 if (baud == baud_table[i])
Jiri Slaby02f11752006-12-08 02:39:28 -08002012 break;
Jiri Slaby02f11752006-12-08 02:39:28 -08002013 }
Alan Cox15ed6cc2008-04-30 00:53:55 -07002014 if (i == 20)
Jiri Slaby02f11752006-12-08 02:39:28 -08002015 i = 19; /* CD1400_MAX_SPEED */
Jiri Slaby02f11752006-12-08 02:39:28 -08002016
Alan Cox77451e52008-07-16 21:57:02 +01002017 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
Jiri Slaby02f11752006-12-08 02:39:28 -08002018 ASYNC_SPD_CUST) {
2019 cyy_baud_calc(info, baud_rate);
2020 } else {
2021 if (info->chip_rev >= CD1400_REV_J) {
2022 /* It is a CD1400 rev. J or later */
2023 info->tbpr = baud_bpr_60[i]; /* Tx BPR */
2024 info->tco = baud_co_60[i]; /* Tx CO */
2025 info->rbpr = baud_bpr_60[i]; /* Rx BPR */
2026 info->rco = baud_co_60[i]; /* Rx CO */
2027 } else {
2028 info->tbpr = baud_bpr_25[i]; /* Tx BPR */
2029 info->tco = baud_co_25[i]; /* Tx CO */
2030 info->rbpr = baud_bpr_25[i]; /* Rx BPR */
2031 info->rco = baud_co_25[i]; /* Rx CO */
2032 }
2033 }
2034 if (baud_table[i] == 134) {
2035 /* get it right for 134.5 baud */
2036 info->timeout = (info->xmit_fifo_size * HZ * 30 / 269) +
2037 2;
Alan Cox77451e52008-07-16 21:57:02 +01002038 } else if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
Jiri Slaby02f11752006-12-08 02:39:28 -08002039 ASYNC_SPD_CUST) {
2040 info->timeout = (info->xmit_fifo_size * HZ * 15 /
2041 baud_rate) + 2;
2042 } else if (baud_table[i]) {
2043 info->timeout = (info->xmit_fifo_size * HZ * 15 /
2044 baud_table[i]) + 2;
2045 /* this needs to be propagated into the card info */
2046 } else {
2047 info->timeout = 0;
2048 }
2049 /* By tradition (is it a standard?) a baud rate of zero
2050 implies the line should be/has been closed. A bit
2051 later in this routine such a test is performed. */
2052
2053 /* byte size and parity */
2054 info->cor5 = 0;
2055 info->cor4 = 0;
2056 /* receive threshold */
2057 info->cor3 = (info->default_threshold ?
2058 info->default_threshold : baud_cor3[i]);
2059 info->cor2 = CyETC;
2060 switch (cflag & CSIZE) {
2061 case CS5:
2062 info->cor1 = Cy_5_BITS;
2063 break;
2064 case CS6:
2065 info->cor1 = Cy_6_BITS;
2066 break;
2067 case CS7:
2068 info->cor1 = Cy_7_BITS;
2069 break;
2070 case CS8:
2071 info->cor1 = Cy_8_BITS;
2072 break;
2073 }
Alan Cox15ed6cc2008-04-30 00:53:55 -07002074 if (cflag & CSTOPB)
Jiri Slaby02f11752006-12-08 02:39:28 -08002075 info->cor1 |= Cy_2_STOP;
Alan Cox15ed6cc2008-04-30 00:53:55 -07002076
Jiri Slaby02f11752006-12-08 02:39:28 -08002077 if (cflag & PARENB) {
Alan Cox15ed6cc2008-04-30 00:53:55 -07002078 if (cflag & PARODD)
Jiri Slaby02f11752006-12-08 02:39:28 -08002079 info->cor1 |= CyPARITY_O;
Alan Cox15ed6cc2008-04-30 00:53:55 -07002080 else
Jiri Slaby02f11752006-12-08 02:39:28 -08002081 info->cor1 |= CyPARITY_E;
Alan Cox15ed6cc2008-04-30 00:53:55 -07002082 } else
Jiri Slaby02f11752006-12-08 02:39:28 -08002083 info->cor1 |= CyPARITY_NONE;
Jiri Slaby02f11752006-12-08 02:39:28 -08002084
2085 /* CTS flow control flag */
2086 if (cflag & CRTSCTS) {
Alan Cox77451e52008-07-16 21:57:02 +01002087 info->port.flags |= ASYNC_CTS_FLOW;
Jiri Slaby02f11752006-12-08 02:39:28 -08002088 info->cor2 |= CyCtsAE;
2089 } else {
Alan Cox77451e52008-07-16 21:57:02 +01002090 info->port.flags &= ~ASYNC_CTS_FLOW;
Jiri Slaby02f11752006-12-08 02:39:28 -08002091 info->cor2 &= ~CyCtsAE;
2092 }
2093 if (cflag & CLOCAL)
Alan Cox77451e52008-07-16 21:57:02 +01002094 info->port.flags &= ~ASYNC_CHECK_CD;
Jiri Slaby02f11752006-12-08 02:39:28 -08002095 else
Alan Cox77451e52008-07-16 21:57:02 +01002096 info->port.flags |= ASYNC_CHECK_CD;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002097
2098 /***********************************************
2099 The hardware option, CyRtsAO, presents RTS when
2100 the chip has characters to send. Since most modems
2101 use RTS as reverse (inbound) flow control, this
2102 option is not used. If inbound flow control is
2103 necessary, DTR can be programmed to provide the
2104 appropriate signals for use with a non-standard
2105 cable. Contact Marcio Saito for details.
2106 ***********************************************/
2107
Jiri Slaby02f11752006-12-08 02:39:28 -08002108 channel &= 0x03;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002109
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002110 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002111 cyy_writeb(info, CyCAR, channel);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002112
Jiri Slaby02f11752006-12-08 02:39:28 -08002113 /* tx and rx baud rate */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002114
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002115 cyy_writeb(info, CyTCOR, info->tco);
2116 cyy_writeb(info, CyTBPR, info->tbpr);
2117 cyy_writeb(info, CyRCOR, info->rco);
2118 cyy_writeb(info, CyRBPR, info->rbpr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002119
Jiri Slaby02f11752006-12-08 02:39:28 -08002120 /* set line characteristics according configuration */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002122 cyy_writeb(info, CySCHR1, START_CHAR(tty));
2123 cyy_writeb(info, CySCHR2, STOP_CHAR(tty));
2124 cyy_writeb(info, CyCOR1, info->cor1);
2125 cyy_writeb(info, CyCOR2, info->cor2);
2126 cyy_writeb(info, CyCOR3, info->cor3);
2127 cyy_writeb(info, CyCOR4, info->cor4);
2128 cyy_writeb(info, CyCOR5, info->cor5);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002129
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002130 cyy_issue_cmd(info, CyCOR_CHANGE | CyCOR1ch | CyCOR2ch |
2131 CyCOR3ch);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132
Alan Cox15ed6cc2008-04-30 00:53:55 -07002133 /* !!! Is this needed? */
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002134 cyy_writeb(info, CyCAR, channel);
2135 cyy_writeb(info, CyRTPR,
Jiri Slaby02f11752006-12-08 02:39:28 -08002136 (info->default_timeout ? info->default_timeout : 0x02));
2137 /* 10ms rx timeout */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002138
Jiri Slaby46fb7822009-09-19 13:13:17 -07002139 cflags = CyCTS;
2140 if (!C_CLOCAL(tty))
2141 cflags |= CyDSR | CyRI | CyDCD;
2142 /* without modem intr */
2143 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyMdmCh);
2144 /* act on 1->0 modem transitions */
2145 if ((cflag & CRTSCTS) && info->rflow)
2146 cyy_writeb(info, CyMCOR1, cflags | rflow_thr[i]);
2147 else
2148 cyy_writeb(info, CyMCOR1, cflags);
2149 /* act on 0->1 modem transitions */
2150 cyy_writeb(info, CyMCOR2, cflags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002151
Jiri Slaby4d768202009-09-19 13:13:15 -07002152 if (i == 0) /* baud rate is zero, turn off line */
2153 cyy_change_rts_dtr(info, 0, TIOCM_DTR);
2154 else
2155 cyy_change_rts_dtr(info, TIOCM_DTR, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002156
Jiri Slabyd13549f2009-09-19 13:13:12 -07002157 clear_bit(TTY_IO_ERROR, &tty->flags);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002158 spin_unlock_irqrestore(&card->card_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002159
Linus Torvalds1da177e2005-04-16 15:20:36 -07002160 } else {
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07002161 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
Klaus Kudielka1a86b5e2007-05-08 00:26:26 -07002162 __u32 sw_flow;
Jiri Slaby02f11752006-12-08 02:39:28 -08002163 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002164
Jiri Slaby2693f482009-06-11 12:31:06 +01002165 if (!cyz_is_loaded(card))
Jiri Slaby02f11752006-12-08 02:39:28 -08002166 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002167
Jiri Slaby02f11752006-12-08 02:39:28 -08002168 /* baud rate */
Jiri Slabyd13549f2009-09-19 13:13:12 -07002169 baud = tty_get_baud_rate(tty);
Alan Cox77451e52008-07-16 21:57:02 +01002170 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
Jiri Slaby02f11752006-12-08 02:39:28 -08002171 ASYNC_SPD_CUST) {
2172 if (info->custom_divisor)
2173 baud_rate = info->baud / info->custom_divisor;
2174 else
2175 baud_rate = info->baud;
2176 } else if (baud > CYZ_MAX_SPEED) {
2177 baud = CYZ_MAX_SPEED;
2178 }
2179 cy_writel(&ch_ctrl->comm_baud, baud);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002180
Jiri Slaby02f11752006-12-08 02:39:28 -08002181 if (baud == 134) {
2182 /* get it right for 134.5 baud */
2183 info->timeout = (info->xmit_fifo_size * HZ * 30 / 269) +
2184 2;
Alan Cox77451e52008-07-16 21:57:02 +01002185 } else if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
Jiri Slaby02f11752006-12-08 02:39:28 -08002186 ASYNC_SPD_CUST) {
2187 info->timeout = (info->xmit_fifo_size * HZ * 15 /
2188 baud_rate) + 2;
2189 } else if (baud) {
2190 info->timeout = (info->xmit_fifo_size * HZ * 15 /
2191 baud) + 2;
2192 /* this needs to be propagated into the card info */
2193 } else {
2194 info->timeout = 0;
2195 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002196
Jiri Slaby02f11752006-12-08 02:39:28 -08002197 /* byte size and parity */
2198 switch (cflag & CSIZE) {
2199 case CS5:
2200 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS5);
2201 break;
2202 case CS6:
2203 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS6);
2204 break;
2205 case CS7:
2206 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS7);
2207 break;
2208 case CS8:
2209 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS8);
2210 break;
2211 }
2212 if (cflag & CSTOPB) {
2213 cy_writel(&ch_ctrl->comm_data_l,
Jiri Slabydb05c3b2007-05-08 00:35:46 -07002214 readl(&ch_ctrl->comm_data_l) | C_DL_2STOP);
Jiri Slaby02f11752006-12-08 02:39:28 -08002215 } else {
2216 cy_writel(&ch_ctrl->comm_data_l,
Jiri Slabydb05c3b2007-05-08 00:35:46 -07002217 readl(&ch_ctrl->comm_data_l) | C_DL_1STOP);
Jiri Slaby02f11752006-12-08 02:39:28 -08002218 }
2219 if (cflag & PARENB) {
Alan Cox15ed6cc2008-04-30 00:53:55 -07002220 if (cflag & PARODD)
Jiri Slaby02f11752006-12-08 02:39:28 -08002221 cy_writel(&ch_ctrl->comm_parity, C_PR_ODD);
Alan Cox15ed6cc2008-04-30 00:53:55 -07002222 else
Jiri Slaby02f11752006-12-08 02:39:28 -08002223 cy_writel(&ch_ctrl->comm_parity, C_PR_EVEN);
Alan Cox15ed6cc2008-04-30 00:53:55 -07002224 } else
Jiri Slaby02f11752006-12-08 02:39:28 -08002225 cy_writel(&ch_ctrl->comm_parity, C_PR_NONE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002226
Jiri Slaby02f11752006-12-08 02:39:28 -08002227 /* CTS flow control flag */
2228 if (cflag & CRTSCTS) {
2229 cy_writel(&ch_ctrl->hw_flow,
Jiri Slabydb05c3b2007-05-08 00:35:46 -07002230 readl(&ch_ctrl->hw_flow) | C_RS_CTS | C_RS_RTS);
Jiri Slaby02f11752006-12-08 02:39:28 -08002231 } else {
Jiri Slabydb05c3b2007-05-08 00:35:46 -07002232 cy_writel(&ch_ctrl->hw_flow, readl(&ch_ctrl->hw_flow) &
2233 ~(C_RS_CTS | C_RS_RTS));
Jiri Slaby02f11752006-12-08 02:39:28 -08002234 }
2235 /* As the HW flow control is done in firmware, the driver
2236 doesn't need to care about it */
Alan Cox77451e52008-07-16 21:57:02 +01002237 info->port.flags &= ~ASYNC_CTS_FLOW;
Jiri Slaby02f11752006-12-08 02:39:28 -08002238
2239 /* XON/XOFF/XANY flow control flags */
2240 sw_flow = 0;
2241 if (iflag & IXON) {
2242 sw_flow |= C_FL_OXX;
2243 if (iflag & IXANY)
2244 sw_flow |= C_FL_OIXANY;
2245 }
2246 cy_writel(&ch_ctrl->sw_flow, sw_flow);
2247
Jiri Slaby875b2062007-05-08 00:36:49 -07002248 retval = cyz_issue_cmd(card, channel, C_CM_IOCTL, 0L);
Jiri Slaby02f11752006-12-08 02:39:28 -08002249 if (retval != 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07002250 printk(KERN_ERR "cyc:set_line_char retval on ttyC%d "
2251 "was %x\n", info->line, retval);
Jiri Slaby02f11752006-12-08 02:39:28 -08002252 }
2253
2254 /* CD sensitivity */
Alan Cox15ed6cc2008-04-30 00:53:55 -07002255 if (cflag & CLOCAL)
Alan Cox77451e52008-07-16 21:57:02 +01002256 info->port.flags &= ~ASYNC_CHECK_CD;
Alan Cox15ed6cc2008-04-30 00:53:55 -07002257 else
Alan Cox77451e52008-07-16 21:57:02 +01002258 info->port.flags |= ASYNC_CHECK_CD;
Jiri Slaby02f11752006-12-08 02:39:28 -08002259
2260 if (baud == 0) { /* baud rate is zero, turn off line */
2261 cy_writel(&ch_ctrl->rs_control,
Jiri Slabydb05c3b2007-05-08 00:35:46 -07002262 readl(&ch_ctrl->rs_control) & ~C_RS_DTR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002263#ifdef CY_DEBUG_DTR
Jiri Slaby21719192007-05-08 00:36:42 -07002264 printk(KERN_DEBUG "cyc:set_line_char dropping Z DTR\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002265#endif
Jiri Slaby02f11752006-12-08 02:39:28 -08002266 } else {
2267 cy_writel(&ch_ctrl->rs_control,
Jiri Slabydb05c3b2007-05-08 00:35:46 -07002268 readl(&ch_ctrl->rs_control) | C_RS_DTR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002269#ifdef CY_DEBUG_DTR
Jiri Slaby21719192007-05-08 00:36:42 -07002270 printk(KERN_DEBUG "cyc:set_line_char raising Z DTR\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002271#endif
Jiri Slaby02f11752006-12-08 02:39:28 -08002272 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002273
Alan Cox15ed6cc2008-04-30 00:53:55 -07002274 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLM, 0L);
Jiri Slaby02f11752006-12-08 02:39:28 -08002275 if (retval != 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07002276 printk(KERN_ERR "cyc:set_line_char(2) retval on ttyC%d "
2277 "was %x\n", info->line, retval);
Jiri Slaby02f11752006-12-08 02:39:28 -08002278 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002279
Jiri Slabyd13549f2009-09-19 13:13:12 -07002280 clear_bit(TTY_IO_ERROR, &tty->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002281 }
Jiri Slaby02f11752006-12-08 02:39:28 -08002282} /* set_line_char */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002283
Jiri Slaby6c281812009-09-19 13:13:15 -07002284static int cy_get_serial_info(struct cyclades_port *info,
Alan Cox15ed6cc2008-04-30 00:53:55 -07002285 struct serial_struct __user *retinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002286{
Jiri Slaby875b2062007-05-08 00:36:49 -07002287 struct cyclades_card *cinfo = info->card;
Jiri Slaby6c281812009-09-19 13:13:15 -07002288 struct serial_struct tmp = {
2289 .type = info->type,
2290 .line = info->line,
2291 .port = (info->card - cy_card) * 0x100 + info->line -
2292 cinfo->first_line,
2293 .irq = cinfo->irq,
2294 .flags = info->port.flags,
2295 .close_delay = info->port.close_delay,
2296 .closing_wait = info->port.closing_wait,
2297 .baud_base = info->baud,
2298 .custom_divisor = info->custom_divisor,
2299 .hub6 = 0, /*!!! */
2300 };
Jiri Slaby02f11752006-12-08 02:39:28 -08002301 return copy_to_user(retinfo, &tmp, sizeof(*retinfo)) ? -EFAULT : 0;
Jiri Slaby6c281812009-09-19 13:13:15 -07002302}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002303
2304static int
Jiri Slabyd13549f2009-09-19 13:13:12 -07002305cy_set_serial_info(struct cyclades_port *info, struct tty_struct *tty,
Alan Cox15ed6cc2008-04-30 00:53:55 -07002306 struct serial_struct __user *new_info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002307{
Jiri Slaby02f11752006-12-08 02:39:28 -08002308 struct serial_struct new_serial;
Alan Cox25c3cdf2010-06-01 22:52:47 +02002309 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002310
Jiri Slaby02f11752006-12-08 02:39:28 -08002311 if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
2312 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002313
Alan Cox25c3cdf2010-06-01 22:52:47 +02002314 mutex_lock(&info->port.mutex);
Jiri Slaby02f11752006-12-08 02:39:28 -08002315 if (!capable(CAP_SYS_ADMIN)) {
Alan Cox44b7d1b2008-07-16 21:57:18 +01002316 if (new_serial.close_delay != info->port.close_delay ||
Jiri Slaby02f11752006-12-08 02:39:28 -08002317 new_serial.baud_base != info->baud ||
2318 (new_serial.flags & ASYNC_FLAGS &
2319 ~ASYNC_USR_MASK) !=
Alan Cox77451e52008-07-16 21:57:02 +01002320 (info->port.flags & ASYNC_FLAGS & ~ASYNC_USR_MASK))
Alan Cox25c3cdf2010-06-01 22:52:47 +02002321 {
2322 mutex_unlock(&info->port.mutex);
Jiri Slaby02f11752006-12-08 02:39:28 -08002323 return -EPERM;
Alan Cox25c3cdf2010-06-01 22:52:47 +02002324 }
Alan Cox77451e52008-07-16 21:57:02 +01002325 info->port.flags = (info->port.flags & ~ASYNC_USR_MASK) |
Jiri Slaby02f11752006-12-08 02:39:28 -08002326 (new_serial.flags & ASYNC_USR_MASK);
2327 info->baud = new_serial.baud_base;
2328 info->custom_divisor = new_serial.custom_divisor;
2329 goto check_and_exit;
2330 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002331
Jiri Slaby02f11752006-12-08 02:39:28 -08002332 /*
2333 * OK, past this point, all the error checking has been done.
2334 * At this point, we start making changes.....
2335 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002336
Jiri Slaby02f11752006-12-08 02:39:28 -08002337 info->baud = new_serial.baud_base;
2338 info->custom_divisor = new_serial.custom_divisor;
Alan Cox77451e52008-07-16 21:57:02 +01002339 info->port.flags = (info->port.flags & ~ASYNC_FLAGS) |
Jiri Slaby02f11752006-12-08 02:39:28 -08002340 (new_serial.flags & ASYNC_FLAGS);
Alan Cox44b7d1b2008-07-16 21:57:18 +01002341 info->port.close_delay = new_serial.close_delay * HZ / 100;
2342 info->port.closing_wait = new_serial.closing_wait * HZ / 100;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002343
2344check_and_exit:
Alan Cox77451e52008-07-16 21:57:02 +01002345 if (info->port.flags & ASYNC_INITIALIZED) {
Jiri Slabyd13549f2009-09-19 13:13:12 -07002346 cy_set_line_char(info, tty);
Alan Cox25c3cdf2010-06-01 22:52:47 +02002347 ret = 0;
Jiri Slaby02f11752006-12-08 02:39:28 -08002348 } else {
Alan Cox25c3cdf2010-06-01 22:52:47 +02002349 ret = cy_startup(info, tty);
Jiri Slaby02f11752006-12-08 02:39:28 -08002350 }
Alan Cox25c3cdf2010-06-01 22:52:47 +02002351 mutex_unlock(&info->port.mutex);
2352 return ret;
Jiri Slaby02f11752006-12-08 02:39:28 -08002353} /* set_serial_info */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002354
2355/*
2356 * get_lsr_info - get line status register info
2357 *
2358 * Purpose: Let user call ioctl() to get info when the UART physically
2359 * is emptied. On bus types like RS485, the transmitter must
2360 * release the bus after transmitting. This must be done when
2361 * the transmit shift register is empty, not be done when the
2362 * transmit holding register is empty. This functionality
2363 * allows an RS485 driver to be written in user space.
2364 */
Alan Cox15ed6cc2008-04-30 00:53:55 -07002365static int get_lsr_info(struct cyclades_port *info, unsigned int __user *value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002366{
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002367 struct cyclades_card *card = info->card;
Jiri Slaby02f11752006-12-08 02:39:28 -08002368 unsigned int result;
2369 unsigned long flags;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002370 u8 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002371
Jiri Slaby2693f482009-06-11 12:31:06 +01002372 if (!cy_is_Z(card)) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002373 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002374 status = cyy_readb(info, CySRER) & (CyTxRdy | CyTxMpty);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002375 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002376 result = (status ? 0 : TIOCSER_TEMT);
2377 } else {
2378 /* Not supported yet */
2379 return -EINVAL;
2380 }
Dan Carpenterdbca36e2012-03-05 21:07:11 +03002381 return put_user(result, value);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002382}
2383
Alan Cox60b33c12011-02-14 16:26:14 +00002384static int cy_tiocmget(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002385{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07002386 struct cyclades_port *info = tty->driver_data;
Jiri Slaby875b2062007-05-08 00:36:49 -07002387 struct cyclades_card *card;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002388 int result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002389
Harvey Harrisonbf9d8922008-04-30 00:55:10 -07002390 if (serial_paranoia_check(info, tty->name, __func__))
Jiri Slaby02f11752006-12-08 02:39:28 -08002391 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002392
Jiri Slaby02f11752006-12-08 02:39:28 -08002393 card = info->card;
Jiri Slaby0d348722009-09-19 13:13:16 -07002394
Jiri Slaby2693f482009-06-11 12:31:06 +01002395 if (!cy_is_Z(card)) {
Jiri Slaby0d348722009-09-19 13:13:16 -07002396 unsigned long flags;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002397 int channel = info->line - card->first_line;
2398 u8 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002399
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002400 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002401 cyy_writeb(info, CyCAR, channel & 0x03);
2402 status = cyy_readb(info, CyMSVR1);
2403 status |= cyy_readb(info, CyMSVR2);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002404 spin_unlock_irqrestore(&card->card_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002405
Jiri Slaby02f11752006-12-08 02:39:28 -08002406 if (info->rtsdtr_inv) {
2407 result = ((status & CyRTS) ? TIOCM_DTR : 0) |
2408 ((status & CyDTR) ? TIOCM_RTS : 0);
2409 } else {
2410 result = ((status & CyRTS) ? TIOCM_RTS : 0) |
2411 ((status & CyDTR) ? TIOCM_DTR : 0);
2412 }
2413 result |= ((status & CyDCD) ? TIOCM_CAR : 0) |
2414 ((status & CyRI) ? TIOCM_RNG : 0) |
2415 ((status & CyDSR) ? TIOCM_DSR : 0) |
2416 ((status & CyCTS) ? TIOCM_CTS : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002417 } else {
Jiri Slaby0d348722009-09-19 13:13:16 -07002418 u32 lstatus;
2419
2420 if (!cyz_is_loaded(card)) {
2421 result = -ENODEV;
2422 goto end;
Jiri Slaby02f11752006-12-08 02:39:28 -08002423 }
2424
Jiri Slaby0d348722009-09-19 13:13:16 -07002425 lstatus = readl(&info->u.cyz.ch_ctrl->rs_status);
2426 result = ((lstatus & C_RS_RTS) ? TIOCM_RTS : 0) |
2427 ((lstatus & C_RS_DTR) ? TIOCM_DTR : 0) |
2428 ((lstatus & C_RS_DCD) ? TIOCM_CAR : 0) |
2429 ((lstatus & C_RS_RI) ? TIOCM_RNG : 0) |
2430 ((lstatus & C_RS_DSR) ? TIOCM_DSR : 0) |
2431 ((lstatus & C_RS_CTS) ? TIOCM_CTS : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002432 }
Jiri Slaby0d348722009-09-19 13:13:16 -07002433end:
Jiri Slaby02f11752006-12-08 02:39:28 -08002434 return result;
2435} /* cy_tiomget */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002436
2437static int
Alan Cox20b9d172011-02-14 16:26:50 +00002438cy_tiocmset(struct tty_struct *tty,
Jiri Slaby02f11752006-12-08 02:39:28 -08002439 unsigned int set, unsigned int clear)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002440{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07002441 struct cyclades_port *info = tty->driver_data;
Jiri Slaby875b2062007-05-08 00:36:49 -07002442 struct cyclades_card *card;
Jiri Slaby02f11752006-12-08 02:39:28 -08002443 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002444
Harvey Harrisonbf9d8922008-04-30 00:55:10 -07002445 if (serial_paranoia_check(info, tty->name, __func__))
Jiri Slaby02f11752006-12-08 02:39:28 -08002446 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002447
Jiri Slaby02f11752006-12-08 02:39:28 -08002448 card = info->card;
Jiri Slaby2693f482009-06-11 12:31:06 +01002449 if (!cy_is_Z(card)) {
Jiri Slaby4d768202009-09-19 13:13:15 -07002450 spin_lock_irqsave(&card->card_lock, flags);
2451 cyy_change_rts_dtr(info, set, clear);
2452 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002453 } else {
Jiri Slaby0d348722009-09-19 13:13:16 -07002454 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
2455 int retval, channel = info->line - card->first_line;
2456 u32 rs;
Jiri Slaby02f11752006-12-08 02:39:28 -08002457
Jiri Slaby0d348722009-09-19 13:13:16 -07002458 if (!cyz_is_loaded(card))
Jiri Slaby02f11752006-12-08 02:39:28 -08002459 return -ENODEV;
Jiri Slaby0d348722009-09-19 13:13:16 -07002460
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002461 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby0d348722009-09-19 13:13:16 -07002462 rs = readl(&ch_ctrl->rs_control);
2463 if (set & TIOCM_RTS)
2464 rs |= C_RS_RTS;
2465 if (clear & TIOCM_RTS)
2466 rs &= ~C_RS_RTS;
2467 if (set & TIOCM_DTR) {
2468 rs |= C_RS_DTR;
2469#ifdef CY_DEBUG_DTR
2470 printk(KERN_DEBUG "cyc:set_modem_info raising Z DTR\n");
2471#endif
2472 }
2473 if (clear & TIOCM_DTR) {
2474 rs &= ~C_RS_DTR;
2475#ifdef CY_DEBUG_DTR
2476 printk(KERN_DEBUG "cyc:set_modem_info clearing "
2477 "Z DTR\n");
2478#endif
2479 }
2480 cy_writel(&ch_ctrl->rs_control, rs);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002481 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLM, 0L);
Jiri Slaby0d348722009-09-19 13:13:16 -07002482 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002483 if (retval != 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07002484 printk(KERN_ERR "cyc:set_modem_info retval on ttyC%d "
2485 "was %x\n", info->line, retval);
Jiri Slaby02f11752006-12-08 02:39:28 -08002486 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002487 }
Jiri Slaby02f11752006-12-08 02:39:28 -08002488 return 0;
Jiri Slaby0d348722009-09-19 13:13:16 -07002489}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002490
2491/*
2492 * cy_break() --- routine which turns the break handling on or off
2493 */
Alan Cox9e989662008-07-22 11:18:03 +01002494static int cy_break(struct tty_struct *tty, int break_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002495{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07002496 struct cyclades_port *info = tty->driver_data;
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002497 struct cyclades_card *card;
Jiri Slaby02f11752006-12-08 02:39:28 -08002498 unsigned long flags;
Alan Cox9e989662008-07-22 11:18:03 +01002499 int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002500
Jiri Slaby02f11752006-12-08 02:39:28 -08002501 if (serial_paranoia_check(info, tty->name, "cy_break"))
Alan Cox9e989662008-07-22 11:18:03 +01002502 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002503
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002504 card = info->card;
2505
2506 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby2693f482009-06-11 12:31:06 +01002507 if (!cy_is_Z(card)) {
Jiri Slaby02f11752006-12-08 02:39:28 -08002508 /* Let the transmit ISR take care of this (since it
2509 requires stuffing characters into the output stream).
2510 */
2511 if (break_state == -1) {
2512 if (!info->breakon) {
2513 info->breakon = 1;
2514 if (!info->xmit_cnt) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002515 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002516 start_xmit(info);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002517 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002518 }
2519 }
2520 } else {
2521 if (!info->breakoff) {
2522 info->breakoff = 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 }
2530 } else {
Jiri Slaby02f11752006-12-08 02:39:28 -08002531 if (break_state == -1) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002532 retval = cyz_issue_cmd(card,
2533 info->line - card->first_line,
Jiri Slaby02f11752006-12-08 02:39:28 -08002534 C_CM_SET_BREAK, 0L);
2535 if (retval != 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07002536 printk(KERN_ERR "cyc:cy_break (set) retval on "
2537 "ttyC%d was %x\n", info->line, retval);
Jiri Slaby02f11752006-12-08 02:39:28 -08002538 }
2539 } else {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002540 retval = cyz_issue_cmd(card,
2541 info->line - card->first_line,
Jiri Slaby02f11752006-12-08 02:39:28 -08002542 C_CM_CLR_BREAK, 0L);
2543 if (retval != 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07002544 printk(KERN_DEBUG "cyc:cy_break (clr) retval "
2545 "on ttyC%d was %x\n", info->line,
2546 retval);
Jiri Slaby02f11752006-12-08 02:39:28 -08002547 }
2548 }
2549 }
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002550 spin_unlock_irqrestore(&card->card_lock, flags);
Alan Cox9e989662008-07-22 11:18:03 +01002551 return retval;
Jiri Slaby02f11752006-12-08 02:39:28 -08002552} /* cy_break */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002553
Jiri Slaby02f11752006-12-08 02:39:28 -08002554static int set_threshold(struct cyclades_port *info, unsigned long value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002555{
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002556 struct cyclades_card *card = info->card;
Jiri Slaby02f11752006-12-08 02:39:28 -08002557 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002558
Jiri Slaby2693f482009-06-11 12:31:06 +01002559 if (!cy_is_Z(card)) {
Jiri Slaby02f11752006-12-08 02:39:28 -08002560 info->cor3 &= ~CyREC_FIFO;
2561 info->cor3 |= value & CyREC_FIFO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002562
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002563 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002564 cyy_writeb(info, CyCOR3, info->cor3);
2565 cyy_issue_cmd(info, CyCOR_CHANGE | CyCOR3ch);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002566 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002567 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002568 return 0;
Jiri Slaby02f11752006-12-08 02:39:28 -08002569} /* set_threshold */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002570
Alan Cox15ed6cc2008-04-30 00:53:55 -07002571static int get_threshold(struct cyclades_port *info,
2572 unsigned long __user *value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002573{
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002574 struct cyclades_card *card = info->card;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002575
Jiri Slaby2693f482009-06-11 12:31:06 +01002576 if (!cy_is_Z(card)) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002577 u8 tmp = cyy_readb(info, CyCOR3) & CyREC_FIFO;
Jiri Slaby02f11752006-12-08 02:39:28 -08002578 return put_user(tmp, value);
Jiri Slaby02f11752006-12-08 02:39:28 -08002579 }
Jiri Slabyf7429032007-05-08 00:36:59 -07002580 return 0;
Jiri Slaby02f11752006-12-08 02:39:28 -08002581} /* get_threshold */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002582
Jiri Slaby02f11752006-12-08 02:39:28 -08002583static int set_timeout(struct cyclades_port *info, unsigned long value)
2584{
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002585 struct cyclades_card *card = info->card;
Jiri Slaby02f11752006-12-08 02:39:28 -08002586 unsigned long flags;
2587
Jiri Slaby2693f482009-06-11 12:31:06 +01002588 if (!cy_is_Z(card)) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002589 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002590 cyy_writeb(info, CyRTPR, value & 0xff);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002591 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002592 }
2593 return 0;
2594} /* set_timeout */
2595
Alan Cox15ed6cc2008-04-30 00:53:55 -07002596static int get_timeout(struct cyclades_port *info,
2597 unsigned long __user *value)
Jiri Slaby02f11752006-12-08 02:39:28 -08002598{
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002599 struct cyclades_card *card = info->card;
Jiri Slaby02f11752006-12-08 02:39:28 -08002600
Jiri Slaby2693f482009-06-11 12:31:06 +01002601 if (!cy_is_Z(card)) {
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002602 u8 tmp = cyy_readb(info, CyRTPR);
Jiri Slaby02f11752006-12-08 02:39:28 -08002603 return put_user(tmp, value);
Jiri Slaby02f11752006-12-08 02:39:28 -08002604 }
Jiri Slabyf7429032007-05-08 00:36:59 -07002605 return 0;
Jiri Slaby02f11752006-12-08 02:39:28 -08002606} /* get_timeout */
2607
Jiri Slaby6c281812009-09-19 13:13:15 -07002608static int cy_cflags_changed(struct cyclades_port *info, unsigned long arg,
2609 struct cyclades_icount *cprev)
Jiri Slaby02f11752006-12-08 02:39:28 -08002610{
Jiri Slaby6c281812009-09-19 13:13:15 -07002611 struct cyclades_icount cnow;
2612 unsigned long flags;
2613 int ret;
Jiri Slaby02f11752006-12-08 02:39:28 -08002614
Jiri Slaby6c281812009-09-19 13:13:15 -07002615 spin_lock_irqsave(&info->card->card_lock, flags);
2616 cnow = info->icount; /* atomic copy */
2617 spin_unlock_irqrestore(&info->card->card_lock, flags);
2618
2619 ret = ((arg & TIOCM_RNG) && (cnow.rng != cprev->rng)) ||
2620 ((arg & TIOCM_DSR) && (cnow.dsr != cprev->dsr)) ||
2621 ((arg & TIOCM_CD) && (cnow.dcd != cprev->dcd)) ||
2622 ((arg & TIOCM_CTS) && (cnow.cts != cprev->cts));
2623
2624 *cprev = cnow;
2625
2626 return ret;
2627}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002628
2629/*
2630 * This routine allows the tty driver to implement device-
2631 * specific ioctl's. If the ioctl number passed in cmd is
2632 * not recognized by the driver, it should return ENOIOCTLCMD.
2633 */
2634static int
Alan Cox6caa76b2011-02-14 16:27:22 +00002635cy_ioctl(struct tty_struct *tty,
Jiri Slaby02f11752006-12-08 02:39:28 -08002636 unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002637{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07002638 struct cyclades_port *info = tty->driver_data;
Jiri Slaby6c281812009-09-19 13:13:15 -07002639 struct cyclades_icount cnow; /* kernel counter temps */
Jiri Slaby02f11752006-12-08 02:39:28 -08002640 int ret_val = 0;
2641 unsigned long flags;
2642 void __user *argp = (void __user *)arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002643
Jiri Slaby02f11752006-12-08 02:39:28 -08002644 if (serial_paranoia_check(info, tty->name, "cy_ioctl"))
2645 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002646
2647#ifdef CY_DEBUG_OTHER
Jiri Slaby21719192007-05-08 00:36:42 -07002648 printk(KERN_DEBUG "cyc:cy_ioctl ttyC%d, cmd = %x arg = %lx\n",
2649 info->line, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002650#endif
2651
Jiri Slaby02f11752006-12-08 02:39:28 -08002652 switch (cmd) {
2653 case CYGETMON:
Jiri Slaby6c281812009-09-19 13:13:15 -07002654 if (copy_to_user(argp, &info->mon, sizeof(info->mon))) {
2655 ret_val = -EFAULT;
2656 break;
2657 }
2658 memset(&info->mon, 0, sizeof(info->mon));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002659 break;
Jiri Slaby02f11752006-12-08 02:39:28 -08002660 case CYGETTHRESH:
2661 ret_val = get_threshold(info, argp);
2662 break;
2663 case CYSETTHRESH:
2664 ret_val = set_threshold(info, arg);
2665 break;
2666 case CYGETDEFTHRESH:
Jiri Slaby6c281812009-09-19 13:13:15 -07002667 ret_val = put_user(info->default_threshold,
2668 (unsigned long __user *)argp);
Jiri Slaby02f11752006-12-08 02:39:28 -08002669 break;
2670 case CYSETDEFTHRESH:
Jiri Slaby6c281812009-09-19 13:13:15 -07002671 info->default_threshold = arg & 0x0f;
Jiri Slaby02f11752006-12-08 02:39:28 -08002672 break;
2673 case CYGETTIMEOUT:
2674 ret_val = get_timeout(info, argp);
2675 break;
2676 case CYSETTIMEOUT:
2677 ret_val = set_timeout(info, arg);
2678 break;
2679 case CYGETDEFTIMEOUT:
Jiri Slaby6c281812009-09-19 13:13:15 -07002680 ret_val = put_user(info->default_timeout,
2681 (unsigned long __user *)argp);
Jiri Slaby02f11752006-12-08 02:39:28 -08002682 break;
2683 case CYSETDEFTIMEOUT:
Jiri Slaby6c281812009-09-19 13:13:15 -07002684 info->default_timeout = arg & 0xff;
Jiri Slaby02f11752006-12-08 02:39:28 -08002685 break;
2686 case CYSETRFLOW:
2687 info->rflow = (int)arg;
Jiri Slaby02f11752006-12-08 02:39:28 -08002688 break;
2689 case CYGETRFLOW:
2690 ret_val = info->rflow;
2691 break;
2692 case CYSETRTSDTR_INV:
2693 info->rtsdtr_inv = (int)arg;
Jiri Slaby02f11752006-12-08 02:39:28 -08002694 break;
2695 case CYGETRTSDTR_INV:
2696 ret_val = info->rtsdtr_inv;
2697 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002698 case CYGETCD1400VER:
Jiri Slaby02f11752006-12-08 02:39:28 -08002699 ret_val = info->chip_rev;
2700 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002701#ifndef CONFIG_CYZ_INTR
2702 case CYZSETPOLLCYCLE:
Qixue Xiao351d6202013-12-20 17:51:12 +08002703 if (arg > LONG_MAX / HZ)
2704 return -ENODEV;
Jiri Slaby02f11752006-12-08 02:39:28 -08002705 cyz_polling_cycle = (arg * HZ) / 1000;
Jiri Slaby02f11752006-12-08 02:39:28 -08002706 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002707 case CYZGETPOLLCYCLE:
Jiri Slaby02f11752006-12-08 02:39:28 -08002708 ret_val = (cyz_polling_cycle * 1000) / HZ;
2709 break;
2710#endif /* CONFIG_CYZ_INTR */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002711 case CYSETWAIT:
Alan Cox44b7d1b2008-07-16 21:57:18 +01002712 info->port.closing_wait = (unsigned short)arg * HZ / 100;
Jiri Slaby02f11752006-12-08 02:39:28 -08002713 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002714 case CYGETWAIT:
Alan Cox44b7d1b2008-07-16 21:57:18 +01002715 ret_val = info->port.closing_wait / (HZ / 100);
Jiri Slaby02f11752006-12-08 02:39:28 -08002716 break;
2717 case TIOCGSERIAL:
Jiri Slaby6c281812009-09-19 13:13:15 -07002718 ret_val = cy_get_serial_info(info, argp);
Jiri Slaby02f11752006-12-08 02:39:28 -08002719 break;
2720 case TIOCSSERIAL:
Jiri Slabyd13549f2009-09-19 13:13:12 -07002721 ret_val = cy_set_serial_info(info, tty, argp);
Jiri Slaby02f11752006-12-08 02:39:28 -08002722 break;
2723 case TIOCSERGETLSR: /* Get line status register */
2724 ret_val = get_lsr_info(info, argp);
2725 break;
2726 /*
2727 * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
2728 * - mask passed in arg for lines of interest
2729 * (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
2730 * Caller should use TIOCGICOUNT to see which one it was
2731 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002732 case TIOCMIWAIT:
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002733 spin_lock_irqsave(&info->card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002734 /* note the counters on entry */
Jiri Slaby2c7fea92007-05-08 00:36:51 -07002735 cnow = info->icount;
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002736 spin_unlock_irqrestore(&info->card->card_lock, flags);
Alan Coxbdc04e32009-09-19 13:13:31 -07002737 ret_val = wait_event_interruptible(info->port.delta_msr_wait,
Jiri Slaby6c281812009-09-19 13:13:15 -07002738 cy_cflags_changed(info, arg, &cnow));
Jiri Slaby2c7fea92007-05-08 00:36:51 -07002739 break;
Jiri Slaby02f11752006-12-08 02:39:28 -08002740
2741 /*
2742 * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
2743 * Return: write counters to the user passed counter struct
2744 * NB: both 1->0 and 0->1 transitions are counted except for
2745 * RI where only 0->1 is counted.
2746 */
Jiri Slaby02f11752006-12-08 02:39:28 -08002747 default:
2748 ret_val = -ENOIOCTLCMD;
2749 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002750
2751#ifdef CY_DEBUG_OTHER
Jiri Slaby21719192007-05-08 00:36:42 -07002752 printk(KERN_DEBUG "cyc:cy_ioctl done\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002753#endif
Jiri Slaby02f11752006-12-08 02:39:28 -08002754 return ret_val;
2755} /* cy_ioctl */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002756
Alan Cox05871022010-09-16 18:21:52 +01002757static int cy_get_icount(struct tty_struct *tty,
2758 struct serial_icounter_struct *sic)
2759{
2760 struct cyclades_port *info = tty->driver_data;
2761 struct cyclades_icount cnow; /* Used to snapshot */
2762 unsigned long flags;
2763
2764 spin_lock_irqsave(&info->card->card_lock, flags);
2765 cnow = info->icount;
2766 spin_unlock_irqrestore(&info->card->card_lock, flags);
2767
2768 sic->cts = cnow.cts;
2769 sic->dsr = cnow.dsr;
2770 sic->rng = cnow.rng;
2771 sic->dcd = cnow.dcd;
2772 sic->rx = cnow.rx;
2773 sic->tx = cnow.tx;
2774 sic->frame = cnow.frame;
2775 sic->overrun = cnow.overrun;
2776 sic->parity = cnow.parity;
2777 sic->brk = cnow.brk;
2778 sic->buf_overrun = cnow.buf_overrun;
2779 return 0;
2780}
2781
Linus Torvalds1da177e2005-04-16 15:20:36 -07002782/*
2783 * This routine allows the tty driver to be notified when
2784 * device's termios settings have changed. Note that a
2785 * well-designed tty driver should be prepared to accept the case
2786 * where old == NULL, and try to do something rational.
2787 */
Jiri Slaby02f11752006-12-08 02:39:28 -08002788static void cy_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002789{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07002790 struct cyclades_port *info = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002791
2792#ifdef CY_DEBUG_OTHER
Jiri Slaby21719192007-05-08 00:36:42 -07002793 printk(KERN_DEBUG "cyc:cy_set_termios ttyC%d\n", info->line);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002794#endif
2795
Jiri Slabyd13549f2009-09-19 13:13:12 -07002796 cy_set_line_char(info, tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002797
Peter Hurley9db276f2016-01-10 20:36:15 -08002798 if ((old_termios->c_cflag & CRTSCTS) && !C_CRTSCTS(tty)) {
Jiri Slaby02f11752006-12-08 02:39:28 -08002799 tty->hw_stopped = 0;
2800 cy_start(tty);
2801 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002802#if 0
Jiri Slaby02f11752006-12-08 02:39:28 -08002803 /*
2804 * No need to wake up processes in open wait, since they
2805 * sample the CLOCAL flag once, and don't recheck it.
2806 * XXX It's not clear whether the current behavior is correct
2807 * or not. Hence, this may change.....
2808 */
Peter Hurley9db276f2016-01-10 20:36:15 -08002809 if (!(old_termios->c_cflag & CLOCAL) && C_CLOCAL(tty))
Alan Cox77451e52008-07-16 21:57:02 +01002810 wake_up_interruptible(&info->port.open_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002811#endif
Jiri Slaby02f11752006-12-08 02:39:28 -08002812} /* cy_set_termios */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002813
2814/* This function is used to send a high-priority XON/XOFF character to
2815 the device.
2816*/
Jiri Slaby02f11752006-12-08 02:39:28 -08002817static void cy_send_xchar(struct tty_struct *tty, char ch)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002818{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07002819 struct cyclades_port *info = tty->driver_data;
Jiri Slaby875b2062007-05-08 00:36:49 -07002820 struct cyclades_card *card;
2821 int channel;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002822
Jiri Slaby02f11752006-12-08 02:39:28 -08002823 if (serial_paranoia_check(info, tty->name, "cy_send_xchar"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002824 return;
2825
Jiri Slaby02f11752006-12-08 02:39:28 -08002826 info->x_char = ch;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002827
2828 if (ch)
Jiri Slaby02f11752006-12-08 02:39:28 -08002829 cy_start(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002830
2831 card = info->card;
Jiri Slaby875b2062007-05-08 00:36:49 -07002832 channel = info->line - card->first_line;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002833
Jiri Slaby2693f482009-06-11 12:31:06 +01002834 if (cy_is_Z(card)) {
Jiri Slaby02f11752006-12-08 02:39:28 -08002835 if (ch == STOP_CHAR(tty))
Jiri Slaby875b2062007-05-08 00:36:49 -07002836 cyz_issue_cmd(card, channel, C_CM_SENDXOFF, 0L);
Jiri Slaby02f11752006-12-08 02:39:28 -08002837 else if (ch == START_CHAR(tty))
Jiri Slaby875b2062007-05-08 00:36:49 -07002838 cyz_issue_cmd(card, channel, C_CM_SENDXON, 0L);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002839 }
2840}
2841
2842/* This routine is called by the upper-layer tty layer to signal
2843 that incoming characters should be throttled because the input
2844 buffers are close to full.
2845 */
Jiri Slaby02f11752006-12-08 02:39:28 -08002846static void cy_throttle(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002847{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07002848 struct cyclades_port *info = tty->driver_data;
Jiri Slaby875b2062007-05-08 00:36:49 -07002849 struct cyclades_card *card;
Jiri Slaby02f11752006-12-08 02:39:28 -08002850 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002851
2852#ifdef CY_DEBUG_THROTTLE
Peter Hurleyfdfb7192016-01-10 22:40:54 -08002853 printk(KERN_DEBUG "cyc:throttle %s ...ttyC%d\n", tty_name(tty),
2854 info->line);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002855#endif
2856
Alan Cox15ed6cc2008-04-30 00:53:55 -07002857 if (serial_paranoia_check(info, tty->name, "cy_throttle"))
Jiri Slaby02f11752006-12-08 02:39:28 -08002858 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002859
Jiri Slaby02f11752006-12-08 02:39:28 -08002860 card = info->card;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002861
Jiri Slaby02f11752006-12-08 02:39:28 -08002862 if (I_IXOFF(tty)) {
Jiri Slaby2693f482009-06-11 12:31:06 +01002863 if (!cy_is_Z(card))
Jiri Slaby02f11752006-12-08 02:39:28 -08002864 cy_send_xchar(tty, STOP_CHAR(tty));
2865 else
2866 info->throttle = 1;
2867 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002868
Peter Hurley9db276f2016-01-10 20:36:15 -08002869 if (C_CRTSCTS(tty)) {
Jiri Slaby2693f482009-06-11 12:31:06 +01002870 if (!cy_is_Z(card)) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002871 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby4d768202009-09-19 13:13:15 -07002872 cyy_change_rts_dtr(info, 0, TIOCM_RTS);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002873 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002874 } else {
2875 info->throttle = 1;
2876 }
2877 }
Jiri Slaby02f11752006-12-08 02:39:28 -08002878} /* cy_throttle */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002879
2880/*
2881 * This routine notifies the tty driver that it should signal
2882 * that characters can now be sent to the tty without fear of
2883 * overrunning the input buffers of the line disciplines.
2884 */
Jiri Slaby02f11752006-12-08 02:39:28 -08002885static void cy_unthrottle(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002886{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07002887 struct cyclades_port *info = tty->driver_data;
Jiri Slaby875b2062007-05-08 00:36:49 -07002888 struct cyclades_card *card;
Jiri Slaby02f11752006-12-08 02:39:28 -08002889 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002890
2891#ifdef CY_DEBUG_THROTTLE
Peter Hurleyfdfb7192016-01-10 22:40:54 -08002892 printk(KERN_DEBUG "cyc:unthrottle %s ...ttyC%d\n",
2893 tty_name(tty), info->line);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002894#endif
2895
Alan Cox15ed6cc2008-04-30 00:53:55 -07002896 if (serial_paranoia_check(info, tty->name, "cy_unthrottle"))
Jiri Slaby02f11752006-12-08 02:39:28 -08002897 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002898
Jiri Slaby02f11752006-12-08 02:39:28 -08002899 if (I_IXOFF(tty)) {
2900 if (info->x_char)
2901 info->x_char = 0;
2902 else
2903 cy_send_xchar(tty, START_CHAR(tty));
2904 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002905
Peter Hurley9db276f2016-01-10 20:36:15 -08002906 if (C_CRTSCTS(tty)) {
Jiri Slaby02f11752006-12-08 02:39:28 -08002907 card = info->card;
Jiri Slaby2693f482009-06-11 12:31:06 +01002908 if (!cy_is_Z(card)) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002909 spin_lock_irqsave(&card->card_lock, flags);
Jiri Slaby4d768202009-09-19 13:13:15 -07002910 cyy_change_rts_dtr(info, TIOCM_RTS, 0);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002911 spin_unlock_irqrestore(&card->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002912 } else {
2913 info->throttle = 0;
2914 }
2915 }
Jiri Slaby02f11752006-12-08 02:39:28 -08002916} /* cy_unthrottle */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002917
2918/* cy_start and cy_stop provide software output flow control as a
2919 function of XON/XOFF, software CTS, and other such stuff.
2920*/
Jiri Slaby02f11752006-12-08 02:39:28 -08002921static void cy_stop(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002922{
Jiri Slaby02f11752006-12-08 02:39:28 -08002923 struct cyclades_card *cinfo;
Jiri Slabycab9bdd2007-05-08 00:35:51 -07002924 struct cyclades_port *info = tty->driver_data;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002925 int channel;
Jiri Slaby02f11752006-12-08 02:39:28 -08002926 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002927
2928#ifdef CY_DEBUG_OTHER
Jiri Slaby21719192007-05-08 00:36:42 -07002929 printk(KERN_DEBUG "cyc:cy_stop ttyC%d\n", info->line);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002930#endif
2931
Jiri Slaby02f11752006-12-08 02:39:28 -08002932 if (serial_paranoia_check(info, tty->name, "cy_stop"))
2933 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002934
Jiri Slaby875b2062007-05-08 00:36:49 -07002935 cinfo = info->card;
Jiri Slaby02f11752006-12-08 02:39:28 -08002936 channel = info->line - cinfo->first_line;
Jiri Slaby2693f482009-06-11 12:31:06 +01002937 if (!cy_is_Z(cinfo)) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002938 spin_lock_irqsave(&cinfo->card_lock, flags);
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002939 cyy_writeb(info, CyCAR, channel & 0x03);
2940 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyTxRdy);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002941 spin_unlock_irqrestore(&cinfo->card_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002942 }
Jiri Slaby02f11752006-12-08 02:39:28 -08002943} /* cy_stop */
2944
2945static void cy_start(struct tty_struct *tty)
2946{
2947 struct cyclades_card *cinfo;
Jiri Slabycab9bdd2007-05-08 00:35:51 -07002948 struct cyclades_port *info = tty->driver_data;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002949 int channel;
Jiri Slaby02f11752006-12-08 02:39:28 -08002950 unsigned long flags;
2951
2952#ifdef CY_DEBUG_OTHER
Jiri Slaby21719192007-05-08 00:36:42 -07002953 printk(KERN_DEBUG "cyc:cy_start ttyC%d\n", info->line);
Jiri Slaby02f11752006-12-08 02:39:28 -08002954#endif
2955
2956 if (serial_paranoia_check(info, tty->name, "cy_start"))
2957 return;
2958
Jiri Slaby875b2062007-05-08 00:36:49 -07002959 cinfo = info->card;
Jiri Slaby02f11752006-12-08 02:39:28 -08002960 channel = info->line - cinfo->first_line;
Jiri Slaby2693f482009-06-11 12:31:06 +01002961 if (!cy_is_Z(cinfo)) {
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002962 spin_lock_irqsave(&cinfo->card_lock, flags);
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002963 cyy_writeb(info, CyCAR, channel & 0x03);
2964 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyTxRdy);
Jiri Slaby9fa1b3b182007-05-08 00:36:57 -07002965 spin_unlock_irqrestore(&cinfo->card_lock, flags);
Jiri Slaby02f11752006-12-08 02:39:28 -08002966 }
Jiri Slaby02f11752006-12-08 02:39:28 -08002967} /* cy_start */
2968
Linus Torvalds1da177e2005-04-16 15:20:36 -07002969/*
2970 * cy_hangup() --- called by tty_hangup() when a hangup is signaled.
2971 */
Jiri Slaby02f11752006-12-08 02:39:28 -08002972static void cy_hangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002973{
Jiri Slabycab9bdd2007-05-08 00:35:51 -07002974 struct cyclades_port *info = tty->driver_data;
Jiri Slaby02f11752006-12-08 02:39:28 -08002975
Linus Torvalds1da177e2005-04-16 15:20:36 -07002976#ifdef CY_DEBUG_OTHER
Jiri Slaby21719192007-05-08 00:36:42 -07002977 printk(KERN_DEBUG "cyc:cy_hangup ttyC%d\n", info->line);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002978#endif
2979
Jiri Slaby02f11752006-12-08 02:39:28 -08002980 if (serial_paranoia_check(info, tty->name, "cy_hangup"))
2981 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002982
Jiri Slaby02f11752006-12-08 02:39:28 -08002983 cy_flush_buffer(tty);
Jiri Slabyd13549f2009-09-19 13:13:12 -07002984 cy_shutdown(info, tty);
Jiri Slaby174e6fe2009-09-19 13:13:13 -07002985 tty_port_hangup(&info->port);
Jiri Slaby02f11752006-12-08 02:39:28 -08002986} /* cy_hangup */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002987
Jiri Slabyf0737572009-09-19 13:13:12 -07002988static int cyy_carrier_raised(struct tty_port *port)
2989{
2990 struct cyclades_port *info = container_of(port, struct cyclades_port,
2991 port);
2992 struct cyclades_card *cinfo = info->card;
Jiri Slabyf0737572009-09-19 13:13:12 -07002993 unsigned long flags;
2994 int channel = info->line - cinfo->first_line;
Jiri Slabyf0737572009-09-19 13:13:12 -07002995 u32 cd;
2996
Jiri Slabyf0737572009-09-19 13:13:12 -07002997 spin_lock_irqsave(&cinfo->card_lock, flags);
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07002998 cyy_writeb(info, CyCAR, channel & 0x03);
2999 cd = cyy_readb(info, CyMSVR1) & CyDCD;
Jiri Slabyf0737572009-09-19 13:13:12 -07003000 spin_unlock_irqrestore(&cinfo->card_lock, flags);
3001
3002 return cd;
3003}
3004
3005static void cyy_dtr_rts(struct tty_port *port, int raise)
3006{
3007 struct cyclades_port *info = container_of(port, struct cyclades_port,
3008 port);
3009 struct cyclades_card *cinfo = info->card;
Jiri Slabyf0737572009-09-19 13:13:12 -07003010 unsigned long flags;
Jiri Slabyf0737572009-09-19 13:13:12 -07003011
3012 spin_lock_irqsave(&cinfo->card_lock, flags);
Jiri Slaby4d768202009-09-19 13:13:15 -07003013 cyy_change_rts_dtr(info, raise ? TIOCM_RTS | TIOCM_DTR : 0,
3014 raise ? 0 : TIOCM_RTS | TIOCM_DTR);
Jiri Slabyf0737572009-09-19 13:13:12 -07003015 spin_unlock_irqrestore(&cinfo->card_lock, flags);
3016}
3017
3018static int cyz_carrier_raised(struct tty_port *port)
3019{
3020 struct cyclades_port *info = container_of(port, struct cyclades_port,
3021 port);
Jiri Slabyf0737572009-09-19 13:13:12 -07003022
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003023 return readl(&info->u.cyz.ch_ctrl->rs_status) & C_RS_DCD;
Jiri Slabyf0737572009-09-19 13:13:12 -07003024}
3025
3026static void cyz_dtr_rts(struct tty_port *port, int raise)
3027{
3028 struct cyclades_port *info = container_of(port, struct cyclades_port,
3029 port);
3030 struct cyclades_card *cinfo = info->card;
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003031 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
Jiri Slabyf0737572009-09-19 13:13:12 -07003032 int ret, channel = info->line - cinfo->first_line;
3033 u32 rs;
3034
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003035 rs = readl(&ch_ctrl->rs_control);
Jiri Slabyf0737572009-09-19 13:13:12 -07003036 if (raise)
3037 rs |= C_RS_RTS | C_RS_DTR;
3038 else
3039 rs &= ~(C_RS_RTS | C_RS_DTR);
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003040 cy_writel(&ch_ctrl->rs_control, rs);
Jiri Slabyf0737572009-09-19 13:13:12 -07003041 ret = cyz_issue_cmd(cinfo, channel, C_CM_IOCTLM, 0L);
3042 if (ret != 0)
3043 printk(KERN_ERR "%s: retval on ttyC%d was %x\n",
3044 __func__, info->line, ret);
3045#ifdef CY_DEBUG_DTR
3046 printk(KERN_DEBUG "%s: raising Z DTR\n", __func__);
3047#endif
3048}
3049
3050static const struct tty_port_operations cyy_port_ops = {
3051 .carrier_raised = cyy_carrier_raised,
3052 .dtr_rts = cyy_dtr_rts,
Alan Coxe936ffd2009-09-19 13:13:22 -07003053 .shutdown = cy_do_close,
Jiri Slabyf0737572009-09-19 13:13:12 -07003054};
3055
3056static const struct tty_port_operations cyz_port_ops = {
3057 .carrier_raised = cyz_carrier_raised,
3058 .dtr_rts = cyz_dtr_rts,
Alan Coxe936ffd2009-09-19 13:13:22 -07003059 .shutdown = cy_do_close,
Jiri Slabyf0737572009-09-19 13:13:12 -07003060};
3061
Linus Torvalds1da177e2005-04-16 15:20:36 -07003062/*
3063 * ---------------------------------------------------------------------
3064 * cy_init() and friends
3065 *
3066 * cy_init() is called at boot-time to initialize the serial driver.
3067 * ---------------------------------------------------------------------
3068 */
3069
Bill Pemberton9671f092012-11-19 13:21:50 -05003070static int cy_init_card(struct cyclades_card *cinfo)
Jiri Slaby0809e262007-05-08 00:36:14 -07003071{
3072 struct cyclades_port *info;
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003073 unsigned int channel, port;
Jiri Slaby0809e262007-05-08 00:36:14 -07003074
Jiri Slaby3046d502007-05-08 00:36:46 -07003075 spin_lock_init(&cinfo->card_lock);
Jiri Slaby963118e2009-06-11 12:34:27 +01003076 cinfo->intr_enabled = 0;
Jiri Slaby3046d502007-05-08 00:36:46 -07003077
Jiri Slaby963118e2009-06-11 12:34:27 +01003078 cinfo->ports = kcalloc(cinfo->nports, sizeof(*cinfo->ports),
3079 GFP_KERNEL);
Jiri Slabydd025c02007-05-08 00:37:02 -07003080 if (cinfo->ports == NULL) {
3081 printk(KERN_ERR "Cyclades: cannot allocate ports\n");
3082 return -ENOMEM;
3083 }
3084
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003085 for (channel = 0, port = cinfo->first_line; channel < cinfo->nports;
3086 channel++, port++) {
3087 info = &cinfo->ports[channel];
Alan Cox44b7d1b2008-07-16 21:57:18 +01003088 tty_port_init(&info->port);
Jiri Slaby3046d502007-05-08 00:36:46 -07003089 info->magic = CYCLADES_MAGIC;
Jiri Slaby875b2062007-05-08 00:36:49 -07003090 info->card = cinfo;
Jiri Slaby3046d502007-05-08 00:36:46 -07003091 info->line = port;
Jiri Slaby3046d502007-05-08 00:36:46 -07003092
Alan Cox44b7d1b2008-07-16 21:57:18 +01003093 info->port.closing_wait = CLOSING_WAIT_DELAY;
3094 info->port.close_delay = 5 * HZ / 10;
Alan Cox77451e52008-07-16 21:57:02 +01003095 info->port.flags = STD_COM_FLAGS;
Jiri Slaby2c7fea92007-05-08 00:36:51 -07003096 init_completion(&info->shutdown_wait);
Jiri Slaby3046d502007-05-08 00:36:46 -07003097
Jiri Slaby2693f482009-06-11 12:31:06 +01003098 if (cy_is_Z(cinfo)) {
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003099 struct FIRM_ID *firm_id = cinfo->base_addr + ID_ADDRESS;
3100 struct ZFW_CTRL *zfw_ctrl;
3101
Jiri Slabyf0737572009-09-19 13:13:12 -07003102 info->port.ops = &cyz_port_ops;
Jiri Slaby0809e262007-05-08 00:36:14 -07003103 info->type = PORT_STARTECH;
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003104
3105 zfw_ctrl = cinfo->base_addr +
3106 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
3107 info->u.cyz.ch_ctrl = &zfw_ctrl->ch_ctrl[channel];
3108 info->u.cyz.buf_ctrl = &zfw_ctrl->buf_ctrl[channel];
3109
Jiri Slaby101b8152009-06-11 12:30:10 +01003110 if (cinfo->hw_ver == ZO_V1)
Jiri Slaby0809e262007-05-08 00:36:14 -07003111 info->xmit_fifo_size = CYZ_FIFO_SIZE;
3112 else
Jiri Slaby3046d502007-05-08 00:36:46 -07003113 info->xmit_fifo_size = 4 * CYZ_FIFO_SIZE;
Jiri Slaby0809e262007-05-08 00:36:14 -07003114#ifdef CONFIG_CYZ_INTR
Jiri Slaby39914282007-05-08 00:36:54 -07003115 setup_timer(&cyz_rx_full_timer[port],
3116 cyz_rx_restart, (unsigned long)info);
Jiri Slaby0809e262007-05-08 00:36:14 -07003117#endif
Jiri Slaby3046d502007-05-08 00:36:46 -07003118 } else {
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003119 unsigned short chip_number;
Jiri Slaby963118e2009-06-11 12:34:27 +01003120 int index = cinfo->bus_index;
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003121
Jiri Slabyf0737572009-09-19 13:13:12 -07003122 info->port.ops = &cyy_port_ops;
Jiri Slaby0809e262007-05-08 00:36:14 -07003123 info->type = PORT_CIRRUS;
Jiri Slaby0809e262007-05-08 00:36:14 -07003124 info->xmit_fifo_size = CyMAX_CHAR_FIFO;
Jiri Slaby3046d502007-05-08 00:36:46 -07003125 info->cor1 = CyPARITY_NONE | Cy_1_STOP | Cy_8_BITS;
Jiri Slaby0809e262007-05-08 00:36:14 -07003126 info->cor2 = CyETC;
3127 info->cor3 = 0x08; /* _very_ small rcv threshold */
Jiri Slaby3046d502007-05-08 00:36:46 -07003128
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003129 chip_number = channel / CyPORTS_PER_CHIP;
Jiri Slaby3aeea5b2009-09-19 13:13:16 -07003130 info->u.cyy.base_addr = cinfo->base_addr +
3131 (cy_chip_offset[chip_number] << index);
3132 info->chip_rev = cyy_readb(info, CyGFRCR);
Alan Cox15ed6cc2008-04-30 00:53:55 -07003133
3134 if (info->chip_rev >= CD1400_REV_J) {
Jiri Slaby0809e262007-05-08 00:36:14 -07003135 /* It is a CD1400 rev. J or later */
3136 info->tbpr = baud_bpr_60[13]; /* Tx BPR */
3137 info->tco = baud_co_60[13]; /* Tx CO */
3138 info->rbpr = baud_bpr_60[13]; /* Rx BPR */
3139 info->rco = baud_co_60[13]; /* Rx CO */
Jiri Slaby0809e262007-05-08 00:36:14 -07003140 info->rtsdtr_inv = 1;
3141 } else {
3142 info->tbpr = baud_bpr_25[13]; /* Tx BPR */
3143 info->tco = baud_co_25[13]; /* Tx CO */
3144 info->rbpr = baud_bpr_25[13]; /* Rx BPR */
3145 info->rco = baud_co_25[13]; /* Rx CO */
Jiri Slaby0809e262007-05-08 00:36:14 -07003146 info->rtsdtr_inv = 0;
3147 }
Jiri Slaby3046d502007-05-08 00:36:46 -07003148 info->read_status_mask = CyTIMEOUT | CySPECHAR |
3149 CyBREAK | CyPARITY | CyFRAME | CyOVERRUN;
Jiri Slaby0809e262007-05-08 00:36:14 -07003150 }
Jiri Slaby3046d502007-05-08 00:36:46 -07003151
Jiri Slaby0809e262007-05-08 00:36:14 -07003152 }
Jiri Slaby3046d502007-05-08 00:36:46 -07003153
3154#ifndef CONFIG_CYZ_INTR
Jiri Slaby2693f482009-06-11 12:31:06 +01003155 if (cy_is_Z(cinfo) && !timer_pending(&cyz_timerlist)) {
Jiri Slaby3046d502007-05-08 00:36:46 -07003156 mod_timer(&cyz_timerlist, jiffies + 1);
3157#ifdef CY_PCI_DEBUG
3158 printk(KERN_DEBUG "Cyclades-Z polling initialized\n");
3159#endif
3160 }
3161#endif
Jiri Slabydd025c02007-05-08 00:37:02 -07003162 return 0;
Jiri Slaby0809e262007-05-08 00:36:14 -07003163}
3164
Linus Torvalds1da177e2005-04-16 15:20:36 -07003165/* initialize chips on Cyclom-Y card -- return number of valid
3166 chips (which is number of ports/4) */
Bill Pemberton9671f092012-11-19 13:21:50 -05003167static unsigned short cyy_init_card(void __iomem *true_base_addr,
Jiri Slaby31b4f0a2007-05-08 00:36:44 -07003168 int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003169{
Jiri Slaby02f11752006-12-08 02:39:28 -08003170 unsigned int chip_number;
3171 void __iomem *base_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003172
Jiri Slaby02f11752006-12-08 02:39:28 -08003173 cy_writeb(true_base_addr + (Cy_HwReset << index), 0);
3174 /* Cy_HwReset is 0x1400 */
3175 cy_writeb(true_base_addr + (Cy_ClrIntr << index), 0);
3176 /* Cy_ClrIntr is 0x1800 */
3177 udelay(500L);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003178
Alan Cox15ed6cc2008-04-30 00:53:55 -07003179 for (chip_number = 0; chip_number < CyMAX_CHIPS_PER_CARD;
3180 chip_number++) {
Jiri Slaby02f11752006-12-08 02:39:28 -08003181 base_addr =
3182 true_base_addr + (cy_chip_offset[chip_number] << index);
3183 mdelay(1);
Jiri Slabydb05c3b2007-05-08 00:35:46 -07003184 if (readb(base_addr + (CyCCR << index)) != 0x00) {
Jiri Slaby02f11752006-12-08 02:39:28 -08003185 /*************
3186 printk(" chip #%d at %#6lx is never idle (CCR != 0)\n",
3187 chip_number, (unsigned long)base_addr);
3188 *************/
3189 return chip_number;
3190 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003191
Jiri Slaby02f11752006-12-08 02:39:28 -08003192 cy_writeb(base_addr + (CyGFRCR << index), 0);
3193 udelay(10L);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003194
Jiri Slaby02f11752006-12-08 02:39:28 -08003195 /* The Cyclom-16Y does not decode address bit 9 and therefore
3196 cannot distinguish between references to chip 0 and a non-
3197 existent chip 4. If the preceding clearing of the supposed
3198 chip 4 GFRCR register appears at chip 0, there is no chip 4
3199 and this must be a Cyclom-16Y, not a Cyclom-32Ye.
3200 */
Jiri Slabydb05c3b2007-05-08 00:35:46 -07003201 if (chip_number == 4 && readb(true_base_addr +
Jiri Slaby02f11752006-12-08 02:39:28 -08003202 (cy_chip_offset[0] << index) +
3203 (CyGFRCR << index)) == 0) {
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 + (CyCCR << index), CyCHIP_RESET);
3208 mdelay(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003209
Jiri Slabydb05c3b2007-05-08 00:35:46 -07003210 if (readb(base_addr + (CyGFRCR << index)) == 0x00) {
Jiri Slaby02f11752006-12-08 02:39:28 -08003211 /*
3212 printk(" chip #%d at %#6lx is not responding ",
3213 chip_number, (unsigned long)base_addr);
3214 printk("(GFRCR stayed 0)\n",
3215 */
3216 return chip_number;
3217 }
Jiri Slabydb05c3b2007-05-08 00:35:46 -07003218 if ((0xf0 & (readb(base_addr + (CyGFRCR << index)))) !=
Jiri Slaby02f11752006-12-08 02:39:28 -08003219 0x40) {
3220 /*
3221 printk(" chip #%d at %#6lx is not valid (GFRCR == "
3222 "%#2x)\n",
3223 chip_number, (unsigned long)base_addr,
3224 base_addr[CyGFRCR<<index]);
3225 */
3226 return chip_number;
3227 }
3228 cy_writeb(base_addr + (CyGCR << index), CyCH0_SERIAL);
Jiri Slabydb05c3b2007-05-08 00:35:46 -07003229 if (readb(base_addr + (CyGFRCR << index)) >= CD1400_REV_J) {
Jiri Slaby02f11752006-12-08 02:39:28 -08003230 /* It is a CD1400 rev. J or later */
3231 /* Impossible to reach 5ms with this chip.
3232 Changed to 2ms instead (f = 500 Hz). */
3233 cy_writeb(base_addr + (CyPPR << index), CyCLOCK_60_2MS);
3234 } else {
3235 /* f = 200 Hz */
3236 cy_writeb(base_addr + (CyPPR << index), CyCLOCK_25_5MS);
3237 }
3238
3239 /*
3240 printk(" chip #%d at %#6lx is rev 0x%2x\n",
3241 chip_number, (unsigned long)base_addr,
Jiri Slabydb05c3b2007-05-08 00:35:46 -07003242 readb(base_addr+(CyGFRCR<<index)));
Jiri Slaby02f11752006-12-08 02:39:28 -08003243 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003244 }
Jiri Slaby02f11752006-12-08 02:39:28 -08003245 return chip_number;
3246} /* cyy_init_card */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003247
3248/*
3249 * ---------------------------------------------------------------------
3250 * cy_detect_isa() - Probe for Cyclom-Y/ISA boards.
3251 * sets global variables and return the number of ISA boards found.
3252 * ---------------------------------------------------------------------
3253 */
Jiri Slaby02f11752006-12-08 02:39:28 -08003254static int __init cy_detect_isa(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003255{
3256#ifdef CONFIG_ISA
Jiri Slaby718c4ca2012-06-04 13:35:15 +02003257 struct cyclades_card *card;
Jiri Slaby02f11752006-12-08 02:39:28 -08003258 unsigned short cy_isa_irq, nboard;
3259 void __iomem *cy_isa_address;
Jiri Slaby734cc172012-08-07 21:47:47 +02003260 unsigned short i, j, k, cy_isa_nchan;
Jiri Slaby02f11752006-12-08 02:39:28 -08003261 int isparam = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003262
Jiri Slaby02f11752006-12-08 02:39:28 -08003263 nboard = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003264
Linus Torvalds1da177e2005-04-16 15:20:36 -07003265 /* Check for module parameters */
Jiri Slaby02f11752006-12-08 02:39:28 -08003266 for (i = 0; i < NR_CARDS; i++) {
3267 if (maddr[i] || i) {
3268 isparam = 1;
3269 cy_isa_addresses[i] = maddr[i];
3270 }
3271 if (!maddr[i])
3272 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003273 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003274
Jiri Slaby02f11752006-12-08 02:39:28 -08003275 /* scan the address table probing for Cyclom-Y/ISA boards */
3276 for (i = 0; i < NR_ISA_ADDRS; i++) {
3277 unsigned int isa_address = cy_isa_addresses[i];
Alan Cox15ed6cc2008-04-30 00:53:55 -07003278 if (isa_address == 0x0000)
Jiri Slaby096dcfc2006-12-08 02:39:30 -08003279 return nboard;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003280
Jiri Slaby02f11752006-12-08 02:39:28 -08003281 /* probe for CD1400... */
Alan Coxcd989b32008-04-30 00:53:56 -07003282 cy_isa_address = ioremap_nocache(isa_address, CyISA_Ywin);
Jiri Slaby31375532007-05-08 00:37:04 -07003283 if (cy_isa_address == NULL) {
3284 printk(KERN_ERR "Cyclom-Y/ISA: can't remap base "
3285 "address\n");
3286 continue;
3287 }
Jiri Slaby02f11752006-12-08 02:39:28 -08003288 cy_isa_nchan = CyPORTS_PER_CHIP *
3289 cyy_init_card(cy_isa_address, 0);
3290 if (cy_isa_nchan == 0) {
Jiri Slaby31375532007-05-08 00:37:04 -07003291 iounmap(cy_isa_address);
Jiri Slaby02f11752006-12-08 02:39:28 -08003292 continue;
3293 }
Bartlomiej Zolnierkiewicz20904362009-12-09 12:34:14 -08003294
Roel Kluin196b3162009-10-01 15:44:24 -07003295 if (isparam && i < NR_CARDS && irq[i])
Jiri Slaby02f11752006-12-08 02:39:28 -08003296 cy_isa_irq = irq[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07003297 else
Jiri Slaby02f11752006-12-08 02:39:28 -08003298 /* find out the board's irq by probing */
3299 cy_isa_irq = detect_isa_irq(cy_isa_address);
3300 if (cy_isa_irq == 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07003301 printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but the "
3302 "IRQ could not be detected.\n",
Jiri Slaby02f11752006-12-08 02:39:28 -08003303 (unsigned long)cy_isa_address);
Jiri Slaby31375532007-05-08 00:37:04 -07003304 iounmap(cy_isa_address);
Jiri Slaby02f11752006-12-08 02:39:28 -08003305 continue;
3306 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003307
Jiri Slaby02f11752006-12-08 02:39:28 -08003308 if ((cy_next_channel + cy_isa_nchan) > NR_PORTS) {
Jiri Slaby21719192007-05-08 00:36:42 -07003309 printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but no "
3310 "more channels are available. Change NR_PORTS "
3311 "in cyclades.c and recompile kernel.\n",
Jiri Slaby02f11752006-12-08 02:39:28 -08003312 (unsigned long)cy_isa_address);
Jiri Slaby31375532007-05-08 00:37:04 -07003313 iounmap(cy_isa_address);
Jiri Slaby096dcfc2006-12-08 02:39:30 -08003314 return nboard;
Jiri Slaby02f11752006-12-08 02:39:28 -08003315 }
3316 /* fill the next cy_card structure available */
3317 for (j = 0; j < NR_CARDS; j++) {
Jiri Slaby718c4ca2012-06-04 13:35:15 +02003318 card = &cy_card[j];
3319 if (card->base_addr == NULL)
Jiri Slaby02f11752006-12-08 02:39:28 -08003320 break;
3321 }
3322 if (j == NR_CARDS) { /* no more cy_cards available */
Jiri Slaby21719192007-05-08 00:36:42 -07003323 printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but no "
3324 "more cards can be used. Change NR_CARDS in "
3325 "cyclades.c and recompile kernel.\n",
Jiri Slaby02f11752006-12-08 02:39:28 -08003326 (unsigned long)cy_isa_address);
Jiri Slaby31375532007-05-08 00:37:04 -07003327 iounmap(cy_isa_address);
Jiri Slaby096dcfc2006-12-08 02:39:30 -08003328 return nboard;
Jiri Slaby02f11752006-12-08 02:39:28 -08003329 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003330
Jiri Slaby02f11752006-12-08 02:39:28 -08003331 /* allocate IRQ */
3332 if (request_irq(cy_isa_irq, cyy_interrupt,
Jiri Slaby718c4ca2012-06-04 13:35:15 +02003333 0, "Cyclom-Y", card)) {
Jiri Slaby21719192007-05-08 00:36:42 -07003334 printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but "
3335 "could not allocate IRQ#%d.\n",
3336 (unsigned long)cy_isa_address, cy_isa_irq);
Jiri Slaby31375532007-05-08 00:37:04 -07003337 iounmap(cy_isa_address);
Jiri Slaby096dcfc2006-12-08 02:39:30 -08003338 return nboard;
Jiri Slaby02f11752006-12-08 02:39:28 -08003339 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003340
Jiri Slaby02f11752006-12-08 02:39:28 -08003341 /* set cy_card */
Jiri Slaby718c4ca2012-06-04 13:35:15 +02003342 card->base_addr = cy_isa_address;
3343 card->ctl_addr.p9050 = NULL;
3344 card->irq = (int)cy_isa_irq;
3345 card->bus_index = 0;
3346 card->first_line = cy_next_channel;
3347 card->num_chips = cy_isa_nchan / CyPORTS_PER_CHIP;
3348 card->nports = cy_isa_nchan;
3349 if (cy_init_card(card)) {
3350 card->base_addr = NULL;
3351 free_irq(cy_isa_irq, card);
Jiri Slaby31375532007-05-08 00:37:04 -07003352 iounmap(cy_isa_address);
3353 continue;
3354 }
Jiri Slaby02f11752006-12-08 02:39:28 -08003355 nboard++;
3356
Jiri Slaby21719192007-05-08 00:36:42 -07003357 printk(KERN_INFO "Cyclom-Y/ISA #%d: 0x%lx-0x%lx, IRQ%d found: "
3358 "%d channels starting from port %d\n",
Jiri Slaby02f11752006-12-08 02:39:28 -08003359 j + 1, (unsigned long)cy_isa_address,
3360 (unsigned long)(cy_isa_address + (CyISA_Ywin - 1)),
Jiri Slaby21719192007-05-08 00:36:42 -07003361 cy_isa_irq, cy_isa_nchan, cy_next_channel);
3362
Jiri Slaby734cc172012-08-07 21:47:47 +02003363 for (k = 0, j = cy_next_channel;
3364 j < cy_next_channel + cy_isa_nchan; j++, k++)
3365 tty_port_register_device(&card->ports[k].port,
3366 cy_serial_driver, j, NULL);
Jiri Slaby02f11752006-12-08 02:39:28 -08003367 cy_next_channel += cy_isa_nchan;
3368 }
Jiri Slaby096dcfc2006-12-08 02:39:30 -08003369 return nboard;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003370#else
Jiri Slaby096dcfc2006-12-08 02:39:30 -08003371 return 0;
Jiri Slaby02f11752006-12-08 02:39:28 -08003372#endif /* CONFIG_ISA */
3373} /* cy_detect_isa */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003374
Jiri Slaby58936d82007-05-08 00:36:13 -07003375#ifdef CONFIG_PCI
Bill Pemberton9671f092012-11-19 13:21:50 -05003376static inline int cyc_isfwstr(const char *str, unsigned int size)
Jiri Slaby054f5b02007-07-17 04:05:16 -07003377{
3378 unsigned int a;
3379
3380 for (a = 0; a < size && *str; a++, str++)
3381 if (*str & 0x80)
3382 return -EINVAL;
3383
3384 for (; a < size; a++, str++)
3385 if (*str)
3386 return -EINVAL;
3387
3388 return 0;
3389}
3390
Bill Pemberton9671f092012-11-19 13:21:50 -05003391static inline void cyz_fpga_copy(void __iomem *fpga, const u8 *data,
Jiri Slaby054f5b02007-07-17 04:05:16 -07003392 unsigned int size)
3393{
3394 for (; size > 0; size--) {
3395 cy_writel(fpga, *data++);
3396 udelay(10);
3397 }
3398}
3399
Bill Pemberton9671f092012-11-19 13:21:50 -05003400static void plx_init(struct pci_dev *pdev, int irq,
Jiri Slaby054f5b02007-07-17 04:05:16 -07003401 struct RUNTIME_9060 __iomem *addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003402{
Jiri Slaby02f11752006-12-08 02:39:28 -08003403 /* Reset PLX */
Jiri Slaby054f5b02007-07-17 04:05:16 -07003404 cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) | 0x40000000);
Jiri Slaby02f11752006-12-08 02:39:28 -08003405 udelay(100L);
Jiri Slaby054f5b02007-07-17 04:05:16 -07003406 cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) & ~0x40000000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003407
Jiri Slaby02f11752006-12-08 02:39:28 -08003408 /* Reload Config. Registers from EEPROM */
Jiri Slaby054f5b02007-07-17 04:05:16 -07003409 cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) | 0x20000000);
Jiri Slaby02f11752006-12-08 02:39:28 -08003410 udelay(100L);
Jiri Slaby054f5b02007-07-17 04:05:16 -07003411 cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) & ~0x20000000);
3412
3413 /* For some yet unknown reason, once the PLX9060 reloads the EEPROM,
3414 * the IRQ is lost and, thus, we have to re-write it to the PCI config.
3415 * registers. This will remain here until we find a permanent fix.
3416 */
3417 pci_write_config_byte(pdev, PCI_INTERRUPT_LINE, irq);
3418}
3419
Bill Pemberton9671f092012-11-19 13:21:50 -05003420static int __cyz_load_fw(const struct firmware *fw,
Jiri Slaby054f5b02007-07-17 04:05:16 -07003421 const char *name, const u32 mailbox, void __iomem *base,
3422 void __iomem *fpga)
3423{
David Woodhousef61e7612008-05-23 23:57:19 +01003424 const void *ptr = fw->data;
3425 const struct zfile_header *h = ptr;
3426 const struct zfile_config *c, *cs;
3427 const struct zfile_block *b, *bs;
Jiri Slaby054f5b02007-07-17 04:05:16 -07003428 unsigned int a, tmp, len = fw->size;
3429#define BAD_FW KERN_ERR "Bad firmware: "
3430 if (len < sizeof(*h)) {
3431 printk(BAD_FW "too short: %u<%zu\n", len, sizeof(*h));
3432 return -EINVAL;
3433 }
3434
3435 cs = ptr + h->config_offset;
3436 bs = ptr + h->block_offset;
3437
3438 if ((void *)(cs + h->n_config) > ptr + len ||
3439 (void *)(bs + h->n_blocks) > ptr + len) {
3440 printk(BAD_FW "too short");
3441 return -EINVAL;
3442 }
3443
3444 if (cyc_isfwstr(h->name, sizeof(h->name)) ||
3445 cyc_isfwstr(h->date, sizeof(h->date))) {
3446 printk(BAD_FW "bad formatted header string\n");
3447 return -EINVAL;
3448 }
3449
3450 if (strncmp(name, h->name, sizeof(h->name))) {
3451 printk(BAD_FW "bad name '%s' (expected '%s')\n", h->name, name);
3452 return -EINVAL;
3453 }
3454
3455 tmp = 0;
3456 for (c = cs; c < cs + h->n_config; c++) {
3457 for (a = 0; a < c->n_blocks; a++)
3458 if (c->block_list[a] > h->n_blocks) {
3459 printk(BAD_FW "bad block ref number in cfgs\n");
3460 return -EINVAL;
3461 }
3462 if (c->mailbox == mailbox && c->function == 0) /* 0 is normal */
3463 tmp++;
3464 }
3465 if (!tmp) {
3466 printk(BAD_FW "nothing appropriate\n");
3467 return -EINVAL;
3468 }
3469
3470 for (b = bs; b < bs + h->n_blocks; b++)
3471 if (b->file_offset + b->size > len) {
3472 printk(BAD_FW "bad block data offset\n");
3473 return -EINVAL;
3474 }
3475
3476 /* everything is OK, let's seek'n'load it */
3477 for (c = cs; c < cs + h->n_config; c++)
3478 if (c->mailbox == mailbox && c->function == 0)
3479 break;
3480
3481 for (a = 0; a < c->n_blocks; a++) {
3482 b = &bs[c->block_list[a]];
3483 if (b->type == ZBLOCK_FPGA) {
3484 if (fpga != NULL)
3485 cyz_fpga_copy(fpga, ptr + b->file_offset,
3486 b->size);
3487 } else {
3488 if (base != NULL)
3489 memcpy_toio(base + b->ram_offset,
3490 ptr + b->file_offset, b->size);
3491 }
3492 }
3493#undef BAD_FW
3494 return 0;
3495}
3496
Bill Pemberton9671f092012-11-19 13:21:50 -05003497static int cyz_load_fw(struct pci_dev *pdev, void __iomem *base_addr,
Jiri Slaby054f5b02007-07-17 04:05:16 -07003498 struct RUNTIME_9060 __iomem *ctl_addr, int irq)
3499{
3500 const struct firmware *fw;
3501 struct FIRM_ID __iomem *fid = base_addr + ID_ADDRESS;
3502 struct CUSTOM_REG __iomem *cust = base_addr;
3503 struct ZFW_CTRL __iomem *pt_zfwctrl;
Jiri Slabyc4923b42007-07-17 04:05:17 -07003504 void __iomem *tmp;
Jiri Slaby963118e2009-06-11 12:34:27 +01003505 u32 mailbox, status, nchan;
Jiri Slaby054f5b02007-07-17 04:05:16 -07003506 unsigned int i;
3507 int retval;
3508
3509 retval = request_firmware(&fw, "cyzfirm.bin", &pdev->dev);
3510 if (retval) {
3511 dev_err(&pdev->dev, "can't get firmware\n");
3512 goto err;
3513 }
3514
3515 /* Check whether the firmware is already loaded and running. If
3516 positive, skip this board */
Jiri Slaby2693f482009-06-11 12:31:06 +01003517 if (__cyz_fpga_loaded(ctl_addr) && readl(&fid->signature) == ZFIRM_ID) {
Jiri Slaby054f5b02007-07-17 04:05:16 -07003518 u32 cntval = readl(base_addr + 0x190);
3519
3520 udelay(100);
3521 if (cntval != readl(base_addr + 0x190)) {
3522 /* FW counter is working, FW is running */
3523 dev_dbg(&pdev->dev, "Cyclades-Z FW already loaded. "
3524 "Skipping board.\n");
3525 retval = 0;
3526 goto err_rel;
3527 }
3528 }
3529
3530 /* start boot */
3531 cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) &
3532 ~0x00030800UL);
3533
3534 mailbox = readl(&ctl_addr->mail_box_0);
3535
Jiri Slaby2693f482009-06-11 12:31:06 +01003536 if (mailbox == 0 || __cyz_fpga_loaded(ctl_addr)) {
Jiri Slaby054f5b02007-07-17 04:05:16 -07003537 /* stops CPU and set window to beginning of RAM */
3538 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3539 cy_writel(&cust->cpu_stop, 0);
3540 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3541 udelay(100);
3542 }
3543
3544 plx_init(pdev, irq, ctl_addr);
3545
3546 if (mailbox != 0) {
3547 /* load FPGA */
3548 retval = __cyz_load_fw(fw, "Cyclom-Z", mailbox, NULL,
3549 base_addr);
3550 if (retval)
3551 goto err_rel;
Jiri Slaby2693f482009-06-11 12:31:06 +01003552 if (!__cyz_fpga_loaded(ctl_addr)) {
Jiri Slaby054f5b02007-07-17 04:05:16 -07003553 dev_err(&pdev->dev, "fw upload successful, but fw is "
3554 "not loaded\n");
3555 goto err_rel;
3556 }
3557 }
3558
3559 /* stops CPU and set window to beginning of RAM */
3560 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3561 cy_writel(&cust->cpu_stop, 0);
3562 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3563 udelay(100);
3564
3565 /* clear memory */
Jiri Slabyc4923b42007-07-17 04:05:17 -07003566 for (tmp = base_addr; tmp < base_addr + RAM_SIZE; tmp++)
Jiri Slaby054f5b02007-07-17 04:05:16 -07003567 cy_writeb(tmp, 255);
3568 if (mailbox != 0) {
3569 /* set window to last 512K of RAM */
3570 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM + RAM_SIZE);
Jiri Slabyc4923b42007-07-17 04:05:17 -07003571 for (tmp = base_addr; tmp < base_addr + RAM_SIZE; tmp++)
Jiri Slaby054f5b02007-07-17 04:05:16 -07003572 cy_writeb(tmp, 255);
3573 /* set window to beginning of RAM */
3574 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
Jiri Slaby054f5b02007-07-17 04:05:16 -07003575 }
3576
3577 retval = __cyz_load_fw(fw, "Cyclom-Z", mailbox, base_addr, NULL);
3578 release_firmware(fw);
3579 if (retval)
3580 goto err;
3581
3582 /* finish boot and start boards */
3583 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3584 cy_writel(&cust->cpu_start, 0);
3585 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3586 i = 0;
3587 while ((status = readl(&fid->signature)) != ZFIRM_ID && i++ < 40)
3588 msleep(100);
3589 if (status != ZFIRM_ID) {
3590 if (status == ZFIRM_HLT) {
3591 dev_err(&pdev->dev, "you need an external power supply "
3592 "for this number of ports. Firmware halted and "
3593 "board reset.\n");
3594 retval = -EIO;
3595 goto err;
3596 }
3597 dev_warn(&pdev->dev, "fid->signature = 0x%x... Waiting "
3598 "some more time\n", status);
3599 while ((status = readl(&fid->signature)) != ZFIRM_ID &&
3600 i++ < 200)
3601 msleep(100);
3602 if (status != ZFIRM_ID) {
3603 dev_err(&pdev->dev, "Board not started in 20 seconds! "
3604 "Giving up. (fid->signature = 0x%x)\n",
3605 status);
3606 dev_info(&pdev->dev, "*** Warning ***: if you are "
3607 "upgrading the FW, please power cycle the "
3608 "system before loading the new FW to the "
3609 "Cyclades-Z.\n");
3610
Jiri Slaby2693f482009-06-11 12:31:06 +01003611 if (__cyz_fpga_loaded(ctl_addr))
Jiri Slaby054f5b02007-07-17 04:05:16 -07003612 plx_init(pdev, irq, ctl_addr);
3613
3614 retval = -EIO;
3615 goto err;
3616 }
3617 dev_dbg(&pdev->dev, "Firmware started after %d seconds.\n",
3618 i / 10);
3619 }
3620 pt_zfwctrl = base_addr + readl(&fid->zfwctrl_addr);
3621
3622 dev_dbg(&pdev->dev, "fid=> %p, zfwctrl_addr=> %x, npt_zfwctrl=> %p\n",
3623 base_addr + ID_ADDRESS, readl(&fid->zfwctrl_addr),
3624 base_addr + readl(&fid->zfwctrl_addr));
3625
Jiri Slaby963118e2009-06-11 12:34:27 +01003626 nchan = readl(&pt_zfwctrl->board_ctrl.n_channel);
Jiri Slaby054f5b02007-07-17 04:05:16 -07003627 dev_info(&pdev->dev, "Cyclades-Z FW loaded: version = %x, ports = %u\n",
Jiri Slaby963118e2009-06-11 12:34:27 +01003628 readl(&pt_zfwctrl->board_ctrl.fw_version), nchan);
Jiri Slaby054f5b02007-07-17 04:05:16 -07003629
Jiri Slaby963118e2009-06-11 12:34:27 +01003630 if (nchan == 0) {
Jiri Slaby054f5b02007-07-17 04:05:16 -07003631 dev_warn(&pdev->dev, "no Cyclades-Z ports were found. Please "
3632 "check the connection between the Z host card and the "
3633 "serial expanders.\n");
3634
Jiri Slaby2693f482009-06-11 12:31:06 +01003635 if (__cyz_fpga_loaded(ctl_addr))
Jiri Slaby054f5b02007-07-17 04:05:16 -07003636 plx_init(pdev, irq, ctl_addr);
3637
3638 dev_info(&pdev->dev, "Null number of ports detected. Board "
3639 "reset.\n");
3640 retval = 0;
3641 goto err;
3642 }
3643
3644 cy_writel(&pt_zfwctrl->board_ctrl.op_system, C_OS_LINUX);
3645 cy_writel(&pt_zfwctrl->board_ctrl.dr_version, DRIVER_VERSION);
3646
3647 /*
3648 Early firmware failed to start looking for commands.
3649 This enables firmware interrupts for those commands.
3650 */
3651 cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) |
3652 (1 << 17));
3653 cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) |
3654 0x00030800UL);
3655
Jiri Slaby963118e2009-06-11 12:34:27 +01003656 return nchan;
Jiri Slaby054f5b02007-07-17 04:05:16 -07003657err_rel:
3658 release_firmware(fw);
3659err:
3660 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003661}
3662
Bill Pemberton9671f092012-11-19 13:21:50 -05003663static int cy_pci_probe(struct pci_dev *pdev,
Jiri Slaby58936d82007-05-08 00:36:13 -07003664 const struct pci_device_id *ent)
3665{
Jiri Slaby718c4ca2012-06-04 13:35:15 +02003666 struct cyclades_card *card;
Jiri Slaby31375532007-05-08 00:37:04 -07003667 void __iomem *addr0 = NULL, *addr2 = NULL;
3668 char *card_name = NULL;
Jiri Slaby101b8152009-06-11 12:30:10 +01003669 u32 uninitialized_var(mailbox);
Jiri Slaby734cc172012-08-07 21:47:47 +02003670 unsigned int device_id, nchan = 0, card_no, i, j;
Jiri Slaby31375532007-05-08 00:37:04 -07003671 unsigned char plx_ver;
3672 int retval, irq;
Jiri Slaby58936d82007-05-08 00:36:13 -07003673
3674 retval = pci_enable_device(pdev);
3675 if (retval) {
3676 dev_err(&pdev->dev, "cannot enable device\n");
Jiri Slaby31375532007-05-08 00:37:04 -07003677 goto err;
Jiri Slaby58936d82007-05-08 00:36:13 -07003678 }
3679
3680 /* read PCI configuration area */
Jiri Slaby31375532007-05-08 00:37:04 -07003681 irq = pdev->irq;
Jiri Slaby58936d82007-05-08 00:36:13 -07003682 device_id = pdev->device & ~PCI_DEVICE_ID_MASK;
3683
Jiri Slaby31375532007-05-08 00:37:04 -07003684#if defined(__alpha__)
3685 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo) { /* below 1M? */
3686 dev_err(&pdev->dev, "Cyclom-Y/PCI not supported for low "
3687 "addresses on Alpha systems.\n");
3688 retval = -EIO;
3689 goto err_dis;
3690 }
3691#endif
3692 if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Lo) {
3693 dev_err(&pdev->dev, "Cyclades-Z/PCI not supported for low "
3694 "addresses\n");
3695 retval = -EIO;
3696 goto err_dis;
3697 }
3698
3699 if (pci_resource_flags(pdev, 2) & IORESOURCE_IO) {
3700 dev_warn(&pdev->dev, "PCI I/O bit incorrectly set. Ignoring "
3701 "it...\n");
3702 pdev->resource[2].flags &= ~IORESOURCE_IO;
3703 }
3704
3705 retval = pci_request_regions(pdev, "cyclades");
3706 if (retval) {
3707 dev_err(&pdev->dev, "failed to reserve resources\n");
3708 goto err_dis;
3709 }
3710
3711 retval = -EIO;
Jiri Slaby58936d82007-05-08 00:36:13 -07003712 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3713 device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
Jiri Slaby31375532007-05-08 00:37:04 -07003714 card_name = "Cyclom-Y";
Jiri Slaby58936d82007-05-08 00:36:13 -07003715
Jiri Slaby24e6fd42008-10-13 10:34:09 +01003716 addr0 = ioremap_nocache(pci_resource_start(pdev, 0),
3717 CyPCI_Yctl);
Jiri Slaby31375532007-05-08 00:37:04 -07003718 if (addr0 == NULL) {
3719 dev_err(&pdev->dev, "can't remap ctl region\n");
3720 goto err_reg;
3721 }
Jiri Slaby24e6fd42008-10-13 10:34:09 +01003722 addr2 = ioremap_nocache(pci_resource_start(pdev, 2),
3723 CyPCI_Ywin);
Jiri Slaby31375532007-05-08 00:37:04 -07003724 if (addr2 == NULL) {
3725 dev_err(&pdev->dev, "can't remap base region\n");
3726 goto err_unmap;
Jiri Slaby58936d82007-05-08 00:36:13 -07003727 }
3728
Jiri Slaby31375532007-05-08 00:37:04 -07003729 nchan = CyPORTS_PER_CHIP * cyy_init_card(addr2, 1);
3730 if (nchan == 0) {
Jiri Slaby21719192007-05-08 00:36:42 -07003731 dev_err(&pdev->dev, "Cyclom-Y PCI host card with no "
3732 "Serial-Modules\n");
Andrew Mortonc847d472009-01-02 13:50:07 +00003733 goto err_unmap;
Jiri Slaby58936d82007-05-08 00:36:13 -07003734 }
Jiri Slaby31375532007-05-08 00:37:04 -07003735 } else if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Hi) {
3736 struct RUNTIME_9060 __iomem *ctl_addr;
3737
Jiri Slaby24e6fd42008-10-13 10:34:09 +01003738 ctl_addr = addr0 = ioremap_nocache(pci_resource_start(pdev, 0),
3739 CyPCI_Zctl);
Jiri Slaby31375532007-05-08 00:37:04 -07003740 if (addr0 == NULL) {
3741 dev_err(&pdev->dev, "can't remap ctl region\n");
3742 goto err_reg;
Jiri Slaby58936d82007-05-08 00:36:13 -07003743 }
3744
Jiri Slaby31375532007-05-08 00:37:04 -07003745 /* Disable interrupts on the PLX before resetting it */
Jiri Slaby97e87f82009-06-11 12:29:27 +01003746 cy_writew(&ctl_addr->intr_ctrl_stat,
3747 readw(&ctl_addr->intr_ctrl_stat) & ~0x0900);
Jiri Slaby31375532007-05-08 00:37:04 -07003748
Jiri Slaby054f5b02007-07-17 04:05:16 -07003749 plx_init(pdev, irq, addr0);
Jiri Slaby31375532007-05-08 00:37:04 -07003750
Jiri Slaby101b8152009-06-11 12:30:10 +01003751 mailbox = readl(&ctl_addr->mail_box_0);
Jiri Slaby31375532007-05-08 00:37:04 -07003752
Jiri Slaby24e6fd42008-10-13 10:34:09 +01003753 addr2 = ioremap_nocache(pci_resource_start(pdev, 2),
3754 mailbox == ZE_V1 ? CyPCI_Ze_win : CyPCI_Zwin);
Jiri Slaby31375532007-05-08 00:37:04 -07003755 if (addr2 == NULL) {
3756 dev_err(&pdev->dev, "can't remap base region\n");
3757 goto err_unmap;
3758 }
3759
3760 if (mailbox == ZE_V1) {
3761 card_name = "Cyclades-Ze";
Jiri Slaby31375532007-05-08 00:37:04 -07003762 } else {
3763 card_name = "Cyclades-8Zo";
Jiri Slaby31375532007-05-08 00:37:04 -07003764#ifdef CY_PCI_DEBUG
3765 if (mailbox == ZO_V1) {
3766 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3767 dev_info(&pdev->dev, "Cyclades-8Zo/PCI: FPGA "
3768 "id %lx, ver %lx\n", (ulong)(0xff &
3769 readl(&((struct CUSTOM_REG *)addr2)->
3770 fpga_id)), (ulong)(0xff &
3771 readl(&((struct CUSTOM_REG *)addr2)->
3772 fpga_version)));
3773 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3774 } else {
3775 dev_info(&pdev->dev, "Cyclades-Z/PCI: New "
3776 "Cyclades-Z board. FPGA not loaded\n");
3777 }
3778#endif
3779 /* The following clears the firmware id word. This
3780 ensures that the driver will not attempt to talk to
3781 the board until it has been properly initialized.
3782 */
3783 if ((mailbox == ZO_V1) || (mailbox == ZO_V2))
3784 cy_writel(addr2 + ID_ADDRESS, 0L);
Jiri Slaby31375532007-05-08 00:37:04 -07003785 }
Jiri Slabyace08c32009-06-11 12:20:38 +01003786
3787 retval = cyz_load_fw(pdev, addr2, addr0, irq);
Jiri Slaby963118e2009-06-11 12:34:27 +01003788 if (retval <= 0)
Jiri Slabyace08c32009-06-11 12:20:38 +01003789 goto err_unmap;
Jiri Slaby963118e2009-06-11 12:34:27 +01003790 nchan = retval;
Jiri Slaby31375532007-05-08 00:37:04 -07003791 }
3792
3793 if ((cy_next_channel + nchan) > NR_PORTS) {
3794 dev_err(&pdev->dev, "Cyclades-8Zo/PCI found, but no "
3795 "channels are available. Change NR_PORTS in "
3796 "cyclades.c and recompile kernel.\n");
3797 goto err_unmap;
3798 }
3799 /* fill the next cy_card structure available */
3800 for (card_no = 0; card_no < NR_CARDS; card_no++) {
Jiri Slaby718c4ca2012-06-04 13:35:15 +02003801 card = &cy_card[card_no];
3802 if (card->base_addr == NULL)
Jiri Slaby31375532007-05-08 00:37:04 -07003803 break;
3804 }
3805 if (card_no == NR_CARDS) { /* no more cy_cards available */
3806 dev_err(&pdev->dev, "Cyclades-8Zo/PCI found, but no "
3807 "more cards can be used. Change NR_CARDS in "
3808 "cyclades.c and recompile kernel.\n");
3809 goto err_unmap;
3810 }
3811
3812 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3813 device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
Jiri Slaby58936d82007-05-08 00:36:13 -07003814 /* allocate IRQ */
Jiri Slaby31375532007-05-08 00:37:04 -07003815 retval = request_irq(irq, cyy_interrupt,
Jiri Slaby718c4ca2012-06-04 13:35:15 +02003816 IRQF_SHARED, "Cyclom-Y", card);
Jiri Slaby58936d82007-05-08 00:36:13 -07003817 if (retval) {
Jiri Slaby21719192007-05-08 00:36:42 -07003818 dev_err(&pdev->dev, "could not allocate IRQ\n");
Jiri Slaby31375532007-05-08 00:37:04 -07003819 goto err_unmap;
Jiri Slaby58936d82007-05-08 00:36:13 -07003820 }
Jiri Slaby718c4ca2012-06-04 13:35:15 +02003821 card->num_chips = nchan / CyPORTS_PER_CHIP;
Jiri Slaby31375532007-05-08 00:37:04 -07003822 } else {
Jiri Slabyf0eefdc2009-09-19 13:13:13 -07003823 struct FIRM_ID __iomem *firm_id = addr2 + ID_ADDRESS;
3824 struct ZFW_CTRL __iomem *zfw_ctrl;
3825
3826 zfw_ctrl = addr2 + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
3827
Jiri Slaby718c4ca2012-06-04 13:35:15 +02003828 card->hw_ver = mailbox;
3829 card->num_chips = (unsigned int)-1;
3830 card->board_ctrl = &zfw_ctrl->board_ctrl;
Jiri Slaby31375532007-05-08 00:37:04 -07003831#ifdef CONFIG_CYZ_INTR
3832 /* allocate IRQ only if board has an IRQ */
3833 if (irq != 0 && irq != 255) {
3834 retval = request_irq(irq, cyz_interrupt,
Jiri Slaby718c4ca2012-06-04 13:35:15 +02003835 IRQF_SHARED, "Cyclades-Z", card);
Jiri Slaby31375532007-05-08 00:37:04 -07003836 if (retval) {
3837 dev_err(&pdev->dev, "could not allocate IRQ\n");
3838 goto err_unmap;
3839 }
3840 }
3841#endif /* CONFIG_CYZ_INTR */
Jiri Slaby31375532007-05-08 00:37:04 -07003842 }
Jiri Slaby58936d82007-05-08 00:36:13 -07003843
Jiri Slaby31375532007-05-08 00:37:04 -07003844 /* set cy_card */
Jiri Slaby718c4ca2012-06-04 13:35:15 +02003845 card->base_addr = addr2;
3846 card->ctl_addr.p9050 = addr0;
3847 card->irq = irq;
3848 card->bus_index = 1;
3849 card->first_line = cy_next_channel;
3850 card->nports = nchan;
3851 retval = cy_init_card(card);
Jiri Slaby31375532007-05-08 00:37:04 -07003852 if (retval)
3853 goto err_null;
Jiri Slaby58936d82007-05-08 00:36:13 -07003854
Jiri Slaby718c4ca2012-06-04 13:35:15 +02003855 pci_set_drvdata(pdev, card);
Jiri Slaby31375532007-05-08 00:37:04 -07003856
3857 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3858 device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
Jiri Slaby58936d82007-05-08 00:36:13 -07003859 /* enable interrupts in the PCI interface */
Jiri Slaby31375532007-05-08 00:37:04 -07003860 plx_ver = readb(addr2 + CyPLX_VER) & 0x0f;
Jiri Slaby58936d82007-05-08 00:36:13 -07003861 switch (plx_ver) {
3862 case PLX_9050:
Jiri Slaby31375532007-05-08 00:37:04 -07003863 cy_writeb(addr0 + 0x4c, 0x43);
Jiri Slaby58936d82007-05-08 00:36:13 -07003864 break;
3865
3866 case PLX_9060:
3867 case PLX_9080:
3868 default: /* Old boards, use PLX_9060 */
Jiri Slaby97e87f82009-06-11 12:29:27 +01003869 {
3870 struct RUNTIME_9060 __iomem *ctl_addr = addr0;
3871 plx_init(pdev, irq, ctl_addr);
3872 cy_writew(&ctl_addr->intr_ctrl_stat,
3873 readw(&ctl_addr->intr_ctrl_stat) | 0x0900);
Jiri Slaby58936d82007-05-08 00:36:13 -07003874 break;
3875 }
Jiri Slaby97e87f82009-06-11 12:29:27 +01003876 }
Jiri Slaby58936d82007-05-08 00:36:13 -07003877 }
3878
Jiri Slaby31375532007-05-08 00:37:04 -07003879 dev_info(&pdev->dev, "%s/PCI #%d found: %d channels starting from "
3880 "port %d.\n", card_name, card_no + 1, nchan, cy_next_channel);
Jiri Slaby734cc172012-08-07 21:47:47 +02003881 for (j = 0, i = cy_next_channel; i < cy_next_channel + nchan; i++, j++)
3882 tty_port_register_device(&card->ports[j].port,
3883 cy_serial_driver, i, &pdev->dev);
Jiri Slaby31375532007-05-08 00:37:04 -07003884 cy_next_channel += nchan;
3885
Jiri Slaby58936d82007-05-08 00:36:13 -07003886 return 0;
Jiri Slaby31375532007-05-08 00:37:04 -07003887err_null:
Jiri Slaby718c4ca2012-06-04 13:35:15 +02003888 card->base_addr = NULL;
3889 free_irq(irq, card);
Jiri Slaby31375532007-05-08 00:37:04 -07003890err_unmap:
Jiri Slaby24e6fd42008-10-13 10:34:09 +01003891 iounmap(addr0);
Jiri Slaby31375532007-05-08 00:37:04 -07003892 if (addr2)
Jiri Slaby24e6fd42008-10-13 10:34:09 +01003893 iounmap(addr2);
Jiri Slaby31375532007-05-08 00:37:04 -07003894err_reg:
3895 pci_release_regions(pdev);
3896err_dis:
3897 pci_disable_device(pdev);
3898err:
3899 return retval;
Jiri Slaby58936d82007-05-08 00:36:13 -07003900}
Jiri Slaby58936d82007-05-08 00:36:13 -07003901
Bill Pembertonae8d8a12012-11-19 13:26:18 -05003902static void cy_pci_remove(struct pci_dev *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003903{
Jiri Slaby38d09092007-05-08 00:36:10 -07003904 struct cyclades_card *cinfo = pci_get_drvdata(pdev);
Jiri Slaby191c5f12012-11-15 09:49:56 +01003905 unsigned int i, channel;
Jiri Slaby38d09092007-05-08 00:36:10 -07003906
Jiri Slaby85c93fa2007-05-08 00:36:23 -07003907 /* non-Z with old PLX */
Jiri Slaby2693f482009-06-11 12:31:06 +01003908 if (!cy_is_Z(cinfo) && (readb(cinfo->base_addr + CyPLX_VER) & 0x0f) ==
Jiri Slabyc2ad4c72007-05-08 00:36:32 -07003909 PLX_9050)
Jiri Slaby97e87f82009-06-11 12:29:27 +01003910 cy_writeb(cinfo->ctl_addr.p9050 + 0x4c, 0);
Jiri Slaby85c93fa2007-05-08 00:36:23 -07003911 else
3912#ifndef CONFIG_CYZ_INTR
Jiri Slaby2693f482009-06-11 12:31:06 +01003913 if (!cy_is_Z(cinfo))
Jiri Slaby85c93fa2007-05-08 00:36:23 -07003914#endif
Jiri Slaby97e87f82009-06-11 12:29:27 +01003915 cy_writew(&cinfo->ctl_addr.p9060->intr_ctrl_stat,
3916 readw(&cinfo->ctl_addr.p9060->intr_ctrl_stat) &
3917 ~0x0900);
Jiri Slaby85c93fa2007-05-08 00:36:23 -07003918
Jiri Slaby24e6fd42008-10-13 10:34:09 +01003919 iounmap(cinfo->base_addr);
Jiri Slaby97e87f82009-06-11 12:29:27 +01003920 if (cinfo->ctl_addr.p9050)
3921 iounmap(cinfo->ctl_addr.p9050);
Jiri Slaby38d09092007-05-08 00:36:10 -07003922 if (cinfo->irq
3923#ifndef CONFIG_CYZ_INTR
Jiri Slaby2693f482009-06-11 12:31:06 +01003924 && !cy_is_Z(cinfo)
Jiri Slaby38d09092007-05-08 00:36:10 -07003925#endif /* CONFIG_CYZ_INTR */
3926 )
3927 free_irq(cinfo->irq, cinfo);
3928 pci_release_regions(pdev);
3929
3930 cinfo->base_addr = NULL;
Jiri Slaby191c5f12012-11-15 09:49:56 +01003931 for (channel = 0, i = cinfo->first_line; i < cinfo->first_line +
3932 cinfo->nports; i++, channel++) {
Jiri Slaby6ad1ccc2007-05-08 00:36:22 -07003933 tty_unregister_device(cy_serial_driver, i);
Jiri Slaby191c5f12012-11-15 09:49:56 +01003934 tty_port_destroy(&cinfo->ports[channel].port);
3935 }
Jiri Slabydd025c02007-05-08 00:37:02 -07003936 cinfo->nports = 0;
3937 kfree(cinfo->ports);
Jiri Slaby38d09092007-05-08 00:36:10 -07003938}
3939
Jiri Slaby6747cd92007-05-08 00:36:34 -07003940static struct pci_driver cy_pci_driver = {
3941 .name = "cyclades",
3942 .id_table = cy_pci_dev_id,
3943 .probe = cy_pci_probe,
Bill Pemberton91116cb2012-11-19 13:21:06 -05003944 .remove = cy_pci_remove
Jiri Slaby6747cd92007-05-08 00:36:34 -07003945};
3946#endif
3947
Alexey Dobriyan444697d2009-03-31 15:19:15 -07003948static int cyclades_proc_show(struct seq_file *m, void *v)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003949{
Jiri Slaby02f11752006-12-08 02:39:28 -08003950 struct cyclades_port *info;
Jiri Slabydd025c02007-05-08 00:37:02 -07003951 unsigned int i, j;
Jiri Slaby02f11752006-12-08 02:39:28 -08003952 __u32 cur_jifs = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003953
Alexey Dobriyan444697d2009-03-31 15:19:15 -07003954 seq_puts(m, "Dev TimeOpen BytesOut IdleOut BytesIn "
Jiri Slaby02f11752006-12-08 02:39:28 -08003955 "IdleIn Overruns Ldisc\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003956
Jiri Slaby02f11752006-12-08 02:39:28 -08003957 /* Output one line for each known port */
Jiri Slabydd025c02007-05-08 00:37:02 -07003958 for (i = 0; i < NR_CARDS; i++)
3959 for (j = 0; j < cy_card[i].nports; j++) {
3960 info = &cy_card[i].ports[j];
Jiri Slaby02f11752006-12-08 02:39:28 -08003961
Jiri Slabyd13549f2009-09-19 13:13:12 -07003962 if (info->port.count) {
3963 /* XXX is the ldisc num worth this? */
3964 struct tty_struct *tty;
3965 struct tty_ldisc *ld;
3966 int num = 0;
3967 tty = tty_port_tty_get(&info->port);
3968 if (tty) {
3969 ld = tty_ldisc_ref(tty);
3970 if (ld) {
3971 num = ld->ops->num;
3972 tty_ldisc_deref(ld);
3973 }
3974 tty_kref_put(tty);
3975 }
Alexey Dobriyan444697d2009-03-31 15:19:15 -07003976 seq_printf(m, "%3d %8lu %10lu %8lu "
Jiri Slabyd13549f2009-09-19 13:13:12 -07003977 "%10lu %8lu %9lu %6d\n", info->line,
Jiri Slabydd025c02007-05-08 00:37:02 -07003978 (cur_jifs - info->idle_stats.in_use) /
3979 HZ, info->idle_stats.xmit_bytes,
3980 (cur_jifs - info->idle_stats.xmit_idle)/
3981 HZ, info->idle_stats.recv_bytes,
3982 (cur_jifs - info->idle_stats.recv_idle)/
3983 HZ, info->idle_stats.overruns,
Jiri Slabyd13549f2009-09-19 13:13:12 -07003984 num);
3985 } else
Alexey Dobriyan444697d2009-03-31 15:19:15 -07003986 seq_printf(m, "%3d %8lu %10lu %8lu "
Jiri Slabydd025c02007-05-08 00:37:02 -07003987 "%10lu %8lu %9lu %6ld\n",
3988 info->line, 0L, 0L, 0L, 0L, 0L, 0L, 0L);
Jiri Slaby02f11752006-12-08 02:39:28 -08003989 }
Alexey Dobriyan444697d2009-03-31 15:19:15 -07003990 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003991}
3992
Alexey Dobriyan444697d2009-03-31 15:19:15 -07003993static int cyclades_proc_open(struct inode *inode, struct file *file)
3994{
3995 return single_open(file, cyclades_proc_show, NULL);
3996}
3997
3998static const struct file_operations cyclades_proc_fops = {
3999 .owner = THIS_MODULE,
4000 .open = cyclades_proc_open,
4001 .read = seq_read,
4002 .llseek = seq_lseek,
4003 .release = single_release,
4004};
4005
Linus Torvalds1da177e2005-04-16 15:20:36 -07004006/* The serial driver boot-time initialization code!
4007 Hardware I/O ports are mapped to character special devices on a
4008 first found, first allocated manner. That is, this code searches
4009 for Cyclom cards in the system. As each is found, it is probed
4010 to discover how many chips (and thus how many ports) are present.
4011 These ports are mapped to the tty ports 32 and upward in monotonic
4012 fashion. If an 8-port card is replaced with a 16-port card, the
4013 port mapping on a following card will shift.
4014
4015 This approach is different from what is used in the other serial
4016 device driver because the Cyclom is more properly a multiplexer,
4017 not just an aggregation of serial ports on one card.
4018
4019 If there are more cards with more ports than have been
4020 statically allocated above, a warning is printed and the
4021 extra ports are ignored.
4022 */
4023
Jeff Dikeb68e31d2006-10-02 02:17:18 -07004024static const struct tty_operations cy_ops = {
Jiri Slaby02f11752006-12-08 02:39:28 -08004025 .open = cy_open,
4026 .close = cy_close,
4027 .write = cy_write,
4028 .put_char = cy_put_char,
4029 .flush_chars = cy_flush_chars,
4030 .write_room = cy_write_room,
4031 .chars_in_buffer = cy_chars_in_buffer,
4032 .flush_buffer = cy_flush_buffer,
4033 .ioctl = cy_ioctl,
4034 .throttle = cy_throttle,
4035 .unthrottle = cy_unthrottle,
4036 .set_termios = cy_set_termios,
4037 .stop = cy_stop,
4038 .start = cy_start,
4039 .hangup = cy_hangup,
4040 .break_ctl = cy_break,
4041 .wait_until_sent = cy_wait_until_sent,
Jiri Slaby02f11752006-12-08 02:39:28 -08004042 .tiocmget = cy_tiocmget,
4043 .tiocmset = cy_tiocmset,
Alan Cox05871022010-09-16 18:21:52 +01004044 .get_icount = cy_get_icount,
Alexey Dobriyan444697d2009-03-31 15:19:15 -07004045 .proc_fops = &cyclades_proc_fops,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004046};
4047
Jiri Slaby02f11752006-12-08 02:39:28 -08004048static int __init cy_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004049{
Jiri Slabydd025c02007-05-08 00:37:02 -07004050 unsigned int nboards;
Jiri Slaby9dacf3b2007-05-08 00:36:20 -07004051 int retval = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004052
Jiri Slaby02f11752006-12-08 02:39:28 -08004053 cy_serial_driver = alloc_tty_driver(NR_PORTS);
4054 if (!cy_serial_driver)
Jiri Slaby9dacf3b2007-05-08 00:36:20 -07004055 goto err;
Jiri Slaby21719192007-05-08 00:36:42 -07004056
Michal Marek64a14b52011-04-01 12:41:20 +02004057 printk(KERN_INFO "Cyclades driver " CY_VERSION "\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004058
Jiri Slaby02f11752006-12-08 02:39:28 -08004059 /* Initialize the tty_driver structure */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004060
Jiri Slaby02f11752006-12-08 02:39:28 -08004061 cy_serial_driver->driver_name = "cyclades";
4062 cy_serial_driver->name = "ttyC";
4063 cy_serial_driver->major = CYCLADES_MAJOR;
4064 cy_serial_driver->minor_start = 0;
4065 cy_serial_driver->type = TTY_DRIVER_TYPE_SERIAL;
4066 cy_serial_driver->subtype = SERIAL_TYPE_NORMAL;
4067 cy_serial_driver->init_termios = tty_std_termios;
4068 cy_serial_driver->init_termios.c_cflag =
4069 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
Jiri Slaby6ad1ccc2007-05-08 00:36:22 -07004070 cy_serial_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
Jiri Slaby02f11752006-12-08 02:39:28 -08004071 tty_set_operations(cy_serial_driver, &cy_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004072
Jiri Slaby9dacf3b2007-05-08 00:36:20 -07004073 retval = tty_register_driver(cy_serial_driver);
4074 if (retval) {
4075 printk(KERN_ERR "Couldn't register Cyclades serial driver\n");
4076 goto err_frtty;
4077 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004078
Jiri Slaby02f11752006-12-08 02:39:28 -08004079 /* the code below is responsible to find the boards. Each different
4080 type of board has its own detection routine. If a board is found,
4081 the next cy_card structure available is set by the detection
4082 routine. These functions are responsible for checking the
4083 availability of cy_card and cy_port data structures and updating
4084 the cy_next_channel. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004085
Jiri Slaby02f11752006-12-08 02:39:28 -08004086 /* look for isa boards */
Jiri Slaby14a55a62007-05-08 00:36:18 -07004087 nboards = cy_detect_isa();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004088
Jiri Slaby6747cd92007-05-08 00:36:34 -07004089#ifdef CONFIG_PCI
Jiri Slaby02f11752006-12-08 02:39:28 -08004090 /* look for pci boards */
Jiri Slaby6747cd92007-05-08 00:36:34 -07004091 retval = pci_register_driver(&cy_pci_driver);
Jesper Juhld941ea72007-10-18 03:06:23 -07004092 if (retval && !nboards) {
4093 tty_unregister_driver(cy_serial_driver);
4094 goto err_frtty;
4095 }
Jiri Slaby6747cd92007-05-08 00:36:34 -07004096#endif
Jiri Slaby9dacf3b2007-05-08 00:36:20 -07004097
4098 return 0;
Jiri Slaby9dacf3b2007-05-08 00:36:20 -07004099err_frtty:
4100 put_tty_driver(cy_serial_driver);
4101err:
4102 return retval;
Jiri Slaby02f11752006-12-08 02:39:28 -08004103} /* cy_init */
4104
4105static void __exit cy_cleanup_module(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004106{
Jiri Slabydd025c02007-05-08 00:37:02 -07004107 struct cyclades_card *card;
Jiri Slaby65f76a82007-10-18 03:06:22 -07004108 unsigned int i, e1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004109
4110#ifndef CONFIG_CYZ_INTR
Jiri Slabyb7050902007-05-08 00:35:48 -07004111 del_timer_sync(&cyz_timerlist);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004112#endif /* CONFIG_CYZ_INTR */
4113
Alan Cox15ed6cc2008-04-30 00:53:55 -07004114 e1 = tty_unregister_driver(cy_serial_driver);
4115 if (e1)
Jiri Slaby21719192007-05-08 00:36:42 -07004116 printk(KERN_ERR "failed to unregister Cyclades serial "
4117 "driver(%d)\n", e1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004118
Jiri Slaby6747cd92007-05-08 00:36:34 -07004119#ifdef CONFIG_PCI
4120 pci_unregister_driver(&cy_pci_driver);
4121#endif
4122
Jiri Slaby02f11752006-12-08 02:39:28 -08004123 for (i = 0; i < NR_CARDS; i++) {
Jiri Slabydd025c02007-05-08 00:37:02 -07004124 card = &cy_card[i];
4125 if (card->base_addr) {
Jiri Slaby85c93fa2007-05-08 00:36:23 -07004126 /* clear interrupt */
Jiri Slabydd025c02007-05-08 00:37:02 -07004127 cy_writeb(card->base_addr + Cy_ClrIntr, 0);
4128 iounmap(card->base_addr);
Jiri Slaby97e87f82009-06-11 12:29:27 +01004129 if (card->ctl_addr.p9050)
4130 iounmap(card->ctl_addr.p9050);
Jiri Slabydd025c02007-05-08 00:37:02 -07004131 if (card->irq
Linus Torvalds1da177e2005-04-16 15:20:36 -07004132#ifndef CONFIG_CYZ_INTR
Jiri Slaby2693f482009-06-11 12:31:06 +01004133 && !cy_is_Z(card)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004134#endif /* CONFIG_CYZ_INTR */
Jiri Slaby02f11752006-12-08 02:39:28 -08004135 )
Jiri Slabydd025c02007-05-08 00:37:02 -07004136 free_irq(card->irq, card);
Jiri Slaby65f76a82007-10-18 03:06:22 -07004137 for (e1 = card->first_line; e1 < card->first_line +
Jiri Slabydd025c02007-05-08 00:37:02 -07004138 card->nports; e1++)
Jiri Slaby6ad1ccc2007-05-08 00:36:22 -07004139 tty_unregister_device(cy_serial_driver, e1);
Jiri Slabydd025c02007-05-08 00:37:02 -07004140 kfree(card->ports);
Jiri Slaby02f11752006-12-08 02:39:28 -08004141 }
4142 }
Jiri Slabyf2462bf2007-05-08 00:37:01 -07004143
4144 put_tty_driver(cy_serial_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004145} /* cy_cleanup_module */
4146
4147module_init(cy_init);
4148module_exit(cy_cleanup_module);
4149
4150MODULE_LICENSE("GPL");
Jiri Slabyc8e16932007-05-08 00:37:05 -07004151MODULE_VERSION(CY_VERSION);
Scott James Remnant9f56fad2009-04-06 17:33:04 +01004152MODULE_ALIAS_CHARDEV_MAJOR(CYCLADES_MAJOR);
Ben Hutchingse6c4ef92010-01-13 23:34:18 +00004153MODULE_FIRMWARE("cyzfirm.bin");