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