History

tty: cyclades, remove this orphan

The Cyclades driver was orphaned by commit d459883e6c54 (MAINTAINERS: remove two dead e-mail) 13 years ago. Noone stepped up to take care of them and to fix all the issues the driver has. On the top of that, there is no way to obtain the firmware for Z cards from the vendor as cyclades.com ceased to exist. So it's time to drop the driver with all its traces.

Jiri Slaby committed 5 years ago

Commit f76edd81 parent 5a3c96e18 files · +5 −5057Browse files

Unified · Split

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