Kernel

Kernel Git Source Tree

Root/drivers/tty/cyclades.c

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

Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9

Kernel

Kernel Git Source Tree

Root/drivers/tty/cyclades.c

interactive