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