Merge branch 'linus' into x86/xen
[linux-2.6] / drivers / s390 / char / vmur.c
1 /*
2  * Linux driver for System z and s390 unit record devices
3  * (z/VM virtual punch, reader, printer)
4  *
5  * Copyright IBM Corp. 2001, 2007
6  * Authors: Malcolm Beattie <beattiem@uk.ibm.com>
7  *          Michael Holzheu <holzheu@de.ibm.com>
8  *          Frank Munzert <munzert@de.ibm.com>
9  */
10
11 #include <linux/cdev.h>
12
13 #include <asm/uaccess.h>
14 #include <asm/cio.h>
15 #include <asm/ccwdev.h>
16 #include <asm/debug.h>
17 #include <asm/diag.h>
18
19 #include "vmur.h"
20
21 /*
22  * Driver overview
23  *
24  * Unit record device support is implemented as a character device driver.
25  * We can fit at least 16 bits into a device minor number and use the
26  * simple method of mapping a character device number with minor abcd
27  * to the unit record device with devno abcd.
28  * I/O to virtual unit record devices is handled as follows:
29  * Reads: Diagnose code 0x14 (input spool file manipulation)
30  * is used to read spool data page-wise.
31  * Writes: The CCW used is WRITE_CCW_CMD (0x01). The device's record length
32  * is available by reading sysfs attr reclen. Each write() to the device
33  * must specify an integral multiple (maximal 511) of reclen.
34  */
35
36 static char ur_banner[] = "z/VM virtual unit record device driver";
37
38 MODULE_AUTHOR("IBM Corporation");
39 MODULE_DESCRIPTION("s390 z/VM virtual unit record device driver");
40 MODULE_LICENSE("GPL");
41
42 #define PRINTK_HEADER "vmur: "
43
44 static dev_t ur_first_dev_maj_min;
45 static struct class *vmur_class;
46 static struct debug_info *vmur_dbf;
47
48 /* We put the device's record length (for writes) in the driver_info field */
49 static struct ccw_device_id ur_ids[] = {
50         { CCWDEV_CU_DI(READER_PUNCH_DEVTYPE, 80) },
51         { CCWDEV_CU_DI(PRINTER_DEVTYPE, 132) },
52         { /* end of list */ }
53 };
54
55 MODULE_DEVICE_TABLE(ccw, ur_ids);
56
57 static int ur_probe(struct ccw_device *cdev);
58 static void ur_remove(struct ccw_device *cdev);
59 static int ur_set_online(struct ccw_device *cdev);
60 static int ur_set_offline(struct ccw_device *cdev);
61
62 static struct ccw_driver ur_driver = {
63         .name           = "vmur",
64         .owner          = THIS_MODULE,
65         .ids            = ur_ids,
66         .probe          = ur_probe,
67         .remove         = ur_remove,
68         .set_online     = ur_set_online,
69         .set_offline    = ur_set_offline,
70 };
71
72 static DEFINE_MUTEX(vmur_mutex);
73
74 /*
75  * Allocation, freeing, getting and putting of urdev structures
76  *
77  * Each ur device (urd) contains a reference to its corresponding ccw device
78  * (cdev) using the urd->cdev pointer. Each ccw device has a reference to the
79  * ur device using the cdev->dev.driver_data pointer.
80  *
81  * urd references:
82  * - ur_probe gets a urd reference, ur_remove drops the reference
83  *   (cdev->dev.driver_data)
84  * - ur_open gets a urd reference, ur_relase drops the reference
85  *   (urf->urd)
86  *
87  * cdev references:
88  * - urdev_alloc get a cdev reference (urd->cdev)
89  * - urdev_free drops the cdev reference (urd->cdev)
90  *
91  * Setting and clearing of cdev->dev.driver_data is protected by the ccwdev lock
92  */
93 static struct urdev *urdev_alloc(struct ccw_device *cdev)
94 {
95         struct urdev *urd;
96
97         urd = kzalloc(sizeof(struct urdev), GFP_KERNEL);
98         if (!urd)
99                 return NULL;
100         urd->reclen = cdev->id.driver_info;
101         ccw_device_get_id(cdev, &urd->dev_id);
102         mutex_init(&urd->io_mutex);
103         init_waitqueue_head(&urd->wait);
104         spin_lock_init(&urd->open_lock);
105         atomic_set(&urd->ref_count,  1);
106         urd->cdev = cdev;
107         get_device(&cdev->dev);
108         return urd;
109 }
110
111 static void urdev_free(struct urdev *urd)
112 {
113         TRACE("urdev_free: %p\n", urd);
114         if (urd->cdev)
115                 put_device(&urd->cdev->dev);
116         kfree(urd);
117 }
118
119 static void urdev_get(struct urdev *urd)
120 {
121         atomic_inc(&urd->ref_count);
122 }
123
124 static struct urdev *urdev_get_from_cdev(struct ccw_device *cdev)
125 {
126         struct urdev *urd;
127         unsigned long flags;
128
129         spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
130         urd = cdev->dev.driver_data;
131         if (urd)
132                 urdev_get(urd);
133         spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
134         return urd;
135 }
136
137 static struct urdev *urdev_get_from_devno(u16 devno)
138 {
139         char bus_id[16];
140         struct ccw_device *cdev;
141         struct urdev *urd;
142
143         sprintf(bus_id, "0.0.%04x", devno);
144         cdev = get_ccwdev_by_busid(&ur_driver, bus_id);
145         if (!cdev)
146                 return NULL;
147         urd = urdev_get_from_cdev(cdev);
148         put_device(&cdev->dev);
149         return urd;
150 }
151
152 static void urdev_put(struct urdev *urd)
153 {
154         if (atomic_dec_and_test(&urd->ref_count))
155                 urdev_free(urd);
156 }
157
158 /*
159  * Low-level functions to do I/O to a ur device.
160  *     alloc_chan_prog
161  *     free_chan_prog
162  *     do_ur_io
163  *     ur_int_handler
164  *
165  * alloc_chan_prog allocates and builds the channel program
166  * free_chan_prog frees memory of the channel program
167  *
168  * do_ur_io issues the channel program to the device and blocks waiting
169  * on a completion event it publishes at urd->io_done. The function
170  * serialises itself on the device's mutex so that only one I/O
171  * is issued at a time (and that I/O is synchronous).
172  *
173  * ur_int_handler catches the "I/O done" interrupt, writes the
174  * subchannel status word into the scsw member of the urdev structure
175  * and complete()s the io_done to wake the waiting do_ur_io.
176  *
177  * The caller of do_ur_io is responsible for kfree()ing the channel program
178  * address pointer that alloc_chan_prog returned.
179  */
180
181 static void free_chan_prog(struct ccw1 *cpa)
182 {
183         struct ccw1 *ptr = cpa;
184
185         while (ptr->cda) {
186                 kfree((void *)(addr_t) ptr->cda);
187                 ptr++;
188         }
189         kfree(cpa);
190 }
191
192 /*
193  * alloc_chan_prog
194  * The channel program we use is write commands chained together
195  * with a final NOP CCW command-chained on (which ensures that CE and DE
196  * are presented together in a single interrupt instead of as separate
197  * interrupts unless an incorrect length indication kicks in first). The
198  * data length in each CCW is reclen.
199  */
200 static struct ccw1 *alloc_chan_prog(const char __user *ubuf, int rec_count,
201                                     int reclen)
202 {
203         struct ccw1 *cpa;
204         void *kbuf;
205         int i;
206
207         TRACE("alloc_chan_prog(%p, %i, %i)\n", ubuf, rec_count, reclen);
208
209         /*
210          * We chain a NOP onto the writes to force CE+DE together.
211          * That means we allocate room for CCWs to cover count/reclen
212          * records plus a NOP.
213          */
214         cpa = kzalloc((rec_count + 1) * sizeof(struct ccw1),
215                       GFP_KERNEL | GFP_DMA);
216         if (!cpa)
217                 return ERR_PTR(-ENOMEM);
218
219         for (i = 0; i < rec_count; i++) {
220                 cpa[i].cmd_code = WRITE_CCW_CMD;
221                 cpa[i].flags = CCW_FLAG_CC | CCW_FLAG_SLI;
222                 cpa[i].count = reclen;
223                 kbuf = kmalloc(reclen, GFP_KERNEL | GFP_DMA);
224                 if (!kbuf) {
225                         free_chan_prog(cpa);
226                         return ERR_PTR(-ENOMEM);
227                 }
228                 cpa[i].cda = (u32)(addr_t) kbuf;
229                 if (copy_from_user(kbuf, ubuf, reclen)) {
230                         free_chan_prog(cpa);
231                         return ERR_PTR(-EFAULT);
232                 }
233                 ubuf += reclen;
234         }
235         /* The following NOP CCW forces CE+DE to be presented together */
236         cpa[i].cmd_code = CCW_CMD_NOOP;
237         return cpa;
238 }
239
240 static int do_ur_io(struct urdev *urd, struct ccw1 *cpa)
241 {
242         int rc;
243         struct ccw_device *cdev = urd->cdev;
244         DECLARE_COMPLETION_ONSTACK(event);
245
246         TRACE("do_ur_io: cpa=%p\n", cpa);
247
248         rc = mutex_lock_interruptible(&urd->io_mutex);
249         if (rc)
250                 return rc;
251
252         urd->io_done = &event;
253
254         spin_lock_irq(get_ccwdev_lock(cdev));
255         rc = ccw_device_start(cdev, cpa, 1, 0, 0);
256         spin_unlock_irq(get_ccwdev_lock(cdev));
257
258         TRACE("do_ur_io: ccw_device_start returned %d\n", rc);
259         if (rc)
260                 goto out;
261
262         wait_for_completion(&event);
263         TRACE("do_ur_io: I/O complete\n");
264         rc = 0;
265
266 out:
267         mutex_unlock(&urd->io_mutex);
268         return rc;
269 }
270
271 /*
272  * ur interrupt handler, called from the ccw_device layer
273  */
274 static void ur_int_handler(struct ccw_device *cdev, unsigned long intparm,
275                            struct irb *irb)
276 {
277         struct urdev *urd;
278
279         TRACE("ur_int_handler: intparm=0x%lx cstat=%02x dstat=%02x res=%u\n",
280               intparm, irb->scsw.cstat, irb->scsw.dstat, irb->scsw.count);
281
282         if (!intparm) {
283                 TRACE("ur_int_handler: unsolicited interrupt\n");
284                 return;
285         }
286         urd = cdev->dev.driver_data;
287         BUG_ON(!urd);
288         /* On special conditions irb is an error pointer */
289         if (IS_ERR(irb))
290                 urd->io_request_rc = PTR_ERR(irb);
291         else if (irb->scsw.dstat == (DEV_STAT_CHN_END | DEV_STAT_DEV_END))
292                 urd->io_request_rc = 0;
293         else
294                 urd->io_request_rc = -EIO;
295
296         complete(urd->io_done);
297 }
298
299 /*
300  * reclen sysfs attribute - The record length to be used for write CCWs
301  */
302 static ssize_t ur_attr_reclen_show(struct device *dev,
303                                    struct device_attribute *attr, char *buf)
304 {
305         struct urdev *urd;
306         int rc;
307
308         urd = urdev_get_from_cdev(to_ccwdev(dev));
309         if (!urd)
310                 return -ENODEV;
311         rc = sprintf(buf, "%zu\n", urd->reclen);
312         urdev_put(urd);
313         return rc;
314 }
315
316 static DEVICE_ATTR(reclen, 0444, ur_attr_reclen_show, NULL);
317
318 static int ur_create_attributes(struct device *dev)
319 {
320         return device_create_file(dev, &dev_attr_reclen);
321 }
322
323 static void ur_remove_attributes(struct device *dev)
324 {
325         device_remove_file(dev, &dev_attr_reclen);
326 }
327
328 /*
329  * diagnose code 0x210 - retrieve device information
330  * cc=0  normal completion, we have a real device
331  * cc=1  CP paging error
332  * cc=2  The virtual device exists, but is not associated with a real device
333  * cc=3  Invalid device address, or the virtual device does not exist
334  */
335 static int get_urd_class(struct urdev *urd)
336 {
337         static struct diag210 ur_diag210;
338         int cc;
339
340         ur_diag210.vrdcdvno = urd->dev_id.devno;
341         ur_diag210.vrdclen = sizeof(struct diag210);
342
343         cc = diag210(&ur_diag210);
344         switch (cc) {
345         case 0:
346                 return -ENOTSUPP;
347         case 2:
348                 return ur_diag210.vrdcvcla; /* virtual device class */
349         case 3:
350                 return -ENODEV;
351         default:
352                 return -EIO;
353         }
354 }
355
356 /*
357  * Allocation and freeing of urfile structures
358  */
359 static struct urfile *urfile_alloc(struct urdev *urd)
360 {
361         struct urfile *urf;
362
363         urf = kzalloc(sizeof(struct urfile), GFP_KERNEL);
364         if (!urf)
365                 return NULL;
366         urf->urd = urd;
367
368         TRACE("urfile_alloc: urd=%p urf=%p rl=%zu\n", urd, urf,
369               urf->dev_reclen);
370
371         return urf;
372 }
373
374 static void urfile_free(struct urfile *urf)
375 {
376         TRACE("urfile_free: urf=%p urd=%p\n", urf, urf->urd);
377         kfree(urf);
378 }
379
380 /*
381  * The fops implementation of the character device driver
382  */
383 static ssize_t do_write(struct urdev *urd, const char __user *udata,
384                         size_t count, size_t reclen, loff_t *ppos)
385 {
386         struct ccw1 *cpa;
387         int rc;
388
389         cpa = alloc_chan_prog(udata, count / reclen, reclen);
390         if (IS_ERR(cpa))
391                 return PTR_ERR(cpa);
392
393         rc = do_ur_io(urd, cpa);
394         if (rc)
395                 goto fail_kfree_cpa;
396
397         if (urd->io_request_rc) {
398                 rc = urd->io_request_rc;
399                 goto fail_kfree_cpa;
400         }
401         *ppos += count;
402         rc = count;
403
404 fail_kfree_cpa:
405         free_chan_prog(cpa);
406         return rc;
407 }
408
409 static ssize_t ur_write(struct file *file, const char __user *udata,
410                         size_t count, loff_t *ppos)
411 {
412         struct urfile *urf = file->private_data;
413
414         TRACE("ur_write: count=%zu\n", count);
415
416         if (count == 0)
417                 return 0;
418
419         if (count % urf->dev_reclen)
420                 return -EINVAL; /* count must be a multiple of reclen */
421
422         if (count > urf->dev_reclen * MAX_RECS_PER_IO)
423                 count = urf->dev_reclen * MAX_RECS_PER_IO;
424
425         return do_write(urf->urd, udata, count, urf->dev_reclen, ppos);
426 }
427
428 /*
429  * diagnose code 0x14 subcode 0x0028 - position spool file to designated
430  *                                     record
431  * cc=0  normal completion
432  * cc=2  no file active on the virtual reader or device not ready
433  * cc=3  record specified is beyond EOF
434  */
435 static int diag_position_to_record(int devno, int record)
436 {
437         int cc;
438
439         cc = diag14(record, devno, 0x28);
440         switch (cc) {
441         case 0:
442                 return 0;
443         case 2:
444                 return -ENOMEDIUM;
445         case 3:
446                 return -ENODATA; /* position beyond end of file */
447         default:
448                 return -EIO;
449         }
450 }
451
452 /*
453  * diagnose code 0x14 subcode 0x0000 - read next spool file buffer
454  * cc=0  normal completion
455  * cc=1  EOF reached
456  * cc=2  no file active on the virtual reader, and no file eligible
457  * cc=3  file already active on the virtual reader or specified virtual
458  *       reader does not exist or is not a reader
459  */
460 static int diag_read_file(int devno, char *buf)
461 {
462         int cc;
463
464         cc = diag14((unsigned long) buf, devno, 0x00);
465         switch (cc) {
466         case 0:
467                 return 0;
468         case 1:
469                 return -ENODATA;
470         case 2:
471                 return -ENOMEDIUM;
472         default:
473                 return -EIO;
474         }
475 }
476
477 static ssize_t diag14_read(struct file *file, char __user *ubuf, size_t count,
478                            loff_t *offs)
479 {
480         size_t len, copied, res;
481         char *buf;
482         int rc;
483         u16 reclen;
484         struct urdev *urd;
485
486         urd = ((struct urfile *) file->private_data)->urd;
487         reclen = ((struct urfile *) file->private_data)->file_reclen;
488
489         rc = diag_position_to_record(urd->dev_id.devno, *offs / PAGE_SIZE + 1);
490         if (rc == -ENODATA)
491                 return 0;
492         if (rc)
493                 return rc;
494
495         len = min((size_t) PAGE_SIZE, count);
496         buf = (char *) __get_free_page(GFP_KERNEL | GFP_DMA);
497         if (!buf)
498                 return -ENOMEM;
499
500         copied = 0;
501         res = (size_t) (*offs % PAGE_SIZE);
502         do {
503                 rc = diag_read_file(urd->dev_id.devno, buf);
504                 if (rc == -ENODATA) {
505                         break;
506                 }
507                 if (rc)
508                         goto fail;
509                 if (reclen && (copied == 0) && (*offs < PAGE_SIZE))
510                         *((u16 *) &buf[FILE_RECLEN_OFFSET]) = reclen;
511                 len = min(count - copied, PAGE_SIZE - res);
512                 if (copy_to_user(ubuf + copied, buf + res, len)) {
513                         rc = -EFAULT;
514                         goto fail;
515                 }
516                 res = 0;
517                 copied += len;
518         } while (copied != count);
519
520         *offs += copied;
521         rc = copied;
522 fail:
523         free_page((unsigned long) buf);
524         return rc;
525 }
526
527 static ssize_t ur_read(struct file *file, char __user *ubuf, size_t count,
528                        loff_t *offs)
529 {
530         struct urdev *urd;
531         int rc;
532
533         TRACE("ur_read: count=%zu ppos=%li\n", count, (unsigned long) *offs);
534
535         if (count == 0)
536                 return 0;
537
538         urd = ((struct urfile *) file->private_data)->urd;
539         rc = mutex_lock_interruptible(&urd->io_mutex);
540         if (rc)
541                 return rc;
542         rc = diag14_read(file, ubuf, count, offs);
543         mutex_unlock(&urd->io_mutex);
544         return rc;
545 }
546
547 /*
548  * diagnose code 0x14 subcode 0x0fff - retrieve next file descriptor
549  * cc=0  normal completion
550  * cc=1  no files on reader queue or no subsequent file
551  * cc=2  spid specified is invalid
552  */
553 static int diag_read_next_file_info(struct file_control_block *buf, int spid)
554 {
555         int cc;
556
557         cc = diag14((unsigned long) buf, spid, 0xfff);
558         switch (cc) {
559         case 0:
560                 return 0;
561         default:
562                 return -ENODATA;
563         }
564 }
565
566 static int verify_uri_device(struct urdev *urd)
567 {
568         struct file_control_block *fcb;
569         char *buf;
570         int rc;
571
572         fcb = kmalloc(sizeof(*fcb), GFP_KERNEL | GFP_DMA);
573         if (!fcb)
574                 return -ENOMEM;
575
576         /* check for empty reader device (beginning of chain) */
577         rc = diag_read_next_file_info(fcb, 0);
578         if (rc)
579                 goto fail_free_fcb;
580
581         /* if file is in hold status, we do not read it */
582         if (fcb->file_stat & (FLG_SYSTEM_HOLD | FLG_USER_HOLD)) {
583                 rc = -EPERM;
584                 goto fail_free_fcb;
585         }
586
587         /* open file on virtual reader  */
588         buf = (char *) __get_free_page(GFP_KERNEL | GFP_DMA);
589         if (!buf) {
590                 rc = -ENOMEM;
591                 goto fail_free_fcb;
592         }
593         rc = diag_read_file(urd->dev_id.devno, buf);
594         if ((rc != 0) && (rc != -ENODATA)) /* EOF does not hurt */
595                 goto fail_free_buf;
596
597         /* check if the file on top of the queue is open now */
598         rc = diag_read_next_file_info(fcb, 0);
599         if (rc)
600                 goto fail_free_buf;
601         if (!(fcb->file_stat & FLG_IN_USE)) {
602                 rc = -EMFILE;
603                 goto fail_free_buf;
604         }
605         rc = 0;
606
607 fail_free_buf:
608         free_page((unsigned long) buf);
609 fail_free_fcb:
610         kfree(fcb);
611         return rc;
612 }
613
614 static int verify_device(struct urdev *urd)
615 {
616         switch (urd->class) {
617         case DEV_CLASS_UR_O:
618                 return 0; /* no check needed here */
619         case DEV_CLASS_UR_I:
620                 return verify_uri_device(urd);
621         default:
622                 return -ENOTSUPP;
623         }
624 }
625
626 static int get_uri_file_reclen(struct urdev *urd)
627 {
628         struct file_control_block *fcb;
629         int rc;
630
631         fcb = kmalloc(sizeof(*fcb), GFP_KERNEL | GFP_DMA);
632         if (!fcb)
633                 return -ENOMEM;
634         rc = diag_read_next_file_info(fcb, 0);
635         if (rc)
636                 goto fail_free;
637         if (fcb->file_stat & FLG_CP_DUMP)
638                 rc = 0;
639         else
640                 rc = fcb->rec_len;
641
642 fail_free:
643         kfree(fcb);
644         return rc;
645 }
646
647 static int get_file_reclen(struct urdev *urd)
648 {
649         switch (urd->class) {
650         case DEV_CLASS_UR_O:
651                 return 0;
652         case DEV_CLASS_UR_I:
653                 return get_uri_file_reclen(urd);
654         default:
655                 return -ENOTSUPP;
656         }
657 }
658
659 static int ur_open(struct inode *inode, struct file *file)
660 {
661         u16 devno;
662         struct urdev *urd;
663         struct urfile *urf;
664         unsigned short accmode;
665         int rc;
666
667         accmode = file->f_flags & O_ACCMODE;
668
669         if (accmode == O_RDWR)
670                 return -EACCES;
671
672         /*
673          * We treat the minor number as the devno of the ur device
674          * to find in the driver tree.
675          */
676         devno = MINOR(file->f_dentry->d_inode->i_rdev);
677
678         urd = urdev_get_from_devno(devno);
679         if (!urd)
680                 return -ENXIO;
681
682         spin_lock(&urd->open_lock);
683         while (urd->open_flag) {
684                 spin_unlock(&urd->open_lock);
685                 if (file->f_flags & O_NONBLOCK) {
686                         rc = -EBUSY;
687                         goto fail_put;
688                 }
689                 if (wait_event_interruptible(urd->wait, urd->open_flag == 0)) {
690                         rc = -ERESTARTSYS;
691                         goto fail_put;
692                 }
693                 spin_lock(&urd->open_lock);
694         }
695         urd->open_flag++;
696         spin_unlock(&urd->open_lock);
697
698         TRACE("ur_open\n");
699
700         if (((accmode == O_RDONLY) && (urd->class != DEV_CLASS_UR_I)) ||
701             ((accmode == O_WRONLY) && (urd->class != DEV_CLASS_UR_O))) {
702                 TRACE("ur_open: unsupported dev class (%d)\n", urd->class);
703                 rc = -EACCES;
704                 goto fail_unlock;
705         }
706
707         rc = verify_device(urd);
708         if (rc)
709                 goto fail_unlock;
710
711         urf = urfile_alloc(urd);
712         if (!urf) {
713                 rc = -ENOMEM;
714                 goto fail_unlock;
715         }
716
717         urf->dev_reclen = urd->reclen;
718         rc = get_file_reclen(urd);
719         if (rc < 0)
720                 goto fail_urfile_free;
721         urf->file_reclen = rc;
722         file->private_data = urf;
723         return 0;
724
725 fail_urfile_free:
726         urfile_free(urf);
727 fail_unlock:
728         spin_lock(&urd->open_lock);
729         urd->open_flag--;
730         spin_unlock(&urd->open_lock);
731 fail_put:
732         urdev_put(urd);
733         return rc;
734 }
735
736 static int ur_release(struct inode *inode, struct file *file)
737 {
738         struct urfile *urf = file->private_data;
739
740         TRACE("ur_release\n");
741         spin_lock(&urf->urd->open_lock);
742         urf->urd->open_flag--;
743         spin_unlock(&urf->urd->open_lock);
744         wake_up_interruptible(&urf->urd->wait);
745         urdev_put(urf->urd);
746         urfile_free(urf);
747         return 0;
748 }
749
750 static loff_t ur_llseek(struct file *file, loff_t offset, int whence)
751 {
752         loff_t newpos;
753
754         if ((file->f_flags & O_ACCMODE) != O_RDONLY)
755                 return -ESPIPE; /* seek allowed only for reader */
756         if (offset % PAGE_SIZE)
757                 return -ESPIPE; /* only multiples of 4K allowed */
758         switch (whence) {
759         case 0: /* SEEK_SET */
760                 newpos = offset;
761                 break;
762         case 1: /* SEEK_CUR */
763                 newpos = file->f_pos + offset;
764                 break;
765         default:
766                 return -EINVAL;
767         }
768         file->f_pos = newpos;
769         return newpos;
770 }
771
772 static const struct file_operations ur_fops = {
773         .owner   = THIS_MODULE,
774         .open    = ur_open,
775         .release = ur_release,
776         .read    = ur_read,
777         .write   = ur_write,
778         .llseek  = ur_llseek,
779 };
780
781 /*
782  * ccw_device infrastructure:
783  *     ur_probe creates the struct urdev (with refcount = 1), the device
784  *     attributes, sets up the interrupt handler and validates the virtual
785  *     unit record device.
786  *     ur_remove removes the device attributes and drops the reference to
787  *     struct urdev.
788  *
789  *     ur_probe, ur_remove, ur_set_online and ur_set_offline are serialized
790  *     by the vmur_mutex lock.
791  *
792  *     urd->char_device is used as indication that the online function has
793  *     been completed successfully.
794  */
795 static int ur_probe(struct ccw_device *cdev)
796 {
797         struct urdev *urd;
798         int rc;
799
800         TRACE("ur_probe: cdev=%p\n", cdev);
801
802         mutex_lock(&vmur_mutex);
803         urd = urdev_alloc(cdev);
804         if (!urd) {
805                 rc = -ENOMEM;
806                 goto fail_unlock;
807         }
808
809         rc = ur_create_attributes(&cdev->dev);
810         if (rc) {
811                 rc = -ENOMEM;
812                 goto fail_urdev_put;
813         }
814         cdev->handler = ur_int_handler;
815
816         /* validate virtual unit record device */
817         urd->class = get_urd_class(urd);
818         if (urd->class < 0) {
819                 rc = urd->class;
820                 goto fail_remove_attr;
821         }
822         if ((urd->class != DEV_CLASS_UR_I) && (urd->class != DEV_CLASS_UR_O)) {
823                 rc = -ENOTSUPP;
824                 goto fail_remove_attr;
825         }
826         spin_lock_irq(get_ccwdev_lock(cdev));
827         cdev->dev.driver_data = urd;
828         spin_unlock_irq(get_ccwdev_lock(cdev));
829
830         mutex_unlock(&vmur_mutex);
831         return 0;
832
833 fail_remove_attr:
834         ur_remove_attributes(&cdev->dev);
835 fail_urdev_put:
836         urdev_put(urd);
837 fail_unlock:
838         mutex_unlock(&vmur_mutex);
839         return rc;
840 }
841
842 static int ur_set_online(struct ccw_device *cdev)
843 {
844         struct urdev *urd;
845         int minor, major, rc;
846         char node_id[16];
847
848         TRACE("ur_set_online: cdev=%p\n", cdev);
849
850         mutex_lock(&vmur_mutex);
851         urd = urdev_get_from_cdev(cdev);
852         if (!urd) {
853                 /* ur_remove already deleted our urd */
854                 rc = -ENODEV;
855                 goto fail_unlock;
856         }
857
858         if (urd->char_device) {
859                 /* Another ur_set_online was faster */
860                 rc = -EBUSY;
861                 goto fail_urdev_put;
862         }
863
864         minor = urd->dev_id.devno;
865         major = MAJOR(ur_first_dev_maj_min);
866
867         urd->char_device = cdev_alloc();
868         if (!urd->char_device) {
869                 rc = -ENOMEM;
870                 goto fail_urdev_put;
871         }
872
873         cdev_init(urd->char_device, &ur_fops);
874         urd->char_device->dev = MKDEV(major, minor);
875         urd->char_device->owner = ur_fops.owner;
876
877         rc = cdev_add(urd->char_device, urd->char_device->dev, 1);
878         if (rc)
879                 goto fail_free_cdev;
880         if (urd->cdev->id.cu_type == READER_PUNCH_DEVTYPE) {
881                 if (urd->class == DEV_CLASS_UR_I)
882                         sprintf(node_id, "vmrdr-%s", cdev->dev.bus_id);
883                 if (urd->class == DEV_CLASS_UR_O)
884                         sprintf(node_id, "vmpun-%s", cdev->dev.bus_id);
885         } else if (urd->cdev->id.cu_type == PRINTER_DEVTYPE) {
886                 sprintf(node_id, "vmprt-%s", cdev->dev.bus_id);
887         } else {
888                 rc = -ENOTSUPP;
889                 goto fail_free_cdev;
890         }
891
892         urd->device = device_create(vmur_class, NULL, urd->char_device->dev,
893                                         "%s", node_id);
894         if (IS_ERR(urd->device)) {
895                 rc = PTR_ERR(urd->device);
896                 TRACE("ur_set_online: device_create rc=%d\n", rc);
897                 goto fail_free_cdev;
898         }
899         urdev_put(urd);
900         mutex_unlock(&vmur_mutex);
901         return 0;
902
903 fail_free_cdev:
904         cdev_del(urd->char_device);
905         urd->char_device = NULL;
906 fail_urdev_put:
907         urdev_put(urd);
908 fail_unlock:
909         mutex_unlock(&vmur_mutex);
910         return rc;
911 }
912
913 static int ur_set_offline_force(struct ccw_device *cdev, int force)
914 {
915         struct urdev *urd;
916         int rc;
917
918         TRACE("ur_set_offline: cdev=%p\n", cdev);
919         urd = urdev_get_from_cdev(cdev);
920         if (!urd)
921                 /* ur_remove already deleted our urd */
922                 return -ENODEV;
923         if (!urd->char_device) {
924                 /* Another ur_set_offline was faster */
925                 rc = -EBUSY;
926                 goto fail_urdev_put;
927         }
928         if (!force && (atomic_read(&urd->ref_count) > 2)) {
929                 /* There is still a user of urd (e.g. ur_open) */
930                 TRACE("ur_set_offline: BUSY\n");
931                 rc = -EBUSY;
932                 goto fail_urdev_put;
933         }
934         device_destroy(vmur_class, urd->char_device->dev);
935         cdev_del(urd->char_device);
936         urd->char_device = NULL;
937         rc = 0;
938
939 fail_urdev_put:
940         urdev_put(urd);
941         return rc;
942 }
943
944 static int ur_set_offline(struct ccw_device *cdev)
945 {
946         int rc;
947
948         mutex_lock(&vmur_mutex);
949         rc = ur_set_offline_force(cdev, 0);
950         mutex_unlock(&vmur_mutex);
951         return rc;
952 }
953
954 static void ur_remove(struct ccw_device *cdev)
955 {
956         unsigned long flags;
957
958         TRACE("ur_remove\n");
959
960         mutex_lock(&vmur_mutex);
961
962         if (cdev->online)
963                 ur_set_offline_force(cdev, 1);
964         ur_remove_attributes(&cdev->dev);
965
966         spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
967         urdev_put(cdev->dev.driver_data);
968         cdev->dev.driver_data = NULL;
969         spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
970
971         mutex_unlock(&vmur_mutex);
972 }
973
974 /*
975  * Module initialisation and cleanup
976  */
977 static int __init ur_init(void)
978 {
979         int rc;
980         dev_t dev;
981
982         if (!MACHINE_IS_VM) {
983                 PRINT_ERR("%s is only available under z/VM.\n", ur_banner);
984                 return -ENODEV;
985         }
986
987         vmur_dbf = debug_register("vmur", 4, 1, 4 * sizeof(long));
988         if (!vmur_dbf)
989                 return -ENOMEM;
990         rc = debug_register_view(vmur_dbf, &debug_sprintf_view);
991         if (rc)
992                 goto fail_free_dbf;
993
994         debug_set_level(vmur_dbf, 6);
995
996         rc = ccw_driver_register(&ur_driver);
997         if (rc)
998                 goto fail_free_dbf;
999
1000         rc = alloc_chrdev_region(&dev, 0, NUM_MINORS, "vmur");
1001         if (rc) {
1002                 PRINT_ERR("alloc_chrdev_region failed: err = %d\n", rc);
1003                 goto fail_unregister_driver;
1004         }
1005         ur_first_dev_maj_min = MKDEV(MAJOR(dev), 0);
1006
1007         vmur_class = class_create(THIS_MODULE, "vmur");
1008         if (IS_ERR(vmur_class)) {
1009                 rc = PTR_ERR(vmur_class);
1010                 goto fail_unregister_region;
1011         }
1012         PRINT_INFO("%s loaded.\n", ur_banner);
1013         return 0;
1014
1015 fail_unregister_region:
1016         unregister_chrdev_region(ur_first_dev_maj_min, NUM_MINORS);
1017 fail_unregister_driver:
1018         ccw_driver_unregister(&ur_driver);
1019 fail_free_dbf:
1020         debug_unregister(vmur_dbf);
1021         return rc;
1022 }
1023
1024 static void __exit ur_exit(void)
1025 {
1026         class_destroy(vmur_class);
1027         unregister_chrdev_region(ur_first_dev_maj_min, NUM_MINORS);
1028         ccw_driver_unregister(&ur_driver);
1029         debug_unregister(vmur_dbf);
1030         PRINT_INFO("%s unloaded.\n", ur_banner);
1031 }
1032
1033 module_init(ur_init);
1034 module_exit(ur_exit);