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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
36 #include <linux/major.h>
37 #include <linux/blkdev.h>
38 #include <linux/cdrom.h>
39 #include <linux/errno.h>
40 #include <linux/init.h>
41 #include <linux/dma-mapping.h>
42 #include <linux/module.h>
43 #include <linux/completion.h>
44 #include <linux/proc_fs.h>
45 #include <linux/mutex.h>
46 #include <linux/seq_file.h>
47 #include <linux/scatterlist.h>
50 #include <asm/iseries/hv_types.h>
51 #include <asm/iseries/hv_lp_event.h>
52 #include <asm/iseries/vio.h>
53 #include <asm/firmware.h>
55 #define VIOCD_DEVICE "iseries/vcd"
57 #define VIOCD_VERS "1.06"
60 * Should probably make this a module parameter....sigh
62 #define VIOCD_MAX_CD HVMAXARCHITECTEDVIRTUALCDROMS
64 static DEFINE_MUTEX(viocd_mutex
);
65 static const struct vio_error_entry viocd_err_table
[] = {
66 {0x0201, EINVAL
, "Invalid Range"},
67 {0x0202, EINVAL
, "Invalid Token"},
68 {0x0203, EIO
, "DMA Error"},
69 {0x0204, EIO
, "Use Error"},
70 {0x0205, EIO
, "Release Error"},
71 {0x0206, EINVAL
, "Invalid CD"},
72 {0x020C, EROFS
, "Read Only Device"},
73 {0x020D, ENOMEDIUM
, "Changed or Missing Volume (or Varied Off?)"},
74 {0x020E, EIO
, "Optical System Error (Varied Off?)"},
75 {0x02FF, EIO
, "Internal Error"},
76 {0x3010, EIO
, "Changed Volume"},
77 {0xC100, EIO
, "Optical System Error"},
82 * This is the structure we use to exchange info between driver and interrupt
85 struct viocd_waitevent
{
86 struct completion com
;
92 /* this is a lookup table for the true capabilities of a device */
93 struct capability_entry
{
98 static struct capability_entry capability_table
[] __initdata
= {
99 { "6330", CDC_LOCK
| CDC_DVD_RAM
| CDC_RAM
},
100 { "6331", CDC_LOCK
| CDC_DVD_RAM
| CDC_RAM
},
101 { "6333", CDC_LOCK
| CDC_DVD_RAM
| CDC_RAM
},
102 { "632A", CDC_LOCK
| CDC_DVD_RAM
| CDC_RAM
},
103 { "6321", CDC_LOCK
},
108 /* These are our internal structures for keeping track of devices */
109 static int viocd_numdev
;
112 struct gendisk
*viocd_disk
;
113 struct cdrom_device_info viocd_info
;
115 const char *rsrcname
;
119 static struct disk_info viocd_diskinfo
[VIOCD_MAX_CD
];
121 #define DEVICE_NR(di) ((di) - &viocd_diskinfo[0])
123 static spinlock_t viocd_reqlock
;
128 static int proc_viocd_show(struct seq_file
*m
, void *v
)
132 for (i
= 0; i
< viocd_numdev
; i
++) {
133 seq_printf(m
, "viocd device %d is iSeries resource %10.10s"
134 "type %4.4s, model %3.3s\n",
135 i
, viocd_diskinfo
[i
].rsrcname
,
136 viocd_diskinfo
[i
].type
,
137 viocd_diskinfo
[i
].model
);
142 static int proc_viocd_open(struct inode
*inode
, struct file
*file
)
144 return single_open(file
, proc_viocd_show
, NULL
);
147 static const struct file_operations proc_viocd_operations
= {
148 .owner
= THIS_MODULE
,
149 .open
= proc_viocd_open
,
152 .release
= single_release
,
155 static int viocd_blk_open(struct block_device
*bdev
, fmode_t mode
)
157 struct disk_info
*di
= bdev
->bd_disk
->private_data
;
160 mutex_lock(&viocd_mutex
);
161 ret
= cdrom_open(&di
->viocd_info
, bdev
, mode
);
162 mutex_unlock(&viocd_mutex
);
167 static int viocd_blk_release(struct gendisk
*disk
, fmode_t mode
)
169 struct disk_info
*di
= disk
->private_data
;
170 mutex_lock(&viocd_mutex
);
171 cdrom_release(&di
->viocd_info
, mode
);
172 mutex_unlock(&viocd_mutex
);
176 static int viocd_blk_ioctl(struct block_device
*bdev
, fmode_t mode
,
177 unsigned cmd
, unsigned long arg
)
179 struct disk_info
*di
= bdev
->bd_disk
->private_data
;
182 mutex_lock(&viocd_mutex
);
183 ret
= cdrom_ioctl(&di
->viocd_info
, bdev
, mode
, cmd
, arg
);
184 mutex_unlock(&viocd_mutex
);
189 static int viocd_blk_media_changed(struct gendisk
*disk
)
191 struct disk_info
*di
= disk
->private_data
;
192 return cdrom_media_changed(&di
->viocd_info
);
195 static const struct block_device_operations viocd_fops
= {
196 .owner
= THIS_MODULE
,
197 .open
= viocd_blk_open
,
198 .release
= viocd_blk_release
,
199 .ioctl
= viocd_blk_ioctl
,
200 .media_changed
= viocd_blk_media_changed
,
203 static int viocd_open(struct cdrom_device_info
*cdi
, int purpose
)
205 struct disk_info
*diskinfo
= cdi
->handle
;
206 int device_no
= DEVICE_NR(diskinfo
);
208 struct viocd_waitevent we
;
210 init_completion(&we
.com
);
211 hvrc
= HvCallEvent_signalLpEventFast(viopath_hostLp
,
212 HvLpEvent_Type_VirtualIo
,
213 viomajorsubtype_cdio
| viocdopen
,
214 HvLpEvent_AckInd_DoAck
, HvLpEvent_AckType_ImmediateAck
,
215 viopath_sourceinst(viopath_hostLp
),
216 viopath_targetinst(viopath_hostLp
),
217 (u64
)&we
, VIOVERSION
<< 16, ((u64
)device_no
<< 48),
220 pr_warning("bad rc on HvCallEvent_signalLpEventFast %d\n",
225 wait_for_completion(&we
.com
);
228 const struct vio_error_entry
*err
=
229 vio_lookup_rc(viocd_err_table
, we
.sub_result
);
230 pr_warning("bad rc %d:0x%04X on open: %s\n",
231 we
.rc
, we
.sub_result
, err
->msg
);
238 static void viocd_release(struct cdrom_device_info
*cdi
)
240 int device_no
= DEVICE_NR((struct disk_info
*)cdi
->handle
);
243 hvrc
= HvCallEvent_signalLpEventFast(viopath_hostLp
,
244 HvLpEvent_Type_VirtualIo
,
245 viomajorsubtype_cdio
| viocdclose
,
246 HvLpEvent_AckInd_NoAck
, HvLpEvent_AckType_ImmediateAck
,
247 viopath_sourceinst(viopath_hostLp
),
248 viopath_targetinst(viopath_hostLp
), 0,
249 VIOVERSION
<< 16, ((u64
)device_no
<< 48), 0, 0, 0);
251 pr_warning("bad rc on HvCallEvent_signalLpEventFast %d\n",
255 /* Send a read or write request to OS/400 */
256 static int send_request(struct request
*req
)
259 struct disk_info
*diskinfo
= req
->rq_disk
->private_data
;
264 struct scatterlist sg
;
266 BUG_ON(req
->nr_phys_segments
> 1);
268 if (rq_data_dir(req
) == READ
) {
269 direction
= DMA_FROM_DEVICE
;
270 cmd
= viomajorsubtype_cdio
| viocdread
;
272 direction
= DMA_TO_DEVICE
;
273 cmd
= viomajorsubtype_cdio
| viocdwrite
;
276 sg_init_table(&sg
, 1);
277 if (blk_rq_map_sg(req
->q
, req
, &sg
) == 0) {
278 pr_warning("error setting up scatter/gather list\n");
282 if (dma_map_sg(diskinfo
->dev
, &sg
, 1, direction
) == 0) {
283 pr_warning("error allocating sg tce\n");
286 dmaaddr
= sg_dma_address(&sg
);
287 len
= sg_dma_len(&sg
);
289 hvrc
= HvCallEvent_signalLpEventFast(viopath_hostLp
,
290 HvLpEvent_Type_VirtualIo
, cmd
,
291 HvLpEvent_AckInd_DoAck
,
292 HvLpEvent_AckType_ImmediateAck
,
293 viopath_sourceinst(viopath_hostLp
),
294 viopath_targetinst(viopath_hostLp
),
295 (u64
)req
, VIOVERSION
<< 16,
296 ((u64
)DEVICE_NR(diskinfo
) << 48) | dmaaddr
,
297 (u64
)blk_rq_pos(req
) * 512, len
, 0);
298 if (hvrc
!= HvLpEvent_Rc_Good
) {
299 pr_warning("hv error on op %d\n", (int)hvrc
);
308 static void do_viocd_request(struct request_queue
*q
)
312 while ((rwreq
== 0) && ((req
= blk_fetch_request(q
)) != NULL
)) {
313 if (req
->cmd_type
!= REQ_TYPE_FS
)
314 __blk_end_request_all(req
, -EIO
);
315 else if (send_request(req
) < 0) {
316 pr_warning("unable to send message to OS/400!\n");
317 __blk_end_request_all(req
, -EIO
);
323 static int viocd_media_changed(struct cdrom_device_info
*cdi
, int disc_nr
)
325 struct viocd_waitevent we
;
327 int device_no
= DEVICE_NR((struct disk_info
*)cdi
->handle
);
329 init_completion(&we
.com
);
331 /* Send the open event to OS/400 */
332 hvrc
= HvCallEvent_signalLpEventFast(viopath_hostLp
,
333 HvLpEvent_Type_VirtualIo
,
334 viomajorsubtype_cdio
| viocdcheck
,
335 HvLpEvent_AckInd_DoAck
, HvLpEvent_AckType_ImmediateAck
,
336 viopath_sourceinst(viopath_hostLp
),
337 viopath_targetinst(viopath_hostLp
),
338 (u64
)&we
, VIOVERSION
<< 16, ((u64
)device_no
<< 48),
341 pr_warning("bad rc on HvCallEvent_signalLpEventFast %d\n",
346 wait_for_completion(&we
.com
);
348 /* Check the return code. If bad, assume no change */
350 const struct vio_error_entry
*err
=
351 vio_lookup_rc(viocd_err_table
, we
.sub_result
);
352 pr_warning("bad rc %d:0x%04X on check_change: %s; Assuming no change\n",
353 we
.rc
, we
.sub_result
, err
->msg
);
360 static int viocd_lock_door(struct cdrom_device_info
*cdi
, int locking
)
363 u64 device_no
= DEVICE_NR((struct disk_info
*)cdi
->handle
);
364 /* NOTE: flags is 1 or 0 so it won't overwrite the device_no */
365 u64 flags
= !!locking
;
366 struct viocd_waitevent we
;
368 init_completion(&we
.com
);
370 /* Send the lockdoor event to OS/400 */
371 hvrc
= HvCallEvent_signalLpEventFast(viopath_hostLp
,
372 HvLpEvent_Type_VirtualIo
,
373 viomajorsubtype_cdio
| viocdlockdoor
,
374 HvLpEvent_AckInd_DoAck
, HvLpEvent_AckType_ImmediateAck
,
375 viopath_sourceinst(viopath_hostLp
),
376 viopath_targetinst(viopath_hostLp
),
377 (u64
)&we
, VIOVERSION
<< 16,
378 (device_no
<< 48) | (flags
<< 32), 0, 0, 0);
380 pr_warning("bad rc on HvCallEvent_signalLpEventFast %d\n",
385 wait_for_completion(&we
.com
);
392 static int viocd_packet(struct cdrom_device_info
*cdi
,
393 struct packet_command
*cgc
)
395 unsigned int buflen
= cgc
->buflen
;
398 switch (cgc
->cmd
[0]) {
399 case GPCMD_READ_DISC_INFO
:
401 disc_information
*di
= (disc_information
*)cgc
->buffer
;
404 di
->disc_information_length
= cpu_to_be16(1);
409 (cdi
->ops
->capability
& ~cdi
->mask
410 & (CDC_DVD_RAM
| CDC_RAM
)) != 0;
413 case GPCMD_GET_CONFIGURATION
:
414 if (cgc
->cmd
[3] == CDF_RWRT
) {
415 struct rwrt_feature_desc
*rfd
= (struct rwrt_feature_desc
*)(cgc
->buffer
+ sizeof(struct feature_header
));
418 (sizeof(struct feature_header
) + sizeof(*rfd
))) &&
419 (cdi
->ops
->capability
& ~cdi
->mask
420 & (CDC_DVD_RAM
| CDC_RAM
))) {
421 rfd
->feature_code
= cpu_to_be16(CDF_RWRT
);
429 /* indicate Unknown code */
430 cgc
->sense
->sense_key
= 0x05;
431 cgc
->sense
->asc
= 0x20;
432 cgc
->sense
->ascq
= 0x00;
441 static void restart_all_queues(int first_index
)
445 for (i
= first_index
+ 1; i
< viocd_numdev
; i
++)
446 if (viocd_diskinfo
[i
].viocd_disk
)
447 blk_run_queue(viocd_diskinfo
[i
].viocd_disk
->queue
);
448 for (i
= 0; i
<= first_index
; i
++)
449 if (viocd_diskinfo
[i
].viocd_disk
)
450 blk_run_queue(viocd_diskinfo
[i
].viocd_disk
->queue
);
453 /* This routine handles incoming CD LP events */
454 static void vio_handle_cd_event(struct HvLpEvent
*event
)
456 struct viocdlpevent
*bevent
;
457 struct viocd_waitevent
*pwe
;
458 struct disk_info
*di
;
464 /* Notification that a partition went away! */
466 /* First, we should NEVER get an int here...only acks */
467 if (hvlpevent_is_int(event
)) {
468 pr_warning("Yikes! got an int in viocd event handler!\n");
469 if (hvlpevent_need_ack(event
)) {
470 event
->xRc
= HvLpEvent_Rc_InvalidSubtype
;
471 HvCallEvent_ackLpEvent(event
);
475 bevent
= (struct viocdlpevent
*)event
;
477 switch (event
->xSubtype
& VIOMINOR_SUBTYPE_MASK
) {
479 if (event
->xRc
== 0) {
480 di
= &viocd_diskinfo
[bevent
->disk
];
481 blk_queue_logical_block_size(di
->viocd_disk
->queue
,
483 set_capacity(di
->viocd_disk
,
485 bevent
->block_size
/ 512);
489 pwe
= (struct viocd_waitevent
*)event
->xCorrelationToken
;
491 pwe
->rc
= event
->xRc
;
492 pwe
->sub_result
= bevent
->sub_result
;
497 pwe
= (struct viocd_waitevent
*)event
->xCorrelationToken
;
498 pwe
->changed
= bevent
->flags
;
499 goto return_complete
;
507 * Since this is running in interrupt mode, we need to
508 * make sure we're not stepping on any global I/O operations
510 di
= &viocd_diskinfo
[bevent
->disk
];
511 spin_lock_irqsave(&viocd_reqlock
, flags
);
512 dma_unmap_single(di
->dev
, bevent
->token
, bevent
->len
,
513 ((event
->xSubtype
& VIOMINOR_SUBTYPE_MASK
) == viocdread
)
514 ? DMA_FROM_DEVICE
: DMA_TO_DEVICE
);
515 req
= (struct request
*)bevent
->event
.xCorrelationToken
;
518 if (event
->xRc
!= HvLpEvent_Rc_Good
) {
519 const struct vio_error_entry
*err
=
520 vio_lookup_rc(viocd_err_table
,
522 pr_warning("request %p failed with rc %d:0x%04X: %s\n",
524 bevent
->sub_result
, err
->msg
);
525 __blk_end_request_all(req
, -EIO
);
527 __blk_end_request_all(req
, 0);
529 /* restart handling of incoming requests */
530 spin_unlock_irqrestore(&viocd_reqlock
, flags
);
531 restart_all_queues(bevent
->disk
);
535 pr_warning("message with invalid subtype %0x04X!\n",
536 event
->xSubtype
& VIOMINOR_SUBTYPE_MASK
);
537 if (hvlpevent_need_ack(event
)) {
538 event
->xRc
= HvLpEvent_Rc_InvalidSubtype
;
539 HvCallEvent_ackLpEvent(event
);
544 static int viocd_audio_ioctl(struct cdrom_device_info
*cdi
, unsigned int cmd
,
550 static struct cdrom_device_ops viocd_dops
= {
552 .release
= viocd_release
,
553 .media_changed
= viocd_media_changed
,
554 .lock_door
= viocd_lock_door
,
555 .generic_packet
= viocd_packet
,
556 .audio_ioctl
= viocd_audio_ioctl
,
557 .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
560 static int find_capability(const char *type
)
562 struct capability_entry
*entry
;
564 for(entry
= capability_table
; entry
->type
; ++entry
)
565 if(!strncmp(entry
->type
, type
, 4))
567 return entry
->capability
;
570 static int viocd_probe(struct vio_dev
*vdev
, const struct vio_device_id
*id
)
572 struct gendisk
*gendisk
;
575 struct cdrom_device_info
*c
;
576 struct request_queue
*q
;
577 struct device_node
*node
= vdev
->dev
.of_node
;
579 deviceno
= vdev
->unit_address
;
580 if (deviceno
>= VIOCD_MAX_CD
)
585 if (deviceno
>= viocd_numdev
)
586 viocd_numdev
= deviceno
+ 1;
588 d
= &viocd_diskinfo
[deviceno
];
589 d
->rsrcname
= of_get_property(node
, "linux,vio_rsrcname", NULL
);
590 d
->type
= of_get_property(node
, "linux,vio_type", NULL
);
591 d
->model
= of_get_property(node
, "linux,vio_model", NULL
);
595 c
->ops
= &viocd_dops
;
599 c
->mask
= ~find_capability(d
->type
);
600 sprintf(c
->name
, VIOCD_DEVICE
"%c", 'a' + deviceno
);
602 if (register_cdrom(c
) != 0) {
603 pr_warning("Cannot register viocd CD-ROM %s!\n", c
->name
);
606 pr_info("cd %s is iSeries resource %10.10s type %4.4s, model %3.3s\n",
607 c
->name
, d
->rsrcname
, d
->type
, d
->model
);
608 q
= blk_init_queue(do_viocd_request
, &viocd_reqlock
);
610 pr_warning("Cannot allocate queue for %s!\n", c
->name
);
611 goto out_unregister_cdrom
;
613 gendisk
= alloc_disk(1);
614 if (gendisk
== NULL
) {
615 pr_warning("Cannot create gendisk for %s!\n", c
->name
);
616 goto out_cleanup_queue
;
618 gendisk
->major
= VIOCD_MAJOR
;
619 gendisk
->first_minor
= deviceno
;
620 strncpy(gendisk
->disk_name
, c
->name
,
621 sizeof(gendisk
->disk_name
));
622 blk_queue_max_segments(q
, 1);
623 blk_queue_max_hw_sectors(q
, 4096 / 512);
625 gendisk
->fops
= &viocd_fops
;
626 gendisk
->flags
= GENHD_FL_CD
|GENHD_FL_REMOVABLE
;
627 set_capacity(gendisk
, 0);
628 gendisk
->private_data
= d
;
629 d
->viocd_disk
= gendisk
;
631 gendisk
->driverfs_dev
= d
->dev
;
636 blk_cleanup_queue(q
);
637 out_unregister_cdrom
:
643 static int viocd_remove(struct vio_dev
*vdev
)
645 struct disk_info
*d
= &viocd_diskinfo
[vdev
->unit_address
];
647 unregister_cdrom(&d
->viocd_info
);
648 del_gendisk(d
->viocd_disk
);
649 blk_cleanup_queue(d
->viocd_disk
->queue
);
650 put_disk(d
->viocd_disk
);
655 * viocd_device_table: Used by vio.c to match devices that we
658 static struct vio_device_id viocd_device_table
[] __devinitdata
= {
659 { "block", "IBM,iSeries-viocd" },
662 MODULE_DEVICE_TABLE(vio
, viocd_device_table
);
664 static struct vio_driver viocd_driver
= {
665 .id_table
= viocd_device_table
,
666 .probe
= viocd_probe
,
667 .remove
= viocd_remove
,
670 .owner
= THIS_MODULE
,
674 static int __init
viocd_init(void)
678 if (!firmware_has_feature(FW_FEATURE_ISERIES
))
681 if (viopath_hostLp
== HvLpIndexInvalid
) {
683 /* If we don't have a host, bail out */
684 if (viopath_hostLp
== HvLpIndexInvalid
)
688 pr_info("vers " VIOCD_VERS
", hosting partition %d\n", viopath_hostLp
);
690 if (register_blkdev(VIOCD_MAJOR
, VIOCD_DEVICE
) != 0) {
691 pr_warning("Unable to get major %d for %s\n",
692 VIOCD_MAJOR
, VIOCD_DEVICE
);
696 ret
= viopath_open(viopath_hostLp
, viomajorsubtype_cdio
,
699 pr_warning("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");