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/slab.h>
13 #include <linux/spinlock.h>
14 #include <linux/completion.h>
15 #include <linux/delay.h>
16 #include <linux/init.h>
17 #include <linux/list.h>
18 #include <linux/scatterlist.h>
23 #define DRV_MODULE_NAME "sunvdc"
24 #define PFX DRV_MODULE_NAME ": "
25 #define DRV_MODULE_VERSION "1.0"
26 #define DRV_MODULE_RELDATE "June 25, 2007"
28 static char version
[] __devinitdata
=
29 DRV_MODULE_NAME
".c:v" DRV_MODULE_VERSION
" (" DRV_MODULE_RELDATE
")\n";
30 MODULE_AUTHOR("David S. Miller (davem@davemloft.net)");
31 MODULE_DESCRIPTION("Sun LDOM virtual disk client driver");
32 MODULE_LICENSE("GPL");
33 MODULE_VERSION(DRV_MODULE_VERSION
);
35 #define VDC_TX_RING_SIZE 256
37 #define WAITING_FOR_LINK_UP 0x01
38 #define WAITING_FOR_TX_SPACE 0x02
39 #define WAITING_FOR_GEN_CMD 0x04
40 #define WAITING_FOR_ANY -1
42 struct vdc_req_entry
{
47 struct vio_driver_state vio
;
51 struct vdc_completion
*cmp
;
55 struct vdc_req_entry rq_arr
[VDC_TX_RING_SIZE
];
57 unsigned long ring_cookies
;
62 /* The server fills these in for us in the disk attribute
71 struct vio_disk_geom geom
;
72 struct vio_disk_vtoc label
;
75 static inline struct vdc_port
*to_vdc_port(struct vio_driver_state
*vio
)
77 return container_of(vio
, struct vdc_port
, vio
);
80 /* Ordered from largest major to lowest */
81 static struct vio_version vdc_versions
[] = {
82 { .major
= 1, .minor
= 0 },
85 #define VDCBLK_NAME "vdisk"
87 #define PARTITION_SHIFT 3
89 static inline u32
vdc_tx_dring_avail(struct vio_dring_state
*dr
)
91 return vio_dring_avail(dr
, VDC_TX_RING_SIZE
);
94 static int vdc_getgeo(struct block_device
*bdev
, struct hd_geometry
*geo
)
96 struct gendisk
*disk
= bdev
->bd_disk
;
97 struct vdc_port
*port
= disk
->private_data
;
99 geo
->heads
= (u8
) port
->geom
.num_hd
;
100 geo
->sectors
= (u8
) port
->geom
.num_sec
;
101 geo
->cylinders
= port
->geom
.num_cyl
;
106 static const struct block_device_operations vdc_fops
= {
107 .owner
= THIS_MODULE
,
108 .getgeo
= vdc_getgeo
,
111 static void vdc_finish(struct vio_driver_state
*vio
, int err
, int waiting_for
)
114 (waiting_for
== -1 ||
115 vio
->cmp
->waiting_for
== waiting_for
)) {
117 complete(&vio
->cmp
->com
);
122 static void vdc_handshake_complete(struct vio_driver_state
*vio
)
124 vdc_finish(vio
, 0, WAITING_FOR_LINK_UP
);
127 static int vdc_handle_unknown(struct vdc_port
*port
, void *arg
)
129 struct vio_msg_tag
*pkt
= arg
;
131 printk(KERN_ERR PFX
"Received unknown msg [%02x:%02x:%04x:%08x]\n",
132 pkt
->type
, pkt
->stype
, pkt
->stype_env
, pkt
->sid
);
133 printk(KERN_ERR PFX
"Resetting connection.\n");
135 ldc_disconnect(port
->vio
.lp
);
140 static int vdc_send_attr(struct vio_driver_state
*vio
)
142 struct vdc_port
*port
= to_vdc_port(vio
);
143 struct vio_disk_attr_info pkt
;
145 memset(&pkt
, 0, sizeof(pkt
));
147 pkt
.tag
.type
= VIO_TYPE_CTRL
;
148 pkt
.tag
.stype
= VIO_SUBTYPE_INFO
;
149 pkt
.tag
.stype_env
= VIO_ATTR_INFO
;
150 pkt
.tag
.sid
= vio_send_sid(vio
);
152 pkt
.xfer_mode
= VIO_DRING_MODE
;
153 pkt
.vdisk_block_size
= port
->vdisk_block_size
;
154 pkt
.max_xfer_size
= port
->max_xfer_size
;
156 viodbg(HS
, "SEND ATTR xfer_mode[0x%x] blksz[%u] max_xfer[%llu]\n",
157 pkt
.xfer_mode
, pkt
.vdisk_block_size
, pkt
.max_xfer_size
);
159 return vio_ldc_send(&port
->vio
, &pkt
, sizeof(pkt
));
162 static int vdc_handle_attr(struct vio_driver_state
*vio
, void *arg
)
164 struct vdc_port
*port
= to_vdc_port(vio
);
165 struct vio_disk_attr_info
*pkt
= arg
;
167 viodbg(HS
, "GOT ATTR stype[0x%x] ops[%llx] disk_size[%llu] disk_type[%x] "
168 "xfer_mode[0x%x] blksz[%u] max_xfer[%llu]\n",
169 pkt
->tag
.stype
, pkt
->operations
,
170 pkt
->vdisk_size
, pkt
->vdisk_type
,
171 pkt
->xfer_mode
, pkt
->vdisk_block_size
,
174 if (pkt
->tag
.stype
== VIO_SUBTYPE_ACK
) {
175 switch (pkt
->vdisk_type
) {
176 case VD_DISK_TYPE_DISK
:
177 case VD_DISK_TYPE_SLICE
:
181 printk(KERN_ERR PFX
"%s: Bogus vdisk_type 0x%x\n",
182 vio
->name
, pkt
->vdisk_type
);
186 if (pkt
->vdisk_block_size
> port
->vdisk_block_size
) {
187 printk(KERN_ERR PFX
"%s: BLOCK size increased "
190 port
->vdisk_block_size
, pkt
->vdisk_block_size
);
194 port
->operations
= pkt
->operations
;
195 port
->vdisk_size
= pkt
->vdisk_size
;
196 port
->vdisk_type
= pkt
->vdisk_type
;
197 if (pkt
->max_xfer_size
< port
->max_xfer_size
)
198 port
->max_xfer_size
= pkt
->max_xfer_size
;
199 port
->vdisk_block_size
= pkt
->vdisk_block_size
;
202 printk(KERN_ERR PFX
"%s: Attribute NACK\n", vio
->name
);
208 static void vdc_end_special(struct vdc_port
*port
, struct vio_disk_desc
*desc
)
210 int err
= desc
->status
;
212 vdc_finish(&port
->vio
, -err
, WAITING_FOR_GEN_CMD
);
215 static void vdc_end_one(struct vdc_port
*port
, struct vio_dring_state
*dr
,
218 struct vio_disk_desc
*desc
= vio_dring_entry(dr
, index
);
219 struct vdc_req_entry
*rqe
= &port
->rq_arr
[index
];
222 if (unlikely(desc
->hdr
.state
!= VIO_DESC_DONE
))
225 ldc_unmap(port
->vio
.lp
, desc
->cookies
, desc
->ncookies
);
226 desc
->hdr
.state
= VIO_DESC_FREE
;
227 dr
->cons
= (index
+ 1) & (VDC_TX_RING_SIZE
- 1);
231 vdc_end_special(port
, desc
);
237 __blk_end_request(req
, (desc
->status
? -EIO
: 0), desc
->size
);
239 if (blk_queue_stopped(port
->disk
->queue
))
240 blk_start_queue(port
->disk
->queue
);
243 static int vdc_ack(struct vdc_port
*port
, void *msgbuf
)
245 struct vio_dring_state
*dr
= &port
->vio
.drings
[VIO_DRIVER_TX_RING
];
246 struct vio_dring_data
*pkt
= msgbuf
;
248 if (unlikely(pkt
->dring_ident
!= dr
->ident
||
249 pkt
->start_idx
!= pkt
->end_idx
||
250 pkt
->start_idx
>= VDC_TX_RING_SIZE
))
253 vdc_end_one(port
, dr
, pkt
->start_idx
);
258 static int vdc_nack(struct vdc_port
*port
, void *msgbuf
)
263 static void vdc_event(void *arg
, int event
)
265 struct vdc_port
*port
= arg
;
266 struct vio_driver_state
*vio
= &port
->vio
;
270 spin_lock_irqsave(&vio
->lock
, flags
);
272 if (unlikely(event
== LDC_EVENT_RESET
||
273 event
== LDC_EVENT_UP
)) {
274 vio_link_state_change(vio
, event
);
275 spin_unlock_irqrestore(&vio
->lock
, flags
);
279 if (unlikely(event
!= LDC_EVENT_DATA_READY
)) {
280 printk(KERN_WARNING PFX
"Unexpected LDC event %d\n", event
);
281 spin_unlock_irqrestore(&vio
->lock
, flags
);
288 struct vio_msg_tag tag
;
292 err
= ldc_read(vio
->lp
, &msgbuf
, sizeof(msgbuf
));
293 if (unlikely(err
< 0)) {
294 if (err
== -ECONNRESET
)
300 viodbg(DATA
, "TAG [%02x:%02x:%04x:%08x]\n",
303 msgbuf
.tag
.stype_env
,
305 err
= vio_validate_sid(vio
, &msgbuf
.tag
);
309 if (likely(msgbuf
.tag
.type
== VIO_TYPE_DATA
)) {
310 if (msgbuf
.tag
.stype
== VIO_SUBTYPE_ACK
)
311 err
= vdc_ack(port
, &msgbuf
);
312 else if (msgbuf
.tag
.stype
== VIO_SUBTYPE_NACK
)
313 err
= vdc_nack(port
, &msgbuf
);
315 err
= vdc_handle_unknown(port
, &msgbuf
);
316 } else if (msgbuf
.tag
.type
== VIO_TYPE_CTRL
) {
317 err
= vio_control_pkt_engine(vio
, &msgbuf
);
319 err
= vdc_handle_unknown(port
, &msgbuf
);
325 vdc_finish(&port
->vio
, err
, WAITING_FOR_ANY
);
326 spin_unlock_irqrestore(&vio
->lock
, flags
);
329 static int __vdc_tx_trigger(struct vdc_port
*port
)
331 struct vio_dring_state
*dr
= &port
->vio
.drings
[VIO_DRIVER_TX_RING
];
332 struct vio_dring_data hdr
= {
334 .type
= VIO_TYPE_DATA
,
335 .stype
= VIO_SUBTYPE_INFO
,
336 .stype_env
= VIO_DRING_DATA
,
337 .sid
= vio_send_sid(&port
->vio
),
339 .dring_ident
= dr
->ident
,
340 .start_idx
= dr
->prod
,
345 hdr
.seq
= dr
->snd_nxt
;
348 err
= vio_ldc_send(&port
->vio
, &hdr
, sizeof(hdr
));
354 if ((delay
<<= 1) > 128)
356 } while (err
== -EAGAIN
);
361 static int __send_request(struct request
*req
)
363 struct vdc_port
*port
= req
->rq_disk
->private_data
;
364 struct vio_dring_state
*dr
= &port
->vio
.drings
[VIO_DRIVER_TX_RING
];
365 struct scatterlist sg
[port
->ring_cookies
];
366 struct vdc_req_entry
*rqe
;
367 struct vio_disk_desc
*desc
;
368 unsigned int map_perm
;
373 map_perm
= LDC_MAP_SHADOW
| LDC_MAP_DIRECT
| LDC_MAP_IO
;
375 if (rq_data_dir(req
) == READ
) {
376 map_perm
|= LDC_MAP_W
;
379 map_perm
|= LDC_MAP_R
;
383 sg_init_table(sg
, port
->ring_cookies
);
384 nsg
= blk_rq_map_sg(req
->q
, req
, sg
);
387 for (i
= 0; i
< nsg
; i
++)
390 if (unlikely(vdc_tx_dring_avail(dr
) < 1)) {
391 blk_stop_queue(port
->disk
->queue
);
396 desc
= vio_dring_cur(dr
);
398 err
= ldc_map_sg(port
->vio
.lp
, sg
, nsg
,
399 desc
->cookies
, port
->ring_cookies
,
402 printk(KERN_ERR PFX
"ldc_map_sg() failure, err=%d.\n", err
);
406 rqe
= &port
->rq_arr
[dr
->prod
];
409 desc
->hdr
.ack
= VIO_ACK_ENABLE
;
410 desc
->req_id
= port
->req_id
;
411 desc
->operation
= op
;
412 if (port
->vdisk_type
== VD_DISK_TYPE_DISK
) {
418 desc
->offset
= (blk_rq_pos(req
) << 9) / port
->vdisk_block_size
;
420 desc
->ncookies
= err
;
422 /* This has to be a non-SMP write barrier because we are writing
423 * to memory which is shared with the peer LDOM.
426 desc
->hdr
.state
= VIO_DESC_READY
;
428 err
= __vdc_tx_trigger(port
);
430 printk(KERN_ERR PFX
"vdc_tx_trigger() failure, err=%d\n", err
);
433 dr
->prod
= (dr
->prod
+ 1) & (VDC_TX_RING_SIZE
- 1);
440 static void do_vdc_request(struct request_queue
*q
)
443 struct request
*req
= blk_fetch_request(q
);
448 if (__send_request(req
) < 0)
449 __blk_end_request_all(req
, -EIO
);
453 static int generic_request(struct vdc_port
*port
, u8 op
, void *buf
, int len
)
455 struct vio_dring_state
*dr
;
456 struct vio_completion comp
;
457 struct vio_disk_desc
*desc
;
458 unsigned int map_perm
;
463 if (!(((u64
)1 << ((u64
)op
- 1)) & port
->operations
))
478 op_len
= sizeof(u32
);
479 map_perm
= LDC_MAP_W
;
483 op_len
= sizeof(u32
);
484 map_perm
= LDC_MAP_R
;
488 op_len
= sizeof(struct vio_disk_vtoc
);
489 map_perm
= LDC_MAP_W
;
493 op_len
= sizeof(struct vio_disk_vtoc
);
494 map_perm
= LDC_MAP_R
;
497 case VD_OP_GET_DISKGEOM
:
498 op_len
= sizeof(struct vio_disk_geom
);
499 map_perm
= LDC_MAP_W
;
502 case VD_OP_SET_DISKGEOM
:
503 op_len
= sizeof(struct vio_disk_geom
);
504 map_perm
= LDC_MAP_R
;
509 map_perm
= LDC_MAP_RW
;
512 case VD_OP_GET_DEVID
:
513 op_len
= sizeof(struct vio_disk_devid
);
514 map_perm
= LDC_MAP_W
;
523 map_perm
|= LDC_MAP_SHADOW
| LDC_MAP_DIRECT
| LDC_MAP_IO
;
525 op_len
= (op_len
+ 7) & ~7;
526 req_buf
= kzalloc(op_len
, GFP_KERNEL
);
533 if (map_perm
& LDC_MAP_R
)
534 memcpy(req_buf
, buf
, len
);
536 spin_lock_irqsave(&port
->vio
.lock
, flags
);
538 dr
= &port
->vio
.drings
[VIO_DRIVER_TX_RING
];
540 desc
= vio_dring_cur(dr
);
542 err
= ldc_map_single(port
->vio
.lp
, req_buf
, op_len
,
543 desc
->cookies
, port
->ring_cookies
,
546 spin_unlock_irqrestore(&port
->vio
.lock
, flags
);
551 init_completion(&comp
.com
);
552 comp
.waiting_for
= WAITING_FOR_GEN_CMD
;
553 port
->vio
.cmp
= &comp
;
555 desc
->hdr
.ack
= VIO_ACK_ENABLE
;
556 desc
->req_id
= port
->req_id
;
557 desc
->operation
= op
;
562 desc
->ncookies
= err
;
564 /* This has to be a non-SMP write barrier because we are writing
565 * to memory which is shared with the peer LDOM.
568 desc
->hdr
.state
= VIO_DESC_READY
;
570 err
= __vdc_tx_trigger(port
);
573 dr
->prod
= (dr
->prod
+ 1) & (VDC_TX_RING_SIZE
- 1);
574 spin_unlock_irqrestore(&port
->vio
.lock
, flags
);
576 wait_for_completion(&comp
.com
);
579 port
->vio
.cmp
= NULL
;
580 spin_unlock_irqrestore(&port
->vio
.lock
, flags
);
583 if (map_perm
& LDC_MAP_W
)
584 memcpy(buf
, req_buf
, len
);
591 static int __devinit
vdc_alloc_tx_ring(struct vdc_port
*port
)
593 struct vio_dring_state
*dr
= &port
->vio
.drings
[VIO_DRIVER_TX_RING
];
594 unsigned long len
, entry_size
;
598 entry_size
= sizeof(struct vio_disk_desc
) +
599 (sizeof(struct ldc_trans_cookie
) * port
->ring_cookies
);
600 len
= (VDC_TX_RING_SIZE
* entry_size
);
602 ncookies
= VIO_MAX_RING_COOKIES
;
603 dring
= ldc_alloc_exp_dring(port
->vio
.lp
, len
,
604 dr
->cookies
, &ncookies
,
609 return PTR_ERR(dring
);
612 dr
->entry_size
= entry_size
;
613 dr
->num_entries
= VDC_TX_RING_SIZE
;
614 dr
->prod
= dr
->cons
= 0;
615 dr
->pending
= VDC_TX_RING_SIZE
;
616 dr
->ncookies
= ncookies
;
621 static void vdc_free_tx_ring(struct vdc_port
*port
)
623 struct vio_dring_state
*dr
= &port
->vio
.drings
[VIO_DRIVER_TX_RING
];
626 ldc_free_exp_dring(port
->vio
.lp
, dr
->base
,
627 (dr
->entry_size
* dr
->num_entries
),
628 dr
->cookies
, dr
->ncookies
);
637 static int probe_disk(struct vdc_port
*port
)
639 struct vio_completion comp
;
640 struct request_queue
*q
;
644 init_completion(&comp
.com
);
646 comp
.waiting_for
= WAITING_FOR_LINK_UP
;
647 port
->vio
.cmp
= &comp
;
649 vio_port_up(&port
->vio
);
651 wait_for_completion(&comp
.com
);
655 err
= generic_request(port
, VD_OP_GET_VTOC
,
656 &port
->label
, sizeof(port
->label
));
658 printk(KERN_ERR PFX
"VD_OP_GET_VTOC returns error %d\n", err
);
662 err
= generic_request(port
, VD_OP_GET_DISKGEOM
,
663 &port
->geom
, sizeof(port
->geom
));
665 printk(KERN_ERR PFX
"VD_OP_GET_DISKGEOM returns "
670 port
->vdisk_size
= ((u64
)port
->geom
.num_cyl
*
671 (u64
)port
->geom
.num_hd
*
672 (u64
)port
->geom
.num_sec
);
674 q
= blk_init_queue(do_vdc_request
, &port
->vio
.lock
);
676 printk(KERN_ERR PFX
"%s: Could not allocate queue.\n",
680 g
= alloc_disk(1 << PARTITION_SHIFT
);
682 printk(KERN_ERR PFX
"%s: Could not allocate gendisk.\n",
684 blk_cleanup_queue(q
);
690 blk_queue_max_segments(q
, port
->ring_cookies
);
691 blk_queue_max_hw_sectors(q
, port
->max_xfer_size
);
692 g
->major
= vdc_major
;
693 g
->first_minor
= port
->vio
.vdev
->dev_no
<< PARTITION_SHIFT
;
694 strcpy(g
->disk_name
, port
->disk_name
);
698 g
->private_data
= port
;
699 g
->driverfs_dev
= &port
->vio
.vdev
->dev
;
701 set_capacity(g
, port
->vdisk_size
);
703 printk(KERN_INFO PFX
"%s: %u sectors (%u MB)\n",
705 port
->vdisk_size
, (port
->vdisk_size
>> (20 - 9)));
712 static struct ldc_channel_config vdc_ldc_cfg
= {
715 .mode
= LDC_MODE_UNRELIABLE
,
718 static struct vio_driver_ops vdc_vio_ops
= {
719 .send_attr
= vdc_send_attr
,
720 .handle_attr
= vdc_handle_attr
,
721 .handshake_complete
= vdc_handshake_complete
,
724 static void __devinit
print_version(void)
726 static int version_printed
;
728 if (version_printed
++ == 0)
729 printk(KERN_INFO
"%s", version
);
732 static int __devinit
vdc_port_probe(struct vio_dev
*vdev
,
733 const struct vio_device_id
*id
)
735 struct mdesc_handle
*hp
;
736 struct vdc_port
*port
;
744 if ((vdev
->dev_no
<< PARTITION_SHIFT
) & ~(u64
)MINORMASK
) {
745 printk(KERN_ERR PFX
"Port id [%llu] too large.\n",
747 goto err_out_release_mdesc
;
750 port
= kzalloc(sizeof(*port
), GFP_KERNEL
);
753 printk(KERN_ERR PFX
"Cannot allocate vdc_port.\n");
754 goto err_out_release_mdesc
;
757 if (vdev
->dev_no
>= 26)
758 snprintf(port
->disk_name
, sizeof(port
->disk_name
),
760 'a' + ((int)vdev
->dev_no
/ 26) - 1,
761 'a' + ((int)vdev
->dev_no
% 26));
763 snprintf(port
->disk_name
, sizeof(port
->disk_name
),
764 VDCBLK_NAME
"%c", 'a' + ((int)vdev
->dev_no
% 26));
766 err
= vio_driver_init(&port
->vio
, vdev
, VDEV_DISK
,
767 vdc_versions
, ARRAY_SIZE(vdc_versions
),
768 &vdc_vio_ops
, port
->disk_name
);
770 goto err_out_free_port
;
772 port
->vdisk_block_size
= 512;
773 port
->max_xfer_size
= ((128 * 1024) / port
->vdisk_block_size
);
774 port
->ring_cookies
= ((port
->max_xfer_size
*
775 port
->vdisk_block_size
) / PAGE_SIZE
) + 2;
777 err
= vio_ldc_alloc(&port
->vio
, &vdc_ldc_cfg
, port
);
779 goto err_out_free_port
;
781 err
= vdc_alloc_tx_ring(port
);
783 goto err_out_free_ldc
;
785 err
= probe_disk(port
);
787 goto err_out_free_tx_ring
;
789 dev_set_drvdata(&vdev
->dev
, port
);
795 err_out_free_tx_ring
:
796 vdc_free_tx_ring(port
);
799 vio_ldc_free(&port
->vio
);
804 err_out_release_mdesc
:
809 static int vdc_port_remove(struct vio_dev
*vdev
)
811 struct vdc_port
*port
= dev_get_drvdata(&vdev
->dev
);
814 del_timer_sync(&port
->vio
.timer
);
816 vdc_free_tx_ring(port
);
817 vio_ldc_free(&port
->vio
);
819 dev_set_drvdata(&vdev
->dev
, NULL
);
826 static const struct vio_device_id vdc_port_match
[] = {
832 MODULE_DEVICE_TABLE(vio
, vdc_port_match
);
834 static struct vio_driver vdc_port_driver
= {
835 .id_table
= vdc_port_match
,
836 .probe
= vdc_port_probe
,
837 .remove
= vdc_port_remove
,
840 .owner
= THIS_MODULE
,
844 static int __init
vdc_init(void)
848 err
= register_blkdev(0, VDCBLK_NAME
);
854 err
= vio_register_driver(&vdc_port_driver
);
856 goto out_unregister_blkdev
;
860 out_unregister_blkdev
:
861 unregister_blkdev(vdc_major
, VDCBLK_NAME
);
868 static void __exit
vdc_exit(void)
870 vio_unregister_driver(&vdc_port_driver
);
871 unregister_blkdev(vdc_major
, VDCBLK_NAME
);
874 module_init(vdc_init
);
875 module_exit(vdc_exit
);