2 * QEMU PowerPC pSeries Logical Partition (aka sPAPR) hardware System Emulator
4 * PAPR Virtual SCSI, aka ibmvscsi
6 * Copyright (c) 2010,2011 Benjamin Herrenschmidt, IBM Corporation.
8 * Permission is hereby granted, free of charge, to any person obtaining a copy
9 * of this software and associated documentation files (the "Software"), to deal
10 * in the Software without restriction, including without limitation the rights
11 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12 * copies of the Software, and to permit persons to whom the Software is
13 * furnished to do so, subject to the following conditions:
15 * The above copyright notice and this permission notice shall be included in
16 * all copies or substantial portions of the Software.
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
29 * - Sort out better how to assign devices to VSCSI instances
30 * - Fix residual counts
31 * - Add indirect descriptors support
32 * - Maybe do autosense (PAPR seems to mandate it, linux doesn't care)
36 #include "scsi-defs.h"
37 #include "net.h" /* Remove that when we can */
41 #include "hw/spapr_vio.h"
42 #include "hw/ppc-viosrp.h"
46 /*#define DEBUG_VSCSI*/
49 #define dprintf(fmt, ...) \
50 do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
52 #define dprintf(fmt, ...) \
61 #define VSCSI_MAX_SECTORS 4096
62 #define VSCSI_REQ_LIMIT 24
64 #define SCSI_SENSE_BUF_SIZE 96
65 #define SRP_RSP_SENSE_DATA_LEN 18
67 typedef union vscsi_crq
{
72 typedef struct vscsi_req
{
76 /* SCSI request tracking */
79 uint32_t qtag
; /* qemu tag != srp tag */
86 uint8_t sense
[SCSI_SENSE_BUF_SIZE
];
88 /* RDMA related bits */
90 struct srp_direct_buf ext_desc
;
91 struct srp_direct_buf
*cur_desc
;
92 struct srp_indirect_buf
*ind_desc
;
101 vscsi_req reqs
[VSCSI_REQ_LIMIT
];
105 static VSCSIState
*dbg_vscsi_state
;
108 static struct vscsi_req
*vscsi_get_req(VSCSIState
*s
)
113 for (i
= 0; i
< VSCSI_REQ_LIMIT
; i
++) {
116 memset(req
, 0, sizeof(*req
));
125 static void vscsi_put_req(VSCSIState
*s
, vscsi_req
*req
)
127 if (req
->sreq
!= NULL
) {
128 scsi_req_unref(req
->sreq
);
134 static vscsi_req
*vscsi_find_req(VSCSIState
*s
, SCSIRequest
*req
)
136 uint32_t tag
= req
->tag
;
137 if (tag
>= VSCSI_REQ_LIMIT
|| !s
->reqs
[tag
].active
) {
140 return &s
->reqs
[tag
];
143 static void vscsi_decode_id_lun(uint64_t srp_lun
, int *id
, int *lun
)
145 /* XXX Figure that one out properly ! This is crackpot */
146 *id
= (srp_lun
>> 56) & 0x7f;
147 *lun
= (srp_lun
>> 48) & 0xff;
150 static int vscsi_send_iu(VSCSIState
*s
, vscsi_req
*req
,
151 uint64_t length
, uint8_t format
)
155 /* First copy the SRP */
156 rc
= spapr_tce_dma_write(&s
->vdev
, req
->crq
.s
.IU_data_ptr
,
159 fprintf(stderr
, "vscsi_send_iu: DMA write failure !\n");
162 req
->crq
.s
.valid
= 0x80;
163 req
->crq
.s
.format
= format
;
164 req
->crq
.s
.reserved
= 0x00;
165 req
->crq
.s
.timeout
= cpu_to_be16(0x0000);
166 req
->crq
.s
.IU_length
= cpu_to_be16(length
);
167 req
->crq
.s
.IU_data_ptr
= req
->iu
.srp
.rsp
.tag
; /* right byte order */
170 req
->crq
.s
.status
= 0x99; /* Just needs to be non-zero */
172 req
->crq
.s
.status
= 0x00;
175 rc1
= spapr_vio_send_crq(&s
->vdev
, req
->crq
.raw
);
177 fprintf(stderr
, "vscsi_send_iu: Error sending response\n");
184 static void vscsi_makeup_sense(VSCSIState
*s
, vscsi_req
*req
,
185 uint8_t key
, uint8_t asc
, uint8_t ascq
)
187 req
->senselen
= SRP_RSP_SENSE_DATA_LEN
;
189 /* Valid bit and 'current errors' */
190 req
->sense
[0] = (0x1 << 7 | 0x70);
193 /* Additional sense length */
194 req
->sense
[7] = 0xa; /* 10 bytes */
195 /* Additional sense code */
196 req
->sense
[12] = asc
;
197 req
->sense
[13] = ascq
;
200 static int vscsi_send_rsp(VSCSIState
*s
, vscsi_req
*req
,
201 uint8_t status
, int32_t res_in
, int32_t res_out
)
203 union viosrp_iu
*iu
= &req
->iu
;
204 uint64_t tag
= iu
->srp
.rsp
.tag
;
205 int total_len
= sizeof(iu
->srp
.rsp
);
207 dprintf("VSCSI: Sending resp status: 0x%x, "
208 "res_in: %d, res_out: %d\n", status
, res_in
, res_out
);
210 memset(iu
, 0, sizeof(struct srp_rsp
));
211 iu
->srp
.rsp
.opcode
= SRP_RSP
;
212 iu
->srp
.rsp
.req_lim_delta
= cpu_to_be32(1);
213 iu
->srp
.rsp
.tag
= tag
;
215 /* Handle residuals */
217 iu
->srp
.rsp
.flags
|= SRP_RSP_FLAG_DIUNDER
;
220 iu
->srp
.rsp
.flags
|= SRP_RSP_FLAG_DIOVER
;
223 iu
->srp
.rsp
.flags
|= SRP_RSP_FLAG_DOUNDER
;
225 } else if (res_out
) {
226 iu
->srp
.rsp
.flags
|= SRP_RSP_FLAG_DOOVER
;
228 iu
->srp
.rsp
.data_in_res_cnt
= cpu_to_be32(res_in
);
229 iu
->srp
.rsp
.data_out_res_cnt
= cpu_to_be32(res_out
);
231 /* We don't do response data */
232 /* iu->srp.rsp.flags &= ~SRP_RSP_FLAG_RSPVALID; */
233 iu
->srp
.rsp
.resp_data_len
= cpu_to_be32(0);
235 /* Handle success vs. failure */
236 iu
->srp
.rsp
.status
= status
;
238 iu
->srp
.rsp
.sol_not
= (iu
->srp
.cmd
.sol_not
& 0x04) >> 2;
240 req
->iu
.srp
.rsp
.flags
|= SRP_RSP_FLAG_SNSVALID
;
241 req
->iu
.srp
.rsp
.sense_data_len
= cpu_to_be32(req
->senselen
);
242 memcpy(req
->iu
.srp
.rsp
.data
, req
->sense
, req
->senselen
);
243 total_len
+= req
->senselen
;
246 iu
->srp
.rsp
.sol_not
= (iu
->srp
.cmd
.sol_not
& 0x02) >> 1;
249 vscsi_send_iu(s
, req
, total_len
, VIOSRP_SRP_FORMAT
);
253 static inline void vscsi_swap_desc(struct srp_direct_buf
*desc
)
255 desc
->va
= be64_to_cpu(desc
->va
);
256 desc
->len
= be32_to_cpu(desc
->len
);
259 static int vscsi_srp_direct_data(VSCSIState
*s
, vscsi_req
*req
,
260 uint8_t *buf
, uint32_t len
)
262 struct srp_direct_buf
*md
= req
->cur_desc
;
266 dprintf("VSCSI: direct segment 0x%x bytes, va=0x%llx desc len=0x%x\n",
267 len
, (unsigned long long)md
->va
, md
->len
);
269 llen
= MIN(len
, md
->len
);
271 if (req
->writing
) { /* writing = to device = reading from memory */
272 rc
= spapr_tce_dma_read(&s
->vdev
, md
->va
, buf
, llen
);
274 rc
= spapr_tce_dma_write(&s
->vdev
, md
->va
, buf
, llen
);
286 static int vscsi_srp_indirect_data(VSCSIState
*s
, vscsi_req
*req
,
287 uint8_t *buf
, uint32_t len
)
289 struct srp_direct_buf
*td
= &req
->ind_desc
->table_desc
;
290 struct srp_direct_buf
*md
= req
->cur_desc
;
292 uint32_t llen
, total
= 0;
294 dprintf("VSCSI: indirect segment 0x%x bytes, td va=0x%llx len=0x%x\n",
295 len
, (unsigned long long)td
->va
, td
->len
);
297 /* While we have data ... */
299 /* If we have a descriptor but it's empty, go fetch a new one */
300 if (md
&& md
->len
== 0) {
301 /* More local available, use one */
302 if (req
->local_desc
) {
303 md
= ++req
->cur_desc
;
306 td
->va
+= sizeof(struct srp_direct_buf
);
308 md
= req
->cur_desc
= NULL
;
311 /* No descriptor at hand, fetch one */
313 if (!req
->total_desc
) {
314 dprintf("VSCSI: Out of descriptors !\n");
317 md
= req
->cur_desc
= &req
->ext_desc
;
318 dprintf("VSCSI: Reading desc from 0x%llx\n",
319 (unsigned long long)td
->va
);
320 rc
= spapr_tce_dma_read(&s
->vdev
, td
->va
, md
,
321 sizeof(struct srp_direct_buf
));
323 dprintf("VSCSI: tce_dma_read -> %d reading ext_desc\n", rc
);
327 td
->va
+= sizeof(struct srp_direct_buf
);
330 dprintf("VSCSI: [desc va=0x%llx,len=0x%x] remaining=0x%x\n",
331 (unsigned long long)md
->va
, md
->len
, len
);
333 /* Perform transfer */
334 llen
= MIN(len
, md
->len
);
335 if (req
->writing
) { /* writing = to device = reading from memory */
336 rc
= spapr_tce_dma_read(&s
->vdev
, md
->va
, buf
, llen
);
338 rc
= spapr_tce_dma_write(&s
->vdev
, md
->va
, buf
, llen
);
341 dprintf("VSCSI: tce_dma_r/w(%d) -> %d\n", req
->writing
, rc
);
344 dprintf("VSCSI: data: %02x %02x %02x %02x...\n",
345 buf
[0], buf
[1], buf
[2], buf
[3]);
353 return rc
? -1 : total
;
356 static int vscsi_srp_transfer_data(VSCSIState
*s
, vscsi_req
*req
,
357 int writing
, uint8_t *buf
, uint32_t len
)
361 switch (req
->dma_fmt
) {
362 case SRP_NO_DATA_DESC
:
363 dprintf("VSCSI: no data desc transfer, skipping 0x%x bytes\n", len
);
365 case SRP_DATA_DESC_DIRECT
:
366 err
= vscsi_srp_direct_data(s
, req
, buf
, len
);
368 case SRP_DATA_DESC_INDIRECT
:
369 err
= vscsi_srp_indirect_data(s
, req
, buf
, len
);
375 /* Bits from linux srp */
376 static int data_out_desc_size(struct srp_cmd
*cmd
)
379 uint8_t fmt
= cmd
->buf_fmt
>> 4;
382 case SRP_NO_DATA_DESC
:
384 case SRP_DATA_DESC_DIRECT
:
385 size
= sizeof(struct srp_direct_buf
);
387 case SRP_DATA_DESC_INDIRECT
:
388 size
= sizeof(struct srp_indirect_buf
) +
389 sizeof(struct srp_direct_buf
)*cmd
->data_out_desc_cnt
;
397 static int vscsi_preprocess_desc(vscsi_req
*req
)
399 struct srp_cmd
*cmd
= &req
->iu
.srp
.cmd
;
402 offset
= cmd
->add_cdb_len
& ~3;
405 req
->dma_fmt
= cmd
->buf_fmt
>> 4;
407 offset
+= data_out_desc_size(cmd
);
408 req
->dma_fmt
= cmd
->buf_fmt
& ((1U << 4) - 1);
411 switch (req
->dma_fmt
) {
412 case SRP_NO_DATA_DESC
:
414 case SRP_DATA_DESC_DIRECT
:
415 req
->cur_desc
= (struct srp_direct_buf
*)(cmd
->add_data
+ offset
);
416 req
->total_desc
= req
->local_desc
= 1;
417 vscsi_swap_desc(req
->cur_desc
);
418 dprintf("VSCSI: using direct RDMA %s, 0x%x bytes MD: 0x%llx\n",
419 req
->writing
? "write" : "read",
420 req
->cur_desc
->len
, (unsigned long long)req
->cur_desc
->va
);
422 case SRP_DATA_DESC_INDIRECT
:
423 req
->ind_desc
= (struct srp_indirect_buf
*)(cmd
->add_data
+ offset
);
424 vscsi_swap_desc(&req
->ind_desc
->table_desc
);
425 req
->total_desc
= req
->ind_desc
->table_desc
.len
/
426 sizeof(struct srp_direct_buf
);
427 req
->local_desc
= req
->writing
? cmd
->data_out_desc_cnt
:
428 cmd
->data_in_desc_cnt
;
429 for (i
= 0; i
< req
->local_desc
; i
++) {
430 vscsi_swap_desc(&req
->ind_desc
->desc_list
[i
]);
432 req
->cur_desc
= req
->local_desc
? &req
->ind_desc
->desc_list
[0] : NULL
;
433 dprintf("VSCSI: using indirect RDMA %s, 0x%x bytes %d descs "
434 "(%d local) VA: 0x%llx\n",
435 req
->writing
? "read" : "write",
436 be32_to_cpu(req
->ind_desc
->len
),
437 req
->total_desc
, req
->local_desc
,
438 (unsigned long long)req
->ind_desc
->table_desc
.va
);
442 "vscsi_preprocess_desc: Unknown format %x\n", req
->dma_fmt
);
449 static void vscsi_send_request_sense(VSCSIState
*s
, vscsi_req
*req
)
451 SCSIDevice
*sdev
= req
->sdev
;
452 uint8_t *cdb
= req
->iu
.srp
.cmd
.cdb
;
462 n
= sdev
->info
->send_command(req
->sreq
, cdb
);
463 dprintf("VSCSI: Queued request sense tag 0x%x\n", req
->qtag
);
465 fprintf(stderr
, "VSCSI: REQUEST_SENSE wants write data !?!?!?\n");
466 sdev
->info
->cancel_io(req
->sreq
);
467 vscsi_makeup_sense(s
, req
, HARDWARE_ERROR
, 0, 0);
468 vscsi_send_rsp(s
, req
, CHECK_CONDITION
, 0, 0);
469 vscsi_put_req(s
, req
);
474 sdev
->info
->read_data(req
->sreq
);
477 /* Callback to indicate that the SCSI layer has completed a transfer. */
478 static void vscsi_command_complete(SCSIRequest
*sreq
, int reason
, uint32_t arg
)
480 VSCSIState
*s
= DO_UPCAST(VSCSIState
, vdev
.qdev
, sreq
->bus
->qbus
.parent
);
481 vscsi_req
*req
= vscsi_find_req(s
, sreq
);
484 int32_t res_in
= 0, res_out
= 0;
487 dprintf("VSCSI: SCSI cmd complete, r=0x%x tag=0x%x arg=0x%x, req=%p\n",
488 reason
, sreq
->tag
, arg
, req
);
490 fprintf(stderr
, "VSCSI: Can't find request for tag 0x%x\n", sreq
->tag
);
496 if (reason
== SCSI_REASON_DONE
) {
497 dprintf("VSCSI: Sense done !\n");
498 vscsi_send_rsp(s
, req
, CHECK_CONDITION
, 0, 0);
499 vscsi_put_req(s
, req
);
501 uint8_t *buf
= sdev
->info
->get_buf(sreq
);
503 len
= MIN(arg
, SCSI_SENSE_BUF_SIZE
);
504 dprintf("VSCSI: Sense data, %d bytes:\n", len
);
505 dprintf(" %02x %02x %02x %02x %02x %02x %02x %02x\n",
506 buf
[0], buf
[1], buf
[2], buf
[3],
507 buf
[4], buf
[5], buf
[6], buf
[7]);
508 dprintf(" %02x %02x %02x %02x %02x %02x %02x %02x\n",
509 buf
[8], buf
[9], buf
[10], buf
[11],
510 buf
[12], buf
[13], buf
[14], buf
[15]);
511 memcpy(req
->sense
, buf
, len
);
513 sdev
->info
->read_data(sreq
);
518 if (reason
== SCSI_REASON_DONE
) {
519 dprintf("VSCSI: Command complete err=%d\n", arg
);
521 /* We handle overflows, not underflows for normal commands,
522 * but hopefully nobody cares
525 res_out
= req
->data_len
;
527 res_in
= req
->data_len
;
529 vscsi_send_rsp(s
, req
, 0, res_in
, res_out
);
530 } else if (arg
== CHECK_CONDITION
) {
531 dprintf("VSCSI: Got CHECK_CONDITION, requesting sense...\n");
532 vscsi_send_request_sense(s
, req
);
535 vscsi_send_rsp(s
, req
, arg
, 0, 0);
537 vscsi_put_req(s
, req
);
541 /* "arg" is how much we have read for reads and how much we want
542 * to write for writes (ie, how much is to be DMA'd)
545 buf
= sdev
->info
->get_buf(sreq
);
546 rc
= vscsi_srp_transfer_data(s
, req
, req
->writing
, buf
, arg
);
549 fprintf(stderr
, "VSCSI: RDMA error rc=%d!\n", rc
);
550 sdev
->info
->cancel_io(sreq
);
551 vscsi_makeup_sense(s
, req
, HARDWARE_ERROR
, 0, 0);
552 vscsi_send_rsp(s
, req
, CHECK_CONDITION
, 0, 0);
553 vscsi_put_req(s
, req
);
557 /* Start next chunk */
560 sdev
->info
->write_data(sreq
);
562 sdev
->info
->read_data(sreq
);
566 static void vscsi_process_login(VSCSIState
*s
, vscsi_req
*req
)
568 union viosrp_iu
*iu
= &req
->iu
;
569 struct srp_login_rsp
*rsp
= &iu
->srp
.login_rsp
;
570 uint64_t tag
= iu
->srp
.rsp
.tag
;
572 dprintf("VSCSI: Got login, sendin response !\n");
574 /* TODO handle case that requested size is wrong and
575 * buffer format is wrong
577 memset(iu
, 0, sizeof(struct srp_login_rsp
));
578 rsp
->opcode
= SRP_LOGIN_RSP
;
579 /* Don't advertise quite as many request as we support to
580 * keep room for management stuff etc...
582 rsp
->req_lim_delta
= cpu_to_be32(VSCSI_REQ_LIMIT
-2);
584 rsp
->max_it_iu_len
= cpu_to_be32(sizeof(union srp_iu
));
585 rsp
->max_ti_iu_len
= cpu_to_be32(sizeof(union srp_iu
));
586 /* direct and indirect */
587 rsp
->buf_fmt
= cpu_to_be16(SRP_BUF_FORMAT_DIRECT
| SRP_BUF_FORMAT_INDIRECT
);
589 vscsi_send_iu(s
, req
, sizeof(*rsp
), VIOSRP_SRP_FORMAT
);
592 static void vscsi_inquiry_no_target(VSCSIState
*s
, vscsi_req
*req
)
594 uint8_t *cdb
= req
->iu
.srp
.cmd
.cdb
;
595 uint8_t resp_data
[36];
598 /* We dont do EVPD. Also check that page_code is 0 */
599 if ((cdb
[1] & 0x01) || (cdb
[1] & 0x01) || cdb
[2] != 0) {
600 /* Send INVALID FIELD IN CDB */
601 vscsi_makeup_sense(s
, req
, ILLEGAL_REQUEST
, 0x24, 0);
602 vscsi_send_rsp(s
, req
, CHECK_CONDITION
, 0, 0);
606 alen
= (alen
<< 8) | cdb
[4];
609 /* Fake up inquiry using PQ=3 */
610 memset(resp_data
, 0, 36);
611 resp_data
[0] = 0x7f; /* Not capable of supporting a device here */
612 resp_data
[2] = 0x06; /* SPS-4 */
613 resp_data
[3] = 0x02; /* Resp data format */
614 resp_data
[4] = 36 - 5; /* Additional length */
615 resp_data
[7] = 0x10; /* Sync transfers */
616 memcpy(&resp_data
[16], "QEMU EMPTY ", 16);
617 memcpy(&resp_data
[8], "QEMU ", 8);
620 vscsi_preprocess_desc(req
);
621 rc
= vscsi_srp_transfer_data(s
, req
, 0, resp_data
, len
);
623 vscsi_makeup_sense(s
, req
, HARDWARE_ERROR
, 0, 0);
624 vscsi_send_rsp(s
, req
, CHECK_CONDITION
, 0, 0);
626 vscsi_send_rsp(s
, req
, 0, 36 - rc
, 0);
630 static int vscsi_queue_cmd(VSCSIState
*s
, vscsi_req
*req
)
632 union srp_iu
*srp
= &req
->iu
.srp
;
636 vscsi_decode_id_lun(be64_to_cpu(srp
->cmd
.lun
), &id
, &lun
);
638 /* Qemu vs. linux issue with LUNs to be sorted out ... */
639 sdev
= (id
< 8 && lun
< 16) ? s
->bus
.devs
[id
] : NULL
;
641 dprintf("VSCSI: Command for id %d with no drive\n", id
);
642 if (srp
->cmd
.cdb
[0] == INQUIRY
) {
643 vscsi_inquiry_no_target(s
, req
);
645 vscsi_makeup_sense(s
, req
, ILLEGAL_REQUEST
, 0x24, 0x00);
646 vscsi_send_rsp(s
, req
, CHECK_CONDITION
, 0, 0);
652 req
->sreq
= sdev
->info
->alloc_req(sdev
, req
->qtag
, lun
);
653 n
= sdev
->info
->send_command(req
->sreq
, srp
->cmd
.cdb
);
655 dprintf("VSCSI: Queued command tag 0x%x CMD 0x%x ID %d LUN %d ret: %d\n",
656 req
->qtag
, srp
->cmd
.cdb
[0], id
, lun
, n
);
659 /* Transfer direction must be set before preprocessing the
662 req
->writing
= (n
< 1);
664 /* Preprocess RDMA descriptors */
665 vscsi_preprocess_desc(req
);
668 /* Get transfer direction and initiate transfer */
671 sdev
->info
->read_data(req
->sreq
);
674 sdev
->info
->write_data(req
->sreq
);
676 /* Don't touch req here, it may have been recycled already */
681 static int vscsi_process_tsk_mgmt(VSCSIState
*s
, vscsi_req
*req
)
683 union viosrp_iu
*iu
= &req
->iu
;
686 fprintf(stderr
, "vscsi_process_tsk_mgmt %02x\n",
687 iu
->srp
.tsk_mgmt
.tsk_mgmt_func
);
689 switch (iu
->srp
.tsk_mgmt
.tsk_mgmt_func
) {
690 #if 0 /* We really don't deal with these for now */
691 case SRP_TSK_ABORT_TASK
:
694 case SRP_TSK_ABORT_TASK_SET
:
697 case SRP_TSK_CLEAR_TASK_SET
:
700 case SRP_TSK_LUN_RESET
:
701 fn
= LOGICAL_UNIT_RESET
;
703 case SRP_TSK_CLEAR_ACA
:
711 /* XXX Send/Handle target task management */
714 vscsi_makeup_sense(s
, req
, ILLEGAL_REQUEST
, 0x20, 0);
715 vscsi_send_rsp(s
, req
, CHECK_CONDITION
, 0, 0);
720 static int vscsi_handle_srp_req(VSCSIState
*s
, vscsi_req
*req
)
722 union srp_iu
*srp
= &req
->iu
.srp
;
724 uint8_t opcode
= srp
->rsp
.opcode
;
728 vscsi_process_login(s
, req
);
731 done
= vscsi_process_tsk_mgmt(s
, req
);
734 done
= vscsi_queue_cmd(s
, req
);
744 fprintf(stderr
, "VSCSI: Unsupported opcode %02x\n", opcode
);
747 fprintf(stderr
, "VSCSI: Unknown type %02x\n", opcode
);
753 static int vscsi_send_adapter_info(VSCSIState
*s
, vscsi_req
*req
)
755 struct viosrp_adapter_info
*sinfo
;
756 struct mad_adapter_info_data info
;
759 sinfo
= &req
->iu
.mad
.adapter_info
;
761 #if 0 /* What for ? */
762 rc
= spapr_tce_dma_read(&s
->vdev
, be64_to_cpu(sinfo
->buffer
),
763 &info
, be16_to_cpu(sinfo
->common
.length
));
765 fprintf(stderr
, "vscsi_send_adapter_info: DMA read failure !\n");
768 memset(&info
, 0, sizeof(info
));
769 strcpy(info
.srp_version
, SRP_VERSION
);
770 strncpy(info
.partition_name
, "qemu", sizeof("qemu"));
771 info
.partition_number
= cpu_to_be32(0);
772 info
.mad_version
= cpu_to_be32(1);
773 info
.os_type
= cpu_to_be32(2);
774 info
.port_max_txu
[0] = cpu_to_be32(VSCSI_MAX_SECTORS
<< 9);
776 rc
= spapr_tce_dma_write(&s
->vdev
, be64_to_cpu(sinfo
->buffer
),
777 &info
, be16_to_cpu(sinfo
->common
.length
));
779 fprintf(stderr
, "vscsi_send_adapter_info: DMA write failure !\n");
782 sinfo
->common
.status
= rc
? cpu_to_be32(1) : 0;
784 return vscsi_send_iu(s
, req
, sizeof(*sinfo
), VIOSRP_MAD_FORMAT
);
787 static int vscsi_handle_mad_req(VSCSIState
*s
, vscsi_req
*req
)
789 union mad_iu
*mad
= &req
->iu
.mad
;
791 switch (be32_to_cpu(mad
->empty_iu
.common
.type
)) {
792 case VIOSRP_EMPTY_IU_TYPE
:
793 fprintf(stderr
, "Unsupported EMPTY MAD IU\n");
795 case VIOSRP_ERROR_LOG_TYPE
:
796 fprintf(stderr
, "Unsupported ERROR LOG MAD IU\n");
797 mad
->error_log
.common
.status
= cpu_to_be16(1);
798 vscsi_send_iu(s
, req
, sizeof(mad
->error_log
), VIOSRP_MAD_FORMAT
);
800 case VIOSRP_ADAPTER_INFO_TYPE
:
801 vscsi_send_adapter_info(s
, req
);
803 case VIOSRP_HOST_CONFIG_TYPE
:
804 mad
->host_config
.common
.status
= cpu_to_be16(1);
805 vscsi_send_iu(s
, req
, sizeof(mad
->host_config
), VIOSRP_MAD_FORMAT
);
808 fprintf(stderr
, "VSCSI: Unknown MAD type %02x\n",
809 be32_to_cpu(mad
->empty_iu
.common
.type
));
815 static void vscsi_got_payload(VSCSIState
*s
, vscsi_crq
*crq
)
820 req
= vscsi_get_req(s
);
822 fprintf(stderr
, "VSCSI: Failed to get a request !\n");
826 /* We only support a limited number of descriptors, we know
827 * the ibmvscsi driver uses up to 10 max, so it should fit
828 * in our 256 bytes IUs. If not we'll have to increase the size
831 if (crq
->s
.IU_length
> sizeof(union viosrp_iu
)) {
832 fprintf(stderr
, "VSCSI: SRP IU too long (%d bytes) !\n",
837 /* XXX Handle failure differently ? */
838 if (spapr_tce_dma_read(&s
->vdev
, crq
->s
.IU_data_ptr
, &req
->iu
,
840 fprintf(stderr
, "vscsi_got_payload: DMA read failure !\n");
843 memcpy(&req
->crq
, crq
, sizeof(vscsi_crq
));
845 if (crq
->s
.format
== VIOSRP_MAD_FORMAT
) {
846 done
= vscsi_handle_mad_req(s
, req
);
848 done
= vscsi_handle_srp_req(s
, req
);
852 vscsi_put_req(s
, req
);
857 static int vscsi_do_crq(struct VIOsPAPRDevice
*dev
, uint8_t *crq_data
)
859 VSCSIState
*s
= DO_UPCAST(VSCSIState
, vdev
, dev
);
862 memcpy(crq
.raw
, crq_data
, 16);
863 crq
.s
.timeout
= be16_to_cpu(crq
.s
.timeout
);
864 crq
.s
.IU_length
= be16_to_cpu(crq
.s
.IU_length
);
865 crq
.s
.IU_data_ptr
= be64_to_cpu(crq
.s
.IU_data_ptr
);
867 dprintf("VSCSI: do_crq %02x %02x ...\n", crq
.raw
[0], crq
.raw
[1]);
869 switch (crq
.s
.valid
) {
870 case 0xc0: /* Init command/response */
872 /* Respond to initialization request */
873 if (crq
.s
.format
== 0x01) {
874 memset(crq
.raw
, 0, 16);
877 spapr_vio_send_crq(dev
, crq
.raw
);
880 /* Note that in hotplug cases, we might get a 0x02
881 * as a result of us emitting the init request
885 case 0xff: /* Link event */
887 /* Not handled for now */
890 case 0x80: /* Payloads */
891 switch (crq
.s
.format
) {
892 case VIOSRP_SRP_FORMAT
: /* AKA VSCSI request */
893 case VIOSRP_MAD_FORMAT
: /* AKA VSCSI response */
894 vscsi_got_payload(s
, &crq
);
896 case VIOSRP_OS400_FORMAT
:
897 case VIOSRP_AIX_FORMAT
:
898 case VIOSRP_LINUX_FORMAT
:
899 case VIOSRP_INLINE_FORMAT
:
900 fprintf(stderr
, "vscsi_do_srq: Unsupported payload format %02x\n",
904 fprintf(stderr
, "vscsi_do_srq: Unknown payload format %02x\n",
909 fprintf(stderr
, "vscsi_do_crq: unknown CRQ %02x %02x ...\n",
910 crq
.raw
[0], crq
.raw
[1]);
916 static const struct SCSIBusOps vscsi_scsi_ops
= {
917 .complete
= vscsi_command_complete
920 static int spapr_vscsi_init(VIOsPAPRDevice
*dev
)
922 VSCSIState
*s
= DO_UPCAST(VSCSIState
, vdev
, dev
);
927 /* Initialize qemu request tags */
928 memset(s
->reqs
, 0, sizeof(s
->reqs
));
929 for (i
= 0; i
< VSCSI_REQ_LIMIT
; i
++) {
933 dev
->crq
.SendFunc
= vscsi_do_crq
;
935 scsi_bus_new(&s
->bus
, &dev
->qdev
, 1, VSCSI_REQ_LIMIT
,
937 if (!dev
->qdev
.hotplugged
) {
938 scsi_bus_legacy_handle_cmdline(&s
->bus
);
944 void spapr_vscsi_create(VIOsPAPRBus
*bus
, uint32_t reg
,
945 qemu_irq qirq
, uint32_t vio_irq_num
)
948 VIOsPAPRDevice
*sdev
;
950 dev
= qdev_create(&bus
->bus
, "spapr-vscsi");
951 qdev_prop_set_uint32(dev
, "reg", reg
);
953 qdev_init_nofail(dev
);
955 sdev
= (VIOsPAPRDevice
*)dev
;
957 sdev
->vio_irq_num
= vio_irq_num
;
960 static int spapr_vscsi_devnode(VIOsPAPRDevice
*dev
, void *fdt
, int node_off
)
964 ret
= fdt_setprop_cell(fdt
, node_off
, "#address-cells", 2);
969 ret
= fdt_setprop_cell(fdt
, node_off
, "#size-cells", 0);
977 static VIOsPAPRDeviceInfo spapr_vscsi
= {
978 .init
= spapr_vscsi_init
,
979 .devnode
= spapr_vscsi_devnode
,
982 .dt_compatible
= "IBM,v-scsi",
983 .signal_mask
= 0x00000001,
984 .qdev
.name
= "spapr-vscsi",
985 .qdev
.size
= sizeof(VSCSIState
),
986 .qdev
.props
= (Property
[]) {
987 DEFINE_PROP_UINT32("reg", VIOsPAPRDevice
, reg
, 0x2000),
988 DEFINE_PROP_UINT32("dma-window", VIOsPAPRDevice
,
989 rtce_window_size
, 0x10000000),
990 DEFINE_PROP_END_OF_LIST(),
994 static void spapr_vscsi_register(void)
996 spapr_vio_bus_register_withprop(&spapr_vscsi
);
998 device_init(spapr_vscsi_register
);