Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 1 | // Low level AHCI disk access |
| 2 | // |
| 3 | // Copyright (C) 2010 Gerd Hoffmann <kraxel@redhat.com> |
| 4 | // |
| 5 | // This file may be distributed under the terms of the GNU LGPLv3 license. |
| 6 | |
| 7 | #include "types.h" // u8 |
| 8 | #include "ioport.h" // inb |
| 9 | #include "util.h" // dprintf |
Kevin O'Connor | 4bc4997 | 2012-05-13 22:58:08 -0400 | [diff] [blame] | 10 | #include "biosvar.h" // GET_GLOBAL |
Kevin O'Connor | 9cb4992 | 2011-06-20 22:22:42 -0400 | [diff] [blame] | 11 | #include "pci.h" // foreachpci |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 12 | #include "pci_ids.h" // PCI_CLASS_STORAGE_OTHER |
| 13 | #include "pci_regs.h" // PCI_INTERRUPT_LINE |
| 14 | #include "boot.h" // add_bcv_hd |
| 15 | #include "disk.h" // struct ata_s |
| 16 | #include "ata.h" // ATA_CB_STAT |
| 17 | #include "ahci.h" // CDB_CMD_READ_10 |
| 18 | #include "blockcmd.h" // CDB_CMD_READ_10 |
| 19 | |
Gerd Hoffmann | e104119 | 2011-07-14 16:24:04 +0200 | [diff] [blame] | 20 | #define AHCI_REQUEST_TIMEOUT 32000 // 32 seconds max for IDE ops |
| 21 | #define AHCI_RESET_TIMEOUT 500 // 500 miliseconds |
| 22 | #define AHCI_LINK_TIMEOUT 10 // 10 miliseconds |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 23 | |
| 24 | /**************************************************************** |
| 25 | * these bits must run in both 16bit and 32bit modes |
| 26 | ****************************************************************/ |
| 27 | |
| 28 | // prepare sata command fis |
| 29 | static void sata_prep_simple(struct sata_cmd_fis *fis, u8 command) |
| 30 | { |
| 31 | memset_fl(fis, 0, sizeof(*fis)); |
Kevin O'Connor | 890c085 | 2012-05-24 23:55:00 -0400 | [diff] [blame^] | 32 | SET_LOWFLAT(fis->command, command); |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 33 | } |
| 34 | |
| 35 | static void sata_prep_readwrite(struct sata_cmd_fis *fis, |
| 36 | struct disk_op_s *op, int iswrite) |
| 37 | { |
| 38 | u64 lba = op->lba; |
| 39 | u8 command; |
| 40 | |
| 41 | memset_fl(fis, 0, sizeof(*fis)); |
| 42 | |
| 43 | if (op->count >= (1<<8) || lba + op->count >= (1<<28)) { |
Kevin O'Connor | 890c085 | 2012-05-24 23:55:00 -0400 | [diff] [blame^] | 44 | SET_LOWFLAT(fis->sector_count2, op->count >> 8); |
| 45 | SET_LOWFLAT(fis->lba_low2, lba >> 24); |
| 46 | SET_LOWFLAT(fis->lba_mid2, lba >> 32); |
| 47 | SET_LOWFLAT(fis->lba_high2, lba >> 40); |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 48 | lba &= 0xffffff; |
| 49 | command = (iswrite ? ATA_CMD_WRITE_DMA_EXT |
| 50 | : ATA_CMD_READ_DMA_EXT); |
| 51 | } else { |
| 52 | command = (iswrite ? ATA_CMD_WRITE_DMA |
| 53 | : ATA_CMD_READ_DMA); |
| 54 | } |
Kevin O'Connor | 890c085 | 2012-05-24 23:55:00 -0400 | [diff] [blame^] | 55 | SET_LOWFLAT(fis->feature, 1); /* dma */ |
| 56 | SET_LOWFLAT(fis->command, command); |
| 57 | SET_LOWFLAT(fis->sector_count, op->count); |
| 58 | SET_LOWFLAT(fis->lba_low, lba); |
| 59 | SET_LOWFLAT(fis->lba_mid, lba >> 8); |
| 60 | SET_LOWFLAT(fis->lba_high, lba >> 16); |
| 61 | SET_LOWFLAT(fis->device, ((lba >> 24) & 0xf) | ATA_CB_DH_LBA); |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 62 | } |
| 63 | |
| 64 | static void sata_prep_atapi(struct sata_cmd_fis *fis, u16 blocksize) |
| 65 | { |
| 66 | memset_fl(fis, 0, sizeof(*fis)); |
Kevin O'Connor | 890c085 | 2012-05-24 23:55:00 -0400 | [diff] [blame^] | 67 | SET_LOWFLAT(fis->command, ATA_CMD_PACKET); |
| 68 | SET_LOWFLAT(fis->feature, 1); /* dma */ |
| 69 | SET_LOWFLAT(fis->lba_mid, blocksize); |
| 70 | SET_LOWFLAT(fis->lba_high, blocksize >> 8); |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 71 | } |
| 72 | |
| 73 | // ahci register access helpers |
| 74 | static u32 ahci_ctrl_readl(struct ahci_ctrl_s *ctrl, u32 reg) |
| 75 | { |
| 76 | u32 addr = GET_GLOBALFLAT(ctrl->iobase) + reg; |
| 77 | return pci_readl(addr); |
| 78 | } |
| 79 | |
| 80 | static void ahci_ctrl_writel(struct ahci_ctrl_s *ctrl, u32 reg, u32 val) |
| 81 | { |
| 82 | u32 addr = GET_GLOBALFLAT(ctrl->iobase) + reg; |
| 83 | pci_writel(addr, val); |
| 84 | } |
| 85 | |
| 86 | static u32 ahci_port_to_ctrl(u32 pnr, u32 port_reg) |
| 87 | { |
| 88 | u32 ctrl_reg = 0x100; |
| 89 | ctrl_reg += pnr * 0x80; |
| 90 | ctrl_reg += port_reg; |
| 91 | return ctrl_reg; |
| 92 | } |
| 93 | |
| 94 | static u32 ahci_port_readl(struct ahci_ctrl_s *ctrl, u32 pnr, u32 reg) |
| 95 | { |
| 96 | u32 ctrl_reg = ahci_port_to_ctrl(pnr, reg); |
| 97 | return ahci_ctrl_readl(ctrl, ctrl_reg); |
| 98 | } |
| 99 | |
| 100 | static void ahci_port_writel(struct ahci_ctrl_s *ctrl, u32 pnr, u32 reg, u32 val) |
| 101 | { |
| 102 | u32 ctrl_reg = ahci_port_to_ctrl(pnr, reg); |
| 103 | ahci_ctrl_writel(ctrl, ctrl_reg, val); |
| 104 | } |
| 105 | |
| 106 | // submit ahci command + wait for result |
| 107 | static int ahci_command(struct ahci_port_s *port, int iswrite, int isatapi, |
| 108 | void *buffer, u32 bsize) |
| 109 | { |
Gerd Hoffmann | 6f85049 | 2011-07-14 16:24:01 +0200 | [diff] [blame] | 110 | u32 val, status, success, flags, intbits, error; |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 111 | struct ahci_ctrl_s *ctrl = GET_GLOBAL(port->ctrl); |
| 112 | struct ahci_cmd_s *cmd = GET_GLOBAL(port->cmd); |
| 113 | struct ahci_fis_s *fis = GET_GLOBAL(port->fis); |
| 114 | struct ahci_list_s *list = GET_GLOBAL(port->list); |
| 115 | u32 pnr = GET_GLOBAL(port->pnr); |
Gerd Hoffmann | e104119 | 2011-07-14 16:24:04 +0200 | [diff] [blame] | 116 | u64 end; |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 117 | |
Kevin O'Connor | 890c085 | 2012-05-24 23:55:00 -0400 | [diff] [blame^] | 118 | SET_LOWFLAT(cmd->fis.reg, 0x27); |
| 119 | SET_LOWFLAT(cmd->fis.pmp_type, (1 << 7)); /* cmd fis */ |
| 120 | SET_LOWFLAT(cmd->prdt[0].base, ((u32)buffer)); |
| 121 | SET_LOWFLAT(cmd->prdt[0].baseu, 0); |
| 122 | SET_LOWFLAT(cmd->prdt[0].flags, bsize-1); |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 123 | |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 124 | flags = ((1 << 16) | /* one prd entry */ |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 125 | (iswrite ? (1 << 6) : 0) | |
| 126 | (isatapi ? (1 << 5) : 0) | |
Gerd Hoffmann | a8c6a4e | 2011-07-14 16:23:59 +0200 | [diff] [blame] | 127 | (5 << 0)); /* fis length (dwords) */ |
Kevin O'Connor | 890c085 | 2012-05-24 23:55:00 -0400 | [diff] [blame^] | 128 | SET_LOWFLAT(list[0].flags, flags); |
| 129 | SET_LOWFLAT(list[0].bytes, 0); |
| 130 | SET_LOWFLAT(list[0].base, ((u32)(cmd))); |
| 131 | SET_LOWFLAT(list[0].baseu, 0); |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 132 | |
Kevin O'Connor | bf079e1 | 2012-03-11 11:19:52 -0400 | [diff] [blame] | 133 | dprintf(8, "AHCI/%d: send cmd ...\n", pnr); |
Gerd Hoffmann | 0753297 | 2011-07-14 16:24:00 +0200 | [diff] [blame] | 134 | intbits = ahci_port_readl(ctrl, pnr, PORT_IRQ_STAT); |
| 135 | if (intbits) |
| 136 | ahci_port_writel(ctrl, pnr, PORT_IRQ_STAT, intbits); |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 137 | ahci_port_writel(ctrl, pnr, PORT_SCR_ACT, 1); |
| 138 | ahci_port_writel(ctrl, pnr, PORT_CMD_ISSUE, 1); |
Gerd Hoffmann | 0753297 | 2011-07-14 16:24:00 +0200 | [diff] [blame] | 139 | |
Gerd Hoffmann | e104119 | 2011-07-14 16:24:04 +0200 | [diff] [blame] | 140 | end = calc_future_tsc(AHCI_REQUEST_TIMEOUT); |
Gerd Hoffmann | 0753297 | 2011-07-14 16:24:00 +0200 | [diff] [blame] | 141 | do { |
| 142 | for (;;) { |
| 143 | intbits = ahci_port_readl(ctrl, pnr, PORT_IRQ_STAT); |
| 144 | if (intbits) { |
| 145 | ahci_port_writel(ctrl, pnr, PORT_IRQ_STAT, intbits); |
| 146 | if (intbits & 0x02) { |
Kevin O'Connor | 890c085 | 2012-05-24 23:55:00 -0400 | [diff] [blame^] | 147 | status = GET_LOWFLAT(fis->psfis[2]); |
| 148 | error = GET_LOWFLAT(fis->psfis[3]); |
Gerd Hoffmann | 0753297 | 2011-07-14 16:24:00 +0200 | [diff] [blame] | 149 | break; |
| 150 | } |
| 151 | if (intbits & 0x01) { |
Kevin O'Connor | 890c085 | 2012-05-24 23:55:00 -0400 | [diff] [blame^] | 152 | status = GET_LOWFLAT(fis->rfis[2]); |
| 153 | error = GET_LOWFLAT(fis->rfis[3]); |
Gerd Hoffmann | 0753297 | 2011-07-14 16:24:00 +0200 | [diff] [blame] | 154 | break; |
| 155 | } |
| 156 | } |
Gerd Hoffmann | e104119 | 2011-07-14 16:24:04 +0200 | [diff] [blame] | 157 | if (check_tsc(end)) { |
| 158 | warn_timeout(); |
| 159 | return -1; |
| 160 | } |
Gerd Hoffmann | 0753297 | 2011-07-14 16:24:00 +0200 | [diff] [blame] | 161 | yield(); |
| 162 | } |
Kevin O'Connor | bf079e1 | 2012-03-11 11:19:52 -0400 | [diff] [blame] | 163 | dprintf(8, "AHCI/%d: ... intbits 0x%x, status 0x%x ...\n", |
Gerd Hoffmann | 0753297 | 2011-07-14 16:24:00 +0200 | [diff] [blame] | 164 | pnr, intbits, status); |
| 165 | } while (status & ATA_CB_STAT_BSY); |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 166 | |
| 167 | success = (0x00 == (status & (ATA_CB_STAT_BSY | ATA_CB_STAT_DF | |
Gerd Hoffmann | cbda795 | 2011-07-14 16:24:03 +0200 | [diff] [blame] | 168 | ATA_CB_STAT_ERR)) && |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 169 | ATA_CB_STAT_RDY == (status & (ATA_CB_STAT_RDY))); |
Gerd Hoffmann | 6f85049 | 2011-07-14 16:24:01 +0200 | [diff] [blame] | 170 | if (success) { |
Kevin O'Connor | bf079e1 | 2012-03-11 11:19:52 -0400 | [diff] [blame] | 171 | dprintf(8, "AHCI/%d: ... finished, status 0x%x, OK\n", pnr, |
Gerd Hoffmann | 6f85049 | 2011-07-14 16:24:01 +0200 | [diff] [blame] | 172 | status); |
| 173 | } else { |
| 174 | dprintf(2, "AHCI/%d: ... finished, status 0x%x, ERROR 0x%x\n", pnr, |
| 175 | status, error); |
| 176 | |
| 177 | // non-queued error recovery (AHCI 1.3 section 6.2.2.1) |
| 178 | // Clears PxCMD.ST to 0 to reset the PxCI register |
| 179 | val = ahci_port_readl(ctrl, pnr, PORT_CMD); |
| 180 | ahci_port_writel(ctrl, pnr, PORT_CMD, val & ~PORT_CMD_START); |
| 181 | |
| 182 | // waits for PxCMD.CR to clear to 0 |
| 183 | while (1) { |
| 184 | val = ahci_port_readl(ctrl, pnr, PORT_CMD); |
| 185 | if ((val & PORT_CMD_LIST_ON) == 0) |
| 186 | break; |
| 187 | yield(); |
| 188 | } |
| 189 | |
| 190 | // Clears any error bits in PxSERR to enable capturing new errors |
| 191 | val = ahci_port_readl(ctrl, pnr, PORT_SCR_ERR); |
| 192 | ahci_port_writel(ctrl, pnr, PORT_SCR_ERR, val); |
| 193 | |
| 194 | // Clears status bits in PxIS as appropriate |
| 195 | val = ahci_port_readl(ctrl, pnr, PORT_IRQ_STAT); |
| 196 | ahci_port_writel(ctrl, pnr, PORT_IRQ_STAT, val); |
| 197 | |
| 198 | // If PxTFD.STS.BSY or PxTFD.STS.DRQ is set to 1, issue |
| 199 | // a COMRESET to the device to put it in an idle state |
| 200 | val = ahci_port_readl(ctrl, pnr, PORT_TFDATA); |
| 201 | if (val & (ATA_CB_STAT_BSY | ATA_CB_STAT_DRQ)) { |
| 202 | dprintf(2, "AHCI/%d: issue comreset\n", pnr); |
| 203 | val = ahci_port_readl(ctrl, pnr, PORT_SCR_CTL); |
| 204 | // set Device Detection Initialization (DET) to 1 for 1 ms for comreset |
| 205 | ahci_port_writel(ctrl, pnr, PORT_SCR_CTL, val | 1); |
| 206 | mdelay (1); |
| 207 | ahci_port_writel(ctrl, pnr, PORT_SCR_CTL, val); |
| 208 | } |
| 209 | |
| 210 | // Sets PxCMD.ST to 1 to enable issuing new commands |
| 211 | val = ahci_port_readl(ctrl, pnr, PORT_CMD); |
| 212 | ahci_port_writel(ctrl, pnr, PORT_CMD, val | PORT_CMD_START); |
| 213 | } |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 214 | return success ? 0 : -1; |
| 215 | } |
| 216 | |
| 217 | #define CDROM_CDB_SIZE 12 |
| 218 | |
| 219 | int ahci_cmd_data(struct disk_op_s *op, void *cdbcmd, u16 blocksize) |
| 220 | { |
Kevin O'Connor | 80c2b6e | 2010-12-05 12:52:02 -0500 | [diff] [blame] | 221 | if (! CONFIG_AHCI) |
| 222 | return 0; |
| 223 | |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 224 | struct ahci_port_s *port = container_of( |
| 225 | op->drive_g, struct ahci_port_s, drive); |
| 226 | struct ahci_cmd_s *cmd = GET_GLOBAL(port->cmd); |
| 227 | u8 *atapi = cdbcmd; |
| 228 | int i, rc; |
| 229 | |
| 230 | sata_prep_atapi(&cmd->fis, blocksize); |
| 231 | for (i = 0; i < CDROM_CDB_SIZE; i++) { |
Kevin O'Connor | 890c085 | 2012-05-24 23:55:00 -0400 | [diff] [blame^] | 232 | SET_LOWFLAT(cmd->atapi[i], atapi[i]); |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 233 | } |
| 234 | rc = ahci_command(port, 0, 1, op->buf_fl, |
| 235 | op->count * blocksize); |
| 236 | if (rc < 0) |
| 237 | return DISK_RET_EBADTRACK; |
| 238 | return DISK_RET_SUCCESS; |
| 239 | } |
| 240 | |
Scott Duplichan | 9c48aab | 2011-07-14 16:24:02 +0200 | [diff] [blame] | 241 | // read/write count blocks from a harddrive, op->buf_fl must be word aligned |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 242 | static int |
Scott Duplichan | 9c48aab | 2011-07-14 16:24:02 +0200 | [diff] [blame] | 243 | ahci_disk_readwrite_aligned(struct disk_op_s *op, int iswrite) |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 244 | { |
| 245 | struct ahci_port_s *port = container_of( |
| 246 | op->drive_g, struct ahci_port_s, drive); |
| 247 | struct ahci_cmd_s *cmd = GET_GLOBAL(port->cmd); |
| 248 | int rc; |
| 249 | |
| 250 | sata_prep_readwrite(&cmd->fis, op, iswrite); |
| 251 | rc = ahci_command(port, iswrite, 0, op->buf_fl, |
| 252 | op->count * DISK_SECTOR_SIZE); |
Kevin O'Connor | bf079e1 | 2012-03-11 11:19:52 -0400 | [diff] [blame] | 253 | dprintf(8, "ahci disk %s, lba %6x, count %3x, buf %p, rc %d\n", |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 254 | iswrite ? "write" : "read", (u32)op->lba, op->count, op->buf_fl, rc); |
| 255 | if (rc < 0) |
| 256 | return DISK_RET_EBADTRACK; |
| 257 | return DISK_RET_SUCCESS; |
| 258 | } |
| 259 | |
Scott Duplichan | 9c48aab | 2011-07-14 16:24:02 +0200 | [diff] [blame] | 260 | // read/write count blocks from a harddrive. |
| 261 | static int |
| 262 | ahci_disk_readwrite(struct disk_op_s *op, int iswrite) |
| 263 | { |
| 264 | // if caller's buffer is word aligned, use it directly |
| 265 | if (((u32) op->buf_fl & 1) == 0) |
| 266 | return ahci_disk_readwrite_aligned(op, iswrite); |
| 267 | |
| 268 | // Use a word aligned buffer for AHCI I/O |
| 269 | int rc; |
| 270 | struct disk_op_s localop = *op; |
Gerd Hoffmann | d7a7cf3 | 2011-08-04 19:36:27 +0200 | [diff] [blame] | 271 | u8 *alignedbuf_fl = GET_GLOBAL(bounce_buf_fl); |
Scott Duplichan | 9c48aab | 2011-07-14 16:24:02 +0200 | [diff] [blame] | 272 | u8 *position = op->buf_fl; |
| 273 | |
| 274 | localop.buf_fl = alignedbuf_fl; |
| 275 | localop.count = 1; |
| 276 | |
| 277 | if (iswrite) { |
| 278 | u16 block; |
| 279 | for (block = 0; block < op->count; block++) { |
| 280 | memcpy_fl (alignedbuf_fl, position, DISK_SECTOR_SIZE); |
| 281 | rc = ahci_disk_readwrite_aligned (&localop, 1); |
| 282 | if (rc) |
| 283 | return rc; |
| 284 | position += DISK_SECTOR_SIZE; |
| 285 | localop.lba++; |
| 286 | } |
| 287 | } else { // read |
| 288 | u16 block; |
| 289 | for (block = 0; block < op->count; block++) { |
| 290 | rc = ahci_disk_readwrite_aligned (&localop, 0); |
| 291 | if (rc) |
| 292 | return rc; |
| 293 | memcpy_fl (position, alignedbuf_fl, DISK_SECTOR_SIZE); |
| 294 | position += DISK_SECTOR_SIZE; |
| 295 | localop.lba++; |
| 296 | } |
| 297 | } |
| 298 | return DISK_RET_SUCCESS; |
| 299 | } |
| 300 | |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 301 | // command demuxer |
| 302 | int process_ahci_op(struct disk_op_s *op) |
| 303 | { |
| 304 | struct ahci_port_s *port; |
| 305 | u32 atapi; |
| 306 | |
| 307 | if (!CONFIG_AHCI) |
| 308 | return 0; |
| 309 | |
| 310 | port = container_of(op->drive_g, struct ahci_port_s, drive); |
| 311 | atapi = GET_GLOBAL(port->atapi); |
| 312 | |
| 313 | if (atapi) { |
| 314 | switch (op->command) { |
| 315 | case CMD_READ: |
| 316 | return cdb_read(op); |
| 317 | case CMD_WRITE: |
| 318 | case CMD_FORMAT: |
| 319 | return DISK_RET_EWRITEPROTECT; |
| 320 | case CMD_RESET: |
| 321 | /* FIXME: what should we do here? */ |
| 322 | case CMD_VERIFY: |
| 323 | case CMD_SEEK: |
| 324 | return DISK_RET_SUCCESS; |
| 325 | default: |
| 326 | dprintf(1, "AHCI: unknown cdrom command %d\n", op->command); |
| 327 | op->count = 0; |
| 328 | return DISK_RET_EPARAM; |
| 329 | } |
| 330 | } else { |
| 331 | switch (op->command) { |
| 332 | case CMD_READ: |
| 333 | return ahci_disk_readwrite(op, 0); |
| 334 | case CMD_WRITE: |
| 335 | return ahci_disk_readwrite(op, 1); |
| 336 | case CMD_RESET: |
| 337 | /* FIXME: what should we do here? */ |
| 338 | case CMD_FORMAT: |
| 339 | case CMD_VERIFY: |
| 340 | case CMD_SEEK: |
| 341 | return DISK_RET_SUCCESS; |
| 342 | default: |
| 343 | dprintf(1, "AHCI: unknown disk command %d\n", op->command); |
| 344 | op->count = 0; |
| 345 | return DISK_RET_EPARAM; |
| 346 | } |
| 347 | } |
| 348 | } |
| 349 | |
| 350 | /**************************************************************** |
| 351 | * everything below is pure 32bit code |
| 352 | ****************************************************************/ |
| 353 | |
| 354 | static void |
| 355 | ahci_port_reset(struct ahci_ctrl_s *ctrl, u32 pnr) |
| 356 | { |
Gerd Hoffmann | e104119 | 2011-07-14 16:24:04 +0200 | [diff] [blame] | 357 | u32 val; |
| 358 | u64 end; |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 359 | |
| 360 | /* disable FIS + CMD */ |
Gerd Hoffmann | e104119 | 2011-07-14 16:24:04 +0200 | [diff] [blame] | 361 | end = calc_future_tsc(AHCI_RESET_TIMEOUT); |
| 362 | for (;;) { |
| 363 | val = ahci_port_readl(ctrl, pnr, PORT_CMD); |
| 364 | if (!(val & (PORT_CMD_FIS_RX | PORT_CMD_START | |
| 365 | PORT_CMD_FIS_ON | PORT_CMD_LIST_ON))) |
| 366 | break; |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 367 | val &= ~(PORT_CMD_FIS_RX | PORT_CMD_START); |
| 368 | ahci_port_writel(ctrl, pnr, PORT_CMD, val); |
Gerd Hoffmann | e104119 | 2011-07-14 16:24:04 +0200 | [diff] [blame] | 369 | if (check_tsc(end)) { |
| 370 | warn_timeout(); |
| 371 | break; |
| 372 | } |
| 373 | yield(); |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 374 | } |
| 375 | |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 376 | /* disable + clear IRQs */ |
Gerd Hoffmann | e104119 | 2011-07-14 16:24:04 +0200 | [diff] [blame] | 377 | ahci_port_writel(ctrl, pnr, PORT_IRQ_MASK, 0); |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 378 | val = ahci_port_readl(ctrl, pnr, PORT_IRQ_STAT); |
| 379 | if (val) |
| 380 | ahci_port_writel(ctrl, pnr, PORT_IRQ_STAT, val); |
| 381 | } |
| 382 | |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 383 | static struct ahci_port_s* |
Gerd Hoffmann | e104119 | 2011-07-14 16:24:04 +0200 | [diff] [blame] | 384 | ahci_port_alloc(struct ahci_ctrl_s *ctrl, u32 pnr) |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 385 | { |
Gerd Hoffmann | ef8adc0 | 2011-08-04 19:36:31 +0200 | [diff] [blame] | 386 | struct ahci_port_s *port = malloc_tmp(sizeof(*port)); |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 387 | |
| 388 | if (!port) { |
| 389 | warn_noalloc(); |
| 390 | return NULL; |
| 391 | } |
| 392 | port->pnr = pnr; |
| 393 | port->ctrl = ctrl; |
Gerd Hoffmann | e104119 | 2011-07-14 16:24:04 +0200 | [diff] [blame] | 394 | port->list = memalign_tmp(1024, 1024); |
| 395 | port->fis = memalign_tmp(256, 256); |
| 396 | port->cmd = memalign_tmp(256, 256); |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 397 | if (port->list == NULL || port->fis == NULL || port->cmd == NULL) { |
| 398 | warn_noalloc(); |
| 399 | return NULL; |
| 400 | } |
| 401 | memset(port->list, 0, 1024); |
| 402 | memset(port->fis, 0, 256); |
| 403 | memset(port->cmd, 0, 256); |
| 404 | |
| 405 | ahci_port_writel(ctrl, pnr, PORT_LST_ADDR, (u32)port->list); |
| 406 | ahci_port_writel(ctrl, pnr, PORT_FIS_ADDR, (u32)port->fis); |
Gerd Hoffmann | e104119 | 2011-07-14 16:24:04 +0200 | [diff] [blame] | 407 | return port; |
| 408 | } |
| 409 | |
Gerd Hoffmann | ef8adc0 | 2011-08-04 19:36:31 +0200 | [diff] [blame] | 410 | static struct ahci_port_s* ahci_port_realloc(struct ahci_port_s *port) |
Gerd Hoffmann | e104119 | 2011-07-14 16:24:04 +0200 | [diff] [blame] | 411 | { |
Gerd Hoffmann | ef8adc0 | 2011-08-04 19:36:31 +0200 | [diff] [blame] | 412 | struct ahci_port_s *tmp; |
Gerd Hoffmann | e104119 | 2011-07-14 16:24:04 +0200 | [diff] [blame] | 413 | u32 cmd; |
| 414 | |
Gerd Hoffmann | ef8adc0 | 2011-08-04 19:36:31 +0200 | [diff] [blame] | 415 | tmp = malloc_fseg(sizeof(*port)); |
| 416 | *tmp = *port; |
| 417 | free(port); |
| 418 | port = tmp; |
| 419 | |
Gerd Hoffmann | e104119 | 2011-07-14 16:24:04 +0200 | [diff] [blame] | 420 | ahci_port_reset(port->ctrl, port->pnr); |
| 421 | |
| 422 | free(port->list); |
| 423 | free(port->fis); |
| 424 | free(port->cmd); |
| 425 | port->list = memalign_low(1024, 1024); |
| 426 | port->fis = memalign_low(256, 256); |
| 427 | port->cmd = memalign_low(256, 256); |
| 428 | |
| 429 | ahci_port_writel(port->ctrl, port->pnr, PORT_LST_ADDR, (u32)port->list); |
| 430 | ahci_port_writel(port->ctrl, port->pnr, PORT_FIS_ADDR, (u32)port->fis); |
| 431 | |
| 432 | cmd = ahci_port_readl(port->ctrl, port->pnr, PORT_CMD); |
| 433 | cmd |= (PORT_CMD_FIS_RX|PORT_CMD_START); |
| 434 | ahci_port_writel(port->ctrl, port->pnr, PORT_CMD, cmd); |
Gerd Hoffmann | ef8adc0 | 2011-08-04 19:36:31 +0200 | [diff] [blame] | 435 | |
| 436 | return port; |
Gerd Hoffmann | e104119 | 2011-07-14 16:24:04 +0200 | [diff] [blame] | 437 | } |
| 438 | |
| 439 | static void ahci_port_release(struct ahci_port_s *port) |
| 440 | { |
| 441 | ahci_port_reset(port->ctrl, port->pnr); |
| 442 | free(port->list); |
| 443 | free(port->fis); |
| 444 | free(port->cmd); |
| 445 | free(port); |
| 446 | } |
| 447 | |
| 448 | #define MAXMODEL 40 |
| 449 | |
| 450 | /* See ahci spec chapter 10.1 "Software Initialization of HBA" */ |
| 451 | static int ahci_port_init(struct ahci_port_s *port) |
| 452 | { |
| 453 | struct ahci_ctrl_s *ctrl = port->ctrl; |
| 454 | u32 pnr = port->pnr; |
| 455 | char model[MAXMODEL+1]; |
| 456 | u16 buffer[256]; |
| 457 | u32 cmd, stat, err, tf; |
| 458 | u64 end; |
| 459 | int rc; |
| 460 | |
| 461 | /* enable FIS recv */ |
| 462 | cmd = ahci_port_readl(ctrl, pnr, PORT_CMD); |
| 463 | cmd |= PORT_CMD_FIS_RX; |
| 464 | ahci_port_writel(ctrl, pnr, PORT_CMD, cmd); |
| 465 | |
| 466 | /* spin up */ |
| 467 | cmd |= PORT_CMD_SPIN_UP; |
| 468 | ahci_port_writel(ctrl, pnr, PORT_CMD, cmd); |
| 469 | end = calc_future_tsc(AHCI_LINK_TIMEOUT); |
| 470 | for (;;) { |
| 471 | stat = ahci_port_readl(ctrl, pnr, PORT_SCR_STAT); |
| 472 | if ((stat & 0x07) == 0x03) { |
Kevin O'Connor | bf079e1 | 2012-03-11 11:19:52 -0400 | [diff] [blame] | 473 | dprintf(2, "AHCI/%d: link up\n", port->pnr); |
Gerd Hoffmann | e104119 | 2011-07-14 16:24:04 +0200 | [diff] [blame] | 474 | break; |
| 475 | } |
| 476 | if (check_tsc(end)) { |
Kevin O'Connor | bf079e1 | 2012-03-11 11:19:52 -0400 | [diff] [blame] | 477 | dprintf(2, "AHCI/%d: link down\n", port->pnr); |
Gerd Hoffmann | e104119 | 2011-07-14 16:24:04 +0200 | [diff] [blame] | 478 | return -1; |
| 479 | } |
| 480 | yield(); |
| 481 | } |
| 482 | |
| 483 | /* clear error status */ |
| 484 | err = ahci_port_readl(ctrl, pnr, PORT_SCR_ERR); |
| 485 | if (err) |
| 486 | ahci_port_writel(ctrl, pnr, PORT_SCR_ERR, err); |
| 487 | |
| 488 | /* wait for device becoming ready */ |
| 489 | end = calc_future_tsc(AHCI_REQUEST_TIMEOUT); |
| 490 | for (;;) { |
| 491 | tf = ahci_port_readl(ctrl, pnr, PORT_TFDATA); |
| 492 | if (!(tf & (ATA_CB_STAT_BSY | |
| 493 | ATA_CB_STAT_DRQ))) |
| 494 | break; |
| 495 | if (check_tsc(end)) { |
| 496 | warn_timeout(); |
| 497 | dprintf(1, "AHCI/%d: device not ready (tf 0x%x)\n", port->pnr, tf); |
| 498 | return -1; |
| 499 | } |
| 500 | yield(); |
| 501 | } |
| 502 | |
| 503 | /* start device */ |
| 504 | cmd |= PORT_CMD_START; |
| 505 | ahci_port_writel(ctrl, pnr, PORT_CMD, cmd); |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 506 | |
| 507 | sata_prep_simple(&port->cmd->fis, ATA_CMD_IDENTIFY_PACKET_DEVICE); |
| 508 | rc = ahci_command(port, 0, 0, buffer, sizeof(buffer)); |
| 509 | if (rc == 0) { |
| 510 | port->atapi = 1; |
| 511 | } else { |
| 512 | port->atapi = 0; |
| 513 | sata_prep_simple(&port->cmd->fis, ATA_CMD_IDENTIFY_DEVICE); |
| 514 | rc = ahci_command(port, 0, 0, buffer, sizeof(buffer)); |
| 515 | if (rc < 0) |
Gerd Hoffmann | e104119 | 2011-07-14 16:24:04 +0200 | [diff] [blame] | 516 | return -1; |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 517 | } |
| 518 | |
| 519 | port->drive.type = DTYPE_AHCI; |
Gerd Hoffmann | 0e6f636 | 2010-12-09 08:39:48 +0100 | [diff] [blame] | 520 | port->drive.cntl_id = pnr; |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 521 | port->drive.removable = (buffer[0] & 0x80) ? 1 : 0; |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 522 | |
| 523 | if (!port->atapi) { |
| 524 | // found disk (ata) |
| 525 | port->drive.blksize = DISK_SECTOR_SIZE; |
| 526 | port->drive.pchs.cylinders = buffer[1]; |
| 527 | port->drive.pchs.heads = buffer[3]; |
| 528 | port->drive.pchs.spt = buffer[6]; |
| 529 | |
| 530 | u64 sectors; |
| 531 | if (buffer[83] & (1 << 10)) // word 83 - lba48 support |
| 532 | sectors = *(u64*)&buffer[100]; // word 100-103 |
| 533 | else |
| 534 | sectors = *(u32*)&buffer[60]; // word 60 and word 61 |
| 535 | port->drive.sectors = sectors; |
| 536 | u64 adjsize = sectors >> 11; |
| 537 | char adjprefix = 'M'; |
| 538 | if (adjsize >= (1 << 16)) { |
| 539 | adjsize >>= 10; |
| 540 | adjprefix = 'G'; |
| 541 | } |
Gerd Hoffmann | 2dcbf7f | 2011-08-04 19:36:30 +0200 | [diff] [blame] | 542 | port->desc = znprintf(MAXDESCSIZE |
Kevin O'Connor | ca2bc1c | 2010-12-29 21:41:19 -0500 | [diff] [blame] | 543 | , "AHCI/%d: %s ATA-%d Hard-Disk (%u %ciBytes)" |
| 544 | , port->pnr |
| 545 | , ata_extract_model(model, MAXMODEL, buffer) |
| 546 | , ata_extract_version(buffer) |
| 547 | , (u32)adjsize, adjprefix); |
Gerd Hoffmann | 2dcbf7f | 2011-08-04 19:36:30 +0200 | [diff] [blame] | 548 | port->prio = bootprio_find_ata_device(ctrl->pci_tmp, pnr, 0); |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 549 | } else { |
| 550 | // found cdrom (atapi) |
| 551 | port->drive.blksize = CDROM_SECTOR_SIZE; |
| 552 | port->drive.sectors = (u64)-1; |
| 553 | u8 iscd = ((buffer[0] >> 8) & 0x1f) == 0x05; |
Gerd Hoffmann | 263ea2f | 2011-08-04 19:36:29 +0200 | [diff] [blame] | 554 | if (!iscd) { |
| 555 | dprintf(1, "AHCI/%d: atapi device is'nt a cdrom\n", port->pnr); |
| 556 | return -1; |
| 557 | } |
Gerd Hoffmann | 2dcbf7f | 2011-08-04 19:36:30 +0200 | [diff] [blame] | 558 | port->desc = znprintf(MAXDESCSIZE |
Gerd Hoffmann | 263ea2f | 2011-08-04 19:36:29 +0200 | [diff] [blame] | 559 | , "DVD/CD [AHCI/%d: %s ATAPI-%d DVD/CD]" |
Kevin O'Connor | ca2bc1c | 2010-12-29 21:41:19 -0500 | [diff] [blame] | 560 | , port->pnr |
| 561 | , ata_extract_model(model, MAXMODEL, buffer) |
Gerd Hoffmann | 263ea2f | 2011-08-04 19:36:29 +0200 | [diff] [blame] | 562 | , ata_extract_version(buffer)); |
Gerd Hoffmann | 2dcbf7f | 2011-08-04 19:36:30 +0200 | [diff] [blame] | 563 | port->prio = bootprio_find_ata_device(ctrl->pci_tmp, pnr, 0); |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 564 | } |
Gerd Hoffmann | e104119 | 2011-07-14 16:24:04 +0200 | [diff] [blame] | 565 | return 0; |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 566 | } |
| 567 | |
| 568 | // Detect any drives attached to a given controller. |
| 569 | static void |
Gerd Hoffmann | 9713f24 | 2011-08-04 19:36:28 +0200 | [diff] [blame] | 570 | ahci_port_detect(void *data) |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 571 | { |
Gerd Hoffmann | 9713f24 | 2011-08-04 19:36:28 +0200 | [diff] [blame] | 572 | struct ahci_port_s *port = data; |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 573 | int rc; |
| 574 | |
Gerd Hoffmann | 9713f24 | 2011-08-04 19:36:28 +0200 | [diff] [blame] | 575 | dprintf(2, "AHCI/%d: probing\n", port->pnr); |
| 576 | ahci_port_reset(port->ctrl, port->pnr); |
| 577 | rc = ahci_port_init(port); |
| 578 | if (rc < 0) |
| 579 | ahci_port_release(port); |
Gerd Hoffmann | 2dcbf7f | 2011-08-04 19:36:30 +0200 | [diff] [blame] | 580 | else { |
Gerd Hoffmann | ef8adc0 | 2011-08-04 19:36:31 +0200 | [diff] [blame] | 581 | port = ahci_port_realloc(port); |
Gerd Hoffmann | 2dcbf7f | 2011-08-04 19:36:30 +0200 | [diff] [blame] | 582 | dprintf(1, "AHCI/%d: registering: \"%s\"\n", port->pnr, port->desc); |
| 583 | if (!port->atapi) { |
| 584 | // Register with bcv system. |
| 585 | boot_add_hd(&port->drive, port->desc, port->prio); |
| 586 | } else { |
| 587 | // fill cdidmap |
| 588 | boot_add_cd(&port->drive, port->desc, port->prio); |
| 589 | } |
| 590 | } |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 591 | } |
| 592 | |
| 593 | // Initialize an ata controller and detect its drives. |
| 594 | static void |
Gerd Hoffmann | 9c86992 | 2011-07-14 16:24:05 +0200 | [diff] [blame] | 595 | ahci_init_controller(struct pci_device *pci) |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 596 | { |
| 597 | struct ahci_ctrl_s *ctrl = malloc_fseg(sizeof(*ctrl)); |
Gerd Hoffmann | 9713f24 | 2011-08-04 19:36:28 +0200 | [diff] [blame] | 598 | struct ahci_port_s *port; |
Gerd Hoffmann | 9c86992 | 2011-07-14 16:24:05 +0200 | [diff] [blame] | 599 | u16 bdf = pci->bdf; |
Gerd Hoffmann | 9713f24 | 2011-08-04 19:36:28 +0200 | [diff] [blame] | 600 | u32 val, pnr, max; |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 601 | |
| 602 | if (!ctrl) { |
| 603 | warn_noalloc(); |
| 604 | return; |
| 605 | } |
Scott Duplichan | 9c48aab | 2011-07-14 16:24:02 +0200 | [diff] [blame] | 606 | |
Gerd Hoffmann | d7a7cf3 | 2011-08-04 19:36:27 +0200 | [diff] [blame] | 607 | if (bounce_buf_init() < 0) { |
Scott Duplichan | 9c48aab | 2011-07-14 16:24:02 +0200 | [diff] [blame] | 608 | warn_noalloc(); |
Gerd Hoffmann | d7a7cf3 | 2011-08-04 19:36:27 +0200 | [diff] [blame] | 609 | free(ctrl); |
Scott Duplichan | 9c48aab | 2011-07-14 16:24:02 +0200 | [diff] [blame] | 610 | return; |
| 611 | } |
| 612 | |
Gerd Hoffmann | 9c86992 | 2011-07-14 16:24:05 +0200 | [diff] [blame] | 613 | ctrl->pci_tmp = pci; |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 614 | ctrl->pci_bdf = bdf; |
| 615 | ctrl->iobase = pci_config_readl(bdf, PCI_BASE_ADDRESS_5); |
| 616 | ctrl->irq = pci_config_readb(bdf, PCI_INTERRUPT_LINE); |
| 617 | dprintf(1, "AHCI controller at %02x.%x, iobase %x, irq %d\n", |
| 618 | bdf >> 3, bdf & 7, ctrl->iobase, ctrl->irq); |
| 619 | |
Kevin O'Connor | 7eb0222 | 2010-12-12 14:01:47 -0500 | [diff] [blame] | 620 | pci_config_maskw(bdf, PCI_COMMAND, 0, |
| 621 | PCI_COMMAND_IO | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER); |
| 622 | |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 623 | val = ahci_ctrl_readl(ctrl, HOST_CTL); |
| 624 | ahci_ctrl_writel(ctrl, HOST_CTL, val | HOST_CTL_AHCI_EN); |
| 625 | |
| 626 | ctrl->caps = ahci_ctrl_readl(ctrl, HOST_CAP); |
| 627 | ctrl->ports = ahci_ctrl_readl(ctrl, HOST_PORTS_IMPL); |
| 628 | dprintf(2, "AHCI: cap 0x%x, ports_impl 0x%x\n", |
| 629 | ctrl->caps, ctrl->ports); |
| 630 | |
Gerd Hoffmann | 9713f24 | 2011-08-04 19:36:28 +0200 | [diff] [blame] | 631 | max = ctrl->caps & 0x1f; |
| 632 | for (pnr = 0; pnr <= max; pnr++) { |
| 633 | if (!(ctrl->ports & (1 << pnr))) |
| 634 | continue; |
| 635 | port = ahci_port_alloc(ctrl, pnr); |
| 636 | if (port == NULL) |
| 637 | continue; |
| 638 | run_thread(ahci_port_detect, port); |
| 639 | } |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 640 | } |
| 641 | |
| 642 | // Locate and init ahci controllers. |
| 643 | static void |
| 644 | ahci_init(void) |
| 645 | { |
| 646 | // Scan PCI bus for ATA adapters |
Kevin O'Connor | 9cb4992 | 2011-06-20 22:22:42 -0400 | [diff] [blame] | 647 | struct pci_device *pci; |
| 648 | foreachpci(pci) { |
| 649 | if (pci->class != PCI_CLASS_STORAGE_SATA) |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 650 | continue; |
Kevin O'Connor | 9cb4992 | 2011-06-20 22:22:42 -0400 | [diff] [blame] | 651 | if (pci->prog_if != 1 /* AHCI rev 1 */) |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 652 | continue; |
Gerd Hoffmann | 9c86992 | 2011-07-14 16:24:05 +0200 | [diff] [blame] | 653 | ahci_init_controller(pci); |
Gerd Hoffmann | d52fdf6 | 2010-11-29 09:42:13 +0100 | [diff] [blame] | 654 | } |
| 655 | } |
| 656 | |
| 657 | void |
| 658 | ahci_setup(void) |
| 659 | { |
| 660 | ASSERT32FLAT(); |
| 661 | if (!CONFIG_AHCI) |
| 662 | return; |
| 663 | |
| 664 | dprintf(3, "init ahci\n"); |
| 665 | ahci_init(); |
| 666 | } |