| /* |
| * Intel PCH/PCU SPI flash driver. |
| * |
| * Copyright (C) 2016, Intel Corporation |
| * Author: Mika Westerberg <mika.westerberg@linux.intel.com> |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License version 2 as |
| * published by the Free Software Foundation. |
| */ |
| |
| #include <linux/err.h> |
| #include <linux/io.h> |
| #include <linux/iopoll.h> |
| #include <linux/module.h> |
| #include <linux/sched.h> |
| #include <linux/sizes.h> |
| #include <linux/mtd/mtd.h> |
| #include <linux/mtd/partitions.h> |
| #include <linux/mtd/spi-nor.h> |
| #include <linux/platform_data/intel-spi.h> |
| |
| #include "intel-spi.h" |
| |
| /* Offsets are from @ispi->base */ |
| #define BFPREG 0x00 |
| |
| #define HSFSTS_CTL 0x04 |
| #define HSFSTS_CTL_FSMIE BIT(31) |
| #define HSFSTS_CTL_FDBC_SHIFT 24 |
| #define HSFSTS_CTL_FDBC_MASK (0x3f << HSFSTS_CTL_FDBC_SHIFT) |
| |
| #define HSFSTS_CTL_FCYCLE_SHIFT 17 |
| #define HSFSTS_CTL_FCYCLE_MASK (0x0f << HSFSTS_CTL_FCYCLE_SHIFT) |
| /* HW sequencer opcodes */ |
| #define HSFSTS_CTL_FCYCLE_READ (0x00 << HSFSTS_CTL_FCYCLE_SHIFT) |
| #define HSFSTS_CTL_FCYCLE_WRITE (0x02 << HSFSTS_CTL_FCYCLE_SHIFT) |
| #define HSFSTS_CTL_FCYCLE_ERASE (0x03 << HSFSTS_CTL_FCYCLE_SHIFT) |
| #define HSFSTS_CTL_FCYCLE_ERASE_64K (0x04 << HSFSTS_CTL_FCYCLE_SHIFT) |
| #define HSFSTS_CTL_FCYCLE_RDID (0x06 << HSFSTS_CTL_FCYCLE_SHIFT) |
| #define HSFSTS_CTL_FCYCLE_WRSR (0x07 << HSFSTS_CTL_FCYCLE_SHIFT) |
| #define HSFSTS_CTL_FCYCLE_RDSR (0x08 << HSFSTS_CTL_FCYCLE_SHIFT) |
| |
| #define HSFSTS_CTL_FGO BIT(16) |
| #define HSFSTS_CTL_FLOCKDN BIT(15) |
| #define HSFSTS_CTL_FDV BIT(14) |
| #define HSFSTS_CTL_SCIP BIT(5) |
| #define HSFSTS_CTL_AEL BIT(2) |
| #define HSFSTS_CTL_FCERR BIT(1) |
| #define HSFSTS_CTL_FDONE BIT(0) |
| |
| #define FADDR 0x08 |
| #define DLOCK 0x0c |
| #define FDATA(n) (0x10 + ((n) * 4)) |
| |
| #define FRACC 0x50 |
| |
| #define FREG(n) (0x54 + ((n) * 4)) |
| #define FREG_BASE_MASK 0x3fff |
| #define FREG_LIMIT_SHIFT 16 |
| #define FREG_LIMIT_MASK (0x03fff << FREG_LIMIT_SHIFT) |
| |
| /* Offset is from @ispi->pregs */ |
| #define PR(n) ((n) * 4) |
| #define PR_WPE BIT(31) |
| #define PR_LIMIT_SHIFT 16 |
| #define PR_LIMIT_MASK (0x3fff << PR_LIMIT_SHIFT) |
| #define PR_RPE BIT(15) |
| #define PR_BASE_MASK 0x3fff |
| /* Last PR is GPR0 */ |
| #define PR_NUM (5 + 1) |
| |
| /* Offsets are from @ispi->sregs */ |
| #define SSFSTS_CTL 0x00 |
| #define SSFSTS_CTL_FSMIE BIT(23) |
| #define SSFSTS_CTL_DS BIT(22) |
| #define SSFSTS_CTL_DBC_SHIFT 16 |
| #define SSFSTS_CTL_SPOP BIT(11) |
| #define SSFSTS_CTL_ACS BIT(10) |
| #define SSFSTS_CTL_SCGO BIT(9) |
| #define SSFSTS_CTL_COP_SHIFT 12 |
| #define SSFSTS_CTL_FRS BIT(7) |
| #define SSFSTS_CTL_DOFRS BIT(6) |
| #define SSFSTS_CTL_AEL BIT(4) |
| #define SSFSTS_CTL_FCERR BIT(3) |
| #define SSFSTS_CTL_FDONE BIT(2) |
| #define SSFSTS_CTL_SCIP BIT(0) |
| |
| #define PREOP_OPTYPE 0x04 |
| #define OPMENU0 0x08 |
| #define OPMENU1 0x0c |
| |
| /* CPU specifics */ |
| #define BYT_PR 0x74 |
| #define BYT_SSFSTS_CTL 0x90 |
| #define BYT_BCR 0xfc |
| #define BYT_BCR_WPD BIT(0) |
| #define BYT_FREG_NUM 5 |
| |
| #define LPT_PR 0x74 |
| #define LPT_SSFSTS_CTL 0x90 |
| #define LPT_FREG_NUM 5 |
| |
| #define BXT_PR 0x84 |
| #define BXT_SSFSTS_CTL 0xa0 |
| #define BXT_FREG_NUM 12 |
| |
| #define INTEL_SPI_TIMEOUT 5000 /* ms */ |
| #define INTEL_SPI_FIFO_SZ 64 |
| |
| /** |
| * struct intel_spi - Driver private data |
| * @dev: Device pointer |
| * @info: Pointer to board specific info |
| * @nor: SPI NOR layer structure |
| * @base: Beginning of MMIO space |
| * @pregs: Start of protection registers |
| * @sregs: Start of software sequencer registers |
| * @nregions: Maximum number of regions |
| * @writeable: Is the chip writeable |
| * @swseq: Use SW sequencer in register reads/writes |
| * @erase_64k: 64k erase supported |
| * @opcodes: Opcodes which are supported. This are programmed by BIOS |
| * before it locks down the controller. |
| * @preopcodes: Preopcodes which are supported. |
| */ |
| struct intel_spi { |
| struct device *dev; |
| const struct intel_spi_boardinfo *info; |
| struct spi_nor nor; |
| void __iomem *base; |
| void __iomem *pregs; |
| void __iomem *sregs; |
| size_t nregions; |
| bool writeable; |
| bool swseq; |
| bool erase_64k; |
| u8 opcodes[8]; |
| u8 preopcodes[2]; |
| }; |
| |
| static bool writeable; |
| module_param(writeable, bool, 0); |
| MODULE_PARM_DESC(writeable, "Enable write access to SPI flash chip (default=0)"); |
| |
| static void intel_spi_dump_regs(struct intel_spi *ispi) |
| { |
| u32 value; |
| int i; |
| |
| dev_dbg(ispi->dev, "BFPREG=0x%08x\n", readl(ispi->base + BFPREG)); |
| |
| value = readl(ispi->base + HSFSTS_CTL); |
| dev_dbg(ispi->dev, "HSFSTS_CTL=0x%08x\n", value); |
| if (value & HSFSTS_CTL_FLOCKDN) |
| dev_dbg(ispi->dev, "-> Locked\n"); |
| |
| dev_dbg(ispi->dev, "FADDR=0x%08x\n", readl(ispi->base + FADDR)); |
| dev_dbg(ispi->dev, "DLOCK=0x%08x\n", readl(ispi->base + DLOCK)); |
| |
| for (i = 0; i < 16; i++) |
| dev_dbg(ispi->dev, "FDATA(%d)=0x%08x\n", |
| i, readl(ispi->base + FDATA(i))); |
| |
| dev_dbg(ispi->dev, "FRACC=0x%08x\n", readl(ispi->base + FRACC)); |
| |
| for (i = 0; i < ispi->nregions; i++) |
| dev_dbg(ispi->dev, "FREG(%d)=0x%08x\n", i, |
| readl(ispi->base + FREG(i))); |
| for (i = 0; i < PR_NUM; i++) |
| dev_dbg(ispi->dev, "PR(%d)=0x%08x\n", i, |
| readl(ispi->pregs + PR(i))); |
| |
| value = readl(ispi->sregs + SSFSTS_CTL); |
| dev_dbg(ispi->dev, "SSFSTS_CTL=0x%08x\n", value); |
| dev_dbg(ispi->dev, "PREOP_OPTYPE=0x%08x\n", |
| readl(ispi->sregs + PREOP_OPTYPE)); |
| dev_dbg(ispi->dev, "OPMENU0=0x%08x\n", readl(ispi->sregs + OPMENU0)); |
| dev_dbg(ispi->dev, "OPMENU1=0x%08x\n", readl(ispi->sregs + OPMENU1)); |
| |
| if (ispi->info->type == INTEL_SPI_BYT) |
| dev_dbg(ispi->dev, "BCR=0x%08x\n", readl(ispi->base + BYT_BCR)); |
| |
| dev_dbg(ispi->dev, "Protected regions:\n"); |
| for (i = 0; i < PR_NUM; i++) { |
| u32 base, limit; |
| |
| value = readl(ispi->pregs + PR(i)); |
| if (!(value & (PR_WPE | PR_RPE))) |
| continue; |
| |
| limit = (value & PR_LIMIT_MASK) >> PR_LIMIT_SHIFT; |
| base = value & PR_BASE_MASK; |
| |
| dev_dbg(ispi->dev, " %02d base: 0x%08x limit: 0x%08x [%c%c]\n", |
| i, base << 12, (limit << 12) | 0xfff, |
| value & PR_WPE ? 'W' : '.', |
| value & PR_RPE ? 'R' : '.'); |
| } |
| |
| dev_dbg(ispi->dev, "Flash regions:\n"); |
| for (i = 0; i < ispi->nregions; i++) { |
| u32 region, base, limit; |
| |
| region = readl(ispi->base + FREG(i)); |
| base = region & FREG_BASE_MASK; |
| limit = (region & FREG_LIMIT_MASK) >> FREG_LIMIT_SHIFT; |
| |
| if (base >= limit || (i > 0 && limit == 0)) |
| dev_dbg(ispi->dev, " %02d disabled\n", i); |
| else |
| dev_dbg(ispi->dev, " %02d base: 0x%08x limit: 0x%08x\n", |
| i, base << 12, (limit << 12) | 0xfff); |
| } |
| |
| dev_dbg(ispi->dev, "Using %cW sequencer for register access\n", |
| ispi->swseq ? 'S' : 'H'); |
| } |
| |
| /* Reads max INTEL_SPI_FIFO_SZ bytes from the device fifo */ |
| static int intel_spi_read_block(struct intel_spi *ispi, void *buf, size_t size) |
| { |
| size_t bytes; |
| int i = 0; |
| |
| if (size > INTEL_SPI_FIFO_SZ) |
| return -EINVAL; |
| |
| while (size > 0) { |
| bytes = min_t(size_t, size, 4); |
| memcpy_fromio(buf, ispi->base + FDATA(i), bytes); |
| size -= bytes; |
| buf += bytes; |
| i++; |
| } |
| |
| return 0; |
| } |
| |
| /* Writes max INTEL_SPI_FIFO_SZ bytes to the device fifo */ |
| static int intel_spi_write_block(struct intel_spi *ispi, const void *buf, |
| size_t size) |
| { |
| size_t bytes; |
| int i = 0; |
| |
| if (size > INTEL_SPI_FIFO_SZ) |
| return -EINVAL; |
| |
| while (size > 0) { |
| bytes = min_t(size_t, size, 4); |
| memcpy_toio(ispi->base + FDATA(i), buf, bytes); |
| size -= bytes; |
| buf += bytes; |
| i++; |
| } |
| |
| return 0; |
| } |
| |
| static int intel_spi_wait_hw_busy(struct intel_spi *ispi) |
| { |
| u32 val; |
| |
| return readl_poll_timeout(ispi->base + HSFSTS_CTL, val, |
| !(val & HSFSTS_CTL_SCIP), 0, |
| INTEL_SPI_TIMEOUT * 1000); |
| } |
| |
| static int intel_spi_wait_sw_busy(struct intel_spi *ispi) |
| { |
| u32 val; |
| |
| return readl_poll_timeout(ispi->sregs + SSFSTS_CTL, val, |
| !(val & SSFSTS_CTL_SCIP), 0, |
| INTEL_SPI_TIMEOUT * 1000); |
| } |
| |
| static int intel_spi_init(struct intel_spi *ispi) |
| { |
| u32 opmenu0, opmenu1, val; |
| int i; |
| |
| switch (ispi->info->type) { |
| case INTEL_SPI_BYT: |
| ispi->sregs = ispi->base + BYT_SSFSTS_CTL; |
| ispi->pregs = ispi->base + BYT_PR; |
| ispi->nregions = BYT_FREG_NUM; |
| |
| if (writeable) { |
| /* Disable write protection */ |
| val = readl(ispi->base + BYT_BCR); |
| if (!(val & BYT_BCR_WPD)) { |
| val |= BYT_BCR_WPD; |
| writel(val, ispi->base + BYT_BCR); |
| val = readl(ispi->base + BYT_BCR); |
| } |
| |
| ispi->writeable = !!(val & BYT_BCR_WPD); |
| } |
| |
| break; |
| |
| case INTEL_SPI_LPT: |
| ispi->sregs = ispi->base + LPT_SSFSTS_CTL; |
| ispi->pregs = ispi->base + LPT_PR; |
| ispi->nregions = LPT_FREG_NUM; |
| break; |
| |
| case INTEL_SPI_BXT: |
| ispi->sregs = ispi->base + BXT_SSFSTS_CTL; |
| ispi->pregs = ispi->base + BXT_PR; |
| ispi->nregions = BXT_FREG_NUM; |
| ispi->erase_64k = true; |
| break; |
| |
| default: |
| return -EINVAL; |
| } |
| |
| /* Disable #SMI generation */ |
| val = readl(ispi->base + HSFSTS_CTL); |
| val &= ~HSFSTS_CTL_FSMIE; |
| writel(val, ispi->base + HSFSTS_CTL); |
| |
| /* |
| * BIOS programs allowed opcodes and then locks down the register. |
| * So read back what opcodes it decided to support. That's the set |
| * we are going to support as well. |
| */ |
| opmenu0 = readl(ispi->sregs + OPMENU0); |
| opmenu1 = readl(ispi->sregs + OPMENU1); |
| |
| /* |
| * Some controllers can only do basic operations using hardware |
| * sequencer. All other operations are supposed to be carried out |
| * using software sequencer. If we find that BIOS has programmed |
| * opcodes for the software sequencer we use that over the hardware |
| * sequencer. |
| */ |
| if (opmenu0 && opmenu1) { |
| for (i = 0; i < ARRAY_SIZE(ispi->opcodes) / 2; i++) { |
| ispi->opcodes[i] = opmenu0 >> i * 8; |
| ispi->opcodes[i + 4] = opmenu1 >> i * 8; |
| } |
| |
| val = readl(ispi->sregs + PREOP_OPTYPE); |
| ispi->preopcodes[0] = val; |
| ispi->preopcodes[1] = val >> 8; |
| |
| /* Disable #SMI generation from SW sequencer */ |
| val = readl(ispi->sregs + SSFSTS_CTL); |
| val &= ~SSFSTS_CTL_FSMIE; |
| writel(val, ispi->sregs + SSFSTS_CTL); |
| |
| ispi->swseq = true; |
| } |
| |
| intel_spi_dump_regs(ispi); |
| |
| return 0; |
| } |
| |
| static int intel_spi_opcode_index(struct intel_spi *ispi, u8 opcode) |
| { |
| int i; |
| |
| for (i = 0; i < ARRAY_SIZE(ispi->opcodes); i++) |
| if (ispi->opcodes[i] == opcode) |
| return i; |
| return -EINVAL; |
| } |
| |
| static int intel_spi_hw_cycle(struct intel_spi *ispi, u8 opcode, u8 *buf, |
| int len) |
| { |
| u32 val, status; |
| int ret; |
| |
| val = readl(ispi->base + HSFSTS_CTL); |
| val &= ~(HSFSTS_CTL_FCYCLE_MASK | HSFSTS_CTL_FDBC_MASK); |
| |
| switch (opcode) { |
| case SPINOR_OP_RDID: |
| val |= HSFSTS_CTL_FCYCLE_RDID; |
| break; |
| case SPINOR_OP_WRSR: |
| val |= HSFSTS_CTL_FCYCLE_WRSR; |
| break; |
| case SPINOR_OP_RDSR: |
| val |= HSFSTS_CTL_FCYCLE_RDSR; |
| break; |
| default: |
| return -EINVAL; |
| } |
| |
| val |= (len - 1) << HSFSTS_CTL_FDBC_SHIFT; |
| val |= HSFSTS_CTL_FCERR | HSFSTS_CTL_FDONE; |
| val |= HSFSTS_CTL_FGO; |
| writel(val, ispi->base + HSFSTS_CTL); |
| |
| ret = intel_spi_wait_hw_busy(ispi); |
| if (ret) |
| return ret; |
| |
| status = readl(ispi->base + HSFSTS_CTL); |
| if (status & HSFSTS_CTL_FCERR) |
| return -EIO; |
| else if (status & HSFSTS_CTL_AEL) |
| return -EACCES; |
| |
| return 0; |
| } |
| |
| static int intel_spi_sw_cycle(struct intel_spi *ispi, u8 opcode, u8 *buf, |
| int len) |
| { |
| u32 val, status; |
| int ret; |
| |
| ret = intel_spi_opcode_index(ispi, opcode); |
| if (ret < 0) |
| return ret; |
| |
| val = (len << SSFSTS_CTL_DBC_SHIFT) | SSFSTS_CTL_DS; |
| val |= ret << SSFSTS_CTL_COP_SHIFT; |
| val |= SSFSTS_CTL_FCERR | SSFSTS_CTL_FDONE; |
| val |= SSFSTS_CTL_SCGO; |
| writel(val, ispi->sregs + SSFSTS_CTL); |
| |
| ret = intel_spi_wait_sw_busy(ispi); |
| if (ret) |
| return ret; |
| |
| status = readl(ispi->base + SSFSTS_CTL); |
| if (status & SSFSTS_CTL_FCERR) |
| return -EIO; |
| else if (status & SSFSTS_CTL_AEL) |
| return -EACCES; |
| |
| return 0; |
| } |
| |
| static int intel_spi_read_reg(struct spi_nor *nor, u8 opcode, u8 *buf, int len) |
| { |
| struct intel_spi *ispi = nor->priv; |
| int ret; |
| |
| /* Address of the first chip */ |
| writel(0, ispi->base + FADDR); |
| |
| if (ispi->swseq) |
| ret = intel_spi_sw_cycle(ispi, opcode, buf, len); |
| else |
| ret = intel_spi_hw_cycle(ispi, opcode, buf, len); |
| |
| if (ret) |
| return ret; |
| |
| return intel_spi_read_block(ispi, buf, len); |
| } |
| |
| static int intel_spi_write_reg(struct spi_nor *nor, u8 opcode, u8 *buf, int len) |
| { |
| struct intel_spi *ispi = nor->priv; |
| int ret; |
| |
| /* |
| * This is handled with atomic operation and preop code in Intel |
| * controller so skip it here now. |
| */ |
| if (opcode == SPINOR_OP_WREN) |
| return 0; |
| |
| writel(0, ispi->base + FADDR); |
| |
| /* Write the value beforehand */ |
| ret = intel_spi_write_block(ispi, buf, len); |
| if (ret) |
| return ret; |
| |
| if (ispi->swseq) |
| return intel_spi_sw_cycle(ispi, opcode, buf, len); |
| return intel_spi_hw_cycle(ispi, opcode, buf, len); |
| } |
| |
| static ssize_t intel_spi_read(struct spi_nor *nor, loff_t from, size_t len, |
| u_char *read_buf) |
| { |
| struct intel_spi *ispi = nor->priv; |
| size_t block_size, retlen = 0; |
| u32 val, status; |
| ssize_t ret; |
| |
| switch (nor->read_opcode) { |
| case SPINOR_OP_READ: |
| case SPINOR_OP_READ_FAST: |
| break; |
| default: |
| return -EINVAL; |
| } |
| |
| while (len > 0) { |
| block_size = min_t(size_t, len, INTEL_SPI_FIFO_SZ); |
| |
| writel(from, ispi->base + FADDR); |
| |
| val = readl(ispi->base + HSFSTS_CTL); |
| val &= ~(HSFSTS_CTL_FDBC_MASK | HSFSTS_CTL_FCYCLE_MASK); |
| val |= HSFSTS_CTL_AEL | HSFSTS_CTL_FCERR | HSFSTS_CTL_FDONE; |
| val |= (block_size - 1) << HSFSTS_CTL_FDBC_SHIFT; |
| val |= HSFSTS_CTL_FCYCLE_READ; |
| val |= HSFSTS_CTL_FGO; |
| writel(val, ispi->base + HSFSTS_CTL); |
| |
| ret = intel_spi_wait_hw_busy(ispi); |
| if (ret) |
| return ret; |
| |
| status = readl(ispi->base + HSFSTS_CTL); |
| if (status & HSFSTS_CTL_FCERR) |
| ret = -EIO; |
| else if (status & HSFSTS_CTL_AEL) |
| ret = -EACCES; |
| |
| if (ret < 0) { |
| dev_err(ispi->dev, "read error: %llx: %#x\n", from, |
| status); |
| return ret; |
| } |
| |
| ret = intel_spi_read_block(ispi, read_buf, block_size); |
| if (ret) |
| return ret; |
| |
| len -= block_size; |
| from += block_size; |
| retlen += block_size; |
| read_buf += block_size; |
| } |
| |
| return retlen; |
| } |
| |
| static ssize_t intel_spi_write(struct spi_nor *nor, loff_t to, size_t len, |
| const u_char *write_buf) |
| { |
| struct intel_spi *ispi = nor->priv; |
| size_t block_size, retlen = 0; |
| u32 val, status; |
| ssize_t ret; |
| |
| while (len > 0) { |
| block_size = min_t(size_t, len, INTEL_SPI_FIFO_SZ); |
| |
| writel(to, ispi->base + FADDR); |
| |
| val = readl(ispi->base + HSFSTS_CTL); |
| val &= ~(HSFSTS_CTL_FDBC_MASK | HSFSTS_CTL_FCYCLE_MASK); |
| val |= HSFSTS_CTL_AEL | HSFSTS_CTL_FCERR | HSFSTS_CTL_FDONE; |
| val |= (block_size - 1) << HSFSTS_CTL_FDBC_SHIFT; |
| val |= HSFSTS_CTL_FCYCLE_WRITE; |
| |
| /* Write enable */ |
| if (ispi->preopcodes[1] == SPINOR_OP_WREN) |
| val |= SSFSTS_CTL_SPOP; |
| val |= SSFSTS_CTL_ACS; |
| writel(val, ispi->base + HSFSTS_CTL); |
| |
| ret = intel_spi_write_block(ispi, write_buf, block_size); |
| if (ret) { |
| dev_err(ispi->dev, "failed to write block\n"); |
| return ret; |
| } |
| |
| /* Start the write now */ |
| val = readl(ispi->base + HSFSTS_CTL); |
| writel(val | HSFSTS_CTL_FGO, ispi->base + HSFSTS_CTL); |
| |
| ret = intel_spi_wait_hw_busy(ispi); |
| if (ret) { |
| dev_err(ispi->dev, "timeout\n"); |
| return ret; |
| } |
| |
| status = readl(ispi->base + HSFSTS_CTL); |
| if (status & HSFSTS_CTL_FCERR) |
| ret = -EIO; |
| else if (status & HSFSTS_CTL_AEL) |
| ret = -EACCES; |
| |
| if (ret < 0) { |
| dev_err(ispi->dev, "write error: %llx: %#x\n", to, |
| status); |
| return ret; |
| } |
| |
| len -= block_size; |
| to += block_size; |
| retlen += block_size; |
| write_buf += block_size; |
| } |
| |
| return retlen; |
| } |
| |
| static int intel_spi_erase(struct spi_nor *nor, loff_t offs) |
| { |
| size_t erase_size, len = nor->mtd.erasesize; |
| struct intel_spi *ispi = nor->priv; |
| u32 val, status, cmd; |
| int ret; |
| |
| /* If the hardware can do 64k erase use that when possible */ |
| if (len >= SZ_64K && ispi->erase_64k) { |
| cmd = HSFSTS_CTL_FCYCLE_ERASE_64K; |
| erase_size = SZ_64K; |
| } else { |
| cmd = HSFSTS_CTL_FCYCLE_ERASE; |
| erase_size = SZ_4K; |
| } |
| |
| while (len > 0) { |
| writel(offs, ispi->base + FADDR); |
| |
| val = readl(ispi->base + HSFSTS_CTL); |
| val &= ~(HSFSTS_CTL_FDBC_MASK | HSFSTS_CTL_FCYCLE_MASK); |
| val |= HSFSTS_CTL_AEL | HSFSTS_CTL_FCERR | HSFSTS_CTL_FDONE; |
| val |= cmd; |
| val |= HSFSTS_CTL_FGO; |
| writel(val, ispi->base + HSFSTS_CTL); |
| |
| ret = intel_spi_wait_hw_busy(ispi); |
| if (ret) |
| return ret; |
| |
| status = readl(ispi->base + HSFSTS_CTL); |
| if (status & HSFSTS_CTL_FCERR) |
| return -EIO; |
| else if (status & HSFSTS_CTL_AEL) |
| return -EACCES; |
| |
| offs += erase_size; |
| len -= erase_size; |
| } |
| |
| return 0; |
| } |
| |
| static bool intel_spi_is_protected(const struct intel_spi *ispi, |
| unsigned int base, unsigned int limit) |
| { |
| int i; |
| |
| for (i = 0; i < PR_NUM; i++) { |
| u32 pr_base, pr_limit, pr_value; |
| |
| pr_value = readl(ispi->pregs + PR(i)); |
| if (!(pr_value & (PR_WPE | PR_RPE))) |
| continue; |
| |
| pr_limit = (pr_value & PR_LIMIT_MASK) >> PR_LIMIT_SHIFT; |
| pr_base = pr_value & PR_BASE_MASK; |
| |
| if (pr_base >= base && pr_limit <= limit) |
| return true; |
| } |
| |
| return false; |
| } |
| |
| /* |
| * There will be a single partition holding all enabled flash regions. We |
| * call this "BIOS". |
| */ |
| static void intel_spi_fill_partition(struct intel_spi *ispi, |
| struct mtd_partition *part) |
| { |
| u64 end; |
| int i; |
| |
| memset(part, 0, sizeof(*part)); |
| |
| /* Start from the mandatory descriptor region */ |
| part->size = 4096; |
| part->name = "BIOS"; |
| |
| /* |
| * Now try to find where this partition ends based on the flash |
| * region registers. |
| */ |
| for (i = 1; i < ispi->nregions; i++) { |
| u32 region, base, limit; |
| |
| region = readl(ispi->base + FREG(i)); |
| base = region & FREG_BASE_MASK; |
| limit = (region & FREG_LIMIT_MASK) >> FREG_LIMIT_SHIFT; |
| |
| if (base >= limit || limit == 0) |
| continue; |
| |
| /* |
| * If any of the regions have protection bits set, make the |
| * whole partition read-only to be on the safe side. |
| */ |
| if (intel_spi_is_protected(ispi, base, limit)) |
| ispi->writeable = false; |
| |
| end = (limit << 12) + 4096; |
| if (end > part->size) |
| part->size = end; |
| } |
| } |
| |
| struct intel_spi *intel_spi_probe(struct device *dev, |
| struct resource *mem, const struct intel_spi_boardinfo *info) |
| { |
| struct mtd_partition part; |
| struct intel_spi *ispi; |
| int ret; |
| |
| if (!info || !mem) |
| return ERR_PTR(-EINVAL); |
| |
| ispi = devm_kzalloc(dev, sizeof(*ispi), GFP_KERNEL); |
| if (!ispi) |
| return ERR_PTR(-ENOMEM); |
| |
| ispi->base = devm_ioremap_resource(dev, mem); |
| if (IS_ERR(ispi->base)) |
| return ERR_CAST(ispi->base); |
| |
| ispi->dev = dev; |
| ispi->info = info; |
| ispi->writeable = info->writeable; |
| |
| ret = intel_spi_init(ispi); |
| if (ret) |
| return ERR_PTR(ret); |
| |
| ispi->nor.dev = ispi->dev; |
| ispi->nor.priv = ispi; |
| ispi->nor.read_reg = intel_spi_read_reg; |
| ispi->nor.write_reg = intel_spi_write_reg; |
| ispi->nor.read = intel_spi_read; |
| ispi->nor.write = intel_spi_write; |
| ispi->nor.erase = intel_spi_erase; |
| |
| ret = spi_nor_scan(&ispi->nor, NULL, SPI_NOR_NORMAL); |
| if (ret) { |
| dev_info(dev, "failed to locate the chip\n"); |
| return ERR_PTR(ret); |
| } |
| |
| intel_spi_fill_partition(ispi, &part); |
| |
| /* Prevent writes if not explicitly enabled */ |
| if (!ispi->writeable || !writeable) |
| ispi->nor.mtd.flags &= ~MTD_WRITEABLE; |
| |
| ret = mtd_device_parse_register(&ispi->nor.mtd, NULL, NULL, &part, 1); |
| if (ret) |
| return ERR_PTR(ret); |
| |
| return ispi; |
| } |
| EXPORT_SYMBOL_GPL(intel_spi_probe); |
| |
| int intel_spi_remove(struct intel_spi *ispi) |
| { |
| return mtd_device_unregister(&ispi->nor.mtd); |
| } |
| EXPORT_SYMBOL_GPL(intel_spi_remove); |
| |
| MODULE_DESCRIPTION("Intel PCH/PCU SPI flash core driver"); |
| MODULE_AUTHOR("Mika Westerberg <mika.westerberg@linux.intel.com>"); |
| MODULE_LICENSE("GPL v2"); |