Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * drivers/s390/char/fs3270.c | |
3 | * IBM/3270 Driver - fullscreen driver. | |
4 | * | |
5 | * Author(s): | |
6 | * Original 3270 Code for 2.4 written by Richard Hitt (UTS Global) | |
7 | * Rewritten for 2.5/2.6 by Martin Schwidefsky <schwidefsky@de.ibm.com> | |
8 | * -- Copyright (C) 2003 IBM Deutschland Entwicklung GmbH, IBM Corporation | |
9 | */ | |
10 | ||
11 | #include <linux/config.h> | |
12 | #include <linux/bootmem.h> | |
13 | #include <linux/console.h> | |
14 | #include <linux/init.h> | |
15 | #include <linux/interrupt.h> | |
16 | #include <linux/list.h> | |
17 | #include <linux/types.h> | |
18 | ||
19 | #include <asm/ccwdev.h> | |
20 | #include <asm/cio.h> | |
21 | #include <asm/cpcmd.h> | |
22 | #include <asm/ebcdic.h> | |
23 | #include <asm/idals.h> | |
24 | ||
25 | #include "raw3270.h" | |
26 | #include "ctrlchar.h" | |
27 | ||
28 | struct raw3270_fn fs3270_fn; | |
29 | ||
30 | struct fs3270 { | |
31 | struct raw3270_view view; | |
32 | pid_t fs_pid; /* Pid of controlling program. */ | |
33 | int read_command; /* ccw command to use for reads. */ | |
34 | int write_command; /* ccw command to use for writes. */ | |
35 | int attention; /* Got attention. */ | |
36 | struct raw3270_request *clear; /* single clear request. */ | |
37 | wait_queue_head_t attn_wait; /* Attention wait queue. */ | |
38 | }; | |
39 | ||
40 | static void | |
41 | fs3270_wake_up(struct raw3270_request *rq, void *data) | |
42 | { | |
43 | wake_up((wait_queue_head_t *) data); | |
44 | } | |
45 | ||
46 | static int | |
47 | fs3270_do_io(struct raw3270_view *view, struct raw3270_request *rq) | |
48 | { | |
49 | wait_queue_head_t wq; | |
50 | int rc; | |
51 | ||
52 | init_waitqueue_head(&wq); | |
53 | rq->callback = fs3270_wake_up; | |
54 | rq->callback_data = &wq; | |
55 | rc = raw3270_start(view, rq); | |
56 | if (rc) | |
57 | return rc; | |
58 | /* Started sucessfully. Now wait for completion. */ | |
59 | wait_event(wq, raw3270_request_final(rq)); | |
60 | return rq->rc; | |
61 | } | |
62 | ||
63 | static void | |
64 | fs3270_reset_callback(struct raw3270_request *rq, void *data) | |
65 | { | |
66 | raw3270_request_reset(rq); | |
67 | } | |
68 | ||
69 | /* | |
70 | * Switch to the fullscreen view. | |
71 | */ | |
72 | static int | |
73 | fs3270_activate(struct raw3270_view *view) | |
74 | { | |
75 | struct fs3270 *fp; | |
76 | ||
77 | fp = (struct fs3270 *) view; | |
78 | raw3270_request_set_cmd(fp->clear, TC_EWRITEA); | |
79 | fp->clear->callback = fs3270_reset_callback; | |
80 | return raw3270_start(view, fp->clear); | |
81 | } | |
82 | ||
83 | /* | |
84 | * Shutdown fullscreen view. | |
85 | */ | |
86 | static void | |
87 | fs3270_deactivate(struct raw3270_view *view) | |
88 | { | |
89 | // FIXME: is this a good idea? The user program using fullscreen 3270 | |
90 | // will die just because a console message appeared. On the other | |
91 | // hand the fullscreen device is unoperational now. | |
92 | struct fs3270 *fp; | |
93 | ||
94 | fp = (struct fs3270 *) view; | |
95 | if (fp->fs_pid != 0) | |
96 | kill_proc(fp->fs_pid, SIGHUP, 1); | |
97 | fp->fs_pid = 0; | |
98 | } | |
99 | ||
100 | static int | |
101 | fs3270_irq(struct fs3270 *fp, struct raw3270_request *rq, struct irb *irb) | |
102 | { | |
103 | /* Handle ATTN. Set indication and wake waiters for attention. */ | |
104 | if (irb->scsw.dstat & DEV_STAT_ATTENTION) { | |
105 | fp->attention = 1; | |
106 | wake_up(&fp->attn_wait); | |
107 | } | |
108 | ||
109 | if (rq) { | |
110 | if (irb->scsw.dstat & DEV_STAT_UNIT_CHECK) | |
111 | rq->rc = -EIO; | |
112 | else | |
113 | /* Normal end. Copy residual count. */ | |
114 | rq->rescnt = irb->scsw.count; | |
115 | } | |
116 | return RAW3270_IO_DONE; | |
117 | } | |
118 | ||
119 | /* | |
120 | * Process reads from fullscreen 3270. | |
121 | */ | |
122 | static ssize_t | |
123 | fs3270_read(struct file *filp, char *data, size_t count, loff_t *off) | |
124 | { | |
125 | struct fs3270 *fp; | |
126 | struct raw3270_request *rq; | |
127 | struct idal_buffer *ib; | |
128 | int rc; | |
129 | ||
130 | if (count == 0 || count > 65535) | |
131 | return -EINVAL; | |
132 | fp = filp->private_data; | |
133 | if (!fp) | |
134 | return -ENODEV; | |
135 | ib = idal_buffer_alloc(count, 0); | |
136 | if (!ib) | |
137 | return -ENOMEM; | |
138 | rq = raw3270_request_alloc(0); | |
139 | if (!IS_ERR(rq)) { | |
140 | if (fp->read_command == 0 && fp->write_command != 0) | |
141 | fp->read_command = 6; | |
142 | raw3270_request_set_cmd(rq, fp->read_command ? : 2); | |
143 | raw3270_request_set_idal(rq, ib); | |
144 | wait_event(fp->attn_wait, fp->attention); | |
145 | rc = fs3270_do_io(&fp->view, rq); | |
146 | if (rc == 0 && idal_buffer_to_user(ib, data, count)) | |
147 | rc = -EFAULT; | |
148 | raw3270_request_free(rq); | |
149 | } else | |
150 | rc = PTR_ERR(rq); | |
151 | idal_buffer_free(ib); | |
152 | return rc; | |
153 | } | |
154 | ||
155 | /* | |
156 | * Process writes to fullscreen 3270. | |
157 | */ | |
158 | static ssize_t | |
159 | fs3270_write(struct file *filp, const char *data, size_t count, loff_t *off) | |
160 | { | |
161 | struct fs3270 *fp; | |
162 | struct raw3270_request *rq; | |
163 | struct idal_buffer *ib; | |
164 | int write_command; | |
165 | int rc; | |
166 | ||
167 | fp = filp->private_data; | |
168 | if (!fp) | |
169 | return -ENODEV; | |
170 | ib = idal_buffer_alloc(count, 0); | |
171 | if (!ib) | |
172 | return -ENOMEM; | |
173 | rq = raw3270_request_alloc(0); | |
174 | if (!IS_ERR(rq)) { | |
175 | if (idal_buffer_from_user(ib, data, count) == 0) { | |
176 | write_command = fp->write_command ? : 1; | |
177 | if (write_command == 5) | |
178 | write_command = 13; | |
179 | raw3270_request_set_cmd(rq, write_command); | |
180 | raw3270_request_set_idal(rq, ib); | |
181 | rc = fs3270_do_io(&fp->view, rq); | |
182 | } else | |
183 | rc = -EFAULT; | |
184 | raw3270_request_free(rq); | |
185 | } else | |
186 | rc = PTR_ERR(rq); | |
187 | idal_buffer_free(ib); | |
188 | return rc; | |
189 | } | |
190 | ||
191 | /* | |
192 | * process ioctl commands for the tube driver | |
193 | */ | |
194 | static int | |
195 | fs3270_ioctl(struct inode *inode, struct file *filp, | |
196 | unsigned int cmd, unsigned long arg) | |
197 | { | |
198 | struct fs3270 *fp; | |
199 | struct raw3270_iocb iocb; | |
200 | int rc; | |
201 | ||
202 | fp = filp->private_data; | |
203 | if (!fp) | |
204 | return -ENODEV; | |
205 | rc = 0; | |
206 | switch (cmd) { | |
207 | case TUBICMD: | |
208 | fp->read_command = arg; | |
209 | break; | |
210 | case TUBOCMD: | |
211 | fp->write_command = arg; | |
212 | break; | |
213 | case TUBGETI: | |
214 | rc = put_user(fp->read_command, (char *) arg); | |
215 | break; | |
216 | case TUBGETO: | |
217 | rc = put_user(fp->write_command,(char *) arg); | |
218 | break; | |
219 | case TUBGETMOD: | |
220 | iocb.model = fp->view.model; | |
221 | iocb.line_cnt = fp->view.rows; | |
222 | iocb.col_cnt = fp->view.cols; | |
223 | iocb.pf_cnt = 24; | |
224 | iocb.re_cnt = 20; | |
225 | iocb.map = 0; | |
226 | if (copy_to_user((char *) arg, &iocb, | |
227 | sizeof(struct raw3270_iocb))) | |
228 | rc = -EFAULT; | |
229 | break; | |
230 | } | |
231 | return rc; | |
232 | } | |
233 | ||
234 | /* | |
235 | * Allocate tty3270 structure. | |
236 | */ | |
237 | static struct fs3270 * | |
238 | fs3270_alloc_view(void) | |
239 | { | |
240 | struct fs3270 *fp; | |
241 | ||
242 | fp = (struct fs3270 *) kmalloc(sizeof(struct fs3270),GFP_KERNEL); | |
243 | if (!fp) | |
244 | return ERR_PTR(-ENOMEM); | |
245 | memset(fp, 0, sizeof(struct fs3270)); | |
246 | fp->clear = raw3270_request_alloc(0); | |
247 | if (!IS_ERR(fp->clear)) { | |
248 | kfree(fp); | |
249 | return ERR_PTR(-ENOMEM); | |
250 | } | |
251 | return fp; | |
252 | } | |
253 | ||
254 | /* | |
255 | * Free tty3270 structure. | |
256 | */ | |
257 | static void | |
258 | fs3270_free_view(struct raw3270_view *view) | |
259 | { | |
260 | raw3270_request_free(((struct fs3270 *) view)->clear); | |
261 | kfree(view); | |
262 | } | |
263 | ||
264 | /* | |
265 | * Unlink fs3270 data structure from filp. | |
266 | */ | |
267 | static void | |
268 | fs3270_release(struct raw3270_view *view) | |
269 | { | |
270 | } | |
271 | ||
272 | /* View to a 3270 device. Can be console, tty or fullscreen. */ | |
273 | struct raw3270_fn fs3270_fn = { | |
274 | .activate = fs3270_activate, | |
275 | .deactivate = fs3270_deactivate, | |
276 | .intv = (void *) fs3270_irq, | |
277 | .release = fs3270_release, | |
278 | .free = fs3270_free_view | |
279 | }; | |
280 | ||
281 | /* | |
282 | * This routine is called whenever a 3270 fullscreen device is opened. | |
283 | */ | |
284 | static int | |
285 | fs3270_open(struct inode *inode, struct file *filp) | |
286 | { | |
287 | struct fs3270 *fp; | |
288 | int minor, rc; | |
289 | ||
290 | if (imajor(filp->f_dentry->d_inode) != IBM_FS3270_MAJOR) | |
291 | return -ENODEV; | |
292 | minor = iminor(filp->f_dentry->d_inode); | |
293 | /* Check if some other program is already using fullscreen mode. */ | |
294 | fp = (struct fs3270 *) raw3270_find_view(&fs3270_fn, minor); | |
295 | if (!IS_ERR(fp)) { | |
296 | raw3270_put_view(&fp->view); | |
297 | return -EBUSY; | |
298 | } | |
299 | /* Allocate fullscreen view structure. */ | |
300 | fp = fs3270_alloc_view(); | |
301 | if (IS_ERR(fp)) | |
302 | return PTR_ERR(fp); | |
303 | ||
304 | init_waitqueue_head(&fp->attn_wait); | |
305 | fp->fs_pid = current->pid; | |
306 | rc = raw3270_add_view(&fp->view, &fs3270_fn, minor); | |
307 | if (rc) { | |
308 | fs3270_free_view(&fp->view); | |
309 | return rc; | |
310 | } | |
311 | ||
312 | rc = raw3270_activate_view(&fp->view); | |
313 | if (rc) { | |
314 | raw3270_del_view(&fp->view); | |
315 | return rc; | |
316 | } | |
317 | filp->private_data = fp; | |
318 | return 0; | |
319 | } | |
320 | ||
321 | /* | |
322 | * This routine is called when the 3270 tty is closed. We wait | |
323 | * for the remaining request to be completed. Then we clean up. | |
324 | */ | |
325 | static int | |
326 | fs3270_close(struct inode *inode, struct file *filp) | |
327 | { | |
328 | struct fs3270 *fp; | |
329 | ||
330 | fp = filp->private_data; | |
331 | filp->private_data = 0; | |
332 | if (fp) | |
333 | raw3270_del_view(&fp->view); | |
334 | return 0; | |
335 | } | |
336 | ||
337 | static struct file_operations fs3270_fops = { | |
338 | .owner = THIS_MODULE, /* owner */ | |
339 | .read = fs3270_read, /* read */ | |
340 | .write = fs3270_write, /* write */ | |
341 | .ioctl = fs3270_ioctl, /* ioctl */ | |
342 | .open = fs3270_open, /* open */ | |
343 | .release = fs3270_close, /* release */ | |
344 | }; | |
345 | ||
346 | /* | |
347 | * 3270 fullscreen driver initialization. | |
348 | */ | |
349 | static int __init | |
350 | fs3270_init(void) | |
351 | { | |
352 | int rc; | |
353 | ||
354 | rc = register_chrdev(IBM_FS3270_MAJOR, "fs3270", &fs3270_fops); | |
355 | if (rc) { | |
356 | printk(KERN_ERR "fs3270 can't get major number %d: errno %d\n", | |
357 | IBM_FS3270_MAJOR, rc); | |
358 | return rc; | |
359 | } | |
360 | return 0; | |
361 | } | |
362 | ||
363 | static void __exit | |
364 | fs3270_exit(void) | |
365 | { | |
366 | unregister_chrdev(IBM_FS3270_MAJOR, "fs3270"); | |
367 | } | |
368 | ||
369 | MODULE_LICENSE("GPL"); | |
370 | MODULE_ALIAS_CHARDEV_MAJOR(IBM_FS3270_MAJOR); | |
371 | ||
372 | module_init(fs3270_init); | |
373 | module_exit(fs3270_exit); |