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