1 /* 2 * Virtio driver bits 3 * 4 * Copyright (c) 2013 Alexander Graf <agraf@suse.de> 5 * 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 8 * directory. 9 */ 10 11 #include "s390-ccw.h" 12 #include "virtio.h" 13 #include "virtio-scsi.h" 14 15 #define VRING_WAIT_REPLY_TIMEOUT 3 16 17 static VRing block[VIRTIO_MAX_VQS]; 18 static char ring_area[VIRTIO_RING_SIZE * VIRTIO_MAX_VQS] 19 __attribute__((__aligned__(PAGE_SIZE))); 20 21 static char chsc_page[PAGE_SIZE] __attribute__((__aligned__(PAGE_SIZE))); 22 23 static VDev vdev = { 24 .nr_vqs = 1, 25 .vrings = block, 26 .cmd_vr_idx = 0, 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, 31 .blk_factor = 1, 32 }; 33 34 VDev *virtio_get_device(void) 35 { 36 return &vdev; 37 } 38 39 VirtioDevType virtio_get_device_type(void) 40 { 41 return vdev.senseid.cu_model; 42 } 43 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) 47 { 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"); 53 54 asm volatile ("diag 2,4,0x500" 55 : "=d" (retval) 56 : "d" (r_nr), "0" (r_param1), "r"(r_param2), "d"(r_param3) 57 : "memory", "cc"); 58 59 return retval; 60 } 61 62 static long virtio_notify(SubChannelId schid, int vq_idx, long cookie) 63 { 64 return kvm_hypercall(KVM_S390_VIRTIO_CCW_NOTIFY, *(u32 *)&schid, 65 vq_idx, cookie); 66 } 67 68 /*********************************************** 69 * Virtio functions * 70 ***********************************************/ 71 72 static int drain_irqs(SubChannelId schid) 73 { 74 Irb irb = {}; 75 int r = 0; 76 77 while (1) { 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. */ 81 if (irb.scsw.cstat) { 82 r = -EIO; 83 } else if (irb.scsw.dstat != 0xc) { 84 r = -EIO; 85 } 86 return r; 87 } 88 } 89 } 90 91 static int run_ccw(VDev *vdev, int cmd, void *ptr, int len) 92 { 93 Ccw1 ccw = {}; 94 CmdOrb orb = {}; 95 Schib schib; 96 int r; 97 98 /* start command processing */ 99 stsch_err(vdev->schid, &schib); 100 /* enable the subchannel for IPL device */ 101 schib.pmcw.ena = 1; 102 msch(vdev->schid, &schib); 103 104 /* start subchannel command */ 105 orb.fmt = 1; 106 orb.cpa = (u32)(long)&ccw; 107 orb.lpm = 0x80; 108 109 ccw.cmd_code = cmd; 110 ccw.cda = (long)ptr; 111 ccw.count = len; 112 113 r = ssch(vdev->schid, &orb); 114 /* 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 118 */ 119 if (!r) { 120 r = drain_irqs(vdev->schid); 121 } 122 return r; 123 } 124 125 static void vring_init(VRing *vr, VqInfo *info) 126 { 127 void *p = (void *) info->queue; 128 129 debug_print_addr("init p", p); 130 vr->id = info->index; 131 vr->num = info->num; 132 vr->desc = p; 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)); 136 137 /* Zero out all relevant field */ 138 vr->avail->flags = 0; 139 vr->avail->idx = 0; 140 141 /* We're running with interrupts off anyways, so don't bother */ 142 vr->used->flags = VRING_USED_F_NO_NOTIFY; 143 vr->used->idx = 0; 144 vr->used_idx = 0; 145 vr->next_idx = 0; 146 vr->cookie = 0; 147 148 debug_print_addr("init vr", vr); 149 } 150 151 static bool vring_notify(VRing *vr) 152 { 153 vr->cookie = virtio_notify(vr->schid, vr->id, vr->cookie); 154 return vr->cookie >= 0; 155 } 156 157 static void vring_send_buf(VRing *vr, void *p, int len, int flags) 158 { 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; 162 } 163 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++; 169 vr->next_idx++; 170 171 /* Chains only have a single ID */ 172 if (!(flags & VRING_DESC_F_NEXT)) { 173 vr->avail->idx++; 174 } 175 } 176 177 static u64 get_clock(void) 178 { 179 u64 r; 180 181 asm volatile("stck %0" : "=Q" (r) : : "cc"); 182 return r; 183 } 184 185 ulong get_second(void) 186 { 187 return (get_clock() >> 12) / 1000000; 188 } 189 190 static int vr_poll(VRing *vr) 191 { 192 if (vr->used->idx == vr->used_idx) { 193 vring_notify(vr); 194 yield(); 195 return 0; 196 } 197 198 vr->used_idx = vr->used->idx; 199 vr->next_idx = 0; 200 vr->desc[0].len = 0; 201 vr->desc[0].flags = 0; 202 return 1; /* vr has been updated */ 203 } 204 205 /* 206 * Wait for the host to reply. 207 * 208 * timeout is in seconds if > 0. 209 * 210 * Returns 0 on success, 1 on timeout. 211 */ 212 static int vring_wait_reply(void) 213 { 214 ulong target_second = get_second() + vdev.wait_reply_timeout; 215 216 /* Wait for any queue to be updated by the host */ 217 do { 218 int i, r = 0; 219 220 for (i = 0; i < vdev.nr_vqs; i++) { 221 r += vr_poll(&vdev.vrings[i]); 222 } 223 yield(); 224 if (r) { 225 return 0; 226 } 227 } while (!vdev.wait_reply_timeout || (get_second() < target_second)); 228 229 return 1; 230 } 231 232 int virtio_run(VDev *vdev, int vqid, VirtioCmd *cmd) 233 { 234 VRing *vr = &vdev->vrings[vqid]; 235 int i = 0; 236 237 do { 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); 241 242 vring_wait_reply(); 243 if (drain_irqs(vr->schid)) { 244 return -1; 245 } 246 return 0; 247 } 248 249 /*********************************************** 250 * Virtio block * 251 ***********************************************/ 252 253 static int virtio_blk_read_many(VDev *vdev, 254 ulong sector, void *load_addr, int sec_num) 255 { 256 VirtioBlkOuthdr out_hdr; 257 u8 status; 258 VRing *vr = &vdev->vrings[vdev->cmd_vr_idx]; 259 260 /* Tell the host we want to read */ 261 out_hdr.type = VIRTIO_BLK_T_IN; 262 out_hdr.ioprio = 99; 263 out_hdr.sector = virtio_sector_adjust(sector); 264 265 vring_send_buf(vr, &out_hdr, sizeof(out_hdr), VRING_DESC_F_NEXT); 266 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 | 270 VRING_DESC_F_NEXT); 271 272 /* status field */ 273 vring_send_buf(vr, &status, sizeof(u8), 274 VRING_DESC_F_WRITE | VRING_HIDDEN_IS_CHAIN); 275 276 /* Now we can tell the host to read */ 277 vring_wait_reply(); 278 279 if (drain_irqs(vr->schid)) { 280 /* Well, whatever status is supposed to contain... */ 281 status = 1; 282 } 283 return status; 284 } 285 286 int virtio_read_many(ulong sector, void *load_addr, int sec_num) 287 { 288 switch (vdev.senseid.cu_model) { 289 case VIRTIO_ID_BLOCK: 290 return virtio_blk_read_many(&vdev, sector, load_addr, sec_num); 291 case VIRTIO_ID_SCSI: 292 return virtio_scsi_read_many(&vdev, sector, load_addr, sec_num); 293 } 294 panic("\n! No readable IPL device !\n"); 295 return -1; 296 } 297 298 unsigned long virtio_load_direct(ulong rec_list1, ulong rec_list2, 299 ulong subchan_id, void *load_addr) 300 { 301 u8 status; 302 int sec = rec_list1; 303 int sec_num = ((rec_list2 >> 32) & 0xffff) + 1; 304 int sec_len = rec_list2 >> 48; 305 ulong addr = (ulong)load_addr; 306 307 if (sec_len != virtio_get_block_size()) { 308 return -1; 309 } 310 311 sclp_print("."); 312 status = virtio_read_many(sec, (void *)addr, sec_num); 313 if (status) { 314 panic("I/O Error"); 315 } 316 addr += sec_num * virtio_get_block_size(); 317 318 return addr; 319 } 320 321 int virtio_read(ulong sector, void *load_addr) 322 { 323 return virtio_read_many(sector, load_addr, 1); 324 } 325 326 /* 327 * Other supported value pairs, if any, would need to be added here. 328 * Note: head count is always 15. 329 */ 330 static inline u8 virtio_eckd_sectors_for_block_size(int size) 331 { 332 switch (size) { 333 case 512: 334 return 49; 335 case 1024: 336 return 33; 337 case 2048: 338 return 21; 339 case 4096: 340 return 12; 341 } 342 return 0; 343 } 344 345 VirtioGDN virtio_guessed_disk_nature(void) 346 { 347 return vdev.guessed_disk_nature; 348 } 349 350 void virtio_assume_scsi(void) 351 { 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; 357 vdev.blk_factor = 1; 358 break; 359 case VIRTIO_ID_SCSI: 360 vdev.scsi_block_size = VIRTIO_SCSI_BLOCK_SIZE; 361 break; 362 } 363 } 364 365 void virtio_assume_iso9660(void) 366 { 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; 373 break; 374 case VIRTIO_ID_SCSI: 375 vdev.scsi_block_size = VIRTIO_ISO_BLOCK_SIZE; 376 break; 377 } 378 } 379 380 void virtio_assume_eckd(void) 381 { 382 vdev.guessed_disk_nature = VIRTIO_GDN_DASD; 383 vdev.blk_factor = 1; 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; 388 break; 389 case VIRTIO_ID_SCSI: 390 vdev.config.blk.blk_size = vdev.scsi_block_size; 391 break; 392 } 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); 396 } 397 398 bool virtio_disk_is_scsi(void) 399 { 400 if (vdev.guessed_disk_nature == VIRTIO_GDN_SCSI) { 401 return true; 402 } 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); 408 case VIRTIO_ID_SCSI: 409 return true; 410 } 411 return false; 412 } 413 414 bool virtio_disk_is_eckd(void) 415 { 416 const int block_size = virtio_get_block_size(); 417 418 if (vdev.guessed_disk_nature == VIRTIO_GDN_DASD) { 419 return true; 420 } 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)); 426 case VIRTIO_ID_SCSI: 427 return false; 428 } 429 return false; 430 } 431 432 bool virtio_ipl_disk_is_valid(void) 433 { 434 return virtio_disk_is_scsi() || virtio_disk_is_eckd(); 435 } 436 437 int virtio_get_block_size(void) 438 { 439 switch (vdev.senseid.cu_model) { 440 case VIRTIO_ID_BLOCK: 441 return vdev.config.blk.blk_size << vdev.config.blk.physical_block_exp; 442 case VIRTIO_ID_SCSI: 443 return vdev.scsi_block_size; 444 } 445 return 0; 446 } 447 448 uint8_t virtio_get_heads(void) 449 { 450 switch (vdev.senseid.cu_model) { 451 case VIRTIO_ID_BLOCK: 452 return vdev.config.blk.geometry.heads; 453 case VIRTIO_ID_SCSI: 454 return vdev.guessed_disk_nature == VIRTIO_GDN_DASD 455 ? vdev.config.blk.geometry.heads : 255; 456 } 457 return 0; 458 } 459 460 uint8_t virtio_get_sectors(void) 461 { 462 switch (vdev.senseid.cu_model) { 463 case VIRTIO_ID_BLOCK: 464 return vdev.config.blk.geometry.sectors; 465 case VIRTIO_ID_SCSI: 466 return vdev.guessed_disk_nature == VIRTIO_GDN_DASD 467 ? vdev.config.blk.geometry.sectors : 63; 468 } 469 return 0; 470 } 471 472 uint64_t virtio_get_blocks(void) 473 { 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; 478 case VIRTIO_ID_SCSI: 479 return vdev.scsi_last_block / factor; 480 } 481 return 0; 482 } 483 484 static void virtio_setup_ccw(VDev *vdev) 485 { 486 int i, cfg_size = 0; 487 unsigned char status = VIRTIO_CONFIG_S_DRIVER_OK; 488 489 IPL_assert(virtio_is_supported(vdev->schid), "PE"); 490 /* device ID has been established now */ 491 492 vdev->config.blk.blk_size = 0; /* mark "illegal" - setup started... */ 493 vdev->guessed_disk_nature = VIRTIO_GDN_NONE; 494 495 run_ccw(vdev, CCW_CMD_VDEV_RESET, NULL, 0); 496 497 switch (vdev->senseid.cu_model) { 498 case VIRTIO_ID_BLOCK: 499 vdev->nr_vqs = 1; 500 vdev->cmd_vr_idx = 0; 501 cfg_size = sizeof(vdev->config.blk); 502 break; 503 case VIRTIO_ID_SCSI: 504 vdev->nr_vqs = 3; 505 vdev->cmd_vr_idx = VR_REQUEST; 506 cfg_size = sizeof(vdev->config.scsi); 507 break; 508 default: 509 panic("Unsupported virtio device\n"); 510 } 511 IPL_assert(run_ccw(vdev, CCW_CMD_READ_CONF, &vdev->config, cfg_size) == 0, 512 "Could not get block device configuration"); 513 514 /* 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 517 * expect it. 518 */ 519 520 for (i = 0; i < vdev->nr_vqs; i++) { 521 VqInfo info = { 522 .queue = (unsigned long long) ring_area + (i * VIRTIO_RING_SIZE), 523 .align = KVM_S390_VIRTIO_RING_ALIGN, 524 .index = i, 525 .num = 0, 526 }; 527 VqConfig config = { 528 .index = i, 529 .num = 0, 530 }; 531 532 IPL_assert( 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"); 540 } 541 IPL_assert( 542 run_ccw(vdev, CCW_CMD_WRITE_STATUS, &status, sizeof(status)) == 0, 543 "Could not write status to host"); 544 } 545 546 void virtio_setup_device(SubChannelId schid) 547 { 548 vdev.schid = schid; 549 virtio_setup_ccw(&vdev); 550 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 556 * invalid IPL disk 557 */ 558 memset(&vdev.config.blk, 0, sizeof(vdev.config.blk)); 559 virtio_assume_scsi(); 560 } 561 break; 562 case VIRTIO_ID_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"); 567 568 sclp_print("Using virtio-scsi.\n"); 569 virtio_scsi_setup(&vdev); 570 break; 571 default: 572 panic("\n! No IPL device available !\n"); 573 } 574 } 575 576 bool virtio_is_supported(SubChannelId schid) 577 { 578 vdev.schid = 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))) { 582 return false; 583 } 584 if (vdev.senseid.cu_type == 0x3832) { 585 switch (vdev.senseid.cu_model) { 586 case VIRTIO_ID_BLOCK: 587 case VIRTIO_ID_SCSI: 588 return true; 589 } 590 } 591 return false; 592 } 593 594 int enable_mss_facility(void) 595 { 596 int ret; 597 ChscAreaSda *sda_area = (ChscAreaSda *) chsc_page; 598 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; 603 604 ret = chsc(sda_area); 605 if ((ret == 0) && (sda_area->response.code == 0x0001)) { 606 return 0; 607 } 608 return -EIO; 609 } 610