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
14 #define VRING_WAIT_REPLY_TIMEOUT 3
16 static VRing block
[VIRTIO_MAX_VQS
];
17 static char ring_area
[VIRTIO_RING_SIZE
* VIRTIO_MAX_VQS
]
18 __attribute__((__aligned__(PAGE_SIZE
)));
20 static char chsc_page
[PAGE_SIZE
] __attribute__((__aligned__(PAGE_SIZE
)));
26 .ring_area
= ring_area
,
27 .wait_reply_timeout
= VRING_WAIT_REPLY_TIMEOUT
,
28 .schid
= { .one
= 1 },
31 VDev
*virtio_get_device(void)
36 VirtioDevType
virtio_get_device_type(void)
38 return vdev
.senseid
.cu_model
;
41 /* virtio spec v1.0 para 4.3.3.2 */
42 static long kvm_hypercall(unsigned long nr
, unsigned long param1
,
43 unsigned long param2
, unsigned long param3
)
45 register ulong r_nr
asm("1") = nr
;
46 register ulong r_param1
asm("2") = param1
;
47 register ulong r_param2
asm("3") = param2
;
48 register ulong r_param3
asm("4") = param3
;
49 register long retval
asm("2");
51 asm volatile ("diag 2,4,0x500"
53 : "d" (r_nr
), "0" (r_param1
), "r"(r_param2
), "d"(r_param3
)
59 static long virtio_notify(SubChannelId schid
, int vq_idx
, long cookie
)
61 return kvm_hypercall(KVM_S390_VIRTIO_CCW_NOTIFY
, *(u32
*)&schid
,
65 /***********************************************
67 ***********************************************/
69 static int drain_irqs(SubChannelId schid
)
75 /* FIXME: make use of TPI, for that enable subchannel and isc */
76 if (tsch(schid
, &irb
)) {
77 /* Might want to differentiate error codes later on. */
80 } else if (irb
.scsw
.dstat
!= 0xc) {
88 static int run_ccw(VDev
*vdev
, int cmd
, void *ptr
, int len
)
95 /* start command processing */
96 stsch_err(vdev
->schid
, &schib
);
97 schib
.scsw
.ctrl
= SCSW_FCTL_START_FUNC
;
98 msch(vdev
->schid
, &schib
);
100 /* start subchannel command */
102 orb
.cpa
= (u32
)(long)&ccw
;
109 r
= ssch(vdev
->schid
, &orb
);
111 * XXX Wait until device is done processing the CCW. For now we can
112 * assume that a simple tsch will have finished the CCW processing,
113 * but the architecture allows for asynchronous operation
116 r
= drain_irqs(vdev
->schid
);
121 static void vring_init(VRing
*vr
, VqInfo
*info
)
123 void *p
= (void *) info
->queue
;
125 debug_print_addr("init p", p
);
126 vr
->id
= info
->index
;
129 vr
->avail
= p
+ info
->num
* sizeof(VRingDesc
);
130 vr
->used
= (void *)(((unsigned long)&vr
->avail
->ring
[info
->num
]
131 + info
->align
- 1) & ~(info
->align
- 1));
133 /* Zero out all relevant field */
134 vr
->avail
->flags
= 0;
137 /* We're running with interrupts off anyways, so don't bother */
138 vr
->used
->flags
= VRING_USED_F_NO_NOTIFY
;
144 debug_print_addr("init vr", vr
);
147 static bool vring_notify(VRing
*vr
)
149 vr
->cookie
= virtio_notify(vr
->schid
, vr
->id
, vr
->cookie
);
150 return vr
->cookie
>= 0;
153 static void vring_send_buf(VRing
*vr
, void *p
, int len
, int flags
)
155 /* For follow-up chains we need to keep the first entry point */
156 if (!(flags
& VRING_HIDDEN_IS_CHAIN
)) {
157 vr
->avail
->ring
[vr
->avail
->idx
% vr
->num
] = vr
->next_idx
;
160 vr
->desc
[vr
->next_idx
].addr
= (ulong
)p
;
161 vr
->desc
[vr
->next_idx
].len
= len
;
162 vr
->desc
[vr
->next_idx
].flags
= flags
& ~VRING_HIDDEN_IS_CHAIN
;
163 vr
->desc
[vr
->next_idx
].next
= vr
->next_idx
;
164 vr
->desc
[vr
->next_idx
].next
++;
167 /* Chains only have a single ID */
168 if (!(flags
& VRING_DESC_F_NEXT
)) {
173 static u64
get_clock(void)
177 asm volatile("stck %0" : "=Q" (r
) : : "cc");
181 ulong
get_second(void)
183 return (get_clock() >> 12) / 1000000;
186 static int vr_poll(VRing
*vr
)
188 if (vr
->used
->idx
== vr
->used_idx
) {
194 vr
->used_idx
= vr
->used
->idx
;
197 vr
->desc
[0].flags
= 0;
198 return 1; /* vr has been updated */
202 * Wait for the host to reply.
204 * timeout is in seconds if > 0.
206 * Returns 0 on success, 1 on timeout.
208 static int vring_wait_reply(void)
210 ulong target_second
= get_second() + vdev
.wait_reply_timeout
;
212 /* Wait for any queue to be updated by the host */
216 for (i
= 0; i
< vdev
.nr_vqs
; i
++) {
217 r
+= vr_poll(&vdev
.vrings
[i
]);
223 } while (!vdev
.wait_reply_timeout
|| (get_second() < target_second
));
228 /***********************************************
230 ***********************************************/
232 static int virtio_blk_read_many(VDev
*vdev
,
233 ulong sector
, void *load_addr
, int sec_num
)
235 VirtioBlkOuthdr out_hdr
;
237 VRing
*vr
= &vdev
->vrings
[vdev
->cmd_vr_idx
];
239 /* Tell the host we want to read */
240 out_hdr
.type
= VIRTIO_BLK_T_IN
;
242 out_hdr
.sector
= virtio_sector_adjust(sector
);
244 vring_send_buf(vr
, &out_hdr
, sizeof(out_hdr
), VRING_DESC_F_NEXT
);
246 /* This is where we want to receive data */
247 vring_send_buf(vr
, load_addr
, virtio_get_block_size() * sec_num
,
248 VRING_DESC_F_WRITE
| VRING_HIDDEN_IS_CHAIN
|
252 vring_send_buf(vr
, &status
, sizeof(u8
),
253 VRING_DESC_F_WRITE
| VRING_HIDDEN_IS_CHAIN
);
255 /* Now we can tell the host to read */
258 if (drain_irqs(vr
->schid
)) {
259 /* Well, whatever status is supposed to contain... */
265 int virtio_read_many(ulong sector
, void *load_addr
, int sec_num
)
267 switch (vdev
.senseid
.cu_model
) {
268 case VIRTIO_ID_BLOCK
:
269 return virtio_blk_read_many(&vdev
, sector
, load_addr
, sec_num
);
271 panic("\n! No readable IPL device !\n");
275 unsigned long virtio_load_direct(ulong rec_list1
, ulong rec_list2
,
276 ulong subchan_id
, void *load_addr
)
280 int sec_num
= ((rec_list2
>> 32) & 0xffff) + 1;
281 int sec_len
= rec_list2
>> 48;
282 ulong addr
= (ulong
)load_addr
;
284 if (sec_len
!= virtio_get_block_size()) {
289 status
= virtio_read_many(sec
, (void *)addr
, sec_num
);
293 addr
+= sec_num
* virtio_get_block_size();
298 int virtio_read(ulong sector
, void *load_addr
)
300 return virtio_read_many(sector
, load_addr
, 1);
303 VirtioGDN
virtio_guessed_disk_nature(void)
305 return vdev
.guessed_disk_nature
;
308 void virtio_assume_scsi(void)
310 vdev
.guessed_disk_nature
= VIRTIO_GDN_SCSI
;
311 switch (vdev
.senseid
.cu_model
) {
312 case VIRTIO_ID_BLOCK
:
313 vdev
.config
.blk
.blk_size
= 512;
314 vdev
.config
.blk
.physical_block_exp
= 0;
319 void virtio_assume_iso9660(void)
321 vdev
.guessed_disk_nature
= VIRTIO_GDN_CDROM
;
322 switch (vdev
.senseid
.cu_model
) {
323 case VIRTIO_ID_BLOCK
:
324 vdev
.config
.blk
.blk_size
= 2048;
325 vdev
.config
.blk
.physical_block_exp
= 0;
330 void virtio_assume_eckd(void)
332 vdev
.guessed_disk_nature
= VIRTIO_GDN_DASD
;
333 switch (vdev
.senseid
.cu_model
) {
334 case VIRTIO_ID_BLOCK
:
335 vdev
.config
.blk
.blk_size
= 4096;
336 vdev
.config
.blk
.physical_block_exp
= 0;
338 /* this must be here to calculate code segment position */
339 vdev
.config
.blk
.geometry
.heads
= 15;
340 vdev
.config
.blk
.geometry
.sectors
= 12;
345 bool virtio_disk_is_scsi(void)
347 if (vdev
.guessed_disk_nature
== VIRTIO_GDN_SCSI
) {
350 switch (vdev
.senseid
.cu_model
) {
351 case VIRTIO_ID_BLOCK
:
352 return (vdev
.config
.blk
.geometry
.heads
== 255)
353 && (vdev
.config
.blk
.geometry
.sectors
== 63)
354 && (virtio_get_block_size() == 512);
360 * Other supported value pairs, if any, would need to be added here.
361 * Note: head count is always 15.
363 static inline u8
virtio_eckd_sectors_for_block_size(int size
)
378 bool virtio_disk_is_eckd(void)
380 const int block_size
= virtio_get_block_size();
382 if (vdev
.guessed_disk_nature
== VIRTIO_GDN_DASD
) {
385 switch (vdev
.senseid
.cu_model
) {
386 case VIRTIO_ID_BLOCK
:
387 return (vdev
.config
.blk
.geometry
.heads
== 15)
388 && (vdev
.config
.blk
.geometry
.sectors
==
389 virtio_eckd_sectors_for_block_size(block_size
));
394 bool virtio_ipl_disk_is_valid(void)
396 return virtio_disk_is_scsi() || virtio_disk_is_eckd();
399 int virtio_get_block_size(void)
401 switch (vdev
.senseid
.cu_model
) {
402 case VIRTIO_ID_BLOCK
:
403 return vdev
.config
.blk
.blk_size
<< vdev
.config
.blk
.physical_block_exp
;
408 uint8_t virtio_get_heads(void)
410 switch (vdev
.senseid
.cu_model
) {
411 case VIRTIO_ID_BLOCK
:
412 return vdev
.config
.blk
.geometry
.heads
;
417 uint8_t virtio_get_sectors(void)
419 switch (vdev
.senseid
.cu_model
) {
420 case VIRTIO_ID_BLOCK
:
421 return vdev
.config
.blk
.geometry
.sectors
;
426 uint64_t virtio_get_blocks(void)
428 switch (vdev
.senseid
.cu_model
) {
429 case VIRTIO_ID_BLOCK
:
430 return vdev
.config
.blk
.capacity
/
431 (virtio_get_block_size() / VIRTIO_SECTOR_SIZE
);
436 static void virtio_setup_ccw(VDev
*vdev
)
439 unsigned char status
= VIRTIO_CONFIG_S_DRIVER_OK
;
441 vdev
->config
.blk
.blk_size
= 0; /* mark "illegal" - setup started... */
442 vdev
->guessed_disk_nature
= VIRTIO_GDN_NONE
;
444 run_ccw(vdev
, CCW_CMD_VDEV_RESET
, NULL
, 0);
446 switch (vdev
->senseid
.cu_model
) {
447 case VIRTIO_ID_BLOCK
:
449 vdev
->cmd_vr_idx
= 0;
450 cfg_size
= sizeof(vdev
->config
.blk
);
453 panic("Unsupported virtio device\n");
455 IPL_assert(run_ccw(vdev
, CCW_CMD_READ_CONF
, &vdev
->config
, cfg_size
) == 0,
456 "Could not get block device configuration");
459 * Skipping CCW_CMD_READ_FEAT. We're not doing anything fancy, and
460 * we'll just stop dead anyway if anything does not work like we
464 for (i
= 0; i
< vdev
->nr_vqs
; i
++) {
466 .queue
= (unsigned long long) ring_area
+ (i
* VIRTIO_RING_SIZE
),
467 .align
= KVM_S390_VIRTIO_RING_ALIGN
,
477 run_ccw(vdev
, CCW_CMD_READ_VQ_CONF
, &config
, sizeof(config
)) == 0,
478 "Could not get block device VQ configuration");
479 info
.num
= config
.num
;
480 vring_init(&vdev
->vrings
[i
], &info
);
481 vdev
->vrings
[i
].schid
= vdev
->schid
;
482 IPL_assert(run_ccw(vdev
, CCW_CMD_SET_VQ
, &info
, sizeof(info
)) == 0,
483 "Cannot set VQ info");
486 run_ccw(vdev
, CCW_CMD_WRITE_STATUS
, &status
, sizeof(status
)) == 0,
487 "Could not write status to host");
490 void virtio_setup_device(SubChannelId schid
)
493 virtio_setup_ccw(&vdev
);
495 switch (vdev
.senseid
.cu_model
) {
496 case VIRTIO_ID_BLOCK
:
497 if (!virtio_ipl_disk_is_valid()) {
498 /* make sure all getters but blocksize return 0 for
501 memset(&vdev
.config
.blk
, 0, sizeof(vdev
.config
.blk
));
502 virtio_assume_scsi();
506 panic("\n! No IPL device available !\n");
510 bool virtio_is_supported(SubChannelId schid
)
513 memset(&vdev
.senseid
, 0, sizeof(vdev
.senseid
));
514 /* run sense id command */
515 if (run_ccw(&vdev
, CCW_CMD_SENSE_ID
, &vdev
.senseid
, sizeof(vdev
.senseid
))) {
518 if (vdev
.senseid
.cu_type
== 0x3832) {
519 switch (vdev
.senseid
.cu_model
) {
520 case VIRTIO_ID_BLOCK
:
527 int enable_mss_facility(void)
530 ChscAreaSda
*sda_area
= (ChscAreaSda
*) chsc_page
;
532 memset(sda_area
, 0, PAGE_SIZE
);
533 sda_area
->request
.length
= 0x0400;
534 sda_area
->request
.code
= 0x0031;
535 sda_area
->operation_code
= 0x2;
537 ret
= chsc(sda_area
);
538 if ((ret
== 0) && (sda_area
->response
.code
== 0x0001)) {