2 * QEMU MegaRAID SAS 8708EM2 Host Bus Adapter emulation
3 * Based on the linux driver code at drivers/scsi/megaraid
5 * Copyright (c) 2009-2012 Hannes Reinecke, SUSE Labs
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
21 #include "qemu/osdep.h"
23 #include "hw/pci/pci.h"
24 #include "sysemu/dma.h"
25 #include "sysemu/block-backend.h"
26 #include "hw/pci/msi.h"
27 #include "hw/pci/msix.h"
29 #include "hw/scsi/scsi.h"
30 #include "block/scsi.h"
32 #include "qapi/error.h"
35 #define MEGASAS_VERSION_GEN1 "1.70"
36 #define MEGASAS_VERSION_GEN2 "1.80"
37 #define MEGASAS_MAX_FRAMES 2048 /* Firmware limit at 65535 */
38 #define MEGASAS_DEFAULT_FRAMES 1000 /* Windows requires this */
39 #define MEGASAS_GEN2_DEFAULT_FRAMES 1008 /* Windows requires this */
40 #define MEGASAS_MAX_SGE 128 /* Firmware limit */
41 #define MEGASAS_DEFAULT_SGE 80
42 #define MEGASAS_MAX_SECTORS 0xFFFF /* No real limit */
43 #define MEGASAS_MAX_ARRAYS 128
45 #define MEGASAS_HBA_SERIAL "QEMU123456"
46 #define NAA_LOCALLY_ASSIGNED_ID 0x3ULL
47 #define IEEE_COMPANY_LOCALLY_ASSIGNED 0x525400
49 #define MEGASAS_FLAG_USE_JBOD 0
50 #define MEGASAS_MASK_USE_JBOD (1 << MEGASAS_FLAG_USE_JBOD)
51 #define MEGASAS_FLAG_USE_QUEUE64 1
52 #define MEGASAS_MASK_USE_QUEUE64 (1 << MEGASAS_FLAG_USE_QUEUE64)
54 static const char *mfi_frame_desc
[] = {
55 "MFI init", "LD Read", "LD Write", "LD SCSI", "PD SCSI",
56 "MFI Doorbell", "MFI Abort", "MFI SMP", "MFI Stop"};
58 typedef struct MegasasCmd
{
67 union mfi_frame
*frame
;
73 struct MegasasState
*state
;
76 typedef struct MegasasState
{
83 MemoryRegion queue_io
;
99 MegasasCmd
*event_cmd
;
109 uint64_t reply_queue_pa
;
112 int reply_queue_head
;
113 int reply_queue_tail
;
114 uint64_t consumer_pa
;
115 uint64_t producer_pa
;
117 MegasasCmd frames
[MEGASAS_MAX_FRAMES
];
118 DECLARE_BITMAP(frame_map
, MEGASAS_MAX_FRAMES
);
122 typedef struct MegasasBaseClass
{
123 PCIDeviceClass parent_class
;
124 const char *product_name
;
125 const char *product_version
;
131 #define TYPE_MEGASAS_BASE "megasas-base"
132 #define TYPE_MEGASAS_GEN1 "megasas"
133 #define TYPE_MEGASAS_GEN2 "megasas-gen2"
135 #define MEGASAS(obj) \
136 OBJECT_CHECK(MegasasState, (obj), TYPE_MEGASAS_BASE)
138 #define MEGASAS_DEVICE_CLASS(oc) \
139 OBJECT_CLASS_CHECK(MegasasBaseClass, (oc), TYPE_MEGASAS_BASE)
140 #define MEGASAS_DEVICE_GET_CLASS(oc) \
141 OBJECT_GET_CLASS(MegasasBaseClass, (oc), TYPE_MEGASAS_BASE)
143 #define MEGASAS_INTR_DISABLED_MASK 0xFFFFFFFF
145 static bool megasas_intr_enabled(MegasasState
*s
)
147 if ((s
->intr_mask
& MEGASAS_INTR_DISABLED_MASK
) !=
148 MEGASAS_INTR_DISABLED_MASK
) {
154 static bool megasas_use_queue64(MegasasState
*s
)
156 return s
->flags
& MEGASAS_MASK_USE_QUEUE64
;
159 static bool megasas_use_msix(MegasasState
*s
)
161 return s
->msix
!= ON_OFF_AUTO_OFF
;
164 static bool megasas_is_jbod(MegasasState
*s
)
166 return s
->flags
& MEGASAS_MASK_USE_JBOD
;
169 static void megasas_frame_set_cmd_status(MegasasState
*s
,
170 unsigned long frame
, uint8_t v
)
172 PCIDevice
*pci
= &s
->parent_obj
;
173 stb_pci_dma(pci
, frame
+ offsetof(struct mfi_frame_header
, cmd_status
), v
);
176 static void megasas_frame_set_scsi_status(MegasasState
*s
,
177 unsigned long frame
, uint8_t v
)
179 PCIDevice
*pci
= &s
->parent_obj
;
180 stb_pci_dma(pci
, frame
+ offsetof(struct mfi_frame_header
, scsi_status
), v
);
184 * Context is considered opaque, but the HBA firmware is running
185 * in little endian mode. So convert it to little endian, too.
187 static uint64_t megasas_frame_get_context(MegasasState
*s
,
190 PCIDevice
*pci
= &s
->parent_obj
;
191 return ldq_le_pci_dma(pci
, frame
+ offsetof(struct mfi_frame_header
, context
));
194 static bool megasas_frame_is_ieee_sgl(MegasasCmd
*cmd
)
196 return cmd
->flags
& MFI_FRAME_IEEE_SGL
;
199 static bool megasas_frame_is_sgl64(MegasasCmd
*cmd
)
201 return cmd
->flags
& MFI_FRAME_SGL64
;
204 static bool megasas_frame_is_sense64(MegasasCmd
*cmd
)
206 return cmd
->flags
& MFI_FRAME_SENSE64
;
209 static uint64_t megasas_sgl_get_addr(MegasasCmd
*cmd
,
214 if (megasas_frame_is_ieee_sgl(cmd
)) {
215 addr
= le64_to_cpu(sgl
->sg_skinny
->addr
);
216 } else if (megasas_frame_is_sgl64(cmd
)) {
217 addr
= le64_to_cpu(sgl
->sg64
->addr
);
219 addr
= le32_to_cpu(sgl
->sg32
->addr
);
224 static uint32_t megasas_sgl_get_len(MegasasCmd
*cmd
,
229 if (megasas_frame_is_ieee_sgl(cmd
)) {
230 len
= le32_to_cpu(sgl
->sg_skinny
->len
);
231 } else if (megasas_frame_is_sgl64(cmd
)) {
232 len
= le32_to_cpu(sgl
->sg64
->len
);
234 len
= le32_to_cpu(sgl
->sg32
->len
);
239 static union mfi_sgl
*megasas_sgl_next(MegasasCmd
*cmd
,
242 uint8_t *next
= (uint8_t *)sgl
;
244 if (megasas_frame_is_ieee_sgl(cmd
)) {
245 next
+= sizeof(struct mfi_sg_skinny
);
246 } else if (megasas_frame_is_sgl64(cmd
)) {
247 next
+= sizeof(struct mfi_sg64
);
249 next
+= sizeof(struct mfi_sg32
);
252 if (next
>= (uint8_t *)cmd
->frame
+ cmd
->pa_size
) {
255 return (union mfi_sgl
*)next
;
258 static void megasas_soft_reset(MegasasState
*s
);
260 static int megasas_map_sgl(MegasasState
*s
, MegasasCmd
*cmd
, union mfi_sgl
*sgl
)
266 cmd
->flags
= le16_to_cpu(cmd
->frame
->header
.flags
);
267 iov_count
= cmd
->frame
->header
.sge_count
;
268 if (iov_count
> MEGASAS_MAX_SGE
) {
269 trace_megasas_iovec_sgl_overflow(cmd
->index
, iov_count
,
273 pci_dma_sglist_init(&cmd
->qsg
, PCI_DEVICE(s
), iov_count
);
274 for (i
= 0; i
< iov_count
; i
++) {
275 dma_addr_t iov_pa
, iov_size_p
;
278 trace_megasas_iovec_sgl_underflow(cmd
->index
, i
);
281 iov_pa
= megasas_sgl_get_addr(cmd
, sgl
);
282 iov_size_p
= megasas_sgl_get_len(cmd
, sgl
);
283 if (!iov_pa
|| !iov_size_p
) {
284 trace_megasas_iovec_sgl_invalid(cmd
->index
, i
,
288 qemu_sglist_add(&cmd
->qsg
, iov_pa
, iov_size_p
);
289 sgl
= megasas_sgl_next(cmd
, sgl
);
290 iov_size
+= (size_t)iov_size_p
;
292 if (cmd
->iov_size
> iov_size
) {
293 trace_megasas_iovec_overflow(cmd
->index
, iov_size
, cmd
->iov_size
);
294 } else if (cmd
->iov_size
< iov_size
) {
295 trace_megasas_iovec_underflow(cmd
->index
, iov_size
, cmd
->iov_size
);
300 qemu_sglist_destroy(&cmd
->qsg
);
301 return iov_count
- i
;
305 * passthrough sense and io sense are at the same offset
307 static int megasas_build_sense(MegasasCmd
*cmd
, uint8_t *sense_ptr
,
310 PCIDevice
*pcid
= PCI_DEVICE(cmd
->state
);
311 uint32_t pa_hi
= 0, pa_lo
;
315 frame_sense_len
= cmd
->frame
->header
.sense_len
;
316 if (sense_len
> frame_sense_len
) {
317 sense_len
= frame_sense_len
;
320 pa_lo
= le32_to_cpu(cmd
->frame
->pass
.sense_addr_lo
);
321 if (megasas_frame_is_sense64(cmd
)) {
322 pa_hi
= le32_to_cpu(cmd
->frame
->pass
.sense_addr_hi
);
324 pa
= ((uint64_t) pa_hi
<< 32) | pa_lo
;
325 pci_dma_write(pcid
, pa
, sense_ptr
, sense_len
);
326 cmd
->frame
->header
.sense_len
= sense_len
;
331 static void megasas_write_sense(MegasasCmd
*cmd
, SCSISense sense
)
333 uint8_t sense_buf
[SCSI_SENSE_BUF_SIZE
];
334 uint8_t sense_len
= 18;
336 memset(sense_buf
, 0, sense_len
);
338 sense_buf
[2] = sense
.key
;
340 sense_buf
[12] = sense
.asc
;
341 sense_buf
[13] = sense
.ascq
;
342 megasas_build_sense(cmd
, sense_buf
, sense_len
);
345 static void megasas_copy_sense(MegasasCmd
*cmd
)
347 uint8_t sense_buf
[SCSI_SENSE_BUF_SIZE
];
350 sense_len
= scsi_req_get_sense(cmd
->req
, sense_buf
,
351 SCSI_SENSE_BUF_SIZE
);
352 megasas_build_sense(cmd
, sense_buf
, sense_len
);
356 * Format an INQUIRY CDB
358 static int megasas_setup_inquiry(uint8_t *cdb
, int pg
, int len
)
366 cdb
[3] = (len
>> 8) & 0xff;
367 cdb
[4] = (len
& 0xff);
372 * Encode lba and len into a READ_16/WRITE_16 CDB
374 static void megasas_encode_lba(uint8_t *cdb
, uint64_t lba
,
375 uint32_t len
, bool is_write
)
377 memset(cdb
, 0x0, 16);
383 cdb
[2] = (lba
>> 56) & 0xff;
384 cdb
[3] = (lba
>> 48) & 0xff;
385 cdb
[4] = (lba
>> 40) & 0xff;
386 cdb
[5] = (lba
>> 32) & 0xff;
387 cdb
[6] = (lba
>> 24) & 0xff;
388 cdb
[7] = (lba
>> 16) & 0xff;
389 cdb
[8] = (lba
>> 8) & 0xff;
390 cdb
[9] = (lba
) & 0xff;
391 cdb
[10] = (len
>> 24) & 0xff;
392 cdb
[11] = (len
>> 16) & 0xff;
393 cdb
[12] = (len
>> 8) & 0xff;
394 cdb
[13] = (len
) & 0xff;
400 static uint64_t megasas_fw_time(void)
404 qemu_get_timedate(&curtime
, 0);
405 return ((uint64_t)curtime
.tm_sec
& 0xff) << 48 |
406 ((uint64_t)curtime
.tm_min
& 0xff) << 40 |
407 ((uint64_t)curtime
.tm_hour
& 0xff) << 32 |
408 ((uint64_t)curtime
.tm_mday
& 0xff) << 24 |
409 ((uint64_t)curtime
.tm_mon
& 0xff) << 16 |
410 ((uint64_t)(curtime
.tm_year
+ 1900) & 0xffff);
414 * Default disk sata address
415 * 0x1221 is the magic number as
416 * present in real hardware,
417 * so use it here, too.
419 static uint64_t megasas_get_sata_addr(uint16_t id
)
421 uint64_t addr
= (0x1221ULL
<< 48);
422 return addr
| ((uint64_t)id
<< 24);
428 static int megasas_next_index(MegasasState
*s
, int index
, int limit
)
431 if (index
== limit
) {
437 static MegasasCmd
*megasas_lookup_frame(MegasasState
*s
,
440 MegasasCmd
*cmd
= NULL
;
443 index
= s
->reply_queue_head
;
445 while (num
< s
->fw_cmds
) {
446 if (s
->frames
[index
].pa
&& s
->frames
[index
].pa
== frame
) {
447 cmd
= &s
->frames
[index
];
450 index
= megasas_next_index(s
, index
, s
->fw_cmds
);
457 static void megasas_unmap_frame(MegasasState
*s
, MegasasCmd
*cmd
)
459 PCIDevice
*p
= PCI_DEVICE(s
);
462 pci_dma_unmap(p
, cmd
->frame
, cmd
->pa_size
, 0, 0);
467 clear_bit(cmd
->index
, s
->frame_map
);
471 * This absolutely needs to be locked if
472 * qemu ever goes multithreaded.
474 static MegasasCmd
*megasas_enqueue_frame(MegasasState
*s
,
475 hwaddr frame
, uint64_t context
, int count
)
477 PCIDevice
*pcid
= PCI_DEVICE(s
);
478 MegasasCmd
*cmd
= NULL
;
479 int frame_size
= MFI_FRAME_SIZE
* 16;
480 hwaddr frame_size_p
= frame_size
;
484 while (index
< s
->fw_cmds
) {
485 index
= find_next_zero_bit(s
->frame_map
, s
->fw_cmds
, index
);
486 if (!s
->frames
[index
].pa
)
488 /* Busy frame found */
489 trace_megasas_qf_mapped(index
);
491 if (index
>= s
->fw_cmds
) {
492 /* All frames busy */
493 trace_megasas_qf_busy(frame
);
496 cmd
= &s
->frames
[index
];
497 set_bit(index
, s
->frame_map
);
498 trace_megasas_qf_new(index
, frame
);
501 /* Map all possible frames */
502 cmd
->frame
= pci_dma_map(pcid
, frame
, &frame_size_p
, 0);
503 if (frame_size_p
!= frame_size
) {
504 trace_megasas_qf_map_failed(cmd
->index
, (unsigned long)frame
);
506 megasas_unmap_frame(s
, cmd
);
511 cmd
->pa_size
= frame_size_p
;
512 cmd
->context
= context
;
513 if (!megasas_use_queue64(s
)) {
514 cmd
->context
&= (uint64_t)0xFFFFFFFF;
517 cmd
->dcmd_opcode
= -1;
520 if (s
->consumer_pa
) {
521 s
->reply_queue_tail
= ldl_le_pci_dma(pcid
, s
->consumer_pa
);
523 trace_megasas_qf_enqueue(cmd
->index
, cmd
->count
, cmd
->context
,
524 s
->reply_queue_head
, s
->reply_queue_tail
, s
->busy
);
529 static void megasas_complete_frame(MegasasState
*s
, uint64_t context
)
531 PCIDevice
*pci_dev
= PCI_DEVICE(s
);
532 int tail
, queue_offset
;
534 /* Decrement busy count */
536 if (s
->reply_queue_pa
) {
538 * Put command on the reply queue.
539 * Context is opaque, but emulation is running in
540 * little endian. So convert it.
542 if (megasas_use_queue64(s
)) {
543 queue_offset
= s
->reply_queue_head
* sizeof(uint64_t);
544 stq_le_pci_dma(pci_dev
, s
->reply_queue_pa
+ queue_offset
, context
);
546 queue_offset
= s
->reply_queue_head
* sizeof(uint32_t);
547 stl_le_pci_dma(pci_dev
, s
->reply_queue_pa
+ queue_offset
, context
);
549 s
->reply_queue_tail
= ldl_le_pci_dma(pci_dev
, s
->consumer_pa
);
550 trace_megasas_qf_complete(context
, s
->reply_queue_head
,
551 s
->reply_queue_tail
, s
->busy
);
554 if (megasas_intr_enabled(s
)) {
555 /* Update reply queue pointer */
556 s
->reply_queue_tail
= ldl_le_pci_dma(pci_dev
, s
->consumer_pa
);
557 tail
= s
->reply_queue_head
;
558 s
->reply_queue_head
= megasas_next_index(s
, tail
, s
->fw_cmds
);
559 trace_megasas_qf_update(s
->reply_queue_head
, s
->reply_queue_tail
,
561 stl_le_pci_dma(pci_dev
, s
->producer_pa
, s
->reply_queue_head
);
563 if (msix_enabled(pci_dev
)) {
564 trace_megasas_msix_raise(0);
565 msix_notify(pci_dev
, 0);
566 } else if (msi_enabled(pci_dev
)) {
567 trace_megasas_msi_raise(0);
568 msi_notify(pci_dev
, 0);
571 if (s
->doorbell
== 1) {
572 trace_megasas_irq_raise();
573 pci_irq_assert(pci_dev
);
577 trace_megasas_qf_complete_noirq(context
);
581 static void megasas_complete_command(MegasasCmd
*cmd
)
583 qemu_sglist_destroy(&cmd
->qsg
);
587 cmd
->req
->hba_private
= NULL
;
588 scsi_req_unref(cmd
->req
);
591 megasas_unmap_frame(cmd
->state
, cmd
);
592 megasas_complete_frame(cmd
->state
, cmd
->context
);
595 static void megasas_reset_frames(MegasasState
*s
)
600 for (i
= 0; i
< s
->fw_cmds
; i
++) {
603 megasas_unmap_frame(s
, cmd
);
606 bitmap_zero(s
->frame_map
, MEGASAS_MAX_FRAMES
);
609 static void megasas_abort_command(MegasasCmd
*cmd
)
611 /* Never abort internal commands. */
612 if (cmd
->req
!= NULL
) {
613 scsi_req_cancel(cmd
->req
);
617 static int megasas_init_firmware(MegasasState
*s
, MegasasCmd
*cmd
)
619 PCIDevice
*pcid
= PCI_DEVICE(s
);
620 uint32_t pa_hi
, pa_lo
;
621 hwaddr iq_pa
, initq_size
= sizeof(struct mfi_init_qinfo
);
622 struct mfi_init_qinfo
*initq
= NULL
;
624 int ret
= MFI_STAT_OK
;
626 if (s
->reply_queue_pa
) {
627 trace_megasas_initq_mapped(s
->reply_queue_pa
);
630 pa_lo
= le32_to_cpu(cmd
->frame
->init
.qinfo_new_addr_lo
);
631 pa_hi
= le32_to_cpu(cmd
->frame
->init
.qinfo_new_addr_hi
);
632 iq_pa
= (((uint64_t) pa_hi
<< 32) | pa_lo
);
633 trace_megasas_init_firmware((uint64_t)iq_pa
);
634 initq
= pci_dma_map(pcid
, iq_pa
, &initq_size
, 0);
635 if (!initq
|| initq_size
!= sizeof(*initq
)) {
636 trace_megasas_initq_map_failed(cmd
->index
);
638 ret
= MFI_STAT_MEMORY_NOT_AVAILABLE
;
641 s
->reply_queue_len
= le32_to_cpu(initq
->rq_entries
) & 0xFFFF;
642 if (s
->reply_queue_len
> s
->fw_cmds
) {
643 trace_megasas_initq_mismatch(s
->reply_queue_len
, s
->fw_cmds
);
645 ret
= MFI_STAT_INVALID_PARAMETER
;
648 pa_lo
= le32_to_cpu(initq
->rq_addr_lo
);
649 pa_hi
= le32_to_cpu(initq
->rq_addr_hi
);
650 s
->reply_queue_pa
= ((uint64_t) pa_hi
<< 32) | pa_lo
;
651 pa_lo
= le32_to_cpu(initq
->ci_addr_lo
);
652 pa_hi
= le32_to_cpu(initq
->ci_addr_hi
);
653 s
->consumer_pa
= ((uint64_t) pa_hi
<< 32) | pa_lo
;
654 pa_lo
= le32_to_cpu(initq
->pi_addr_lo
);
655 pa_hi
= le32_to_cpu(initq
->pi_addr_hi
);
656 s
->producer_pa
= ((uint64_t) pa_hi
<< 32) | pa_lo
;
657 s
->reply_queue_head
= ldl_le_pci_dma(pcid
, s
->producer_pa
);
658 s
->reply_queue_head
%= MEGASAS_MAX_FRAMES
;
659 s
->reply_queue_tail
= ldl_le_pci_dma(pcid
, s
->consumer_pa
);
660 s
->reply_queue_tail
%= MEGASAS_MAX_FRAMES
;
661 flags
= le32_to_cpu(initq
->flags
);
662 if (flags
& MFI_QUEUE_FLAG_CONTEXT64
) {
663 s
->flags
|= MEGASAS_MASK_USE_QUEUE64
;
665 trace_megasas_init_queue((unsigned long)s
->reply_queue_pa
,
666 s
->reply_queue_len
, s
->reply_queue_head
,
667 s
->reply_queue_tail
, flags
);
668 megasas_reset_frames(s
);
669 s
->fw_state
= MFI_FWSTATE_OPERATIONAL
;
672 pci_dma_unmap(pcid
, initq
, initq_size
, 0, 0);
677 static int megasas_map_dcmd(MegasasState
*s
, MegasasCmd
*cmd
)
679 dma_addr_t iov_pa
, iov_size
;
682 cmd
->flags
= le16_to_cpu(cmd
->frame
->header
.flags
);
683 iov_count
= cmd
->frame
->header
.sge_count
;
685 trace_megasas_dcmd_zero_sge(cmd
->index
);
688 } else if (iov_count
> 1) {
689 trace_megasas_dcmd_invalid_sge(cmd
->index
, iov_count
);
693 iov_pa
= megasas_sgl_get_addr(cmd
, &cmd
->frame
->dcmd
.sgl
);
694 iov_size
= megasas_sgl_get_len(cmd
, &cmd
->frame
->dcmd
.sgl
);
695 pci_dma_sglist_init(&cmd
->qsg
, PCI_DEVICE(s
), 1);
696 qemu_sglist_add(&cmd
->qsg
, iov_pa
, iov_size
);
697 cmd
->iov_size
= iov_size
;
701 static void megasas_finish_dcmd(MegasasCmd
*cmd
, uint32_t iov_size
)
703 trace_megasas_finish_dcmd(cmd
->index
, iov_size
);
705 if (iov_size
> cmd
->iov_size
) {
706 if (megasas_frame_is_ieee_sgl(cmd
)) {
707 cmd
->frame
->dcmd
.sgl
.sg_skinny
->len
= cpu_to_le32(iov_size
);
708 } else if (megasas_frame_is_sgl64(cmd
)) {
709 cmd
->frame
->dcmd
.sgl
.sg64
->len
= cpu_to_le32(iov_size
);
711 cmd
->frame
->dcmd
.sgl
.sg32
->len
= cpu_to_le32(iov_size
);
716 static int megasas_ctrl_get_info(MegasasState
*s
, MegasasCmd
*cmd
)
718 PCIDevice
*pci_dev
= PCI_DEVICE(s
);
719 PCIDeviceClass
*pci_class
= PCI_DEVICE_GET_CLASS(pci_dev
);
720 MegasasBaseClass
*base_class
= MEGASAS_DEVICE_GET_CLASS(s
);
721 struct mfi_ctrl_info info
;
722 size_t dcmd_size
= sizeof(info
);
724 int num_pd_disks
= 0;
726 memset(&info
, 0x0, dcmd_size
);
727 if (cmd
->iov_size
< dcmd_size
) {
728 trace_megasas_dcmd_invalid_xfer_len(cmd
->index
, cmd
->iov_size
,
730 return MFI_STAT_INVALID_PARAMETER
;
733 info
.pci
.vendor
= cpu_to_le16(pci_class
->vendor_id
);
734 info
.pci
.device
= cpu_to_le16(pci_class
->device_id
);
735 info
.pci
.subvendor
= cpu_to_le16(pci_class
->subsystem_vendor_id
);
736 info
.pci
.subdevice
= cpu_to_le16(pci_class
->subsystem_id
);
739 * For some reason the firmware supports
740 * only up to 8 device ports.
741 * Despite supporting a far larger number
742 * of devices for the physical devices.
743 * So just display the first 8 devices
744 * in the device port list, independent
745 * of how many logical devices are actually
748 info
.host
.type
= MFI_INFO_HOST_PCIE
;
749 info
.device
.type
= MFI_INFO_DEV_SAS3G
;
750 info
.device
.port_count
= 8;
751 QTAILQ_FOREACH(kid
, &s
->bus
.qbus
.children
, sibling
) {
752 SCSIDevice
*sdev
= SCSI_DEVICE(kid
->child
);
755 if (num_pd_disks
< 8) {
756 pd_id
= ((sdev
->id
& 0xFF) << 8) | (sdev
->lun
& 0xFF);
757 info
.device
.port_addr
[num_pd_disks
] =
758 cpu_to_le64(megasas_get_sata_addr(pd_id
));
763 memcpy(info
.product_name
, base_class
->product_name
, 24);
764 snprintf(info
.serial_number
, 32, "%s", s
->hba_serial
);
765 snprintf(info
.package_version
, 0x60, "%s-QEMU", qemu_hw_version());
766 memcpy(info
.image_component
[0].name
, "APP", 3);
767 snprintf(info
.image_component
[0].version
, 10, "%s-QEMU",
768 base_class
->product_version
);
769 memcpy(info
.image_component
[0].build_date
, "Apr 1 2014", 11);
770 memcpy(info
.image_component
[0].build_time
, "12:34:56", 8);
771 info
.image_component_count
= 1;
772 if (pci_dev
->has_rom
) {
776 ptr
= memory_region_get_ram_ptr(&pci_dev
->rom
);
777 memcpy(biosver
, ptr
+ 0x41, 31);
779 memcpy(info
.image_component
[1].name
, "BIOS", 4);
780 memcpy(info
.image_component
[1].version
, biosver
,
781 strlen((const char *)biosver
));
782 info
.image_component_count
++;
784 info
.current_fw_time
= cpu_to_le32(megasas_fw_time());
787 info
.max_arrays
= MEGASAS_MAX_ARRAYS
;
788 info
.max_lds
= MFI_MAX_LD
;
789 info
.max_cmds
= cpu_to_le16(s
->fw_cmds
);
790 info
.max_sg_elements
= cpu_to_le16(s
->fw_sge
);
791 info
.max_request_size
= cpu_to_le32(MEGASAS_MAX_SECTORS
);
792 if (!megasas_is_jbod(s
))
793 info
.lds_present
= cpu_to_le16(num_pd_disks
);
794 info
.pd_present
= cpu_to_le16(num_pd_disks
);
795 info
.pd_disks_present
= cpu_to_le16(num_pd_disks
);
796 info
.hw_present
= cpu_to_le32(MFI_INFO_HW_NVRAM
|
799 info
.memory_size
= cpu_to_le16(512);
800 info
.nvram_size
= cpu_to_le16(32);
801 info
.flash_size
= cpu_to_le16(16);
802 info
.raid_levels
= cpu_to_le32(MFI_INFO_RAID_0
);
803 info
.adapter_ops
= cpu_to_le32(MFI_INFO_AOPS_RBLD_RATE
|
804 MFI_INFO_AOPS_SELF_DIAGNOSTIC
|
805 MFI_INFO_AOPS_MIXED_ARRAY
);
806 info
.ld_ops
= cpu_to_le32(MFI_INFO_LDOPS_DISK_CACHE_POLICY
|
807 MFI_INFO_LDOPS_ACCESS_POLICY
|
808 MFI_INFO_LDOPS_IO_POLICY
|
809 MFI_INFO_LDOPS_WRITE_POLICY
|
810 MFI_INFO_LDOPS_READ_POLICY
);
811 info
.max_strips_per_io
= cpu_to_le16(s
->fw_sge
);
812 info
.stripe_sz_ops
.min
= 3;
813 info
.stripe_sz_ops
.max
= ctz32(MEGASAS_MAX_SECTORS
+ 1);
814 info
.properties
.pred_fail_poll_interval
= cpu_to_le16(300);
815 info
.properties
.intr_throttle_cnt
= cpu_to_le16(16);
816 info
.properties
.intr_throttle_timeout
= cpu_to_le16(50);
817 info
.properties
.rebuild_rate
= 30;
818 info
.properties
.patrol_read_rate
= 30;
819 info
.properties
.bgi_rate
= 30;
820 info
.properties
.cc_rate
= 30;
821 info
.properties
.recon_rate
= 30;
822 info
.properties
.cache_flush_interval
= 4;
823 info
.properties
.spinup_drv_cnt
= 2;
824 info
.properties
.spinup_delay
= 6;
825 info
.properties
.ecc_bucket_size
= 15;
826 info
.properties
.ecc_bucket_leak_rate
= cpu_to_le16(1440);
827 info
.properties
.expose_encl_devices
= 1;
828 info
.properties
.OnOffProperties
= cpu_to_le32(MFI_CTRL_PROP_EnableJBOD
);
829 info
.pd_ops
= cpu_to_le32(MFI_INFO_PDOPS_FORCE_ONLINE
|
830 MFI_INFO_PDOPS_FORCE_OFFLINE
);
831 info
.pd_mix_support
= cpu_to_le32(MFI_INFO_PDMIX_SAS
|
832 MFI_INFO_PDMIX_SATA
|
835 cmd
->iov_size
-= dma_buf_read((uint8_t *)&info
, dcmd_size
, &cmd
->qsg
);
839 static int megasas_mfc_get_defaults(MegasasState
*s
, MegasasCmd
*cmd
)
841 struct mfi_defaults info
;
842 size_t dcmd_size
= sizeof(struct mfi_defaults
);
844 memset(&info
, 0x0, dcmd_size
);
845 if (cmd
->iov_size
< dcmd_size
) {
846 trace_megasas_dcmd_invalid_xfer_len(cmd
->index
, cmd
->iov_size
,
848 return MFI_STAT_INVALID_PARAMETER
;
851 info
.sas_addr
= cpu_to_le64(s
->sas_addr
);
852 info
.stripe_size
= 3;
854 info
.background_rate
= 30;
855 info
.allow_mix_in_enclosure
= 1;
856 info
.allow_mix_in_ld
= 1;
857 info
.direct_pd_mapping
= 1;
858 /* Enable for BIOS support */
859 info
.bios_enumerate_lds
= 1;
860 info
.disable_ctrl_r
= 1;
861 info
.expose_enclosure_devices
= 1;
862 info
.disable_preboot_cli
= 1;
863 info
.cluster_disable
= 1;
865 cmd
->iov_size
-= dma_buf_read((uint8_t *)&info
, dcmd_size
, &cmd
->qsg
);
869 static int megasas_dcmd_get_bios_info(MegasasState
*s
, MegasasCmd
*cmd
)
871 struct mfi_bios_data info
;
872 size_t dcmd_size
= sizeof(info
);
874 memset(&info
, 0x0, dcmd_size
);
875 if (cmd
->iov_size
< dcmd_size
) {
876 trace_megasas_dcmd_invalid_xfer_len(cmd
->index
, cmd
->iov_size
,
878 return MFI_STAT_INVALID_PARAMETER
;
880 info
.continue_on_error
= 1;
882 if (megasas_is_jbod(s
)) {
883 info
.expose_all_drives
= 1;
886 cmd
->iov_size
-= dma_buf_read((uint8_t *)&info
, dcmd_size
, &cmd
->qsg
);
890 static int megasas_dcmd_get_fw_time(MegasasState
*s
, MegasasCmd
*cmd
)
893 size_t dcmd_size
= sizeof(fw_time
);
895 fw_time
= cpu_to_le64(megasas_fw_time());
897 cmd
->iov_size
-= dma_buf_read((uint8_t *)&fw_time
, dcmd_size
, &cmd
->qsg
);
901 static int megasas_dcmd_set_fw_time(MegasasState
*s
, MegasasCmd
*cmd
)
905 /* This is a dummy; setting of firmware time is not allowed */
906 memcpy(&fw_time
, cmd
->frame
->dcmd
.mbox
, sizeof(fw_time
));
908 trace_megasas_dcmd_set_fw_time(cmd
->index
, fw_time
);
909 fw_time
= cpu_to_le64(megasas_fw_time());
913 static int megasas_event_info(MegasasState
*s
, MegasasCmd
*cmd
)
915 struct mfi_evt_log_state info
;
916 size_t dcmd_size
= sizeof(info
);
918 memset(&info
, 0, dcmd_size
);
920 info
.newest_seq_num
= cpu_to_le32(s
->event_count
);
921 info
.shutdown_seq_num
= cpu_to_le32(s
->shutdown_event
);
922 info
.boot_seq_num
= cpu_to_le32(s
->boot_event
);
924 cmd
->iov_size
-= dma_buf_read((uint8_t *)&info
, dcmd_size
, &cmd
->qsg
);
928 static int megasas_event_wait(MegasasState
*s
, MegasasCmd
*cmd
)
932 if (cmd
->iov_size
< sizeof(struct mfi_evt_detail
)) {
933 trace_megasas_dcmd_invalid_xfer_len(cmd
->index
, cmd
->iov_size
,
934 sizeof(struct mfi_evt_detail
));
935 return MFI_STAT_INVALID_PARAMETER
;
937 s
->event_count
= cpu_to_le32(cmd
->frame
->dcmd
.mbox
[0]);
938 event
.word
= cpu_to_le32(cmd
->frame
->dcmd
.mbox
[4]);
939 s
->event_locale
= event
.members
.locale
;
940 s
->event_class
= event
.members
.class;
942 /* Decrease busy count; event frame doesn't count here */
944 cmd
->iov_size
= sizeof(struct mfi_evt_detail
);
945 return MFI_STAT_INVALID_STATUS
;
948 static int megasas_dcmd_pd_get_list(MegasasState
*s
, MegasasCmd
*cmd
)
950 struct mfi_pd_list info
;
951 size_t dcmd_size
= sizeof(info
);
953 uint32_t offset
, dcmd_limit
, num_pd_disks
= 0, max_pd_disks
;
955 memset(&info
, 0, dcmd_size
);
957 dcmd_limit
= offset
+ sizeof(struct mfi_pd_address
);
958 if (cmd
->iov_size
< dcmd_limit
) {
959 trace_megasas_dcmd_invalid_xfer_len(cmd
->index
, cmd
->iov_size
,
961 return MFI_STAT_INVALID_PARAMETER
;
964 max_pd_disks
= (cmd
->iov_size
- offset
) / sizeof(struct mfi_pd_address
);
965 if (max_pd_disks
> MFI_MAX_SYS_PDS
) {
966 max_pd_disks
= MFI_MAX_SYS_PDS
;
968 QTAILQ_FOREACH(kid
, &s
->bus
.qbus
.children
, sibling
) {
969 SCSIDevice
*sdev
= SCSI_DEVICE(kid
->child
);
972 if (num_pd_disks
>= max_pd_disks
)
975 pd_id
= ((sdev
->id
& 0xFF) << 8) | (sdev
->lun
& 0xFF);
976 info
.addr
[num_pd_disks
].device_id
= cpu_to_le16(pd_id
);
977 info
.addr
[num_pd_disks
].encl_device_id
= 0xFFFF;
978 info
.addr
[num_pd_disks
].encl_index
= 0;
979 info
.addr
[num_pd_disks
].slot_number
= sdev
->id
& 0xFF;
980 info
.addr
[num_pd_disks
].scsi_dev_type
= sdev
->type
;
981 info
.addr
[num_pd_disks
].connect_port_bitmap
= 0x1;
982 info
.addr
[num_pd_disks
].sas_addr
[0] =
983 cpu_to_le64(megasas_get_sata_addr(pd_id
));
985 offset
+= sizeof(struct mfi_pd_address
);
987 trace_megasas_dcmd_pd_get_list(cmd
->index
, num_pd_disks
,
988 max_pd_disks
, offset
);
990 info
.size
= cpu_to_le32(offset
);
991 info
.count
= cpu_to_le32(num_pd_disks
);
993 cmd
->iov_size
-= dma_buf_read((uint8_t *)&info
, offset
, &cmd
->qsg
);
997 static int megasas_dcmd_pd_list_query(MegasasState
*s
, MegasasCmd
*cmd
)
1001 /* mbox0 contains flags */
1002 flags
= le16_to_cpu(cmd
->frame
->dcmd
.mbox
[0]);
1003 trace_megasas_dcmd_pd_list_query(cmd
->index
, flags
);
1004 if (flags
== MR_PD_QUERY_TYPE_ALL
||
1005 megasas_is_jbod(s
)) {
1006 return megasas_dcmd_pd_get_list(s
, cmd
);
1012 static int megasas_pd_get_info_submit(SCSIDevice
*sdev
, int lun
,
1015 struct mfi_pd_info
*info
= cmd
->iov_buf
;
1016 size_t dcmd_size
= sizeof(struct mfi_pd_info
);
1018 uint16_t pd_id
= ((sdev
->id
& 0xFF) << 8) | (lun
& 0xFF);
1023 if (!cmd
->iov_buf
) {
1024 cmd
->iov_buf
= g_malloc0(dcmd_size
);
1025 info
= cmd
->iov_buf
;
1026 info
->inquiry_data
[0] = 0x7f; /* Force PQual 0x3, PType 0x1f */
1027 info
->vpd_page83
[0] = 0x7f;
1028 megasas_setup_inquiry(cmdbuf
, 0, sizeof(info
->inquiry_data
));
1029 req
= scsi_req_new(sdev
, cmd
->index
, lun
, cmdbuf
, cmd
);
1031 trace_megasas_dcmd_req_alloc_failed(cmd
->index
,
1032 "PD get info std inquiry");
1033 g_free(cmd
->iov_buf
);
1034 cmd
->iov_buf
= NULL
;
1035 return MFI_STAT_FLASH_ALLOC_FAIL
;
1037 trace_megasas_dcmd_internal_submit(cmd
->index
,
1038 "PD get info std inquiry", lun
);
1039 len
= scsi_req_enqueue(req
);
1041 cmd
->iov_size
= len
;
1042 scsi_req_continue(req
);
1044 return MFI_STAT_INVALID_STATUS
;
1045 } else if (info
->inquiry_data
[0] != 0x7f && info
->vpd_page83
[0] == 0x7f) {
1046 megasas_setup_inquiry(cmdbuf
, 0x83, sizeof(info
->vpd_page83
));
1047 req
= scsi_req_new(sdev
, cmd
->index
, lun
, cmdbuf
, cmd
);
1049 trace_megasas_dcmd_req_alloc_failed(cmd
->index
,
1050 "PD get info vpd inquiry");
1051 return MFI_STAT_FLASH_ALLOC_FAIL
;
1053 trace_megasas_dcmd_internal_submit(cmd
->index
,
1054 "PD get info vpd inquiry", lun
);
1055 len
= scsi_req_enqueue(req
);
1057 cmd
->iov_size
= len
;
1058 scsi_req_continue(req
);
1060 return MFI_STAT_INVALID_STATUS
;
1062 /* Finished, set FW state */
1063 if ((info
->inquiry_data
[0] >> 5) == 0) {
1064 if (megasas_is_jbod(cmd
->state
)) {
1065 info
->fw_state
= cpu_to_le16(MFI_PD_STATE_SYSTEM
);
1067 info
->fw_state
= cpu_to_le16(MFI_PD_STATE_ONLINE
);
1070 info
->fw_state
= cpu_to_le16(MFI_PD_STATE_OFFLINE
);
1073 info
->ref
.v
.device_id
= cpu_to_le16(pd_id
);
1074 info
->state
.ddf
.pd_type
= cpu_to_le16(MFI_PD_DDF_TYPE_IN_VD
|
1075 MFI_PD_DDF_TYPE_INTF_SAS
);
1076 blk_get_geometry(sdev
->conf
.blk
, &pd_size
);
1077 info
->raw_size
= cpu_to_le64(pd_size
);
1078 info
->non_coerced_size
= cpu_to_le64(pd_size
);
1079 info
->coerced_size
= cpu_to_le64(pd_size
);
1080 info
->encl_device_id
= 0xFFFF;
1081 info
->slot_number
= (sdev
->id
& 0xFF);
1082 info
->path_info
.count
= 1;
1083 info
->path_info
.sas_addr
[0] =
1084 cpu_to_le64(megasas_get_sata_addr(pd_id
));
1085 info
->connected_port_bitmap
= 0x1;
1086 info
->device_speed
= 1;
1087 info
->link_speed
= 1;
1088 resid
= dma_buf_read(cmd
->iov_buf
, dcmd_size
, &cmd
->qsg
);
1089 g_free(cmd
->iov_buf
);
1090 cmd
->iov_size
= dcmd_size
- resid
;
1091 cmd
->iov_buf
= NULL
;
1095 static int megasas_dcmd_pd_get_info(MegasasState
*s
, MegasasCmd
*cmd
)
1097 size_t dcmd_size
= sizeof(struct mfi_pd_info
);
1099 uint8_t target_id
, lun_id
;
1100 SCSIDevice
*sdev
= NULL
;
1101 int retval
= MFI_STAT_DEVICE_NOT_FOUND
;
1103 if (cmd
->iov_size
< dcmd_size
) {
1104 return MFI_STAT_INVALID_PARAMETER
;
1107 /* mbox0 has the ID */
1108 pd_id
= le16_to_cpu(cmd
->frame
->dcmd
.mbox
[0]);
1109 target_id
= (pd_id
>> 8) & 0xFF;
1110 lun_id
= pd_id
& 0xFF;
1111 sdev
= scsi_device_find(&s
->bus
, 0, target_id
, lun_id
);
1112 trace_megasas_dcmd_pd_get_info(cmd
->index
, pd_id
);
1115 /* Submit inquiry */
1116 retval
= megasas_pd_get_info_submit(sdev
, pd_id
, cmd
);
1122 static int megasas_dcmd_ld_get_list(MegasasState
*s
, MegasasCmd
*cmd
)
1124 struct mfi_ld_list info
;
1125 size_t dcmd_size
= sizeof(info
), resid
;
1126 uint32_t num_ld_disks
= 0, max_ld_disks
;
1130 memset(&info
, 0, dcmd_size
);
1131 if (cmd
->iov_size
> dcmd_size
) {
1132 trace_megasas_dcmd_invalid_xfer_len(cmd
->index
, cmd
->iov_size
,
1134 return MFI_STAT_INVALID_PARAMETER
;
1137 max_ld_disks
= (cmd
->iov_size
- 8) / 16;
1138 if (megasas_is_jbod(s
)) {
1141 if (max_ld_disks
> MFI_MAX_LD
) {
1142 max_ld_disks
= MFI_MAX_LD
;
1144 QTAILQ_FOREACH(kid
, &s
->bus
.qbus
.children
, sibling
) {
1145 SCSIDevice
*sdev
= SCSI_DEVICE(kid
->child
);
1147 if (num_ld_disks
>= max_ld_disks
) {
1150 /* Logical device size is in blocks */
1151 blk_get_geometry(sdev
->conf
.blk
, &ld_size
);
1152 info
.ld_list
[num_ld_disks
].ld
.v
.target_id
= sdev
->id
;
1153 info
.ld_list
[num_ld_disks
].state
= MFI_LD_STATE_OPTIMAL
;
1154 info
.ld_list
[num_ld_disks
].size
= cpu_to_le64(ld_size
);
1157 info
.ld_count
= cpu_to_le32(num_ld_disks
);
1158 trace_megasas_dcmd_ld_get_list(cmd
->index
, num_ld_disks
, max_ld_disks
);
1160 resid
= dma_buf_read((uint8_t *)&info
, dcmd_size
, &cmd
->qsg
);
1161 cmd
->iov_size
= dcmd_size
- resid
;
1165 static int megasas_dcmd_ld_list_query(MegasasState
*s
, MegasasCmd
*cmd
)
1168 struct mfi_ld_targetid_list info
;
1169 size_t dcmd_size
= sizeof(info
), resid
;
1170 uint32_t num_ld_disks
= 0, max_ld_disks
= s
->fw_luns
;
1173 /* mbox0 contains flags */
1174 flags
= le16_to_cpu(cmd
->frame
->dcmd
.mbox
[0]);
1175 trace_megasas_dcmd_ld_list_query(cmd
->index
, flags
);
1176 if (flags
!= MR_LD_QUERY_TYPE_ALL
&&
1177 flags
!= MR_LD_QUERY_TYPE_EXPOSED_TO_HOST
) {
1181 memset(&info
, 0, dcmd_size
);
1182 if (cmd
->iov_size
< 12) {
1183 trace_megasas_dcmd_invalid_xfer_len(cmd
->index
, cmd
->iov_size
,
1185 return MFI_STAT_INVALID_PARAMETER
;
1187 dcmd_size
= sizeof(uint32_t) * 2 + 3;
1188 max_ld_disks
= cmd
->iov_size
- dcmd_size
;
1189 if (megasas_is_jbod(s
)) {
1192 if (max_ld_disks
> MFI_MAX_LD
) {
1193 max_ld_disks
= MFI_MAX_LD
;
1195 QTAILQ_FOREACH(kid
, &s
->bus
.qbus
.children
, sibling
) {
1196 SCSIDevice
*sdev
= SCSI_DEVICE(kid
->child
);
1198 if (num_ld_disks
>= max_ld_disks
) {
1201 info
.targetid
[num_ld_disks
] = sdev
->lun
;
1205 info
.ld_count
= cpu_to_le32(num_ld_disks
);
1206 info
.size
= dcmd_size
;
1207 trace_megasas_dcmd_ld_get_list(cmd
->index
, num_ld_disks
, max_ld_disks
);
1209 resid
= dma_buf_read((uint8_t *)&info
, dcmd_size
, &cmd
->qsg
);
1210 cmd
->iov_size
= dcmd_size
- resid
;
1214 static int megasas_ld_get_info_submit(SCSIDevice
*sdev
, int lun
,
1217 struct mfi_ld_info
*info
= cmd
->iov_buf
;
1218 size_t dcmd_size
= sizeof(struct mfi_ld_info
);
1222 uint16_t sdev_id
= ((sdev
->id
& 0xFF) << 8) | (lun
& 0xFF);
1225 if (!cmd
->iov_buf
) {
1226 cmd
->iov_buf
= g_malloc0(dcmd_size
);
1227 info
= cmd
->iov_buf
;
1228 megasas_setup_inquiry(cdb
, 0x83, sizeof(info
->vpd_page83
));
1229 req
= scsi_req_new(sdev
, cmd
->index
, lun
, cdb
, cmd
);
1231 trace_megasas_dcmd_req_alloc_failed(cmd
->index
,
1232 "LD get info vpd inquiry");
1233 g_free(cmd
->iov_buf
);
1234 cmd
->iov_buf
= NULL
;
1235 return MFI_STAT_FLASH_ALLOC_FAIL
;
1237 trace_megasas_dcmd_internal_submit(cmd
->index
,
1238 "LD get info vpd inquiry", lun
);
1239 len
= scsi_req_enqueue(req
);
1241 cmd
->iov_size
= len
;
1242 scsi_req_continue(req
);
1244 return MFI_STAT_INVALID_STATUS
;
1247 info
->ld_config
.params
.state
= MFI_LD_STATE_OPTIMAL
;
1248 info
->ld_config
.properties
.ld
.v
.target_id
= lun
;
1249 info
->ld_config
.params
.stripe_size
= 3;
1250 info
->ld_config
.params
.num_drives
= 1;
1251 info
->ld_config
.params
.is_consistent
= 1;
1252 /* Logical device size is in blocks */
1253 blk_get_geometry(sdev
->conf
.blk
, &ld_size
);
1254 info
->size
= cpu_to_le64(ld_size
);
1255 memset(info
->ld_config
.span
, 0, sizeof(info
->ld_config
.span
));
1256 info
->ld_config
.span
[0].start_block
= 0;
1257 info
->ld_config
.span
[0].num_blocks
= info
->size
;
1258 info
->ld_config
.span
[0].array_ref
= cpu_to_le16(sdev_id
);
1260 resid
= dma_buf_read(cmd
->iov_buf
, dcmd_size
, &cmd
->qsg
);
1261 g_free(cmd
->iov_buf
);
1262 cmd
->iov_size
= dcmd_size
- resid
;
1263 cmd
->iov_buf
= NULL
;
1267 static int megasas_dcmd_ld_get_info(MegasasState
*s
, MegasasCmd
*cmd
)
1269 struct mfi_ld_info info
;
1270 size_t dcmd_size
= sizeof(info
);
1272 uint32_t max_ld_disks
= s
->fw_luns
;
1273 SCSIDevice
*sdev
= NULL
;
1274 int retval
= MFI_STAT_DEVICE_NOT_FOUND
;
1276 if (cmd
->iov_size
< dcmd_size
) {
1277 return MFI_STAT_INVALID_PARAMETER
;
1280 /* mbox0 has the ID */
1281 ld_id
= le16_to_cpu(cmd
->frame
->dcmd
.mbox
[0]);
1282 trace_megasas_dcmd_ld_get_info(cmd
->index
, ld_id
);
1284 if (megasas_is_jbod(s
)) {
1285 return MFI_STAT_DEVICE_NOT_FOUND
;
1288 if (ld_id
< max_ld_disks
) {
1289 sdev
= scsi_device_find(&s
->bus
, 0, ld_id
, 0);
1293 retval
= megasas_ld_get_info_submit(sdev
, ld_id
, cmd
);
1299 static int megasas_dcmd_cfg_read(MegasasState
*s
, MegasasCmd
*cmd
)
1301 uint8_t data
[4096] = { 0 };
1302 struct mfi_config_data
*info
;
1303 int num_pd_disks
= 0, array_offset
, ld_offset
;
1306 if (cmd
->iov_size
> 4096) {
1307 return MFI_STAT_INVALID_PARAMETER
;
1310 QTAILQ_FOREACH(kid
, &s
->bus
.qbus
.children
, sibling
) {
1313 info
= (struct mfi_config_data
*)&data
;
1316 * - One array per SCSI device
1317 * - One logical drive per SCSI device
1318 * spanning the entire device
1320 info
->array_count
= num_pd_disks
;
1321 info
->array_size
= sizeof(struct mfi_array
) * num_pd_disks
;
1322 info
->log_drv_count
= num_pd_disks
;
1323 info
->log_drv_size
= sizeof(struct mfi_ld_config
) * num_pd_disks
;
1324 info
->spares_count
= 0;
1325 info
->spares_size
= sizeof(struct mfi_spare
);
1326 info
->size
= sizeof(struct mfi_config_data
) + info
->array_size
+
1328 if (info
->size
> 4096) {
1329 return MFI_STAT_INVALID_PARAMETER
;
1332 array_offset
= sizeof(struct mfi_config_data
);
1333 ld_offset
= array_offset
+ sizeof(struct mfi_array
) * num_pd_disks
;
1335 QTAILQ_FOREACH(kid
, &s
->bus
.qbus
.children
, sibling
) {
1336 SCSIDevice
*sdev
= SCSI_DEVICE(kid
->child
);
1337 uint16_t sdev_id
= ((sdev
->id
& 0xFF) << 8) | (sdev
->lun
& 0xFF);
1338 struct mfi_array
*array
;
1339 struct mfi_ld_config
*ld
;
1343 array
= (struct mfi_array
*)(data
+ array_offset
);
1344 blk_get_geometry(sdev
->conf
.blk
, &pd_size
);
1345 array
->size
= cpu_to_le64(pd_size
);
1346 array
->num_drives
= 1;
1347 array
->array_ref
= cpu_to_le16(sdev_id
);
1348 array
->pd
[0].ref
.v
.device_id
= cpu_to_le16(sdev_id
);
1349 array
->pd
[0].ref
.v
.seq_num
= 0;
1350 array
->pd
[0].fw_state
= MFI_PD_STATE_ONLINE
;
1351 array
->pd
[0].encl
.pd
= 0xFF;
1352 array
->pd
[0].encl
.slot
= (sdev
->id
& 0xFF);
1353 for (i
= 1; i
< MFI_MAX_ROW_SIZE
; i
++) {
1354 array
->pd
[i
].ref
.v
.device_id
= 0xFFFF;
1355 array
->pd
[i
].ref
.v
.seq_num
= 0;
1356 array
->pd
[i
].fw_state
= MFI_PD_STATE_UNCONFIGURED_GOOD
;
1357 array
->pd
[i
].encl
.pd
= 0xFF;
1358 array
->pd
[i
].encl
.slot
= 0xFF;
1360 array_offset
+= sizeof(struct mfi_array
);
1361 ld
= (struct mfi_ld_config
*)(data
+ ld_offset
);
1362 memset(ld
, 0, sizeof(struct mfi_ld_config
));
1363 ld
->properties
.ld
.v
.target_id
= sdev
->id
;
1364 ld
->properties
.default_cache_policy
= MR_LD_CACHE_READ_AHEAD
|
1365 MR_LD_CACHE_READ_ADAPTIVE
;
1366 ld
->properties
.current_cache_policy
= MR_LD_CACHE_READ_AHEAD
|
1367 MR_LD_CACHE_READ_ADAPTIVE
;
1368 ld
->params
.state
= MFI_LD_STATE_OPTIMAL
;
1369 ld
->params
.stripe_size
= 3;
1370 ld
->params
.num_drives
= 1;
1371 ld
->params
.span_depth
= 1;
1372 ld
->params
.is_consistent
= 1;
1373 ld
->span
[0].start_block
= 0;
1374 ld
->span
[0].num_blocks
= cpu_to_le64(pd_size
);
1375 ld
->span
[0].array_ref
= cpu_to_le16(sdev_id
);
1376 ld_offset
+= sizeof(struct mfi_ld_config
);
1379 cmd
->iov_size
-= dma_buf_read((uint8_t *)data
, info
->size
, &cmd
->qsg
);
1383 static int megasas_dcmd_get_properties(MegasasState
*s
, MegasasCmd
*cmd
)
1385 struct mfi_ctrl_props info
;
1386 size_t dcmd_size
= sizeof(info
);
1388 memset(&info
, 0x0, dcmd_size
);
1389 if (cmd
->iov_size
< dcmd_size
) {
1390 trace_megasas_dcmd_invalid_xfer_len(cmd
->index
, cmd
->iov_size
,
1392 return MFI_STAT_INVALID_PARAMETER
;
1394 info
.pred_fail_poll_interval
= cpu_to_le16(300);
1395 info
.intr_throttle_cnt
= cpu_to_le16(16);
1396 info
.intr_throttle_timeout
= cpu_to_le16(50);
1397 info
.rebuild_rate
= 30;
1398 info
.patrol_read_rate
= 30;
1401 info
.recon_rate
= 30;
1402 info
.cache_flush_interval
= 4;
1403 info
.spinup_drv_cnt
= 2;
1404 info
.spinup_delay
= 6;
1405 info
.ecc_bucket_size
= 15;
1406 info
.ecc_bucket_leak_rate
= cpu_to_le16(1440);
1407 info
.expose_encl_devices
= 1;
1409 cmd
->iov_size
-= dma_buf_read((uint8_t *)&info
, dcmd_size
, &cmd
->qsg
);
1413 static int megasas_cache_flush(MegasasState
*s
, MegasasCmd
*cmd
)
1419 static int megasas_ctrl_shutdown(MegasasState
*s
, MegasasCmd
*cmd
)
1421 s
->fw_state
= MFI_FWSTATE_READY
;
1425 /* Some implementations use CLUSTER RESET LD to simulate a device reset */
1426 static int megasas_cluster_reset_ld(MegasasState
*s
, MegasasCmd
*cmd
)
1431 /* mbox0 contains the device index */
1432 target_id
= le16_to_cpu(cmd
->frame
->dcmd
.mbox
[0]);
1433 trace_megasas_dcmd_reset_ld(cmd
->index
, target_id
);
1434 for (i
= 0; i
< s
->fw_cmds
; i
++) {
1435 MegasasCmd
*tmp_cmd
= &s
->frames
[i
];
1436 if (tmp_cmd
->req
&& tmp_cmd
->req
->dev
->id
== target_id
) {
1437 SCSIDevice
*d
= tmp_cmd
->req
->dev
;
1438 qdev_reset_all(&d
->qdev
);
1444 static int megasas_dcmd_set_properties(MegasasState
*s
, MegasasCmd
*cmd
)
1446 struct mfi_ctrl_props info
;
1447 size_t dcmd_size
= sizeof(info
);
1449 if (cmd
->iov_size
< dcmd_size
) {
1450 trace_megasas_dcmd_invalid_xfer_len(cmd
->index
, cmd
->iov_size
,
1452 return MFI_STAT_INVALID_PARAMETER
;
1454 dma_buf_write((uint8_t *)&info
, dcmd_size
, &cmd
->qsg
);
1455 trace_megasas_dcmd_unsupported(cmd
->index
, cmd
->iov_size
);
1459 static int megasas_dcmd_dummy(MegasasState
*s
, MegasasCmd
*cmd
)
1461 trace_megasas_dcmd_dummy(cmd
->index
, cmd
->iov_size
);
1465 static const struct dcmd_cmd_tbl_t
{
1468 int (*func
)(MegasasState
*s
, MegasasCmd
*cmd
);
1469 } dcmd_cmd_tbl
[] = {
1470 { MFI_DCMD_CTRL_MFI_HOST_MEM_ALLOC
, "CTRL_HOST_MEM_ALLOC",
1471 megasas_dcmd_dummy
},
1472 { MFI_DCMD_CTRL_GET_INFO
, "CTRL_GET_INFO",
1473 megasas_ctrl_get_info
},
1474 { MFI_DCMD_CTRL_GET_PROPERTIES
, "CTRL_GET_PROPERTIES",
1475 megasas_dcmd_get_properties
},
1476 { MFI_DCMD_CTRL_SET_PROPERTIES
, "CTRL_SET_PROPERTIES",
1477 megasas_dcmd_set_properties
},
1478 { MFI_DCMD_CTRL_ALARM_GET
, "CTRL_ALARM_GET",
1479 megasas_dcmd_dummy
},
1480 { MFI_DCMD_CTRL_ALARM_ENABLE
, "CTRL_ALARM_ENABLE",
1481 megasas_dcmd_dummy
},
1482 { MFI_DCMD_CTRL_ALARM_DISABLE
, "CTRL_ALARM_DISABLE",
1483 megasas_dcmd_dummy
},
1484 { MFI_DCMD_CTRL_ALARM_SILENCE
, "CTRL_ALARM_SILENCE",
1485 megasas_dcmd_dummy
},
1486 { MFI_DCMD_CTRL_ALARM_TEST
, "CTRL_ALARM_TEST",
1487 megasas_dcmd_dummy
},
1488 { MFI_DCMD_CTRL_EVENT_GETINFO
, "CTRL_EVENT_GETINFO",
1489 megasas_event_info
},
1490 { MFI_DCMD_CTRL_EVENT_GET
, "CTRL_EVENT_GET",
1491 megasas_dcmd_dummy
},
1492 { MFI_DCMD_CTRL_EVENT_WAIT
, "CTRL_EVENT_WAIT",
1493 megasas_event_wait
},
1494 { MFI_DCMD_CTRL_SHUTDOWN
, "CTRL_SHUTDOWN",
1495 megasas_ctrl_shutdown
},
1496 { MFI_DCMD_HIBERNATE_STANDBY
, "CTRL_STANDBY",
1497 megasas_dcmd_dummy
},
1498 { MFI_DCMD_CTRL_GET_TIME
, "CTRL_GET_TIME",
1499 megasas_dcmd_get_fw_time
},
1500 { MFI_DCMD_CTRL_SET_TIME
, "CTRL_SET_TIME",
1501 megasas_dcmd_set_fw_time
},
1502 { MFI_DCMD_CTRL_BIOS_DATA_GET
, "CTRL_BIOS_DATA_GET",
1503 megasas_dcmd_get_bios_info
},
1504 { MFI_DCMD_CTRL_FACTORY_DEFAULTS
, "CTRL_FACTORY_DEFAULTS",
1505 megasas_dcmd_dummy
},
1506 { MFI_DCMD_CTRL_MFC_DEFAULTS_GET
, "CTRL_MFC_DEFAULTS_GET",
1507 megasas_mfc_get_defaults
},
1508 { MFI_DCMD_CTRL_MFC_DEFAULTS_SET
, "CTRL_MFC_DEFAULTS_SET",
1509 megasas_dcmd_dummy
},
1510 { MFI_DCMD_CTRL_CACHE_FLUSH
, "CTRL_CACHE_FLUSH",
1511 megasas_cache_flush
},
1512 { MFI_DCMD_PD_GET_LIST
, "PD_GET_LIST",
1513 megasas_dcmd_pd_get_list
},
1514 { MFI_DCMD_PD_LIST_QUERY
, "PD_LIST_QUERY",
1515 megasas_dcmd_pd_list_query
},
1516 { MFI_DCMD_PD_GET_INFO
, "PD_GET_INFO",
1517 megasas_dcmd_pd_get_info
},
1518 { MFI_DCMD_PD_STATE_SET
, "PD_STATE_SET",
1519 megasas_dcmd_dummy
},
1520 { MFI_DCMD_PD_REBUILD
, "PD_REBUILD",
1521 megasas_dcmd_dummy
},
1522 { MFI_DCMD_PD_BLINK
, "PD_BLINK",
1523 megasas_dcmd_dummy
},
1524 { MFI_DCMD_PD_UNBLINK
, "PD_UNBLINK",
1525 megasas_dcmd_dummy
},
1526 { MFI_DCMD_LD_GET_LIST
, "LD_GET_LIST",
1527 megasas_dcmd_ld_get_list
},
1528 { MFI_DCMD_LD_LIST_QUERY
, "LD_LIST_QUERY",
1529 megasas_dcmd_ld_list_query
},
1530 { MFI_DCMD_LD_GET_INFO
, "LD_GET_INFO",
1531 megasas_dcmd_ld_get_info
},
1532 { MFI_DCMD_LD_GET_PROP
, "LD_GET_PROP",
1533 megasas_dcmd_dummy
},
1534 { MFI_DCMD_LD_SET_PROP
, "LD_SET_PROP",
1535 megasas_dcmd_dummy
},
1536 { MFI_DCMD_LD_DELETE
, "LD_DELETE",
1537 megasas_dcmd_dummy
},
1538 { MFI_DCMD_CFG_READ
, "CFG_READ",
1539 megasas_dcmd_cfg_read
},
1540 { MFI_DCMD_CFG_ADD
, "CFG_ADD",
1541 megasas_dcmd_dummy
},
1542 { MFI_DCMD_CFG_CLEAR
, "CFG_CLEAR",
1543 megasas_dcmd_dummy
},
1544 { MFI_DCMD_CFG_FOREIGN_READ
, "CFG_FOREIGN_READ",
1545 megasas_dcmd_dummy
},
1546 { MFI_DCMD_CFG_FOREIGN_IMPORT
, "CFG_FOREIGN_IMPORT",
1547 megasas_dcmd_dummy
},
1548 { MFI_DCMD_BBU_STATUS
, "BBU_STATUS",
1549 megasas_dcmd_dummy
},
1550 { MFI_DCMD_BBU_CAPACITY_INFO
, "BBU_CAPACITY_INFO",
1551 megasas_dcmd_dummy
},
1552 { MFI_DCMD_BBU_DESIGN_INFO
, "BBU_DESIGN_INFO",
1553 megasas_dcmd_dummy
},
1554 { MFI_DCMD_BBU_PROP_GET
, "BBU_PROP_GET",
1555 megasas_dcmd_dummy
},
1556 { MFI_DCMD_CLUSTER
, "CLUSTER",
1557 megasas_dcmd_dummy
},
1558 { MFI_DCMD_CLUSTER_RESET_ALL
, "CLUSTER_RESET_ALL",
1559 megasas_dcmd_dummy
},
1560 { MFI_DCMD_CLUSTER_RESET_LD
, "CLUSTER_RESET_LD",
1561 megasas_cluster_reset_ld
},
1565 static int megasas_handle_dcmd(MegasasState
*s
, MegasasCmd
*cmd
)
1569 const struct dcmd_cmd_tbl_t
*cmdptr
= dcmd_cmd_tbl
;
1571 cmd
->dcmd_opcode
= le32_to_cpu(cmd
->frame
->dcmd
.opcode
);
1572 trace_megasas_handle_dcmd(cmd
->index
, cmd
->dcmd_opcode
);
1573 if (megasas_map_dcmd(s
, cmd
) < 0) {
1574 return MFI_STAT_MEMORY_NOT_AVAILABLE
;
1576 while (cmdptr
->opcode
!= -1 && cmdptr
->opcode
!= cmd
->dcmd_opcode
) {
1579 len
= cmd
->iov_size
;
1580 if (cmdptr
->opcode
== -1) {
1581 trace_megasas_dcmd_unhandled(cmd
->index
, cmd
->dcmd_opcode
, len
);
1582 retval
= megasas_dcmd_dummy(s
, cmd
);
1584 trace_megasas_dcmd_enter(cmd
->index
, cmdptr
->desc
, len
);
1585 retval
= cmdptr
->func(s
, cmd
);
1587 if (retval
!= MFI_STAT_INVALID_STATUS
) {
1588 megasas_finish_dcmd(cmd
, len
);
1593 static int megasas_finish_internal_dcmd(MegasasCmd
*cmd
,
1594 SCSIRequest
*req
, size_t resid
)
1596 int retval
= MFI_STAT_OK
;
1599 trace_megasas_dcmd_internal_finish(cmd
->index
, cmd
->dcmd_opcode
, lun
);
1600 cmd
->iov_size
-= resid
;
1601 switch (cmd
->dcmd_opcode
) {
1602 case MFI_DCMD_PD_GET_INFO
:
1603 retval
= megasas_pd_get_info_submit(req
->dev
, lun
, cmd
);
1605 case MFI_DCMD_LD_GET_INFO
:
1606 retval
= megasas_ld_get_info_submit(req
->dev
, lun
, cmd
);
1609 trace_megasas_dcmd_internal_invalid(cmd
->index
, cmd
->dcmd_opcode
);
1610 retval
= MFI_STAT_INVALID_DCMD
;
1613 if (retval
!= MFI_STAT_INVALID_STATUS
) {
1614 megasas_finish_dcmd(cmd
, cmd
->iov_size
);
1619 static int megasas_enqueue_req(MegasasCmd
*cmd
, bool is_write
)
1623 len
= scsi_req_enqueue(cmd
->req
);
1628 if (len
> cmd
->iov_size
) {
1630 trace_megasas_iov_write_overflow(cmd
->index
, len
,
1633 trace_megasas_iov_read_overflow(cmd
->index
, len
,
1637 if (len
< cmd
->iov_size
) {
1639 trace_megasas_iov_write_underflow(cmd
->index
, len
,
1642 trace_megasas_iov_read_underflow(cmd
->index
, len
,
1645 cmd
->iov_size
= len
;
1647 scsi_req_continue(cmd
->req
);
1652 static int megasas_handle_scsi(MegasasState
*s
, MegasasCmd
*cmd
,
1657 struct SCSIDevice
*sdev
= NULL
;
1658 bool is_logical
= (frame_cmd
== MFI_CMD_LD_SCSI_IO
);
1660 cdb
= cmd
->frame
->pass
.cdb
;
1663 if (cmd
->frame
->header
.target_id
>= MFI_MAX_LD
||
1664 cmd
->frame
->header
.lun_id
!= 0) {
1665 trace_megasas_scsi_target_not_present(
1666 mfi_frame_desc
[frame_cmd
], is_logical
,
1667 cmd
->frame
->header
.target_id
, cmd
->frame
->header
.lun_id
);
1668 return MFI_STAT_DEVICE_NOT_FOUND
;
1671 sdev
= scsi_device_find(&s
->bus
, 0, cmd
->frame
->header
.target_id
,
1672 cmd
->frame
->header
.lun_id
);
1674 cmd
->iov_size
= le32_to_cpu(cmd
->frame
->header
.data_len
);
1675 trace_megasas_handle_scsi(mfi_frame_desc
[cmd
->frame
->header
.frame_cmd
],
1676 trace_megasas_handle_scsi(mfi_frame_desc
[frame_cmd
], is_logical
,
1677 cmd
->frame
->header
.target_id
,
1678 cmd
->frame
->header
.lun_id
, sdev
, cmd
->iov_size
);
1680 if (!sdev
|| (megasas_is_jbod(s
) && is_logical
)) {
1681 trace_megasas_scsi_target_not_present(
1682 mfi_frame_desc
[frame_cmd
], is_logical
,
1683 cmd
->frame
->header
.target_id
, cmd
->frame
->header
.lun_id
);
1684 return MFI_STAT_DEVICE_NOT_FOUND
;
1687 if (cmd
->frame
->header
.cdb_len
> 16) {
1688 trace_megasas_scsi_invalid_cdb_len(
1689 mfi_frame_desc
[frame_cmd
], is_logical
,
1690 cmd
->frame
->header
.target_id
, cmd
->frame
->header
.lun_id
,
1691 cmd
->frame
->header
.cdb_len
);
1692 megasas_write_sense(cmd
, SENSE_CODE(INVALID_OPCODE
));
1693 cmd
->frame
->header
.scsi_status
= CHECK_CONDITION
;
1695 return MFI_STAT_SCSI_DONE_WITH_ERROR
;
1698 if (megasas_map_sgl(s
, cmd
, &cmd
->frame
->pass
.sgl
)) {
1699 megasas_write_sense(cmd
, SENSE_CODE(TARGET_FAILURE
));
1700 cmd
->frame
->header
.scsi_status
= CHECK_CONDITION
;
1702 return MFI_STAT_SCSI_DONE_WITH_ERROR
;
1705 cmd
->req
= scsi_req_new(sdev
, cmd
->index
,
1706 cmd
->frame
->header
.lun_id
, cdb
, cmd
);
1708 trace_megasas_scsi_req_alloc_failed(
1709 mfi_frame_desc
[frame_cmd
],
1710 cmd
->frame
->header
.target_id
, cmd
->frame
->header
.lun_id
);
1711 megasas_write_sense(cmd
, SENSE_CODE(NO_SENSE
));
1712 cmd
->frame
->header
.scsi_status
= BUSY
;
1714 return MFI_STAT_SCSI_DONE_WITH_ERROR
;
1717 is_write
= (cmd
->req
->cmd
.mode
== SCSI_XFER_TO_DEV
);
1718 if (cmd
->iov_size
) {
1720 trace_megasas_scsi_write_start(cmd
->index
, cmd
->iov_size
);
1722 trace_megasas_scsi_read_start(cmd
->index
, cmd
->iov_size
);
1725 trace_megasas_scsi_nodata(cmd
->index
);
1727 megasas_enqueue_req(cmd
, is_write
);
1728 return MFI_STAT_INVALID_STATUS
;
1731 static int megasas_handle_io(MegasasState
*s
, MegasasCmd
*cmd
, int frame_cmd
)
1733 uint32_t lba_count
, lba_start_hi
, lba_start_lo
;
1735 bool is_write
= (frame_cmd
== MFI_CMD_LD_WRITE
);
1738 struct SCSIDevice
*sdev
= NULL
;
1740 lba_count
= le32_to_cpu(cmd
->frame
->io
.header
.data_len
);
1741 lba_start_lo
= le32_to_cpu(cmd
->frame
->io
.lba_lo
);
1742 lba_start_hi
= le32_to_cpu(cmd
->frame
->io
.lba_hi
);
1743 lba_start
= ((uint64_t)lba_start_hi
<< 32) | lba_start_lo
;
1745 if (cmd
->frame
->header
.target_id
< MFI_MAX_LD
&&
1746 cmd
->frame
->header
.lun_id
== 0) {
1747 sdev
= scsi_device_find(&s
->bus
, 0, cmd
->frame
->header
.target_id
,
1748 cmd
->frame
->header
.lun_id
);
1751 trace_megasas_handle_io(cmd
->index
,
1752 mfi_frame_desc
[frame_cmd
],
1753 cmd
->frame
->header
.target_id
,
1754 cmd
->frame
->header
.lun_id
,
1755 (unsigned long)lba_start
, (unsigned long)lba_count
);
1757 trace_megasas_io_target_not_present(cmd
->index
,
1758 mfi_frame_desc
[frame_cmd
],
1759 cmd
->frame
->header
.target_id
, cmd
->frame
->header
.lun_id
);
1760 return MFI_STAT_DEVICE_NOT_FOUND
;
1763 if (cmd
->frame
->header
.cdb_len
> 16) {
1764 trace_megasas_scsi_invalid_cdb_len(
1765 mfi_frame_desc
[frame_cmd
], 1,
1766 cmd
->frame
->header
.target_id
, cmd
->frame
->header
.lun_id
,
1767 cmd
->frame
->header
.cdb_len
);
1768 megasas_write_sense(cmd
, SENSE_CODE(INVALID_OPCODE
));
1769 cmd
->frame
->header
.scsi_status
= CHECK_CONDITION
;
1771 return MFI_STAT_SCSI_DONE_WITH_ERROR
;
1774 cmd
->iov_size
= lba_count
* sdev
->blocksize
;
1775 if (megasas_map_sgl(s
, cmd
, &cmd
->frame
->io
.sgl
)) {
1776 megasas_write_sense(cmd
, SENSE_CODE(TARGET_FAILURE
));
1777 cmd
->frame
->header
.scsi_status
= CHECK_CONDITION
;
1779 return MFI_STAT_SCSI_DONE_WITH_ERROR
;
1782 megasas_encode_lba(cdb
, lba_start
, lba_count
, is_write
);
1783 cmd
->req
= scsi_req_new(sdev
, cmd
->index
,
1784 cmd
->frame
->header
.lun_id
, cdb
, cmd
);
1786 trace_megasas_scsi_req_alloc_failed(
1787 mfi_frame_desc
[frame_cmd
],
1788 cmd
->frame
->header
.target_id
, cmd
->frame
->header
.lun_id
);
1789 megasas_write_sense(cmd
, SENSE_CODE(NO_SENSE
));
1790 cmd
->frame
->header
.scsi_status
= BUSY
;
1792 return MFI_STAT_SCSI_DONE_WITH_ERROR
;
1794 len
= megasas_enqueue_req(cmd
, is_write
);
1797 trace_megasas_io_write_start(cmd
->index
, lba_start
, lba_count
, len
);
1799 trace_megasas_io_read_start(cmd
->index
, lba_start
, lba_count
, len
);
1802 return MFI_STAT_INVALID_STATUS
;
1805 static QEMUSGList
*megasas_get_sg_list(SCSIRequest
*req
)
1807 MegasasCmd
*cmd
= req
->hba_private
;
1809 if (cmd
->dcmd_opcode
!= -1) {
1816 static void megasas_xfer_complete(SCSIRequest
*req
, uint32_t len
)
1818 MegasasCmd
*cmd
= req
->hba_private
;
1821 trace_megasas_io_complete(cmd
->index
, len
);
1823 if (cmd
->dcmd_opcode
!= -1) {
1824 scsi_req_continue(req
);
1828 buf
= scsi_req_get_buf(req
);
1829 if (cmd
->dcmd_opcode
== MFI_DCMD_PD_GET_INFO
&& cmd
->iov_buf
) {
1830 struct mfi_pd_info
*info
= cmd
->iov_buf
;
1832 if (info
->inquiry_data
[0] == 0x7f) {
1833 memset(info
->inquiry_data
, 0, sizeof(info
->inquiry_data
));
1834 memcpy(info
->inquiry_data
, buf
, len
);
1835 } else if (info
->vpd_page83
[0] == 0x7f) {
1836 memset(info
->vpd_page83
, 0, sizeof(info
->vpd_page83
));
1837 memcpy(info
->vpd_page83
, buf
, len
);
1839 scsi_req_continue(req
);
1840 } else if (cmd
->dcmd_opcode
== MFI_DCMD_LD_GET_INFO
) {
1841 struct mfi_ld_info
*info
= cmd
->iov_buf
;
1844 memcpy(info
->vpd_page83
, buf
, sizeof(info
->vpd_page83
));
1845 scsi_req_continue(req
);
1850 static void megasas_command_complete(SCSIRequest
*req
, uint32_t status
,
1853 MegasasCmd
*cmd
= req
->hba_private
;
1854 uint8_t cmd_status
= MFI_STAT_OK
;
1856 trace_megasas_command_complete(cmd
->index
, status
, resid
);
1858 if (req
->io_canceled
) {
1862 if (cmd
->req
== NULL
) {
1864 * Internal command complete
1866 cmd_status
= megasas_finish_internal_dcmd(cmd
, req
, resid
);
1867 if (cmd_status
== MFI_STAT_INVALID_STATUS
) {
1871 req
->status
= status
;
1872 trace_megasas_scsi_complete(cmd
->index
, req
->status
,
1873 cmd
->iov_size
, req
->cmd
.xfer
);
1874 if (req
->status
!= GOOD
) {
1875 cmd_status
= MFI_STAT_SCSI_DONE_WITH_ERROR
;
1877 if (req
->status
== CHECK_CONDITION
) {
1878 megasas_copy_sense(cmd
);
1881 cmd
->frame
->header
.scsi_status
= req
->status
;
1883 cmd
->frame
->header
.cmd_status
= cmd_status
;
1884 megasas_complete_command(cmd
);
1887 static void megasas_command_cancelled(SCSIRequest
*req
)
1889 MegasasCmd
*cmd
= req
->hba_private
;
1894 cmd
->frame
->header
.cmd_status
= MFI_STAT_SCSI_IO_FAILED
;
1895 megasas_complete_command(cmd
);
1898 static int megasas_handle_abort(MegasasState
*s
, MegasasCmd
*cmd
)
1900 uint64_t abort_ctx
= le64_to_cpu(cmd
->frame
->abort
.abort_context
);
1901 hwaddr abort_addr
, addr_hi
, addr_lo
;
1902 MegasasCmd
*abort_cmd
;
1904 addr_hi
= le32_to_cpu(cmd
->frame
->abort
.abort_mfi_addr_hi
);
1905 addr_lo
= le32_to_cpu(cmd
->frame
->abort
.abort_mfi_addr_lo
);
1906 abort_addr
= ((uint64_t)addr_hi
<< 32) | addr_lo
;
1908 abort_cmd
= megasas_lookup_frame(s
, abort_addr
);
1910 trace_megasas_abort_no_cmd(cmd
->index
, abort_ctx
);
1914 if (!megasas_use_queue64(s
)) {
1915 abort_ctx
&= (uint64_t)0xFFFFFFFF;
1917 if (abort_cmd
->context
!= abort_ctx
) {
1918 trace_megasas_abort_invalid_context(cmd
->index
, abort_cmd
->context
,
1921 return MFI_STAT_ABORT_NOT_POSSIBLE
;
1923 trace_megasas_abort_frame(cmd
->index
, abort_cmd
->index
);
1924 megasas_abort_command(abort_cmd
);
1925 if (!s
->event_cmd
|| abort_cmd
!= s
->event_cmd
) {
1926 s
->event_cmd
= NULL
;
1932 static void megasas_handle_frame(MegasasState
*s
, uint64_t frame_addr
,
1933 uint32_t frame_count
)
1935 uint8_t frame_status
= MFI_STAT_INVALID_CMD
;
1936 uint64_t frame_context
;
1941 * Always read 64bit context, top bits will be
1942 * masked out if required in megasas_enqueue_frame()
1944 frame_context
= megasas_frame_get_context(s
, frame_addr
);
1946 cmd
= megasas_enqueue_frame(s
, frame_addr
, frame_context
, frame_count
);
1948 /* reply queue full */
1949 trace_megasas_frame_busy(frame_addr
);
1950 megasas_frame_set_scsi_status(s
, frame_addr
, BUSY
);
1951 megasas_frame_set_cmd_status(s
, frame_addr
, MFI_STAT_SCSI_DONE_WITH_ERROR
);
1952 megasas_complete_frame(s
, frame_context
);
1956 frame_cmd
= cmd
->frame
->header
.frame_cmd
;
1957 switch (frame_cmd
) {
1959 frame_status
= megasas_init_firmware(s
, cmd
);
1962 frame_status
= megasas_handle_dcmd(s
, cmd
);
1965 frame_status
= megasas_handle_abort(s
, cmd
);
1967 case MFI_CMD_PD_SCSI_IO
:
1968 case MFI_CMD_LD_SCSI_IO
:
1969 frame_status
= megasas_handle_scsi(s
, cmd
, frame_cmd
);
1971 case MFI_CMD_LD_READ
:
1972 case MFI_CMD_LD_WRITE
:
1973 frame_status
= megasas_handle_io(s
, cmd
, frame_cmd
);
1976 trace_megasas_unhandled_frame_cmd(cmd
->index
, frame_cmd
);
1980 if (frame_status
!= MFI_STAT_INVALID_STATUS
) {
1982 cmd
->frame
->header
.cmd_status
= frame_status
;
1984 megasas_frame_set_cmd_status(s
, frame_addr
, frame_status
);
1986 megasas_unmap_frame(s
, cmd
);
1987 megasas_complete_frame(s
, cmd
->context
);
1991 static uint64_t megasas_mmio_read(void *opaque
, hwaddr addr
,
1994 MegasasState
*s
= opaque
;
1995 PCIDevice
*pci_dev
= PCI_DEVICE(s
);
1996 MegasasBaseClass
*base_class
= MEGASAS_DEVICE_GET_CLASS(s
);
1997 uint32_t retval
= 0;
2002 trace_megasas_mmio_readl("MFI_IDB", retval
);
2006 retval
= (msix_present(pci_dev
) ? MFI_FWSTATE_MSIX_SUPPORTED
: 0) |
2007 (s
->fw_state
& MFI_FWSTATE_MASK
) |
2008 ((s
->fw_sge
& 0xff) << 16) |
2009 (s
->fw_cmds
& 0xFFFF);
2010 trace_megasas_mmio_readl(addr
== MFI_OMSG0
? "MFI_OMSG0" : "MFI_OSP0",
2014 if (megasas_intr_enabled(s
) && s
->doorbell
) {
2015 retval
= base_class
->osts
;
2017 trace_megasas_mmio_readl("MFI_OSTS", retval
);
2020 retval
= s
->intr_mask
;
2021 trace_megasas_mmio_readl("MFI_OMSK", retval
);
2024 retval
= s
->doorbell
? 1 : 0;
2025 trace_megasas_mmio_readl("MFI_ODCR0", retval
);
2029 trace_megasas_mmio_readl("MFI_DIAG", retval
);
2033 trace_megasas_mmio_readl("MFI_OSP1", retval
);
2036 trace_megasas_mmio_invalid_readl(addr
);
2042 static int adp_reset_seq
[] = {0x00, 0x04, 0x0b, 0x02, 0x07, 0x0d};
2044 static void megasas_mmio_write(void *opaque
, hwaddr addr
,
2045 uint64_t val
, unsigned size
)
2047 MegasasState
*s
= opaque
;
2048 PCIDevice
*pci_dev
= PCI_DEVICE(s
);
2049 uint64_t frame_addr
;
2050 uint32_t frame_count
;
2055 trace_megasas_mmio_writel("MFI_IDB", val
);
2056 if (val
& MFI_FWINIT_ABORT
) {
2057 /* Abort all pending cmds */
2058 for (i
= 0; i
< s
->fw_cmds
; i
++) {
2059 megasas_abort_command(&s
->frames
[i
]);
2062 if (val
& MFI_FWINIT_READY
) {
2063 /* move to FW READY */
2064 megasas_soft_reset(s
);
2066 if (val
& MFI_FWINIT_MFIMODE
) {
2069 if (val
& MFI_FWINIT_STOP_ADP
) {
2070 /* Terminal error, stop processing */
2071 s
->fw_state
= MFI_FWSTATE_FAULT
;
2075 trace_megasas_mmio_writel("MFI_OMSK", val
);
2077 if (!megasas_intr_enabled(s
) &&
2078 !msi_enabled(pci_dev
) &&
2079 !msix_enabled(pci_dev
)) {
2080 trace_megasas_irq_lower();
2081 pci_irq_deassert(pci_dev
);
2083 if (megasas_intr_enabled(s
)) {
2084 if (msix_enabled(pci_dev
)) {
2085 trace_megasas_msix_enabled(0);
2086 } else if (msi_enabled(pci_dev
)) {
2087 trace_megasas_msi_enabled(0);
2089 trace_megasas_intr_enabled();
2092 trace_megasas_intr_disabled();
2093 megasas_soft_reset(s
);
2097 trace_megasas_mmio_writel("MFI_ODCR0", val
);
2099 if (megasas_intr_enabled(s
)) {
2100 if (!msix_enabled(pci_dev
) && !msi_enabled(pci_dev
)) {
2101 trace_megasas_irq_lower();
2102 pci_irq_deassert(pci_dev
);
2107 trace_megasas_mmio_writel("MFI_IQPH", val
);
2108 /* Received high 32 bits of a 64 bit MFI frame address */
2112 trace_megasas_mmio_writel("MFI_IQPL", val
);
2113 /* Received low 32 bits of a 64 bit MFI frame address */
2116 if (addr
== MFI_IQP
) {
2117 trace_megasas_mmio_writel("MFI_IQP", val
);
2118 /* Received 64 bit MFI frame address */
2121 frame_addr
= (val
& ~0x1F);
2122 /* Add possible 64 bit offset */
2123 frame_addr
|= ((uint64_t)s
->frame_hi
<< 32);
2125 frame_count
= (val
>> 1) & 0xF;
2126 megasas_handle_frame(s
, frame_addr
, frame_count
);
2129 trace_megasas_mmio_writel("MFI_SEQ", val
);
2130 /* Magic sequence to start ADP reset */
2131 if (adp_reset_seq
[s
->adp_reset
++] == val
) {
2132 if (s
->adp_reset
== 6) {
2134 s
->diag
= MFI_DIAG_WRITE_ENABLE
;
2142 trace_megasas_mmio_writel("MFI_DIAG", val
);
2144 if ((s
->diag
& MFI_DIAG_WRITE_ENABLE
) &&
2145 (val
& MFI_DIAG_RESET_ADP
)) {
2146 s
->diag
|= MFI_DIAG_RESET_ADP
;
2147 megasas_soft_reset(s
);
2153 trace_megasas_mmio_invalid_writel(addr
, val
);
2158 static const MemoryRegionOps megasas_mmio_ops
= {
2159 .read
= megasas_mmio_read
,
2160 .write
= megasas_mmio_write
,
2161 .endianness
= DEVICE_LITTLE_ENDIAN
,
2163 .min_access_size
= 8,
2164 .max_access_size
= 8,
2168 static uint64_t megasas_port_read(void *opaque
, hwaddr addr
,
2171 return megasas_mmio_read(opaque
, addr
& 0xff, size
);
2174 static void megasas_port_write(void *opaque
, hwaddr addr
,
2175 uint64_t val
, unsigned size
)
2177 megasas_mmio_write(opaque
, addr
& 0xff, val
, size
);
2180 static const MemoryRegionOps megasas_port_ops
= {
2181 .read
= megasas_port_read
,
2182 .write
= megasas_port_write
,
2183 .endianness
= DEVICE_LITTLE_ENDIAN
,
2185 .min_access_size
= 4,
2186 .max_access_size
= 4,
2190 static uint64_t megasas_queue_read(void *opaque
, hwaddr addr
,
2196 static void megasas_queue_write(void *opaque
, hwaddr addr
,
2197 uint64_t val
, unsigned size
)
2202 static const MemoryRegionOps megasas_queue_ops
= {
2203 .read
= megasas_queue_read
,
2204 .write
= megasas_queue_write
,
2205 .endianness
= DEVICE_LITTLE_ENDIAN
,
2207 .min_access_size
= 8,
2208 .max_access_size
= 8,
2212 static void megasas_soft_reset(MegasasState
*s
)
2217 trace_megasas_reset(s
->fw_state
);
2218 for (i
= 0; i
< s
->fw_cmds
; i
++) {
2219 cmd
= &s
->frames
[i
];
2220 megasas_abort_command(cmd
);
2222 if (s
->fw_state
== MFI_FWSTATE_READY
) {
2226 * The EFI firmware doesn't handle UA,
2227 * so we need to clear the Power On/Reset UA
2228 * after the initial reset.
2230 QTAILQ_FOREACH(kid
, &s
->bus
.qbus
.children
, sibling
) {
2231 SCSIDevice
*sdev
= SCSI_DEVICE(kid
->child
);
2233 sdev
->unit_attention
= SENSE_CODE(NO_SENSE
);
2234 scsi_device_unit_attention_reported(sdev
);
2237 megasas_reset_frames(s
);
2238 s
->reply_queue_len
= s
->fw_cmds
;
2239 s
->reply_queue_pa
= 0;
2242 s
->fw_state
= MFI_FWSTATE_READY
;
2244 s
->intr_mask
= MEGASAS_INTR_DISABLED_MASK
;
2246 s
->flags
&= ~MEGASAS_MASK_USE_QUEUE64
;
2248 s
->boot_event
= s
->event_count
;
2251 static void megasas_scsi_reset(DeviceState
*dev
)
2253 MegasasState
*s
= MEGASAS(dev
);
2255 megasas_soft_reset(s
);
2258 static const VMStateDescription vmstate_megasas_gen1
= {
2261 .minimum_version_id
= 0,
2262 .fields
= (VMStateField
[]) {
2263 VMSTATE_PCI_DEVICE(parent_obj
, MegasasState
),
2264 VMSTATE_MSIX(parent_obj
, MegasasState
),
2266 VMSTATE_INT32(fw_state
, MegasasState
),
2267 VMSTATE_INT32(intr_mask
, MegasasState
),
2268 VMSTATE_INT32(doorbell
, MegasasState
),
2269 VMSTATE_UINT64(reply_queue_pa
, MegasasState
),
2270 VMSTATE_UINT64(consumer_pa
, MegasasState
),
2271 VMSTATE_UINT64(producer_pa
, MegasasState
),
2272 VMSTATE_END_OF_LIST()
2276 static const VMStateDescription vmstate_megasas_gen2
= {
2277 .name
= "megasas-gen2",
2279 .minimum_version_id
= 0,
2280 .minimum_version_id_old
= 0,
2281 .fields
= (VMStateField
[]) {
2282 VMSTATE_PCI_DEVICE(parent_obj
, MegasasState
),
2283 VMSTATE_MSIX(parent_obj
, MegasasState
),
2285 VMSTATE_INT32(fw_state
, MegasasState
),
2286 VMSTATE_INT32(intr_mask
, MegasasState
),
2287 VMSTATE_INT32(doorbell
, MegasasState
),
2288 VMSTATE_UINT64(reply_queue_pa
, MegasasState
),
2289 VMSTATE_UINT64(consumer_pa
, MegasasState
),
2290 VMSTATE_UINT64(producer_pa
, MegasasState
),
2291 VMSTATE_END_OF_LIST()
2295 static void megasas_scsi_uninit(PCIDevice
*d
)
2297 MegasasState
*s
= MEGASAS(d
);
2299 if (megasas_use_msix(s
)) {
2300 msix_uninit(d
, &s
->mmio_io
, &s
->mmio_io
);
2305 static const struct SCSIBusInfo megasas_scsi_info
= {
2307 .max_target
= MFI_MAX_LD
,
2310 .transfer_data
= megasas_xfer_complete
,
2311 .get_sg_list
= megasas_get_sg_list
,
2312 .complete
= megasas_command_complete
,
2313 .cancel
= megasas_command_cancelled
,
2316 static void megasas_scsi_realize(PCIDevice
*dev
, Error
**errp
)
2318 MegasasState
*s
= MEGASAS(dev
);
2319 MegasasBaseClass
*b
= MEGASAS_DEVICE_GET_CLASS(s
);
2325 pci_conf
= dev
->config
;
2327 /* PCI latency timer = 0 */
2328 pci_conf
[PCI_LATENCY_TIMER
] = 0;
2329 /* Interrupt pin 1 */
2330 pci_conf
[PCI_INTERRUPT_PIN
] = 0x01;
2332 if (s
->msi
!= ON_OFF_AUTO_OFF
) {
2333 ret
= msi_init(dev
, 0x50, 1, true, false, &err
);
2334 /* Any error other than -ENOTSUP(board's MSI support is broken)
2335 * is a programming error */
2336 assert(!ret
|| ret
== -ENOTSUP
);
2337 if (ret
&& s
->msi
== ON_OFF_AUTO_ON
) {
2338 /* Can't satisfy user's explicit msi=on request, fail */
2339 error_append_hint(&err
, "You have to use msi=auto (default) or "
2340 "msi=off with this machine type.\n");
2341 error_propagate(errp
, err
);
2344 /* With msi=auto, we fall back to MSI off silently */
2345 s
->msi
= ON_OFF_AUTO_OFF
;
2350 memory_region_init_io(&s
->mmio_io
, OBJECT(s
), &megasas_mmio_ops
, s
,
2351 "megasas-mmio", 0x4000);
2352 memory_region_init_io(&s
->port_io
, OBJECT(s
), &megasas_port_ops
, s
,
2354 memory_region_init_io(&s
->queue_io
, OBJECT(s
), &megasas_queue_ops
, s
,
2355 "megasas-queue", 0x40000);
2357 if (megasas_use_msix(s
) &&
2358 msix_init(dev
, 15, &s
->mmio_io
, b
->mmio_bar
, 0x2000,
2359 &s
->mmio_io
, b
->mmio_bar
, 0x3800, 0x68, NULL
)) {
2360 /* TODO: check msix_init's error, and should fail on msix=on */
2361 s
->msix
= ON_OFF_AUTO_OFF
;
2364 if (pci_is_express(dev
)) {
2365 pcie_endpoint_cap_init(dev
, 0xa0);
2368 bar_type
= PCI_BASE_ADDRESS_SPACE_MEMORY
| PCI_BASE_ADDRESS_MEM_TYPE_64
;
2369 pci_register_bar(dev
, b
->ioport_bar
,
2370 PCI_BASE_ADDRESS_SPACE_IO
, &s
->port_io
);
2371 pci_register_bar(dev
, b
->mmio_bar
, bar_type
, &s
->mmio_io
);
2372 pci_register_bar(dev
, 3, bar_type
, &s
->queue_io
);
2374 if (megasas_use_msix(s
)) {
2375 msix_vector_use(dev
, 0);
2378 s
->fw_state
= MFI_FWSTATE_READY
;
2380 s
->sas_addr
= ((NAA_LOCALLY_ASSIGNED_ID
<< 24) |
2381 IEEE_COMPANY_LOCALLY_ASSIGNED
) << 36;
2382 s
->sas_addr
|= (pci_bus_num(dev
->bus
) << 16);
2383 s
->sas_addr
|= (PCI_SLOT(dev
->devfn
) << 8);
2384 s
->sas_addr
|= PCI_FUNC(dev
->devfn
);
2386 if (!s
->hba_serial
) {
2387 s
->hba_serial
= g_strdup(MEGASAS_HBA_SERIAL
);
2389 if (s
->fw_sge
>= MEGASAS_MAX_SGE
- MFI_PASS_FRAME_SIZE
) {
2390 s
->fw_sge
= MEGASAS_MAX_SGE
- MFI_PASS_FRAME_SIZE
;
2391 } else if (s
->fw_sge
>= 128 - MFI_PASS_FRAME_SIZE
) {
2392 s
->fw_sge
= 128 - MFI_PASS_FRAME_SIZE
;
2394 s
->fw_sge
= 64 - MFI_PASS_FRAME_SIZE
;
2396 if (s
->fw_cmds
> MEGASAS_MAX_FRAMES
) {
2397 s
->fw_cmds
= MEGASAS_MAX_FRAMES
;
2399 trace_megasas_init(s
->fw_sge
, s
->fw_cmds
,
2400 megasas_is_jbod(s
) ? "jbod" : "raid");
2402 if (megasas_is_jbod(s
)) {
2403 s
->fw_luns
= MFI_MAX_SYS_PDS
;
2405 s
->fw_luns
= MFI_MAX_LD
;
2409 for (i
= 0; i
< s
->fw_cmds
; i
++) {
2410 s
->frames
[i
].index
= i
;
2411 s
->frames
[i
].context
= -1;
2412 s
->frames
[i
].pa
= 0;
2413 s
->frames
[i
].state
= s
;
2416 scsi_bus_new(&s
->bus
, sizeof(s
->bus
), DEVICE(dev
),
2417 &megasas_scsi_info
, NULL
);
2420 static Property megasas_properties_gen1
[] = {
2421 DEFINE_PROP_UINT32("max_sge", MegasasState
, fw_sge
,
2422 MEGASAS_DEFAULT_SGE
),
2423 DEFINE_PROP_UINT32("max_cmds", MegasasState
, fw_cmds
,
2424 MEGASAS_DEFAULT_FRAMES
),
2425 DEFINE_PROP_STRING("hba_serial", MegasasState
, hba_serial
),
2426 DEFINE_PROP_UINT64("sas_address", MegasasState
, sas_addr
, 0),
2427 DEFINE_PROP_ON_OFF_AUTO("msi", MegasasState
, msi
, ON_OFF_AUTO_AUTO
),
2428 DEFINE_PROP_ON_OFF_AUTO("msix", MegasasState
, msix
, ON_OFF_AUTO_AUTO
),
2429 DEFINE_PROP_BIT("use_jbod", MegasasState
, flags
,
2430 MEGASAS_FLAG_USE_JBOD
, false),
2431 DEFINE_PROP_END_OF_LIST(),
2434 static Property megasas_properties_gen2
[] = {
2435 DEFINE_PROP_UINT32("max_sge", MegasasState
, fw_sge
,
2436 MEGASAS_DEFAULT_SGE
),
2437 DEFINE_PROP_UINT32("max_cmds", MegasasState
, fw_cmds
,
2438 MEGASAS_GEN2_DEFAULT_FRAMES
),
2439 DEFINE_PROP_STRING("hba_serial", MegasasState
, hba_serial
),
2440 DEFINE_PROP_UINT64("sas_address", MegasasState
, sas_addr
, 0),
2441 DEFINE_PROP_ON_OFF_AUTO("msi", MegasasState
, msi
, ON_OFF_AUTO_AUTO
),
2442 DEFINE_PROP_ON_OFF_AUTO("msix", MegasasState
, msix
, ON_OFF_AUTO_AUTO
),
2443 DEFINE_PROP_BIT("use_jbod", MegasasState
, flags
,
2444 MEGASAS_FLAG_USE_JBOD
, false),
2445 DEFINE_PROP_END_OF_LIST(),
2448 typedef struct MegasasInfo
{
2451 const char *product_name
;
2452 const char *product_version
;
2454 uint16_t subsystem_id
;
2459 const VMStateDescription
*vmsd
;
2463 static struct MegasasInfo megasas_devices
[] = {
2465 .name
= TYPE_MEGASAS_GEN1
,
2466 .desc
= "LSI MegaRAID SAS 1078",
2467 .product_name
= "LSI MegaRAID SAS 8708EM2",
2468 .product_version
= MEGASAS_VERSION_GEN1
,
2469 .device_id
= PCI_DEVICE_ID_LSI_SAS1078
,
2470 .subsystem_id
= 0x1013,
2473 .osts
= MFI_1078_RM
| 1,
2474 .is_express
= false,
2475 .vmsd
= &vmstate_megasas_gen1
,
2476 .props
= megasas_properties_gen1
,
2478 .name
= TYPE_MEGASAS_GEN2
,
2479 .desc
= "LSI MegaRAID SAS 2108",
2480 .product_name
= "LSI MegaRAID SAS 9260-8i",
2481 .product_version
= MEGASAS_VERSION_GEN2
,
2482 .device_id
= PCI_DEVICE_ID_LSI_SAS0079
,
2483 .subsystem_id
= 0x9261,
2486 .osts
= MFI_GEN2_RM
,
2488 .vmsd
= &vmstate_megasas_gen2
,
2489 .props
= megasas_properties_gen2
,
2493 static void megasas_class_init(ObjectClass
*oc
, void *data
)
2495 DeviceClass
*dc
= DEVICE_CLASS(oc
);
2496 PCIDeviceClass
*pc
= PCI_DEVICE_CLASS(oc
);
2497 MegasasBaseClass
*e
= MEGASAS_DEVICE_CLASS(oc
);
2498 const MegasasInfo
*info
= data
;
2500 pc
->realize
= megasas_scsi_realize
;
2501 pc
->exit
= megasas_scsi_uninit
;
2502 pc
->vendor_id
= PCI_VENDOR_ID_LSI_LOGIC
;
2503 pc
->device_id
= info
->device_id
;
2504 pc
->subsystem_vendor_id
= PCI_VENDOR_ID_LSI_LOGIC
;
2505 pc
->subsystem_id
= info
->subsystem_id
;
2506 pc
->class_id
= PCI_CLASS_STORAGE_RAID
;
2507 pc
->is_express
= info
->is_express
;
2508 e
->mmio_bar
= info
->mmio_bar
;
2509 e
->ioport_bar
= info
->ioport_bar
;
2510 e
->osts
= info
->osts
;
2511 e
->product_name
= info
->product_name
;
2512 e
->product_version
= info
->product_version
;
2513 dc
->props
= info
->props
;
2514 dc
->reset
= megasas_scsi_reset
;
2515 dc
->vmsd
= info
->vmsd
;
2516 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
2517 dc
->desc
= info
->desc
;
2520 static const TypeInfo megasas_info
= {
2521 .name
= TYPE_MEGASAS_BASE
,
2522 .parent
= TYPE_PCI_DEVICE
,
2523 .instance_size
= sizeof(MegasasState
),
2524 .class_size
= sizeof(MegasasBaseClass
),
2528 static void megasas_register_types(void)
2532 type_register_static(&megasas_info
);
2533 for (i
= 0; i
< ARRAY_SIZE(megasas_devices
); i
++) {
2534 const MegasasInfo
*info
= &megasas_devices
[i
];
2535 TypeInfo type_info
= {};
2537 type_info
.name
= info
->name
;
2538 type_info
.parent
= TYPE_MEGASAS_BASE
;
2539 type_info
.class_data
= (void *)info
;
2540 type_info
.class_init
= megasas_class_init
;
2542 type_register(&type_info
);
2546 type_init(megasas_register_types
)