Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
con3215.c
Go to the documentation of this file.
1 /*
2  * 3215 line mode terminal driver.
3  *
4  * Copyright IBM Corp. 1999, 2009
5  * Author(s): Martin Schwidefsky <[email protected]>
6  *
7  * Updated:
8  * Aug-2000: Added tab support
9  * Dan Morrison, IBM Corporation <[email protected]>
10  */
11 
12 #include <linux/module.h>
13 #include <linux/types.h>
14 #include <linux/kdev_t.h>
15 #include <linux/tty.h>
16 #include <linux/tty_flip.h>
17 #include <linux/vt_kern.h>
18 #include <linux/init.h>
19 #include <linux/console.h>
20 #include <linux/interrupt.h>
21 #include <linux/err.h>
22 #include <linux/reboot.h>
23 #include <linux/serial.h> /* ASYNC_* flags */
24 #include <linux/slab.h>
25 #include <asm/ccwdev.h>
26 #include <asm/cio.h>
27 #include <asm/io.h>
28 #include <asm/ebcdic.h>
29 #include <asm/uaccess.h>
30 #include <asm/delay.h>
31 #include <asm/cpcmd.h>
32 #include <asm/setup.h>
33 
34 #include "ctrlchar.h"
35 
36 #define NR_3215 1
37 #define NR_3215_REQ (4*NR_3215)
38 #define RAW3215_BUFFER_SIZE 65536 /* output buffer size */
39 #define RAW3215_INBUF_SIZE 256 /* input buffer size */
40 #define RAW3215_MIN_SPACE 128 /* minimum free space for wakeup */
41 #define RAW3215_MIN_WRITE 1024 /* min. length for immediate output */
42 #define RAW3215_MAX_BYTES 3968 /* max. bytes to write with one ssch */
43 #define RAW3215_MAX_NEWLINE 50 /* max. lines to write with one ssch */
44 #define RAW3215_NR_CCWS 3
45 #define RAW3215_TIMEOUT HZ/10 /* time for delayed output */
46 
47 #define RAW3215_WORKING 4 /* set if a request is being worked on */
48 #define RAW3215_THROTTLED 8 /* set if reading is disabled */
49 #define RAW3215_STOPPED 16 /* set if writing is disabled */
50 #define RAW3215_TIMER_RUNS 64 /* set if the output delay timer is on */
51 #define RAW3215_FLUSHING 128 /* set to flush buffer (no delay) */
52 
53 #define TAB_STOP_SIZE 8 /* tab stop size */
54 
55 /*
56  * Request types for a 3215 device
57  */
60 };
61 
62 /*
63  * Request structure for a 3215 device
64  */
65 struct raw3215_req {
66  enum raw3215_type type; /* type of the request */
67  int start, len; /* start index & len in output buffer */
68  int delayable; /* indication to wait for more data */
69  int residual; /* residual count for read request */
70  struct ccw1 ccws[RAW3215_NR_CCWS]; /* space for the channel program */
71  struct raw3215_info *info; /* pointer to main structure */
72  struct raw3215_req *next; /* pointer to next request */
73 } __attribute__ ((aligned(8)));
74 
75 struct raw3215_info {
76  struct tty_port port;
77  struct ccw_device *cdev; /* device for tty driver */
78  spinlock_t *lock; /* pointer to irq lock */
79  int flags; /* state flags */
80  char *buffer; /* pointer to output buffer */
81  char *inbuf; /* pointer to input buffer */
82  int head; /* first free byte in output buffer */
83  int count; /* number of bytes in output buffer */
84  int written; /* number of bytes in write requests */
85  struct raw3215_req *queued_read; /* pointer to queued read requests */
86  struct raw3215_req *queued_write;/* pointer to queued write requests */
87  struct tasklet_struct tlet; /* tasklet to invoke tty_wakeup */
88  wait_queue_head_t empty_wait; /* wait queue for flushing */
89  struct timer_list timer; /* timer for delayed output */
90  int line_pos; /* position on the line (for tabs) */
91  char ubuffer[80]; /* copy_from_user buffer */
92 };
93 
94 /* array of 3215 devices structures */
95 static struct raw3215_info *raw3215[NR_3215];
96 /* spinlock to protect the raw3215 array */
97 static DEFINE_SPINLOCK(raw3215_device_lock);
98 /* list of free request structures */
99 static struct raw3215_req *raw3215_freelist;
100 /* spinlock to protect free list */
101 static spinlock_t raw3215_freelist_lock;
102 
103 static struct tty_driver *tty3215_driver;
104 
105 /*
106  * Get a request structure from the free list
107  */
108 static inline struct raw3215_req *raw3215_alloc_req(void)
109 {
110  struct raw3215_req *req;
111  unsigned long flags;
112 
113  spin_lock_irqsave(&raw3215_freelist_lock, flags);
114  req = raw3215_freelist;
115  raw3215_freelist = req->next;
116  spin_unlock_irqrestore(&raw3215_freelist_lock, flags);
117  return req;
118 }
119 
120 /*
121  * Put a request structure back to the free list
122  */
123 static inline void raw3215_free_req(struct raw3215_req *req)
124 {
125  unsigned long flags;
126 
127  if (req->type == RAW3215_FREE)
128  return; /* don't free a free request */
129  req->type = RAW3215_FREE;
130  spin_lock_irqsave(&raw3215_freelist_lock, flags);
131  req->next = raw3215_freelist;
132  raw3215_freelist = req;
133  spin_unlock_irqrestore(&raw3215_freelist_lock, flags);
134 }
135 
136 /*
137  * Set up a read request that reads up to 160 byte from the 3215 device.
138  * If there is a queued read request it is used, but that shouldn't happen
139  * because a 3215 terminal won't accept a new read before the old one is
140  * completed.
141  */
142 static void raw3215_mk_read_req(struct raw3215_info *raw)
143 {
144  struct raw3215_req *req;
145  struct ccw1 *ccw;
146 
147  /* there can only be ONE read request at a time */
148  req = raw->queued_read;
149  if (req == NULL) {
150  /* no queued read request, use new req structure */
151  req = raw3215_alloc_req();
152  req->type = RAW3215_READ;
153  req->info = raw;
154  raw->queued_read = req;
155  }
156 
157  ccw = req->ccws;
158  ccw->cmd_code = 0x0A; /* read inquiry */
159  ccw->flags = 0x20; /* ignore incorrect length */
160  ccw->count = 160;
161  ccw->cda = (__u32) __pa(raw->inbuf);
162 }
163 
164 /*
165  * Set up a write request with the information from the main structure.
166  * A ccw chain is created that writes as much as possible from the output
167  * buffer to the 3215 device. If a queued write exists it is replaced by
168  * the new, probably lengthened request.
169  */
170 static void raw3215_mk_write_req(struct raw3215_info *raw)
171 {
172  struct raw3215_req *req;
173  struct ccw1 *ccw;
174  int len, count, ix, lines;
175 
176  if (raw->count <= raw->written)
177  return;
178  /* check if there is a queued write request */
179  req = raw->queued_write;
180  if (req == NULL) {
181  /* no queued write request, use new req structure */
182  req = raw3215_alloc_req();
183  req->type = RAW3215_WRITE;
184  req->info = raw;
185  raw->queued_write = req;
186  } else {
187  raw->written -= req->len;
188  }
189 
190  ccw = req->ccws;
191  req->start = (raw->head - raw->count + raw->written) &
192  (RAW3215_BUFFER_SIZE - 1);
193  /*
194  * now we have to count newlines. We can at max accept
195  * RAW3215_MAX_NEWLINE newlines in a single ssch due to
196  * a restriction in VM
197  */
198  lines = 0;
199  ix = req->start;
200  while (lines < RAW3215_MAX_NEWLINE && ix != raw->head) {
201  if (raw->buffer[ix] == 0x15)
202  lines++;
203  ix = (ix + 1) & (RAW3215_BUFFER_SIZE - 1);
204  }
205  len = ((ix - 1 - req->start) & (RAW3215_BUFFER_SIZE - 1)) + 1;
206  if (len > RAW3215_MAX_BYTES)
207  len = RAW3215_MAX_BYTES;
208  req->len = len;
209  raw->written += len;
210 
211  /* set the indication if we should try to enlarge this request */
212  req->delayable = (ix == raw->head) && (len < RAW3215_MIN_WRITE);
213 
214  ix = req->start;
215  while (len > 0) {
216  if (ccw > req->ccws)
217  ccw[-1].flags |= 0x40; /* use command chaining */
218  ccw->cmd_code = 0x01; /* write, auto carrier return */
219  ccw->flags = 0x20; /* ignore incorrect length ind. */
220  ccw->cda =
221  (__u32) __pa(raw->buffer + ix);
222  count = len;
223  if (ix + count > RAW3215_BUFFER_SIZE)
224  count = RAW3215_BUFFER_SIZE - ix;
225  ccw->count = count;
226  len -= count;
227  ix = (ix + count) & (RAW3215_BUFFER_SIZE - 1);
228  ccw++;
229  }
230  /*
231  * Add a NOP to the channel program. 3215 devices are purely
232  * emulated and its much better to avoid the channel end
233  * interrupt in this case.
234  */
235  if (ccw > req->ccws)
236  ccw[-1].flags |= 0x40; /* use command chaining */
237  ccw->cmd_code = 0x03; /* NOP */
238  ccw->flags = 0;
239  ccw->cda = 0;
240  ccw->count = 1;
241 }
242 
243 /*
244  * Start a read or a write request
245  */
246 static void raw3215_start_io(struct raw3215_info *raw)
247 {
248  struct raw3215_req *req;
249  int res;
250 
251  req = raw->queued_read;
252  if (req != NULL &&
253  !(raw->flags & (RAW3215_WORKING | RAW3215_THROTTLED))) {
254  /* dequeue request */
255  raw->queued_read = NULL;
256  res = ccw_device_start(raw->cdev, req->ccws,
257  (unsigned long) req, 0, 0);
258  if (res != 0) {
259  /* do_IO failed, put request back to queue */
260  raw->queued_read = req;
261  } else {
262  raw->flags |= RAW3215_WORKING;
263  }
264  }
265  req = raw->queued_write;
266  if (req != NULL &&
267  !(raw->flags & (RAW3215_WORKING | RAW3215_STOPPED))) {
268  /* dequeue request */
269  raw->queued_write = NULL;
270  res = ccw_device_start(raw->cdev, req->ccws,
271  (unsigned long) req, 0, 0);
272  if (res != 0) {
273  /* do_IO failed, put request back to queue */
274  raw->queued_write = req;
275  } else {
276  raw->flags |= RAW3215_WORKING;
277  }
278  }
279 }
280 
281 /*
282  * Function to start a delayed output after RAW3215_TIMEOUT seconds
283  */
284 static void raw3215_timeout(unsigned long __data)
285 {
286  struct raw3215_info *raw = (struct raw3215_info *) __data;
287  unsigned long flags;
288 
289  spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
290  if (raw->flags & RAW3215_TIMER_RUNS) {
291  del_timer(&raw->timer);
292  raw->flags &= ~RAW3215_TIMER_RUNS;
293  if (!(raw->port.flags & ASYNC_SUSPENDED)) {
294  raw3215_mk_write_req(raw);
295  raw3215_start_io(raw);
296  }
297  }
298  spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
299 }
300 
301 /*
302  * Function to conditionally start an IO. A read is started immediately,
303  * a write is only started immediately if the flush flag is on or the
304  * amount of data is bigger than RAW3215_MIN_WRITE. If a write is not
305  * done immediately a timer is started with a delay of RAW3215_TIMEOUT.
306  */
307 static inline void raw3215_try_io(struct raw3215_info *raw)
308 {
309  if (!(raw->port.flags & ASYNC_INITIALIZED) ||
310  (raw->port.flags & ASYNC_SUSPENDED))
311  return;
312  if (raw->queued_read != NULL)
313  raw3215_start_io(raw);
314  else if (raw->queued_write != NULL) {
315  if ((raw->queued_write->delayable == 0) ||
316  (raw->flags & RAW3215_FLUSHING)) {
317  /* execute write requests bigger than minimum size */
318  raw3215_start_io(raw);
319  if (raw->flags & RAW3215_TIMER_RUNS) {
320  del_timer(&raw->timer);
321  raw->flags &= ~RAW3215_TIMER_RUNS;
322  }
323  } else if (!(raw->flags & RAW3215_TIMER_RUNS)) {
324  /* delay small writes */
325  raw->timer.expires = RAW3215_TIMEOUT + jiffies;
326  add_timer(&raw->timer);
327  raw->flags |= RAW3215_TIMER_RUNS;
328  }
329  }
330 }
331 
332 /*
333  * Call tty_wakeup from tasklet context
334  */
335 static void raw3215_wakeup(unsigned long data)
336 {
337  struct raw3215_info *raw = (struct raw3215_info *) data;
338  struct tty_struct *tty;
339 
340  tty = tty_port_tty_get(&raw->port);
341  if (tty) {
342  tty_wakeup(tty);
343  tty_kref_put(tty);
344  }
345 }
346 
347 /*
348  * Try to start the next IO and wake up processes waiting on the tty.
349  */
350 static void raw3215_next_io(struct raw3215_info *raw, struct tty_struct *tty)
351 {
352  raw3215_mk_write_req(raw);
353  raw3215_try_io(raw);
354  if (tty && RAW3215_BUFFER_SIZE - raw->count >= RAW3215_MIN_SPACE)
355  tasklet_schedule(&raw->tlet);
356 }
357 
358 /*
359  * Interrupt routine, called from common io layer
360  */
361 static void raw3215_irq(struct ccw_device *cdev, unsigned long intparm,
362  struct irb *irb)
363 {
364  struct raw3215_info *raw;
365  struct raw3215_req *req;
366  struct tty_struct *tty;
367  int cstat, dstat;
368  int count;
369 
370  raw = dev_get_drvdata(&cdev->dev);
371  req = (struct raw3215_req *) intparm;
372  tty = tty_port_tty_get(&raw->port);
373  cstat = irb->scsw.cmd.cstat;
374  dstat = irb->scsw.cmd.dstat;
375  if (cstat != 0)
376  raw3215_next_io(raw, tty);
377  if (dstat & 0x01) { /* we got a unit exception */
378  dstat &= ~0x01; /* we can ignore it */
379  }
380  switch (dstat) {
381  case 0x80:
382  if (cstat != 0)
383  break;
384  /* Attention interrupt, someone hit the enter key */
385  raw3215_mk_read_req(raw);
386  raw3215_next_io(raw, tty);
387  break;
388  case 0x08:
389  case 0x0C:
390  /* Channel end interrupt. */
391  if ((raw = req->info) == NULL)
392  goto put_tty; /* That shouldn't happen ... */
393  if (req->type == RAW3215_READ) {
394  /* store residual count, then wait for device end */
395  req->residual = irb->scsw.cmd.count;
396  }
397  if (dstat == 0x08)
398  break;
399  case 0x04:
400  /* Device end interrupt. */
401  if ((raw = req->info) == NULL)
402  goto put_tty; /* That shouldn't happen ... */
403  if (req->type == RAW3215_READ && tty != NULL) {
404  unsigned int cchar;
405 
406  count = 160 - req->residual;
407  EBCASC(raw->inbuf, count);
408  cchar = ctrlchar_handle(raw->inbuf, count, tty);
409  switch (cchar & CTRLCHAR_MASK) {
410  case CTRLCHAR_SYSRQ:
411  break;
412 
413  case CTRLCHAR_CTRL:
414  tty_insert_flip_char(tty, cchar, TTY_NORMAL);
416  break;
417 
418  case CTRLCHAR_NONE:
419  if (count < 2 ||
420  (strncmp(raw->inbuf+count-2, "\252n", 2) &&
421  strncmp(raw->inbuf+count-2, "^n", 2)) ) {
422  /* add the auto \n */
423  raw->inbuf[count] = '\n';
424  count++;
425  } else
426  count -= 2;
427  tty_insert_flip_string(tty, raw->inbuf, count);
429  break;
430  }
431  } else if (req->type == RAW3215_WRITE) {
432  raw->count -= req->len;
433  raw->written -= req->len;
434  }
435  raw->flags &= ~RAW3215_WORKING;
436  raw3215_free_req(req);
437  /* check for empty wait */
438  if (waitqueue_active(&raw->empty_wait) &&
439  raw->queued_write == NULL &&
440  raw->queued_read == NULL) {
442  }
443  raw3215_next_io(raw, tty);
444  break;
445  default:
446  /* Strange interrupt, I'll do my best to clean up */
447  if (req != NULL && req->type != RAW3215_FREE) {
448  if (req->type == RAW3215_WRITE) {
449  raw->count -= req->len;
450  raw->written -= req->len;
451  }
452  raw->flags &= ~RAW3215_WORKING;
453  raw3215_free_req(req);
454  }
455  raw3215_next_io(raw, tty);
456  }
457 put_tty:
458  tty_kref_put(tty);
459 }
460 
461 /*
462  * Drop the oldest line from the output buffer.
463  */
464 static void raw3215_drop_line(struct raw3215_info *raw)
465 {
466  int ix;
467  char ch;
468 
469  BUG_ON(raw->written != 0);
470  ix = (raw->head - raw->count) & (RAW3215_BUFFER_SIZE - 1);
471  while (raw->count > 0) {
472  ch = raw->buffer[ix];
473  ix = (ix + 1) & (RAW3215_BUFFER_SIZE - 1);
474  raw->count--;
475  if (ch == 0x15)
476  break;
477  }
478  raw->head = ix;
479 }
480 
481 /*
482  * Wait until length bytes are available int the output buffer.
483  * Has to be called with the s390irq lock held. Can be called
484  * disabled.
485  */
486 static void raw3215_make_room(struct raw3215_info *raw, unsigned int length)
487 {
488  while (RAW3215_BUFFER_SIZE - raw->count < length) {
489  /* While console is frozen for suspend we have no other
490  * choice but to drop message from the buffer to make
491  * room for even more messages. */
492  if (raw->port.flags & ASYNC_SUSPENDED) {
493  raw3215_drop_line(raw);
494  continue;
495  }
496  /* there might be a request pending */
497  raw->flags |= RAW3215_FLUSHING;
498  raw3215_mk_write_req(raw);
499  raw3215_try_io(raw);
500  raw->flags &= ~RAW3215_FLUSHING;
501 #ifdef CONFIG_TN3215_CONSOLE
502  wait_cons_dev();
503 #endif
504  /* Enough room freed up ? */
505  if (RAW3215_BUFFER_SIZE - raw->count >= length)
506  break;
507  /* there might be another cpu waiting for the lock */
508  spin_unlock(get_ccwdev_lock(raw->cdev));
509  udelay(100);
510  spin_lock(get_ccwdev_lock(raw->cdev));
511  }
512 }
513 
514 /*
515  * String write routine for 3215 devices
516  */
517 static void raw3215_write(struct raw3215_info *raw, const char *str,
518  unsigned int length)
519 {
520  unsigned long flags;
521  int c, count;
522 
523  while (length > 0) {
524  spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
525  count = (length > RAW3215_BUFFER_SIZE) ?
526  RAW3215_BUFFER_SIZE : length;
527  length -= count;
528 
529  raw3215_make_room(raw, count);
530 
531  /* copy string to output buffer and convert it to EBCDIC */
532  while (1) {
533  c = min_t(int, count,
535  RAW3215_BUFFER_SIZE - raw->head));
536  if (c <= 0)
537  break;
538  memcpy(raw->buffer + raw->head, str, c);
539  ASCEBC(raw->buffer + raw->head, c);
540  raw->head = (raw->head + c) & (RAW3215_BUFFER_SIZE - 1);
541  raw->count += c;
542  raw->line_pos += c;
543  str += c;
544  count -= c;
545  }
546  if (!(raw->flags & RAW3215_WORKING)) {
547  raw3215_mk_write_req(raw);
548  /* start or queue request */
549  raw3215_try_io(raw);
550  }
551  spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
552  }
553 }
554 
555 /*
556  * Put character routine for 3215 devices
557  */
558 static void raw3215_putchar(struct raw3215_info *raw, unsigned char ch)
559 {
560  unsigned long flags;
561  unsigned int length, i;
562 
563  spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
564  if (ch == '\t') {
565  length = TAB_STOP_SIZE - (raw->line_pos%TAB_STOP_SIZE);
566  raw->line_pos += length;
567  ch = ' ';
568  } else if (ch == '\n') {
569  length = 1;
570  raw->line_pos = 0;
571  } else {
572  length = 1;
573  raw->line_pos++;
574  }
575  raw3215_make_room(raw, length);
576 
577  for (i = 0; i < length; i++) {
578  raw->buffer[raw->head] = (char) _ascebc[(int) ch];
579  raw->head = (raw->head + 1) & (RAW3215_BUFFER_SIZE - 1);
580  raw->count++;
581  }
582  if (!(raw->flags & RAW3215_WORKING)) {
583  raw3215_mk_write_req(raw);
584  /* start or queue request */
585  raw3215_try_io(raw);
586  }
587  spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
588 }
589 
590 /*
591  * Flush routine, it simply sets the flush flag and tries to start
592  * pending IO.
593  */
594 static void raw3215_flush_buffer(struct raw3215_info *raw)
595 {
596  unsigned long flags;
597 
598  spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
599  if (raw->count > 0) {
600  raw->flags |= RAW3215_FLUSHING;
601  raw3215_try_io(raw);
602  raw->flags &= ~RAW3215_FLUSHING;
603  }
604  spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
605 }
606 
607 /*
608  * Fire up a 3215 device.
609  */
610 static int raw3215_startup(struct raw3215_info *raw)
611 {
612  unsigned long flags;
613 
614  if (raw->port.flags & ASYNC_INITIALIZED)
615  return 0;
616  raw->line_pos = 0;
617  raw->port.flags |= ASYNC_INITIALIZED;
618  spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
619  raw3215_try_io(raw);
620  spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
621 
622  return 0;
623 }
624 
625 /*
626  * Shutdown a 3215 device.
627  */
628 static void raw3215_shutdown(struct raw3215_info *raw)
629 {
631  unsigned long flags;
632 
633  if (!(raw->port.flags & ASYNC_INITIALIZED))
634  return;
635  /* Wait for outstanding requests, then free irq */
636  spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
637  if ((raw->flags & RAW3215_WORKING) ||
638  raw->queued_write != NULL ||
639  raw->queued_read != NULL) {
640  raw->port.flags |= ASYNC_CLOSING;
641  add_wait_queue(&raw->empty_wait, &wait);
643  spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
644  schedule();
645  spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
648  raw->port.flags &= ~(ASYNC_INITIALIZED | ASYNC_CLOSING);
649  }
650  spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
651 }
652 
653 static struct raw3215_info *raw3215_alloc_info(void)
654 {
655  struct raw3215_info *info;
656 
657  info = kzalloc(sizeof(struct raw3215_info), GFP_KERNEL | GFP_DMA);
658  if (!info)
659  return NULL;
660 
661  info->buffer = kzalloc(RAW3215_BUFFER_SIZE, GFP_KERNEL | GFP_DMA);
662  info->inbuf = kzalloc(RAW3215_INBUF_SIZE, GFP_KERNEL | GFP_DMA);
663  if (!info->buffer || !info->inbuf) {
664  kfree(info);
665  return NULL;
666  }
667 
668  setup_timer(&info->timer, raw3215_timeout, (unsigned long)info);
670  tasklet_init(&info->tlet, raw3215_wakeup, (unsigned long)info);
671  tty_port_init(&info->port);
672 
673  return info;
674 }
675 
676 static void raw3215_free_info(struct raw3215_info *raw)
677 {
678  kfree(raw->inbuf);
679  kfree(raw->buffer);
680  kfree(raw);
681 }
682 
683 static int raw3215_probe (struct ccw_device *cdev)
684 {
685  struct raw3215_info *raw;
686  int line;
687 
688  /* Console is special. */
689  if (raw3215[0] && (raw3215[0] == dev_get_drvdata(&cdev->dev)))
690  return 0;
691 
692  raw = raw3215_alloc_info();
693  if (raw == NULL)
694  return -ENOMEM;
695 
696  raw->cdev = cdev;
697  dev_set_drvdata(&cdev->dev, raw);
698  cdev->handler = raw3215_irq;
699 
700  spin_lock(&raw3215_device_lock);
701  for (line = 0; line < NR_3215; line++) {
702  if (!raw3215[line]) {
703  raw3215[line] = raw;
704  break;
705  }
706  }
707  spin_unlock(&raw3215_device_lock);
708  if (line == NR_3215) {
709  raw3215_free_info(raw);
710  return -ENODEV;
711  }
712 
713  return 0;
714 }
715 
716 static void raw3215_remove (struct ccw_device *cdev)
717 {
718  struct raw3215_info *raw;
719  unsigned int line;
720 
722  raw = dev_get_drvdata(&cdev->dev);
723  if (raw) {
724  spin_lock(&raw3215_device_lock);
725  for (line = 0; line < NR_3215; line++)
726  if (raw3215[line] == raw)
727  break;
728  raw3215[line] = NULL;
729  spin_unlock(&raw3215_device_lock);
730  dev_set_drvdata(&cdev->dev, NULL);
731  raw3215_free_info(raw);
732  }
733 }
734 
735 static int raw3215_set_online (struct ccw_device *cdev)
736 {
737  struct raw3215_info *raw;
738 
739  raw = dev_get_drvdata(&cdev->dev);
740  if (!raw)
741  return -ENODEV;
742 
743  return raw3215_startup(raw);
744 }
745 
746 static int raw3215_set_offline (struct ccw_device *cdev)
747 {
748  struct raw3215_info *raw;
749 
750  raw = dev_get_drvdata(&cdev->dev);
751  if (!raw)
752  return -ENODEV;
753 
754  raw3215_shutdown(raw);
755 
756  return 0;
757 }
758 
759 static int raw3215_pm_stop(struct ccw_device *cdev)
760 {
761  struct raw3215_info *raw;
762  unsigned long flags;
763 
764  /* Empty the output buffer, then prevent new I/O. */
765  raw = dev_get_drvdata(&cdev->dev);
766  spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
767  raw3215_make_room(raw, RAW3215_BUFFER_SIZE);
768  raw->port.flags |= ASYNC_SUSPENDED;
769  spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
770  return 0;
771 }
772 
773 static int raw3215_pm_start(struct ccw_device *cdev)
774 {
775  struct raw3215_info *raw;
776  unsigned long flags;
777 
778  /* Allow I/O again and flush output buffer. */
779  raw = dev_get_drvdata(&cdev->dev);
780  spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
781  raw->port.flags &= ~ASYNC_SUSPENDED;
782  raw->flags |= RAW3215_FLUSHING;
783  raw3215_try_io(raw);
784  raw->flags &= ~RAW3215_FLUSHING;
785  spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
786  return 0;
787 }
788 
789 static struct ccw_device_id raw3215_id[] = {
790  { CCW_DEVICE(0x3215, 0) },
791  { /* end of list */ },
792 };
793 
794 static struct ccw_driver raw3215_ccw_driver = {
795  .driver = {
796  .name = "3215",
797  .owner = THIS_MODULE,
798  },
799  .ids = raw3215_id,
800  .probe = &raw3215_probe,
801  .remove = &raw3215_remove,
802  .set_online = &raw3215_set_online,
803  .set_offline = &raw3215_set_offline,
804  .freeze = &raw3215_pm_stop,
805  .thaw = &raw3215_pm_start,
806  .restore = &raw3215_pm_start,
807  .int_class = IOINT_C15,
808 };
809 
810 #ifdef CONFIG_TN3215_CONSOLE
811 /*
812  * Write a string to the 3215 console
813  */
814 static void con3215_write(struct console *co, const char *str,
815  unsigned int count)
816 {
817  struct raw3215_info *raw;
818  int i;
819 
820  if (count <= 0)
821  return;
822  raw = raw3215[0]; /* console 3215 is the first one */
823  while (count > 0) {
824  for (i = 0; i < count; i++)
825  if (str[i] == '\t' || str[i] == '\n')
826  break;
827  raw3215_write(raw, str, i);
828  count -= i;
829  str += i;
830  if (count > 0) {
831  raw3215_putchar(raw, *str);
832  count--;
833  str++;
834  }
835  }
836 }
837 
838 static struct tty_driver *con3215_device(struct console *c, int *index)
839 {
840  *index = c->index;
841  return tty3215_driver;
842 }
843 
844 /*
845  * panic() calls con3215_flush through a panic_notifier
846  * before the system enters a disabled, endless loop.
847  */
848 static void con3215_flush(void)
849 {
850  struct raw3215_info *raw;
851  unsigned long flags;
852 
853  raw = raw3215[0]; /* console 3215 is the first one */
854  if (raw->port.flags & ASYNC_SUSPENDED)
855  /* The console is still frozen for suspend. */
857  /* Forcing didn't work, no panic message .. */
858  return;
859  spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
860  raw3215_make_room(raw, RAW3215_BUFFER_SIZE);
861  spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
862 }
863 
864 static int con3215_notify(struct notifier_block *self,
865  unsigned long event, void *data)
866 {
867  con3215_flush();
868  return NOTIFY_OK;
869 }
870 
871 static struct notifier_block on_panic_nb = {
872  .notifier_call = con3215_notify,
873  .priority = 0,
874 };
875 
876 static struct notifier_block on_reboot_nb = {
877  .notifier_call = con3215_notify,
878  .priority = 0,
879 };
880 
881 /*
882  * The console structure for the 3215 console
883  */
884 static struct console con3215 = {
885  .name = "ttyS",
886  .write = con3215_write,
887  .device = con3215_device,
888  .flags = CON_PRINTBUFFER,
889 };
890 
891 /*
892  * 3215 console initialization code called from console_init().
893  */
894 static int __init con3215_init(void)
895 {
896  struct ccw_device *cdev;
897  struct raw3215_info *raw;
898  struct raw3215_req *req;
899  int i;
900 
901  /* Check if 3215 is to be the console */
902  if (!CONSOLE_IS_3215)
903  return -ENODEV;
904 
905  /* Set the console mode for VM */
906  if (MACHINE_IS_VM) {
907  cpcmd("TERM CONMODE 3215", NULL, 0, NULL);
908  cpcmd("TERM AUTOCR OFF", NULL, 0, NULL);
909  }
910 
911  /* allocate 3215 request structures */
912  raw3215_freelist = NULL;
913  spin_lock_init(&raw3215_freelist_lock);
914  for (i = 0; i < NR_3215_REQ; i++) {
915  req = kzalloc(sizeof(struct raw3215_req), GFP_KERNEL | GFP_DMA);
916  req->next = raw3215_freelist;
917  raw3215_freelist = req;
918  }
919 
920  cdev = ccw_device_probe_console();
921  if (IS_ERR(cdev))
922  return -ENODEV;
923 
924  raw3215[0] = raw = raw3215_alloc_info();
925  raw->cdev = cdev;
926  dev_set_drvdata(&cdev->dev, raw);
927  cdev->handler = raw3215_irq;
928 
929  /* Request the console irq */
930  if (raw3215_startup(raw) != 0) {
931  raw3215_free_info(raw);
932  raw3215[0] = NULL;
933  return -ENODEV;
934  }
935  atomic_notifier_chain_register(&panic_notifier_list, &on_panic_nb);
936  register_reboot_notifier(&on_reboot_nb);
937  register_console(&con3215);
938  return 0;
939 }
940 console_initcall(con3215_init);
941 #endif
942 
943 static int tty3215_install(struct tty_driver *driver, struct tty_struct *tty)
944 {
945  struct raw3215_info *raw;
946 
947  raw = raw3215[tty->index];
948  if (raw == NULL)
949  return -ENODEV;
950 
951  tty->driver_data = raw;
952 
953  return tty_port_install(&raw->port, driver, tty);
954 }
955 
956 /*
957  * tty3215_open
958  *
959  * This routine is called whenever a 3215 tty is opened.
960  */
961 static int tty3215_open(struct tty_struct *tty, struct file * filp)
962 {
963  struct raw3215_info *raw = tty->driver_data;
964  int retval;
965 
966  tty_port_tty_set(&raw->port, tty);
967 
968  tty->low_latency = 0; /* don't use bottom half for pushing chars */
969  /*
970  * Start up 3215 device
971  */
972  retval = raw3215_startup(raw);
973  if (retval)
974  return retval;
975 
976  return 0;
977 }
978 
979 /*
980  * tty3215_close()
981  *
982  * This routine is called when the 3215 tty is closed. We wait
983  * for the remaining request to be completed. Then we clean up.
984  */
985 static void tty3215_close(struct tty_struct *tty, struct file * filp)
986 {
987  struct raw3215_info *raw;
988 
989  raw = (struct raw3215_info *) tty->driver_data;
990  if (raw == NULL || tty->count > 1)
991  return;
992  tty->closing = 1;
993  /* Shutdown the terminal */
994  raw3215_shutdown(raw);
995  tasklet_kill(&raw->tlet);
996  tty->closing = 0;
997  tty_port_tty_set(&raw->port, NULL);
998 }
999 
1000 /*
1001  * Returns the amount of free space in the output buffer.
1002  */
1003 static int tty3215_write_room(struct tty_struct *tty)
1004 {
1005  struct raw3215_info *raw;
1006 
1007  raw = (struct raw3215_info *) tty->driver_data;
1008 
1009  /* Subtract TAB_STOP_SIZE to allow for a tab, 8 <<< 64K */
1010  if ((RAW3215_BUFFER_SIZE - raw->count - TAB_STOP_SIZE) >= 0)
1011  return RAW3215_BUFFER_SIZE - raw->count - TAB_STOP_SIZE;
1012  else
1013  return 0;
1014 }
1015 
1016 /*
1017  * String write routine for 3215 ttys
1018  */
1019 static int tty3215_write(struct tty_struct * tty,
1020  const unsigned char *buf, int count)
1021 {
1022  struct raw3215_info *raw;
1023 
1024  if (!tty)
1025  return 0;
1026  raw = (struct raw3215_info *) tty->driver_data;
1027  raw3215_write(raw, buf, count);
1028  return count;
1029 }
1030 
1031 /*
1032  * Put character routine for 3215 ttys
1033  */
1034 static int tty3215_put_char(struct tty_struct *tty, unsigned char ch)
1035 {
1036  struct raw3215_info *raw;
1037 
1038  if (!tty)
1039  return 0;
1040  raw = (struct raw3215_info *) tty->driver_data;
1041  raw3215_putchar(raw, ch);
1042  return 1;
1043 }
1044 
1045 static void tty3215_flush_chars(struct tty_struct *tty)
1046 {
1047 }
1048 
1049 /*
1050  * Returns the number of characters in the output buffer
1051  */
1052 static int tty3215_chars_in_buffer(struct tty_struct *tty)
1053 {
1054  struct raw3215_info *raw;
1055 
1056  raw = (struct raw3215_info *) tty->driver_data;
1057  return raw->count;
1058 }
1059 
1060 static void tty3215_flush_buffer(struct tty_struct *tty)
1061 {
1062  struct raw3215_info *raw;
1063 
1064  raw = (struct raw3215_info *) tty->driver_data;
1065  raw3215_flush_buffer(raw);
1066  tty_wakeup(tty);
1067 }
1068 
1069 /*
1070  * Disable reading from a 3215 tty
1071  */
1072 static void tty3215_throttle(struct tty_struct * tty)
1073 {
1074  struct raw3215_info *raw;
1075 
1076  raw = (struct raw3215_info *) tty->driver_data;
1077  raw->flags |= RAW3215_THROTTLED;
1078 }
1079 
1080 /*
1081  * Enable reading from a 3215 tty
1082  */
1083 static void tty3215_unthrottle(struct tty_struct * tty)
1084 {
1085  struct raw3215_info *raw;
1086  unsigned long flags;
1087 
1088  raw = (struct raw3215_info *) tty->driver_data;
1089  if (raw->flags & RAW3215_THROTTLED) {
1090  spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
1091  raw->flags &= ~RAW3215_THROTTLED;
1092  raw3215_try_io(raw);
1093  spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
1094  }
1095 }
1096 
1097 /*
1098  * Disable writing to a 3215 tty
1099  */
1100 static void tty3215_stop(struct tty_struct *tty)
1101 {
1102  struct raw3215_info *raw;
1103 
1104  raw = (struct raw3215_info *) tty->driver_data;
1105  raw->flags |= RAW3215_STOPPED;
1106 }
1107 
1108 /*
1109  * Enable writing to a 3215 tty
1110  */
1111 static void tty3215_start(struct tty_struct *tty)
1112 {
1113  struct raw3215_info *raw;
1114  unsigned long flags;
1115 
1116  raw = (struct raw3215_info *) tty->driver_data;
1117  if (raw->flags & RAW3215_STOPPED) {
1118  spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
1119  raw->flags &= ~RAW3215_STOPPED;
1120  raw3215_try_io(raw);
1121  spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
1122  }
1123 }
1124 
1125 static const struct tty_operations tty3215_ops = {
1126  .install = tty3215_install,
1127  .open = tty3215_open,
1128  .close = tty3215_close,
1129  .write = tty3215_write,
1130  .put_char = tty3215_put_char,
1131  .flush_chars = tty3215_flush_chars,
1132  .write_room = tty3215_write_room,
1133  .chars_in_buffer = tty3215_chars_in_buffer,
1134  .flush_buffer = tty3215_flush_buffer,
1135  .throttle = tty3215_throttle,
1136  .unthrottle = tty3215_unthrottle,
1137  .stop = tty3215_stop,
1138  .start = tty3215_start,
1139 };
1140 
1141 /*
1142  * 3215 tty registration code called from tty_init().
1143  * Most kernel services (incl. kmalloc) are available at this poimt.
1144  */
1145 static int __init tty3215_init(void)
1146 {
1147  struct tty_driver *driver;
1148  int ret;
1149 
1150  if (!CONSOLE_IS_3215)
1151  return 0;
1152 
1153  driver = alloc_tty_driver(NR_3215);
1154  if (!driver)
1155  return -ENOMEM;
1156 
1157  ret = ccw_driver_register(&raw3215_ccw_driver);
1158  if (ret) {
1159  put_tty_driver(driver);
1160  return ret;
1161  }
1162  /*
1163  * Initialize the tty_driver structure
1164  * Entries in tty3215_driver that are NOT initialized:
1165  * proc_entry, set_termios, flush_buffer, set_ldisc, write_proc
1166  */
1167 
1168  driver->driver_name = "tty3215";
1169  driver->name = "ttyS";
1170  driver->major = TTY_MAJOR;
1171  driver->minor_start = 64;
1172  driver->type = TTY_DRIVER_TYPE_SYSTEM;
1173  driver->subtype = SYSTEM_TYPE_TTY;
1174  driver->init_termios = tty_std_termios;
1175  driver->init_termios.c_iflag = IGNBRK | IGNPAR;
1176  driver->init_termios.c_oflag = ONLCR | XTABS;
1177  driver->init_termios.c_lflag = ISIG;
1178  driver->flags = TTY_DRIVER_REAL_RAW;
1179  tty_set_operations(driver, &tty3215_ops);
1180  ret = tty_register_driver(driver);
1181  if (ret) {
1182  put_tty_driver(driver);
1183  return ret;
1184  }
1185  tty3215_driver = driver;
1186  return 0;
1187 }
1188 
1189 static void __exit tty3215_exit(void)
1190 {
1191  tty_unregister_driver(tty3215_driver);
1192  put_tty_driver(tty3215_driver);
1193  ccw_driver_unregister(&raw3215_ccw_driver);
1194 }
1195 
1196 module_init(tty3215_init);
1197 module_exit(tty3215_exit);