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