1 /* sunvdc.c: Sun LDOM Virtual Disk Client.
3 * Copyright (C) 2007, 2008 David S. Miller <davem@davemloft.net>
6 #include <linux/module.h>
7 #include <linux/kernel.h>
8 #include <linux/types.h>
9 #include <linux/blkdev.h>
10 #include <linux/hdreg.h>
11 #include <linux/genhd.h>
12 #include <linux/cdrom.h>
13 #include <linux/slab.h>
14 #include <linux/spinlock.h>
15 #include <linux/completion.h>
16 #include <linux/delay.h>
17 #include <linux/init.h>
18 #include <linux/list.h>
19 #include <linux/scatterlist.h>
24 #define DRV_MODULE_NAME "sunvdc"
25 #define PFX DRV_MODULE_NAME ": "
26 #define DRV_MODULE_VERSION "1.1"
27 #define DRV_MODULE_RELDATE "February 13, 2013"
29 static char version
[] =
30 DRV_MODULE_NAME
".c:v" DRV_MODULE_VERSION
" (" DRV_MODULE_RELDATE
")\n";
31 MODULE_AUTHOR("David S. Miller (davem@davemloft.net)");
32 MODULE_DESCRIPTION("Sun LDOM virtual disk client driver");
33 MODULE_LICENSE("GPL");
34 MODULE_VERSION(DRV_MODULE_VERSION
);
36 #define VDC_TX_RING_SIZE 512
38 #define WAITING_FOR_LINK_UP 0x01
39 #define WAITING_FOR_TX_SPACE 0x02
40 #define WAITING_FOR_GEN_CMD 0x04
41 #define WAITING_FOR_ANY -1
43 struct vdc_req_entry
{
48 struct vio_driver_state vio
;
52 struct vdc_completion
*cmp
;
56 struct vdc_req_entry rq_arr
[VDC_TX_RING_SIZE
];
58 unsigned long ring_cookies
;
63 /* The server fills these in for us in the disk attribute
73 struct vio_disk_vtoc label
;
76 static inline struct vdc_port
*to_vdc_port(struct vio_driver_state
*vio
)
78 return container_of(vio
, struct vdc_port
, vio
);
81 /* Ordered from largest major to lowest */
82 static struct vio_version vdc_versions
[] = {
83 { .major
= 1, .minor
= 1 },
84 { .major
= 1, .minor
= 0 },
87 static inline int vdc_version_supported(struct vdc_port
*port
,
90 return port
->vio
.ver
.major
== major
&& port
->vio
.ver
.minor
>= minor
;
93 #define VDCBLK_NAME "vdisk"
95 #define PARTITION_SHIFT 3
97 static inline u32
vdc_tx_dring_avail(struct vio_dring_state
*dr
)
99 return vio_dring_avail(dr
, VDC_TX_RING_SIZE
);
102 static int vdc_getgeo(struct block_device
*bdev
, struct hd_geometry
*geo
)
104 struct gendisk
*disk
= bdev
->bd_disk
;
105 sector_t nsect
= get_capacity(disk
);
106 sector_t cylinders
= nsect
;
110 sector_div(cylinders
, geo
->heads
* geo
->sectors
);
111 geo
->cylinders
= cylinders
;
112 if ((sector_t
)(geo
->cylinders
+ 1) * geo
->heads
* geo
->sectors
< nsect
)
113 geo
->cylinders
= 0xffff;
118 /* Add ioctl/CDROM_GET_CAPABILITY to support cdrom_id in udev
119 * when vdisk_mtype is VD_MEDIA_TYPE_CD or VD_MEDIA_TYPE_DVD.
120 * Needed to be able to install inside an ldom from an iso image.
122 static int vdc_ioctl(struct block_device
*bdev
, fmode_t mode
,
123 unsigned command
, unsigned long argument
)
126 struct gendisk
*disk
;
129 case CDROMMULTISESSION
:
130 pr_debug(PFX
"Multisession CDs not supported\n");
131 for (i
= 0; i
< sizeof(struct cdrom_multisession
); i
++)
132 if (put_user(0, (char __user
*)(argument
+ i
)))
136 case CDROM_GET_CAPABILITY
:
137 disk
= bdev
->bd_disk
;
139 if (bdev
->bd_disk
&& (disk
->flags
& GENHD_FL_CD
))
144 pr_debug(PFX
"ioctl %08x not supported\n", command
);
149 static const struct block_device_operations vdc_fops
= {
150 .owner
= THIS_MODULE
,
151 .getgeo
= vdc_getgeo
,
155 static void vdc_finish(struct vio_driver_state
*vio
, int err
, int waiting_for
)
158 (waiting_for
== -1 ||
159 vio
->cmp
->waiting_for
== waiting_for
)) {
161 complete(&vio
->cmp
->com
);
166 static void vdc_handshake_complete(struct vio_driver_state
*vio
)
168 vdc_finish(vio
, 0, WAITING_FOR_LINK_UP
);
171 static int vdc_handle_unknown(struct vdc_port
*port
, void *arg
)
173 struct vio_msg_tag
*pkt
= arg
;
175 printk(KERN_ERR PFX
"Received unknown msg [%02x:%02x:%04x:%08x]\n",
176 pkt
->type
, pkt
->stype
, pkt
->stype_env
, pkt
->sid
);
177 printk(KERN_ERR PFX
"Resetting connection.\n");
179 ldc_disconnect(port
->vio
.lp
);
184 static int vdc_send_attr(struct vio_driver_state
*vio
)
186 struct vdc_port
*port
= to_vdc_port(vio
);
187 struct vio_disk_attr_info pkt
;
189 memset(&pkt
, 0, sizeof(pkt
));
191 pkt
.tag
.type
= VIO_TYPE_CTRL
;
192 pkt
.tag
.stype
= VIO_SUBTYPE_INFO
;
193 pkt
.tag
.stype_env
= VIO_ATTR_INFO
;
194 pkt
.tag
.sid
= vio_send_sid(vio
);
196 pkt
.xfer_mode
= VIO_DRING_MODE
;
197 pkt
.vdisk_block_size
= port
->vdisk_block_size
;
198 pkt
.max_xfer_size
= port
->max_xfer_size
;
200 viodbg(HS
, "SEND ATTR xfer_mode[0x%x] blksz[%u] max_xfer[%llu]\n",
201 pkt
.xfer_mode
, pkt
.vdisk_block_size
, pkt
.max_xfer_size
);
203 return vio_ldc_send(&port
->vio
, &pkt
, sizeof(pkt
));
206 static int vdc_handle_attr(struct vio_driver_state
*vio
, void *arg
)
208 struct vdc_port
*port
= to_vdc_port(vio
);
209 struct vio_disk_attr_info
*pkt
= arg
;
211 viodbg(HS
, "GOT ATTR stype[0x%x] ops[%llx] disk_size[%llu] disk_type[%x] "
212 "mtype[0x%x] xfer_mode[0x%x] blksz[%u] max_xfer[%llu]\n",
213 pkt
->tag
.stype
, pkt
->operations
,
214 pkt
->vdisk_size
, pkt
->vdisk_type
, pkt
->vdisk_mtype
,
215 pkt
->xfer_mode
, pkt
->vdisk_block_size
,
218 if (pkt
->tag
.stype
== VIO_SUBTYPE_ACK
) {
219 switch (pkt
->vdisk_type
) {
220 case VD_DISK_TYPE_DISK
:
221 case VD_DISK_TYPE_SLICE
:
225 printk(KERN_ERR PFX
"%s: Bogus vdisk_type 0x%x\n",
226 vio
->name
, pkt
->vdisk_type
);
230 if (pkt
->vdisk_block_size
> port
->vdisk_block_size
) {
231 printk(KERN_ERR PFX
"%s: BLOCK size increased "
234 port
->vdisk_block_size
, pkt
->vdisk_block_size
);
238 port
->operations
= pkt
->operations
;
239 port
->vdisk_type
= pkt
->vdisk_type
;
240 if (vdc_version_supported(port
, 1, 1)) {
241 port
->vdisk_size
= pkt
->vdisk_size
;
242 port
->vdisk_mtype
= pkt
->vdisk_mtype
;
244 if (pkt
->max_xfer_size
< port
->max_xfer_size
)
245 port
->max_xfer_size
= pkt
->max_xfer_size
;
246 port
->vdisk_block_size
= pkt
->vdisk_block_size
;
249 printk(KERN_ERR PFX
"%s: Attribute NACK\n", vio
->name
);
255 static void vdc_end_special(struct vdc_port
*port
, struct vio_disk_desc
*desc
)
257 int err
= desc
->status
;
259 vdc_finish(&port
->vio
, -err
, WAITING_FOR_GEN_CMD
);
262 static void vdc_end_one(struct vdc_port
*port
, struct vio_dring_state
*dr
,
265 struct vio_disk_desc
*desc
= vio_dring_entry(dr
, index
);
266 struct vdc_req_entry
*rqe
= &port
->rq_arr
[index
];
269 if (unlikely(desc
->hdr
.state
!= VIO_DESC_DONE
))
272 ldc_unmap(port
->vio
.lp
, desc
->cookies
, desc
->ncookies
);
273 desc
->hdr
.state
= VIO_DESC_FREE
;
274 dr
->cons
= (index
+ 1) & (VDC_TX_RING_SIZE
- 1);
278 vdc_end_special(port
, desc
);
284 __blk_end_request(req
, (desc
->status
? -EIO
: 0), desc
->size
);
286 /* restart blk queue when ring is half emptied */
287 if (blk_queue_stopped(port
->disk
->queue
) &&
288 vdc_tx_dring_avail(dr
) * 100 / VDC_TX_RING_SIZE
>= 50)
289 blk_start_queue(port
->disk
->queue
);
292 static int vdc_ack(struct vdc_port
*port
, void *msgbuf
)
294 struct vio_dring_state
*dr
= &port
->vio
.drings
[VIO_DRIVER_TX_RING
];
295 struct vio_dring_data
*pkt
= msgbuf
;
297 if (unlikely(pkt
->dring_ident
!= dr
->ident
||
298 pkt
->start_idx
!= pkt
->end_idx
||
299 pkt
->start_idx
>= VDC_TX_RING_SIZE
))
302 vdc_end_one(port
, dr
, pkt
->start_idx
);
307 static int vdc_nack(struct vdc_port
*port
, void *msgbuf
)
309 /* XXX Implement me XXX */
313 static void vdc_event(void *arg
, int event
)
315 struct vdc_port
*port
= arg
;
316 struct vio_driver_state
*vio
= &port
->vio
;
320 spin_lock_irqsave(&vio
->lock
, flags
);
322 if (unlikely(event
== LDC_EVENT_RESET
||
323 event
== LDC_EVENT_UP
)) {
324 vio_link_state_change(vio
, event
);
325 spin_unlock_irqrestore(&vio
->lock
, flags
);
329 if (unlikely(event
!= LDC_EVENT_DATA_READY
)) {
330 printk(KERN_WARNING PFX
"Unexpected LDC event %d\n", event
);
331 spin_unlock_irqrestore(&vio
->lock
, flags
);
338 struct vio_msg_tag tag
;
342 err
= ldc_read(vio
->lp
, &msgbuf
, sizeof(msgbuf
));
343 if (unlikely(err
< 0)) {
344 if (err
== -ECONNRESET
)
350 viodbg(DATA
, "TAG [%02x:%02x:%04x:%08x]\n",
353 msgbuf
.tag
.stype_env
,
355 err
= vio_validate_sid(vio
, &msgbuf
.tag
);
359 if (likely(msgbuf
.tag
.type
== VIO_TYPE_DATA
)) {
360 if (msgbuf
.tag
.stype
== VIO_SUBTYPE_ACK
)
361 err
= vdc_ack(port
, &msgbuf
);
362 else if (msgbuf
.tag
.stype
== VIO_SUBTYPE_NACK
)
363 err
= vdc_nack(port
, &msgbuf
);
365 err
= vdc_handle_unknown(port
, &msgbuf
);
366 } else if (msgbuf
.tag
.type
== VIO_TYPE_CTRL
) {
367 err
= vio_control_pkt_engine(vio
, &msgbuf
);
369 err
= vdc_handle_unknown(port
, &msgbuf
);
375 vdc_finish(&port
->vio
, err
, WAITING_FOR_ANY
);
376 spin_unlock_irqrestore(&vio
->lock
, flags
);
379 static int __vdc_tx_trigger(struct vdc_port
*port
)
381 struct vio_dring_state
*dr
= &port
->vio
.drings
[VIO_DRIVER_TX_RING
];
382 struct vio_dring_data hdr
= {
384 .type
= VIO_TYPE_DATA
,
385 .stype
= VIO_SUBTYPE_INFO
,
386 .stype_env
= VIO_DRING_DATA
,
387 .sid
= vio_send_sid(&port
->vio
),
389 .dring_ident
= dr
->ident
,
390 .start_idx
= dr
->prod
,
395 hdr
.seq
= dr
->snd_nxt
;
398 err
= vio_ldc_send(&port
->vio
, &hdr
, sizeof(hdr
));
404 if ((delay
<<= 1) > 128)
406 } while (err
== -EAGAIN
);
411 static int __send_request(struct request
*req
)
413 struct vdc_port
*port
= req
->rq_disk
->private_data
;
414 struct vio_dring_state
*dr
= &port
->vio
.drings
[VIO_DRIVER_TX_RING
];
415 struct scatterlist sg
[port
->ring_cookies
];
416 struct vdc_req_entry
*rqe
;
417 struct vio_disk_desc
*desc
;
418 unsigned int map_perm
;
423 map_perm
= LDC_MAP_SHADOW
| LDC_MAP_DIRECT
| LDC_MAP_IO
;
425 if (rq_data_dir(req
) == READ
) {
426 map_perm
|= LDC_MAP_W
;
429 map_perm
|= LDC_MAP_R
;
433 sg_init_table(sg
, port
->ring_cookies
);
434 nsg
= blk_rq_map_sg(req
->q
, req
, sg
);
437 for (i
= 0; i
< nsg
; i
++)
440 desc
= vio_dring_cur(dr
);
442 err
= ldc_map_sg(port
->vio
.lp
, sg
, nsg
,
443 desc
->cookies
, port
->ring_cookies
,
446 printk(KERN_ERR PFX
"ldc_map_sg() failure, err=%d.\n", err
);
450 rqe
= &port
->rq_arr
[dr
->prod
];
453 desc
->hdr
.ack
= VIO_ACK_ENABLE
;
454 desc
->req_id
= port
->req_id
;
455 desc
->operation
= op
;
456 if (port
->vdisk_type
== VD_DISK_TYPE_DISK
) {
462 desc
->offset
= (blk_rq_pos(req
) << 9) / port
->vdisk_block_size
;
464 desc
->ncookies
= err
;
466 /* This has to be a non-SMP write barrier because we are writing
467 * to memory which is shared with the peer LDOM.
470 desc
->hdr
.state
= VIO_DESC_READY
;
472 err
= __vdc_tx_trigger(port
);
474 printk(KERN_ERR PFX
"vdc_tx_trigger() failure, err=%d\n", err
);
477 dr
->prod
= (dr
->prod
+ 1) & (VDC_TX_RING_SIZE
- 1);
483 static void do_vdc_request(struct request_queue
*rq
)
487 while ((req
= blk_peek_request(rq
)) != NULL
) {
488 struct vdc_port
*port
;
489 struct vio_dring_state
*dr
;
491 port
= req
->rq_disk
->private_data
;
492 dr
= &port
->vio
.drings
[VIO_DRIVER_TX_RING
];
493 if (unlikely(vdc_tx_dring_avail(dr
) < 1))
496 blk_start_request(req
);
498 if (__send_request(req
) < 0) {
499 blk_requeue_request(rq
, req
);
501 /* Avoid pointless unplugs. */
508 static int generic_request(struct vdc_port
*port
, u8 op
, void *buf
, int len
)
510 struct vio_dring_state
*dr
;
511 struct vio_completion comp
;
512 struct vio_disk_desc
*desc
;
513 unsigned int map_perm
;
518 if (!(((u64
)1 << (u64
)op
) & port
->operations
))
533 op_len
= sizeof(u32
);
534 map_perm
= LDC_MAP_W
;
538 op_len
= sizeof(u32
);
539 map_perm
= LDC_MAP_R
;
543 op_len
= sizeof(struct vio_disk_vtoc
);
544 map_perm
= LDC_MAP_W
;
548 op_len
= sizeof(struct vio_disk_vtoc
);
549 map_perm
= LDC_MAP_R
;
552 case VD_OP_GET_DISKGEOM
:
553 op_len
= sizeof(struct vio_disk_geom
);
554 map_perm
= LDC_MAP_W
;
557 case VD_OP_SET_DISKGEOM
:
558 op_len
= sizeof(struct vio_disk_geom
);
559 map_perm
= LDC_MAP_R
;
564 map_perm
= LDC_MAP_RW
;
567 case VD_OP_GET_DEVID
:
568 op_len
= sizeof(struct vio_disk_devid
);
569 map_perm
= LDC_MAP_W
;
578 map_perm
|= LDC_MAP_SHADOW
| LDC_MAP_DIRECT
| LDC_MAP_IO
;
580 op_len
= (op_len
+ 7) & ~7;
581 req_buf
= kzalloc(op_len
, GFP_KERNEL
);
588 if (map_perm
& LDC_MAP_R
)
589 memcpy(req_buf
, buf
, len
);
591 spin_lock_irqsave(&port
->vio
.lock
, flags
);
593 dr
= &port
->vio
.drings
[VIO_DRIVER_TX_RING
];
595 /* XXX If we want to use this code generically we have to
596 * XXX handle TX ring exhaustion etc.
598 desc
= vio_dring_cur(dr
);
600 err
= ldc_map_single(port
->vio
.lp
, req_buf
, op_len
,
601 desc
->cookies
, port
->ring_cookies
,
604 spin_unlock_irqrestore(&port
->vio
.lock
, flags
);
609 init_completion(&comp
.com
);
610 comp
.waiting_for
= WAITING_FOR_GEN_CMD
;
611 port
->vio
.cmp
= &comp
;
613 desc
->hdr
.ack
= VIO_ACK_ENABLE
;
614 desc
->req_id
= port
->req_id
;
615 desc
->operation
= op
;
620 desc
->ncookies
= err
;
622 /* This has to be a non-SMP write barrier because we are writing
623 * to memory which is shared with the peer LDOM.
626 desc
->hdr
.state
= VIO_DESC_READY
;
628 err
= __vdc_tx_trigger(port
);
631 dr
->prod
= (dr
->prod
+ 1) & (VDC_TX_RING_SIZE
- 1);
632 spin_unlock_irqrestore(&port
->vio
.lock
, flags
);
634 wait_for_completion(&comp
.com
);
637 port
->vio
.cmp
= NULL
;
638 spin_unlock_irqrestore(&port
->vio
.lock
, flags
);
641 if (map_perm
& LDC_MAP_W
)
642 memcpy(buf
, req_buf
, len
);
649 static int vdc_alloc_tx_ring(struct vdc_port
*port
)
651 struct vio_dring_state
*dr
= &port
->vio
.drings
[VIO_DRIVER_TX_RING
];
652 unsigned long len
, entry_size
;
656 entry_size
= sizeof(struct vio_disk_desc
) +
657 (sizeof(struct ldc_trans_cookie
) * port
->ring_cookies
);
658 len
= (VDC_TX_RING_SIZE
* entry_size
);
660 ncookies
= VIO_MAX_RING_COOKIES
;
661 dring
= ldc_alloc_exp_dring(port
->vio
.lp
, len
,
662 dr
->cookies
, &ncookies
,
667 return PTR_ERR(dring
);
670 dr
->entry_size
= entry_size
;
671 dr
->num_entries
= VDC_TX_RING_SIZE
;
672 dr
->prod
= dr
->cons
= 0;
673 dr
->pending
= VDC_TX_RING_SIZE
;
674 dr
->ncookies
= ncookies
;
679 static void vdc_free_tx_ring(struct vdc_port
*port
)
681 struct vio_dring_state
*dr
= &port
->vio
.drings
[VIO_DRIVER_TX_RING
];
684 ldc_free_exp_dring(port
->vio
.lp
, dr
->base
,
685 (dr
->entry_size
* dr
->num_entries
),
686 dr
->cookies
, dr
->ncookies
);
695 static int probe_disk(struct vdc_port
*port
)
697 struct vio_completion comp
;
698 struct request_queue
*q
;
702 init_completion(&comp
.com
);
704 comp
.waiting_for
= WAITING_FOR_LINK_UP
;
705 port
->vio
.cmp
= &comp
;
707 vio_port_up(&port
->vio
);
709 wait_for_completion(&comp
.com
);
713 err
= generic_request(port
, VD_OP_GET_VTOC
,
714 &port
->label
, sizeof(port
->label
));
716 printk(KERN_ERR PFX
"VD_OP_GET_VTOC returns error %d\n", err
);
720 if (vdc_version_supported(port
, 1, 1)) {
721 /* vdisk_size should be set during the handshake, if it wasn't
722 * then the underlying disk is reserved by another system
724 if (port
->vdisk_size
== -1)
727 struct vio_disk_geom geom
;
729 err
= generic_request(port
, VD_OP_GET_DISKGEOM
,
730 &geom
, sizeof(geom
));
732 printk(KERN_ERR PFX
"VD_OP_GET_DISKGEOM returns "
736 port
->vdisk_size
= ((u64
)geom
.num_cyl
*
741 q
= blk_init_queue(do_vdc_request
, &port
->vio
.lock
);
743 printk(KERN_ERR PFX
"%s: Could not allocate queue.\n",
747 g
= alloc_disk(1 << PARTITION_SHIFT
);
749 printk(KERN_ERR PFX
"%s: Could not allocate gendisk.\n",
751 blk_cleanup_queue(q
);
757 /* Each segment in a request is up to an aligned page in size. */
758 blk_queue_segment_boundary(q
, PAGE_SIZE
- 1);
759 blk_queue_max_segment_size(q
, PAGE_SIZE
);
761 blk_queue_max_segments(q
, port
->ring_cookies
);
762 blk_queue_max_hw_sectors(q
, port
->max_xfer_size
);
763 g
->major
= vdc_major
;
764 g
->first_minor
= port
->vio
.vdev
->dev_no
<< PARTITION_SHIFT
;
765 strcpy(g
->disk_name
, port
->disk_name
);
769 g
->private_data
= port
;
770 g
->driverfs_dev
= &port
->vio
.vdev
->dev
;
772 set_capacity(g
, port
->vdisk_size
);
774 if (vdc_version_supported(port
, 1, 1)) {
775 switch (port
->vdisk_mtype
) {
776 case VD_MEDIA_TYPE_CD
:
777 pr_info(PFX
"Virtual CDROM %s\n", port
->disk_name
);
778 g
->flags
|= GENHD_FL_CD
;
779 g
->flags
|= GENHD_FL_REMOVABLE
;
783 case VD_MEDIA_TYPE_DVD
:
784 pr_info(PFX
"Virtual DVD %s\n", port
->disk_name
);
785 g
->flags
|= GENHD_FL_CD
;
786 g
->flags
|= GENHD_FL_REMOVABLE
;
790 case VD_MEDIA_TYPE_FIXED
:
791 pr_info(PFX
"Virtual Hard disk %s\n", port
->disk_name
);
796 pr_info(PFX
"%s: %u sectors (%u MB) protocol %d.%d\n",
798 port
->vdisk_size
, (port
->vdisk_size
>> (20 - 9)),
799 port
->vio
.ver
.major
, port
->vio
.ver
.minor
);
806 static struct ldc_channel_config vdc_ldc_cfg
= {
809 .mode
= LDC_MODE_UNRELIABLE
,
812 static struct vio_driver_ops vdc_vio_ops
= {
813 .send_attr
= vdc_send_attr
,
814 .handle_attr
= vdc_handle_attr
,
815 .handshake_complete
= vdc_handshake_complete
,
818 static void print_version(void)
820 static int version_printed
;
822 if (version_printed
++ == 0)
823 printk(KERN_INFO
"%s", version
);
826 static int vdc_port_probe(struct vio_dev
*vdev
, const struct vio_device_id
*id
)
828 struct mdesc_handle
*hp
;
829 struct vdc_port
*port
;
837 if ((vdev
->dev_no
<< PARTITION_SHIFT
) & ~(u64
)MINORMASK
) {
838 printk(KERN_ERR PFX
"Port id [%llu] too large.\n",
840 goto err_out_release_mdesc
;
843 port
= kzalloc(sizeof(*port
), GFP_KERNEL
);
846 printk(KERN_ERR PFX
"Cannot allocate vdc_port.\n");
847 goto err_out_release_mdesc
;
850 if (vdev
->dev_no
>= 26)
851 snprintf(port
->disk_name
, sizeof(port
->disk_name
),
853 'a' + ((int)vdev
->dev_no
/ 26) - 1,
854 'a' + ((int)vdev
->dev_no
% 26));
856 snprintf(port
->disk_name
, sizeof(port
->disk_name
),
857 VDCBLK_NAME
"%c", 'a' + ((int)vdev
->dev_no
% 26));
858 port
->vdisk_size
= -1;
860 err
= vio_driver_init(&port
->vio
, vdev
, VDEV_DISK
,
861 vdc_versions
, ARRAY_SIZE(vdc_versions
),
862 &vdc_vio_ops
, port
->disk_name
);
864 goto err_out_free_port
;
866 port
->vdisk_block_size
= 512;
867 port
->max_xfer_size
= ((128 * 1024) / port
->vdisk_block_size
);
868 port
->ring_cookies
= ((port
->max_xfer_size
*
869 port
->vdisk_block_size
) / PAGE_SIZE
) + 2;
871 err
= vio_ldc_alloc(&port
->vio
, &vdc_ldc_cfg
, port
);
873 goto err_out_free_port
;
875 err
= vdc_alloc_tx_ring(port
);
877 goto err_out_free_ldc
;
879 err
= probe_disk(port
);
881 goto err_out_free_tx_ring
;
883 dev_set_drvdata(&vdev
->dev
, port
);
889 err_out_free_tx_ring
:
890 vdc_free_tx_ring(port
);
893 vio_ldc_free(&port
->vio
);
898 err_out_release_mdesc
:
903 static int vdc_port_remove(struct vio_dev
*vdev
)
905 struct vdc_port
*port
= dev_get_drvdata(&vdev
->dev
);
908 del_timer_sync(&port
->vio
.timer
);
910 vdc_free_tx_ring(port
);
911 vio_ldc_free(&port
->vio
);
913 dev_set_drvdata(&vdev
->dev
, NULL
);
920 static const struct vio_device_id vdc_port_match
[] = {
926 MODULE_DEVICE_TABLE(vio
, vdc_port_match
);
928 static struct vio_driver vdc_port_driver
= {
929 .id_table
= vdc_port_match
,
930 .probe
= vdc_port_probe
,
931 .remove
= vdc_port_remove
,
935 static int __init
vdc_init(void)
939 err
= register_blkdev(0, VDCBLK_NAME
);
945 err
= vio_register_driver(&vdc_port_driver
);
947 goto out_unregister_blkdev
;
951 out_unregister_blkdev
:
952 unregister_blkdev(vdc_major
, VDCBLK_NAME
);
959 static void __exit
vdc_exit(void)
961 vio_unregister_driver(&vdc_port_driver
);
962 unregister_blkdev(vdc_major
, VDCBLK_NAME
);
965 module_init(vdc_init
);
966 module_exit(vdc_exit
);