qemu/roms/seabios/src/hw/esp-scsi.c

   1 // AMD PCscsi boot support.
   2 //
   3 // Copyright (C) 2012 Red Hat Inc.
   4 //
   5 // Authors:
   6 //  Paolo Bonzini <pbonzini@redhat.com>
   7 //
   8 // based on lsi-scsi.c which is written by:
   9 //  Gerd Hoffman <kraxel@redhat.com>
  10 //
  11 // This file may be distributed under the terms of the GNU LGPLv3 license.
  12
  13 #include "biosvar.h" // GET_GLOBALFLAT
  14 #include "block.h" // struct drive_s
  15 #include "blockcmd.h" // scsi_drive_setup
  16 #include "config.h" // CONFIG_*
  17 #include "fw/paravirt.h" // runningOnQEMU
  18 #include "malloc.h" // free
  19 #include "output.h" // dprintf
  20 #include "pci.h" // foreachpci
  21 #include "pci_ids.h" // PCI_DEVICE_ID
  22 #include "pci_regs.h" // PCI_VENDOR_ID
  23 #include "std/disk.h" // DISK_RET_SUCCESS
  24 #include "string.h" // memset
  25 #include "util.h" // usleep
  26
  27 #define ESP_TCLO      0x00
  28 #define ESP_TCMID     0x04
  29 #define ESP_FIFO      0x08
  30 #define ESP_CMD       0x0c
  31 #define ESP_WBUSID    0x10
  32 #define ESP_TCHI      0x38
  33
  34 #define ESP_RSTAT     0x10
  35 #define ESP_RINTR     0x14
  36 #define ESP_RFLAGS    0x1c
  37
  38 #define ESP_DMA_CMD   0x40
  39 #define ESP_DMA_STC   0x44
  40 #define ESP_DMA_SPA   0x48
  41 #define ESP_DMA_WBC   0x4c
  42 #define ESP_DMA_WAC   0x50
  43 #define ESP_DMA_STAT  0x54
  44 #define ESP_DMA_SMDLA 0x58
  45 #define ESP_DMA_WMAC  0x58c
  46
  47 #define ESP_CMD_DMA      0x80
  48 #define ESP_CMD_RESET    0x02
  49 #define ESP_CMD_TI       0x10
  50 #define ESP_CMD_ICCS     0x11
  51 #define ESP_CMD_SELATN   0x42
  52
  53 #define ESP_STAT_DI      0x01
  54 #define ESP_STAT_CD      0x02
  55 #define ESP_STAT_MSG     0x04
  56 #define ESP_STAT_TC      0x10
  57
  58 #define ESP_INTR_DC      0x20
  59
  60 struct esp_lun_s {
  61     struct drive_s drive;
  62     struct pci_device *pci;
  63     u32 iobase;
  64     u8 target;
  65     u8 lun;
  66 };
  67
  68 static void
  69 esp_scsi_dma(u32 iobase, u32 buf, u32 len, int read)
  70 {
  71     outb(len         & 0xff, iobase + ESP_TCLO);
  72     outb((len >> 8)  & 0xff, iobase + ESP_TCMID);
  73     outb((len >> 16) & 0xff, iobase + ESP_TCHI);
  74     outl(buf,                iobase + ESP_DMA_SPA);
  75     outl(len,                iobase + ESP_DMA_STC);
  76     outb(read ? 0x83 : 0x03, iobase + ESP_DMA_CMD);
  77 }
  78
  79 int
  80 esp_scsi_process_op(struct disk_op_s *op)
  81 {
  82     if (!CONFIG_ESP_SCSI)
  83         return DISK_RET_EBADTRACK;
  84     struct esp_lun_s *llun_gf =
  85         container_of(op->drive_gf, struct esp_lun_s, drive);
  86     u16 target = GET_GLOBALFLAT(llun_gf->target);
  87     u16 lun = GET_GLOBALFLAT(llun_gf->lun);
  88     u8 cdbcmd[16];
  89     int blocksize = scsi_fill_cmd(op, cdbcmd, sizeof(cdbcmd));
  90     if (blocksize < 0)
  91         return default_process_op(op);
  92     u32 iobase = GET_GLOBALFLAT(llun_gf->iobase);
  93     int i, state;
  94     u8 status;
  95
  96     outb(target, iobase + ESP_WBUSID);
  97
  98     /*
  99      * We need to pass the LUN at the beginning of the command, and the FIFO
 100      * is only 16 bytes, so we cannot support 16-byte CDBs.  The alternative
 101      * would be to use DMA for the 17-byte command too, which is quite
 102      * overkill.
 103      */
 104     outb(lun, iobase + ESP_FIFO);
 105     cdbcmd[1] &= 0x1f;
 106     cdbcmd[1] |= lun << 5;
 107     for (i = 0; i < 12; i++)
 108         outb(cdbcmd[i], iobase + ESP_FIFO);
 109     outb(ESP_CMD_SELATN, iobase + ESP_CMD);
 110
 111     for (state = 0;;) {
 112         u8 stat = inb(iobase + ESP_RSTAT);
 113
 114         /* Detect disconnected device.  */
 115         if (state == 0 && (inb(iobase + ESP_RINTR) & ESP_INTR_DC)) {
 116             return DISK_RET_ENOTREADY;
 117         }
 118
 119         /* HBA reads command, clears CD, sets TC -> do DMA if needed.  */
 120         if (state == 0 && (stat & ESP_STAT_TC)) {
 121             state++;
 122             if (op->count && blocksize) {
 123                 /* Data phase.  */
 124                 u32 count = (u32)op->count * blocksize;
 125                 esp_scsi_dma(iobase, (u32)op->buf_fl, count, scsi_is_read(op));
 126                 outb(ESP_CMD_TI | ESP_CMD_DMA, iobase + ESP_CMD);
 127                 continue;
 128             }
 129         }
 130
 131         /* At end of DMA TC is set again -> complete command.  */
 132         if (state == 1 && (stat & ESP_STAT_TC)) {
 133             state++;
 134             outb(ESP_CMD_ICCS, iobase + ESP_CMD);
 135             continue;
 136         }
 137
 138         /* Finally read data from the message in phase.  */
 139         if (state == 2 && (stat & ESP_STAT_MSG)) {
 140             state++;
 141             status = inb(iobase + ESP_FIFO);
 142             inb(iobase + ESP_FIFO);
 143             break;
 144         }
 145         usleep(5);
 146     }
 147
 148     if (status == 0) {
 149         return DISK_RET_SUCCESS;
 150     }
 151
 152     return DISK_RET_EBADTRACK;
 153 }
 154
 155 static int
 156 esp_scsi_add_lun(struct pci_device *pci, u32 iobase, u8 target, u8 lun)
 157 {
 158     struct esp_lun_s *llun = malloc_fseg(sizeof(*llun));
 159     if (!llun) {
 160         warn_noalloc();
 161         return -1;
 162     }
 163     memset(llun, 0, sizeof(*llun));
 164     llun->drive.type = DTYPE_ESP_SCSI;
 165     llun->drive.cntl_id = pci->bdf;
 166     llun->pci = pci;
 167     llun->target = target;
 168     llun->lun = lun;
 169     llun->iobase = iobase;
 170
 171     char *name = znprintf(16, "esp %02x:%02x.%x %d:%d",
 172                           pci_bdf_to_bus(pci->bdf), pci_bdf_to_dev(pci->bdf),
 173                           pci_bdf_to_fn(pci->bdf), target, lun);
 174     int prio = bootprio_find_scsi_device(pci, target, lun);
 175     int ret = scsi_drive_setup(&llun->drive, name, prio);
 176     free(name);
 177     if (ret)
 178         goto fail;
 179     return 0;
 180
 181 fail:
 182     free(llun);
 183     return -1;
 184 }
 185
 186 static void
 187 esp_scsi_scan_target(struct pci_device *pci, u32 iobase, u8 target)
 188 {
 189     esp_scsi_add_lun(pci, iobase, target, 0);
 190 }
 191
 192 static void
 193 init_esp_scsi(struct pci_device *pci)
 194 {
 195     u16 bdf = pci->bdf;
 196     u32 iobase = pci_config_readl(pci->bdf, PCI_BASE_ADDRESS_0)
 197         & PCI_BASE_ADDRESS_IO_MASK;
 198
 199     dprintf(1, "found esp at %02x:%02x.%x, io @ %x\n",
 200             pci_bdf_to_bus(bdf), pci_bdf_to_dev(bdf),
 201             pci_bdf_to_fn(bdf), iobase);
 202
 203     pci_config_maskw(bdf, PCI_COMMAND, 0, PCI_COMMAND_MASTER);
 204
 205     // reset
 206     outb(ESP_CMD_RESET, iobase + ESP_CMD);
 207
 208     int i;
 209     for (i = 0; i <= 7; i++)
 210         esp_scsi_scan_target(pci, iobase, i);
 211
 212     return;
 213 }
 214
 215 void
 216 esp_scsi_setup(void)
 217 {
 218     ASSERT32FLAT();
 219     if (!CONFIG_ESP_SCSI || !runningOnQEMU())
 220         return;
 221
 222     dprintf(3, "init esp\n");
 223
 224     struct pci_device *pci;
 225     foreachpci(pci) {
 226         if (pci->vendor != PCI_VENDOR_ID_AMD
 227             || pci->device != PCI_DEVICE_ID_AMD_SCSI)
 228             continue;
 229         init_esp_scsi(pci);
 230     }
 231 }