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 schib.scsw.ctrl = SCSW_FCTL_START_FUNC; 101 msch(vdev->schid, &schib); 102 103 /* start subchannel command */ 104 orb.fmt = 1; 105 orb.cpa = (u32)(long)&ccw; 106 orb.lpm = 0x80; 107 108 ccw.cmd_code = cmd; 109 ccw.cda = (long)ptr; 110 ccw.count = len; 111 112 r = ssch(vdev->schid, &orb); 113 /* 114 * XXX Wait until device is done processing the CCW. For now we can 115 * assume that a simple tsch will have finished the CCW processing, 116 * but the architecture allows for asynchronous operation 117 */ 118 if (!r) { 119 r = drain_irqs(vdev->schid); 120 } 121 return r; 122 } 123 124 static void vring_init(VRing *vr, VqInfo *info) 125 { 126 void *p = (void *) info->queue; 127 128 debug_print_addr("init p", p); 129 vr->id = info->index; 130 vr->num = info->num; 131 vr->desc = p; 132 vr->avail = p + info->num * sizeof(VRingDesc); 133 vr->used = (void *)(((unsigned long)&vr->avail->ring[info->num] 134 + info->align - 1) & ~(info->align - 1)); 135 136 /* Zero out all relevant field */ 137 vr->avail->flags = 0; 138 vr->avail->idx = 0; 139 140 /* We're running with interrupts off anyways, so don't bother */ 141 vr->used->flags = VRING_USED_F_NO_NOTIFY; 142 vr->used->idx = 0; 143 vr->used_idx = 0; 144 vr->next_idx = 0; 145 vr->cookie = 0; 146 147 debug_print_addr("init vr", vr); 148 } 149 150 static bool vring_notify(VRing *vr) 151 { 152 vr->cookie = virtio_notify(vr->schid, vr->id, vr->cookie); 153 return vr->cookie >= 0; 154 } 155 156 static void vring_send_buf(VRing *vr, void *p, int len, int flags) 157 { 158 /* For follow-up chains we need to keep the first entry point */ 159 if (!(flags & VRING_HIDDEN_IS_CHAIN)) { 160 vr->avail->ring[vr->avail->idx % vr->num] = vr->next_idx; 161 } 162 163 vr->desc[vr->next_idx].addr = (ulong)p; 164 vr->desc[vr->next_idx].len = len; 165 vr->desc[vr->next_idx].flags = flags & ~VRING_HIDDEN_IS_CHAIN; 166 vr->desc[vr->next_idx].next = vr->next_idx; 167 vr->desc[vr->next_idx].next++; 168 vr->next_idx++; 169 170 /* Chains only have a single ID */ 171 if (!(flags & VRING_DESC_F_NEXT)) { 172 vr->avail->idx++; 173 } 174 } 175 176 static u64 get_clock(void) 177 { 178 u64 r; 179 180 asm volatile("stck %0" : "=Q" (r) : : "cc"); 181 return r; 182 } 183 184 ulong get_second(void) 185 { 186 return (get_clock() >> 12) / 1000000; 187 } 188 189 static int vr_poll(VRing *vr) 190 { 191 if (vr->used->idx == vr->used_idx) { 192 vring_notify(vr); 193 yield(); 194 return 0; 195 } 196 197 vr->used_idx = vr->used->idx; 198 vr->next_idx = 0; 199 vr->desc[0].len = 0; 200 vr->desc[0].flags = 0; 201 return 1; /* vr has been updated */ 202 } 203 204 /* 205 * Wait for the host to reply. 206 * 207 * timeout is in seconds if > 0. 208 * 209 * Returns 0 on success, 1 on timeout. 210 */ 211 static int vring_wait_reply(void) 212 { 213 ulong target_second = get_second() + vdev.wait_reply_timeout; 214 215 /* Wait for any queue to be updated by the host */ 216 do { 217 int i, r = 0; 218 219 for (i = 0; i < vdev.nr_vqs; i++) { 220 r += vr_poll(&vdev.vrings[i]); 221 } 222 yield(); 223 if (r) { 224 return 0; 225 } 226 } while (!vdev.wait_reply_timeout || (get_second() < target_second)); 227 228 return 1; 229 } 230 231 int virtio_run(VDev *vdev, int vqid, VirtioCmd *cmd) 232 { 233 VRing *vr = &vdev->vrings[vqid]; 234 int i = 0; 235 236 do { 237 vring_send_buf(vr, cmd[i].data, cmd[i].size, 238 cmd[i].flags | (i ? VRING_HIDDEN_IS_CHAIN : 0)); 239 } while (cmd[i++].flags & VRING_DESC_F_NEXT); 240 241 vring_wait_reply(); 242 if (drain_irqs(vr->schid)) { 243 return -1; 244 } 245 return 0; 246 } 247 248 /*********************************************** 249 * Virtio block * 250 ***********************************************/ 251 252 static int virtio_blk_read_many(VDev *vdev, 253 ulong sector, void *load_addr, int sec_num) 254 { 255 VirtioBlkOuthdr out_hdr; 256 u8 status; 257 VRing *vr = &vdev->vrings[vdev->cmd_vr_idx]; 258 259 /* Tell the host we want to read */ 260 out_hdr.type = VIRTIO_BLK_T_IN; 261 out_hdr.ioprio = 99; 262 out_hdr.sector = virtio_sector_adjust(sector); 263 264 vring_send_buf(vr, &out_hdr, sizeof(out_hdr), VRING_DESC_F_NEXT); 265 266 /* This is where we want to receive data */ 267 vring_send_buf(vr, load_addr, virtio_get_block_size() * sec_num, 268 VRING_DESC_F_WRITE | VRING_HIDDEN_IS_CHAIN | 269 VRING_DESC_F_NEXT); 270 271 /* status field */ 272 vring_send_buf(vr, &status, sizeof(u8), 273 VRING_DESC_F_WRITE | VRING_HIDDEN_IS_CHAIN); 274 275 /* Now we can tell the host to read */ 276 vring_wait_reply(); 277 278 if (drain_irqs(vr->schid)) { 279 /* Well, whatever status is supposed to contain... */ 280 status = 1; 281 } 282 return status; 283 } 284 285 int virtio_read_many(ulong sector, void *load_addr, int sec_num) 286 { 287 switch (vdev.senseid.cu_model) { 288 case VIRTIO_ID_BLOCK: 289 return virtio_blk_read_many(&vdev, sector, load_addr, sec_num); 290 case VIRTIO_ID_SCSI: 291 return virtio_scsi_read_many(&vdev, sector, load_addr, sec_num); 292 } 293 panic("\n! No readable IPL device !\n"); 294 return -1; 295 } 296 297 unsigned long virtio_load_direct(ulong rec_list1, ulong rec_list2, 298 ulong subchan_id, void *load_addr) 299 { 300 u8 status; 301 int sec = rec_list1; 302 int sec_num = ((rec_list2 >> 32) & 0xffff) + 1; 303 int sec_len = rec_list2 >> 48; 304 ulong addr = (ulong)load_addr; 305 306 if (sec_len != virtio_get_block_size()) { 307 return -1; 308 } 309 310 sclp_print("."); 311 status = virtio_read_many(sec, (void *)addr, sec_num); 312 if (status) { 313 panic("I/O Error"); 314 } 315 addr += sec_num * virtio_get_block_size(); 316 317 return addr; 318 } 319 320 int virtio_read(ulong sector, void *load_addr) 321 { 322 return virtio_read_many(sector, load_addr, 1); 323 } 324 325 /* 326 * Other supported value pairs, if any, would need to be added here. 327 * Note: head count is always 15. 328 */ 329 static inline u8 virtio_eckd_sectors_for_block_size(int size) 330 { 331 switch (size) { 332 case 512: 333 return 49; 334 case 1024: 335 return 33; 336 case 2048: 337 return 21; 338 case 4096: 339 return 12; 340 } 341 return 0; 342 } 343 344 VirtioGDN virtio_guessed_disk_nature(void) 345 { 346 return vdev.guessed_disk_nature; 347 } 348 349 void virtio_assume_scsi(void) 350 { 351 switch (vdev.senseid.cu_model) { 352 case VIRTIO_ID_BLOCK: 353 vdev.guessed_disk_nature = VIRTIO_GDN_SCSI; 354 vdev.config.blk.blk_size = VIRTIO_SCSI_BLOCK_SIZE; 355 vdev.config.blk.physical_block_exp = 0; 356 vdev.blk_factor = 1; 357 break; 358 case VIRTIO_ID_SCSI: 359 vdev.scsi_block_size = VIRTIO_SCSI_BLOCK_SIZE; 360 break; 361 } 362 } 363 364 void virtio_assume_iso9660(void) 365 { 366 switch (vdev.senseid.cu_model) { 367 case VIRTIO_ID_BLOCK: 368 vdev.guessed_disk_nature = VIRTIO_GDN_SCSI; 369 vdev.config.blk.blk_size = VIRTIO_ISO_BLOCK_SIZE; 370 vdev.config.blk.physical_block_exp = 0; 371 vdev.blk_factor = VIRTIO_ISO_BLOCK_SIZE / VIRTIO_SECTOR_SIZE; 372 break; 373 case VIRTIO_ID_SCSI: 374 vdev.scsi_block_size = VIRTIO_ISO_BLOCK_SIZE; 375 break; 376 } 377 } 378 379 void virtio_assume_eckd(void) 380 { 381 vdev.guessed_disk_nature = VIRTIO_GDN_DASD; 382 vdev.blk_factor = 1; 383 vdev.config.blk.physical_block_exp = 0; 384 switch (vdev.senseid.cu_model) { 385 case VIRTIO_ID_BLOCK: 386 vdev.config.blk.blk_size = 4096; 387 break; 388 case VIRTIO_ID_SCSI: 389 vdev.config.blk.blk_size = vdev.scsi_block_size; 390 break; 391 } 392 vdev.config.blk.geometry.heads = 15; 393 vdev.config.blk.geometry.sectors = 394 virtio_eckd_sectors_for_block_size(vdev.config.blk.blk_size); 395 } 396 397 bool virtio_disk_is_scsi(void) 398 { 399 if (vdev.guessed_disk_nature == VIRTIO_GDN_SCSI) { 400 return true; 401 } 402 switch (vdev.senseid.cu_model) { 403 case VIRTIO_ID_BLOCK: 404 return (vdev.config.blk.geometry.heads == 255) 405 && (vdev.config.blk.geometry.sectors == 63) 406 && (virtio_get_block_size() == VIRTIO_SCSI_BLOCK_SIZE); 407 case VIRTIO_ID_SCSI: 408 return true; 409 } 410 return false; 411 } 412 413 bool virtio_disk_is_eckd(void) 414 { 415 const int block_size = virtio_get_block_size(); 416 417 if (vdev.guessed_disk_nature == VIRTIO_GDN_DASD) { 418 return true; 419 } 420 switch (vdev.senseid.cu_model) { 421 case VIRTIO_ID_BLOCK: 422 return (vdev.config.blk.geometry.heads == 15) 423 && (vdev.config.blk.geometry.sectors == 424 virtio_eckd_sectors_for_block_size(block_size)); 425 case VIRTIO_ID_SCSI: 426 return false; 427 } 428 return false; 429 } 430 431 bool virtio_ipl_disk_is_valid(void) 432 { 433 return virtio_disk_is_scsi() || virtio_disk_is_eckd(); 434 } 435 436 int virtio_get_block_size(void) 437 { 438 switch (vdev.senseid.cu_model) { 439 case VIRTIO_ID_BLOCK: 440 return vdev.config.blk.blk_size << vdev.config.blk.physical_block_exp; 441 case VIRTIO_ID_SCSI: 442 return vdev.scsi_block_size; 443 } 444 return 0; 445 } 446 447 uint8_t virtio_get_heads(void) 448 { 449 switch (vdev.senseid.cu_model) { 450 case VIRTIO_ID_BLOCK: 451 return vdev.config.blk.geometry.heads; 452 case VIRTIO_ID_SCSI: 453 return vdev.guessed_disk_nature == VIRTIO_GDN_DASD 454 ? vdev.config.blk.geometry.heads : 255; 455 } 456 return 0; 457 } 458 459 uint8_t virtio_get_sectors(void) 460 { 461 switch (vdev.senseid.cu_model) { 462 case VIRTIO_ID_BLOCK: 463 return vdev.config.blk.geometry.sectors; 464 case VIRTIO_ID_SCSI: 465 return vdev.guessed_disk_nature == VIRTIO_GDN_DASD 466 ? vdev.config.blk.geometry.sectors : 63; 467 } 468 return 0; 469 } 470 471 uint64_t virtio_get_blocks(void) 472 { 473 const uint64_t factor = virtio_get_block_size() / VIRTIO_SECTOR_SIZE; 474 switch (vdev.senseid.cu_model) { 475 case VIRTIO_ID_BLOCK: 476 return vdev.config.blk.capacity / factor; 477 case VIRTIO_ID_SCSI: 478 return vdev.scsi_last_block / factor; 479 } 480 return 0; 481 } 482 483 static void virtio_setup_ccw(VDev *vdev) 484 { 485 int i, cfg_size = 0; 486 unsigned char status = VIRTIO_CONFIG_S_DRIVER_OK; 487 488 IPL_assert(virtio_is_supported(vdev->schid), "PE"); 489 /* device ID has been established now */ 490 491 vdev->config.blk.blk_size = 0; /* mark "illegal" - setup started... */ 492 vdev->guessed_disk_nature = VIRTIO_GDN_NONE; 493 494 run_ccw(vdev, CCW_CMD_VDEV_RESET, NULL, 0); 495 496 switch (vdev->senseid.cu_model) { 497 case VIRTIO_ID_BLOCK: 498 vdev->nr_vqs = 1; 499 vdev->cmd_vr_idx = 0; 500 cfg_size = sizeof(vdev->config.blk); 501 break; 502 case VIRTIO_ID_SCSI: 503 vdev->nr_vqs = 3; 504 vdev->cmd_vr_idx = VR_REQUEST; 505 cfg_size = sizeof(vdev->config.scsi); 506 break; 507 default: 508 panic("Unsupported virtio device\n"); 509 } 510 IPL_assert(run_ccw(vdev, CCW_CMD_READ_CONF, &vdev->config, cfg_size) == 0, 511 "Could not get block device configuration"); 512 513 /* 514 * Skipping CCW_CMD_READ_FEAT. We're not doing anything fancy, and 515 * we'll just stop dead anyway if anything does not work like we 516 * expect it. 517 */ 518 519 for (i = 0; i < vdev->nr_vqs; i++) { 520 VqInfo info = { 521 .queue = (unsigned long long) ring_area + (i * VIRTIO_RING_SIZE), 522 .align = KVM_S390_VIRTIO_RING_ALIGN, 523 .index = i, 524 .num = 0, 525 }; 526 VqConfig config = { 527 .index = i, 528 .num = 0, 529 }; 530 531 IPL_assert( 532 run_ccw(vdev, CCW_CMD_READ_VQ_CONF, &config, sizeof(config)) == 0, 533 "Could not get block device VQ configuration"); 534 info.num = config.num; 535 vring_init(&vdev->vrings[i], &info); 536 vdev->vrings[i].schid = vdev->schid; 537 IPL_assert(run_ccw(vdev, CCW_CMD_SET_VQ, &info, sizeof(info)) == 0, 538 "Cannot set VQ info"); 539 } 540 IPL_assert( 541 run_ccw(vdev, CCW_CMD_WRITE_STATUS, &status, sizeof(status)) == 0, 542 "Could not write status to host"); 543 } 544 545 void virtio_setup_device(SubChannelId schid) 546 { 547 vdev.schid = schid; 548 virtio_setup_ccw(&vdev); 549 550 switch (vdev.senseid.cu_model) { 551 case VIRTIO_ID_BLOCK: 552 sclp_print("Using virtio-blk.\n"); 553 if (!virtio_ipl_disk_is_valid()) { 554 /* make sure all getters but blocksize return 0 for 555 * invalid IPL disk 556 */ 557 memset(&vdev.config.blk, 0, sizeof(vdev.config.blk)); 558 virtio_assume_scsi(); 559 } 560 break; 561 case VIRTIO_ID_SCSI: 562 IPL_assert(vdev.config.scsi.sense_size == VIRTIO_SCSI_SENSE_SIZE, 563 "Config: sense size mismatch"); 564 IPL_assert(vdev.config.scsi.cdb_size == VIRTIO_SCSI_CDB_SIZE, 565 "Config: CDB size mismatch"); 566 567 sclp_print("Using virtio-scsi.\n"); 568 virtio_scsi_setup(&vdev); 569 break; 570 default: 571 panic("\n! No IPL device available !\n"); 572 } 573 } 574 575 bool virtio_is_supported(SubChannelId schid) 576 { 577 vdev.schid = schid; 578 memset(&vdev.senseid, 0, sizeof(vdev.senseid)); 579 /* run sense id command */ 580 if (run_ccw(&vdev, CCW_CMD_SENSE_ID, &vdev.senseid, sizeof(vdev.senseid))) { 581 return false; 582 } 583 if (vdev.senseid.cu_type == 0x3832) { 584 switch (vdev.senseid.cu_model) { 585 case VIRTIO_ID_BLOCK: 586 case VIRTIO_ID_SCSI: 587 return true; 588 } 589 } 590 return false; 591 } 592 593 int enable_mss_facility(void) 594 { 595 int ret; 596 ChscAreaSda *sda_area = (ChscAreaSda *) chsc_page; 597 598 memset(sda_area, 0, PAGE_SIZE); 599 sda_area->request.length = 0x0400; 600 sda_area->request.code = 0x0031; 601 sda_area->operation_code = 0x2; 602 603 ret = chsc(sda_area); 604 if ((ret == 0) && (sda_area->response.code == 0x0001)) { 605 return 0; 606 } 607 return -EIO; 608 } 609