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 uint8_t *cdb
= req
->iu
.srp
.cmd
.cdb
;
461 n
= scsi_req_enqueue(req
->sreq
, cdb
);
462 dprintf("VSCSI: Queued request sense tag 0x%x\n", req
->qtag
);
464 fprintf(stderr
, "VSCSI: REQUEST_SENSE wants write data !?!?!?\n");
465 vscsi_makeup_sense(s
, req
, HARDWARE_ERROR
, 0, 0);
466 scsi_req_abort(req
->sreq
, CHECK_CONDITION
);
471 scsi_req_continue(req
->sreq
);
474 /* Callback to indicate that the SCSI layer has completed a transfer. */
475 static void vscsi_command_complete(SCSIRequest
*sreq
, int reason
, uint32_t arg
)
477 VSCSIState
*s
= DO_UPCAST(VSCSIState
, vdev
.qdev
, sreq
->bus
->qbus
.parent
);
478 vscsi_req
*req
= vscsi_find_req(s
, sreq
);
481 int32_t res_in
= 0, res_out
= 0;
484 dprintf("VSCSI: SCSI cmd complete, r=0x%x tag=0x%x arg=0x%x, req=%p\n",
485 reason
, sreq
->tag
, arg
, req
);
487 fprintf(stderr
, "VSCSI: Can't find request for tag 0x%x\n", sreq
->tag
);
493 if (reason
== SCSI_REASON_DONE
) {
494 dprintf("VSCSI: Sense done !\n");
495 vscsi_send_rsp(s
, req
, CHECK_CONDITION
, 0, 0);
496 vscsi_put_req(s
, req
);
498 uint8_t *buf
= sdev
->info
->get_buf(sreq
);
500 len
= MIN(arg
, SCSI_SENSE_BUF_SIZE
);
501 dprintf("VSCSI: Sense data, %d bytes:\n", len
);
502 dprintf(" %02x %02x %02x %02x %02x %02x %02x %02x\n",
503 buf
[0], buf
[1], buf
[2], buf
[3],
504 buf
[4], buf
[5], buf
[6], buf
[7]);
505 dprintf(" %02x %02x %02x %02x %02x %02x %02x %02x\n",
506 buf
[8], buf
[9], buf
[10], buf
[11],
507 buf
[12], buf
[13], buf
[14], buf
[15]);
508 memcpy(req
->sense
, buf
, len
);
510 scsi_req_continue(req
->sreq
);
515 if (reason
== SCSI_REASON_DONE
) {
516 dprintf("VSCSI: Command complete err=%d\n", arg
);
518 /* We handle overflows, not underflows for normal commands,
519 * but hopefully nobody cares
522 res_out
= req
->data_len
;
524 res_in
= req
->data_len
;
526 vscsi_send_rsp(s
, req
, 0, res_in
, res_out
);
527 } else if (arg
== CHECK_CONDITION
) {
528 dprintf("VSCSI: Got CHECK_CONDITION, requesting sense...\n");
529 vscsi_send_request_sense(s
, req
);
532 vscsi_send_rsp(s
, req
, arg
, 0, 0);
534 vscsi_put_req(s
, req
);
538 /* "arg" is how much we have read for reads and how much we want
539 * to write for writes (ie, how much is to be DMA'd)
542 buf
= sdev
->info
->get_buf(sreq
);
543 rc
= vscsi_srp_transfer_data(s
, req
, req
->writing
, buf
, arg
);
546 fprintf(stderr
, "VSCSI: RDMA error rc=%d!\n", rc
);
547 vscsi_makeup_sense(s
, req
, HARDWARE_ERROR
, 0, 0);
548 scsi_req_abort(req
->sreq
, CHECK_CONDITION
);
552 /* Start next chunk */
554 scsi_req_continue(sreq
);
557 static void vscsi_request_cancelled(SCSIRequest
*sreq
)
559 VSCSIState
*s
= DO_UPCAST(VSCSIState
, vdev
.qdev
, sreq
->bus
->qbus
.parent
);
560 vscsi_req
*req
= vscsi_find_req(s
, sreq
);
562 vscsi_put_req(s
, req
);
565 static void vscsi_process_login(VSCSIState
*s
, vscsi_req
*req
)
567 union viosrp_iu
*iu
= &req
->iu
;
568 struct srp_login_rsp
*rsp
= &iu
->srp
.login_rsp
;
569 uint64_t tag
= iu
->srp
.rsp
.tag
;
571 dprintf("VSCSI: Got login, sendin response !\n");
573 /* TODO handle case that requested size is wrong and
574 * buffer format is wrong
576 memset(iu
, 0, sizeof(struct srp_login_rsp
));
577 rsp
->opcode
= SRP_LOGIN_RSP
;
578 /* Don't advertise quite as many request as we support to
579 * keep room for management stuff etc...
581 rsp
->req_lim_delta
= cpu_to_be32(VSCSI_REQ_LIMIT
-2);
583 rsp
->max_it_iu_len
= cpu_to_be32(sizeof(union srp_iu
));
584 rsp
->max_ti_iu_len
= cpu_to_be32(sizeof(union srp_iu
));
585 /* direct and indirect */
586 rsp
->buf_fmt
= cpu_to_be16(SRP_BUF_FORMAT_DIRECT
| SRP_BUF_FORMAT_INDIRECT
);
588 vscsi_send_iu(s
, req
, sizeof(*rsp
), VIOSRP_SRP_FORMAT
);
591 static void vscsi_inquiry_no_target(VSCSIState
*s
, vscsi_req
*req
)
593 uint8_t *cdb
= req
->iu
.srp
.cmd
.cdb
;
594 uint8_t resp_data
[36];
597 /* We dont do EVPD. Also check that page_code is 0 */
598 if ((cdb
[1] & 0x01) || (cdb
[1] & 0x01) || cdb
[2] != 0) {
599 /* Send INVALID FIELD IN CDB */
600 vscsi_makeup_sense(s
, req
, ILLEGAL_REQUEST
, 0x24, 0);
601 vscsi_send_rsp(s
, req
, CHECK_CONDITION
, 0, 0);
605 alen
= (alen
<< 8) | cdb
[4];
608 /* Fake up inquiry using PQ=3 */
609 memset(resp_data
, 0, 36);
610 resp_data
[0] = 0x7f; /* Not capable of supporting a device here */
611 resp_data
[2] = 0x06; /* SPS-4 */
612 resp_data
[3] = 0x02; /* Resp data format */
613 resp_data
[4] = 36 - 5; /* Additional length */
614 resp_data
[7] = 0x10; /* Sync transfers */
615 memcpy(&resp_data
[16], "QEMU EMPTY ", 16);
616 memcpy(&resp_data
[8], "QEMU ", 8);
619 vscsi_preprocess_desc(req
);
620 rc
= vscsi_srp_transfer_data(s
, req
, 0, resp_data
, len
);
622 vscsi_makeup_sense(s
, req
, HARDWARE_ERROR
, 0, 0);
623 vscsi_send_rsp(s
, req
, CHECK_CONDITION
, 0, 0);
625 vscsi_send_rsp(s
, req
, 0, 36 - rc
, 0);
629 static int vscsi_queue_cmd(VSCSIState
*s
, vscsi_req
*req
)
631 union srp_iu
*srp
= &req
->iu
.srp
;
635 vscsi_decode_id_lun(be64_to_cpu(srp
->cmd
.lun
), &id
, &lun
);
637 /* Qemu vs. linux issue with LUNs to be sorted out ... */
638 sdev
= (id
< 8 && lun
< 16) ? s
->bus
.devs
[id
] : NULL
;
640 dprintf("VSCSI: Command for id %d with no drive\n", id
);
641 if (srp
->cmd
.cdb
[0] == INQUIRY
) {
642 vscsi_inquiry_no_target(s
, req
);
644 vscsi_makeup_sense(s
, req
, ILLEGAL_REQUEST
, 0x24, 0x00);
645 vscsi_send_rsp(s
, req
, CHECK_CONDITION
, 0, 0);
651 req
->sreq
= scsi_req_new(sdev
, req
->qtag
, lun
);
652 n
= scsi_req_enqueue(req
->sreq
, srp
->cmd
.cdb
);
654 dprintf("VSCSI: Queued command tag 0x%x CMD 0x%x ID %d LUN %d ret: %d\n",
655 req
->qtag
, srp
->cmd
.cdb
[0], id
, lun
, n
);
658 /* Transfer direction must be set before preprocessing the
661 req
->writing
= (n
< 1);
663 /* Preprocess RDMA descriptors */
664 vscsi_preprocess_desc(req
);
666 /* Get transfer direction and initiate transfer */
672 scsi_req_continue(req
->sreq
);
674 /* Don't touch req here, it may have been recycled already */
679 static int vscsi_process_tsk_mgmt(VSCSIState
*s
, vscsi_req
*req
)
681 union viosrp_iu
*iu
= &req
->iu
;
684 fprintf(stderr
, "vscsi_process_tsk_mgmt %02x\n",
685 iu
->srp
.tsk_mgmt
.tsk_mgmt_func
);
687 switch (iu
->srp
.tsk_mgmt
.tsk_mgmt_func
) {
688 #if 0 /* We really don't deal with these for now */
689 case SRP_TSK_ABORT_TASK
:
692 case SRP_TSK_ABORT_TASK_SET
:
695 case SRP_TSK_CLEAR_TASK_SET
:
698 case SRP_TSK_LUN_RESET
:
699 fn
= LOGICAL_UNIT_RESET
;
701 case SRP_TSK_CLEAR_ACA
:
709 /* XXX Send/Handle target task management */
712 vscsi_makeup_sense(s
, req
, ILLEGAL_REQUEST
, 0x20, 0);
713 vscsi_send_rsp(s
, req
, CHECK_CONDITION
, 0, 0);
718 static int vscsi_handle_srp_req(VSCSIState
*s
, vscsi_req
*req
)
720 union srp_iu
*srp
= &req
->iu
.srp
;
722 uint8_t opcode
= srp
->rsp
.opcode
;
726 vscsi_process_login(s
, req
);
729 done
= vscsi_process_tsk_mgmt(s
, req
);
732 done
= vscsi_queue_cmd(s
, req
);
742 fprintf(stderr
, "VSCSI: Unsupported opcode %02x\n", opcode
);
745 fprintf(stderr
, "VSCSI: Unknown type %02x\n", opcode
);
751 static int vscsi_send_adapter_info(VSCSIState
*s
, vscsi_req
*req
)
753 struct viosrp_adapter_info
*sinfo
;
754 struct mad_adapter_info_data info
;
757 sinfo
= &req
->iu
.mad
.adapter_info
;
759 #if 0 /* What for ? */
760 rc
= spapr_tce_dma_read(&s
->vdev
, be64_to_cpu(sinfo
->buffer
),
761 &info
, be16_to_cpu(sinfo
->common
.length
));
763 fprintf(stderr
, "vscsi_send_adapter_info: DMA read failure !\n");
766 memset(&info
, 0, sizeof(info
));
767 strcpy(info
.srp_version
, SRP_VERSION
);
768 strncpy(info
.partition_name
, "qemu", sizeof("qemu"));
769 info
.partition_number
= cpu_to_be32(0);
770 info
.mad_version
= cpu_to_be32(1);
771 info
.os_type
= cpu_to_be32(2);
772 info
.port_max_txu
[0] = cpu_to_be32(VSCSI_MAX_SECTORS
<< 9);
774 rc
= spapr_tce_dma_write(&s
->vdev
, be64_to_cpu(sinfo
->buffer
),
775 &info
, be16_to_cpu(sinfo
->common
.length
));
777 fprintf(stderr
, "vscsi_send_adapter_info: DMA write failure !\n");
780 sinfo
->common
.status
= rc
? cpu_to_be32(1) : 0;
782 return vscsi_send_iu(s
, req
, sizeof(*sinfo
), VIOSRP_MAD_FORMAT
);
785 static int vscsi_handle_mad_req(VSCSIState
*s
, vscsi_req
*req
)
787 union mad_iu
*mad
= &req
->iu
.mad
;
789 switch (be32_to_cpu(mad
->empty_iu
.common
.type
)) {
790 case VIOSRP_EMPTY_IU_TYPE
:
791 fprintf(stderr
, "Unsupported EMPTY MAD IU\n");
793 case VIOSRP_ERROR_LOG_TYPE
:
794 fprintf(stderr
, "Unsupported ERROR LOG MAD IU\n");
795 mad
->error_log
.common
.status
= cpu_to_be16(1);
796 vscsi_send_iu(s
, req
, sizeof(mad
->error_log
), VIOSRP_MAD_FORMAT
);
798 case VIOSRP_ADAPTER_INFO_TYPE
:
799 vscsi_send_adapter_info(s
, req
);
801 case VIOSRP_HOST_CONFIG_TYPE
:
802 mad
->host_config
.common
.status
= cpu_to_be16(1);
803 vscsi_send_iu(s
, req
, sizeof(mad
->host_config
), VIOSRP_MAD_FORMAT
);
806 fprintf(stderr
, "VSCSI: Unknown MAD type %02x\n",
807 be32_to_cpu(mad
->empty_iu
.common
.type
));
813 static void vscsi_got_payload(VSCSIState
*s
, vscsi_crq
*crq
)
818 req
= vscsi_get_req(s
);
820 fprintf(stderr
, "VSCSI: Failed to get a request !\n");
824 /* We only support a limited number of descriptors, we know
825 * the ibmvscsi driver uses up to 10 max, so it should fit
826 * in our 256 bytes IUs. If not we'll have to increase the size
829 if (crq
->s
.IU_length
> sizeof(union viosrp_iu
)) {
830 fprintf(stderr
, "VSCSI: SRP IU too long (%d bytes) !\n",
835 /* XXX Handle failure differently ? */
836 if (spapr_tce_dma_read(&s
->vdev
, crq
->s
.IU_data_ptr
, &req
->iu
,
838 fprintf(stderr
, "vscsi_got_payload: DMA read failure !\n");
841 memcpy(&req
->crq
, crq
, sizeof(vscsi_crq
));
843 if (crq
->s
.format
== VIOSRP_MAD_FORMAT
) {
844 done
= vscsi_handle_mad_req(s
, req
);
846 done
= vscsi_handle_srp_req(s
, req
);
850 vscsi_put_req(s
, req
);
855 static int vscsi_do_crq(struct VIOsPAPRDevice
*dev
, uint8_t *crq_data
)
857 VSCSIState
*s
= DO_UPCAST(VSCSIState
, vdev
, dev
);
860 memcpy(crq
.raw
, crq_data
, 16);
861 crq
.s
.timeout
= be16_to_cpu(crq
.s
.timeout
);
862 crq
.s
.IU_length
= be16_to_cpu(crq
.s
.IU_length
);
863 crq
.s
.IU_data_ptr
= be64_to_cpu(crq
.s
.IU_data_ptr
);
865 dprintf("VSCSI: do_crq %02x %02x ...\n", crq
.raw
[0], crq
.raw
[1]);
867 switch (crq
.s
.valid
) {
868 case 0xc0: /* Init command/response */
870 /* Respond to initialization request */
871 if (crq
.s
.format
== 0x01) {
872 memset(crq
.raw
, 0, 16);
875 spapr_vio_send_crq(dev
, crq
.raw
);
878 /* Note that in hotplug cases, we might get a 0x02
879 * as a result of us emitting the init request
883 case 0xff: /* Link event */
885 /* Not handled for now */
888 case 0x80: /* Payloads */
889 switch (crq
.s
.format
) {
890 case VIOSRP_SRP_FORMAT
: /* AKA VSCSI request */
891 case VIOSRP_MAD_FORMAT
: /* AKA VSCSI response */
892 vscsi_got_payload(s
, &crq
);
894 case VIOSRP_OS400_FORMAT
:
895 case VIOSRP_AIX_FORMAT
:
896 case VIOSRP_LINUX_FORMAT
:
897 case VIOSRP_INLINE_FORMAT
:
898 fprintf(stderr
, "vscsi_do_srq: Unsupported payload format %02x\n",
902 fprintf(stderr
, "vscsi_do_srq: Unknown payload format %02x\n",
907 fprintf(stderr
, "vscsi_do_crq: unknown CRQ %02x %02x ...\n",
908 crq
.raw
[0], crq
.raw
[1]);
914 static const struct SCSIBusOps vscsi_scsi_ops
= {
915 .complete
= vscsi_command_complete
,
916 .cancel
= vscsi_request_cancelled
919 static int spapr_vscsi_init(VIOsPAPRDevice
*dev
)
921 VSCSIState
*s
= DO_UPCAST(VSCSIState
, vdev
, dev
);
926 /* Initialize qemu request tags */
927 memset(s
->reqs
, 0, sizeof(s
->reqs
));
928 for (i
= 0; i
< VSCSI_REQ_LIMIT
; i
++) {
932 dev
->crq
.SendFunc
= vscsi_do_crq
;
934 scsi_bus_new(&s
->bus
, &dev
->qdev
, 1, VSCSI_REQ_LIMIT
,
936 if (!dev
->qdev
.hotplugged
) {
937 scsi_bus_legacy_handle_cmdline(&s
->bus
);
943 void spapr_vscsi_create(VIOsPAPRBus
*bus
, uint32_t reg
,
944 qemu_irq qirq
, uint32_t vio_irq_num
)
947 VIOsPAPRDevice
*sdev
;
949 dev
= qdev_create(&bus
->bus
, "spapr-vscsi");
950 qdev_prop_set_uint32(dev
, "reg", reg
);
952 qdev_init_nofail(dev
);
954 sdev
= (VIOsPAPRDevice
*)dev
;
956 sdev
->vio_irq_num
= vio_irq_num
;
959 static int spapr_vscsi_devnode(VIOsPAPRDevice
*dev
, void *fdt
, int node_off
)
963 ret
= fdt_setprop_cell(fdt
, node_off
, "#address-cells", 2);
968 ret
= fdt_setprop_cell(fdt
, node_off
, "#size-cells", 0);
976 static VIOsPAPRDeviceInfo spapr_vscsi
= {
977 .init
= spapr_vscsi_init
,
978 .devnode
= spapr_vscsi_devnode
,
981 .dt_compatible
= "IBM,v-scsi",
982 .signal_mask
= 0x00000001,
983 .qdev
.name
= "spapr-vscsi",
984 .qdev
.size
= sizeof(VSCSIState
),
985 .qdev
.props
= (Property
[]) {
986 DEFINE_PROP_UINT32("reg", VIOsPAPRDevice
, reg
, 0x2000),
987 DEFINE_PROP_UINT32("dma-window", VIOsPAPRDevice
,
988 rtce_window_size
, 0x10000000),
989 DEFINE_PROP_END_OF_LIST(),
993 static void spapr_vscsi_register(void)
995 spapr_vio_bus_register_withprop(&spapr_vscsi
);
997 device_init(spapr_vscsi_register
);