Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
sclp_tty.c
Go to the documentation of this file.
1 /*
2  * SCLP line mode terminal driver.
3  *
4  * S390 version
5  * Copyright IBM Corp. 1999
6  * Author(s): Martin Peschke <[email protected]>
7  * Martin Schwidefsky <[email protected]>
8  */
9 
10 #include <linux/module.h>
11 #include <linux/kmod.h>
12 #include <linux/tty.h>
13 #include <linux/tty_driver.h>
14 #include <linux/tty_flip.h>
15 #include <linux/err.h>
16 #include <linux/init.h>
17 #include <linux/interrupt.h>
18 #include <linux/gfp.h>
19 #include <asm/uaccess.h>
20 
21 #include "ctrlchar.h"
22 #include "sclp.h"
23 #include "sclp_rw.h"
24 #include "sclp_tty.h"
25 
26 /*
27  * size of a buffer that collects single characters coming in
28  * via sclp_tty_put_char()
29  */
30 #define SCLP_TTY_BUF_SIZE 512
31 
32 /*
33  * There is exactly one SCLP terminal, so we can keep things simple
34  * and allocate all variables statically.
35  */
36 
37 /* Lock to guard over changes to global variables. */
38 static spinlock_t sclp_tty_lock;
39 /* List of free pages that can be used for console output buffering. */
40 static struct list_head sclp_tty_pages;
41 /* List of full struct sclp_buffer structures ready for output. */
42 static struct list_head sclp_tty_outqueue;
43 /* Counter how many buffers are emitted. */
44 static int sclp_tty_buffer_count;
45 /* Pointer to current console buffer. */
46 static struct sclp_buffer *sclp_ttybuf;
47 /* Timer for delayed output of console messages. */
48 static struct timer_list sclp_tty_timer;
49 
50 static struct tty_port sclp_port;
51 static unsigned char sclp_tty_chars[SCLP_TTY_BUF_SIZE];
52 static unsigned short int sclp_tty_chars_count;
53 
55 
56 static int sclp_tty_tolower;
57 static int sclp_tty_columns = 80;
58 
59 #define SPACES_PER_TAB 8
60 #define CASE_DELIMITER 0x6c /* to separate upper and lower case (% in EBCDIC) */
61 
62 /* This routine is called whenever we try to open a SCLP terminal. */
63 static int
64 sclp_tty_open(struct tty_struct *tty, struct file *filp)
65 {
66  tty_port_tty_set(&sclp_port, tty);
67  tty->driver_data = NULL;
68  tty->low_latency = 0;
69  return 0;
70 }
71 
72 /* This routine is called when the SCLP terminal is closed. */
73 static void
74 sclp_tty_close(struct tty_struct *tty, struct file *filp)
75 {
76  if (tty->count > 1)
77  return;
78  tty_port_tty_set(&sclp_port, NULL);
79 }
80 
81 /*
82  * This routine returns the numbers of characters the tty driver
83  * will accept for queuing to be written. This number is subject
84  * to change as output buffers get emptied, or if the output flow
85  * control is acted. This is not an exact number because not every
86  * character needs the same space in the sccb. The worst case is
87  * a string of newlines. Every newlines creates a new mto which
88  * needs 8 bytes.
89  */
90 static int
91 sclp_tty_write_room (struct tty_struct *tty)
92 {
93  unsigned long flags;
94  struct list_head *l;
95  int count;
96 
97  spin_lock_irqsave(&sclp_tty_lock, flags);
98  count = 0;
99  if (sclp_ttybuf != NULL)
100  count = sclp_buffer_space(sclp_ttybuf) / sizeof(struct mto);
101  list_for_each(l, &sclp_tty_pages)
102  count += NR_EMPTY_MTO_PER_SCCB;
103  spin_unlock_irqrestore(&sclp_tty_lock, flags);
104  return count;
105 }
106 
107 static void
108 sclp_ttybuf_callback(struct sclp_buffer *buffer, int rc)
109 {
110  struct tty_struct *tty;
111  unsigned long flags;
112  void *page;
113 
114  do {
115  page = sclp_unmake_buffer(buffer);
116  spin_lock_irqsave(&sclp_tty_lock, flags);
117  /* Remove buffer from outqueue */
118  list_del(&buffer->list);
119  sclp_tty_buffer_count--;
120  list_add_tail((struct list_head *) page, &sclp_tty_pages);
121  /* Check if there is a pending buffer on the out queue. */
122  buffer = NULL;
123  if (!list_empty(&sclp_tty_outqueue))
124  buffer = list_entry(sclp_tty_outqueue.next,
125  struct sclp_buffer, list);
126  spin_unlock_irqrestore(&sclp_tty_lock, flags);
127  } while (buffer && sclp_emit_buffer(buffer, sclp_ttybuf_callback));
128  /* check if the tty needs a wake up call */
129  tty = tty_port_tty_get(&sclp_port);
130  if (tty != NULL) {
131  tty_wakeup(tty);
132  tty_kref_put(tty);
133  }
134 }
135 
136 static inline void
137 __sclp_ttybuf_emit(struct sclp_buffer *buffer)
138 {
139  unsigned long flags;
140  int count;
141  int rc;
142 
143  spin_lock_irqsave(&sclp_tty_lock, flags);
144  list_add_tail(&buffer->list, &sclp_tty_outqueue);
145  count = sclp_tty_buffer_count++;
146  spin_unlock_irqrestore(&sclp_tty_lock, flags);
147  if (count)
148  return;
149  rc = sclp_emit_buffer(buffer, sclp_ttybuf_callback);
150  if (rc)
151  sclp_ttybuf_callback(buffer, rc);
152 }
153 
154 /*
155  * When this routine is called from the timer then we flush the
156  * temporary write buffer.
157  */
158 static void
159 sclp_tty_timeout(unsigned long data)
160 {
161  unsigned long flags;
162  struct sclp_buffer *buf;
163 
164  spin_lock_irqsave(&sclp_tty_lock, flags);
165  buf = sclp_ttybuf;
166  sclp_ttybuf = NULL;
167  spin_unlock_irqrestore(&sclp_tty_lock, flags);
168 
169  if (buf != NULL) {
170  __sclp_ttybuf_emit(buf);
171  }
172 }
173 
174 /*
175  * Write a string to the sclp tty.
176  */
177 static int sclp_tty_write_string(const unsigned char *str, int count, int may_fail)
178 {
179  unsigned long flags;
180  void *page;
181  int written;
182  int overall_written;
183  struct sclp_buffer *buf;
184 
185  if (count <= 0)
186  return 0;
187  overall_written = 0;
188  spin_lock_irqsave(&sclp_tty_lock, flags);
189  do {
190  /* Create a sclp output buffer if none exists yet */
191  if (sclp_ttybuf == NULL) {
192  while (list_empty(&sclp_tty_pages)) {
193  spin_unlock_irqrestore(&sclp_tty_lock, flags);
194  if (may_fail)
195  goto out;
196  else
197  sclp_sync_wait();
198  spin_lock_irqsave(&sclp_tty_lock, flags);
199  }
200  page = sclp_tty_pages.next;
201  list_del((struct list_head *) page);
202  sclp_ttybuf = sclp_make_buffer(page, sclp_tty_columns,
204  }
205  /* try to write the string to the current output buffer */
206  written = sclp_write(sclp_ttybuf, str, count);
207  overall_written += written;
208  if (written == count)
209  break;
210  /*
211  * Not all characters could be written to the current
212  * output buffer. Emit the buffer, create a new buffer
213  * and then output the rest of the string.
214  */
215  buf = sclp_ttybuf;
216  sclp_ttybuf = NULL;
217  spin_unlock_irqrestore(&sclp_tty_lock, flags);
218  __sclp_ttybuf_emit(buf);
219  spin_lock_irqsave(&sclp_tty_lock, flags);
220  str += written;
221  count -= written;
222  } while (count > 0);
223  /* Setup timer to output current console buffer after 1/10 second */
224  if (sclp_ttybuf && sclp_chars_in_buffer(sclp_ttybuf) &&
225  !timer_pending(&sclp_tty_timer)) {
226  init_timer(&sclp_tty_timer);
227  sclp_tty_timer.function = sclp_tty_timeout;
228  sclp_tty_timer.data = 0UL;
229  sclp_tty_timer.expires = jiffies + HZ/10;
230  add_timer(&sclp_tty_timer);
231  }
232  spin_unlock_irqrestore(&sclp_tty_lock, flags);
233 out:
234  return overall_written;
235 }
236 
237 /*
238  * This routine is called by the kernel to write a series of characters to the
239  * tty device. The characters may come from user space or kernel space. This
240  * routine will return the number of characters actually accepted for writing.
241  */
242 static int
243 sclp_tty_write(struct tty_struct *tty, const unsigned char *buf, int count)
244 {
245  if (sclp_tty_chars_count > 0) {
246  sclp_tty_write_string(sclp_tty_chars, sclp_tty_chars_count, 0);
247  sclp_tty_chars_count = 0;
248  }
249  return sclp_tty_write_string(buf, count, 1);
250 }
251 
252 /*
253  * This routine is called by the kernel to write a single character to the tty
254  * device. If the kernel uses this routine, it must call the flush_chars()
255  * routine (if defined) when it is done stuffing characters into the driver.
256  *
257  * Characters provided to sclp_tty_put_char() are buffered by the SCLP driver.
258  * If the given character is a '\n' the contents of the SCLP write buffer
259  * - including previous characters from sclp_tty_put_char() and strings from
260  * sclp_write() without final '\n' - will be written.
261  */
262 static int
263 sclp_tty_put_char(struct tty_struct *tty, unsigned char ch)
264 {
265  sclp_tty_chars[sclp_tty_chars_count++] = ch;
266  if (ch == '\n' || sclp_tty_chars_count >= SCLP_TTY_BUF_SIZE) {
267  sclp_tty_write_string(sclp_tty_chars, sclp_tty_chars_count, 0);
268  sclp_tty_chars_count = 0;
269  }
270  return 1;
271 }
272 
273 /*
274  * This routine is called by the kernel after it has written a series of
275  * characters to the tty device using put_char().
276  */
277 static void
278 sclp_tty_flush_chars(struct tty_struct *tty)
279 {
280  if (sclp_tty_chars_count > 0) {
281  sclp_tty_write_string(sclp_tty_chars, sclp_tty_chars_count, 0);
282  sclp_tty_chars_count = 0;
283  }
284 }
285 
286 /*
287  * This routine returns the number of characters in the write buffer of the
288  * SCLP driver. The provided number includes all characters that are stored
289  * in the SCCB (will be written next time the SCLP is not busy) as well as
290  * characters in the write buffer (will not be written as long as there is a
291  * final line feed missing).
292  */
293 static int
294 sclp_tty_chars_in_buffer(struct tty_struct *tty)
295 {
296  unsigned long flags;
297  struct list_head *l;
298  struct sclp_buffer *t;
299  int count;
300 
301  spin_lock_irqsave(&sclp_tty_lock, flags);
302  count = 0;
303  if (sclp_ttybuf != NULL)
304  count = sclp_chars_in_buffer(sclp_ttybuf);
305  list_for_each(l, &sclp_tty_outqueue) {
306  t = list_entry(l, struct sclp_buffer, list);
307  count += sclp_chars_in_buffer(t);
308  }
309  spin_unlock_irqrestore(&sclp_tty_lock, flags);
310  return count;
311 }
312 
313 /*
314  * removes all content from buffers of low level driver
315  */
316 static void
317 sclp_tty_flush_buffer(struct tty_struct *tty)
318 {
319  if (sclp_tty_chars_count > 0) {
320  sclp_tty_write_string(sclp_tty_chars, sclp_tty_chars_count, 0);
321  sclp_tty_chars_count = 0;
322  }
323 }
324 
325 /*
326  * push input to tty
327  */
328 static void
329 sclp_tty_input(unsigned char* buf, unsigned int count)
330 {
331  struct tty_struct *tty = tty_port_tty_get(&sclp_port);
332  unsigned int cchar;
333 
334  /*
335  * If this tty driver is currently closed
336  * then throw the received input away.
337  */
338  if (tty == NULL)
339  return;
340  cchar = ctrlchar_handle(buf, count, tty);
341  switch (cchar & CTRLCHAR_MASK) {
342  case CTRLCHAR_SYSRQ:
343  break;
344  case CTRLCHAR_CTRL:
345  tty_insert_flip_char(tty, cchar, TTY_NORMAL);
347  break;
348  case CTRLCHAR_NONE:
349  /* send (normal) input to line discipline */
350  if (count < 2 ||
351  (strncmp((const char *) buf + count - 2, "^n", 2) &&
352  strncmp((const char *) buf + count - 2, "\252n", 2))) {
353  /* add the auto \n */
354  tty_insert_flip_string(tty, buf, count);
355  tty_insert_flip_char(tty, '\n', TTY_NORMAL);
356  } else
357  tty_insert_flip_string(tty, buf, count - 2);
359  break;
360  }
361  tty_kref_put(tty);
362 }
363 
364 /*
365  * get a EBCDIC string in upper/lower case,
366  * find out characters in lower/upper case separated by a special character,
367  * modifiy original string,
368  * returns length of resulting string
369  */
370 static int sclp_switch_cases(unsigned char *buf, int count)
371 {
372  unsigned char *ip, *op;
373  int toggle;
374 
375  /* initially changing case is off */
376  toggle = 0;
377  ip = op = buf;
378  while (count-- > 0) {
379  /* compare with special character */
380  if (*ip == CASE_DELIMITER) {
381  /* followed by another special character? */
382  if (count && ip[1] == CASE_DELIMITER) {
383  /*
384  * ... then put a single copy of the special
385  * character to the output string
386  */
387  *op++ = *ip++;
388  count--;
389  } else
390  /*
391  * ... special character follower by a normal
392  * character toggles the case change behaviour
393  */
394  toggle = ~toggle;
395  /* skip special character */
396  ip++;
397  } else
398  /* not the special character */
399  if (toggle)
400  /* but case switching is on */
401  if (sclp_tty_tolower)
402  /* switch to uppercase */
403  *op++ = _ebc_toupper[(int) *ip++];
404  else
405  /* switch to lowercase */
406  *op++ = _ebc_tolower[(int) *ip++];
407  else
408  /* no case switching, copy the character */
409  *op++ = *ip++;
410  }
411  /* return length of reformatted string. */
412  return op - buf;
413 }
414 
415 static void sclp_get_input(struct gds_subvector *sv)
416 {
417  unsigned char *str;
418  int count;
419 
420  str = (unsigned char *) (sv + 1);
421  count = sv->length - sizeof(*sv);
422  if (sclp_tty_tolower)
423  EBC_TOLOWER(str, count);
424  count = sclp_switch_cases(str, count);
425  /* convert EBCDIC to ASCII (modify original input in SCCB) */
426  sclp_ebcasc_str(str, count);
427 
428  /* transfer input to high level driver */
429  sclp_tty_input(str, count);
430 }
431 
432 static inline void sclp_eval_selfdeftextmsg(struct gds_subvector *sv)
433 {
434  void *end;
435 
436  end = (void *) sv + sv->length;
437  for (sv = sv + 1; (void *) sv < end; sv = (void *) sv + sv->length)
438  if (sv->key == 0x30)
439  sclp_get_input(sv);
440 }
441 
442 static inline void sclp_eval_textcmd(struct gds_vector *v)
443 {
444  struct gds_subvector *sv;
445  void *end;
446 
447  end = (void *) v + v->length;
448  for (sv = (struct gds_subvector *) (v + 1);
449  (void *) sv < end; sv = (void *) sv + sv->length)
450  if (sv->key == GDS_KEY_SELFDEFTEXTMSG)
451  sclp_eval_selfdeftextmsg(sv);
452 
453 }
454 
455 static inline void sclp_eval_cpmsu(struct gds_vector *v)
456 {
457  void *end;
458 
459  end = (void *) v + v->length;
460  for (v = v + 1; (void *) v < end; v = (void *) v + v->length)
461  if (v->gds_id == GDS_ID_TEXTCMD)
462  sclp_eval_textcmd(v);
463 }
464 
465 
466 static inline void sclp_eval_mdsmu(struct gds_vector *v)
467 {
468  v = sclp_find_gds_vector(v + 1, (void *) v + v->length, GDS_ID_CPMSU);
469  if (v)
470  sclp_eval_cpmsu(v);
471 }
472 
473 static void sclp_tty_receiver(struct evbuf_header *evbuf)
474 {
475  struct gds_vector *v;
476 
477  v = sclp_find_gds_vector(evbuf + 1, (void *) evbuf + evbuf->length,
478  GDS_ID_MDSMU);
479  if (v)
480  sclp_eval_mdsmu(v);
481 }
482 
483 static void
484 sclp_tty_state_change(struct sclp_register *reg)
485 {
486 }
487 
488 static struct sclp_register sclp_input_event =
489 {
490  .receive_mask = EVTYP_OPCMD_MASK | EVTYP_PMSGCMD_MASK,
491  .state_change_fn = sclp_tty_state_change,
492  .receiver_fn = sclp_tty_receiver
493 };
494 
495 static const struct tty_operations sclp_ops = {
496  .open = sclp_tty_open,
497  .close = sclp_tty_close,
498  .write = sclp_tty_write,
499  .put_char = sclp_tty_put_char,
500  .flush_chars = sclp_tty_flush_chars,
501  .write_room = sclp_tty_write_room,
502  .chars_in_buffer = sclp_tty_chars_in_buffer,
503  .flush_buffer = sclp_tty_flush_buffer,
504 };
505 
506 static int __init
507 sclp_tty_init(void)
508 {
509  struct tty_driver *driver;
510  void *page;
511  int i;
512  int rc;
513 
514  if (!CONSOLE_IS_SCLP)
515  return 0;
516  driver = alloc_tty_driver(1);
517  if (!driver)
518  return -ENOMEM;
519 
520  rc = sclp_rw_init();
521  if (rc) {
522  put_tty_driver(driver);
523  return rc;
524  }
525  /* Allocate pages for output buffering */
526  INIT_LIST_HEAD(&sclp_tty_pages);
527  for (i = 0; i < MAX_KMEM_PAGES; i++) {
528  page = (void *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
529  if (page == NULL) {
530  put_tty_driver(driver);
531  return -ENOMEM;
532  }
533  list_add_tail((struct list_head *) page, &sclp_tty_pages);
534  }
535  INIT_LIST_HEAD(&sclp_tty_outqueue);
536  spin_lock_init(&sclp_tty_lock);
537  init_timer(&sclp_tty_timer);
538  sclp_ttybuf = NULL;
539  sclp_tty_buffer_count = 0;
540  if (MACHINE_IS_VM) {
541  /*
542  * save 4 characters for the CPU number
543  * written at start of each line by VM/CP
544  */
545  sclp_tty_columns = 76;
546  /* case input lines to lowercase */
547  sclp_tty_tolower = 1;
548  }
549  sclp_tty_chars_count = 0;
550  tty_port_init(&sclp_port);
551 
552  rc = sclp_register(&sclp_input_event);
553  if (rc) {
554  put_tty_driver(driver);
555  return rc;
556  }
557 
558  driver->driver_name = "sclp_line";
559  driver->name = "sclp_line";
560  driver->major = TTY_MAJOR;
561  driver->minor_start = 64;
562  driver->type = TTY_DRIVER_TYPE_SYSTEM;
563  driver->subtype = SYSTEM_TYPE_TTY;
564  driver->init_termios = tty_std_termios;
565  driver->init_termios.c_iflag = IGNBRK | IGNPAR;
566  driver->init_termios.c_oflag = ONLCR | XTABS;
567  driver->init_termios.c_lflag = ISIG | ECHO;
568  driver->flags = TTY_DRIVER_REAL_RAW;
569  tty_set_operations(driver, &sclp_ops);
570  tty_port_link_device(&sclp_port, driver, 0);
571  rc = tty_register_driver(driver);
572  if (rc) {
573  put_tty_driver(driver);
574  return rc;
575  }
576  sclp_tty_driver = driver;
577  return 0;
578 }
579 module_init(sclp_tty_init);