2 * drivers/cdrom/viocd.c
4 * iSeries Virtual CD Rom
6 * Authors: Dave Boutcher <boutcher@us.ibm.com>
7 * Ryan Arnold <ryanarn@us.ibm.com>
8 * Colin Devilbiss <devilbis@us.ibm.com>
11 * (C) Copyright 2000-2004 IBM Corporation
13 * This program is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU General Public License as
15 * published by the Free Software Foundation; either version 2 of the
16 * License, or (at your option) anyu later version.
18 * This program is distributed in the hope that it will be useful, but
19 * WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 * General Public License for more details.
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the Free Software Foundation,
25 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
27 * This routine provides access to CD ROM drives owned and managed by an
28 * OS/400 partition running on the same box as this Linux partition.
30 * All operations are performed by sending messages back and forth to
31 * the OS/400 partition.
34 #include <linux/major.h>
35 #include <linux/blkdev.h>
36 #include <linux/cdrom.h>
37 #include <linux/errno.h>
38 #include <linux/init.h>
39 #include <linux/dma-mapping.h>
40 #include <linux/module.h>
41 #include <linux/completion.h>
42 #include <linux/proc_fs.h>
43 #include <linux/seq_file.h>
44 #include <linux/scatterlist.h>
47 #include <asm/iseries/hv_types.h>
48 #include <asm/iseries/hv_lp_event.h>
49 #include <asm/iseries/vio.h>
50 #include <asm/firmware.h>
52 #define VIOCD_DEVICE "iseries/vcd"
54 #define VIOCD_VERS "1.06"
56 #define VIOCD_KERN_WARNING KERN_WARNING "viocd: "
57 #define VIOCD_KERN_INFO KERN_INFO "viocd: "
60 * Should probably make this a module parameter....sigh
62 #define VIOCD_MAX_CD HVMAXARCHITECTEDVIRTUALCDROMS
64 static const struct vio_error_entry viocd_err_table
[] = {
65 {0x0201, EINVAL
, "Invalid Range"},
66 {0x0202, EINVAL
, "Invalid Token"},
67 {0x0203, EIO
, "DMA Error"},
68 {0x0204, EIO
, "Use Error"},
69 {0x0205, EIO
, "Release Error"},
70 {0x0206, EINVAL
, "Invalid CD"},
71 {0x020C, EROFS
, "Read Only Device"},
72 {0x020D, ENOMEDIUM
, "Changed or Missing Volume (or Varied Off?)"},
73 {0x020E, EIO
, "Optical System Error (Varied Off?)"},
74 {0x02FF, EIO
, "Internal Error"},
75 {0x3010, EIO
, "Changed Volume"},
76 {0xC100, EIO
, "Optical System Error"},
81 * This is the structure we use to exchange info between driver and interrupt
84 struct viocd_waitevent
{
85 struct completion com
;
91 /* this is a lookup table for the true capabilities of a device */
92 struct capability_entry
{
97 static struct capability_entry capability_table
[] __initdata
= {
98 { "6330", CDC_LOCK
| CDC_DVD_RAM
| CDC_RAM
},
99 { "6331", CDC_LOCK
| CDC_DVD_RAM
| CDC_RAM
},
100 { "6333", CDC_LOCK
| CDC_DVD_RAM
| CDC_RAM
},
101 { "632A", CDC_LOCK
| CDC_DVD_RAM
| CDC_RAM
},
102 { "6321", CDC_LOCK
},
107 /* These are our internal structures for keeping track of devices */
108 static int viocd_numdev
;
111 struct gendisk
*viocd_disk
;
112 struct cdrom_device_info viocd_info
;
114 const char *rsrcname
;
118 static struct disk_info viocd_diskinfo
[VIOCD_MAX_CD
];
120 #define DEVICE_NR(di) ((di) - &viocd_diskinfo[0])
122 static spinlock_t viocd_reqlock
;
127 static int proc_viocd_show(struct seq_file
*m
, void *v
)
131 for (i
= 0; i
< viocd_numdev
; i
++) {
132 seq_printf(m
, "viocd device %d is iSeries resource %10.10s"
133 "type %4.4s, model %3.3s\n",
134 i
, viocd_diskinfo
[i
].rsrcname
,
135 viocd_diskinfo
[i
].type
,
136 viocd_diskinfo
[i
].model
);
141 static int proc_viocd_open(struct inode
*inode
, struct file
*file
)
143 return single_open(file
, proc_viocd_show
, NULL
);
146 static const struct file_operations proc_viocd_operations
= {
147 .owner
= THIS_MODULE
,
148 .open
= proc_viocd_open
,
151 .release
= single_release
,
154 static int viocd_blk_open(struct block_device
*bdev
, fmode_t mode
)
156 struct disk_info
*di
= bdev
->bd_disk
->private_data
;
157 return cdrom_open(&di
->viocd_info
, bdev
, mode
);
160 static int viocd_blk_release(struct gendisk
*disk
, fmode_t mode
)
162 struct disk_info
*di
= disk
->private_data
;
163 cdrom_release(&di
->viocd_info
, mode
);
167 static int viocd_blk_ioctl(struct block_device
*bdev
, fmode_t mode
,
168 unsigned cmd
, unsigned long arg
)
170 struct disk_info
*di
= bdev
->bd_disk
->private_data
;
171 return cdrom_ioctl(&di
->viocd_info
, bdev
, mode
, cmd
, arg
);
174 static int viocd_blk_media_changed(struct gendisk
*disk
)
176 struct disk_info
*di
= disk
->private_data
;
177 return cdrom_media_changed(&di
->viocd_info
);
180 struct block_device_operations viocd_fops
= {
181 .owner
= THIS_MODULE
,
182 .open
= viocd_blk_open
,
183 .release
= viocd_blk_release
,
184 .locked_ioctl
= viocd_blk_ioctl
,
185 .media_changed
= viocd_blk_media_changed
,
188 static int viocd_open(struct cdrom_device_info
*cdi
, int purpose
)
190 struct disk_info
*diskinfo
= cdi
->handle
;
191 int device_no
= DEVICE_NR(diskinfo
);
193 struct viocd_waitevent we
;
195 init_completion(&we
.com
);
196 hvrc
= HvCallEvent_signalLpEventFast(viopath_hostLp
,
197 HvLpEvent_Type_VirtualIo
,
198 viomajorsubtype_cdio
| viocdopen
,
199 HvLpEvent_AckInd_DoAck
, HvLpEvent_AckType_ImmediateAck
,
200 viopath_sourceinst(viopath_hostLp
),
201 viopath_targetinst(viopath_hostLp
),
202 (u64
)&we
, VIOVERSION
<< 16, ((u64
)device_no
<< 48),
205 printk(VIOCD_KERN_WARNING
206 "bad rc on HvCallEvent_signalLpEventFast %d\n",
211 wait_for_completion(&we
.com
);
214 const struct vio_error_entry
*err
=
215 vio_lookup_rc(viocd_err_table
, we
.sub_result
);
216 printk(VIOCD_KERN_WARNING
"bad rc %d:0x%04X on open: %s\n",
217 we
.rc
, we
.sub_result
, err
->msg
);
224 static void viocd_release(struct cdrom_device_info
*cdi
)
226 int device_no
= DEVICE_NR((struct disk_info
*)cdi
->handle
);
229 hvrc
= HvCallEvent_signalLpEventFast(viopath_hostLp
,
230 HvLpEvent_Type_VirtualIo
,
231 viomajorsubtype_cdio
| viocdclose
,
232 HvLpEvent_AckInd_NoAck
, HvLpEvent_AckType_ImmediateAck
,
233 viopath_sourceinst(viopath_hostLp
),
234 viopath_targetinst(viopath_hostLp
), 0,
235 VIOVERSION
<< 16, ((u64
)device_no
<< 48), 0, 0, 0);
237 printk(VIOCD_KERN_WARNING
238 "bad rc on HvCallEvent_signalLpEventFast %d\n",
242 /* Send a read or write request to OS/400 */
243 static int send_request(struct request
*req
)
246 struct disk_info
*diskinfo
= req
->rq_disk
->private_data
;
251 struct scatterlist sg
;
253 BUG_ON(req
->nr_phys_segments
> 1);
255 if (rq_data_dir(req
) == READ
) {
256 direction
= DMA_FROM_DEVICE
;
257 cmd
= viomajorsubtype_cdio
| viocdread
;
259 direction
= DMA_TO_DEVICE
;
260 cmd
= viomajorsubtype_cdio
| viocdwrite
;
263 sg_init_table(&sg
, 1);
264 if (blk_rq_map_sg(req
->q
, req
, &sg
) == 0) {
265 printk(VIOCD_KERN_WARNING
266 "error setting up scatter/gather list\n");
270 if (dma_map_sg(diskinfo
->dev
, &sg
, 1, direction
) == 0) {
271 printk(VIOCD_KERN_WARNING
"error allocating sg tce\n");
274 dmaaddr
= sg_dma_address(&sg
);
275 len
= sg_dma_len(&sg
);
277 hvrc
= HvCallEvent_signalLpEventFast(viopath_hostLp
,
278 HvLpEvent_Type_VirtualIo
, cmd
,
279 HvLpEvent_AckInd_DoAck
,
280 HvLpEvent_AckType_ImmediateAck
,
281 viopath_sourceinst(viopath_hostLp
),
282 viopath_targetinst(viopath_hostLp
),
283 (u64
)req
, VIOVERSION
<< 16,
284 ((u64
)DEVICE_NR(diskinfo
) << 48) | dmaaddr
,
285 (u64
)blk_rq_pos(req
) * 512, len
, 0);
286 if (hvrc
!= HvLpEvent_Rc_Good
) {
287 printk(VIOCD_KERN_WARNING
"hv error on op %d\n", (int)hvrc
);
296 static void do_viocd_request(struct request_queue
*q
)
300 while ((rwreq
== 0) && ((req
= blk_fetch_request(q
)) != NULL
)) {
301 if (!blk_fs_request(req
))
302 __blk_end_request_all(req
, -EIO
);
303 else if (send_request(req
) < 0) {
304 printk(VIOCD_KERN_WARNING
305 "unable to send message to OS/400!");
306 __blk_end_request_all(req
, -EIO
);
312 static int viocd_media_changed(struct cdrom_device_info
*cdi
, int disc_nr
)
314 struct viocd_waitevent we
;
316 int device_no
= DEVICE_NR((struct disk_info
*)cdi
->handle
);
318 init_completion(&we
.com
);
320 /* Send the open event to OS/400 */
321 hvrc
= HvCallEvent_signalLpEventFast(viopath_hostLp
,
322 HvLpEvent_Type_VirtualIo
,
323 viomajorsubtype_cdio
| viocdcheck
,
324 HvLpEvent_AckInd_DoAck
, HvLpEvent_AckType_ImmediateAck
,
325 viopath_sourceinst(viopath_hostLp
),
326 viopath_targetinst(viopath_hostLp
),
327 (u64
)&we
, VIOVERSION
<< 16, ((u64
)device_no
<< 48),
330 printk(VIOCD_KERN_WARNING
"bad rc on HvCallEvent_signalLpEventFast %d\n",
335 wait_for_completion(&we
.com
);
337 /* Check the return code. If bad, assume no change */
339 const struct vio_error_entry
*err
=
340 vio_lookup_rc(viocd_err_table
, we
.sub_result
);
341 printk(VIOCD_KERN_WARNING
342 "bad rc %d:0x%04X on check_change: %s; Assuming no change\n",
343 we
.rc
, we
.sub_result
, err
->msg
);
350 static int viocd_lock_door(struct cdrom_device_info
*cdi
, int locking
)
353 u64 device_no
= DEVICE_NR((struct disk_info
*)cdi
->handle
);
354 /* NOTE: flags is 1 or 0 so it won't overwrite the device_no */
355 u64 flags
= !!locking
;
356 struct viocd_waitevent we
;
358 init_completion(&we
.com
);
360 /* Send the lockdoor event to OS/400 */
361 hvrc
= HvCallEvent_signalLpEventFast(viopath_hostLp
,
362 HvLpEvent_Type_VirtualIo
,
363 viomajorsubtype_cdio
| viocdlockdoor
,
364 HvLpEvent_AckInd_DoAck
, HvLpEvent_AckType_ImmediateAck
,
365 viopath_sourceinst(viopath_hostLp
),
366 viopath_targetinst(viopath_hostLp
),
367 (u64
)&we
, VIOVERSION
<< 16,
368 (device_no
<< 48) | (flags
<< 32), 0, 0, 0);
370 printk(VIOCD_KERN_WARNING
"bad rc on HvCallEvent_signalLpEventFast %d\n",
375 wait_for_completion(&we
.com
);
382 static int viocd_packet(struct cdrom_device_info
*cdi
,
383 struct packet_command
*cgc
)
385 unsigned int buflen
= cgc
->buflen
;
388 switch (cgc
->cmd
[0]) {
389 case GPCMD_READ_DISC_INFO
:
391 disc_information
*di
= (disc_information
*)cgc
->buffer
;
394 di
->disc_information_length
= cpu_to_be16(1);
399 (cdi
->ops
->capability
& ~cdi
->mask
400 & (CDC_DVD_RAM
| CDC_RAM
)) != 0;
403 case GPCMD_GET_CONFIGURATION
:
404 if (cgc
->cmd
[3] == CDF_RWRT
) {
405 struct rwrt_feature_desc
*rfd
= (struct rwrt_feature_desc
*)(cgc
->buffer
+ sizeof(struct feature_header
));
408 (sizeof(struct feature_header
) + sizeof(*rfd
))) &&
409 (cdi
->ops
->capability
& ~cdi
->mask
410 & (CDC_DVD_RAM
| CDC_RAM
))) {
411 rfd
->feature_code
= cpu_to_be16(CDF_RWRT
);
419 /* indicate Unknown code */
420 cgc
->sense
->sense_key
= 0x05;
421 cgc
->sense
->asc
= 0x20;
422 cgc
->sense
->ascq
= 0x00;
431 static void restart_all_queues(int first_index
)
435 for (i
= first_index
+ 1; i
< viocd_numdev
; i
++)
436 if (viocd_diskinfo
[i
].viocd_disk
)
437 blk_run_queue(viocd_diskinfo
[i
].viocd_disk
->queue
);
438 for (i
= 0; i
<= first_index
; i
++)
439 if (viocd_diskinfo
[i
].viocd_disk
)
440 blk_run_queue(viocd_diskinfo
[i
].viocd_disk
->queue
);
443 /* This routine handles incoming CD LP events */
444 static void vio_handle_cd_event(struct HvLpEvent
*event
)
446 struct viocdlpevent
*bevent
;
447 struct viocd_waitevent
*pwe
;
448 struct disk_info
*di
;
454 /* Notification that a partition went away! */
456 /* First, we should NEVER get an int here...only acks */
457 if (hvlpevent_is_int(event
)) {
458 printk(VIOCD_KERN_WARNING
459 "Yikes! got an int in viocd event handler!\n");
460 if (hvlpevent_need_ack(event
)) {
461 event
->xRc
= HvLpEvent_Rc_InvalidSubtype
;
462 HvCallEvent_ackLpEvent(event
);
466 bevent
= (struct viocdlpevent
*)event
;
468 switch (event
->xSubtype
& VIOMINOR_SUBTYPE_MASK
) {
470 if (event
->xRc
== 0) {
471 di
= &viocd_diskinfo
[bevent
->disk
];
472 blk_queue_hardsect_size(di
->viocd_disk
->queue
,
474 set_capacity(di
->viocd_disk
,
476 bevent
->block_size
/ 512);
480 pwe
= (struct viocd_waitevent
*)event
->xCorrelationToken
;
482 pwe
->rc
= event
->xRc
;
483 pwe
->sub_result
= bevent
->sub_result
;
488 pwe
= (struct viocd_waitevent
*)event
->xCorrelationToken
;
489 pwe
->changed
= bevent
->flags
;
490 goto return_complete
;
498 * Since this is running in interrupt mode, we need to
499 * make sure we're not stepping on any global I/O operations
501 di
= &viocd_diskinfo
[bevent
->disk
];
502 spin_lock_irqsave(&viocd_reqlock
, flags
);
503 dma_unmap_single(di
->dev
, bevent
->token
, bevent
->len
,
504 ((event
->xSubtype
& VIOMINOR_SUBTYPE_MASK
) == viocdread
)
505 ? DMA_FROM_DEVICE
: DMA_TO_DEVICE
);
506 req
= (struct request
*)bevent
->event
.xCorrelationToken
;
509 if (event
->xRc
!= HvLpEvent_Rc_Good
) {
510 const struct vio_error_entry
*err
=
511 vio_lookup_rc(viocd_err_table
,
513 printk(VIOCD_KERN_WARNING
"request %p failed "
514 "with rc %d:0x%04X: %s\n",
516 bevent
->sub_result
, err
->msg
);
517 __blk_end_request_all(req
, -EIO
);
519 __blk_end_request_all(req
, 0);
521 /* restart handling of incoming requests */
522 spin_unlock_irqrestore(&viocd_reqlock
, flags
);
523 restart_all_queues(bevent
->disk
);
527 printk(VIOCD_KERN_WARNING
528 "message with invalid subtype %0x04X!\n",
529 event
->xSubtype
& VIOMINOR_SUBTYPE_MASK
);
530 if (hvlpevent_need_ack(event
)) {
531 event
->xRc
= HvLpEvent_Rc_InvalidSubtype
;
532 HvCallEvent_ackLpEvent(event
);
537 static int viocd_audio_ioctl(struct cdrom_device_info
*cdi
, unsigned int cmd
,
543 static struct cdrom_device_ops viocd_dops
= {
545 .release
= viocd_release
,
546 .media_changed
= viocd_media_changed
,
547 .lock_door
= viocd_lock_door
,
548 .generic_packet
= viocd_packet
,
549 .audio_ioctl
= viocd_audio_ioctl
,
550 .capability
= CDC_CLOSE_TRAY
| CDC_OPEN_TRAY
| CDC_LOCK
| CDC_SELECT_SPEED
| CDC_SELECT_DISC
| CDC_MULTI_SESSION
| CDC_MCN
| CDC_MEDIA_CHANGED
| CDC_PLAY_AUDIO
| CDC_RESET
| CDC_DRIVE_STATUS
| CDC_GENERIC_PACKET
| CDC_CD_R
| CDC_CD_RW
| CDC_DVD
| CDC_DVD_R
| CDC_DVD_RAM
| CDC_RAM
553 static int find_capability(const char *type
)
555 struct capability_entry
*entry
;
557 for(entry
= capability_table
; entry
->type
; ++entry
)
558 if(!strncmp(entry
->type
, type
, 4))
560 return entry
->capability
;
563 static int viocd_probe(struct vio_dev
*vdev
, const struct vio_device_id
*id
)
565 struct gendisk
*gendisk
;
568 struct cdrom_device_info
*c
;
569 struct request_queue
*q
;
570 struct device_node
*node
= vdev
->dev
.archdata
.of_node
;
572 deviceno
= vdev
->unit_address
;
573 if (deviceno
>= VIOCD_MAX_CD
)
578 if (deviceno
>= viocd_numdev
)
579 viocd_numdev
= deviceno
+ 1;
581 d
= &viocd_diskinfo
[deviceno
];
582 d
->rsrcname
= of_get_property(node
, "linux,vio_rsrcname", NULL
);
583 d
->type
= of_get_property(node
, "linux,vio_type", NULL
);
584 d
->model
= of_get_property(node
, "linux,vio_model", NULL
);
588 c
->ops
= &viocd_dops
;
592 c
->mask
= ~find_capability(d
->type
);
593 sprintf(c
->name
, VIOCD_DEVICE
"%c", 'a' + deviceno
);
595 if (register_cdrom(c
) != 0) {
596 printk(VIOCD_KERN_WARNING
"Cannot register viocd CD-ROM %s!\n",
600 printk(VIOCD_KERN_INFO
"cd %s is iSeries resource %10.10s "
601 "type %4.4s, model %3.3s\n",
602 c
->name
, d
->rsrcname
, d
->type
, d
->model
);
603 q
= blk_init_queue(do_viocd_request
, &viocd_reqlock
);
605 printk(VIOCD_KERN_WARNING
"Cannot allocate queue for %s!\n",
607 goto out_unregister_cdrom
;
609 gendisk
= alloc_disk(1);
610 if (gendisk
== NULL
) {
611 printk(VIOCD_KERN_WARNING
"Cannot create gendisk for %s!\n",
613 goto out_cleanup_queue
;
615 gendisk
->major
= VIOCD_MAJOR
;
616 gendisk
->first_minor
= deviceno
;
617 strncpy(gendisk
->disk_name
, c
->name
,
618 sizeof(gendisk
->disk_name
));
619 blk_queue_max_hw_segments(q
, 1);
620 blk_queue_max_phys_segments(q
, 1);
621 blk_queue_max_sectors(q
, 4096 / 512);
623 gendisk
->fops
= &viocd_fops
;
624 gendisk
->flags
= GENHD_FL_CD
|GENHD_FL_REMOVABLE
;
625 set_capacity(gendisk
, 0);
626 gendisk
->private_data
= d
;
627 d
->viocd_disk
= gendisk
;
629 gendisk
->driverfs_dev
= d
->dev
;
634 blk_cleanup_queue(q
);
635 out_unregister_cdrom
:
641 static int viocd_remove(struct vio_dev
*vdev
)
643 struct disk_info
*d
= &viocd_diskinfo
[vdev
->unit_address
];
645 unregister_cdrom(&d
->viocd_info
);
646 del_gendisk(d
->viocd_disk
);
647 blk_cleanup_queue(d
->viocd_disk
->queue
);
648 put_disk(d
->viocd_disk
);
653 * viocd_device_table: Used by vio.c to match devices that we
656 static struct vio_device_id viocd_device_table
[] __devinitdata
= {
657 { "block", "IBM,iSeries-viocd" },
660 MODULE_DEVICE_TABLE(vio
, viocd_device_table
);
662 static struct vio_driver viocd_driver
= {
663 .id_table
= viocd_device_table
,
664 .probe
= viocd_probe
,
665 .remove
= viocd_remove
,
668 .owner
= THIS_MODULE
,
672 static int __init
viocd_init(void)
676 if (!firmware_has_feature(FW_FEATURE_ISERIES
))
679 if (viopath_hostLp
== HvLpIndexInvalid
) {
681 /* If we don't have a host, bail out */
682 if (viopath_hostLp
== HvLpIndexInvalid
)
686 printk(VIOCD_KERN_INFO
"vers " VIOCD_VERS
", hosting partition %d\n",
689 if (register_blkdev(VIOCD_MAJOR
, VIOCD_DEVICE
) != 0) {
690 printk(VIOCD_KERN_WARNING
"Unable to get major %d for %s\n",
691 VIOCD_MAJOR
, VIOCD_DEVICE
);
695 ret
= viopath_open(viopath_hostLp
, viomajorsubtype_cdio
,
698 printk(VIOCD_KERN_WARNING
699 "error opening path to host partition %d\n",
704 /* Initialize our request handler */
705 vio_setHandler(viomajorsubtype_cdio
, vio_handle_cd_event
);
707 spin_lock_init(&viocd_reqlock
);
709 ret
= vio_register_driver(&viocd_driver
);
713 proc_create("iSeries/viocd", S_IFREG
|S_IRUGO
, NULL
,
714 &proc_viocd_operations
);
718 vio_clearHandler(viomajorsubtype_cdio
);
719 viopath_close(viopath_hostLp
, viomajorsubtype_cdio
, MAX_CD_REQ
+ 2);
721 unregister_blkdev(VIOCD_MAJOR
, VIOCD_DEVICE
);
725 static void __exit
viocd_exit(void)
727 remove_proc_entry("iSeries/viocd", NULL
);
728 vio_unregister_driver(&viocd_driver
);
729 viopath_close(viopath_hostLp
, viomajorsubtype_cdio
, MAX_CD_REQ
+ 2);
730 vio_clearHandler(viomajorsubtype_cdio
);
731 unregister_blkdev(VIOCD_MAJOR
, VIOCD_DEVICE
);
734 module_init(viocd_init
);
735 module_exit(viocd_exit
);
736 MODULE_LICENSE("GPL");