1 // SPDX-License-Identifier: GPL-2.0
3 * Linux driver for System z and s390 unit record devices
4 * (z/VM virtual punch, reader, printer)
6 * Copyright IBM Corp. 2001, 2009
7 * Authors: Malcolm Beattie <beattiem@uk.ibm.com>
8 * Michael Holzheu <holzheu@de.ibm.com>
9 * Frank Munzert <munzert@de.ibm.com>
12 #define KMSG_COMPONENT "vmur"
13 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
15 #include <linux/cdev.h>
16 #include <linux/slab.h>
17 #include <linux/module.h>
19 #include <linux/uaccess.h>
21 #include <asm/ccwdev.h>
22 #include <asm/debug.h>
30 * Unit record device support is implemented as a character device driver.
31 * We can fit at least 16 bits into a device minor number and use the
32 * simple method of mapping a character device number with minor abcd
33 * to the unit record device with devno abcd.
34 * I/O to virtual unit record devices is handled as follows:
35 * Reads: Diagnose code 0x14 (input spool file manipulation)
36 * is used to read spool data page-wise.
37 * Writes: The CCW used is WRITE_CCW_CMD (0x01). The device's record length
38 * is available by reading sysfs attr reclen. Each write() to the device
39 * must specify an integral multiple (maximal 511) of reclen.
42 static char ur_banner
[] = "z/VM virtual unit record device driver";
44 MODULE_AUTHOR("IBM Corporation");
45 MODULE_DESCRIPTION("s390 z/VM virtual unit record device driver");
46 MODULE_LICENSE("GPL");
48 static dev_t ur_first_dev_maj_min
;
49 static struct class *vmur_class
;
50 static struct debug_info
*vmur_dbf
;
52 /* We put the device's record length (for writes) in the driver_info field */
53 static struct ccw_device_id ur_ids
[] = {
54 { CCWDEV_CU_DI(READER_PUNCH_DEVTYPE
, 80) },
55 { CCWDEV_CU_DI(PRINTER_DEVTYPE
, 132) },
59 MODULE_DEVICE_TABLE(ccw
, ur_ids
);
61 static int ur_probe(struct ccw_device
*cdev
);
62 static void ur_remove(struct ccw_device
*cdev
);
63 static int ur_set_online(struct ccw_device
*cdev
);
64 static int ur_set_offline(struct ccw_device
*cdev
);
66 static struct ccw_driver ur_driver
= {
74 .set_online
= ur_set_online
,
75 .set_offline
= ur_set_offline
,
76 .int_class
= IRQIO_VMR
,
79 static DEFINE_MUTEX(vmur_mutex
);
82 * Allocation, freeing, getting and putting of urdev structures
84 * Each ur device (urd) contains a reference to its corresponding ccw device
85 * (cdev) using the urd->cdev pointer. Each ccw device has a reference to the
86 * ur device using dev_get_drvdata(&cdev->dev) pointer.
89 * - ur_probe gets a urd reference, ur_remove drops the reference
90 * dev_get_drvdata(&cdev->dev)
91 * - ur_open gets a urd reference, ur_release drops the reference
95 * - urdev_alloc get a cdev reference (urd->cdev)
96 * - urdev_free drops the cdev reference (urd->cdev)
98 * Setting and clearing of dev_get_drvdata(&cdev->dev) is protected by the ccwdev lock
100 static struct urdev
*urdev_alloc(struct ccw_device
*cdev
)
104 urd
= kzalloc(sizeof(struct urdev
), GFP_KERNEL
);
107 urd
->reclen
= cdev
->id
.driver_info
;
108 ccw_device_get_id(cdev
, &urd
->dev_id
);
109 mutex_init(&urd
->io_mutex
);
110 init_waitqueue_head(&urd
->wait
);
111 spin_lock_init(&urd
->open_lock
);
112 refcount_set(&urd
->ref_count
, 1);
114 get_device(&cdev
->dev
);
118 static void urdev_free(struct urdev
*urd
)
120 TRACE("urdev_free: %p\n", urd
);
122 put_device(&urd
->cdev
->dev
);
126 static void urdev_get(struct urdev
*urd
)
128 refcount_inc(&urd
->ref_count
);
131 static struct urdev
*urdev_get_from_cdev(struct ccw_device
*cdev
)
136 spin_lock_irqsave(get_ccwdev_lock(cdev
), flags
);
137 urd
= dev_get_drvdata(&cdev
->dev
);
140 spin_unlock_irqrestore(get_ccwdev_lock(cdev
), flags
);
144 static struct urdev
*urdev_get_from_devno(u16 devno
)
147 struct ccw_device
*cdev
;
150 sprintf(bus_id
, "0.0.%04x", devno
);
151 cdev
= get_ccwdev_by_busid(&ur_driver
, bus_id
);
154 urd
= urdev_get_from_cdev(cdev
);
155 put_device(&cdev
->dev
);
159 static void urdev_put(struct urdev
*urd
)
161 if (refcount_dec_and_test(&urd
->ref_count
))
166 * Low-level functions to do I/O to a ur device.
172 * alloc_chan_prog allocates and builds the channel program
173 * free_chan_prog frees memory of the channel program
175 * do_ur_io issues the channel program to the device and blocks waiting
176 * on a completion event it publishes at urd->io_done. The function
177 * serialises itself on the device's mutex so that only one I/O
178 * is issued at a time (and that I/O is synchronous).
180 * ur_int_handler catches the "I/O done" interrupt, writes the
181 * subchannel status word into the scsw member of the urdev structure
182 * and complete()s the io_done to wake the waiting do_ur_io.
184 * The caller of do_ur_io is responsible for kfree()ing the channel program
185 * address pointer that alloc_chan_prog returned.
188 static void free_chan_prog(struct ccw1
*cpa
)
190 struct ccw1
*ptr
= cpa
;
193 kfree((void *)(addr_t
) ptr
->cda
);
201 * The channel program we use is write commands chained together
202 * with a final NOP CCW command-chained on (which ensures that CE and DE
203 * are presented together in a single interrupt instead of as separate
204 * interrupts unless an incorrect length indication kicks in first). The
205 * data length in each CCW is reclen.
207 static struct ccw1
*alloc_chan_prog(const char __user
*ubuf
, int rec_count
,
214 TRACE("alloc_chan_prog(%p, %i, %i)\n", ubuf
, rec_count
, reclen
);
217 * We chain a NOP onto the writes to force CE+DE together.
218 * That means we allocate room for CCWs to cover count/reclen
219 * records plus a NOP.
221 cpa
= kcalloc(rec_count
+ 1, sizeof(struct ccw1
),
222 GFP_KERNEL
| GFP_DMA
);
224 return ERR_PTR(-ENOMEM
);
226 for (i
= 0; i
< rec_count
; i
++) {
227 cpa
[i
].cmd_code
= WRITE_CCW_CMD
;
228 cpa
[i
].flags
= CCW_FLAG_CC
| CCW_FLAG_SLI
;
229 cpa
[i
].count
= reclen
;
230 kbuf
= kmalloc(reclen
, GFP_KERNEL
| GFP_DMA
);
233 return ERR_PTR(-ENOMEM
);
235 cpa
[i
].cda
= (u32
)(addr_t
) kbuf
;
236 if (copy_from_user(kbuf
, ubuf
, reclen
)) {
238 return ERR_PTR(-EFAULT
);
242 /* The following NOP CCW forces CE+DE to be presented together */
243 cpa
[i
].cmd_code
= CCW_CMD_NOOP
;
247 static int do_ur_io(struct urdev
*urd
, struct ccw1
*cpa
)
250 struct ccw_device
*cdev
= urd
->cdev
;
251 DECLARE_COMPLETION_ONSTACK(event
);
253 TRACE("do_ur_io: cpa=%p\n", cpa
);
255 rc
= mutex_lock_interruptible(&urd
->io_mutex
);
259 urd
->io_done
= &event
;
261 spin_lock_irq(get_ccwdev_lock(cdev
));
262 rc
= ccw_device_start(cdev
, cpa
, 1, 0, 0);
263 spin_unlock_irq(get_ccwdev_lock(cdev
));
265 TRACE("do_ur_io: ccw_device_start returned %d\n", rc
);
269 wait_for_completion(&event
);
270 TRACE("do_ur_io: I/O complete\n");
274 mutex_unlock(&urd
->io_mutex
);
279 * ur interrupt handler, called from the ccw_device layer
281 static void ur_int_handler(struct ccw_device
*cdev
, unsigned long intparm
,
287 TRACE("ur_int_handler: intparm=0x%lx cstat=%02x dstat=%02x res=%u\n",
288 intparm
, irb
->scsw
.cmd
.cstat
, irb
->scsw
.cmd
.dstat
,
289 irb
->scsw
.cmd
.count
);
292 TRACE("ur_int_handler: unsolicited interrupt\n");
295 urd
= dev_get_drvdata(&cdev
->dev
);
297 /* On special conditions irb is an error pointer */
299 urd
->io_request_rc
= PTR_ERR(irb
);
300 else if (irb
->scsw
.cmd
.dstat
== (DEV_STAT_CHN_END
| DEV_STAT_DEV_END
))
301 urd
->io_request_rc
= 0;
303 urd
->io_request_rc
= -EIO
;
305 complete(urd
->io_done
);
309 * reclen sysfs attribute - The record length to be used for write CCWs
311 static ssize_t
ur_attr_reclen_show(struct device
*dev
,
312 struct device_attribute
*attr
, char *buf
)
317 urd
= urdev_get_from_cdev(to_ccwdev(dev
));
320 rc
= sprintf(buf
, "%zu\n", urd
->reclen
);
325 static DEVICE_ATTR(reclen
, 0444, ur_attr_reclen_show
, NULL
);
327 static int ur_create_attributes(struct device
*dev
)
329 return device_create_file(dev
, &dev_attr_reclen
);
332 static void ur_remove_attributes(struct device
*dev
)
334 device_remove_file(dev
, &dev_attr_reclen
);
338 * diagnose code 0x210 - retrieve device information
339 * cc=0 normal completion, we have a real device
340 * cc=1 CP paging error
341 * cc=2 The virtual device exists, but is not associated with a real device
342 * cc=3 Invalid device address, or the virtual device does not exist
344 static int get_urd_class(struct urdev
*urd
)
346 static struct diag210 ur_diag210
;
349 ur_diag210
.vrdcdvno
= urd
->dev_id
.devno
;
350 ur_diag210
.vrdclen
= sizeof(struct diag210
);
352 cc
= diag210(&ur_diag210
);
357 return ur_diag210
.vrdcvcla
; /* virtual device class */
366 * Allocation and freeing of urfile structures
368 static struct urfile
*urfile_alloc(struct urdev
*urd
)
372 urf
= kzalloc(sizeof(struct urfile
), GFP_KERNEL
);
377 TRACE("urfile_alloc: urd=%p urf=%p rl=%zu\n", urd
, urf
,
383 static void urfile_free(struct urfile
*urf
)
385 TRACE("urfile_free: urf=%p urd=%p\n", urf
, urf
->urd
);
390 * The fops implementation of the character device driver
392 static ssize_t
do_write(struct urdev
*urd
, const char __user
*udata
,
393 size_t count
, size_t reclen
, loff_t
*ppos
)
398 cpa
= alloc_chan_prog(udata
, count
/ reclen
, reclen
);
402 rc
= do_ur_io(urd
, cpa
);
406 if (urd
->io_request_rc
) {
407 rc
= urd
->io_request_rc
;
418 static ssize_t
ur_write(struct file
*file
, const char __user
*udata
,
419 size_t count
, loff_t
*ppos
)
421 struct urfile
*urf
= file
->private_data
;
423 TRACE("ur_write: count=%zu\n", count
);
428 if (count
% urf
->dev_reclen
)
429 return -EINVAL
; /* count must be a multiple of reclen */
431 if (count
> urf
->dev_reclen
* MAX_RECS_PER_IO
)
432 count
= urf
->dev_reclen
* MAX_RECS_PER_IO
;
434 return do_write(urf
->urd
, udata
, count
, urf
->dev_reclen
, ppos
);
438 * diagnose code 0x14 subcode 0x0028 - position spool file to designated
440 * cc=0 normal completion
441 * cc=2 no file active on the virtual reader or device not ready
442 * cc=3 record specified is beyond EOF
444 static int diag_position_to_record(int devno
, int record
)
448 cc
= diag14(record
, devno
, 0x28);
455 return -ENODATA
; /* position beyond end of file */
462 * diagnose code 0x14 subcode 0x0000 - read next spool file buffer
463 * cc=0 normal completion
465 * cc=2 no file active on the virtual reader, and no file eligible
466 * cc=3 file already active on the virtual reader or specified virtual
467 * reader does not exist or is not a reader
469 static int diag_read_file(int devno
, char *buf
)
473 cc
= diag14((unsigned long) buf
, devno
, 0x00);
486 static ssize_t
diag14_read(struct file
*file
, char __user
*ubuf
, size_t count
,
489 size_t len
, copied
, res
;
495 urd
= ((struct urfile
*) file
->private_data
)->urd
;
496 reclen
= ((struct urfile
*) file
->private_data
)->file_reclen
;
498 rc
= diag_position_to_record(urd
->dev_id
.devno
, *offs
/ PAGE_SIZE
+ 1);
504 len
= min((size_t) PAGE_SIZE
, count
);
505 buf
= (char *) __get_free_page(GFP_KERNEL
| GFP_DMA
);
510 res
= (size_t) (*offs
% PAGE_SIZE
);
512 rc
= diag_read_file(urd
->dev_id
.devno
, buf
);
513 if (rc
== -ENODATA
) {
518 if (reclen
&& (copied
== 0) && (*offs
< PAGE_SIZE
))
519 *((u16
*) &buf
[FILE_RECLEN_OFFSET
]) = reclen
;
520 len
= min(count
- copied
, PAGE_SIZE
- res
);
521 if (copy_to_user(ubuf
+ copied
, buf
+ res
, len
)) {
527 } while (copied
!= count
);
532 free_page((unsigned long) buf
);
536 static ssize_t
ur_read(struct file
*file
, char __user
*ubuf
, size_t count
,
542 TRACE("ur_read: count=%zu ppos=%li\n", count
, (unsigned long) *offs
);
547 urd
= ((struct urfile
*) file
->private_data
)->urd
;
548 rc
= mutex_lock_interruptible(&urd
->io_mutex
);
551 rc
= diag14_read(file
, ubuf
, count
, offs
);
552 mutex_unlock(&urd
->io_mutex
);
557 * diagnose code 0x14 subcode 0x0fff - retrieve next file descriptor
558 * cc=0 normal completion
559 * cc=1 no files on reader queue or no subsequent file
560 * cc=2 spid specified is invalid
562 static int diag_read_next_file_info(struct file_control_block
*buf
, int spid
)
566 cc
= diag14((unsigned long) buf
, spid
, 0xfff);
575 static int verify_uri_device(struct urdev
*urd
)
577 struct file_control_block
*fcb
;
581 fcb
= kmalloc(sizeof(*fcb
), GFP_KERNEL
| GFP_DMA
);
585 /* check for empty reader device (beginning of chain) */
586 rc
= diag_read_next_file_info(fcb
, 0);
590 /* if file is in hold status, we do not read it */
591 if (fcb
->file_stat
& (FLG_SYSTEM_HOLD
| FLG_USER_HOLD
)) {
596 /* open file on virtual reader */
597 buf
= (char *) __get_free_page(GFP_KERNEL
| GFP_DMA
);
602 rc
= diag_read_file(urd
->dev_id
.devno
, buf
);
603 if ((rc
!= 0) && (rc
!= -ENODATA
)) /* EOF does not hurt */
606 /* check if the file on top of the queue is open now */
607 rc
= diag_read_next_file_info(fcb
, 0);
610 if (!(fcb
->file_stat
& FLG_IN_USE
)) {
617 free_page((unsigned long) buf
);
623 static int verify_device(struct urdev
*urd
)
625 switch (urd
->class) {
627 return 0; /* no check needed here */
629 return verify_uri_device(urd
);
635 static int get_uri_file_reclen(struct urdev
*urd
)
637 struct file_control_block
*fcb
;
640 fcb
= kmalloc(sizeof(*fcb
), GFP_KERNEL
| GFP_DMA
);
643 rc
= diag_read_next_file_info(fcb
, 0);
646 if (fcb
->file_stat
& FLG_CP_DUMP
)
656 static int get_file_reclen(struct urdev
*urd
)
658 switch (urd
->class) {
662 return get_uri_file_reclen(urd
);
668 static int ur_open(struct inode
*inode
, struct file
*file
)
673 unsigned short accmode
;
676 accmode
= file
->f_flags
& O_ACCMODE
;
678 if (accmode
== O_RDWR
)
681 * We treat the minor number as the devno of the ur device
682 * to find in the driver tree.
684 devno
= MINOR(file_inode(file
)->i_rdev
);
686 urd
= urdev_get_from_devno(devno
);
692 spin_lock(&urd
->open_lock
);
693 while (urd
->open_flag
) {
694 spin_unlock(&urd
->open_lock
);
695 if (file
->f_flags
& O_NONBLOCK
) {
699 if (wait_event_interruptible(urd
->wait
, urd
->open_flag
== 0)) {
703 spin_lock(&urd
->open_lock
);
706 spin_unlock(&urd
->open_lock
);
710 if (((accmode
== O_RDONLY
) && (urd
->class != DEV_CLASS_UR_I
)) ||
711 ((accmode
== O_WRONLY
) && (urd
->class != DEV_CLASS_UR_O
))) {
712 TRACE("ur_open: unsupported dev class (%d)\n", urd
->class);
717 rc
= verify_device(urd
);
721 urf
= urfile_alloc(urd
);
727 urf
->dev_reclen
= urd
->reclen
;
728 rc
= get_file_reclen(urd
);
730 goto fail_urfile_free
;
731 urf
->file_reclen
= rc
;
732 file
->private_data
= urf
;
738 spin_lock(&urd
->open_lock
);
740 spin_unlock(&urd
->open_lock
);
747 static int ur_release(struct inode
*inode
, struct file
*file
)
749 struct urfile
*urf
= file
->private_data
;
751 TRACE("ur_release\n");
752 spin_lock(&urf
->urd
->open_lock
);
753 urf
->urd
->open_flag
--;
754 spin_unlock(&urf
->urd
->open_lock
);
755 wake_up_interruptible(&urf
->urd
->wait
);
761 static loff_t
ur_llseek(struct file
*file
, loff_t offset
, int whence
)
763 if ((file
->f_flags
& O_ACCMODE
) != O_RDONLY
)
764 return -ESPIPE
; /* seek allowed only for reader */
765 if (offset
% PAGE_SIZE
)
766 return -ESPIPE
; /* only multiples of 4K allowed */
767 return no_seek_end_llseek(file
, offset
, whence
);
770 static const struct file_operations ur_fops
= {
771 .owner
= THIS_MODULE
,
773 .release
= ur_release
,
780 * ccw_device infrastructure:
781 * ur_probe creates the struct urdev (with refcount = 1), the device
782 * attributes, sets up the interrupt handler and validates the virtual
783 * unit record device.
784 * ur_remove removes the device attributes and drops the reference to
787 * ur_probe, ur_remove, ur_set_online and ur_set_offline are serialized
788 * by the vmur_mutex lock.
790 * urd->char_device is used as indication that the online function has
791 * been completed successfully.
793 static int ur_probe(struct ccw_device
*cdev
)
798 TRACE("ur_probe: cdev=%p\n", cdev
);
800 mutex_lock(&vmur_mutex
);
801 urd
= urdev_alloc(cdev
);
807 rc
= ur_create_attributes(&cdev
->dev
);
812 cdev
->handler
= ur_int_handler
;
814 /* validate virtual unit record device */
815 urd
->class = get_urd_class(urd
);
816 if (urd
->class < 0) {
818 goto fail_remove_attr
;
820 if ((urd
->class != DEV_CLASS_UR_I
) && (urd
->class != DEV_CLASS_UR_O
)) {
822 goto fail_remove_attr
;
824 spin_lock_irq(get_ccwdev_lock(cdev
));
825 dev_set_drvdata(&cdev
->dev
, urd
);
826 spin_unlock_irq(get_ccwdev_lock(cdev
));
828 mutex_unlock(&vmur_mutex
);
832 ur_remove_attributes(&cdev
->dev
);
836 mutex_unlock(&vmur_mutex
);
840 static int ur_set_online(struct ccw_device
*cdev
)
843 int minor
, major
, rc
;
846 TRACE("ur_set_online: cdev=%p\n", cdev
);
848 mutex_lock(&vmur_mutex
);
849 urd
= urdev_get_from_cdev(cdev
);
851 /* ur_remove already deleted our urd */
856 if (urd
->char_device
) {
857 /* Another ur_set_online was faster */
862 minor
= urd
->dev_id
.devno
;
863 major
= MAJOR(ur_first_dev_maj_min
);
865 urd
->char_device
= cdev_alloc();
866 if (!urd
->char_device
) {
871 urd
->char_device
->ops
= &ur_fops
;
872 urd
->char_device
->owner
= ur_fops
.owner
;
874 rc
= cdev_add(urd
->char_device
, MKDEV(major
, minor
), 1);
877 if (urd
->cdev
->id
.cu_type
== READER_PUNCH_DEVTYPE
) {
878 if (urd
->class == DEV_CLASS_UR_I
)
879 sprintf(node_id
, "vmrdr-%s", dev_name(&cdev
->dev
));
880 if (urd
->class == DEV_CLASS_UR_O
)
881 sprintf(node_id
, "vmpun-%s", dev_name(&cdev
->dev
));
882 } else if (urd
->cdev
->id
.cu_type
== PRINTER_DEVTYPE
) {
883 sprintf(node_id
, "vmprt-%s", dev_name(&cdev
->dev
));
889 urd
->device
= device_create(vmur_class
, &cdev
->dev
,
890 urd
->char_device
->dev
, NULL
, "%s", node_id
);
891 if (IS_ERR(urd
->device
)) {
892 rc
= PTR_ERR(urd
->device
);
893 TRACE("ur_set_online: device_create rc=%d\n", rc
);
897 mutex_unlock(&vmur_mutex
);
901 cdev_del(urd
->char_device
);
902 urd
->char_device
= NULL
;
906 mutex_unlock(&vmur_mutex
);
910 static int ur_set_offline_force(struct ccw_device
*cdev
, int force
)
915 TRACE("ur_set_offline: cdev=%p\n", cdev
);
916 urd
= urdev_get_from_cdev(cdev
);
918 /* ur_remove already deleted our urd */
920 if (!urd
->char_device
) {
921 /* Another ur_set_offline was faster */
925 if (!force
&& (refcount_read(&urd
->ref_count
) > 2)) {
926 /* There is still a user of urd (e.g. ur_open) */
927 TRACE("ur_set_offline: BUSY\n");
931 device_destroy(vmur_class
, urd
->char_device
->dev
);
932 cdev_del(urd
->char_device
);
933 urd
->char_device
= NULL
;
941 static int ur_set_offline(struct ccw_device
*cdev
)
945 mutex_lock(&vmur_mutex
);
946 rc
= ur_set_offline_force(cdev
, 0);
947 mutex_unlock(&vmur_mutex
);
951 static void ur_remove(struct ccw_device
*cdev
)
955 TRACE("ur_remove\n");
957 mutex_lock(&vmur_mutex
);
960 ur_set_offline_force(cdev
, 1);
961 ur_remove_attributes(&cdev
->dev
);
963 spin_lock_irqsave(get_ccwdev_lock(cdev
), flags
);
964 urdev_put(dev_get_drvdata(&cdev
->dev
));
965 dev_set_drvdata(&cdev
->dev
, NULL
);
966 spin_unlock_irqrestore(get_ccwdev_lock(cdev
), flags
);
968 mutex_unlock(&vmur_mutex
);
972 * Module initialisation and cleanup
974 static int __init
ur_init(void)
979 if (!MACHINE_IS_VM
) {
980 pr_err("The %s cannot be loaded without z/VM\n",
985 vmur_dbf
= debug_register("vmur", 4, 1, 4 * sizeof(long));
988 rc
= debug_register_view(vmur_dbf
, &debug_sprintf_view
);
992 debug_set_level(vmur_dbf
, 6);
994 vmur_class
= class_create(THIS_MODULE
, "vmur");
995 if (IS_ERR(vmur_class
)) {
996 rc
= PTR_ERR(vmur_class
);
1000 rc
= ccw_driver_register(&ur_driver
);
1002 goto fail_class_destroy
;
1004 rc
= alloc_chrdev_region(&dev
, 0, NUM_MINORS
, "vmur");
1006 pr_err("Kernel function alloc_chrdev_region failed with "
1007 "error code %d\n", rc
);
1008 goto fail_unregister_driver
;
1010 ur_first_dev_maj_min
= MKDEV(MAJOR(dev
), 0);
1012 pr_info("%s loaded.\n", ur_banner
);
1015 fail_unregister_driver
:
1016 ccw_driver_unregister(&ur_driver
);
1018 class_destroy(vmur_class
);
1020 debug_unregister(vmur_dbf
);
1024 static void __exit
ur_exit(void)
1026 unregister_chrdev_region(ur_first_dev_maj_min
, NUM_MINORS
);
1027 ccw_driver_unregister(&ur_driver
);
1028 class_destroy(vmur_class
);
1029 debug_unregister(vmur_dbf
);
1030 pr_info("%s unloaded.\n", ur_banner
);
1033 module_init(ur_init
);
1034 module_exit(ur_exit
);