xref: /netbsd-src/sys/arch/sparc64/dev/vdsk.c (revision eee07adbf05a769cf403719ff36bb6b373b57ece)
1 /*	$NetBSD: vdsk.c,v 1.18 2024/06/20 18:41:45 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_capacity(struct vdsk_softc *sc, struct scsipi_xfer *);
220 void	vdsk_scsi_capacity16(struct vdsk_softc *sc, struct scsipi_xfer *);
221 void	vdsk_scsi_report_luns(struct vdsk_softc *sc, struct scsipi_xfer *);
222 void	vdsk_scsi_done(struct scsipi_xfer *, int);
223 
224 int
vdsk_match(device_t parent,cfdata_t match,void * aux)225 vdsk_match(device_t parent, cfdata_t match, void *aux)
226 {
227 	struct cbus_attach_args *ca = aux;
228 
229 	if (strcmp(ca->ca_name, "disk") == 0)
230 		return (1);
231 
232 	return (0);
233 }
234 
235 void
vdsk_attach(device_t parent,device_t self,void * aux)236 vdsk_attach(device_t parent, device_t self, void *aux)
237 {
238 	struct vdsk_softc *sc = device_private(self);
239 	struct cbus_attach_args *ca = aux;
240 	struct ldc_conn *lc;
241 	int err, s;
242 	int timeout;
243         vaddr_t va;
244         paddr_t pa;
245 
246 	sc->sc_bustag = ca->ca_bustag;
247 	sc->sc_dmatag = ca->ca_dmatag;
248 
249 	printf(": ivec 0x%llx, 0x%llx",
250 	       (long long unsigned int)ca->ca_tx_ino,
251 	       (long long unsigned int)ca->ca_rx_ino);
252 
253 	/*
254 	 * Un-configure queues before registering interrupt handlers,
255 	 * such that we don't get any stale LDC packets or events.
256 	 */
257 	hv_ldc_tx_qconf(ca->ca_id, 0, 0);
258 	hv_ldc_rx_qconf(ca->ca_id, 0, 0);
259 
260 	sc->sc_tx_ih = bus_intr_establish(ca->ca_bustag, ca->ca_tx_ino,
261 	    IPL_BIO, vdsk_tx_intr, sc);
262 	sc->sc_rx_ih = bus_intr_establish(ca->ca_bustag, ca->ca_rx_ino,
263 	    IPL_BIO, vdsk_rx_intr, sc);
264 	if (sc->sc_tx_ih == NULL || sc->sc_rx_ih == NULL) {
265 		printf(", can't establish interrupt\n");
266 		return;
267 	}
268 
269 	lc = &sc->sc_lc;
270 	lc->lc_id = ca->ca_id;
271 	lc->lc_sc = sc;
272 	lc->lc_reset = vdsk_ldc_reset;
273 	lc->lc_start = vdsk_ldc_start;
274 	lc->lc_rx_data = vdsk_rx_data;
275 
276 #if OPENBSD_BUSDMA
277 	lc->lc_txq = ldc_queue_alloc(sc->sc_dmatag, VDSK_TX_ENTRIES);
278 #else
279 	lc->lc_txq = ldc_queue_alloc(VDSK_TX_ENTRIES);
280 #endif
281 #if OPENBSD_BUSDMA
282 	lc->lc_rxq = ldc_queue_alloc(sc->sc_dmatag, VDSK_RX_ENTRIES);
283 #else
284 	lc->lc_rxq = ldc_queue_alloc(VDSK_RX_ENTRIES);
285 #endif
286 #if OPENBSD_BUSDMA
287 	sc->sc_lm = ldc_map_alloc(sc->sc_dmatag, 2048);
288 #else
289 	sc->sc_lm = ldc_map_alloc(2048);
290 #endif
291 #if OPENBSD_BUSDMA
292 	err = hv_ldc_set_map_table(lc->lc_id,
293 	    sc->sc_lm->lm_map->dm_segs[0].ds_addr, sc->sc_lm->lm_nentries);
294 #else
295         va = (vaddr_t)sc->sc_lm->lm_slot;
296         pa = 0;
297 	if (pmap_extract(pmap_kernel(), va, &pa) == FALSE)
298 	  panic("pmap_extract failed %lx\n", va);
299 	err = hv_ldc_set_map_table(lc->lc_id, pa, 2048);
300 #endif
301 	if (err != H_EOK) {
302 		printf("hv_ldc_set_map_table %d\n", err);
303 		goto free_map;
304 	}
305 #if OPENBSD_BUSDMA
306 	sc->sc_vd = vdsk_dring_alloc(sc->sc_dmatag, 32);
307 #else
308 	sc->sc_vd = vdsk_dring_alloc(32);
309 #endif
310 	sc->sc_vsd = kmem_zalloc(32 * sizeof(*sc->sc_vsd), KM_SLEEP);
311 
312 #if OPENBSD_BUSDMA
313 	sc->sc_lm->lm_slot[0].entry = sc->sc_vd->vd_map->dm_segs[0].ds_addr;
314 #else
315         va = (vaddr_t)sc->sc_vd->vd_desc;
316         pa = 0;
317 	if (pmap_extract(pmap_kernel(), va, &pa) == FALSE)
318 	  panic("pmap_extract failed %lx\n", va);
319 
320 	sc->sc_lm->lm_slot[0].entry = pa;
321 #endif
322 	sc->sc_lm->lm_slot[0].entry &= LDC_MTE_RA_MASK;
323 	sc->sc_lm->lm_slot[0].entry |= LDC_MTE_CPR | LDC_MTE_CPW;
324 	sc->sc_lm->lm_slot[0].entry |= LDC_MTE_R | LDC_MTE_W;
325 	sc->sc_lm->lm_next = 1;
326 	sc->sc_lm->lm_count = 1;
327 	va = lc->lc_txq->lq_va;
328 	pa = 0;
329 	if (pmap_extract(pmap_kernel(), va, &pa) == FALSE)
330 		panic("pmap_extract failed %lx\n", va);
331 #if OPENBSD_BUSDMA
332 	err = hv_ldc_tx_qconf(lc->lc_id,
333 	    lc->lc_txq->lq_map->dm_segs[0].ds_addr, lc->lc_txq->lq_nentries);
334 #else
335         err = hv_ldc_tx_qconf(lc->lc_id, pa, lc->lc_txq->lq_nentries);
336 #endif
337 	if (err != H_EOK)
338 		printf("hv_ldc_tx_qconf %d\n", err);
339 	va = (vaddr_t)lc->lc_rxq->lq_va;
340 	pa = 0;
341 	if (pmap_extract(pmap_kernel(), va, &pa) == FALSE)
342 	  panic("pmap_extract failed %lx\n", va);
343 #if OPENBSD_BUSDMA
344 	err = hv_ldc_rx_qconf(lc->lc_id,
345 	    lc->lc_rxq->lq_map->dm_segs[0].ds_addr, lc->lc_rxq->lq_nentries);
346 #else
347         err = hv_ldc_rx_qconf(lc->lc_id, pa, lc->lc_rxq->lq_nentries);
348 #endif
349 	if (err != H_EOK)
350 		printf("hv_ldc_rx_qconf %d\n", err);
351 
352 	cbus_intr_setenabled(sc->sc_bustag, ca->ca_tx_ino, INTR_ENABLED);
353 	cbus_intr_setenabled(sc->sc_bustag, ca->ca_rx_ino, INTR_ENABLED);
354 
355 	ldc_send_vers(lc);
356 
357 	printf("\n");
358 
359 	/*
360 	 * Interrupts aren't enabled during autoconf, so poll for VIO
361 	 * peer-to-peer handshake completion.
362 	 */
363 	s = splbio();
364 	timeout = 10 * 1000;
365 	do {
366 		if (vdsk_rx_intr(sc) && sc->sc_vio_state == VIO_ESTABLISHED)
367 			break;
368 
369 		delay(1000);
370 	} while(--timeout > 0);
371 	splx(s);
372 
373 	if (sc->sc_vio_state != VIO_ESTABLISHED) {
374 	  printf("vio not established: %d\n", sc->sc_vio_state);
375 	  return;
376 	}
377 
378 	sc->sc_dv = self;
379 
380 	sc->sc_adapter.adapt_dev = sc->sc_dv;
381 	sc->sc_adapter.adapt_nchannels = 1;
382 	sc->sc_adapter.adapt_openings = sc->sc_vd->vd_nentries - 1;
383 	sc->sc_adapter.adapt_max_periph = sc->sc_vd->vd_nentries - 1;
384 
385 	sc->sc_adapter.adapt_minphys = minphys;
386 	sc->sc_adapter.adapt_request = vdsk_scsipi_request;
387 
388 	sc->sc_channel.chan_adapter = &sc->sc_adapter;
389 	sc->sc_channel.chan_bustype = &scsi_bustype;
390 	sc->sc_channel.chan_channel = 0;
391 	sc->sc_channel.chan_ntargets = 2; /* XXX why not 1? */
392 	sc->sc_channel.chan_nluns = 1; /* XXX slices should be presented as luns? */
393 	sc->sc_channel.chan_id = 0;
394 	sc->sc_channel.chan_flags = SCSIPI_CHAN_NOSETTLE;
395 
396 	config_found(self, &sc->sc_channel, scsiprint, CFARGS_NONE);
397 
398 	return;
399 
400 free_map:
401 	hv_ldc_set_map_table(lc->lc_id, 0, 0);
402 #if OPENBSD_BUSDMA
403 	ldc_map_free(sc->sc_dmatag, sc->sc_lm);
404 #else
405 	ldc_map_free(sc->sc_lm);
406 #endif
407 }
408 
409 void
vdsk_scsipi_request(struct scsipi_channel * chan,scsipi_adapter_req_t req,void * arg)410 vdsk_scsipi_request(struct scsipi_channel *chan, scsipi_adapter_req_t req,
411 		     void *arg)
412 {
413 
414 	struct vdsk_softc *sc;
415 	struct scsipi_xfer *xs;
416 
417 	sc = device_private(chan->chan_adapter->adapt_dev);
418 
419 	xs = arg;
420 
421 	switch (req) {
422 		case ADAPTER_REQ_RUN_XFER:
423 			vdsk_scsi_cmd(sc, xs);
424 			break;
425 		case ADAPTER_REQ_GROW_RESOURCES:
426 		case ADAPTER_REQ_SET_XFER_MODE:
427 			/* Ignored */
428 			break;
429 		default:
430 			panic("req unhandled: %x", req);
431 	}
432 
433 }
434 
435 int
vdsk_tx_intr(void * arg)436 vdsk_tx_intr(void *arg)
437 {
438 	panic("%s: not verified yet", __FUNCTION__);
439 
440 	struct vdsk_softc *sc = arg;
441 	struct ldc_conn *lc = &sc->sc_lc;
442 	uint64_t tx_head, tx_tail, tx_state;
443 
444 	hv_ldc_tx_get_state(lc->lc_id, &tx_head, &tx_tail, &tx_state);
445 	if (tx_state != lc->lc_tx_state) {
446 		switch (tx_state) {
447 		case LDC_CHANNEL_DOWN:
448 			DPRINTF(("Tx link down\n"));
449 			break;
450 		case LDC_CHANNEL_UP:
451 			DPRINTF(("Tx link up\n"));
452 			break;
453 		case LDC_CHANNEL_RESET:
454 			DPRINTF(("Tx link reset\n"));
455 			break;
456 		}
457 		lc->lc_tx_state = tx_state;
458 	}
459 
460 	return (1);
461 }
462 
463 int
vdsk_rx_intr(void * arg)464 vdsk_rx_intr(void *arg)
465 {
466 	struct vdsk_softc *sc = arg;
467 	struct ldc_conn *lc = &sc->sc_lc;
468 	uint64_t rx_head, rx_tail, rx_state;
469 	struct ldc_pkt *lp;
470 	int err;
471 
472 	err = hv_ldc_rx_get_state(lc->lc_id, &rx_head, &rx_tail, &rx_state);
473 	if (err == H_EINVAL) {
474 		printf("hv_ldc_rx_get_state H_EINVAL\n");
475 		return (0);
476 	}
477 	if (err != H_EOK) {
478 		printf("hv_ldc_rx_get_state %d\n", err);
479 		return (0);
480 	}
481 
482 	if (rx_state != lc->lc_rx_state) {
483 		sc->sc_vio_state = 0;
484 		lc->lc_tx_seqid = 0;
485 		lc->lc_state = 0;
486 		switch (rx_state) {
487 		case LDC_CHANNEL_DOWN:
488 			DPRINTF(("Rx link down\n"));
489 			break;
490 		case LDC_CHANNEL_UP:
491 			DPRINTF(("Rx link up\n"));
492 			ldc_send_vers(lc);
493 			break;
494 		case LDC_CHANNEL_RESET:
495 			DPRINTF(("Rx link reset\n"));
496 			ldc_send_vers(lc);
497 			break;
498 		}
499 		lc->lc_rx_state = rx_state;
500 		hv_ldc_rx_set_qhead(lc->lc_id, rx_tail);
501 		return (1);
502 	}
503 
504 	if (rx_head == rx_tail)
505 		return (0);
506 
507 	lp = (struct ldc_pkt *)(uintptr_t)(lc->lc_rxq->lq_va + rx_head);
508 	switch (lp->type) {
509 		case LDC_CTRL:
510 			ldc_rx_ctrl(lc, lp);
511 			break;
512 
513 		case LDC_DATA:
514 			ldc_rx_data(lc, lp);
515 			break;
516 
517 		default:
518 			DPRINTF(("%0x02/%0x02/%0x02\n", lp->type, lp->stype,
519 			    lp->ctrl));
520 			ldc_reset(lc);
521 			break;
522 	}
523 
524 	if (lc->lc_state == 0)
525 		return (1);
526 
527 	rx_head += sizeof(*lp);
528 	rx_head &= ((lc->lc_rxq->lq_nentries * sizeof(*lp)) - 1);
529 	err = hv_ldc_rx_set_qhead(lc->lc_id, rx_head);
530 	if (err != H_EOK)
531 		printf("%s: hv_ldc_rx_set_qhead %d\n", __func__, err);
532 
533 	return (1);
534 }
535 
536 void
vdsk_rx_data(struct ldc_conn * lc,struct ldc_pkt * lp)537 vdsk_rx_data(struct ldc_conn *lc, struct ldc_pkt *lp)
538 {
539 	struct vio_msg *vm = (struct vio_msg *)lp;
540 
541 	switch (vm->type) {
542 		case VIO_TYPE_CTRL:
543 			if ((lp->env & LDC_FRAG_START) == 0 &&
544 			    (lp->env & LDC_FRAG_STOP) == 0)
545 				return;
546 			vdsk_rx_vio_ctrl(lc->lc_sc, vm);
547 			break;
548 
549 	case VIO_TYPE_DATA:
550 			if((lp->env & LDC_FRAG_START) == 0)
551 				return;
552 			vdsk_rx_vio_data(lc->lc_sc, vm);
553 			break;
554 
555 		default:
556 			DPRINTF(("Unhandled packet type 0x%02x\n", vm->type));
557 			ldc_reset(lc);
558 			break;
559 	}
560 }
561 
562 void
vdsk_rx_vio_ctrl(struct vdsk_softc * sc,struct vio_msg * vm)563 vdsk_rx_vio_ctrl(struct vdsk_softc *sc, struct vio_msg *vm)
564 {
565 	struct vio_msg_tag *tag = (struct vio_msg_tag *)&vm->type;
566 
567 	switch (tag->stype_env) {
568 		case VIO_VER_INFO:
569 			vdsk_rx_vio_ver_info(sc, tag);
570 			break;
571 		case VIO_ATTR_INFO:
572 			vdsk_rx_vio_attr_info(sc, tag);
573 			break;
574 		case VIO_DRING_REG:
575 			vdsk_rx_vio_dring_reg(sc, tag);
576 			break;
577 		case VIO_RDX:
578 			vdsk_rx_vio_rdx(sc, tag);
579 			break;
580 		default:
581 			DPRINTF(("CTRL/0x%02x/0x%04x\n", tag->stype, tag->stype_env));
582 			break;
583 	}
584 }
585 
586 void
vdsk_rx_vio_ver_info(struct vdsk_softc * sc,struct vio_msg_tag * tag)587 vdsk_rx_vio_ver_info(struct vdsk_softc *sc, struct vio_msg_tag *tag)
588 {
589 	struct vio_ver_info *vi = (struct vio_ver_info *)tag;
590 
591 	switch (vi->tag.stype) {
592 		case VIO_SUBTYPE_INFO:
593 			DPRINTF(("CTRL/INFO/VER_INFO\n"));
594 			break;
595 
596 		case VIO_SUBTYPE_ACK:
597 			DPRINTF(("CTRL/ACK/VER_INFO\n"));
598 			if (!ISSET(sc->sc_vio_state, VIO_SND_VER_INFO)) {
599 				ldc_reset(&sc->sc_lc);
600 				break;
601 			}
602 			sc->sc_major = vi->major;
603 			sc->sc_minor = vi->minor;
604 			sc->sc_vio_state |= VIO_ACK_VER_INFO;
605 			break;
606 
607 		default:
608 			DPRINTF(("CTRL/0x%02x/VER_INFO\n", vi->tag.stype));
609 			break;
610 	}
611 
612 	if (ISSET(sc->sc_vio_state, VIO_ACK_VER_INFO))
613 		vdsk_send_attr_info(sc);
614 }
615 
616 void
vdsk_rx_vio_attr_info(struct vdsk_softc * sc,struct vio_msg_tag * tag)617 vdsk_rx_vio_attr_info(struct vdsk_softc *sc, struct vio_msg_tag *tag)
618 {
619 	struct vd_attr_info *ai = (struct vd_attr_info *)tag;
620 
621 	switch (ai->tag.stype) {
622 		case VIO_SUBTYPE_INFO:
623 			DPRINTF(("CTRL/INFO/ATTR_INFO\n"));
624 			break;
625 
626 		case VIO_SUBTYPE_ACK:
627 			DPRINTF(("CTRL/ACK/ATTR_INFO\n"));
628 			if (!ISSET(sc->sc_vio_state, VIO_SND_ATTR_INFO)) {
629 				ldc_reset(&sc->sc_lc);
630 				break;
631 			}
632 
633 			sc->sc_vdisk_block_size = ai->vdisk_block_size;
634 			DPRINTF(("vdisk_block_size %u\n", sc->sc_vdisk_block_size));
635 			sc->sc_vdisk_size = ai->vdisk_size;
636 			DPRINTF(("vdisk_size %lu\n", sc->sc_vdisk_size));
637 			if (sc->sc_major > 1 || sc->sc_minor >= 1)
638 				sc->sc_vd_mtype = ai->vd_mtype;
639 			else
640 				sc->sc_vd_mtype = VD_MEDIA_TYPE_FIXED;
641 
642 			sc->sc_vio_state |= VIO_ACK_ATTR_INFO;
643 			break;
644 
645 		default:
646 			DPRINTF(("CTRL/0x%02x/ATTR_INFO\n", ai->tag.stype));
647 			break;
648 	}
649 
650 	if (ISSET(sc->sc_vio_state, VIO_ACK_ATTR_INFO))
651 		vdsk_send_dring_reg(sc);
652 
653 }
654 
655 void
vdsk_rx_vio_dring_reg(struct vdsk_softc * sc,struct vio_msg_tag * tag)656 vdsk_rx_vio_dring_reg(struct vdsk_softc *sc, struct vio_msg_tag *tag)
657 {
658 	struct vio_dring_reg *dr = (struct vio_dring_reg *)tag;
659 
660 	switch (dr->tag.stype) {
661 		case VIO_SUBTYPE_INFO:
662 			DPRINTF(("CTRL/INFO/DRING_REG\n"));
663 			break;
664 
665 		case VIO_SUBTYPE_ACK:
666 			DPRINTF(("CTRL/ACK/DRING_REG\n"));
667 			if (!ISSET(sc->sc_vio_state, VIO_SND_DRING_REG)) {
668 				ldc_reset(&sc->sc_lc);
669 				break;
670 			}
671 
672 			sc->sc_dring_ident = dr->dring_ident;
673 			sc->sc_seq_no = 1;
674 
675 			sc->sc_vio_state |= VIO_ACK_DRING_REG;
676 			break;
677 
678 		default:
679 			DPRINTF(("CTRL/0x%02x/DRING_REG\n", dr->tag.stype));
680 			break;
681 	}
682 
683 	if (ISSET(sc->sc_vio_state, VIO_ACK_DRING_REG))
684 		vdsk_send_rdx(sc);
685 }
686 
687 void
vdsk_rx_vio_rdx(struct vdsk_softc * sc,struct vio_msg_tag * tag)688 vdsk_rx_vio_rdx(struct vdsk_softc *sc, struct vio_msg_tag *tag)
689 {
690 	switch(tag->stype) {
691 		case VIO_SUBTYPE_INFO:
692 			DPRINTF(("CTRL/INFO/RDX\n"));
693 			break;
694 
695 		case VIO_SUBTYPE_ACK:
696 		{
697 			int prod;
698 
699 			DPRINTF(("CTRL/ACK/RDX\n"));
700 			if (!ISSET(sc->sc_vio_state, VIO_SND_RDX)) {
701 				ldc_reset(&sc->sc_lc);
702 				break;
703 			}
704 			sc->sc_vio_state |= VIO_ACK_RDX;
705 
706 			/*
707 			 * If this ACK is the result of a reconnect, we may
708 			 * have pending I/O that we need to resubmit.  We need
709 			 * to rebuild the ring descriptors though since the
710 			 * vDisk server on the other side may have touched
711 			 * them already.  So we just clean up the ring and the
712 			 * LDC map and resubmit the SCSI commands based on our
713 			 * soft descriptors.
714 			 */
715 			prod = sc->sc_tx_prod;
716 			sc->sc_tx_prod = sc->sc_tx_cons;
717 			sc->sc_tx_cnt = 0;
718 			sc->sc_lm->lm_next = 1;
719 			sc->sc_lm->lm_count = 1;
720 			while (sc->sc_tx_prod != prod)
721 			  vdsk_submit_cmd(sc, sc->sc_vsd[sc->sc_tx_prod].vsd_xs);
722 			break;
723 	}
724 
725 		default:
726 			DPRINTF(("CTRL/0x%02x/RDX (VIO)\n", tag->stype));
727 			break;
728 	}
729 }
730 
731 void
vdsk_rx_vio_data(struct vdsk_softc * sc,struct vio_msg * vm)732 vdsk_rx_vio_data(struct vdsk_softc *sc, struct vio_msg *vm)
733 {
734 	struct vio_msg_tag *tag = (struct vio_msg_tag *)&vm->type;
735 
736 	if (sc->sc_vio_state != VIO_ESTABLISHED) {
737 		DPRINTF(("Spurious DATA/0x%02x/0x%04x\n", tag->stype,
738 		    tag->stype_env));
739 		return;
740 	}
741 
742 	switch(tag->stype_env) {
743 		case VIO_DRING_DATA:
744 			vdsk_rx_vio_dring_data(sc, tag);
745 			break;
746 
747 		default:
748 			DPRINTF(("DATA/0x%02x/0x%04x\n", tag->stype, tag->stype_env));
749 			break;
750 	}
751 }
752 
753 void
vdsk_rx_vio_dring_data(struct vdsk_softc * sc,struct vio_msg_tag * tag)754 vdsk_rx_vio_dring_data(struct vdsk_softc *sc, struct vio_msg_tag *tag)
755 {
756 	switch(tag->stype) {
757 		case VIO_SUBTYPE_INFO:
758 			DPRINTF(("DATA/INFO/DRING_DATA\n"));
759 			break;
760 
761 		case VIO_SUBTYPE_ACK:
762 		{
763 			struct scsipi_xfer *xs;
764 			int cons;
765 
766 			cons = sc->sc_tx_cons;
767 			while (sc->sc_vd->vd_desc[cons].hdr.dstate == VIO_DESC_DONE) {
768 				xs = sc->sc_vsd[cons].vsd_xs;
769 				if (ISSET(xs->xs_control, XS_CTL_POLL) == 0)
770 					vdsk_complete_cmd(sc, xs, cons);
771 				cons++;
772 				cons &= (sc->sc_vd->vd_nentries - 1);
773 			}
774 			sc->sc_tx_cons = cons;
775 			break;
776 	}
777 
778 		case VIO_SUBTYPE_NACK:
779 			DPRINTF(("DATA/NACK/DRING_DATA\n"));
780 			struct ldc_conn *lc = &sc->sc_lc;
781 			ldc_send_vers(lc);
782 			break;
783 
784 		default:
785 			DPRINTF(("DATA/0x%02x/DRING_DATA\n", tag->stype));
786 			break;
787 	}
788 }
789 
790 void
vdsk_ldc_reset(struct ldc_conn * lc)791 vdsk_ldc_reset(struct ldc_conn *lc)
792 {
793 	struct vdsk_softc *sc = lc->lc_sc;
794 
795 	sc->sc_vio_state = 0;
796 }
797 
798 void
vdsk_ldc_start(struct ldc_conn * lc)799 vdsk_ldc_start(struct ldc_conn *lc)
800 {
801 	struct vdsk_softc *sc = lc->lc_sc;
802 
803 	vdsk_send_ver_info(sc, VDSK_MAJOR, VDSK_MINOR);
804 }
805 
806 void
vdsk_sendmsg(struct vdsk_softc * sc,void * msg,size_t len)807 vdsk_sendmsg(struct vdsk_softc *sc, void *msg, size_t len)
808 {
809 	struct ldc_conn *lc = &sc->sc_lc;
810 	int err;
811 
812 	err = ldc_send_unreliable(lc, msg, len);
813 	if (err)
814 		printf("%s: ldc_send_unreliable: %d\n", __func__, err);
815 }
816 
817 void
vdsk_send_ver_info(struct vdsk_softc * sc,uint16_t major,uint16_t minor)818 vdsk_send_ver_info(struct vdsk_softc *sc, uint16_t major, uint16_t minor)
819 {
820 	struct vio_ver_info vi;
821 
822 	/* Allocate new session ID. */
823 	sc->sc_local_sid = gettick();
824 
825 	bzero(&vi, sizeof(vi));
826 	vi.tag.type = VIO_TYPE_CTRL;
827 	vi.tag.stype = VIO_SUBTYPE_INFO;
828 	vi.tag.stype_env = VIO_VER_INFO;
829 	vi.tag.sid = sc->sc_local_sid;
830 	vi.major = major;
831 	vi.minor = minor;
832 	vi.dev_class = VDEV_DISK;
833 	vdsk_sendmsg(sc, &vi, sizeof(vi));
834 
835 	sc->sc_vio_state |= VIO_SND_VER_INFO;
836 }
837 
838 void
vdsk_send_attr_info(struct vdsk_softc * sc)839 vdsk_send_attr_info(struct vdsk_softc *sc)
840 {
841 	struct vd_attr_info ai;
842 
843 	bzero(&ai, sizeof(ai));
844 	ai.tag.type = VIO_TYPE_CTRL;
845 	ai.tag.stype = VIO_SUBTYPE_INFO;
846 	ai.tag.stype_env = VIO_ATTR_INFO;
847 	ai.tag.sid = sc->sc_local_sid;
848 	ai.xfer_mode = VIO_DRING_MODE;
849 	ai.vdisk_block_size = DEV_BSIZE;
850 	ai.max_xfer_sz = MAXPHYS / DEV_BSIZE;
851 	DPRINTF(("vdisk_block_size %u\n", ai.vdisk_block_size));
852 	DPRINTF(("max_xfer_sz %lu\n", ai.max_xfer_sz));
853 	vdsk_sendmsg(sc, &ai, sizeof(ai));
854 
855 	sc->sc_vio_state |= VIO_SND_ATTR_INFO;
856 }
857 
858 void
vdsk_send_dring_reg(struct vdsk_softc * sc)859 vdsk_send_dring_reg(struct vdsk_softc *sc)
860 {
861 	struct vio_dring_reg dr;
862 
863 	bzero(&dr, sizeof(dr));
864 	dr.tag.type = VIO_TYPE_CTRL;
865 	dr.tag.stype = VIO_SUBTYPE_INFO;
866 	dr.tag.stype_env = VIO_DRING_REG;
867 	dr.tag.sid = sc->sc_local_sid;
868 	dr.dring_ident = 0;
869 	dr.num_descriptors = sc->sc_vd->vd_nentries;
870 	dr.descriptor_size = sizeof(struct vd_desc);
871 	dr.options = VIO_TX_RING | VIO_RX_RING;
872 	dr.ncookies = 1;
873 	dr.cookie[0].addr = 0;
874 	dr.cookie[0].size = PAGE_SIZE;
875 	vdsk_sendmsg(sc, &dr, sizeof(dr));
876 
877 	sc->sc_vio_state |= VIO_SND_DRING_REG;
878 };
879 
880 void
vdsk_send_rdx(struct vdsk_softc * sc)881 vdsk_send_rdx(struct vdsk_softc *sc)
882 {
883 	struct vio_rdx rdx;
884 
885 	bzero(&rdx, sizeof(rdx));
886 	rdx.tag.type = VIO_TYPE_CTRL;
887 	rdx.tag.stype = VIO_SUBTYPE_INFO;
888 	rdx.tag.stype_env = VIO_RDX;
889 	rdx.tag.sid = sc->sc_local_sid;
890 	vdsk_sendmsg(sc, &rdx, sizeof(rdx));
891 
892 	sc->sc_vio_state |= VIO_SND_RDX;
893 }
894 
895 #if OPENBSD_BUSDMA
896 struct vdsk_dring *
vdsk_dring_alloc(bus_dma_tag_t t,int nentries)897 vdsk_dring_alloc(bus_dma_tag_t t, int nentries)
898 #else
899 struct vdsk_dring *
900 vdsk_dring_alloc(int nentries)
901 #endif
902 {
903 
904 	struct vdsk_dring *vd;
905 	bus_size_t size;
906 	vaddr_t va;
907 #if OPENBSD_BUSDMA
908 	int nsegs;
909 #endif
910 	int i;
911 
912 	vd = kmem_zalloc(sizeof(struct vdsk_dring), KM_SLEEP);
913 
914 	size = roundup(nentries * sizeof(struct vd_desc), PAGE_SIZE);
915 
916 #if OPENBSD_BUSDMA
917 	if (bus_dmamap_create(t, size, 1, size, 0,
918 	    BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, &vd->vd_map) != 0)
919 		return (NULL);
920 
921 	if (bus_dmamem_alloc(t, size, PAGE_SIZE, 0, &vd->vd_seg, 1,
922 	    &nsegs, BUS_DMA_NOWAIT) != 0)
923 		goto destroy;
924 
925 	if (bus_dmamem_map(t, &vd->vd_seg, 1, size, (void*)&va,
926 	    BUS_DMA_NOWAIT) != 0)
927 		goto free;
928 
929 	if (bus_dmamap_load(t, vd->vd_map, (void*)va, size, NULL,
930 	    BUS_DMA_NOWAIT) != 0)
931 		goto unmap;
932 #else
933 	va = (vaddr_t)kmem_zalloc(size, KM_SLEEP);
934 #endif
935 	vd->vd_desc = (struct vd_desc *)va;
936 	vd->vd_nentries = nentries;
937 	bzero(vd->vd_desc, nentries * sizeof(struct vd_desc));
938 	for (i = 0; i < vd->vd_nentries; i++)
939 		vd->vd_desc[i].hdr.dstate = VIO_DESC_FREE;
940 	return (vd);
941 
942 #if OPENBSD_BUSDMA
943 unmap:
944 	bus_dmamem_unmap(t, (void*)va, size);
945 free:
946 	bus_dmamem_free(t, &vd->vd_seg, 1);
947 destroy:
948 	bus_dmamap_destroy(t, vd->vd_map);
949 #endif
950 	return (NULL);
951 }
952 
953 #if OPENBSD_BUSDMA
954 void
vdsk_dring_free(bus_dma_tag_t t,struct vdsk_dring * vd)955 vdsk_dring_free(bus_dma_tag_t t, struct vdsk_dring *vd)
956 #else
957 void
958 vdsk_dring_free(struct vdsk_dring *vd)
959 #endif
960 {
961 
962 	bus_size_t size;
963 
964 	size = vd->vd_nentries * sizeof(struct vd_desc);
965 	size = roundup(size, PAGE_SIZE);
966 
967 #if OPENBSD_BUSDMA
968 	bus_dmamap_unload(t, vd->vd_map);
969 
970 	bus_dmamem_unmap(t, (caddr_t)vd->vd_desc, size);
971 	bus_dmamem_free(t, &vd->vd_seg, 1);
972 	bus_dmamap_destroy(t, vd->vd_map);
973 #else
974 	kmem_free(vd->vd_desc, size);
975 #endif
976 	kmem_free(vd, size);
977 }
978 
979 void *
vdsk_io_get(void * xsc)980 vdsk_io_get(void *xsc)
981 {
982 
983 	panic("%s: not verified yet", __FUNCTION__);
984 
985 	struct vdsk_softc *sc = xsc;
986 	void *rv = sc; /* just has to be !NULL */
987 	int s;
988 
989 	s = splbio();
990 	if (sc->sc_vio_state != VIO_ESTABLISHED ||
991 	    sc->sc_tx_cnt >= sc->sc_vd->vd_nentries)
992 		rv = NULL;
993 	else
994 		sc->sc_tx_cnt++;
995 	splx(s);
996 
997 	return (rv);
998 }
999 
1000 void
vdsk_io_put(void * xsc,void * io)1001 vdsk_io_put(void *xsc, void *io)
1002 {
1003 
1004 	panic("%s: not verified yet", __FUNCTION__);
1005 
1006 	struct vdsk_softc *sc = xsc;
1007 	int s;
1008 
1009 #ifdef DIAGNOSTIC
1010 	if (sc != io)
1011 		panic("vsdk_io_put: unexpected io");
1012 #endif
1013 
1014 	s = splbio();
1015 	sc->sc_tx_cnt--;
1016 	splx(s);
1017 }
1018 
1019 void
vdsk_scsi_cmd(struct vdsk_softc * sc,struct scsipi_xfer * xs)1020 vdsk_scsi_cmd(struct vdsk_softc *sc, struct scsipi_xfer *xs)
1021 {
1022 	int timeout, s;
1023 	int desc;
1024 
1025 	DPRINTF(("vdsk_scsi_cmd() opcode %x\n", xs->cmd->opcode));
1026 
1027 	switch (xs->cmd->opcode) {
1028 
1029 		case SCSI_READ_6_COMMAND:
1030 			DPRINTF(("SCSI_READ_6_COMMAND\n"));
1031 			break;
1032 
1033 		case READ_10:
1034 			DPRINTF(("SCSI_READ_10\n"));
1035 			break;
1036 
1037 		case READ_12:
1038 			DPRINTF(("SCSI_READ_12\n"));
1039 			break;
1040 
1041 		case READ_16:
1042 			DPRINTF(("SCSI_READ_16\n"));
1043 			break;
1044 
1045 		case SCSI_WRITE_6_COMMAND:
1046 			DPRINTF(("SCSI_WRITE_6\n"));
1047 			break;
1048 
1049 		case WRITE_10:
1050 			DPRINTF(("SCSI_WRITE_10\n"));
1051 			break;
1052 
1053 		case WRITE_12:
1054 			DPRINTF(("SCSI_WRITE_12\n"));
1055 			break;
1056 
1057 		case WRITE_16:
1058 			DPRINTF(("SCSI_WRITE_16\n"));
1059 			break;
1060 
1061 		case SCSI_SYNCHRONIZE_CACHE_10:
1062 			DPRINTF(("SCSI_SYNCHRONIZE_CACHE_10WRITE_16\n"));
1063 			break;
1064 
1065 		case INQUIRY:
1066 			DPRINTF(("INQUIRY\n"));
1067 			vdsk_scsi_inq(sc, xs);
1068 			return;
1069 
1070 		case READ_CAPACITY_10:
1071 			DPRINTF(("READ_CAPACITY_10\n"));
1072 			vdsk_scsi_capacity(sc, xs);
1073 			return;
1074 
1075 		case READ_CAPACITY_16:
1076 			DPRINTF(("READ_CAPACITY_16\n"));
1077 			vdsk_scsi_capacity16(sc, xs);
1078 			return;
1079 
1080 		case SCSI_REPORT_LUNS:
1081 			DPRINTF(("REPORT_LUNS\n"));
1082 			vdsk_scsi_report_luns(sc, xs);
1083 			return;
1084 
1085 		case SCSI_TEST_UNIT_READY:
1086 			DPRINTF(("TEST_UNIT_READY\n"));
1087 			vdsk_scsi_done(xs, XS_NOERROR);
1088 			return;
1089 
1090 		case START_STOP:
1091 			DPRINTF(("START_STOP\n"));
1092 			vdsk_scsi_done(xs, XS_NOERROR);
1093 			return;
1094 
1095 		case SCSI_PREVENT_ALLOW_MEDIUM_REMOVAL:
1096 			DPRINTF(("PREVENT_ALLOW_MEDIUM_REMOVAL\n"));
1097 			vdsk_scsi_done(xs, XS_NOERROR);
1098 			return;
1099 
1100 		case SCSI_MODE_SENSE_6:
1101 			DPRINTF(("SCSI_MODE_SENSE_6 (not implemented)\n"));
1102 			vdsk_scsi_done(xs, XS_DRIVER_STUFFUP);
1103 			return;
1104 
1105 		case SCSI_MODE_SELECT_6:
1106 				DPRINTF(("MODE_SELECT_6 (not implemented)\n"));
1107 			vdsk_scsi_done(xs, XS_DRIVER_STUFFUP);
1108 			return;
1109 
1110 		case SCSI_MAINTENANCE_IN:
1111 			DPRINTF(("MAINTENANCE_IN\n"));
1112 			vdsk_scsi_done(xs, XS_NOERROR);
1113 			return;
1114 
1115 		case SCSI_MODE_SENSE_10:
1116 			DPRINTF(("SCSI_MODE_SENSE_10 (not implemented)\n"));
1117 			vdsk_scsi_done(xs, XS_DRIVER_STUFFUP);
1118 			return;
1119 
1120 		case READ_TOC:
1121 			DPRINTF(("READ_TOC (not implemented)\n"));
1122 			vdsk_scsi_done(xs, XS_DRIVER_STUFFUP);
1123 			return;
1124 
1125 		default:
1126 			panic("%s unhandled cmd 0x%02x\n",
1127 			      __func__, xs->cmd->opcode);
1128 	}
1129 
1130 	s = splbio();
1131 	desc = vdsk_submit_cmd(sc, xs);
1132 
1133 	if (!ISSET(xs->xs_control, XS_CTL_POLL)) {
1134 		splx(s);
1135 		return;
1136 	}
1137 	timeout = 1000;
1138 	do {
1139 		if (sc->sc_vd->vd_desc[desc].hdr.dstate == VIO_DESC_DONE)
1140 			break;
1141 
1142 		delay(1000);
1143 	} while(--timeout > 0);
1144 	if (sc->sc_vd->vd_desc[desc].hdr.dstate == VIO_DESC_DONE) {
1145 		vdsk_complete_cmd(sc, xs, desc);
1146 	} else {
1147 		ldc_reset(&sc->sc_lc);
1148 		vdsk_scsi_done(xs, XS_TIMEOUT);
1149 	}
1150 	splx(s);
1151 }
1152 
1153 int
vdsk_submit_cmd(struct vdsk_softc * sc,struct scsipi_xfer * xs)1154 vdsk_submit_cmd(struct vdsk_softc *sc, struct scsipi_xfer *xs)
1155 {
1156 	struct ldc_map *map = sc->sc_lm;
1157 	struct vio_dring_msg dm;
1158 	struct scsi_rw_6 *rw6;
1159 	struct scsipi_rw_10 *rw10;
1160 	struct scsipi_rw_12 *rw12;
1161 	struct scsipi_rw_16 *rw16;
1162 	u_int64_t lba = 0;
1163 	uint8_t operation;
1164 	vaddr_t va;
1165 	paddr_t pa;
1166 	psize_t nbytes;
1167 	int len, ncookies;
1168 	int desc;
1169 
1170 	switch (xs->cmd->opcode) {
1171 
1172 		case SCSI_READ_6_COMMAND:
1173 		case READ_10:
1174 		case READ_12:
1175 		case READ_16:
1176 			DPRINTF(("VD_OP_BREAD\n"));
1177 			operation = VD_OP_BREAD;
1178 			break;
1179 
1180 		case SCSI_WRITE_6_COMMAND:
1181 		case WRITE_10:
1182 		case WRITE_12:
1183 		case WRITE_16:
1184 			DPRINTF(("VD_OP_BWRITE\n"));
1185 			operation = VD_OP_BWRITE;
1186 			break;
1187 
1188 		case SCSI_SYNCHRONIZE_CACHE_10:
1189 			DPRINTF(("VD_OP_FLUSH\n"));
1190 			operation = VD_OP_FLUSH;
1191 			break;
1192 
1193 		default:
1194 			panic("%s  unhandled cmd opcode 0x%x",
1195 			      __func__, xs->cmd->opcode);
1196 	}
1197 
1198 	/*
1199 	 * READ/WRITE/SYNCHRONIZE commands. SYNCHRONIZE CACHE has same
1200 	 * layout as 10-byte READ/WRITE commands.
1201 	 */
1202 	if (xs->cmdlen == 6) {
1203 		rw6 = (struct scsi_rw_6 *)xs->cmd;
1204 		lba = _3btol(rw6->addr) & (SRW_TOPADDR << 16 | 0xffff);
1205 	} else if (xs->cmdlen == 10) {
1206 		rw10 = (struct scsipi_rw_10 *)xs->cmd;
1207 		lba = _4btol(rw10->addr);
1208 	} else if (xs->cmdlen == 12) {
1209 		rw12 = (struct scsipi_rw_12 *)xs->cmd;
1210 		lba = _4btol(rw12->addr);
1211 	} else if (xs->cmdlen == 16) {
1212 		rw16 = (struct scsipi_rw_16 *)xs->cmd;
1213 		lba = _8btol(rw16->addr);
1214 	}
1215 
1216 	DPRINTF(("lba = %lu\n", lba));
1217 
1218 	desc = sc->sc_tx_prod;
1219 	ncookies = 0;
1220 	len = xs->datalen;
1221 	va = (vaddr_t)xs->data;
1222 	while (len > 0) {
1223 		DPRINTF(("len = %u\n", len));
1224 		KASSERT(ncookies < MAXPHYS / PAGE_SIZE);
1225 		pa = 0;
1226 		pmap_extract(pmap_kernel(), va, &pa);
1227 		while (map->lm_slot[map->lm_next].entry != 0) {
1228 			map->lm_next++;
1229 			map->lm_next &= (map->lm_nentries - 1);
1230 		}
1231 		map->lm_slot[map->lm_next].entry = (pa & LDC_MTE_RA_MASK);
1232 		map->lm_slot[map->lm_next].entry |= LDC_MTE_CPR | LDC_MTE_CPW;
1233 		map->lm_slot[map->lm_next].entry |= LDC_MTE_IOR | LDC_MTE_IOW;
1234 		map->lm_slot[map->lm_next].entry |= LDC_MTE_R | LDC_MTE_W;
1235 		map->lm_count++;
1236 
1237 		nbytes = MIN(len, PAGE_SIZE - (pa & PAGE_MASK));
1238 
1239 		sc->sc_vd->vd_desc[desc].cookie[ncookies].addr =
1240 		    map->lm_next << PAGE_SHIFT | (pa & PAGE_MASK);
1241 		sc->sc_vd->vd_desc[desc].cookie[ncookies].size = nbytes;
1242 
1243 		sc->sc_vsd[desc].vsd_map_idx[ncookies] = map->lm_next;
1244 		va += nbytes;
1245 		len -= nbytes;
1246 		ncookies++;
1247 	}
1248 	if (ISSET(xs->xs_control, XS_CTL_POLL) == 0)
1249 		sc->sc_vd->vd_desc[desc].hdr.ack = 1;
1250 	else
1251 		sc->sc_vd->vd_desc[desc].hdr.ack = 0;
1252 	sc->sc_vd->vd_desc[desc].operation = operation;
1253 	sc->sc_vd->vd_desc[desc].slice = VD_SLICE_NONE;
1254 	sc->sc_vd->vd_desc[desc].status = 0xffffffff;
1255 	sc->sc_vd->vd_desc[desc].offset = lba;
1256 	sc->sc_vd->vd_desc[desc].size = xs->datalen;
1257 	sc->sc_vd->vd_desc[desc].ncookies = ncookies;
1258 
1259 	membar_Sync();
1260 
1261 	sc->sc_vd->vd_desc[desc].hdr.dstate = VIO_DESC_READY;
1262 
1263 	sc->sc_vsd[desc].vsd_xs = xs;
1264 	sc->sc_vsd[desc].vsd_ncookies = ncookies;
1265 
1266 	sc->sc_tx_prod++;
1267 	sc->sc_tx_prod &= (sc->sc_vd->vd_nentries - 1);
1268 
1269 	bzero(&dm, sizeof(dm));
1270 	dm.tag.type = VIO_TYPE_DATA;
1271 	dm.tag.stype = VIO_SUBTYPE_INFO;
1272 	dm.tag.stype_env = VIO_DRING_DATA;
1273 	dm.tag.sid = sc->sc_local_sid;
1274 	dm.seq_no = sc->sc_seq_no++;
1275 	dm.dring_ident = sc->sc_dring_ident;
1276 	dm.start_idx = dm.end_idx = desc;
1277 	vdsk_sendmsg(sc, &dm, sizeof(dm));
1278 
1279 	return desc;
1280 }
1281 
1282 void
vdsk_complete_cmd(struct vdsk_softc * sc,struct scsipi_xfer * xs,int desc)1283 vdsk_complete_cmd(struct vdsk_softc *sc, struct scsipi_xfer *xs, int desc)
1284 {
1285 	struct ldc_map *map = sc->sc_lm;
1286 	int cookie, idx;
1287 	int error;
1288 
1289 	cookie = 0;
1290 	while (cookie < sc->sc_vsd[desc].vsd_ncookies) {
1291 		idx = sc->sc_vsd[desc].vsd_map_idx[cookie++];
1292 		map->lm_slot[idx].entry = 0;
1293 		map->lm_count--;
1294 	}
1295 
1296 	error = XS_NOERROR;
1297 	if (sc->sc_vd->vd_desc[desc].status != 0)
1298 		error = XS_DRIVER_STUFFUP;
1299 	xs->resid = xs->datalen -
1300 		sc->sc_vd->vd_desc[desc].size;
1301 
1302 	/*
1303 	 * scsi_done() called by vdsk_scsi_done() requires
1304 	 * the kernel to be locked
1305 	 */
1306 	KERNEL_LOCK(1, curlwp);
1307 	vdsk_scsi_done(xs, error);
1308 	KERNEL_UNLOCK_ONE(curlwp);
1309 
1310 	sc->sc_vd->vd_desc[desc].hdr.dstate = VIO_DESC_FREE;
1311 
1312 }
1313 
1314 void
vdsk_scsi_inq(struct vdsk_softc * sc,struct scsipi_xfer * xs)1315 vdsk_scsi_inq(struct vdsk_softc *sc, struct scsipi_xfer *xs)
1316 {
1317 	vdsk_scsi_inquiry(sc, xs);
1318 }
1319 
1320 void
vdsk_scsi_inquiry(struct vdsk_softc * sc,struct scsipi_xfer * xs)1321 vdsk_scsi_inquiry(struct vdsk_softc *sc, struct scsipi_xfer *xs)
1322 {
1323 	struct scsipi_inquiry_data inq;
1324 	char buf[5];
1325 
1326 	bzero(&inq, sizeof(inq));
1327 
1328 	switch (sc->sc_vd_mtype) {
1329 		case VD_MEDIA_TYPE_CD:
1330 		case VD_MEDIA_TYPE_DVD:
1331 			inq.device = T_CDROM;
1332 			inq.dev_qual2 = SID_REMOVABLE;
1333 			bcopy("Virtual CDROM   ", inq.product, sizeof(inq.product));
1334 			break;
1335 		case VD_MEDIA_TYPE_FIXED:
1336 			inq.device = T_DIRECT;
1337 			bcopy("Virtual Disk    ", inq.product, sizeof(inq.product));
1338 			break;
1339 		default:
1340 			panic("Unhandled media type %d\n", sc->sc_vd_mtype);
1341 	}
1342 	inq.version = 0x05; /* SPC-3 */
1343 	inq.response_format = 2;
1344 	inq.additional_length = 32;
1345 	inq.flags3 |= SID_CmdQue;
1346 	bcopy("SUN     ", inq.vendor, sizeof(inq.vendor));
1347 	snprintf(buf, sizeof(buf), "%u.%u ", sc->sc_major, sc->sc_minor);
1348 	bcopy(buf, inq.revision, sizeof(inq.revision));
1349 
1350 	bcopy(&inq, xs->data, MIN(sizeof(inq), xs->datalen));
1351 
1352 	vdsk_scsi_done(xs, XS_NOERROR);
1353 }
1354 
1355 void
vdsk_scsi_capacity(struct vdsk_softc * sc,struct scsipi_xfer * xs)1356 vdsk_scsi_capacity(struct vdsk_softc *sc, struct scsipi_xfer *xs)
1357 {
1358 	struct scsipi_read_capacity_10_data rcd;
1359 	uint64_t capacity;
1360 
1361 	bzero(&rcd, sizeof(rcd));
1362 
1363 	capacity = sc->sc_vdisk_size - 1;
1364 	if (capacity > 0xffffffff)
1365 		capacity = 0xffffffff;
1366 
1367 	_lto4b(capacity, rcd.addr);
1368 	_lto4b(sc->sc_vdisk_block_size, rcd.length);
1369 
1370 	DPRINTF(("%s() capacity %lu  block size %u\n",
1371 		 __FUNCTION__, capacity, sc->sc_vdisk_block_size));
1372 
1373 	bcopy(&rcd, xs->data, MIN(sizeof(rcd), xs->datalen));
1374 
1375 	vdsk_scsi_done(xs, XS_NOERROR);
1376 }
1377 
1378 void
vdsk_scsi_capacity16(struct vdsk_softc * sc,struct scsipi_xfer * xs)1379 vdsk_scsi_capacity16(struct vdsk_softc *sc, struct scsipi_xfer *xs)
1380 {
1381 	struct scsipi_read_capacity_16_data rcd;
1382 	uint64_t capacity;
1383 
1384 	bzero(&rcd, sizeof(rcd));
1385 
1386 	capacity = sc->sc_vdisk_size - 1;
1387 
1388 	_lto8b(capacity, rcd.addr);
1389 	_lto4b(sc->sc_vdisk_block_size, rcd.length);
1390 
1391 	DPRINTF(("%s() capacity %lu  block size %u\n",
1392 		 __FUNCTION__, capacity, sc->sc_vdisk_block_size));
1393 
1394 	bcopy(&rcd, xs->data, MIN(sizeof(rcd), xs->datalen));
1395 
1396 	vdsk_scsi_done(xs, XS_NOERROR);
1397 }
1398 
1399 void
vdsk_scsi_report_luns(struct vdsk_softc * sc,struct scsipi_xfer * xs)1400 vdsk_scsi_report_luns(struct vdsk_softc *sc, struct scsipi_xfer *xs)
1401 {
1402 	vdsk_scsi_done(xs, XS_NOERROR);
1403 }
1404 
1405 void
vdsk_scsi_done(struct scsipi_xfer * xs,int error)1406 vdsk_scsi_done(struct scsipi_xfer *xs, int error)
1407 {
1408 	xs->error = error;
1409 
1410 	scsipi_done(xs);
1411 }
1412