| // MPT Fusion boot support. |
| // |
| // Copyright (c) 2012 Verizon, Inc. |
| // Copyright (C) 2016 Paolo Bonzini <pbonzini@redhat.com> |
| // |
| // This file may be distributed under the terms of the GNU LGPLv3 license. |
| |
| #include "biosvar.h" // GET_GLOBALFLAT |
| #include "block.h" // struct drive_s |
| #include "blockcmd.h" // scsi_drive_setup |
| #include "config.h" // CONFIG_* |
| #include "fw/paravirt.h" // runningOnQEMU |
| #include "malloc.h" // free |
| #include "output.h" // dprintf |
| #include "pcidevice.h" // foreachpci |
| #include "pci_ids.h" // PCI_DEVICE_ID |
| #include "pci_regs.h" // PCI_VENDOR_ID |
| #include "stacks.h" // run_thread |
| #include "std/disk.h" // DISK_RET_SUCCESS |
| #include "string.h" // memset |
| #include "util.h" // usleep |
| |
| #define MPT_REG_DOORBELL 0x00 |
| #define MPT_REG_WRITE_SEQ 0x04 |
| #define MPT_REG_HOST_DIAG 0x08 |
| #define MPT_REG_TEST 0x0c |
| #define MPT_REG_DIAG_DATA 0x10 |
| #define MPT_REG_DIAG_ADDR 0x14 |
| #define MPT_REG_ISTATUS 0x30 |
| #define MPT_REG_IMASK 0x34 |
| #define MPT_REG_REQ_Q 0x40 |
| #define MPT_REG_REP_Q 0x44 |
| |
| #define MPT_DOORBELL_MSG_RESET 0x40 |
| #define MPT_DOORBELL_HANDSHAKE 0x42 |
| |
| #define MPT_IMASK_DOORBELL 0x01 |
| #define MPT_IMASK_REPLY 0x08 |
| |
| struct mpt_lun_s { |
| struct drive_s drive; |
| struct pci_device *pci; |
| u32 iobase; |
| u8 target; |
| u8 lun; |
| }; |
| |
| u8 reply_msg[4] __attribute((aligned(4))) VARLOW; |
| |
| #define MPT_MESSAGE_HDR_FUNCTION_SCSI_IO_REQUEST (0x00) |
| #define MPT_MESSAGE_HDR_FUNCTION_IOC_INIT (0x02) |
| |
| static struct MptIOCInitRequest |
| { |
| u8 WhoInit; /* Which system sent this init request. */ |
| u8 Reserved1; /* Reserved */ |
| u8 ChainOffset; /* Chain offset in the SG list. */ |
| u8 Function; /* Function to execute. */ |
| u8 Flags; /* Flags */ |
| u8 MaxDevices; /* Max devices the driver can handle. */ |
| u8 MaxBuses; /* Max buses the driver can handle. */ |
| u8 MessageFlags; /* Message flags. */ |
| u32 MessageContext; /* Message context ID. */ |
| u16 ReplyFrameSize; /* Reply frame size. */ |
| u16 Reserved2; /* Reserved */ |
| u32 HostMfaHighAddr; /* Upper 32bit of the message frames. */ |
| u32 SenseBufferHighAddr; /* Upper 32bit of the sense buffer. */ |
| } MptIOCInitRequest = { |
| .WhoInit = 2, |
| .Function = MPT_MESSAGE_HDR_FUNCTION_IOC_INIT, |
| .MaxDevices = 8, |
| .MaxBuses = 1, |
| .ReplyFrameSize = sizeof(reply_msg), |
| .HostMfaHighAddr = 0, |
| .SenseBufferHighAddr = 0 |
| }; |
| |
| struct MptIOCInitReply { |
| u8 WhoInit; /* Which subsystem sent this init request. */ |
| u8 Reserved1; /* Reserved */ |
| u8 MessageLength; /* Message length */ |
| u8 Function; /* Function. */ |
| u8 Flags; /* Flags */ |
| u8 MaxDevices; /* Maximum number of devices the driver can handle. */ |
| u8 MaxBuses; /* Maximum number of busses the driver can handle. */ |
| u8 MessageFlags; /* Message flags. */ |
| u32 MessageContext; /* Message context ID */ |
| u16 Reserved2; /* Reserved */ |
| u16 IOCStatus; /* IO controller status. */ |
| u32 IOCLogInfo; /* IO controller log information. */ |
| }; |
| |
| typedef struct MptSCSIIORequest { |
| u8 TargetID; /* Target ID */ |
| u8 Bus; /* Bus number */ |
| u8 ChainOffset; /* Chain offset */ |
| u8 Function; /* Function number. */ |
| u8 CDBLength; /* CDB length. */ |
| u8 SenseBufferLength; /* Sense buffer length. */ |
| u8 Reserved; /* Reserved */ |
| u8 MessageFlags; /* Message flags. */ |
| u32 MessageContext; /* Message context ID. */ |
| u8 LUN[8]; /* LUN */ |
| u32 Control; /* Control values. */ |
| u8 CDB[16]; /* The CDB. */ |
| u32 DataLength; /* Data length. */ |
| u32 SenseBufferLowAddr; /* Sense buffer low 32bit address. */ |
| } __attribute__((packed)) MptSCSIIORequest_t; |
| |
| #define MPT_POLL_TIMEOUT 60000 |
| |
| typedef struct MptSGEntrySimple32 { |
| u32 FlagsLength; |
| u32 DataBufferAddressLow; |
| } __attribute__((packed)) MptSGEntrySimple32_t; |
| |
| static int |
| mpt_scsi_cmd(u32 iobase, struct disk_op_s *op, |
| u8 *cdb, u16 target, u16 lun, u16 blocksize) |
| { |
| u32 end = timer_calc(MPT_POLL_TIMEOUT); |
| |
| u8 sense_buf[18]; |
| struct scsi_req { |
| MptSCSIIORequest_t scsi_io; |
| MptSGEntrySimple32_t sge; |
| } __attribute__((packed, aligned(4))) req = { |
| .scsi_io = { |
| .TargetID = target, |
| .Bus = 0, |
| .Function = MPT_MESSAGE_HDR_FUNCTION_SCSI_IO_REQUEST, |
| .CDBLength = 16, |
| .SenseBufferLength = 18, |
| .MessageContext = end & 0x7fffffff, |
| .DataLength = op->count * blocksize, |
| .SenseBufferLowAddr = (u32)MAKE_FLATPTR(GET_SEG(SS), &sense_buf[0]), |
| }, |
| .sge = { |
| /* end of list, simple entry, end of buffer, last element */ |
| .FlagsLength = (op->count * blocksize) | 0xD1000000, |
| .DataBufferAddressLow = (u32)op->buf_fl, |
| } |
| }; |
| |
| req.scsi_io.LUN[1] = lun; |
| memcpy(req.scsi_io.CDB, cdb, 16); |
| if (blocksize) { |
| if (scsi_is_read(op)) { |
| req.scsi_io.Control = 2 << 24; |
| } else { |
| req.scsi_io.Control = 1 << 24; |
| req.sge.FlagsLength |= 0x04000000; |
| } |
| } |
| |
| outl((u32)MAKE_FLATPTR(GET_SEG(SS), &req), iobase + MPT_REG_REQ_Q); |
| |
| for (;;) { |
| if (timer_check(end)) { |
| return DISK_RET_ETIMEOUT; |
| } |
| |
| u32 istatus = inl(iobase + MPT_REG_ISTATUS); |
| if (istatus & MPT_IMASK_REPLY) { |
| u32 resp = inl(iobase + MPT_REG_REP_Q); |
| /* another read to turn interrupt off */ |
| inl(iobase + MPT_REG_REP_Q); |
| if (resp == req.scsi_io.MessageContext) { |
| return DISK_RET_SUCCESS; |
| } else if (resp & 0x80000000) { |
| outl((u32)&reply_msg[0], iobase + MPT_REG_REP_Q); |
| return DISK_RET_EBADTRACK; |
| } |
| } |
| usleep(50); |
| } |
| } |
| |
| int |
| mpt_scsi_process_op(struct disk_op_s *op) |
| { |
| if (!CONFIG_MPT_SCSI) |
| return DISK_RET_EBADTRACK; |
| |
| u8 cdbcmd[16]; |
| int blocksize = scsi_fill_cmd(op, cdbcmd, sizeof(cdbcmd)); |
| if (blocksize < 0) |
| return default_process_op(op); |
| |
| struct mpt_lun_s *llun_gf = |
| container_of(op->drive_fl, struct mpt_lun_s, drive); |
| u16 target = GET_GLOBALFLAT(llun_gf->target); |
| u16 lun = GET_GLOBALFLAT(llun_gf->lun); |
| u32 iobase = GET_GLOBALFLAT(llun_gf->iobase); |
| return mpt_scsi_cmd(iobase, op, cdbcmd, target, lun, blocksize); |
| } |
| |
| static void |
| mpt_scsi_init_lun(struct mpt_lun_s *llun, struct pci_device *pci, |
| u32 iobase, u8 target, u8 lun) |
| { |
| memset(llun, 0, sizeof(*llun)); |
| llun->drive.type = DTYPE_MPT_SCSI; |
| llun->drive.cntl_id = pci->bdf; |
| llun->pci = pci; |
| llun->target = target; |
| llun->lun = lun; |
| llun->iobase = iobase; |
| } |
| |
| static int |
| mpt_scsi_add_lun(u32 lun, struct drive_s *tmpl_drv) |
| { |
| struct mpt_lun_s *tmpl_llun = |
| container_of(tmpl_drv, struct mpt_lun_s, drive); |
| struct mpt_lun_s *llun = malloc_fseg(sizeof(*llun)); |
| if (!llun) { |
| warn_noalloc(); |
| return -1; |
| } |
| mpt_scsi_init_lun(llun, tmpl_llun->pci, tmpl_llun->iobase, |
| tmpl_llun->target, lun); |
| |
| char *name = znprintf(MAXDESCSIZE, "mpt %pP %d:%d", |
| llun->pci, llun->target, llun->lun); |
| int prio = bootprio_find_scsi_device(llun->pci, llun->target, llun->lun); |
| int ret = scsi_drive_setup(&llun->drive, name, prio); |
| free(name); |
| if (ret) { |
| goto fail; |
| } |
| return 0; |
| |
| fail: |
| free(llun); |
| return -1; |
| } |
| |
| static void |
| mpt_scsi_scan_target(struct pci_device *pci, u32 iobase, u8 target) |
| { |
| struct mpt_lun_s llun0; |
| |
| mpt_scsi_init_lun(&llun0, pci, iobase, target, 0); |
| |
| if (scsi_rep_luns_scan(&llun0.drive, mpt_scsi_add_lun) < 0) |
| scsi_sequential_scan(&llun0.drive, 8, mpt_scsi_add_lun); |
| } |
| |
| static inline void |
| mpt_out_doorbell(u8 func, u8 arg, u16 iobase) |
| { |
| outl((func << 24) | (arg << 16), iobase + MPT_REG_DOORBELL); |
| } |
| |
| static void |
| init_mpt_scsi(void *data) |
| { |
| struct pci_device *pci = data; |
| u16 *msg_in_p; |
| u32 iobase = pci_enable_iobar(pci, PCI_BASE_ADDRESS_0); |
| if (!iobase) |
| return; |
| struct MptIOCInitReply MptIOCInitReply; |
| pci_enable_busmaster(pci); |
| |
| dprintf(1, "found mpt-scsi(%04x) at %pP, io @ %x\n" |
| , pci->device, pci, iobase); |
| |
| // reset |
| mpt_out_doorbell(MPT_DOORBELL_MSG_RESET, 0, iobase); |
| outl(MPT_IMASK_DOORBELL|MPT_IMASK_REPLY , iobase + MPT_REG_IMASK); |
| outl(0, iobase + MPT_REG_ISTATUS); |
| |
| // send IOC Init message through the doorbell |
| mpt_out_doorbell(MPT_DOORBELL_HANDSHAKE, |
| sizeof(MptIOCInitRequest)/sizeof(u32), |
| iobase); |
| |
| outsl(iobase + MPT_REG_DOORBELL, |
| (u32 *)&MptIOCInitRequest, |
| sizeof(MptIOCInitRequest)/sizeof(u32)); |
| |
| // Read the reply 16 bits at a time. Cannot use insl |
| // because the port is 32 bits wide. |
| msg_in_p = (u16 *)&MptIOCInitReply; |
| while(msg_in_p != (u16 *)(&MptIOCInitReply + 1)) |
| *msg_in_p++ = (u16)inl(iobase + MPT_REG_DOORBELL); |
| |
| // Eat doorbell interrupt |
| outl(0, iobase + MPT_REG_ISTATUS); |
| |
| // Post reply message used for SCSI errors |
| outl((u32)&reply_msg[0], iobase + MPT_REG_REP_Q); |
| |
| int i; |
| for (i = 0; i < 7; i++) |
| mpt_scsi_scan_target(pci, iobase, i); |
| } |
| |
| void |
| mpt_scsi_setup(void) |
| { |
| ASSERT32FLAT(); |
| if (!CONFIG_MPT_SCSI || !runningOnQEMU()) { |
| return; |
| } |
| |
| dprintf(3, "init MPT\n"); |
| |
| struct pci_device *pci; |
| foreachpci(pci) { |
| if (pci->vendor == PCI_VENDOR_ID_LSI_LOGIC |
| && (pci->device == PCI_DEVICE_ID_LSI_53C1030 |
| || pci->device == PCI_DEVICE_ID_LSI_SAS1068 |
| || pci->device == PCI_DEVICE_ID_LSI_SAS1068E)) |
| run_thread(init_mpt_scsi, pci); |
| } |
| } |
