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