Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
raw3270.c
Go to the documentation of this file.
1 /*
2  * IBM/3270 Driver - core functions.
3  *
4  * Author(s):
5  * Original 3270 Code for 2.4 written by Richard Hitt (UTS Global)
6  * Rewritten for 2.5 by Martin Schwidefsky <[email protected]>
7  * Copyright IBM Corp. 2003, 2009
8  */
9 
10 #include <linux/module.h>
11 #include <linux/err.h>
12 #include <linux/init.h>
13 #include <linux/interrupt.h>
14 #include <linux/list.h>
15 #include <linux/slab.h>
16 #include <linux/types.h>
17 #include <linux/wait.h>
18 
19 #include <asm/ccwdev.h>
20 #include <asm/cio.h>
21 #include <asm/ebcdic.h>
22 #include <asm/diag.h>
23 
24 #include "raw3270.h"
25 
26 #include <linux/major.h>
27 #include <linux/kdev_t.h>
28 #include <linux/device.h>
29 #include <linux/mutex.h>
30 
31 static struct class *class3270;
32 
33 /* The main 3270 data structure. */
34 struct raw3270 {
35  struct list_head list;
36  struct ccw_device *cdev;
37  int minor;
38 
39  short model, rows, cols;
40  unsigned long flags;
41 
42  struct list_head req_queue; /* Request queue. */
43  struct list_head view_list; /* List of available views. */
44  struct raw3270_view *view; /* Active view. */
45 
46  struct timer_list timer; /* Device timer. */
47 
48  unsigned char *ascebc; /* ascii -> ebcdic table */
49  struct device *clttydev; /* 3270-class tty device ptr */
50  struct device *cltubdev; /* 3270-class tub device ptr */
51 
53  unsigned char init_data[256];
54 };
55 
56 /* raw3270->flags */
57 #define RAW3270_FLAGS_14BITADDR 0 /* 14-bit buffer addresses */
58 #define RAW3270_FLAGS_BUSY 1 /* Device busy, leave it alone */
59 #define RAW3270_FLAGS_ATTN 2 /* Device sent an ATTN interrupt */
60 #define RAW3270_FLAGS_READY 4 /* Device is useable by views */
61 #define RAW3270_FLAGS_CONSOLE 8 /* Device is the console. */
62 #define RAW3270_FLAGS_FROZEN 16 /* set if 3270 is frozen for suspend */
63 
64 /* Semaphore to protect global data of raw3270 (devices, views, etc). */
65 static DEFINE_MUTEX(raw3270_mutex);
66 
67 /* List of 3270 devices. */
68 static LIST_HEAD(raw3270_devices);
69 
70 /*
71  * Flag to indicate if the driver has been registered. Some operations
72  * like waiting for the end of i/o need to be done differently as long
73  * as the kernel is still starting up (console support).
74  */
75 static int raw3270_registered;
76 
77 /* Module parameters */
78 static bool tubxcorrect = 0;
79 module_param(tubxcorrect, bool, 0);
80 
81 /*
82  * Wait queue for device init/delete, view delete.
83  */
84 DECLARE_WAIT_QUEUE_HEAD(raw3270_wait_queue);
85 
86 /*
87  * Encode array for 12 bit 3270 addresses.
88  */
89 static unsigned char raw3270_ebcgraf[64] = {
90  0x40, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
91  0xc8, 0xc9, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
92  0x50, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
93  0xd8, 0xd9, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
94  0x60, 0x61, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
95  0xe8, 0xe9, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
96  0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
97  0xf8, 0xf9, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f
98 };
99 
100 void
101 raw3270_buffer_address(struct raw3270 *rp, char *cp, unsigned short addr)
102 {
104  cp[0] = (addr >> 8) & 0x3f;
105  cp[1] = addr & 0xff;
106  } else {
107  cp[0] = raw3270_ebcgraf[(addr >> 6) & 0x3f];
108  cp[1] = raw3270_ebcgraf[addr & 0x3f];
109  }
110 }
111 
112 /*
113  * Allocate a new 3270 ccw request
114  */
115 struct raw3270_request *
117 {
118  struct raw3270_request *rq;
119 
120  /* Allocate request structure */
121  rq = kzalloc(sizeof(struct raw3270_request), GFP_KERNEL | GFP_DMA);
122  if (!rq)
123  return ERR_PTR(-ENOMEM);
124 
125  /* alloc output buffer. */
126  if (size > 0) {
127  rq->buffer = kmalloc(size, GFP_KERNEL | GFP_DMA);
128  if (!rq->buffer) {
129  kfree(rq);
130  return ERR_PTR(-ENOMEM);
131  }
132  }
133  rq->size = size;
134  INIT_LIST_HEAD(&rq->list);
135 
136  /*
137  * Setup ccw.
138  */
139  rq->ccw.cda = __pa(rq->buffer);
140  rq->ccw.flags = CCW_FLAG_SLI;
141 
142  return rq;
143 }
144 
145 /*
146  * Free 3270 ccw request
147  */
148 void
150 {
151  kfree(rq->buffer);
152  kfree(rq);
153 }
154 
155 /*
156  * Reset request to initial state.
157  */
158 void
160 {
161  BUG_ON(!list_empty(&rq->list));
162  rq->ccw.cmd_code = 0;
163  rq->ccw.count = 0;
164  rq->ccw.cda = __pa(rq->buffer);
165  rq->ccw.flags = CCW_FLAG_SLI;
166  rq->rescnt = 0;
167  rq->rc = 0;
168 }
169 
170 /*
171  * Set command code to ccw of a request.
172  */
173 void
175 {
176  rq->ccw.cmd_code = cmd;
177 }
178 
179 /*
180  * Add data fragment to output buffer.
181  */
182 int
184 {
185  if (size + rq->ccw.count > rq->size)
186  return -E2BIG;
187  memcpy(rq->buffer + rq->ccw.count, data, size);
188  rq->ccw.count += size;
189  return 0;
190 }
191 
192 /*
193  * Set address/length pair to ccw of a request.
194  */
195 void
197 {
198  rq->ccw.cda = __pa(data);
199  rq->ccw.count = size;
200 }
201 
202 /*
203  * Set idal buffer to ccw of a request.
204  */
205 void
207 {
208  rq->ccw.cda = __pa(ib->data);
209  rq->ccw.count = ib->size;
210  rq->ccw.flags |= CCW_FLAG_IDA;
211 }
212 
213 /*
214  * Stop running ccw.
215  */
216 static int
217 raw3270_halt_io_nolock(struct raw3270 *rp, struct raw3270_request *rq)
218 {
219  int retries;
220  int rc;
221 
222  if (raw3270_request_final(rq))
223  return 0;
224  /* Check if interrupt has already been processed */
225  for (retries = 0; retries < 5; retries++) {
226  if (retries < 2)
227  rc = ccw_device_halt(rp->cdev, (long) rq);
228  else
229  rc = ccw_device_clear(rp->cdev, (long) rq);
230  if (rc == 0)
231  break; /* termination successful */
232  }
233  return rc;
234 }
235 
236 static int
237 raw3270_halt_io(struct raw3270 *rp, struct raw3270_request *rq)
238 {
239  unsigned long flags;
240  int rc;
241 
243  rc = raw3270_halt_io_nolock(rp, rq);
244  spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
245  return rc;
246 }
247 
248 /*
249  * Add the request to the request queue, try to start it if the
250  * 3270 device is idle. Return without waiting for end of i/o.
251  */
252 static int
253 __raw3270_start(struct raw3270 *rp, struct raw3270_view *view,
254  struct raw3270_request *rq)
255 {
256  rq->view = view;
257  raw3270_get_view(view);
258  if (list_empty(&rp->req_queue) &&
260  /* No other requests are on the queue. Start this one. */
261  rq->rc = ccw_device_start(rp->cdev, &rq->ccw,
262  (unsigned long) rq, 0, 0);
263  if (rq->rc) {
264  raw3270_put_view(view);
265  return rq->rc;
266  }
267  }
268  list_add_tail(&rq->list, &rp->req_queue);
269  return 0;
270 }
271 
272 int
273 raw3270_start(struct raw3270_view *view, struct raw3270_request *rq)
274 {
275  unsigned long flags;
276  struct raw3270 *rp;
277  int rc;
278 
279  spin_lock_irqsave(get_ccwdev_lock(view->dev->cdev), flags);
280  rp = view->dev;
281  if (!rp || rp->view != view ||
283  rc = -EACCES;
284  else if (!test_bit(RAW3270_FLAGS_READY, &rp->flags))
285  rc = -ENODEV;
286  else
287  rc = __raw3270_start(rp, view, rq);
288  spin_unlock_irqrestore(get_ccwdev_lock(view->dev->cdev), flags);
289  return rc;
290 }
291 
292 int
294 {
295  struct raw3270 *rp;
296  int rc;
297 
298  rp = view->dev;
299  if (!rp || rp->view != view ||
301  rc = -EACCES;
302  else if (!test_bit(RAW3270_FLAGS_READY, &rp->flags))
303  rc = -ENODEV;
304  else
305  rc = __raw3270_start(rp, view, rq);
306  return rc;
307 }
308 
309 int
311 {
312  struct raw3270 *rp;
313 
314  rp = view->dev;
315  rq->view = view;
316  raw3270_get_view(view);
317  list_add_tail(&rq->list, &rp->req_queue);
318  return 0;
319 }
320 
321 /*
322  * 3270 interrupt routine, called from the ccw_device layer
323  */
324 static void
325 raw3270_irq (struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
326 {
327  struct raw3270 *rp;
328  struct raw3270_view *view;
329  struct raw3270_request *rq;
330  int rc;
331 
332  rp = dev_get_drvdata(&cdev->dev);
333  if (!rp)
334  return;
335  rq = (struct raw3270_request *) intparm;
336  view = rq ? rq->view : rp->view;
337 
338  if (IS_ERR(irb))
339  rc = RAW3270_IO_RETRY;
340  else if (irb->scsw.cmd.fctl & SCSW_FCTL_HALT_FUNC) {
341  rq->rc = -EIO;
342  rc = RAW3270_IO_DONE;
343  } else if (irb->scsw.cmd.dstat == (DEV_STAT_CHN_END | DEV_STAT_DEV_END |
345  /* Handle CE-DE-UE and subsequent UDE */
347  rc = RAW3270_IO_BUSY;
348  } else if (test_bit(RAW3270_FLAGS_BUSY, &rp->flags)) {
349  /* Wait for UDE if busy flag is set. */
350  if (irb->scsw.cmd.dstat & DEV_STAT_DEV_END) {
352  /* Got it, now retry. */
353  rc = RAW3270_IO_RETRY;
354  } else
355  rc = RAW3270_IO_BUSY;
356  } else if (view)
357  rc = view->fn->intv(view, rq, irb);
358  else
359  rc = RAW3270_IO_DONE;
360 
361  switch (rc) {
362  case RAW3270_IO_DONE:
363  break;
364  case RAW3270_IO_BUSY:
365  /*
366  * Intervention required by the operator. We have to wait
367  * for unsolicited device end.
368  */
369  return;
370  case RAW3270_IO_RETRY:
371  if (!rq)
372  break;
373  rq->rc = ccw_device_start(rp->cdev, &rq->ccw,
374  (unsigned long) rq, 0, 0);
375  if (rq->rc == 0)
376  return; /* Successfully restarted. */
377  break;
378  case RAW3270_IO_STOP:
379  if (!rq)
380  break;
381  raw3270_halt_io_nolock(rp, rq);
382  rq->rc = -EIO;
383  break;
384  default:
385  BUG();
386  }
387  if (rq) {
388  BUG_ON(list_empty(&rq->list));
389  /* The request completed, remove from queue and do callback. */
390  list_del_init(&rq->list);
391  if (rq->callback)
392  rq->callback(rq, rq->callback_data);
393  /* Do put_device for get_device in raw3270_start. */
394  raw3270_put_view(view);
395  }
396  /*
397  * Try to start each request on request queue until one is
398  * started successful.
399  */
400  while (!list_empty(&rp->req_queue)) {
401  rq = list_entry(rp->req_queue.next,struct raw3270_request,list);
402  rq->rc = ccw_device_start(rp->cdev, &rq->ccw,
403  (unsigned long) rq, 0, 0);
404  if (rq->rc == 0)
405  break;
406  /* Start failed. Remove request and do callback. */
407  list_del_init(&rq->list);
408  if (rq->callback)
409  rq->callback(rq, rq->callback_data);
410  /* Do put_device for get_device in raw3270_start. */
411  raw3270_put_view(view);
412  }
413 }
414 
415 /*
416  * Size sensing.
417  */
418 
419 struct raw3270_ua { /* Query Reply structure for Usable Area */
420  struct { /* Usable Area Query Reply Base */
421  short l; /* Length of this structured field */
422  char sfid; /* 0x81 if Query Reply */
423  char qcode; /* 0x81 if Usable Area */
424  char flags0;
425  char flags1;
426  short w; /* Width of usable area */
427  short h; /* Heigth of usavle area */
428  char units; /* 0x00:in; 0x01:mm */
429  int xr;
430  int yr;
431  char aw;
432  char ah;
433  short buffsz; /* Character buffer size, bytes */
434  char xmin;
435  char ymin;
436  char xmax;
437  char ymax;
438  } __attribute__ ((packed)) uab;
439  struct { /* Alternate Usable Area Self-Defining Parameter */
440  char l; /* Length of this Self-Defining Parm */
441  char sdpid; /* 0x02 if Alternate Usable Area */
442  char res;
443  char auaid; /* 0x01 is Id for the A U A */
444  short wauai; /* Width of AUAi */
445  short hauai; /* Height of AUAi */
446  char auaunits; /* 0x00:in, 0x01:mm */
447  int auaxr;
448  int auayr;
449  char awauai;
450  char ahauai;
451  } __attribute__ ((packed)) aua;
452 } __attribute__ ((packed));
454 static struct diag210 raw3270_init_diag210;
455 static DEFINE_MUTEX(raw3270_init_mutex);
457 static int
458 raw3270_init_irq(struct raw3270_view *view, struct raw3270_request *rq,
459  struct irb *irb)
460 {
461  /*
462  * Unit-Check Processing:
463  * Expect Command Reject or Intervention Required.
464  */
465  if (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) {
466  /* Request finished abnormally. */
467  if (irb->ecw[0] & SNS0_INTERVENTION_REQ) {
468  set_bit(RAW3270_FLAGS_BUSY, &view->dev->flags);
469  return RAW3270_IO_BUSY;
470  }
471  }
472  if (rq) {
473  if (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) {
474  if (irb->ecw[0] & SNS0_CMD_REJECT)
475  rq->rc = -EOPNOTSUPP;
476  else
477  rq->rc = -EIO;
478  } else
479  /* Request finished normally. Copy residual count. */
480  rq->rescnt = irb->scsw.cmd.count;
481  }
482  if (irb->scsw.cmd.dstat & DEV_STAT_ATTENTION) {
483  set_bit(RAW3270_FLAGS_ATTN, &view->dev->flags);
485  }
486  return RAW3270_IO_DONE;
487 }
488 
489 static struct raw3270_fn raw3270_init_fn = {
490  .intv = raw3270_init_irq
491 };
492 
493 static struct raw3270_view raw3270_init_view = {
494  .fn = &raw3270_init_fn
495 };
496 
497 /*
498  * raw3270_wait/raw3270_wait_interruptible/__raw3270_wakeup
499  * Wait for end of request. The request must have been started
500  * with raw3270_start, rc = 0. The device lock may NOT have been
501  * released between calling raw3270_start and raw3270_wait.
502  */
503 static void
504 raw3270_wake_init(struct raw3270_request *rq, void *data)
505 {
506  wake_up((wait_queue_head_t *) data);
507 }
508 
509 /*
510  * Special wait function that can cope with console initialization.
511  */
512 static int
513 raw3270_start_init(struct raw3270 *rp, struct raw3270_view *view,
514  struct raw3270_request *rq)
515 {
516  unsigned long flags;
517  int rc;
518 
519 #ifdef CONFIG_TN3270_CONSOLE
520  if (raw3270_registered == 0) {
521  spin_lock_irqsave(get_ccwdev_lock(view->dev->cdev), flags);
522  rq->callback = NULL;
523  rc = __raw3270_start(rp, view, rq);
524  if (rc == 0)
525  while (!raw3270_request_final(rq)) {
526  wait_cons_dev();
527  barrier();
528  }
529  spin_unlock_irqrestore(get_ccwdev_lock(view->dev->cdev), flags);
530  return rq->rc;
531  }
532 #endif
533  rq->callback = raw3270_wake_init;
535  spin_lock_irqsave(get_ccwdev_lock(view->dev->cdev), flags);
536  rc = __raw3270_start(rp, view, rq);
537  spin_unlock_irqrestore(get_ccwdev_lock(view->dev->cdev), flags);
538  if (rc)
539  return rc;
540  /* Now wait for the completion. */
541  rc = wait_event_interruptible(raw3270_wait_queue,
542  raw3270_request_final(rq));
543  if (rc == -ERESTARTSYS) { /* Interrupted by a signal. */
544  raw3270_halt_io(view->dev, rq);
545  /* No wait for the halt to complete. */
546  wait_event(raw3270_wait_queue, raw3270_request_final(rq));
547  return -ERESTARTSYS;
548  }
549  return rq->rc;
550 }
551 
552 static int
553 __raw3270_size_device_vm(struct raw3270 *rp)
554 {
555  int rc, model;
556  struct ccw_dev_id dev_id;
557 
559  raw3270_init_diag210.vrdcdvno = dev_id.devno;
560  raw3270_init_diag210.vrdclen = sizeof(struct diag210);
561  rc = diag210(&raw3270_init_diag210);
562  if (rc)
563  return rc;
564  model = raw3270_init_diag210.vrdccrmd;
565  switch (model) {
566  case 2:
567  rp->model = model;
568  rp->rows = 24;
569  rp->cols = 80;
570  break;
571  case 3:
572  rp->model = model;
573  rp->rows = 32;
574  rp->cols = 80;
575  break;
576  case 4:
577  rp->model = model;
578  rp->rows = 43;
579  rp->cols = 80;
580  break;
581  case 5:
582  rp->model = model;
583  rp->rows = 27;
584  rp->cols = 132;
585  break;
586  default:
587  rc = -EOPNOTSUPP;
588  break;
589  }
590  return rc;
591 }
592 
593 static int
594 __raw3270_size_device(struct raw3270 *rp)
595 {
596  static const unsigned char wbuf[] =
597  { 0x00, 0x07, 0x01, 0xff, 0x03, 0x00, 0x81 };
598  struct raw3270_ua *uap;
599  int rc;
600 
601  /*
602  * To determine the size of the 3270 device we need to do:
603  * 1) send a 'read partition' data stream to the device
604  * 2) wait for the attn interrupt that precedes the query reply
605  * 3) do a read modified to get the query reply
606  * To make things worse we have to cope with intervention
607  * required (3270 device switched to 'stand-by') and command
608  * rejects (old devices that can't do 'read partition').
609  */
610  memset(&rp->init_request, 0, sizeof(rp->init_request));
611  memset(&rp->init_data, 0, 256);
612  /* Store 'read partition' data stream to init_data */
613  memcpy(&rp->init_data, wbuf, sizeof(wbuf));
614  INIT_LIST_HEAD(&rp->init_request.list);
615  rp->init_request.ccw.cmd_code = TC_WRITESF;
616  rp->init_request.ccw.flags = CCW_FLAG_SLI;
617  rp->init_request.ccw.count = sizeof(wbuf);
618  rp->init_request.ccw.cda = (__u32) __pa(&rp->init_data);
619 
620  rc = raw3270_start_init(rp, &raw3270_init_view, &rp->init_request);
621  if (rc)
622  /* Check error cases: -ERESTARTSYS, -EIO and -EOPNOTSUPP */
623  return rc;
624 
625  /* Wait for attention interrupt. */
626 #ifdef CONFIG_TN3270_CONSOLE
627  if (raw3270_registered == 0) {
628  unsigned long flags;
629 
632  wait_cons_dev();
633  spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
634  } else
635 #endif
636  rc = wait_event_interruptible(raw3270_wait_queue,
638  if (rc)
639  return rc;
640 
641  /*
642  * The device accepted the 'read partition' command. Now
643  * set up a read ccw and issue it.
644  */
645  rp->init_request.ccw.cmd_code = TC_READMOD;
646  rp->init_request.ccw.flags = CCW_FLAG_SLI;
647  rp->init_request.ccw.count = sizeof(rp->init_data);
648  rp->init_request.ccw.cda = (__u32) __pa(rp->init_data);
649  rc = raw3270_start_init(rp, &raw3270_init_view, &rp->init_request);
650  if (rc)
651  return rc;
652  /* Got a Query Reply */
653  uap = (struct raw3270_ua *) (rp->init_data + 1);
654  /* Paranoia check. */
655  if (rp->init_data[0] != 0x88 || uap->uab.qcode != 0x81)
656  return -EOPNOTSUPP;
657  /* Copy rows/columns of default Usable Area */
658  rp->rows = uap->uab.h;
659  rp->cols = uap->uab.w;
660  /* Check for 14 bit addressing */
661  if ((uap->uab.flags0 & 0x0d) == 0x01)
663  /* Check for Alternate Usable Area */
664  if (uap->uab.l == sizeof(struct raw3270_ua) &&
665  uap->aua.sdpid == 0x02) {
666  rp->rows = uap->aua.hauai;
667  rp->cols = uap->aua.wauai;
668  }
669  return 0;
670 }
671 
672 static int
673 raw3270_size_device(struct raw3270 *rp)
674 {
675  int rc;
676 
677  mutex_lock(&raw3270_init_mutex);
678  rp->view = &raw3270_init_view;
679  raw3270_init_view.dev = rp;
680  if (MACHINE_IS_VM)
681  rc = __raw3270_size_device_vm(rp);
682  else
683  rc = __raw3270_size_device(rp);
684  raw3270_init_view.dev = NULL;
685  rp->view = NULL;
686  mutex_unlock(&raw3270_init_mutex);
687  if (rc == 0) { /* Found something. */
688  /* Try to find a model. */
689  rp->model = 0;
690  if (rp->rows == 24 && rp->cols == 80)
691  rp->model = 2;
692  if (rp->rows == 32 && rp->cols == 80)
693  rp->model = 3;
694  if (rp->rows == 43 && rp->cols == 80)
695  rp->model = 4;
696  if (rp->rows == 27 && rp->cols == 132)
697  rp->model = 5;
698  } else {
699  /* Couldn't detect size. Use default model 2. */
700  rp->model = 2;
701  rp->rows = 24;
702  rp->cols = 80;
703  return 0;
704  }
705  return rc;
706 }
707 
708 static int
709 raw3270_reset_device(struct raw3270 *rp)
710 {
711  int rc;
712 
713  mutex_lock(&raw3270_init_mutex);
714  memset(&rp->init_request, 0, sizeof(rp->init_request));
715  memset(&rp->init_data, 0, sizeof(rp->init_data));
716  /* Store reset data stream to init_data/init_request */
717  rp->init_data[0] = TW_KR;
718  INIT_LIST_HEAD(&rp->init_request.list);
719  rp->init_request.ccw.cmd_code = TC_EWRITEA;
720  rp->init_request.ccw.flags = CCW_FLAG_SLI;
721  rp->init_request.ccw.count = 1;
722  rp->init_request.ccw.cda = (__u32) __pa(rp->init_data);
723  rp->view = &raw3270_init_view;
724  raw3270_init_view.dev = rp;
725  rc = raw3270_start_init(rp, &raw3270_init_view, &rp->init_request);
726  raw3270_init_view.dev = NULL;
727  rp->view = NULL;
728  mutex_unlock(&raw3270_init_mutex);
729  return rc;
730 }
731 
732 int
734 {
735  struct raw3270 *rp;
736  int rc;
737 
738  rp = view->dev;
739  if (!rp || rp->view != view ||
741  rc = -EACCES;
742  else if (!test_bit(RAW3270_FLAGS_READY, &rp->flags))
743  rc = -ENODEV;
744  else
745  rc = raw3270_reset_device(view->dev);
746  return rc;
747 }
748 
749 /*
750  * Setup new 3270 device.
751  */
752 static int
753 raw3270_setup_device(struct ccw_device *cdev, struct raw3270 *rp, char *ascebc)
754 {
755  struct list_head *l;
756  struct raw3270 *tmp;
757  int minor;
758 
759  memset(rp, 0, sizeof(struct raw3270));
760  /* Copy ebcdic -> ascii translation table. */
761  memcpy(ascebc, _ascebc, 256);
762  if (tubxcorrect) {
763  /* correct brackets and circumflex */
764  ascebc['['] = 0xad;
765  ascebc[']'] = 0xbd;
766  ascebc['^'] = 0xb0;
767  }
768  rp->ascebc = ascebc;
769 
770  /* Set defaults. */
771  rp->rows = 24;
772  rp->cols = 80;
773 
774  INIT_LIST_HEAD(&rp->req_queue);
775  INIT_LIST_HEAD(&rp->view_list);
776 
777  /*
778  * Add device to list and find the smallest unused minor
779  * number for it. Note: there is no device with minor 0,
780  * see special case for fs3270.c:fs3270_open().
781  */
782  mutex_lock(&raw3270_mutex);
783  /* Keep the list sorted. */
784  minor = RAW3270_FIRSTMINOR;
785  rp->minor = -1;
786  list_for_each(l, &raw3270_devices) {
787  tmp = list_entry(l, struct raw3270, list);
788  if (tmp->minor > minor) {
789  rp->minor = minor;
790  __list_add(&rp->list, l->prev, l);
791  break;
792  }
793  minor++;
794  }
795  if (rp->minor == -1 && minor < RAW3270_MAXDEVS + RAW3270_FIRSTMINOR) {
796  rp->minor = minor;
797  list_add_tail(&rp->list, &raw3270_devices);
798  }
799  mutex_unlock(&raw3270_mutex);
800  /* No free minor number? Then give up. */
801  if (rp->minor == -1)
802  return -EUSERS;
803  rp->cdev = cdev;
804  dev_set_drvdata(&cdev->dev, rp);
805  cdev->handler = raw3270_irq;
806  return 0;
807 }
808 
809 #ifdef CONFIG_TN3270_CONSOLE
810 /*
811  * Setup 3270 device configured as console.
812  */
813 struct raw3270 __init *raw3270_setup_console(struct ccw_device *cdev)
814 {
815  struct raw3270 *rp;
816  char *ascebc;
817  int rc;
818 
819  rp = kzalloc(sizeof(struct raw3270), GFP_KERNEL | GFP_DMA);
820  ascebc = kzalloc(256, GFP_KERNEL);
821  rc = raw3270_setup_device(cdev, rp, ascebc);
822  if (rc)
823  return ERR_PTR(rc);
825  rc = raw3270_reset_device(rp);
826  if (rc)
827  return ERR_PTR(rc);
828  rc = raw3270_size_device(rp);
829  if (rc)
830  return ERR_PTR(rc);
831  rc = raw3270_reset_device(rp);
832  if (rc)
833  return ERR_PTR(rc);
835  return rp;
836 }
837 
838 void
839 raw3270_wait_cons_dev(struct raw3270 *rp)
840 {
841  unsigned long flags;
842 
844  wait_cons_dev();
845  spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
846 }
847 
848 #endif
849 
850 /*
851  * Create a 3270 device structure.
852  */
853 static struct raw3270 *
854 raw3270_create_device(struct ccw_device *cdev)
855 {
856  struct raw3270 *rp;
857  char *ascebc;
858  int rc;
859 
860  rp = kmalloc(sizeof(struct raw3270), GFP_KERNEL | GFP_DMA);
861  if (!rp)
862  return ERR_PTR(-ENOMEM);
863  ascebc = kmalloc(256, GFP_KERNEL);
864  if (!ascebc) {
865  kfree(rp);
866  return ERR_PTR(-ENOMEM);
867  }
868  rc = raw3270_setup_device(cdev, rp, ascebc);
869  if (rc) {
870  kfree(rp->ascebc);
871  kfree(rp);
872  rp = ERR_PTR(rc);
873  }
874  /* Get reference to ccw_device structure. */
875  get_device(&cdev->dev);
876  return rp;
877 }
878 
879 /*
880  * Activate a view.
881  */
882 int
884 {
885  struct raw3270 *rp;
886  struct raw3270_view *oldview, *nv;
887  unsigned long flags;
888  int rc;
889 
890  rp = view->dev;
891  if (!rp)
892  return -ENODEV;
894  if (rp->view == view)
895  rc = 0;
896  else if (!test_bit(RAW3270_FLAGS_READY, &rp->flags))
897  rc = -ENODEV;
898  else if (test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
899  rc = -EACCES;
900  else {
901  oldview = NULL;
902  if (rp->view) {
903  oldview = rp->view;
904  oldview->fn->deactivate(oldview);
905  }
906  rp->view = view;
907  rc = view->fn->activate(view);
908  if (rc) {
909  /* Didn't work. Try to reactivate the old view. */
910  rp->view = oldview;
911  if (!oldview || oldview->fn->activate(oldview) != 0) {
912  /* Didn't work as well. Try any other view. */
914  if (nv != view && nv != oldview) {
915  rp->view = nv;
916  if (nv->fn->activate(nv) == 0)
917  break;
918  rp->view = NULL;
919  }
920  }
921  }
922  }
923  spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
924  return rc;
925 }
926 
927 /*
928  * Deactivate current view.
929  */
930 void
932 {
933  unsigned long flags;
934  struct raw3270 *rp;
935 
936  rp = view->dev;
937  if (!rp)
938  return;
940  if (rp->view == view) {
941  view->fn->deactivate(view);
942  rp->view = NULL;
943  /* Move deactivated view to end of list. */
944  list_del_init(&view->list);
945  list_add_tail(&view->list, &rp->view_list);
946  /* Try to activate another view. */
947  if (test_bit(RAW3270_FLAGS_READY, &rp->flags) &&
949  list_for_each_entry(view, &rp->view_list, list) {
950  rp->view = view;
951  if (view->fn->activate(view) == 0)
952  break;
953  rp->view = NULL;
954  }
955  }
956  }
957  spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
958 }
959 
960 /*
961  * Add view to device with minor "minor".
962  */
963 int
964 raw3270_add_view(struct raw3270_view *view, struct raw3270_fn *fn, int minor)
965 {
966  unsigned long flags;
967  struct raw3270 *rp;
968  int rc;
969 
970  if (minor <= 0)
971  return -ENODEV;
972  mutex_lock(&raw3270_mutex);
973  rc = -ENODEV;
974  list_for_each_entry(rp, &raw3270_devices, list) {
975  if (rp->minor != minor)
976  continue;
978  if (test_bit(RAW3270_FLAGS_READY, &rp->flags)) {
979  atomic_set(&view->ref_count, 2);
980  view->dev = rp;
981  view->fn = fn;
982  view->model = rp->model;
983  view->rows = rp->rows;
984  view->cols = rp->cols;
985  view->ascebc = rp->ascebc;
986  spin_lock_init(&view->lock);
987  list_add(&view->list, &rp->view_list);
988  rc = 0;
989  }
990  spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
991  break;
992  }
993  mutex_unlock(&raw3270_mutex);
994  return rc;
995 }
996 
997 /*
998  * Find specific view of device with minor "minor".
999  */
1000 struct raw3270_view *
1001 raw3270_find_view(struct raw3270_fn *fn, int minor)
1002 {
1003  struct raw3270 *rp;
1004  struct raw3270_view *view, *tmp;
1005  unsigned long flags;
1006 
1007  mutex_lock(&raw3270_mutex);
1008  view = ERR_PTR(-ENODEV);
1009  list_for_each_entry(rp, &raw3270_devices, list) {
1010  if (rp->minor != minor)
1011  continue;
1012  spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
1013  if (test_bit(RAW3270_FLAGS_READY, &rp->flags)) {
1014  view = ERR_PTR(-ENOENT);
1015  list_for_each_entry(tmp, &rp->view_list, list) {
1016  if (tmp->fn == fn) {
1017  raw3270_get_view(tmp);
1018  view = tmp;
1019  break;
1020  }
1021  }
1022  }
1023  spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
1024  break;
1025  }
1026  mutex_unlock(&raw3270_mutex);
1027  return view;
1028 }
1029 
1030 /*
1031  * Remove view from device and free view structure via call to view->fn->free.
1032  */
1033 void
1035 {
1036  unsigned long flags;
1037  struct raw3270 *rp;
1038  struct raw3270_view *nv;
1039 
1040  rp = view->dev;
1041  spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
1042  if (rp->view == view) {
1043  view->fn->deactivate(view);
1044  rp->view = NULL;
1045  }
1046  list_del_init(&view->list);
1047  if (!rp->view && test_bit(RAW3270_FLAGS_READY, &rp->flags) &&
1049  /* Try to activate another view. */
1050  list_for_each_entry(nv, &rp->view_list, list) {
1051  if (nv->fn->activate(nv) == 0) {
1052  rp->view = nv;
1053  break;
1054  }
1055  }
1056  }
1057  spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
1058  /* Wait for reference counter to drop to zero. */
1059  atomic_dec(&view->ref_count);
1061  if (view->fn->free)
1062  view->fn->free(view);
1063 }
1064 
1065 /*
1066  * Remove a 3270 device structure.
1067  */
1068 static void
1069 raw3270_delete_device(struct raw3270 *rp)
1070 {
1071  struct ccw_device *cdev;
1072 
1073  /* Remove from device chain. */
1074  mutex_lock(&raw3270_mutex);
1075  if (rp->clttydev && !IS_ERR(rp->clttydev))
1076  device_destroy(class3270, MKDEV(IBM_TTY3270_MAJOR, rp->minor));
1077  if (rp->cltubdev && !IS_ERR(rp->cltubdev))
1078  device_destroy(class3270, MKDEV(IBM_FS3270_MAJOR, rp->minor));
1079  list_del_init(&rp->list);
1080  mutex_unlock(&raw3270_mutex);
1081 
1082  /* Disconnect from ccw_device. */
1083  cdev = rp->cdev;
1084  rp->cdev = NULL;
1085  dev_set_drvdata(&cdev->dev, NULL);
1086  cdev->handler = NULL;
1087 
1088  /* Put ccw_device structure. */
1089  put_device(&cdev->dev);
1090 
1091  /* Now free raw3270 structure. */
1092  kfree(rp->ascebc);
1093  kfree(rp);
1094 }
1095 
1096 static int
1097 raw3270_probe (struct ccw_device *cdev)
1098 {
1099  return 0;
1100 }
1101 
1102 /*
1103  * Additional attributes for a 3270 device
1104  */
1105 static ssize_t
1106 raw3270_model_show(struct device *dev, struct device_attribute *attr, char *buf)
1107 {
1108  return snprintf(buf, PAGE_SIZE, "%i\n",
1109  ((struct raw3270 *) dev_get_drvdata(dev))->model);
1110 }
1111 static DEVICE_ATTR(model, 0444, raw3270_model_show, NULL);
1112 
1113 static ssize_t
1114 raw3270_rows_show(struct device *dev, struct device_attribute *attr, char *buf)
1115 {
1116  return snprintf(buf, PAGE_SIZE, "%i\n",
1117  ((struct raw3270 *) dev_get_drvdata(dev))->rows);
1118 }
1119 static DEVICE_ATTR(rows, 0444, raw3270_rows_show, NULL);
1120 
1121 static ssize_t
1122 raw3270_columns_show(struct device *dev, struct device_attribute *attr, char *buf)
1123 {
1124  return snprintf(buf, PAGE_SIZE, "%i\n",
1125  ((struct raw3270 *) dev_get_drvdata(dev))->cols);
1126 }
1127 static DEVICE_ATTR(columns, 0444, raw3270_columns_show, NULL);
1128 
1129 static struct attribute * raw3270_attrs[] = {
1130  &dev_attr_model.attr,
1131  &dev_attr_rows.attr,
1132  &dev_attr_columns.attr,
1133  NULL,
1134 };
1135 
1136 static struct attribute_group raw3270_attr_group = {
1137  .attrs = raw3270_attrs,
1138 };
1139 
1140 static int raw3270_create_attributes(struct raw3270 *rp)
1141 {
1142  int rc;
1143 
1144  rc = sysfs_create_group(&rp->cdev->dev.kobj, &raw3270_attr_group);
1145  if (rc)
1146  goto out;
1147 
1148  rp->clttydev = device_create(class3270, &rp->cdev->dev,
1150  "tty%s", dev_name(&rp->cdev->dev));
1151  if (IS_ERR(rp->clttydev)) {
1152  rc = PTR_ERR(rp->clttydev);
1153  goto out_ttydev;
1154  }
1155 
1156  rp->cltubdev = device_create(class3270, &rp->cdev->dev,
1158  "tub%s", dev_name(&rp->cdev->dev));
1159  if (!IS_ERR(rp->cltubdev))
1160  goto out;
1161 
1162  rc = PTR_ERR(rp->cltubdev);
1163  device_destroy(class3270, MKDEV(IBM_TTY3270_MAJOR, rp->minor));
1164 
1165 out_ttydev:
1166  sysfs_remove_group(&rp->cdev->dev.kobj, &raw3270_attr_group);
1167 out:
1168  return rc;
1169 }
1170 
1171 /*
1172  * Notifier for device addition/removal
1173  */
1175  struct list_head list;
1176  void (*notifier)(int, int);
1177 };
1178 
1179 static LIST_HEAD(raw3270_notifier);
1180 
1181 int raw3270_register_notifier(void (*notifier)(int, int))
1182 {
1183  struct raw3270_notifier *np;
1184  struct raw3270 *rp;
1185 
1186  np = kmalloc(sizeof(struct raw3270_notifier), GFP_KERNEL);
1187  if (!np)
1188  return -ENOMEM;
1189  np->notifier = notifier;
1190  mutex_lock(&raw3270_mutex);
1192  list_for_each_entry(rp, &raw3270_devices, list) {
1193  get_device(&rp->cdev->dev);
1194  notifier(rp->minor, 1);
1195  }
1196  mutex_unlock(&raw3270_mutex);
1197  return 0;
1198 }
1199 
1200 void raw3270_unregister_notifier(void (*notifier)(int, int))
1201 {
1202  struct raw3270_notifier *np;
1203 
1204  mutex_lock(&raw3270_mutex);
1206  if (np->notifier == notifier) {
1207  list_del(&np->list);
1208  kfree(np);
1209  break;
1210  }
1211  mutex_unlock(&raw3270_mutex);
1212 }
1213 
1214 /*
1215  * Set 3270 device online.
1216  */
1217 static int
1218 raw3270_set_online (struct ccw_device *cdev)
1219 {
1220  struct raw3270 *rp;
1221  struct raw3270_notifier *np;
1222  int rc;
1223 
1224  rp = raw3270_create_device(cdev);
1225  if (IS_ERR(rp))
1226  return PTR_ERR(rp);
1227  rc = raw3270_reset_device(rp);
1228  if (rc)
1229  goto failure;
1230  rc = raw3270_size_device(rp);
1231  if (rc)
1232  goto failure;
1233  rc = raw3270_reset_device(rp);
1234  if (rc)
1235  goto failure;
1236  rc = raw3270_create_attributes(rp);
1237  if (rc)
1238  goto failure;
1240  mutex_lock(&raw3270_mutex);
1242  np->notifier(rp->minor, 1);
1243  mutex_unlock(&raw3270_mutex);
1244  return 0;
1245 
1246 failure:
1247  raw3270_delete_device(rp);
1248  return rc;
1249 }
1250 
1251 /*
1252  * Remove 3270 device structure.
1253  */
1254 static void
1255 raw3270_remove (struct ccw_device *cdev)
1256 {
1257  unsigned long flags;
1258  struct raw3270 *rp;
1259  struct raw3270_view *v;
1260  struct raw3270_notifier *np;
1261 
1262  rp = dev_get_drvdata(&cdev->dev);
1263  /*
1264  * _remove is the opposite of _probe; it's probe that
1265  * should set up rp. raw3270_remove gets entered for
1266  * devices even if they haven't been varied online.
1267  * Thus, rp may validly be NULL here.
1268  */
1269  if (rp == NULL)
1270  return;
1272 
1273  sysfs_remove_group(&cdev->dev.kobj, &raw3270_attr_group);
1274 
1275  /* Deactivate current view and remove all views. */
1276  spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
1277  if (rp->view) {
1278  rp->view->fn->deactivate(rp->view);
1279  rp->view = NULL;
1280  }
1281  while (!list_empty(&rp->view_list)) {
1282  v = list_entry(rp->view_list.next, struct raw3270_view, list);
1283  if (v->fn->release)
1284  v->fn->release(v);
1285  spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
1286  raw3270_del_view(v);
1287  spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
1288  }
1289  spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
1290 
1291  mutex_lock(&raw3270_mutex);
1293  np->notifier(rp->minor, 0);
1294  mutex_unlock(&raw3270_mutex);
1295 
1296  /* Reset 3270 device. */
1297  raw3270_reset_device(rp);
1298  /* And finally remove it. */
1299  raw3270_delete_device(rp);
1300 }
1301 
1302 /*
1303  * Set 3270 device offline.
1304  */
1305 static int
1306 raw3270_set_offline (struct ccw_device *cdev)
1307 {
1308  struct raw3270 *rp;
1309 
1310  rp = dev_get_drvdata(&cdev->dev);
1312  return -EBUSY;
1313  raw3270_remove(cdev);
1314  return 0;
1315 }
1316 
1317 static int raw3270_pm_stop(struct ccw_device *cdev)
1318 {
1319  struct raw3270 *rp;
1320  struct raw3270_view *view;
1321  unsigned long flags;
1322 
1323  rp = dev_get_drvdata(&cdev->dev);
1324  if (!rp)
1325  return 0;
1326  spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
1327  if (rp->view)
1328  rp->view->fn->deactivate(rp->view);
1329  if (!test_bit(RAW3270_FLAGS_CONSOLE, &rp->flags)) {
1330  /*
1331  * Release tty and fullscreen for all non-console
1332  * devices.
1333  */
1334  list_for_each_entry(view, &rp->view_list, list) {
1335  if (view->fn->release)
1336  view->fn->release(view);
1337  }
1338  }
1340  spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
1341  return 0;
1342 }
1343 
1344 static int raw3270_pm_start(struct ccw_device *cdev)
1345 {
1346  struct raw3270 *rp;
1347  unsigned long flags;
1348 
1349  rp = dev_get_drvdata(&cdev->dev);
1350  if (!rp)
1351  return 0;
1352  spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
1354  if (rp->view)
1355  rp->view->fn->activate(rp->view);
1356  spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
1357  return 0;
1358 }
1359 
1361 {
1362 #ifdef CONFIG_TN3270_CONSOLE
1363  struct raw3270 *rp;
1364 
1365  rp = view->dev;
1366  if (rp && test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
1368 #endif
1369 }
1370 
1371 static struct ccw_device_id raw3270_id[] = {
1372  { CCW_DEVICE(0x3270, 0) },
1373  { CCW_DEVICE(0x3271, 0) },
1374  { CCW_DEVICE(0x3272, 0) },
1375  { CCW_DEVICE(0x3273, 0) },
1376  { CCW_DEVICE(0x3274, 0) },
1377  { CCW_DEVICE(0x3275, 0) },
1378  { CCW_DEVICE(0x3276, 0) },
1379  { CCW_DEVICE(0x3277, 0) },
1380  { CCW_DEVICE(0x3278, 0) },
1381  { CCW_DEVICE(0x3279, 0) },
1382  { CCW_DEVICE(0x3174, 0) },
1383  { /* end of list */ },
1384 };
1385 
1386 static struct ccw_driver raw3270_ccw_driver = {
1387  .driver = {
1388  .name = "3270",
1389  .owner = THIS_MODULE,
1390  },
1391  .ids = raw3270_id,
1392  .probe = &raw3270_probe,
1393  .remove = &raw3270_remove,
1394  .set_online = &raw3270_set_online,
1395  .set_offline = &raw3270_set_offline,
1396  .freeze = &raw3270_pm_stop,
1397  .thaw = &raw3270_pm_start,
1398  .restore = &raw3270_pm_start,
1399  .int_class = IOINT_C70,
1400 };
1401 
1402 static int
1403 raw3270_init(void)
1404 {
1405  struct raw3270 *rp;
1406  int rc;
1407 
1408  if (raw3270_registered)
1409  return 0;
1410  raw3270_registered = 1;
1411  rc = ccw_driver_register(&raw3270_ccw_driver);
1412  if (rc == 0) {
1413  /* Create attributes for early (= console) device. */
1414  mutex_lock(&raw3270_mutex);
1415  class3270 = class_create(THIS_MODULE, "3270");
1416  list_for_each_entry(rp, &raw3270_devices, list) {
1417  get_device(&rp->cdev->dev);
1418  raw3270_create_attributes(rp);
1419  }
1420  mutex_unlock(&raw3270_mutex);
1421  }
1422  return rc;
1423 }
1424 
1425 static void
1426 raw3270_exit(void)
1427 {
1428  ccw_driver_unregister(&raw3270_ccw_driver);
1429  class_destroy(class3270);
1430 }
1431 
1432 MODULE_LICENSE("GPL");
1433 
1434 module_init(raw3270_init);
1435 module_exit(raw3270_exit);
1436 
1456 EXPORT_SYMBOL(raw3270_wait_queue);