1 /* $NetBSD: vdsk.c,v 1.22 2026/07/23 17:43:01 palle Exp $ */ 2 /* $OpenBSD: vdsk.c,v 1.46 2015/01/25 21:42:13 kettenis Exp $ */ 3 /* 4 * Copyright (c) 2009, 2011 Mark Kettenis 5 * 6 * Permission to use, copy, modify, and distribute this software for any 7 * purpose with or without fee is hereby granted, provided that the above 8 * copyright notice and this permission notice appear in all copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 17 */ 18 19 #include <sys/kmem.h> 20 #include <sys/param.h> 21 #include <sys/buf.h> 22 #include <sys/device.h> 23 #include <sys/systm.h> 24 25 #include <machine/autoconf.h> 26 #include <machine/hypervisor.h> 27 28 #include <uvm/uvm_extern.h> 29 30 #include <dev/scsipi/scsi_all.h> 31 #include <dev/scsipi/scsipi_disk.h> 32 #include <dev/scsipi/scsipi_cd.h> 33 #include <dev/scsipi/scsiconf.h> 34 35 #include <dev/scsipi/scsi_disk.h> 36 #include <dev/scsipi/scsipi_all.h> 37 #include <dev/scsipi/scsiconf.h> 38 #include <dev/scsipi/scsi_message.h> 39 40 #include <sparc64/dev/cbusvar.h> 41 #include <sparc64/dev/ldcvar.h> 42 #include <sparc64/dev/viovar.h> 43 44 #ifdef VDSK_DEBUG 45 #define DPRINTF(x) printf x 46 #else 47 #define DPRINTF(x) 48 #endif 49 50 #define VDSK_TX_ENTRIES 32 51 #define VDSK_RX_ENTRIES 32 52 53 struct vd_attr_info { 54 struct vio_msg_tag tag; 55 uint8_t xfer_mode; 56 uint8_t vd_type; 57 uint8_t vd_mtype; 58 uint8_t _reserved1; 59 uint32_t vdisk_block_size; 60 uint64_t operations; 61 uint64_t vdisk_size; 62 uint64_t max_xfer_sz; 63 uint64_t _reserved2[2]; 64 }; 65 66 #define VD_DISK_TYPE_SLICE 0x01 67 #define VD_DISK_TYPE_DISK 0x02 68 69 #define VD_MEDIA_TYPE_FIXED 0x01 70 #define VD_MEDIA_TYPE_CD 0x02 71 #define VD_MEDIA_TYPE_DVD 0x03 72 73 /* vDisk version 1.0. */ 74 #define VD_OP_BREAD 0x01 75 #define VD_OP_BWRITE 0x02 76 #define VD_OP_FLUSH 0x03 77 #define VD_OP_GET_WCE 0x04 78 #define VD_OP_SET_WCE 0x05 79 #define VD_OP_GET_VTOC 0x06 80 #define VD_OP_SET_VTOC 0x07 81 #define VD_OP_GET_DISKGEOM 0x08 82 #define VD_OP_SET_DISKGEOM 0x09 83 #define VD_OP_GET_DEVID 0x0b 84 #define VD_OP_GET_EFI 0x0c 85 #define VD_OP_SET_EFI 0x0d 86 87 /* vDisk version 1.1 */ 88 #define VD_OP_SCSICMD 0x0a 89 #define VD_OP_RESET 0x0e 90 #define VD_OP_GET_ACCESS 0x0f 91 #define VD_OP_SET_ACCESS 0x10 92 #define VD_OP_GET_CAPACITY 0x11 93 94 struct vd_desc { 95 struct vio_dring_hdr hdr; 96 uint64_t req_id; 97 uint8_t operation; 98 uint8_t slice; 99 uint16_t _reserved1; 100 uint32_t status; 101 uint64_t offset; 102 uint64_t size; 103 uint32_t ncookies; 104 uint32_t _reserved2; 105 struct ldc_cookie cookie[MAXPHYS / PAGE_SIZE]; 106 }; 107 108 #define VD_SLICE_NONE 0xff 109 110 struct vdsk_dring { 111 bus_dmamap_t vd_map; 112 bus_dma_segment_t vd_seg; 113 struct vd_desc *vd_desc; 114 int vd_nentries; 115 }; 116 117 #if OPENBSD_BUSDMA 118 struct vdsk_dring *vdsk_dring_alloc(bus_dma_tag_t, int); 119 void vdsk_dring_free(bus_dma_tag_t, struct vdsk_dring *); 120 #else 121 struct vdsk_dring *vdsk_dring_alloc(int); 122 void vdsk_dring_free(struct vdsk_dring *); 123 #endif 124 125 /* 126 * We support vDisk 1.0 and 1.1. 127 */ 128 #define VDSK_MAJOR 1 129 #define VDSK_MINOR 1 130 131 struct vdsk_soft_desc { 132 int vsd_map_idx[MAXPHYS / PAGE_SIZE]; 133 struct scsipi_xfer *vsd_xs; 134 int vsd_ncookies; 135 }; 136 137 struct vdsk_softc { 138 device_t sc_dv; 139 140 struct scsipi_adapter sc_adapter; 141 struct scsipi_channel sc_channel; 142 143 bus_space_tag_t sc_bustag; 144 bus_dma_tag_t sc_dmatag; 145 146 void *sc_tx_ih; 147 void *sc_rx_ih; 148 149 struct ldc_conn sc_lc; 150 151 uint16_t sc_vio_state; 152 #define VIO_SND_VER_INFO 0x0001 153 #define VIO_ACK_VER_INFO 0x0002 154 #define VIO_SND_ATTR_INFO 0x0004 155 #define VIO_ACK_ATTR_INFO 0x0008 156 #define VIO_SND_DRING_REG 0x0010 157 #define VIO_ACK_DRING_REG 0x0020 158 #define VIO_SND_RDX 0x0040 159 #define VIO_ACK_RDX 0x0080 160 #define VIO_ESTABLISHED 0x00ff 161 162 uint16_t sc_major; 163 uint16_t sc_minor; 164 165 uint32_t sc_local_sid; 166 uint64_t sc_dring_ident; 167 uint64_t sc_seq_no; 168 169 int sc_tx_cnt; 170 int sc_tx_prod; 171 int sc_tx_cons; 172 173 struct ldc_map *sc_lm; 174 struct vdsk_dring *sc_vd; 175 struct vdsk_soft_desc *sc_vsd; 176 177 uint32_t sc_vdisk_block_size; 178 uint64_t sc_vdisk_size; 179 uint8_t sc_vd_mtype; 180 }; 181 182 int vdsk_match(device_t, cfdata_t, void *); 183 void vdsk_attach(device_t, device_t, void *); 184 void vdsk_scsipi_request(struct scsipi_channel *, scsipi_adapter_req_t, 185 void *); 186 187 CFATTACH_DECL_NEW(vdsk, sizeof(struct vdsk_softc), 188 vdsk_match, vdsk_attach, NULL, NULL); 189 190 int vdsk_tx_intr(void *); 191 int vdsk_rx_intr(void *); 192 193 void vdsk_rx_data(struct ldc_conn *, struct ldc_pkt *); 194 void vdsk_rx_vio_ctrl(struct vdsk_softc *, struct vio_msg *); 195 void vdsk_rx_vio_ver_info(struct vdsk_softc *, struct vio_msg_tag *); 196 void vdsk_rx_vio_attr_info(struct vdsk_softc *, struct vio_msg_tag *); 197 void vdsk_rx_vio_dring_reg(struct vdsk_softc *, struct vio_msg_tag *); 198 void vdsk_rx_vio_rdx(struct vdsk_softc *sc, struct vio_msg_tag *); 199 void vdsk_rx_vio_data(struct vdsk_softc *sc, struct vio_msg *); 200 void vdsk_rx_vio_dring_data(struct vdsk_softc *sc, struct vio_msg_tag *); 201 202 void vdsk_ldc_reset(struct ldc_conn *); 203 void vdsk_ldc_start(struct ldc_conn *); 204 205 void vdsk_sendmsg(struct vdsk_softc *, void *, size_t); 206 void vdsk_send_ver_info(struct vdsk_softc *, uint16_t, uint16_t); 207 void vdsk_send_attr_info(struct vdsk_softc *); 208 void vdsk_send_dring_reg(struct vdsk_softc *); 209 void vdsk_send_rdx(struct vdsk_softc *); 210 211 void *vdsk_io_get(void *); 212 void vdsk_io_put(void *, void *); 213 214 void vdsk_scsi_cmd(struct vdsk_softc *sc, struct scsipi_xfer *); 215 int vdsk_submit_cmd(struct vdsk_softc *sc, struct scsipi_xfer *); 216 void vdsk_complete_cmd(struct vdsk_softc *sc, struct scsipi_xfer *, int); 217 void vdsk_scsi_inq(struct vdsk_softc *sc, struct scsipi_xfer *); 218 void vdsk_scsi_inquiry(struct vdsk_softc *sc, struct scsipi_xfer *); 219 void vdsk_scsi_mode_sense_6(struct vdsk_softc *sc, struct scsipi_xfer *); 220 void vdsk_scsi_mode_sense_10(struct vdsk_softc *sc, struct scsipi_xfer *); 221 void vdsk_scsi_mode_select_6(struct vdsk_softc *sc, struct scsipi_xfer *); 222 void vdsk_scsi_mode_select_10(struct vdsk_softc *sc, struct scsipi_xfer *); 223 void vdsk_scsi_read_toc(struct vdsk_softc *sc, struct scsipi_xfer *); 224 void vdsk_scsi_test_unit_ready(struct vdsk_softc *sc, struct scsipi_xfer *); 225 void vdsk_scsi_start_stop(struct vdsk_softc *sc, struct scsipi_xfer *); 226 void vdsk_scsi_prevent_allow_medium_removal(struct vdsk_softc *sc, struct scsipi_xfer *); 227 void vdsk_scsi_maintenance_in(struct vdsk_softc *sc, struct scsipi_xfer *); 228 void vdsk_scsi_capacity(struct vdsk_softc *sc, struct scsipi_xfer *); 229 void vdsk_scsi_capacity16(struct vdsk_softc *sc, struct scsipi_xfer *); 230 void vdsk_scsi_report_luns(struct vdsk_softc *sc, struct scsipi_xfer *); 231 void vdsk_scsi_done(struct scsipi_xfer *, int); 232 233 int 234 vdsk_match(device_t parent, cfdata_t match, void *aux) 235 { 236 struct cbus_attach_args *ca = aux; 237 238 if (strcmp(ca->ca_name, "disk") == 0) 239 return (1); 240 241 return (0); 242 } 243 244 void 245 vdsk_attach(device_t parent, device_t self, void *aux) 246 { 247 struct vdsk_softc *sc = device_private(self); 248 struct cbus_attach_args *ca = aux; 249 struct ldc_conn *lc; 250 int err, s; 251 int timeout; 252 vaddr_t va; 253 paddr_t pa; 254 255 sc->sc_bustag = ca->ca_bustag; 256 sc->sc_dmatag = ca->ca_dmatag; 257 258 printf(": ivec 0x%llx, 0x%llx", 259 (long long unsigned int)ca->ca_tx_ino, 260 (long long unsigned int)ca->ca_rx_ino); 261 262 /* 263 * Un-configure queues before registering interrupt handlers, 264 * such that we don't get any stale LDC packets or events. 265 */ 266 hv_ldc_tx_qconf(ca->ca_id, 0, 0); 267 hv_ldc_rx_qconf(ca->ca_id, 0, 0); 268 269 sc->sc_tx_ih = bus_intr_establish(ca->ca_bustag, ca->ca_tx_ino, 270 IPL_BIO, vdsk_tx_intr, sc); 271 sc->sc_rx_ih = bus_intr_establish(ca->ca_bustag, ca->ca_rx_ino, 272 IPL_BIO, vdsk_rx_intr, sc); 273 if (sc->sc_tx_ih == NULL || sc->sc_rx_ih == NULL) { 274 printf(", can't establish interrupt\n"); 275 return; 276 } 277 278 lc = &sc->sc_lc; 279 lc->lc_id = ca->ca_id; 280 lc->lc_sc = sc; 281 lc->lc_reset = vdsk_ldc_reset; 282 lc->lc_start = vdsk_ldc_start; 283 lc->lc_rx_data = vdsk_rx_data; 284 285 #if OPENBSD_BUSDMA 286 lc->lc_txq = ldc_queue_alloc(sc->sc_dmatag, VDSK_TX_ENTRIES); 287 #else 288 lc->lc_txq = ldc_queue_alloc(VDSK_TX_ENTRIES); 289 #endif 290 #if OPENBSD_BUSDMA 291 lc->lc_rxq = ldc_queue_alloc(sc->sc_dmatag, VDSK_RX_ENTRIES); 292 #else 293 lc->lc_rxq = ldc_queue_alloc(VDSK_RX_ENTRIES); 294 #endif 295 #if OPENBSD_BUSDMA 296 sc->sc_lm = ldc_map_alloc(sc->sc_dmatag, 2048); 297 #else 298 sc->sc_lm = ldc_map_alloc(2048); 299 #endif 300 #if OPENBSD_BUSDMA 301 err = hv_ldc_set_map_table(lc->lc_id, 302 sc->sc_lm->lm_map->dm_segs[0].ds_addr, sc->sc_lm->lm_nentries); 303 #else 304 va = (vaddr_t)sc->sc_lm->lm_slot; 305 pa = 0; 306 if (pmap_extract(pmap_kernel(), va, &pa) == FALSE) 307 panic("pmap_extract failed %lx\n", va); 308 err = hv_ldc_set_map_table(lc->lc_id, pa, 2048); 309 #endif 310 if (err != H_EOK) { 311 printf("hv_ldc_set_map_table %d\n", err); 312 goto free_map; 313 } 314 #if OPENBSD_BUSDMA 315 sc->sc_vd = vdsk_dring_alloc(sc->sc_dmatag, 32); 316 #else 317 sc->sc_vd = vdsk_dring_alloc(32); 318 #endif 319 sc->sc_vsd = kmem_zalloc(32 * sizeof(*sc->sc_vsd), KM_SLEEP); 320 321 #if OPENBSD_BUSDMA 322 sc->sc_lm->lm_slot[0].entry = sc->sc_vd->vd_map->dm_segs[0].ds_addr; 323 #else 324 va = (vaddr_t)sc->sc_vd->vd_desc; 325 pa = 0; 326 if (pmap_extract(pmap_kernel(), va, &pa) == FALSE) 327 panic("pmap_extract failed %lx\n", va); 328 329 sc->sc_lm->lm_slot[0].entry = pa; 330 #endif 331 sc->sc_lm->lm_slot[0].entry &= LDC_MTE_RA_MASK; 332 sc->sc_lm->lm_slot[0].entry |= LDC_MTE_CPR | LDC_MTE_CPW; 333 sc->sc_lm->lm_slot[0].entry |= LDC_MTE_R | LDC_MTE_W; 334 sc->sc_lm->lm_next = 1; 335 sc->sc_lm->lm_count = 1; 336 va = lc->lc_txq->lq_va; 337 pa = 0; 338 if (pmap_extract(pmap_kernel(), va, &pa) == FALSE) 339 panic("pmap_extract failed %lx\n", va); 340 #if OPENBSD_BUSDMA 341 err = hv_ldc_tx_qconf(lc->lc_id, 342 lc->lc_txq->lq_map->dm_segs[0].ds_addr, lc->lc_txq->lq_nentries); 343 #else 344 err = hv_ldc_tx_qconf(lc->lc_id, pa, lc->lc_txq->lq_nentries); 345 #endif 346 if (err != H_EOK) 347 printf("hv_ldc_tx_qconf %d\n", err); 348 va = (vaddr_t)lc->lc_rxq->lq_va; 349 pa = 0; 350 if (pmap_extract(pmap_kernel(), va, &pa) == FALSE) 351 panic("pmap_extract failed %lx\n", va); 352 #if OPENBSD_BUSDMA 353 err = hv_ldc_rx_qconf(lc->lc_id, 354 lc->lc_rxq->lq_map->dm_segs[0].ds_addr, lc->lc_rxq->lq_nentries); 355 #else 356 err = hv_ldc_rx_qconf(lc->lc_id, pa, lc->lc_rxq->lq_nentries); 357 #endif 358 if (err != H_EOK) 359 printf("hv_ldc_rx_qconf %d\n", err); 360 361 cbus_intr_setenabled(sc->sc_bustag, ca->ca_tx_ino, INTR_ENABLED); 362 cbus_intr_setenabled(sc->sc_bustag, ca->ca_rx_ino, INTR_ENABLED); 363 364 ldc_send_vers(lc); 365 366 printf("\n"); 367 368 /* 369 * Interrupts aren't enabled during autoconf, so poll for VIO 370 * peer-to-peer handshake completion. 371 */ 372 s = splbio(); 373 timeout = 10 * 1000; 374 do { 375 if (vdsk_rx_intr(sc) && sc->sc_vio_state == VIO_ESTABLISHED) 376 break; 377 378 delay(1000); 379 } while(--timeout > 0); 380 splx(s); 381 382 if (sc->sc_vio_state != VIO_ESTABLISHED) { 383 printf("vio not established: %d\n", sc->sc_vio_state); 384 return; 385 } 386 387 sc->sc_dv = self; 388 389 sc->sc_adapter.adapt_dev = sc->sc_dv; 390 sc->sc_adapter.adapt_nchannels = 1; 391 sc->sc_adapter.adapt_openings = sc->sc_vd->vd_nentries - 1; 392 sc->sc_adapter.adapt_max_periph = sc->sc_vd->vd_nentries - 1; 393 394 sc->sc_adapter.adapt_minphys = minphys; 395 sc->sc_adapter.adapt_request = vdsk_scsipi_request; 396 397 sc->sc_channel.chan_adapter = &sc->sc_adapter; 398 sc->sc_channel.chan_bustype = &scsi_bustype; 399 sc->sc_channel.chan_channel = 0; 400 sc->sc_channel.chan_ntargets = 2; /* XXX why not 1? */ 401 sc->sc_channel.chan_nluns = 1; /* XXX slices should be presented as luns? */ 402 sc->sc_channel.chan_id = 0; 403 sc->sc_channel.chan_flags = SCSIPI_CHAN_NOSETTLE; 404 405 config_found(self, &sc->sc_channel, scsiprint, CFARGS_NONE); 406 407 return; 408 409 free_map: 410 hv_ldc_set_map_table(lc->lc_id, 0, 0); 411 #if OPENBSD_BUSDMA 412 ldc_map_free(sc->sc_dmatag, sc->sc_lm); 413 #else 414 ldc_map_free(sc->sc_lm); 415 #endif 416 } 417 418 void 419 vdsk_scsipi_request(struct scsipi_channel *chan, scsipi_adapter_req_t req, 420 void *arg) 421 { 422 423 struct vdsk_softc *sc; 424 struct scsipi_xfer *xs; 425 426 sc = device_private(chan->chan_adapter->adapt_dev); 427 428 xs = arg; 429 430 switch (req) { 431 case ADAPTER_REQ_RUN_XFER: 432 vdsk_scsi_cmd(sc, xs); 433 break; 434 case ADAPTER_REQ_GROW_RESOURCES: 435 case ADAPTER_REQ_SET_XFER_MODE: 436 /* Ignored */ 437 break; 438 default: 439 panic("req unhandled: %x", req); 440 } 441 442 } 443 444 int 445 vdsk_tx_intr(void *arg) 446 { 447 panic("%s: not verified yet", __FUNCTION__); 448 449 struct vdsk_softc *sc = arg; 450 struct ldc_conn *lc = &sc->sc_lc; 451 uint64_t tx_head, tx_tail, tx_state; 452 453 hv_ldc_tx_get_state(lc->lc_id, &tx_head, &tx_tail, &tx_state); 454 if (tx_state != lc->lc_tx_state) { 455 switch (tx_state) { 456 case LDC_CHANNEL_DOWN: 457 DPRINTF(("Tx link down\n")); 458 break; 459 case LDC_CHANNEL_UP: 460 DPRINTF(("Tx link up\n")); 461 break; 462 case LDC_CHANNEL_RESET: 463 DPRINTF(("Tx link reset\n")); 464 break; 465 } 466 lc->lc_tx_state = tx_state; 467 } 468 469 return (1); 470 } 471 472 int 473 vdsk_rx_intr(void *arg) 474 { 475 struct vdsk_softc *sc = arg; 476 struct ldc_conn *lc = &sc->sc_lc; 477 uint64_t rx_head, rx_tail, rx_state; 478 struct ldc_pkt *lp; 479 int err; 480 481 err = hv_ldc_rx_get_state(lc->lc_id, &rx_head, &rx_tail, &rx_state); 482 if (err == H_EINVAL) { 483 printf("hv_ldc_rx_get_state H_EINVAL\n"); 484 return (0); 485 } 486 if (err != H_EOK) { 487 printf("hv_ldc_rx_get_state %d\n", err); 488 return (0); 489 } 490 491 if (rx_state != lc->lc_rx_state) { 492 sc->sc_vio_state = 0; 493 lc->lc_tx_seqid = 0; 494 lc->lc_state = 0; 495 switch (rx_state) { 496 case LDC_CHANNEL_DOWN: 497 DPRINTF(("Rx link down\n")); 498 break; 499 case LDC_CHANNEL_UP: 500 DPRINTF(("Rx link up\n")); 501 ldc_send_vers(lc); 502 break; 503 case LDC_CHANNEL_RESET: 504 DPRINTF(("Rx link reset\n")); 505 ldc_send_vers(lc); 506 break; 507 } 508 lc->lc_rx_state = rx_state; 509 hv_ldc_rx_set_qhead(lc->lc_id, rx_tail); 510 return (1); 511 } 512 513 if (rx_head == rx_tail) 514 return (0); 515 516 lp = (struct ldc_pkt *)(uintptr_t)(lc->lc_rxq->lq_va + rx_head); 517 switch (lp->type) { 518 case LDC_CTRL: 519 ldc_rx_ctrl(lc, lp); 520 break; 521 522 case LDC_DATA: 523 ldc_rx_data(lc, lp); 524 break; 525 526 default: 527 DPRINTF(("%0x02/%0x02/%0x02\n", lp->type, lp->stype, 528 lp->ctrl)); 529 ldc_reset(lc); 530 break; 531 } 532 533 if (lc->lc_state == 0) 534 return (1); 535 536 rx_head += sizeof(*lp); 537 rx_head &= ((lc->lc_rxq->lq_nentries * sizeof(*lp)) - 1); 538 err = hv_ldc_rx_set_qhead(lc->lc_id, rx_head); 539 if (err != H_EOK) 540 printf("%s: hv_ldc_rx_set_qhead %d\n", __func__, err); 541 542 return (1); 543 } 544 545 void 546 vdsk_rx_data(struct ldc_conn *lc, struct ldc_pkt *lp) 547 { 548 struct vio_msg *vm = (struct vio_msg *)lp; 549 550 switch (vm->type) { 551 case VIO_TYPE_CTRL: 552 if ((lp->env & LDC_FRAG_START) == 0 && 553 (lp->env & LDC_FRAG_STOP) == 0) 554 return; 555 vdsk_rx_vio_ctrl(lc->lc_sc, vm); 556 break; 557 558 case VIO_TYPE_DATA: 559 if((lp->env & LDC_FRAG_START) == 0) 560 return; 561 vdsk_rx_vio_data(lc->lc_sc, vm); 562 break; 563 564 default: 565 DPRINTF(("Unhandled packet type 0x%02x\n", vm->type)); 566 ldc_reset(lc); 567 break; 568 } 569 } 570 571 void 572 vdsk_rx_vio_ctrl(struct vdsk_softc *sc, struct vio_msg *vm) 573 { 574 struct vio_msg_tag *tag = (struct vio_msg_tag *)&vm->type; 575 576 switch (tag->stype_env) { 577 case VIO_VER_INFO: 578 vdsk_rx_vio_ver_info(sc, tag); 579 break; 580 case VIO_ATTR_INFO: 581 vdsk_rx_vio_attr_info(sc, tag); 582 break; 583 case VIO_DRING_REG: 584 vdsk_rx_vio_dring_reg(sc, tag); 585 break; 586 case VIO_RDX: 587 vdsk_rx_vio_rdx(sc, tag); 588 break; 589 default: 590 DPRINTF(("CTRL/0x%02x/0x%04x\n", tag->stype, tag->stype_env)); 591 break; 592 } 593 } 594 595 void 596 vdsk_rx_vio_ver_info(struct vdsk_softc *sc, struct vio_msg_tag *tag) 597 { 598 struct vio_ver_info *vi = (struct vio_ver_info *)tag; 599 600 switch (vi->tag.stype) { 601 case VIO_SUBTYPE_INFO: 602 DPRINTF(("CTRL/INFO/VER_INFO\n")); 603 break; 604 605 case VIO_SUBTYPE_ACK: 606 DPRINTF(("CTRL/ACK/VER_INFO\n")); 607 if (!ISSET(sc->sc_vio_state, VIO_SND_VER_INFO)) { 608 ldc_reset(&sc->sc_lc); 609 break; 610 } 611 sc->sc_major = vi->major; 612 sc->sc_minor = vi->minor; 613 sc->sc_vio_state |= VIO_ACK_VER_INFO; 614 break; 615 616 default: 617 DPRINTF(("CTRL/0x%02x/VER_INFO\n", vi->tag.stype)); 618 break; 619 } 620 621 if (ISSET(sc->sc_vio_state, VIO_ACK_VER_INFO)) 622 vdsk_send_attr_info(sc); 623 } 624 625 void 626 vdsk_rx_vio_attr_info(struct vdsk_softc *sc, struct vio_msg_tag *tag) 627 { 628 struct vd_attr_info *ai = (struct vd_attr_info *)tag; 629 630 switch (ai->tag.stype) { 631 case VIO_SUBTYPE_INFO: 632 DPRINTF(("CTRL/INFO/ATTR_INFO\n")); 633 break; 634 635 case VIO_SUBTYPE_ACK: 636 DPRINTF(("CTRL/ACK/ATTR_INFO\n")); 637 if (!ISSET(sc->sc_vio_state, VIO_SND_ATTR_INFO)) { 638 ldc_reset(&sc->sc_lc); 639 break; 640 } 641 642 sc->sc_vdisk_block_size = ai->vdisk_block_size; 643 sc->sc_vdisk_size = ai->vdisk_size; 644 if (sc->sc_major > 1 || sc->sc_minor >= 1) 645 sc->sc_vd_mtype = ai->vd_mtype; 646 else 647 sc->sc_vd_mtype = VD_MEDIA_TYPE_FIXED; 648 649 sc->sc_vio_state |= VIO_ACK_ATTR_INFO; 650 break; 651 652 default: 653 DPRINTF(("CTRL/0x%02x/ATTR_INFO\n", ai->tag.stype)); 654 break; 655 } 656 657 if (ISSET(sc->sc_vio_state, VIO_ACK_ATTR_INFO)) 658 vdsk_send_dring_reg(sc); 659 660 } 661 662 void 663 vdsk_rx_vio_dring_reg(struct vdsk_softc *sc, struct vio_msg_tag *tag) 664 { 665 struct vio_dring_reg *dr = (struct vio_dring_reg *)tag; 666 667 switch (dr->tag.stype) { 668 case VIO_SUBTYPE_INFO: 669 DPRINTF(("CTRL/INFO/DRING_REG\n")); 670 break; 671 672 case VIO_SUBTYPE_ACK: 673 DPRINTF(("CTRL/ACK/DRING_REG\n")); 674 if (!ISSET(sc->sc_vio_state, VIO_SND_DRING_REG)) { 675 ldc_reset(&sc->sc_lc); 676 break; 677 } 678 679 sc->sc_dring_ident = dr->dring_ident; 680 sc->sc_seq_no = 1; 681 682 sc->sc_vio_state |= VIO_ACK_DRING_REG; 683 break; 684 685 default: 686 DPRINTF(("CTRL/0x%02x/DRING_REG\n", dr->tag.stype)); 687 break; 688 } 689 690 if (ISSET(sc->sc_vio_state, VIO_ACK_DRING_REG)) 691 vdsk_send_rdx(sc); 692 } 693 694 void 695 vdsk_rx_vio_rdx(struct vdsk_softc *sc, struct vio_msg_tag *tag) 696 { 697 switch(tag->stype) { 698 case VIO_SUBTYPE_INFO: 699 DPRINTF(("CTRL/INFO/RDX\n")); 700 break; 701 702 case VIO_SUBTYPE_ACK: 703 { 704 int prod; 705 706 DPRINTF(("CTRL/ACK/RDX\n")); 707 if (!ISSET(sc->sc_vio_state, VIO_SND_RDX)) { 708 ldc_reset(&sc->sc_lc); 709 break; 710 } 711 sc->sc_vio_state |= VIO_ACK_RDX; 712 713 /* 714 * If this ACK is the result of a reconnect, we may 715 * have pending I/O that we need to resubmit. We need 716 * to rebuild the ring descriptors though since the 717 * vDisk server on the other side may have touched 718 * them already. So we just clean up the ring and the 719 * LDC map and resubmit the SCSI commands based on our 720 * soft descriptors. 721 */ 722 prod = sc->sc_tx_prod; 723 sc->sc_tx_prod = sc->sc_tx_cons; 724 sc->sc_tx_cnt = 0; 725 sc->sc_lm->lm_next = 1; 726 sc->sc_lm->lm_count = 1; 727 for (int i = sc->sc_lm->lm_next; i < sc->sc_lm->lm_nentries; i++) 728 sc->sc_lm->lm_slot[i].entry = 0; 729 while (sc->sc_tx_prod != prod) 730 vdsk_submit_cmd(sc, sc->sc_vsd[sc->sc_tx_prod].vsd_xs); 731 break; 732 } 733 734 default: 735 DPRINTF(("CTRL/0x%02x/RDX (VIO)\n", tag->stype)); 736 break; 737 } 738 } 739 740 void 741 vdsk_rx_vio_data(struct vdsk_softc *sc, struct vio_msg *vm) 742 { 743 struct vio_msg_tag *tag = (struct vio_msg_tag *)&vm->type; 744 745 if (sc->sc_vio_state != VIO_ESTABLISHED) { 746 DPRINTF(("Spurious DATA/0x%02x/0x%04x\n", tag->stype, 747 tag->stype_env)); 748 return; 749 } 750 751 switch(tag->stype_env) { 752 case VIO_DRING_DATA: 753 vdsk_rx_vio_dring_data(sc, tag); 754 break; 755 756 default: 757 DPRINTF(("DATA/0x%02x/0x%04x\n", tag->stype, tag->stype_env)); 758 break; 759 } 760 } 761 762 void 763 vdsk_rx_vio_dring_data(struct vdsk_softc *sc, struct vio_msg_tag *tag) 764 { 765 switch(tag->stype) { 766 case VIO_SUBTYPE_INFO: 767 DPRINTF(("DATA/INFO/DRING_DATA\n")); 768 break; 769 770 case VIO_SUBTYPE_ACK: 771 { 772 struct scsipi_xfer *xs; 773 int cons; 774 775 cons = sc->sc_tx_cons; 776 while (sc->sc_vd->vd_desc[cons].hdr.dstate == VIO_DESC_DONE) { 777 xs = sc->sc_vsd[cons].vsd_xs; 778 if (ISSET(xs->xs_control, XS_CTL_POLL) == 0) 779 vdsk_complete_cmd(sc, xs, cons); 780 cons++; 781 cons &= (sc->sc_vd->vd_nentries - 1); 782 } 783 sc->sc_tx_cons = cons; 784 break; 785 } 786 787 case VIO_SUBTYPE_NACK: 788 DPRINTF(("DATA/NACK/DRING_DATA\n")); 789 struct ldc_conn *lc = &sc->sc_lc; 790 ldc_send_vers(lc); 791 break; 792 793 default: 794 DPRINTF(("DATA/0x%02x/DRING_DATA\n", tag->stype)); 795 break; 796 } 797 } 798 799 void 800 vdsk_ldc_reset(struct ldc_conn *lc) 801 { 802 struct vdsk_softc *sc = lc->lc_sc; 803 804 sc->sc_vio_state = 0; 805 } 806 807 void 808 vdsk_ldc_start(struct ldc_conn *lc) 809 { 810 struct vdsk_softc *sc = lc->lc_sc; 811 812 vdsk_send_ver_info(sc, VDSK_MAJOR, VDSK_MINOR); 813 } 814 815 void 816 vdsk_sendmsg(struct vdsk_softc *sc, void *msg, size_t len) 817 { 818 struct ldc_conn *lc = &sc->sc_lc; 819 int err; 820 821 err = ldc_send_unreliable(lc, msg, len); 822 if (err) 823 printf("%s: ldc_send_unreliable: %d\n", __func__, err); 824 } 825 826 void 827 vdsk_send_ver_info(struct vdsk_softc *sc, uint16_t major, uint16_t minor) 828 { 829 struct vio_ver_info vi; 830 831 /* Allocate new session ID. */ 832 sc->sc_local_sid = gettick(); 833 834 bzero(&vi, sizeof(vi)); 835 vi.tag.type = VIO_TYPE_CTRL; 836 vi.tag.stype = VIO_SUBTYPE_INFO; 837 vi.tag.stype_env = VIO_VER_INFO; 838 vi.tag.sid = sc->sc_local_sid; 839 vi.major = major; 840 vi.minor = minor; 841 vi.dev_class = VDEV_DISK; 842 vdsk_sendmsg(sc, &vi, sizeof(vi)); 843 844 sc->sc_vio_state |= VIO_SND_VER_INFO; 845 } 846 847 void 848 vdsk_send_attr_info(struct vdsk_softc *sc) 849 { 850 struct vd_attr_info ai; 851 852 bzero(&ai, sizeof(ai)); 853 ai.tag.type = VIO_TYPE_CTRL; 854 ai.tag.stype = VIO_SUBTYPE_INFO; 855 ai.tag.stype_env = VIO_ATTR_INFO; 856 ai.tag.sid = sc->sc_local_sid; 857 ai.xfer_mode = VIO_DRING_MODE; 858 ai.vdisk_block_size = DEV_BSIZE; 859 ai.max_xfer_sz = MAXPHYS / DEV_BSIZE; 860 DPRINTF(("vdisk_block_size %u\n", ai.vdisk_block_size)); 861 DPRINTF(("max_xfer_sz %lu\n", ai.max_xfer_sz)); 862 vdsk_sendmsg(sc, &ai, sizeof(ai)); 863 864 sc->sc_vio_state |= VIO_SND_ATTR_INFO; 865 } 866 867 void 868 vdsk_send_dring_reg(struct vdsk_softc *sc) 869 { 870 struct vio_dring_reg dr; 871 872 bzero(&dr, sizeof(dr)); 873 dr.tag.type = VIO_TYPE_CTRL; 874 dr.tag.stype = VIO_SUBTYPE_INFO; 875 dr.tag.stype_env = VIO_DRING_REG; 876 dr.tag.sid = sc->sc_local_sid; 877 dr.dring_ident = 0; 878 dr.num_descriptors = sc->sc_vd->vd_nentries; 879 dr.descriptor_size = sizeof(struct vd_desc); 880 dr.options = VIO_TX_RING | VIO_RX_RING; 881 dr.ncookies = 1; 882 dr.cookie[0].addr = 0; 883 dr.cookie[0].size = PAGE_SIZE; 884 vdsk_sendmsg(sc, &dr, sizeof(dr)); 885 886 sc->sc_vio_state |= VIO_SND_DRING_REG; 887 }; 888 889 void 890 vdsk_send_rdx(struct vdsk_softc *sc) 891 { 892 struct vio_rdx rdx; 893 894 bzero(&rdx, sizeof(rdx)); 895 rdx.tag.type = VIO_TYPE_CTRL; 896 rdx.tag.stype = VIO_SUBTYPE_INFO; 897 rdx.tag.stype_env = VIO_RDX; 898 rdx.tag.sid = sc->sc_local_sid; 899 vdsk_sendmsg(sc, &rdx, sizeof(rdx)); 900 901 sc->sc_vio_state |= VIO_SND_RDX; 902 } 903 904 #if OPENBSD_BUSDMA 905 struct vdsk_dring * 906 vdsk_dring_alloc(bus_dma_tag_t t, int nentries) 907 #else 908 struct vdsk_dring * 909 vdsk_dring_alloc(int nentries) 910 #endif 911 { 912 913 struct vdsk_dring *vd; 914 bus_size_t size; 915 vaddr_t va; 916 #if OPENBSD_BUSDMA 917 int nsegs; 918 #endif 919 int i; 920 921 vd = kmem_zalloc(sizeof(struct vdsk_dring), KM_SLEEP); 922 923 size = roundup(nentries * sizeof(struct vd_desc), PAGE_SIZE); 924 925 #if OPENBSD_BUSDMA 926 if (bus_dmamap_create(t, size, 1, size, 0, 927 BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, &vd->vd_map) != 0) 928 return (NULL); 929 930 if (bus_dmamem_alloc(t, size, PAGE_SIZE, 0, &vd->vd_seg, 1, 931 &nsegs, BUS_DMA_NOWAIT) != 0) 932 goto destroy; 933 934 if (bus_dmamem_map(t, &vd->vd_seg, 1, size, (void*)&va, 935 BUS_DMA_NOWAIT) != 0) 936 goto free; 937 938 if (bus_dmamap_load(t, vd->vd_map, (void*)va, size, NULL, 939 BUS_DMA_NOWAIT) != 0) 940 goto unmap; 941 #else 942 va = (vaddr_t)kmem_zalloc(size, KM_SLEEP); 943 #endif 944 vd->vd_desc = (struct vd_desc *)va; 945 vd->vd_nentries = nentries; 946 bzero(vd->vd_desc, nentries * sizeof(struct vd_desc)); 947 for (i = 0; i < vd->vd_nentries; i++) 948 vd->vd_desc[i].hdr.dstate = VIO_DESC_FREE; 949 return (vd); 950 951 #if OPENBSD_BUSDMA 952 unmap: 953 bus_dmamem_unmap(t, (void*)va, size); 954 free: 955 bus_dmamem_free(t, &vd->vd_seg, 1); 956 destroy: 957 bus_dmamap_destroy(t, vd->vd_map); 958 #endif 959 return (NULL); 960 } 961 962 #if OPENBSD_BUSDMA 963 void 964 vdsk_dring_free(bus_dma_tag_t t, struct vdsk_dring *vd) 965 #else 966 void 967 vdsk_dring_free(struct vdsk_dring *vd) 968 #endif 969 { 970 971 bus_size_t size; 972 973 size = vd->vd_nentries * sizeof(struct vd_desc); 974 size = roundup(size, PAGE_SIZE); 975 976 #if OPENBSD_BUSDMA 977 bus_dmamap_unload(t, vd->vd_map); 978 979 bus_dmamem_unmap(t, (caddr_t)vd->vd_desc, size); 980 bus_dmamem_free(t, &vd->vd_seg, 1); 981 bus_dmamap_destroy(t, vd->vd_map); 982 #else 983 kmem_free(vd->vd_desc, size); 984 #endif 985 kmem_free(vd, size); 986 } 987 988 void * 989 vdsk_io_get(void *xsc) 990 { 991 992 panic("%s: not verified yet", __FUNCTION__); 993 994 struct vdsk_softc *sc = xsc; 995 void *rv = sc; /* just has to be !NULL */ 996 int s; 997 998 s = splbio(); 999 if (sc->sc_vio_state != VIO_ESTABLISHED || 1000 sc->sc_tx_cnt >= sc->sc_vd->vd_nentries) 1001 rv = NULL; 1002 else 1003 sc->sc_tx_cnt++; 1004 splx(s); 1005 1006 return (rv); 1007 } 1008 1009 void 1010 vdsk_io_put(void *xsc, void *io) 1011 { 1012 1013 panic("%s: not verified yet", __FUNCTION__); 1014 1015 struct vdsk_softc *sc = xsc; 1016 int s; 1017 1018 #ifdef DIAGNOSTIC 1019 if (sc != io) 1020 panic("vsdk_io_put: unexpected io"); 1021 #endif 1022 1023 s = splbio(); 1024 sc->sc_tx_cnt--; 1025 splx(s); 1026 } 1027 1028 void 1029 vdsk_scsi_cmd(struct vdsk_softc *sc, struct scsipi_xfer *xs) 1030 { 1031 int timeout, s; 1032 int desc; 1033 1034 DPRINTF(("vdsk_scsi_cmd() opcode %x\n", xs->cmd->opcode)); 1035 1036 switch (xs->cmd->opcode) { 1037 1038 case SCSI_READ_6_COMMAND: 1039 DPRINTF(("SCSI_READ_6_COMMAND\n")); 1040 break; 1041 1042 case READ_10: 1043 DPRINTF(("SCSI_READ_10\n")); 1044 break; 1045 1046 case READ_12: 1047 DPRINTF(("SCSI_READ_12\n")); 1048 break; 1049 1050 case READ_16: 1051 DPRINTF(("SCSI_READ_16\n")); 1052 break; 1053 1054 case SCSI_WRITE_6_COMMAND: 1055 DPRINTF(("SCSI_WRITE_6\n")); 1056 break; 1057 1058 case WRITE_10: 1059 DPRINTF(("SCSI_WRITE_10\n")); 1060 break; 1061 1062 case WRITE_12: 1063 DPRINTF(("SCSI_WRITE_12\n")); 1064 break; 1065 1066 case WRITE_16: 1067 DPRINTF(("SCSI_WRITE_16\n")); 1068 break; 1069 1070 case SCSI_SYNCHRONIZE_CACHE_10: 1071 DPRINTF(("SCSI_SYNCHRONIZE_CACHE_10\n")); 1072 /* No need to flush read-only device types */ 1073 if (sc->sc_vd_mtype == VD_MEDIA_TYPE_CD || 1074 sc->sc_vd_mtype == VD_MEDIA_TYPE_DVD) { 1075 vdsk_scsi_done(xs, XS_NOERROR); 1076 return; 1077 } 1078 break; 1079 1080 case INQUIRY: 1081 DPRINTF(("INQUIRY\n")); 1082 vdsk_scsi_inq(sc, xs); 1083 return; 1084 1085 case READ_CAPACITY_10: 1086 DPRINTF(("READ_CAPACITY_10\n")); 1087 vdsk_scsi_capacity(sc, xs); 1088 return; 1089 1090 case READ_CAPACITY_16: 1091 DPRINTF(("READ_CAPACITY_16\n")); 1092 vdsk_scsi_capacity16(sc, xs); 1093 return; 1094 1095 case SCSI_REPORT_LUNS: 1096 DPRINTF(("REPORT_LUNS\n")); 1097 vdsk_scsi_report_luns(sc, xs); 1098 return; 1099 1100 case SCSI_TEST_UNIT_READY: 1101 DPRINTF(("TEST_UNIT_READY\n")); 1102 vdsk_scsi_test_unit_ready(sc, xs); 1103 return; 1104 1105 case START_STOP: 1106 DPRINTF(("START_STOP\n")); 1107 vdsk_scsi_start_stop(sc, xs); 1108 return; 1109 1110 case SCSI_PREVENT_ALLOW_MEDIUM_REMOVAL: 1111 DPRINTF(("PREVENT_ALLOW_MEDIUM_REMOVAL\n")); 1112 vdsk_scsi_prevent_allow_medium_removal(sc, xs); 1113 return; 1114 1115 case SCSI_MODE_SENSE_6: 1116 DPRINTF(("SCSI_MODE_SENSE_6\n")); 1117 vdsk_scsi_mode_sense_6(sc, xs); 1118 return; 1119 1120 case SCSI_MODE_SELECT_6: 1121 DPRINTF(("MODE_SELECT_6\n")); 1122 vdsk_scsi_mode_select_6(sc, xs); 1123 return; 1124 1125 case SCSI_MODE_SELECT_10: 1126 DPRINTF(("MODE_SELECT_10\n")); 1127 vdsk_scsi_mode_select_10(sc, xs); 1128 return; 1129 1130 case SCSI_MAINTENANCE_IN: 1131 DPRINTF(("MAINTENANCE_IN\n")); 1132 vdsk_scsi_maintenance_in(sc, xs); 1133 return; 1134 1135 case SCSI_MODE_SENSE_10: 1136 DPRINTF(("SCSI_MODE_SENSE_10\n")); 1137 vdsk_scsi_mode_sense_10(sc, xs); 1138 return; 1139 1140 case READ_TOC: 1141 DPRINTF(("READ_TOC (not implemented)\n")); 1142 vdsk_scsi_read_toc(sc, xs); 1143 return; 1144 1145 default: 1146 panic("%s unhandled cmd 0x%02x\n", 1147 __func__, xs->cmd->opcode); 1148 } 1149 1150 s = splbio(); 1151 desc = vdsk_submit_cmd(sc, xs); 1152 1153 if (!ISSET(xs->xs_control, XS_CTL_POLL)) { 1154 splx(s); 1155 return; 1156 } 1157 timeout = 1000; 1158 do { 1159 if (sc->sc_vd->vd_desc[desc].hdr.dstate == VIO_DESC_DONE) 1160 break; 1161 1162 delay(1000); 1163 } while(--timeout > 0); 1164 if (sc->sc_vd->vd_desc[desc].hdr.dstate == VIO_DESC_DONE) { 1165 vdsk_complete_cmd(sc, xs, desc); 1166 } else { 1167 ldc_reset(&sc->sc_lc); 1168 vdsk_scsi_done(xs, XS_TIMEOUT); 1169 } 1170 splx(s); 1171 } 1172 1173 int 1174 vdsk_submit_cmd(struct vdsk_softc *sc, struct scsipi_xfer *xs) 1175 { 1176 struct ldc_map *map = sc->sc_lm; 1177 struct vio_dring_msg dm; 1178 struct scsi_rw_6 *rw6; 1179 struct scsipi_rw_10 *rw10; 1180 struct scsipi_rw_12 *rw12; 1181 struct scsipi_rw_16 *rw16; 1182 u_int64_t lba = 0; 1183 uint8_t operation; 1184 vaddr_t va; 1185 paddr_t pa; 1186 psize_t nbytes; 1187 int len, ncookies; 1188 int desc; 1189 1190 switch (xs->cmd->opcode) { 1191 1192 case SCSI_READ_6_COMMAND: 1193 case READ_10: 1194 case READ_12: 1195 case READ_16: 1196 DPRINTF(("VD_OP_BREAD\n")); 1197 operation = VD_OP_BREAD; 1198 break; 1199 1200 case SCSI_WRITE_6_COMMAND: 1201 case WRITE_10: 1202 case WRITE_12: 1203 case WRITE_16: 1204 DPRINTF(("VD_OP_BWRITE\n")); 1205 operation = VD_OP_BWRITE; 1206 break; 1207 1208 case SCSI_SYNCHRONIZE_CACHE_10: 1209 DPRINTF(("VD_OP_FLUSH\n")); 1210 operation = VD_OP_FLUSH; 1211 break; 1212 1213 default: 1214 panic("%s unhandled cmd opcode 0x%x", 1215 __func__, xs->cmd->opcode); 1216 } 1217 1218 /* 1219 * READ/WRITE/SYNCHRONIZE commands. SYNCHRONIZE CACHE has same 1220 * layout as 10-byte READ/WRITE commands. 1221 */ 1222 if (xs->cmdlen == 6) { 1223 rw6 = (struct scsi_rw_6 *)xs->cmd; 1224 lba = _3btol(rw6->addr) & (SRW_TOPADDR << 16 | 0xffff); 1225 } else if (xs->cmdlen == 10) { 1226 rw10 = (struct scsipi_rw_10 *)xs->cmd; 1227 lba = _4btol(rw10->addr); 1228 } else if (xs->cmdlen == 12) { 1229 rw12 = (struct scsipi_rw_12 *)xs->cmd; 1230 lba = _4btol(rw12->addr); 1231 } else if (xs->cmdlen == 16) { 1232 rw16 = (struct scsipi_rw_16 *)xs->cmd; 1233 lba = _8btol(rw16->addr); 1234 } 1235 1236 DPRINTF(("lba = %lu\n", lba)); 1237 1238 desc = sc->sc_tx_prod; 1239 ncookies = 0; 1240 len = xs->datalen; 1241 va = (vaddr_t)xs->data; 1242 while (len > 0) { 1243 DPRINTF(("len = %u\n", len)); 1244 KASSERT(ncookies < MAXPHYS / PAGE_SIZE); 1245 pa = 0; 1246 pmap_extract(pmap_kernel(), va, &pa); 1247 while (map->lm_slot[map->lm_next].entry != 0) { 1248 map->lm_next++; 1249 map->lm_next &= (map->lm_nentries - 1); 1250 } 1251 map->lm_slot[map->lm_next].entry = (pa & LDC_MTE_RA_MASK); 1252 map->lm_slot[map->lm_next].entry |= LDC_MTE_CPR | LDC_MTE_CPW; 1253 map->lm_slot[map->lm_next].entry |= LDC_MTE_IOR | LDC_MTE_IOW; 1254 map->lm_slot[map->lm_next].entry |= LDC_MTE_R | LDC_MTE_W; 1255 map->lm_count++; 1256 1257 nbytes = MIN(len, PAGE_SIZE - (pa & PAGE_MASK)); 1258 1259 sc->sc_vd->vd_desc[desc].cookie[ncookies].addr = 1260 map->lm_next << PAGE_SHIFT | (pa & PAGE_MASK); 1261 sc->sc_vd->vd_desc[desc].cookie[ncookies].size = nbytes; 1262 1263 sc->sc_vsd[desc].vsd_map_idx[ncookies] = map->lm_next; 1264 va += nbytes; 1265 len -= nbytes; 1266 ncookies++; 1267 } 1268 if (ISSET(xs->xs_control, XS_CTL_POLL) == 0) 1269 sc->sc_vd->vd_desc[desc].hdr.ack = 1; 1270 else 1271 sc->sc_vd->vd_desc[desc].hdr.ack = 0; 1272 sc->sc_vd->vd_desc[desc].operation = operation; 1273 sc->sc_vd->vd_desc[desc].slice = VD_SLICE_NONE; 1274 sc->sc_vd->vd_desc[desc].status = 0xffffffff; 1275 sc->sc_vd->vd_desc[desc].offset = lba; 1276 sc->sc_vd->vd_desc[desc].size = xs->datalen; 1277 sc->sc_vd->vd_desc[desc].ncookies = ncookies; 1278 1279 membar_Sync(); 1280 1281 sc->sc_vd->vd_desc[desc].hdr.dstate = VIO_DESC_READY; 1282 1283 sc->sc_vsd[desc].vsd_xs = xs; 1284 sc->sc_vsd[desc].vsd_ncookies = ncookies; 1285 1286 sc->sc_tx_prod++; 1287 sc->sc_tx_prod &= (sc->sc_vd->vd_nentries - 1); 1288 1289 bzero(&dm, sizeof(dm)); 1290 dm.tag.type = VIO_TYPE_DATA; 1291 dm.tag.stype = VIO_SUBTYPE_INFO; 1292 dm.tag.stype_env = VIO_DRING_DATA; 1293 dm.tag.sid = sc->sc_local_sid; 1294 dm.seq_no = sc->sc_seq_no++; 1295 dm.dring_ident = sc->sc_dring_ident; 1296 dm.start_idx = dm.end_idx = desc; 1297 vdsk_sendmsg(sc, &dm, sizeof(dm)); 1298 1299 return desc; 1300 } 1301 1302 void 1303 vdsk_complete_cmd(struct vdsk_softc *sc, struct scsipi_xfer *xs, int desc) 1304 { 1305 struct ldc_map *map = sc->sc_lm; 1306 int cookie, idx; 1307 int error; 1308 1309 cookie = 0; 1310 while (cookie < sc->sc_vsd[desc].vsd_ncookies) { 1311 idx = sc->sc_vsd[desc].vsd_map_idx[cookie++]; 1312 map->lm_slot[idx].entry = 0; 1313 map->lm_count--; 1314 } 1315 1316 error = XS_NOERROR; 1317 if (sc->sc_vd->vd_desc[desc].status != 0) 1318 error = XS_DRIVER_STUFFUP; 1319 xs->resid = xs->datalen - 1320 sc->sc_vd->vd_desc[desc].size; 1321 1322 /* 1323 * scsi_done() called by vdsk_scsi_done() requires 1324 * the kernel to be locked 1325 */ 1326 KERNEL_LOCK(1, curlwp); 1327 vdsk_scsi_done(xs, error); 1328 KERNEL_UNLOCK_ONE(curlwp); 1329 1330 sc->sc_vd->vd_desc[desc].hdr.dstate = VIO_DESC_FREE; 1331 1332 } 1333 1334 void 1335 vdsk_scsi_inq(struct vdsk_softc *sc, struct scsipi_xfer *xs) 1336 { 1337 vdsk_scsi_inquiry(sc, xs); 1338 } 1339 1340 void 1341 vdsk_scsi_inquiry(struct vdsk_softc *sc, struct scsipi_xfer *xs) 1342 { 1343 struct scsipi_inquiry_data inq; 1344 char buf[5]; 1345 1346 bzero(&inq, sizeof(inq)); 1347 1348 switch (sc->sc_vd_mtype) { 1349 case VD_MEDIA_TYPE_CD: 1350 case VD_MEDIA_TYPE_DVD: 1351 inq.device = T_CDROM; 1352 inq.dev_qual2 = SID_REMOVABLE; 1353 bcopy("Virtual CDROM ", inq.product, sizeof(inq.product)); 1354 break; 1355 case VD_MEDIA_TYPE_FIXED: 1356 inq.device = T_DIRECT; 1357 bcopy("Virtual Disk ", inq.product, sizeof(inq.product)); 1358 break; 1359 default: 1360 panic("Unhandled media type %d\n", sc->sc_vd_mtype); 1361 } 1362 inq.version = 0x05; /* SPC-3 */ 1363 inq.response_format = 2; 1364 inq.additional_length = 32; 1365 inq.flags3 |= SID_CmdQue; 1366 bcopy("SUN ", inq.vendor, sizeof(inq.vendor)); 1367 snprintf(buf, sizeof(buf), "%u.%u ", sc->sc_major, sc->sc_minor); 1368 bcopy(buf, inq.revision, sizeof(inq.revision)); 1369 1370 bcopy(&inq, xs->data, MIN(sizeof(inq), xs->datalen)); 1371 1372 vdsk_scsi_done(xs, XS_NOERROR); 1373 } 1374 1375 void 1376 vdsk_scsi_mode_sense_6(struct vdsk_softc *sc, struct scsipi_xfer *xs) 1377 { 1378 vdsk_scsi_done(xs, XS_NOERROR); 1379 } 1380 1381 void 1382 vdsk_scsi_mode_sense_10(struct vdsk_softc *sc, struct scsipi_xfer *xs) 1383 { 1384 vdsk_scsi_done(xs, XS_NOERROR); 1385 } 1386 1387 void 1388 vdsk_scsi_mode_select_6(struct vdsk_softc *sc, struct scsipi_xfer *xs) 1389 { 1390 vdsk_scsi_done(xs, XS_NOERROR); 1391 } 1392 1393 void 1394 vdsk_scsi_mode_select_10(struct vdsk_softc *sc, struct scsipi_xfer *xs) 1395 { 1396 vdsk_scsi_done(xs, XS_NOERROR); 1397 } 1398 1399 void 1400 vdsk_scsi_read_toc(struct vdsk_softc *sc, struct scsipi_xfer *xs) 1401 { 1402 vdsk_scsi_done(xs, XS_NOERROR); 1403 } 1404 1405 void 1406 vdsk_scsi_maintenance_in(struct vdsk_softc *sc, struct scsipi_xfer *xs) 1407 { 1408 vdsk_scsi_done(xs, XS_NOERROR); 1409 } 1410 1411 void 1412 vdsk_scsi_start_stop(struct vdsk_softc *sc, struct scsipi_xfer *xs) 1413 { 1414 vdsk_scsi_done(xs, XS_NOERROR); 1415 } 1416 1417 void 1418 vdsk_scsi_prevent_allow_medium_removal(struct vdsk_softc *sc, struct scsipi_xfer *xs) 1419 { 1420 vdsk_scsi_done(xs, XS_NOERROR); 1421 } 1422 1423 void 1424 vdsk_scsi_test_unit_ready(struct vdsk_softc *sc, struct scsipi_xfer *xs) 1425 { 1426 vdsk_scsi_done(xs, XS_NOERROR); 1427 } 1428 1429 void 1430 vdsk_scsi_capacity(struct vdsk_softc *sc, struct scsipi_xfer *xs) 1431 { 1432 struct scsipi_read_capacity_10_data rcd; 1433 uint64_t capacity; 1434 1435 bzero(&rcd, sizeof(rcd)); 1436 1437 capacity = sc->sc_vdisk_size - 1; 1438 if (capacity > 0xffffffff) 1439 capacity = 0xffffffff; 1440 1441 _lto4b(capacity, rcd.addr); 1442 _lto4b(sc->sc_vdisk_block_size, rcd.length); 1443 1444 DPRINTF(("%s() capacity %lu block size %u\n", 1445 __FUNCTION__, capacity, sc->sc_vdisk_block_size)); 1446 1447 bcopy(&rcd, xs->data, MIN(sizeof(rcd), xs->datalen)); 1448 1449 vdsk_scsi_done(xs, XS_NOERROR); 1450 } 1451 1452 void 1453 vdsk_scsi_capacity16(struct vdsk_softc *sc, struct scsipi_xfer *xs) 1454 { 1455 struct scsipi_read_capacity_16_data rcd; 1456 uint64_t capacity; 1457 1458 bzero(&rcd, sizeof(rcd)); 1459 1460 capacity = sc->sc_vdisk_size - 1; 1461 1462 _lto8b(capacity, rcd.addr); 1463 _lto4b(sc->sc_vdisk_block_size, rcd.length); 1464 1465 DPRINTF(("%s() capacity %lu block size %u\n", 1466 __FUNCTION__, capacity, sc->sc_vdisk_block_size)); 1467 1468 bcopy(&rcd, xs->data, MIN(sizeof(rcd), xs->datalen)); 1469 1470 vdsk_scsi_done(xs, XS_NOERROR); 1471 } 1472 1473 void 1474 vdsk_scsi_report_luns(struct vdsk_softc *sc, struct scsipi_xfer *xs) 1475 { 1476 vdsk_scsi_done(xs, XS_NOERROR); 1477 } 1478 1479 void 1480 vdsk_scsi_done(struct scsipi_xfer *xs, int error) 1481 { 1482 xs->error = error; 1483 1484 scsipi_done(xs); 1485 } 1486
Indexes created Sun Oct 25 00:26:45 UTC 2026