blob: 2a4c566456e70d577dd0d7680022e80d8e528ded [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Martin Schwidefsky4b214a02009-06-16 10:30:47 +02002 * IBM/3270 Driver - core functions.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
Martin Schwidefsky4b214a02009-06-16 10:30:47 +02004 * Author(s):
5 * Original 3270 Code for 2.4 written by Richard Hitt (UTS Global)
6 * Rewritten for 2.5 by Martin Schwidefsky <schwidefsky@de.ibm.com>
7 * Copyright IBM Corp. 2003, 2009
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 */
9
Linus Torvalds1da177e2005-04-16 15:20:36 -070010#include <linux/module.h>
11#include <linux/err.h>
12#include <linux/init.h>
13#include <linux/interrupt.h>
14#include <linux/list.h>
15#include <linux/slab.h>
16#include <linux/types.h>
17#include <linux/wait.h>
18
19#include <asm/ccwdev.h>
20#include <asm/cio.h>
21#include <asm/ebcdic.h>
Michael Holzheu0a87c5c2007-08-22 13:51:40 +020022#include <asm/diag.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023
24#include "raw3270.h"
25
Richard Hitted3cb6f2005-10-30 15:00:10 -080026#include <linux/major.h>
27#include <linux/kdev_t.h>
28#include <linux/device.h>
Ingo Molnar14cc3e22006-03-26 01:37:14 -080029#include <linux/mutex.h>
Richard Hitted3cb6f2005-10-30 15:00:10 -080030
Heiko Carstens2b67fc42007-02-05 21:16:47 +010031static struct class *class3270;
Richard Hitted3cb6f2005-10-30 15:00:10 -080032
Linus Torvalds1da177e2005-04-16 15:20:36 -070033/* The main 3270 data structure. */
34struct raw3270 {
35 struct list_head list;
36 struct ccw_device *cdev;
37 int minor;
38
39 short model, rows, cols;
40 unsigned long flags;
41
42 struct list_head req_queue; /* Request queue. */
43 struct list_head view_list; /* List of available views. */
44 struct raw3270_view *view; /* Active view. */
45
46 struct timer_list timer; /* Device timer. */
47
48 unsigned char *ascebc; /* ascii -> ebcdic table */
Cornelia Huck7f021ce2007-10-22 12:52:42 +020049 struct device *clttydev; /* 3270-class tty device ptr */
50 struct device *cltubdev; /* 3270-class tub device ptr */
Martin Schwidefsky132fab12006-06-29 14:57:39 +020051
52 struct raw3270_request init_request;
53 unsigned char init_data[256];
Linus Torvalds1da177e2005-04-16 15:20:36 -070054};
55
56/* raw3270->flags */
57#define RAW3270_FLAGS_14BITADDR 0 /* 14-bit buffer addresses */
58#define RAW3270_FLAGS_BUSY 1 /* Device busy, leave it alone */
59#define RAW3270_FLAGS_ATTN 2 /* Device sent an ATTN interrupt */
60#define RAW3270_FLAGS_READY 4 /* Device is useable by views */
61#define RAW3270_FLAGS_CONSOLE 8 /* Device is the console. */
Martin Schwidefsky4b214a02009-06-16 10:30:47 +020062#define RAW3270_FLAGS_FROZEN 16 /* set if 3270 is frozen for suspend */
Linus Torvalds1da177e2005-04-16 15:20:36 -070063
64/* Semaphore to protect global data of raw3270 (devices, views, etc). */
Ingo Molnar14cc3e22006-03-26 01:37:14 -080065static DEFINE_MUTEX(raw3270_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070066
67/* List of 3270 devices. */
Denis Chengc11ca972008-01-26 14:11:13 +010068static LIST_HEAD(raw3270_devices);
Linus Torvalds1da177e2005-04-16 15:20:36 -070069
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 */
75static int raw3270_registered;
76
77/* Module parameters */
78static int tubxcorrect = 0;
79module_param(tubxcorrect, bool, 0);
80
81/*
82 * Wait queue for device init/delete, view delete.
83 */
84DECLARE_WAIT_QUEUE_HEAD(raw3270_wait_queue);
85
86/*
87 * Encode array for 12 bit 3270 addresses.
88 */
Heiko Carstens2b67fc42007-02-05 21:16:47 +010089static unsigned char raw3270_ebcgraf[64] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 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
100void
101raw3270_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 */
115struct raw3270_request *
116raw3270_request_alloc(size_t size)
117{
118 struct raw3270_request *rq;
119
120 /* Allocate request structure */
Eric Sesterhenn88abaab2006-03-24 03:15:31 -0800121 rq = kzalloc(sizeof(struct raw3270_request), GFP_KERNEL | GFP_DMA);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 if (!rq)
123 return ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124
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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145/*
146 * Free 3270 ccw request
147 */
148void
149raw3270_request_free (struct raw3270_request *rq)
150{
Jesper Juhl17fd6822005-11-07 01:01:30 -0800151 kfree(rq->buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 kfree(rq);
153}
154
155/*
156 * Reset request to initial state.
157 */
158void
159raw3270_request_reset(struct raw3270_request *rq)
160{
161 BUG_ON(!list_empty(&rq->list));
162 rq->ccw.cmd_code = 0;
163 rq->ccw.count = 0;
164 rq->ccw.cda = __pa(rq->buffer);
165 rq->ccw.flags = CCW_FLAG_SLI;
166 rq->rescnt = 0;
167 rq->rc = 0;
168}
169
170/*
171 * Set command code to ccw of a request.
172 */
173void
174raw3270_request_set_cmd(struct raw3270_request *rq, u8 cmd)
175{
176 rq->ccw.cmd_code = cmd;
177}
178
179/*
180 * Add data fragment to output buffer.
181 */
182int
183raw3270_request_add_data(struct raw3270_request *rq, void *data, size_t size)
184{
185 if (size + rq->ccw.count > rq->size)
186 return -E2BIG;
187 memcpy(rq->buffer + rq->ccw.count, data, size);
188 rq->ccw.count += size;
189 return 0;
190}
191
192/*
193 * Set address/length pair to ccw of a request.
194 */
195void
196raw3270_request_set_data(struct raw3270_request *rq, void *data, size_t size)
197{
198 rq->ccw.cda = __pa(data);
199 rq->ccw.count = size;
200}
201
202/*
203 * Set idal buffer to ccw of a request.
204 */
205void
206raw3270_request_set_idal(struct raw3270_request *rq, struct idal_buffer *ib)
207{
208 rq->ccw.cda = __pa(ib->data);
209 rq->ccw.count = ib->size;
210 rq->ccw.flags |= CCW_FLAG_IDA;
211}
212
213/*
214 * Stop running ccw.
215 */
216static int
217raw3270_halt_io_nolock(struct raw3270 *rp, struct raw3270_request *rq)
218{
219 int retries;
220 int rc;
221
222 if (raw3270_request_final(rq))
223 return 0;
224 /* Check if interrupt has already been processed */
225 for (retries = 0; retries < 5; retries++) {
226 if (retries < 2)
227 rc = ccw_device_halt(rp->cdev, (long) rq);
228 else
229 rc = ccw_device_clear(rp->cdev, (long) rq);
230 if (rc == 0)
231 break; /* termination successful */
232 }
233 return rc;
234}
235
236static int
237raw3270_halt_io(struct raw3270 *rp, struct raw3270_request *rq)
238{
239 unsigned long flags;
240 int rc;
241
242 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
243 rc = raw3270_halt_io_nolock(rp, rq);
244 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
245 return rc;
246}
247
248/*
249 * Add the request to the request queue, try to start it if the
250 * 3270 device is idle. Return without waiting for end of i/o.
251 */
252static int
253__raw3270_start(struct raw3270 *rp, struct raw3270_view *view,
254 struct raw3270_request *rq)
255{
256 rq->view = view;
257 raw3270_get_view(view);
258 if (list_empty(&rp->req_queue) &&
259 !test_bit(RAW3270_FLAGS_BUSY, &rp->flags)) {
260 /* No other requests are on the queue. Start this one. */
261 rq->rc = ccw_device_start(rp->cdev, &rq->ccw,
262 (unsigned long) rq, 0, 0);
263 if (rq->rc) {
264 raw3270_put_view(view);
265 return rq->rc;
266 }
267 }
268 list_add_tail(&rq->list, &rp->req_queue);
269 return 0;
270}
271
272int
273raw3270_start(struct raw3270_view *view, struct raw3270_request *rq)
274{
275 unsigned long flags;
276 struct raw3270 *rp;
277 int rc;
278
279 spin_lock_irqsave(get_ccwdev_lock(view->dev->cdev), flags);
280 rp = view->dev;
Martin Schwidefsky4b214a02009-06-16 10:30:47 +0200281 if (!rp || rp->view != view ||
282 test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 rc = -EACCES;
284 else if (!test_bit(RAW3270_FLAGS_READY, &rp->flags))
285 rc = -ENODEV;
286 else
287 rc = __raw3270_start(rp, view, rq);
288 spin_unlock_irqrestore(get_ccwdev_lock(view->dev->cdev), flags);
289 return rc;
290}
291
292int
Richard Hitted3cb6f2005-10-30 15:00:10 -0800293raw3270_start_locked(struct raw3270_view *view, struct raw3270_request *rq)
294{
295 struct raw3270 *rp;
296 int rc;
297
298 rp = view->dev;
Martin Schwidefsky4b214a02009-06-16 10:30:47 +0200299 if (!rp || rp->view != view ||
300 test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
Richard Hitted3cb6f2005-10-30 15:00:10 -0800301 rc = -EACCES;
302 else if (!test_bit(RAW3270_FLAGS_READY, &rp->flags))
303 rc = -ENODEV;
304 else
305 rc = __raw3270_start(rp, view, rq);
306 return rc;
307}
308
309int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310raw3270_start_irq(struct raw3270_view *view, struct raw3270_request *rq)
311{
312 struct raw3270 *rp;
313
314 rp = view->dev;
315 rq->view = view;
316 raw3270_get_view(view);
317 list_add_tail(&rq->list, &rp->req_queue);
318 return 0;
319}
320
321/*
322 * 3270 interrupt routine, called from the ccw_device layer
323 */
324static void
325raw3270_irq (struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
326{
327 struct raw3270 *rp;
328 struct raw3270_view *view;
329 struct raw3270_request *rq;
330 int rc;
331
Greg Kroah-Hartmandff59b62009-05-04 12:40:54 -0700332 rp = dev_get_drvdata(&cdev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 if (!rp)
334 return;
335 rq = (struct raw3270_request *) intparm;
336 view = rq ? rq->view : rp->view;
337
338 if (IS_ERR(irb))
339 rc = RAW3270_IO_RETRY;
Peter Oberparleiter23d805b2008-07-14 09:58:50 +0200340 else if (irb->scsw.cmd.fctl & SCSW_FCTL_HALT_FUNC) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 rq->rc = -EIO;
342 rc = RAW3270_IO_DONE;
Peter Oberparleiter23d805b2008-07-14 09:58:50 +0200343 } else if (irb->scsw.cmd.dstat == (DEV_STAT_CHN_END | DEV_STAT_DEV_END |
344 DEV_STAT_UNIT_EXCEP)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 /* Handle CE-DE-UE and subsequent UDE */
346 set_bit(RAW3270_FLAGS_BUSY, &rp->flags);
347 rc = RAW3270_IO_BUSY;
348 } else if (test_bit(RAW3270_FLAGS_BUSY, &rp->flags)) {
349 /* Wait for UDE if busy flag is set. */
Peter Oberparleiter23d805b2008-07-14 09:58:50 +0200350 if (irb->scsw.cmd.dstat & DEV_STAT_DEV_END) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 clear_bit(RAW3270_FLAGS_BUSY, &rp->flags);
352 /* Got it, now retry. */
353 rc = RAW3270_IO_RETRY;
354 } else
355 rc = RAW3270_IO_BUSY;
356 } else if (view)
357 rc = view->fn->intv(view, rq, irb);
358 else
359 rc = RAW3270_IO_DONE;
360
361 switch (rc) {
362 case RAW3270_IO_DONE:
363 break;
364 case RAW3270_IO_BUSY:
365 /*
366 * Intervention required by the operator. We have to wait
367 * for unsolicited device end.
368 */
369 return;
370 case RAW3270_IO_RETRY:
371 if (!rq)
372 break;
373 rq->rc = ccw_device_start(rp->cdev, &rq->ccw,
374 (unsigned long) rq, 0, 0);
375 if (rq->rc == 0)
Daniel Mack3ad2f3f2010-02-03 08:01:28 +0800376 return; /* Successfully restarted. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 break;
378 case RAW3270_IO_STOP:
379 if (!rq)
380 break;
381 raw3270_halt_io_nolock(rp, rq);
382 rq->rc = -EIO;
383 break;
384 default:
385 BUG();
386 }
387 if (rq) {
388 BUG_ON(list_empty(&rq->list));
389 /* The request completed, remove from queue and do callback. */
390 list_del_init(&rq->list);
391 if (rq->callback)
392 rq->callback(rq, rq->callback_data);
393 /* Do put_device for get_device in raw3270_start. */
394 raw3270_put_view(view);
395 }
396 /*
397 * Try to start each request on request queue until one is
398 * started successful.
399 */
400 while (!list_empty(&rp->req_queue)) {
401 rq = list_entry(rp->req_queue.next,struct raw3270_request,list);
402 rq->rc = ccw_device_start(rp->cdev, &rq->ccw,
403 (unsigned long) rq, 0, 0);
404 if (rq->rc == 0)
405 break;
406 /* Start failed. Remove request and do callback. */
407 list_del_init(&rq->list);
408 if (rq->callback)
409 rq->callback(rq, rq->callback_data);
410 /* Do put_device for get_device in raw3270_start. */
411 raw3270_put_view(view);
412 }
413}
414
415/*
416 * Size sensing.
417 */
418
419struct raw3270_ua { /* Query Reply structure for Usable Area */
420 struct { /* Usable Area Query Reply Base */
421 short l; /* Length of this structured field */
422 char sfid; /* 0x81 if Query Reply */
423 char qcode; /* 0x81 if Usable Area */
424 char flags0;
425 char flags1;
426 short w; /* Width of usable area */
427 short h; /* Heigth of usavle area */
428 char units; /* 0x00:in; 0x01:mm */
429 int xr;
430 int yr;
431 char aw;
432 char ah;
433 short buffsz; /* Character buffer size, bytes */
434 char xmin;
435 char ymin;
436 char xmax;
437 char ymax;
438 } __attribute__ ((packed)) uab;
439 struct { /* Alternate Usable Area Self-Defining Parameter */
440 char l; /* Length of this Self-Defining Parm */
441 char sdpid; /* 0x02 if Alternate Usable Area */
442 char res;
443 char auaid; /* 0x01 is Id for the A U A */
444 short wauai; /* Width of AUAi */
445 short hauai; /* Height of AUAi */
446 char auaunits; /* 0x00:in, 0x01:mm */
447 int auaxr;
448 int auayr;
449 char awauai;
450 char ahauai;
451 } __attribute__ ((packed)) aua;
452} __attribute__ ((packed));
453
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454static struct diag210 raw3270_init_diag210;
Christoph Hellwigd330f932007-05-31 17:38:04 +0200455static DEFINE_MUTEX(raw3270_init_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456
457static int
458raw3270_init_irq(struct raw3270_view *view, struct raw3270_request *rq,
459 struct irb *irb)
460{
461 /*
462 * Unit-Check Processing:
463 * Expect Command Reject or Intervention Required.
464 */
Peter Oberparleiter23d805b2008-07-14 09:58:50 +0200465 if (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 /* Request finished abnormally. */
467 if (irb->ecw[0] & SNS0_INTERVENTION_REQ) {
468 set_bit(RAW3270_FLAGS_BUSY, &view->dev->flags);
469 return RAW3270_IO_BUSY;
470 }
471 }
472 if (rq) {
Peter Oberparleiter23d805b2008-07-14 09:58:50 +0200473 if (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 if (irb->ecw[0] & SNS0_CMD_REJECT)
475 rq->rc = -EOPNOTSUPP;
476 else
477 rq->rc = -EIO;
478 } else
479 /* Request finished normally. Copy residual count. */
Peter Oberparleiter23d805b2008-07-14 09:58:50 +0200480 rq->rescnt = irb->scsw.cmd.count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 }
Peter Oberparleiter23d805b2008-07-14 09:58:50 +0200482 if (irb->scsw.cmd.dstat & DEV_STAT_ATTENTION) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 set_bit(RAW3270_FLAGS_ATTN, &view->dev->flags);
484 wake_up(&raw3270_wait_queue);
485 }
486 return RAW3270_IO_DONE;
487}
488
489static struct raw3270_fn raw3270_init_fn = {
490 .intv = raw3270_init_irq
491};
492
493static struct raw3270_view raw3270_init_view = {
494 .fn = &raw3270_init_fn
495};
496
497/*
498 * raw3270_wait/raw3270_wait_interruptible/__raw3270_wakeup
499 * Wait for end of request. The request must have been started
500 * with raw3270_start, rc = 0. The device lock may NOT have been
501 * released between calling raw3270_start and raw3270_wait.
502 */
503static void
504raw3270_wake_init(struct raw3270_request *rq, void *data)
505{
506 wake_up((wait_queue_head_t *) data);
507}
508
509/*
510 * Special wait function that can cope with console initialization.
511 */
512static int
513raw3270_start_init(struct raw3270 *rp, struct raw3270_view *view,
514 struct raw3270_request *rq)
515{
516 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 int rc;
518
519#ifdef CONFIG_TN3270_CONSOLE
520 if (raw3270_registered == 0) {
521 spin_lock_irqsave(get_ccwdev_lock(view->dev->cdev), flags);
Heiko Carstensd2c993d2006-07-12 16:41:55 +0200522 rq->callback = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 rc = __raw3270_start(rp, view, rq);
524 if (rc == 0)
525 while (!raw3270_request_final(rq)) {
526 wait_cons_dev();
527 barrier();
528 }
529 spin_unlock_irqrestore(get_ccwdev_lock(view->dev->cdev), flags);
530 return rq->rc;
531 }
532#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 rq->callback = raw3270_wake_init;
Martin Schwidefsky54ad6412008-05-30 10:03:32 +0200534 rq->callback_data = &raw3270_wait_queue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 spin_lock_irqsave(get_ccwdev_lock(view->dev->cdev), flags);
536 rc = __raw3270_start(rp, view, rq);
537 spin_unlock_irqrestore(get_ccwdev_lock(view->dev->cdev), flags);
538 if (rc)
539 return rc;
540 /* Now wait for the completion. */
Martin Schwidefsky54ad6412008-05-30 10:03:32 +0200541 rc = wait_event_interruptible(raw3270_wait_queue,
542 raw3270_request_final(rq));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 if (rc == -ERESTARTSYS) { /* Interrupted by a signal. */
544 raw3270_halt_io(view->dev, rq);
545 /* No wait for the halt to complete. */
Martin Schwidefsky54ad6412008-05-30 10:03:32 +0200546 wait_event(raw3270_wait_queue, raw3270_request_final(rq));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 return -ERESTARTSYS;
548 }
549 return rq->rc;
550}
551
552static int
553__raw3270_size_device_vm(struct raw3270 *rp)
554{
555 int rc, model;
Cornelia Huck9a92fe42007-05-10 15:45:42 +0200556 struct ccw_dev_id dev_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557
Cornelia Huck9a92fe42007-05-10 15:45:42 +0200558 ccw_device_get_id(rp->cdev, &dev_id);
559 raw3270_init_diag210.vrdcdvno = dev_id.devno;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 raw3270_init_diag210.vrdclen = sizeof(struct diag210);
561 rc = diag210(&raw3270_init_diag210);
562 if (rc)
563 return rc;
564 model = raw3270_init_diag210.vrdccrmd;
565 switch (model) {
566 case 2:
567 rp->model = model;
568 rp->rows = 24;
569 rp->cols = 80;
570 break;
571 case 3:
572 rp->model = model;
573 rp->rows = 32;
574 rp->cols = 80;
575 break;
576 case 4:
577 rp->model = model;
578 rp->rows = 43;
579 rp->cols = 80;
580 break;
581 case 5:
582 rp->model = model;
583 rp->rows = 27;
584 rp->cols = 132;
585 break;
586 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 rc = -EOPNOTSUPP;
588 break;
589 }
590 return rc;
591}
592
593static int
594__raw3270_size_device(struct raw3270 *rp)
595{
596 static const unsigned char wbuf[] =
597 { 0x00, 0x07, 0x01, 0xff, 0x03, 0x00, 0x81 };
598 struct raw3270_ua *uap;
599 unsigned short count;
600 int rc;
601
602 /*
603 * To determine the size of the 3270 device we need to do:
604 * 1) send a 'read partition' data stream to the device
605 * 2) wait for the attn interrupt that preceeds the query reply
606 * 3) do a read modified to get the query reply
607 * To make things worse we have to cope with intervention
608 * required (3270 device switched to 'stand-by') and command
609 * rejects (old devices that can't do 'read partition').
610 */
Martin Schwidefsky132fab12006-06-29 14:57:39 +0200611 memset(&rp->init_request, 0, sizeof(rp->init_request));
612 memset(&rp->init_data, 0, 256);
613 /* Store 'read partition' data stream to init_data */
614 memcpy(&rp->init_data, wbuf, sizeof(wbuf));
615 INIT_LIST_HEAD(&rp->init_request.list);
616 rp->init_request.ccw.cmd_code = TC_WRITESF;
617 rp->init_request.ccw.flags = CCW_FLAG_SLI;
618 rp->init_request.ccw.count = sizeof(wbuf);
619 rp->init_request.ccw.cda = (__u32) __pa(&rp->init_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620
Martin Schwidefsky132fab12006-06-29 14:57:39 +0200621 rc = raw3270_start_init(rp, &raw3270_init_view, &rp->init_request);
Martin Schwidefsky3863e722005-09-03 15:58:06 -0700622 if (rc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 /* Check error cases: -ERESTARTSYS, -EIO and -EOPNOTSUPP */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625
626 /* Wait for attention interrupt. */
627#ifdef CONFIG_TN3270_CONSOLE
628 if (raw3270_registered == 0) {
629 unsigned long flags;
630
631 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
632 while (!test_and_clear_bit(RAW3270_FLAGS_ATTN, &rp->flags))
633 wait_cons_dev();
634 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
635 } else
636#endif
637 rc = wait_event_interruptible(raw3270_wait_queue,
638 test_and_clear_bit(RAW3270_FLAGS_ATTN, &rp->flags));
639 if (rc)
640 return rc;
641
642 /*
643 * The device accepted the 'read partition' command. Now
644 * set up a read ccw and issue it.
645 */
Martin Schwidefsky132fab12006-06-29 14:57:39 +0200646 rp->init_request.ccw.cmd_code = TC_READMOD;
647 rp->init_request.ccw.flags = CCW_FLAG_SLI;
648 rp->init_request.ccw.count = sizeof(rp->init_data);
649 rp->init_request.ccw.cda = (__u32) __pa(rp->init_data);
650 rc = raw3270_start_init(rp, &raw3270_init_view, &rp->init_request);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 if (rc)
652 return rc;
653 /* Got a Query Reply */
Martin Schwidefsky132fab12006-06-29 14:57:39 +0200654 count = sizeof(rp->init_data) - rp->init_request.rescnt;
655 uap = (struct raw3270_ua *) (rp->init_data + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 /* Paranoia check. */
Martin Schwidefsky132fab12006-06-29 14:57:39 +0200657 if (rp->init_data[0] != 0x88 || uap->uab.qcode != 0x81)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 return -EOPNOTSUPP;
659 /* Copy rows/columns of default Usable Area */
660 rp->rows = uap->uab.h;
661 rp->cols = uap->uab.w;
662 /* Check for 14 bit addressing */
663 if ((uap->uab.flags0 & 0x0d) == 0x01)
664 set_bit(RAW3270_FLAGS_14BITADDR, &rp->flags);
665 /* Check for Alternate Usable Area */
666 if (uap->uab.l == sizeof(struct raw3270_ua) &&
667 uap->aua.sdpid == 0x02) {
668 rp->rows = uap->aua.hauai;
669 rp->cols = uap->aua.wauai;
670 }
671 return 0;
672}
673
674static int
675raw3270_size_device(struct raw3270 *rp)
676{
677 int rc;
678
Christoph Hellwigd330f932007-05-31 17:38:04 +0200679 mutex_lock(&raw3270_init_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 rp->view = &raw3270_init_view;
681 raw3270_init_view.dev = rp;
Martin Schwidefsky3863e722005-09-03 15:58:06 -0700682 if (MACHINE_IS_VM)
683 rc = __raw3270_size_device_vm(rp);
684 else
685 rc = __raw3270_size_device(rp);
Heiko Carstensd2c993d2006-07-12 16:41:55 +0200686 raw3270_init_view.dev = NULL;
687 rp->view = NULL;
Christoph Hellwigd330f932007-05-31 17:38:04 +0200688 mutex_unlock(&raw3270_init_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 if (rc == 0) { /* Found something. */
690 /* Try to find a model. */
691 rp->model = 0;
692 if (rp->rows == 24 && rp->cols == 80)
693 rp->model = 2;
694 if (rp->rows == 32 && rp->cols == 80)
695 rp->model = 3;
696 if (rp->rows == 43 && rp->cols == 80)
697 rp->model = 4;
698 if (rp->rows == 27 && rp->cols == 132)
699 rp->model = 5;
Martin Schwidefsky3863e722005-09-03 15:58:06 -0700700 } else {
701 /* Couldn't detect size. Use default model 2. */
702 rp->model = 2;
703 rp->rows = 24;
704 rp->cols = 80;
705 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 }
707 return rc;
708}
709
710static int
711raw3270_reset_device(struct raw3270 *rp)
712{
713 int rc;
714
Christoph Hellwigd330f932007-05-31 17:38:04 +0200715 mutex_lock(&raw3270_init_mutex);
Martin Schwidefsky132fab12006-06-29 14:57:39 +0200716 memset(&rp->init_request, 0, sizeof(rp->init_request));
717 memset(&rp->init_data, 0, sizeof(rp->init_data));
718 /* Store reset data stream to init_data/init_request */
719 rp->init_data[0] = TW_KR;
720 INIT_LIST_HEAD(&rp->init_request.list);
721 rp->init_request.ccw.cmd_code = TC_EWRITEA;
722 rp->init_request.ccw.flags = CCW_FLAG_SLI;
723 rp->init_request.ccw.count = 1;
724 rp->init_request.ccw.cda = (__u32) __pa(rp->init_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 rp->view = &raw3270_init_view;
726 raw3270_init_view.dev = rp;
Martin Schwidefsky132fab12006-06-29 14:57:39 +0200727 rc = raw3270_start_init(rp, &raw3270_init_view, &rp->init_request);
Heiko Carstensd2c993d2006-07-12 16:41:55 +0200728 raw3270_init_view.dev = NULL;
729 rp->view = NULL;
Christoph Hellwigd330f932007-05-31 17:38:04 +0200730 mutex_unlock(&raw3270_init_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 return rc;
732}
733
Richard Hitted3cb6f2005-10-30 15:00:10 -0800734int
735raw3270_reset(struct raw3270_view *view)
736{
737 struct raw3270 *rp;
738 int rc;
739
740 rp = view->dev;
Martin Schwidefsky4b214a02009-06-16 10:30:47 +0200741 if (!rp || rp->view != view ||
742 test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
Richard Hitted3cb6f2005-10-30 15:00:10 -0800743 rc = -EACCES;
744 else if (!test_bit(RAW3270_FLAGS_READY, &rp->flags))
745 rc = -ENODEV;
746 else
747 rc = raw3270_reset_device(view->dev);
748 return rc;
749}
750
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751/*
752 * Setup new 3270 device.
753 */
754static int
755raw3270_setup_device(struct ccw_device *cdev, struct raw3270 *rp, char *ascebc)
756{
757 struct list_head *l;
758 struct raw3270 *tmp;
759 int minor;
760
761 memset(rp, 0, sizeof(struct raw3270));
762 /* Copy ebcdic -> ascii translation table. */
763 memcpy(ascebc, _ascebc, 256);
764 if (tubxcorrect) {
765 /* correct brackets and circumflex */
766 ascebc['['] = 0xad;
767 ascebc[']'] = 0xbd;
768 ascebc['^'] = 0xb0;
769 }
770 rp->ascebc = ascebc;
771
772 /* Set defaults. */
773 rp->rows = 24;
774 rp->cols = 80;
775
776 INIT_LIST_HEAD(&rp->req_queue);
777 INIT_LIST_HEAD(&rp->view_list);
778
779 /*
780 * Add device to list and find the smallest unused minor
Richard Hitted3cb6f2005-10-30 15:00:10 -0800781 * number for it. Note: there is no device with minor 0,
782 * see special case for fs3270.c:fs3270_open().
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 */
Ingo Molnar14cc3e22006-03-26 01:37:14 -0800784 mutex_lock(&raw3270_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785 /* Keep the list sorted. */
Richard Hitted3cb6f2005-10-30 15:00:10 -0800786 minor = RAW3270_FIRSTMINOR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787 rp->minor = -1;
788 list_for_each(l, &raw3270_devices) {
789 tmp = list_entry(l, struct raw3270, list);
790 if (tmp->minor > minor) {
791 rp->minor = minor;
792 __list_add(&rp->list, l->prev, l);
793 break;
794 }
795 minor++;
796 }
Richard Hitted3cb6f2005-10-30 15:00:10 -0800797 if (rp->minor == -1 && minor < RAW3270_MAXDEVS + RAW3270_FIRSTMINOR) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 rp->minor = minor;
799 list_add_tail(&rp->list, &raw3270_devices);
800 }
Ingo Molnar14cc3e22006-03-26 01:37:14 -0800801 mutex_unlock(&raw3270_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802 /* No free minor number? Then give up. */
803 if (rp->minor == -1)
804 return -EUSERS;
805 rp->cdev = cdev;
Greg Kroah-Hartmandff59b62009-05-04 12:40:54 -0700806 dev_set_drvdata(&cdev->dev, rp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 cdev->handler = raw3270_irq;
808 return 0;
809}
810
811#ifdef CONFIG_TN3270_CONSOLE
812/*
813 * Setup 3270 device configured as console.
814 */
Heiko Carstense62133b2007-07-27 12:29:13 +0200815struct raw3270 __init *raw3270_setup_console(struct ccw_device *cdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816{
817 struct raw3270 *rp;
818 char *ascebc;
819 int rc;
820
Heiko Carstens33403dc2009-06-22 12:08:05 +0200821 rp = kzalloc(sizeof(struct raw3270), GFP_KERNEL | GFP_DMA);
822 ascebc = kzalloc(256, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 rc = raw3270_setup_device(cdev, rp, ascebc);
824 if (rc)
825 return ERR_PTR(rc);
826 set_bit(RAW3270_FLAGS_CONSOLE, &rp->flags);
827 rc = raw3270_reset_device(rp);
828 if (rc)
829 return ERR_PTR(rc);
830 rc = raw3270_size_device(rp);
831 if (rc)
832 return ERR_PTR(rc);
833 rc = raw3270_reset_device(rp);
834 if (rc)
835 return ERR_PTR(rc);
836 set_bit(RAW3270_FLAGS_READY, &rp->flags);
837 return rp;
838}
839
840void
841raw3270_wait_cons_dev(struct raw3270 *rp)
842{
843 unsigned long flags;
844
845 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
846 wait_cons_dev();
847 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
848}
849
850#endif
851
852/*
853 * Create a 3270 device structure.
854 */
855static struct raw3270 *
856raw3270_create_device(struct ccw_device *cdev)
857{
858 struct raw3270 *rp;
859 char *ascebc;
860 int rc;
861
Martin Schwidefsky132fab12006-06-29 14:57:39 +0200862 rp = kmalloc(sizeof(struct raw3270), GFP_KERNEL | GFP_DMA);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 if (!rp)
864 return ERR_PTR(-ENOMEM);
865 ascebc = kmalloc(256, GFP_KERNEL);
866 if (!ascebc) {
867 kfree(rp);
868 return ERR_PTR(-ENOMEM);
869 }
870 rc = raw3270_setup_device(cdev, rp, ascebc);
871 if (rc) {
872 kfree(rp->ascebc);
873 kfree(rp);
874 rp = ERR_PTR(rc);
875 }
876 /* Get reference to ccw_device structure. */
877 get_device(&cdev->dev);
878 return rp;
879}
880
881/*
882 * Activate a view.
883 */
884int
885raw3270_activate_view(struct raw3270_view *view)
886{
887 struct raw3270 *rp;
888 struct raw3270_view *oldview, *nv;
889 unsigned long flags;
890 int rc;
891
892 rp = view->dev;
893 if (!rp)
894 return -ENODEV;
895 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
896 if (rp->view == view)
897 rc = 0;
898 else if (!test_bit(RAW3270_FLAGS_READY, &rp->flags))
899 rc = -ENODEV;
Martin Schwidefsky4b214a02009-06-16 10:30:47 +0200900 else if (test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
901 rc = -EACCES;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902 else {
Heiko Carstensd2c993d2006-07-12 16:41:55 +0200903 oldview = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904 if (rp->view) {
905 oldview = rp->view;
906 oldview->fn->deactivate(oldview);
907 }
908 rp->view = view;
909 rc = view->fn->activate(view);
910 if (rc) {
911 /* Didn't work. Try to reactivate the old view. */
912 rp->view = oldview;
913 if (!oldview || oldview->fn->activate(oldview) != 0) {
914 /* Didn't work as well. Try any other view. */
915 list_for_each_entry(nv, &rp->view_list, list)
916 if (nv != view && nv != oldview) {
917 rp->view = nv;
918 if (nv->fn->activate(nv) == 0)
919 break;
Heiko Carstensd2c993d2006-07-12 16:41:55 +0200920 rp->view = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 }
922 }
923 }
924 }
925 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
926 return rc;
927}
928
929/*
930 * Deactivate current view.
931 */
932void
933raw3270_deactivate_view(struct raw3270_view *view)
934{
935 unsigned long flags;
936 struct raw3270 *rp;
937
938 rp = view->dev;
939 if (!rp)
940 return;
941 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
942 if (rp->view == view) {
943 view->fn->deactivate(view);
Heiko Carstensd2c993d2006-07-12 16:41:55 +0200944 rp->view = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 /* Move deactivated view to end of list. */
946 list_del_init(&view->list);
947 list_add_tail(&view->list, &rp->view_list);
948 /* Try to activate another view. */
Martin Schwidefsky4b214a02009-06-16 10:30:47 +0200949 if (test_bit(RAW3270_FLAGS_READY, &rp->flags) &&
950 !test_bit(RAW3270_FLAGS_FROZEN, &rp->flags)) {
Richard Hitted3cb6f2005-10-30 15:00:10 -0800951 list_for_each_entry(view, &rp->view_list, list) {
952 rp->view = view;
953 if (view->fn->activate(view) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954 break;
Heiko Carstensd2c993d2006-07-12 16:41:55 +0200955 rp->view = NULL;
Richard Hitted3cb6f2005-10-30 15:00:10 -0800956 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957 }
958 }
959 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
960}
961
962/*
963 * Add view to device with minor "minor".
964 */
965int
966raw3270_add_view(struct raw3270_view *view, struct raw3270_fn *fn, int minor)
967{
968 unsigned long flags;
969 struct raw3270 *rp;
970 int rc;
971
Richard Hitted3cb6f2005-10-30 15:00:10 -0800972 if (minor <= 0)
973 return -ENODEV;
Ingo Molnar14cc3e22006-03-26 01:37:14 -0800974 mutex_lock(&raw3270_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975 rc = -ENODEV;
976 list_for_each_entry(rp, &raw3270_devices, list) {
977 if (rp->minor != minor)
978 continue;
979 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
980 if (test_bit(RAW3270_FLAGS_READY, &rp->flags)) {
981 atomic_set(&view->ref_count, 2);
982 view->dev = rp;
983 view->fn = fn;
984 view->model = rp->model;
985 view->rows = rp->rows;
986 view->cols = rp->cols;
987 view->ascebc = rp->ascebc;
988 spin_lock_init(&view->lock);
Richard Hitted3cb6f2005-10-30 15:00:10 -0800989 list_add(&view->list, &rp->view_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990 rc = 0;
991 }
992 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
993 break;
994 }
Ingo Molnar14cc3e22006-03-26 01:37:14 -0800995 mutex_unlock(&raw3270_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996 return rc;
997}
998
999/*
1000 * Find specific view of device with minor "minor".
1001 */
1002struct raw3270_view *
1003raw3270_find_view(struct raw3270_fn *fn, int minor)
1004{
1005 struct raw3270 *rp;
1006 struct raw3270_view *view, *tmp;
1007 unsigned long flags;
1008
Ingo Molnar14cc3e22006-03-26 01:37:14 -08001009 mutex_lock(&raw3270_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 view = ERR_PTR(-ENODEV);
1011 list_for_each_entry(rp, &raw3270_devices, list) {
1012 if (rp->minor != minor)
1013 continue;
1014 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
1015 if (test_bit(RAW3270_FLAGS_READY, &rp->flags)) {
1016 view = ERR_PTR(-ENOENT);
1017 list_for_each_entry(tmp, &rp->view_list, list) {
1018 if (tmp->fn == fn) {
1019 raw3270_get_view(tmp);
1020 view = tmp;
1021 break;
1022 }
1023 }
1024 }
1025 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
1026 break;
1027 }
Ingo Molnar14cc3e22006-03-26 01:37:14 -08001028 mutex_unlock(&raw3270_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 return view;
1030}
1031
1032/*
1033 * Remove view from device and free view structure via call to view->fn->free.
1034 */
1035void
1036raw3270_del_view(struct raw3270_view *view)
1037{
1038 unsigned long flags;
1039 struct raw3270 *rp;
1040 struct raw3270_view *nv;
1041
1042 rp = view->dev;
1043 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
1044 if (rp->view == view) {
1045 view->fn->deactivate(view);
Heiko Carstensd2c993d2006-07-12 16:41:55 +02001046 rp->view = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047 }
1048 list_del_init(&view->list);
Martin Schwidefsky4b214a02009-06-16 10:30:47 +02001049 if (!rp->view && test_bit(RAW3270_FLAGS_READY, &rp->flags) &&
1050 !test_bit(RAW3270_FLAGS_FROZEN, &rp->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051 /* Try to activate another view. */
1052 list_for_each_entry(nv, &rp->view_list, list) {
Richard Hitted3cb6f2005-10-30 15:00:10 -08001053 if (nv->fn->activate(nv) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054 rp->view = nv;
1055 break;
1056 }
1057 }
1058 }
1059 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
1060 /* Wait for reference counter to drop to zero. */
1061 atomic_dec(&view->ref_count);
1062 wait_event(raw3270_wait_queue, atomic_read(&view->ref_count) == 0);
1063 if (view->fn->free)
1064 view->fn->free(view);
1065}
1066
1067/*
1068 * Remove a 3270 device structure.
1069 */
1070static void
1071raw3270_delete_device(struct raw3270 *rp)
1072{
1073 struct ccw_device *cdev;
1074
1075 /* Remove from device chain. */
Ingo Molnar14cc3e22006-03-26 01:37:14 -08001076 mutex_lock(&raw3270_mutex);
Heiko Carstensd7cf0d52006-07-18 13:46:58 +02001077 if (rp->clttydev && !IS_ERR(rp->clttydev))
Cornelia Huck7f021ce2007-10-22 12:52:42 +02001078 device_destroy(class3270, MKDEV(IBM_TTY3270_MAJOR, rp->minor));
Heiko Carstensd7cf0d52006-07-18 13:46:58 +02001079 if (rp->cltubdev && !IS_ERR(rp->cltubdev))
Cornelia Huck7f021ce2007-10-22 12:52:42 +02001080 device_destroy(class3270, MKDEV(IBM_FS3270_MAJOR, rp->minor));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081 list_del_init(&rp->list);
Ingo Molnar14cc3e22006-03-26 01:37:14 -08001082 mutex_unlock(&raw3270_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083
1084 /* Disconnect from ccw_device. */
1085 cdev = rp->cdev;
Heiko Carstensd2c993d2006-07-12 16:41:55 +02001086 rp->cdev = NULL;
Greg Kroah-Hartmandff59b62009-05-04 12:40:54 -07001087 dev_set_drvdata(&cdev->dev, NULL);
Heiko Carstensd2c993d2006-07-12 16:41:55 +02001088 cdev->handler = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089
1090 /* Put ccw_device structure. */
1091 put_device(&cdev->dev);
1092
1093 /* Now free raw3270 structure. */
1094 kfree(rp->ascebc);
1095 kfree(rp);
1096}
1097
1098static int
1099raw3270_probe (struct ccw_device *cdev)
1100{
1101 return 0;
1102}
1103
1104/*
1105 * Additional attributes for a 3270 device
1106 */
1107static ssize_t
Yani Ioannou3fd3c0a2005-05-17 06:43:27 -04001108raw3270_model_show(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109{
1110 return snprintf(buf, PAGE_SIZE, "%i\n",
Greg Kroah-Hartmandff59b62009-05-04 12:40:54 -07001111 ((struct raw3270 *) dev_get_drvdata(dev))->model);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112}
Heiko Carstensd2c993d2006-07-12 16:41:55 +02001113static DEVICE_ATTR(model, 0444, raw3270_model_show, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114
1115static ssize_t
Yani Ioannou3fd3c0a2005-05-17 06:43:27 -04001116raw3270_rows_show(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117{
1118 return snprintf(buf, PAGE_SIZE, "%i\n",
Greg Kroah-Hartmandff59b62009-05-04 12:40:54 -07001119 ((struct raw3270 *) dev_get_drvdata(dev))->rows);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120}
Heiko Carstensd2c993d2006-07-12 16:41:55 +02001121static DEVICE_ATTR(rows, 0444, raw3270_rows_show, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122
1123static ssize_t
Yani Ioannou3fd3c0a2005-05-17 06:43:27 -04001124raw3270_columns_show(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125{
1126 return snprintf(buf, PAGE_SIZE, "%i\n",
Greg Kroah-Hartmandff59b62009-05-04 12:40:54 -07001127 ((struct raw3270 *) dev_get_drvdata(dev))->cols);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128}
Heiko Carstensd2c993d2006-07-12 16:41:55 +02001129static DEVICE_ATTR(columns, 0444, raw3270_columns_show, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130
1131static struct attribute * raw3270_attrs[] = {
1132 &dev_attr_model.attr,
1133 &dev_attr_rows.attr,
1134 &dev_attr_columns.attr,
1135 NULL,
1136};
1137
1138static struct attribute_group raw3270_attr_group = {
1139 .attrs = raw3270_attrs,
1140};
1141
Heiko Carstensd7cf0d52006-07-18 13:46:58 +02001142static int raw3270_create_attributes(struct raw3270 *rp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143{
Heiko Carstensd7cf0d52006-07-18 13:46:58 +02001144 int rc;
1145
1146 rc = sysfs_create_group(&rp->cdev->dev.kobj, &raw3270_attr_group);
1147 if (rc)
1148 goto out;
1149
Greg Kroah-Hartmanea9e42f2008-07-21 20:03:34 -07001150 rp->clttydev = device_create(class3270, &rp->cdev->dev,
1151 MKDEV(IBM_TTY3270_MAJOR, rp->minor), NULL,
1152 "tty%s", dev_name(&rp->cdev->dev));
Heiko Carstensd7cf0d52006-07-18 13:46:58 +02001153 if (IS_ERR(rp->clttydev)) {
1154 rc = PTR_ERR(rp->clttydev);
1155 goto out_ttydev;
1156 }
1157
Greg Kroah-Hartmanea9e42f2008-07-21 20:03:34 -07001158 rp->cltubdev = device_create(class3270, &rp->cdev->dev,
1159 MKDEV(IBM_FS3270_MAJOR, rp->minor), NULL,
1160 "tub%s", dev_name(&rp->cdev->dev));
Heiko Carstensd7cf0d52006-07-18 13:46:58 +02001161 if (!IS_ERR(rp->cltubdev))
1162 goto out;
1163
1164 rc = PTR_ERR(rp->cltubdev);
Cornelia Huck7f021ce2007-10-22 12:52:42 +02001165 device_destroy(class3270, MKDEV(IBM_TTY3270_MAJOR, rp->minor));
Heiko Carstensd7cf0d52006-07-18 13:46:58 +02001166
1167out_ttydev:
1168 sysfs_remove_group(&rp->cdev->dev.kobj, &raw3270_attr_group);
1169out:
1170 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171}
1172
1173/*
1174 * Notifier for device addition/removal
1175 */
1176struct raw3270_notifier {
1177 struct list_head list;
1178 void (*notifier)(int, int);
1179};
1180
Denis Chengc11ca972008-01-26 14:11:13 +01001181static LIST_HEAD(raw3270_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182
1183int raw3270_register_notifier(void (*notifier)(int, int))
1184{
1185 struct raw3270_notifier *np;
1186 struct raw3270 *rp;
1187
1188 np = kmalloc(sizeof(struct raw3270_notifier), GFP_KERNEL);
1189 if (!np)
1190 return -ENOMEM;
1191 np->notifier = notifier;
Ingo Molnar14cc3e22006-03-26 01:37:14 -08001192 mutex_lock(&raw3270_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 list_add_tail(&np->list, &raw3270_notifier);
1194 list_for_each_entry(rp, &raw3270_devices, list) {
1195 get_device(&rp->cdev->dev);
1196 notifier(rp->minor, 1);
1197 }
Ingo Molnar14cc3e22006-03-26 01:37:14 -08001198 mutex_unlock(&raw3270_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199 return 0;
1200}
1201
1202void raw3270_unregister_notifier(void (*notifier)(int, int))
1203{
1204 struct raw3270_notifier *np;
1205
Ingo Molnar14cc3e22006-03-26 01:37:14 -08001206 mutex_lock(&raw3270_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207 list_for_each_entry(np, &raw3270_notifier, list)
1208 if (np->notifier == notifier) {
1209 list_del(&np->list);
1210 kfree(np);
1211 break;
1212 }
Ingo Molnar14cc3e22006-03-26 01:37:14 -08001213 mutex_unlock(&raw3270_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214}
1215
1216/*
1217 * Set 3270 device online.
1218 */
1219static int
1220raw3270_set_online (struct ccw_device *cdev)
1221{
1222 struct raw3270 *rp;
1223 struct raw3270_notifier *np;
1224 int rc;
1225
1226 rp = raw3270_create_device(cdev);
1227 if (IS_ERR(rp))
1228 return PTR_ERR(rp);
1229 rc = raw3270_reset_device(rp);
1230 if (rc)
Richard Hitted3cb6f2005-10-30 15:00:10 -08001231 goto failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232 rc = raw3270_size_device(rp);
1233 if (rc)
Richard Hitted3cb6f2005-10-30 15:00:10 -08001234 goto failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235 rc = raw3270_reset_device(rp);
1236 if (rc)
Richard Hitted3cb6f2005-10-30 15:00:10 -08001237 goto failure;
Heiko Carstensd7cf0d52006-07-18 13:46:58 +02001238 rc = raw3270_create_attributes(rp);
1239 if (rc)
1240 goto failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241 set_bit(RAW3270_FLAGS_READY, &rp->flags);
Ingo Molnar14cc3e22006-03-26 01:37:14 -08001242 mutex_lock(&raw3270_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243 list_for_each_entry(np, &raw3270_notifier, list)
1244 np->notifier(rp->minor, 1);
Ingo Molnar14cc3e22006-03-26 01:37:14 -08001245 mutex_unlock(&raw3270_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001246 return 0;
Richard Hitted3cb6f2005-10-30 15:00:10 -08001247
1248failure:
1249 raw3270_delete_device(rp);
1250 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251}
1252
1253/*
1254 * Remove 3270 device structure.
1255 */
1256static void
1257raw3270_remove (struct ccw_device *cdev)
1258{
1259 unsigned long flags;
1260 struct raw3270 *rp;
1261 struct raw3270_view *v;
1262 struct raw3270_notifier *np;
1263
Greg Kroah-Hartmandff59b62009-05-04 12:40:54 -07001264 rp = dev_get_drvdata(&cdev->dev);
Richard Hitted3cb6f2005-10-30 15:00:10 -08001265 /*
1266 * _remove is the opposite of _probe; it's probe that
1267 * should set up rp. raw3270_remove gets entered for
1268 * devices even if they haven't been varied online.
1269 * Thus, rp may validly be NULL here.
1270 */
1271 if (rp == NULL)
1272 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273 clear_bit(RAW3270_FLAGS_READY, &rp->flags);
1274
1275 sysfs_remove_group(&cdev->dev.kobj, &raw3270_attr_group);
1276
1277 /* Deactivate current view and remove all views. */
1278 spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
1279 if (rp->view) {
1280 rp->view->fn->deactivate(rp->view);
Heiko Carstensd2c993d2006-07-12 16:41:55 +02001281 rp->view = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282 }
1283 while (!list_empty(&rp->view_list)) {
1284 v = list_entry(rp->view_list.next, struct raw3270_view, list);
1285 if (v->fn->release)
1286 v->fn->release(v);
1287 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
1288 raw3270_del_view(v);
1289 spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
1290 }
1291 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
1292
Ingo Molnar14cc3e22006-03-26 01:37:14 -08001293 mutex_lock(&raw3270_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294 list_for_each_entry(np, &raw3270_notifier, list)
1295 np->notifier(rp->minor, 0);
Ingo Molnar14cc3e22006-03-26 01:37:14 -08001296 mutex_unlock(&raw3270_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297
1298 /* Reset 3270 device. */
1299 raw3270_reset_device(rp);
1300 /* And finally remove it. */
1301 raw3270_delete_device(rp);
1302}
1303
1304/*
1305 * Set 3270 device offline.
1306 */
1307static int
1308raw3270_set_offline (struct ccw_device *cdev)
1309{
1310 struct raw3270 *rp;
1311
Greg Kroah-Hartmandff59b62009-05-04 12:40:54 -07001312 rp = dev_get_drvdata(&cdev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313 if (test_bit(RAW3270_FLAGS_CONSOLE, &rp->flags))
1314 return -EBUSY;
1315 raw3270_remove(cdev);
1316 return 0;
1317}
1318
Martin Schwidefsky4b214a02009-06-16 10:30:47 +02001319static int raw3270_pm_stop(struct ccw_device *cdev)
1320{
1321 struct raw3270 *rp;
1322 struct raw3270_view *view;
1323 unsigned long flags;
1324
Martin Schwidefsky4f0076f2009-06-22 12:08:19 +02001325 rp = dev_get_drvdata(&cdev->dev);
Martin Schwidefsky4b214a02009-06-16 10:30:47 +02001326 if (!rp)
1327 return 0;
1328 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
1329 if (rp->view)
1330 rp->view->fn->deactivate(rp->view);
1331 if (!test_bit(RAW3270_FLAGS_CONSOLE, &rp->flags)) {
1332 /*
1333 * Release tty and fullscreen for all non-console
1334 * devices.
1335 */
1336 list_for_each_entry(view, &rp->view_list, list) {
1337 if (view->fn->release)
1338 view->fn->release(view);
1339 }
1340 }
1341 set_bit(RAW3270_FLAGS_FROZEN, &rp->flags);
1342 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
1343 return 0;
1344}
1345
1346static int raw3270_pm_start(struct ccw_device *cdev)
1347{
1348 struct raw3270 *rp;
1349 unsigned long flags;
1350
Martin Schwidefsky4f0076f2009-06-22 12:08:19 +02001351 rp = dev_get_drvdata(&cdev->dev);
Martin Schwidefsky4b214a02009-06-16 10:30:47 +02001352 if (!rp)
1353 return 0;
1354 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
1355 clear_bit(RAW3270_FLAGS_FROZEN, &rp->flags);
1356 if (rp->view)
1357 rp->view->fn->activate(rp->view);
1358 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
1359 return 0;
1360}
1361
1362void raw3270_pm_unfreeze(struct raw3270_view *view)
1363{
Sebastian Ott34483ca2009-10-06 10:33:56 +02001364#ifdef CONFIG_TN3270_CONSOLE
Martin Schwidefsky4b214a02009-06-16 10:30:47 +02001365 struct raw3270 *rp;
1366
1367 rp = view->dev;
1368 if (rp && test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
1369 ccw_device_force_console();
Sebastian Ott34483ca2009-10-06 10:33:56 +02001370#endif
Martin Schwidefsky4b214a02009-06-16 10:30:47 +02001371}
1372
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373static struct ccw_device_id raw3270_id[] = {
1374 { CCW_DEVICE(0x3270, 0) },
1375 { CCW_DEVICE(0x3271, 0) },
1376 { CCW_DEVICE(0x3272, 0) },
1377 { CCW_DEVICE(0x3273, 0) },
1378 { CCW_DEVICE(0x3274, 0) },
1379 { CCW_DEVICE(0x3275, 0) },
1380 { CCW_DEVICE(0x3276, 0) },
1381 { CCW_DEVICE(0x3277, 0) },
1382 { CCW_DEVICE(0x3278, 0) },
1383 { CCW_DEVICE(0x3279, 0) },
1384 { CCW_DEVICE(0x3174, 0) },
1385 { /* end of list */ },
1386};
1387
1388static struct ccw_driver raw3270_ccw_driver = {
1389 .name = "3270",
1390 .owner = THIS_MODULE,
1391 .ids = raw3270_id,
1392 .probe = &raw3270_probe,
1393 .remove = &raw3270_remove,
1394 .set_online = &raw3270_set_online,
1395 .set_offline = &raw3270_set_offline,
Martin Schwidefsky4b214a02009-06-16 10:30:47 +02001396 .freeze = &raw3270_pm_stop,
1397 .thaw = &raw3270_pm_start,
1398 .restore = &raw3270_pm_start,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399};
1400
1401static int
1402raw3270_init(void)
1403{
1404 struct raw3270 *rp;
1405 int rc;
1406
1407 if (raw3270_registered)
1408 return 0;
1409 raw3270_registered = 1;
1410 rc = ccw_driver_register(&raw3270_ccw_driver);
1411 if (rc == 0) {
1412 /* Create attributes for early (= console) device. */
Ingo Molnar14cc3e22006-03-26 01:37:14 -08001413 mutex_lock(&raw3270_mutex);
Richard Hitted3cb6f2005-10-30 15:00:10 -08001414 class3270 = class_create(THIS_MODULE, "3270");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415 list_for_each_entry(rp, &raw3270_devices, list) {
1416 get_device(&rp->cdev->dev);
1417 raw3270_create_attributes(rp);
1418 }
Ingo Molnar14cc3e22006-03-26 01:37:14 -08001419 mutex_unlock(&raw3270_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420 }
1421 return rc;
1422}
1423
1424static void
1425raw3270_exit(void)
1426{
1427 ccw_driver_unregister(&raw3270_ccw_driver);
Richard Hitted3cb6f2005-10-30 15:00:10 -08001428 class_destroy(class3270);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429}
1430
1431MODULE_LICENSE("GPL");
1432
1433module_init(raw3270_init);
1434module_exit(raw3270_exit);
1435
1436EXPORT_SYMBOL(raw3270_request_alloc);
1437EXPORT_SYMBOL(raw3270_request_free);
1438EXPORT_SYMBOL(raw3270_request_reset);
1439EXPORT_SYMBOL(raw3270_request_set_cmd);
1440EXPORT_SYMBOL(raw3270_request_add_data);
1441EXPORT_SYMBOL(raw3270_request_set_data);
1442EXPORT_SYMBOL(raw3270_request_set_idal);
1443EXPORT_SYMBOL(raw3270_buffer_address);
1444EXPORT_SYMBOL(raw3270_add_view);
1445EXPORT_SYMBOL(raw3270_del_view);
1446EXPORT_SYMBOL(raw3270_find_view);
1447EXPORT_SYMBOL(raw3270_activate_view);
1448EXPORT_SYMBOL(raw3270_deactivate_view);
1449EXPORT_SYMBOL(raw3270_start);
Richard Hitted3cb6f2005-10-30 15:00:10 -08001450EXPORT_SYMBOL(raw3270_start_locked);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451EXPORT_SYMBOL(raw3270_start_irq);
Richard Hitted3cb6f2005-10-30 15:00:10 -08001452EXPORT_SYMBOL(raw3270_reset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453EXPORT_SYMBOL(raw3270_register_notifier);
1454EXPORT_SYMBOL(raw3270_unregister_notifier);
1455EXPORT_SYMBOL(raw3270_wait_queue);