4 * Copyright (c) 2013 Alexander Graf <agraf@suse.de>
6 * This work is licensed under the terms of the GNU GPL, version 2 or (at
7 * your option) any later version. See the COPYING file in the top-level
13 #include "virtio-scsi.h"
15 #define VRING_WAIT_REPLY_TIMEOUT 3
17 static VRing block
[VIRTIO_MAX_VQS
];
18 static char ring_area
[VIRTIO_RING_SIZE
* VIRTIO_MAX_VQS
]
19 __attribute__((__aligned__(PAGE_SIZE
)));
21 static char chsc_page
[PAGE_SIZE
] __attribute__((__aligned__(PAGE_SIZE
)));
27 .ring_area
= ring_area
,
28 .wait_reply_timeout
= VRING_WAIT_REPLY_TIMEOUT
,
29 .schid
= { .one
= 1 },
30 .scsi_block_size
= VIRTIO_SCSI_BLOCK_SIZE
,
34 VDev
*virtio_get_device(void)
39 VirtioDevType
virtio_get_device_type(void)
41 return vdev
.senseid
.cu_model
;
44 /* virtio spec v1.0 para 4.3.3.2 */
45 static long kvm_hypercall(unsigned long nr
, unsigned long param1
,
46 unsigned long param2
, unsigned long param3
)
48 register ulong r_nr
asm("1") = nr
;
49 register ulong r_param1
asm("2") = param1
;
50 register ulong r_param2
asm("3") = param2
;
51 register ulong r_param3
asm("4") = param3
;
52 register long retval
asm("2");
54 asm volatile ("diag 2,4,0x500"
56 : "d" (r_nr
), "0" (r_param1
), "r"(r_param2
), "d"(r_param3
)
62 static long virtio_notify(SubChannelId schid
, int vq_idx
, long cookie
)
64 return kvm_hypercall(KVM_S390_VIRTIO_CCW_NOTIFY
, *(u32
*)&schid
,
68 /***********************************************
70 ***********************************************/
72 static int drain_irqs(SubChannelId schid
)
78 /* FIXME: make use of TPI, for that enable subchannel and isc */
79 if (tsch(schid
, &irb
)) {
80 /* Might want to differentiate error codes later on. */
83 } else if (irb
.scsw
.dstat
!= 0xc) {
91 static int run_ccw(VDev
*vdev
, int cmd
, void *ptr
, int len
)
98 /* start command processing */
99 stsch_err(vdev
->schid
, &schib
);
100 /* enable the subchannel for IPL device */
102 msch(vdev
->schid
, &schib
);
104 /* start subchannel command */
106 orb
.cpa
= (u32
)(long)&ccw
;
113 r
= ssch(vdev
->schid
, &orb
);
115 * XXX Wait until device is done processing the CCW. For now we can
116 * assume that a simple tsch will have finished the CCW processing,
117 * but the architecture allows for asynchronous operation
120 r
= drain_irqs(vdev
->schid
);
125 static void vring_init(VRing
*vr
, VqInfo
*info
)
127 void *p
= (void *) info
->queue
;
129 debug_print_addr("init p", p
);
130 vr
->id
= info
->index
;
133 vr
->avail
= p
+ info
->num
* sizeof(VRingDesc
);
134 vr
->used
= (void *)(((unsigned long)&vr
->avail
->ring
[info
->num
]
135 + info
->align
- 1) & ~(info
->align
- 1));
137 /* Zero out all relevant field */
138 vr
->avail
->flags
= 0;
141 /* We're running with interrupts off anyways, so don't bother */
142 vr
->used
->flags
= VRING_USED_F_NO_NOTIFY
;
148 debug_print_addr("init vr", vr
);
151 static bool vring_notify(VRing
*vr
)
153 vr
->cookie
= virtio_notify(vr
->schid
, vr
->id
, vr
->cookie
);
154 return vr
->cookie
>= 0;
157 static void vring_send_buf(VRing
*vr
, void *p
, int len
, int flags
)
159 /* For follow-up chains we need to keep the first entry point */
160 if (!(flags
& VRING_HIDDEN_IS_CHAIN
)) {
161 vr
->avail
->ring
[vr
->avail
->idx
% vr
->num
] = vr
->next_idx
;
164 vr
->desc
[vr
->next_idx
].addr
= (ulong
)p
;
165 vr
->desc
[vr
->next_idx
].len
= len
;
166 vr
->desc
[vr
->next_idx
].flags
= flags
& ~VRING_HIDDEN_IS_CHAIN
;
167 vr
->desc
[vr
->next_idx
].next
= vr
->next_idx
;
168 vr
->desc
[vr
->next_idx
].next
++;
171 /* Chains only have a single ID */
172 if (!(flags
& VRING_DESC_F_NEXT
)) {
177 static u64
get_clock(void)
181 asm volatile("stck %0" : "=Q" (r
) : : "cc");
185 ulong
get_second(void)
187 return (get_clock() >> 12) / 1000000;
190 static int vr_poll(VRing
*vr
)
192 if (vr
->used
->idx
== vr
->used_idx
) {
198 vr
->used_idx
= vr
->used
->idx
;
201 vr
->desc
[0].flags
= 0;
202 return 1; /* vr has been updated */
206 * Wait for the host to reply.
208 * timeout is in seconds if > 0.
210 * Returns 0 on success, 1 on timeout.
212 static int vring_wait_reply(void)
214 ulong target_second
= get_second() + vdev
.wait_reply_timeout
;
216 /* Wait for any queue to be updated by the host */
220 for (i
= 0; i
< vdev
.nr_vqs
; i
++) {
221 r
+= vr_poll(&vdev
.vrings
[i
]);
227 } while (!vdev
.wait_reply_timeout
|| (get_second() < target_second
));
232 int virtio_run(VDev
*vdev
, int vqid
, VirtioCmd
*cmd
)
234 VRing
*vr
= &vdev
->vrings
[vqid
];
238 vring_send_buf(vr
, cmd
[i
].data
, cmd
[i
].size
,
239 cmd
[i
].flags
| (i
? VRING_HIDDEN_IS_CHAIN
: 0));
240 } while (cmd
[i
++].flags
& VRING_DESC_F_NEXT
);
243 if (drain_irqs(vr
->schid
)) {
249 /***********************************************
251 ***********************************************/
253 static int virtio_blk_read_many(VDev
*vdev
,
254 ulong sector
, void *load_addr
, int sec_num
)
256 VirtioBlkOuthdr out_hdr
;
258 VRing
*vr
= &vdev
->vrings
[vdev
->cmd_vr_idx
];
260 /* Tell the host we want to read */
261 out_hdr
.type
= VIRTIO_BLK_T_IN
;
263 out_hdr
.sector
= virtio_sector_adjust(sector
);
265 vring_send_buf(vr
, &out_hdr
, sizeof(out_hdr
), VRING_DESC_F_NEXT
);
267 /* This is where we want to receive data */
268 vring_send_buf(vr
, load_addr
, virtio_get_block_size() * sec_num
,
269 VRING_DESC_F_WRITE
| VRING_HIDDEN_IS_CHAIN
|
273 vring_send_buf(vr
, &status
, sizeof(u8
),
274 VRING_DESC_F_WRITE
| VRING_HIDDEN_IS_CHAIN
);
276 /* Now we can tell the host to read */
279 if (drain_irqs(vr
->schid
)) {
280 /* Well, whatever status is supposed to contain... */
286 int virtio_read_many(ulong sector
, void *load_addr
, int sec_num
)
288 switch (vdev
.senseid
.cu_model
) {
289 case VIRTIO_ID_BLOCK
:
290 return virtio_blk_read_many(&vdev
, sector
, load_addr
, sec_num
);
292 return virtio_scsi_read_many(&vdev
, sector
, load_addr
, sec_num
);
294 panic("\n! No readable IPL device !\n");
298 unsigned long virtio_load_direct(ulong rec_list1
, ulong rec_list2
,
299 ulong subchan_id
, void *load_addr
)
303 int sec_num
= ((rec_list2
>> 32) & 0xffff) + 1;
304 int sec_len
= rec_list2
>> 48;
305 ulong addr
= (ulong
)load_addr
;
307 if (sec_len
!= virtio_get_block_size()) {
312 status
= virtio_read_many(sec
, (void *)addr
, sec_num
);
316 addr
+= sec_num
* virtio_get_block_size();
321 int virtio_read(ulong sector
, void *load_addr
)
323 return virtio_read_many(sector
, load_addr
, 1);
327 * Other supported value pairs, if any, would need to be added here.
328 * Note: head count is always 15.
330 static inline u8
virtio_eckd_sectors_for_block_size(int size
)
345 VirtioGDN
virtio_guessed_disk_nature(void)
347 return vdev
.guessed_disk_nature
;
350 void virtio_assume_scsi(void)
352 switch (vdev
.senseid
.cu_model
) {
353 case VIRTIO_ID_BLOCK
:
354 vdev
.guessed_disk_nature
= VIRTIO_GDN_SCSI
;
355 vdev
.config
.blk
.blk_size
= VIRTIO_SCSI_BLOCK_SIZE
;
356 vdev
.config
.blk
.physical_block_exp
= 0;
360 vdev
.scsi_block_size
= VIRTIO_SCSI_BLOCK_SIZE
;
365 void virtio_assume_iso9660(void)
367 switch (vdev
.senseid
.cu_model
) {
368 case VIRTIO_ID_BLOCK
:
369 vdev
.guessed_disk_nature
= VIRTIO_GDN_SCSI
;
370 vdev
.config
.blk
.blk_size
= VIRTIO_ISO_BLOCK_SIZE
;
371 vdev
.config
.blk
.physical_block_exp
= 0;
372 vdev
.blk_factor
= VIRTIO_ISO_BLOCK_SIZE
/ VIRTIO_SECTOR_SIZE
;
375 vdev
.scsi_block_size
= VIRTIO_ISO_BLOCK_SIZE
;
380 void virtio_assume_eckd(void)
382 vdev
.guessed_disk_nature
= VIRTIO_GDN_DASD
;
384 vdev
.config
.blk
.physical_block_exp
= 0;
385 switch (vdev
.senseid
.cu_model
) {
386 case VIRTIO_ID_BLOCK
:
387 vdev
.config
.blk
.blk_size
= 4096;
390 vdev
.config
.blk
.blk_size
= vdev
.scsi_block_size
;
393 vdev
.config
.blk
.geometry
.heads
= 15;
394 vdev
.config
.blk
.geometry
.sectors
=
395 virtio_eckd_sectors_for_block_size(vdev
.config
.blk
.blk_size
);
398 bool virtio_disk_is_scsi(void)
400 if (vdev
.guessed_disk_nature
== VIRTIO_GDN_SCSI
) {
403 switch (vdev
.senseid
.cu_model
) {
404 case VIRTIO_ID_BLOCK
:
405 return (vdev
.config
.blk
.geometry
.heads
== 255)
406 && (vdev
.config
.blk
.geometry
.sectors
== 63)
407 && (virtio_get_block_size() == VIRTIO_SCSI_BLOCK_SIZE
);
414 bool virtio_disk_is_eckd(void)
416 const int block_size
= virtio_get_block_size();
418 if (vdev
.guessed_disk_nature
== VIRTIO_GDN_DASD
) {
421 switch (vdev
.senseid
.cu_model
) {
422 case VIRTIO_ID_BLOCK
:
423 return (vdev
.config
.blk
.geometry
.heads
== 15)
424 && (vdev
.config
.blk
.geometry
.sectors
==
425 virtio_eckd_sectors_for_block_size(block_size
));
432 bool virtio_ipl_disk_is_valid(void)
434 return virtio_disk_is_scsi() || virtio_disk_is_eckd();
437 int virtio_get_block_size(void)
439 switch (vdev
.senseid
.cu_model
) {
440 case VIRTIO_ID_BLOCK
:
441 return vdev
.config
.blk
.blk_size
<< vdev
.config
.blk
.physical_block_exp
;
443 return vdev
.scsi_block_size
;
448 uint8_t virtio_get_heads(void)
450 switch (vdev
.senseid
.cu_model
) {
451 case VIRTIO_ID_BLOCK
:
452 return vdev
.config
.blk
.geometry
.heads
;
454 return vdev
.guessed_disk_nature
== VIRTIO_GDN_DASD
455 ? vdev
.config
.blk
.geometry
.heads
: 255;
460 uint8_t virtio_get_sectors(void)
462 switch (vdev
.senseid
.cu_model
) {
463 case VIRTIO_ID_BLOCK
:
464 return vdev
.config
.blk
.geometry
.sectors
;
466 return vdev
.guessed_disk_nature
== VIRTIO_GDN_DASD
467 ? vdev
.config
.blk
.geometry
.sectors
: 63;
472 uint64_t virtio_get_blocks(void)
474 const uint64_t factor
= virtio_get_block_size() / VIRTIO_SECTOR_SIZE
;
475 switch (vdev
.senseid
.cu_model
) {
476 case VIRTIO_ID_BLOCK
:
477 return vdev
.config
.blk
.capacity
/ factor
;
479 return vdev
.scsi_last_block
/ factor
;
484 static void virtio_setup_ccw(VDev
*vdev
)
487 unsigned char status
= VIRTIO_CONFIG_S_DRIVER_OK
;
489 IPL_assert(virtio_is_supported(vdev
->schid
), "PE");
490 /* device ID has been established now */
492 vdev
->config
.blk
.blk_size
= 0; /* mark "illegal" - setup started... */
493 vdev
->guessed_disk_nature
= VIRTIO_GDN_NONE
;
495 run_ccw(vdev
, CCW_CMD_VDEV_RESET
, NULL
, 0);
497 switch (vdev
->senseid
.cu_model
) {
498 case VIRTIO_ID_BLOCK
:
500 vdev
->cmd_vr_idx
= 0;
501 cfg_size
= sizeof(vdev
->config
.blk
);
505 vdev
->cmd_vr_idx
= VR_REQUEST
;
506 cfg_size
= sizeof(vdev
->config
.scsi
);
509 panic("Unsupported virtio device\n");
511 IPL_assert(run_ccw(vdev
, CCW_CMD_READ_CONF
, &vdev
->config
, cfg_size
) == 0,
512 "Could not get block device configuration");
515 * Skipping CCW_CMD_READ_FEAT. We're not doing anything fancy, and
516 * we'll just stop dead anyway if anything does not work like we
520 for (i
= 0; i
< vdev
->nr_vqs
; i
++) {
522 .queue
= (unsigned long long) ring_area
+ (i
* VIRTIO_RING_SIZE
),
523 .align
= KVM_S390_VIRTIO_RING_ALIGN
,
533 run_ccw(vdev
, CCW_CMD_READ_VQ_CONF
, &config
, sizeof(config
)) == 0,
534 "Could not get block device VQ configuration");
535 info
.num
= config
.num
;
536 vring_init(&vdev
->vrings
[i
], &info
);
537 vdev
->vrings
[i
].schid
= vdev
->schid
;
538 IPL_assert(run_ccw(vdev
, CCW_CMD_SET_VQ
, &info
, sizeof(info
)) == 0,
539 "Cannot set VQ info");
542 run_ccw(vdev
, CCW_CMD_WRITE_STATUS
, &status
, sizeof(status
)) == 0,
543 "Could not write status to host");
546 void virtio_setup_device(SubChannelId schid
)
549 virtio_setup_ccw(&vdev
);
551 switch (vdev
.senseid
.cu_model
) {
552 case VIRTIO_ID_BLOCK
:
553 sclp_print("Using virtio-blk.\n");
554 if (!virtio_ipl_disk_is_valid()) {
555 /* make sure all getters but blocksize return 0 for
558 memset(&vdev
.config
.blk
, 0, sizeof(vdev
.config
.blk
));
559 virtio_assume_scsi();
563 IPL_assert(vdev
.config
.scsi
.sense_size
== VIRTIO_SCSI_SENSE_SIZE
,
564 "Config: sense size mismatch");
565 IPL_assert(vdev
.config
.scsi
.cdb_size
== VIRTIO_SCSI_CDB_SIZE
,
566 "Config: CDB size mismatch");
568 sclp_print("Using virtio-scsi.\n");
569 virtio_scsi_setup(&vdev
);
572 panic("\n! No IPL device available !\n");
576 bool virtio_is_supported(SubChannelId schid
)
579 memset(&vdev
.senseid
, 0, sizeof(vdev
.senseid
));
580 /* run sense id command */
581 if (run_ccw(&vdev
, CCW_CMD_SENSE_ID
, &vdev
.senseid
, sizeof(vdev
.senseid
))) {
584 if (vdev
.senseid
.cu_type
== 0x3832) {
585 switch (vdev
.senseid
.cu_model
) {
586 case VIRTIO_ID_BLOCK
:
594 int enable_mss_facility(void)
597 ChscAreaSda
*sda_area
= (ChscAreaSda
*) chsc_page
;
599 memset(sda_area
, 0, PAGE_SIZE
);
600 sda_area
->request
.length
= 0x0400;
601 sda_area
->request
.code
= 0x0031;
602 sda_area
->operation_code
= 0x2;
604 ret
= chsc(sda_area
);
605 if ((ret
== 0) && (sda_area
->response
.code
== 0x0001)) {