| 1 | The following changes since commit 5e7b204dbfae9a562fc73684986f936b97f63877: | 1 | The following changes since commit ae35f033b874c627d81d51070187fbf55f0bf1a7: |
|---|---|---|---|
| 2 | 2 | ||
| 3 | Merge remote-tracking branch 'remotes/mst/tags/for_upstream' into staging (2020-12-09 20:08:54 +0000) | 3 | Update version for v9.2.0 release (2024-12-10 16:20:54 +0000) |
| 4 | 4 | ||
| 5 | are available in the Git repository at: | 5 | are available in the Git repository at: |
| 6 | 6 | ||
| 7 | https://github.com/legoater/qemu/ tags/pull-aspeed-20201210 | 7 | https://github.com/legoater/qemu/ tags/pull-aspeed-20241211 |
| 8 | 8 | ||
| 9 | for you to fetch changes up to 6f5f6507e49df4820207a94f3aeaaeab08092d32: | 9 | for you to fetch changes up to 124f4dc0d832c1bf3a4513c05a2b93bac0a5fac0: |
| 10 | 10 | ||
| 11 | aspeed: g220a-bmc: Add an FRU (2020-12-10 12:11:03 +0100) | 11 | test/qtest/ast2700-smc-test: Support to test AST2700 (2024-12-11 07:25:53 +0100) |
| 12 | 12 | ||
| 13 | ---------------------------------------------------------------- | 13 | ---------------------------------------------------------------- |
| 14 | Aspeed patches : | 14 | aspeed queue: |
| 15 | 15 | ||
| 16 | * New device model for EMC1413/EMC1414 temperature sensors (I2C) | 16 | * Removed tacoma-bmc machine |
| 17 | * New g220a-bmc Aspeed machine | 17 | * Added support for SDHCI on AST2700 SoC |
| 18 | * couple of Aspeed cleanups | 18 | * Improved functional tests |
| 19 | * Extended SMC qtest to all Aspeed SoCs | ||
| 19 | 20 | ||
| 20 | ---------------------------------------------------------------- | 21 | ---------------------------------------------------------------- |
| 21 | Cédric Le Goater (1): | 22 | Cédric Le Goater (8): |
| 22 | aspeed/smc: Add support for address lane disablement | 23 | arm: Remove tacoma-bmc machine |
| 24 | tests/functional: Introduce a specific test for ast1030 SoC | ||
| 25 | tests/functional: Introduce a specific test for palmetto-bmc machine | ||
| 26 | tests/functional: Introduce a specific test for romulus-bmc machine | ||
| 27 | tests/functional: Introduce a specific test for ast2500 SoC | ||
| 28 | tests/functional: Introduce a specific test for ast2600 SoC | ||
| 29 | tests/functional: Introduce a specific test for rainier-bmc machine | ||
| 30 | tests/functional: Move debian boot test from avocado | ||
| 23 | 31 | ||
| 24 | Joel Stanley (1): | 32 | Jamin Lin (16): |
| 25 | ast2600: SRAM is 89KB | 33 | hw/sd/aspeed_sdhci: Fix coding style |
| 34 | hw/arm/aspeed: Fix coding style | ||
| 35 | hw:sdhci: Introduce a new "capareg" class member to set the different Capability Registers | ||
| 36 | hw/sd/aspeed_sdhci: Add AST2700 Support | ||
| 37 | aspeed/soc: Support SDHCI for AST2700 | ||
| 38 | aspeed/soc: Support eMMC for AST2700 | ||
| 39 | test/qtest/aspeed_smc-test: Move testcases to test_palmetto_bmc function | ||
| 40 | test/qtest/aspeed_smc-test: Introduce a new TestData to test different BMC SOCs | ||
| 41 | test/qtest/aspeed_smc-test: Support to test all CE pins | ||
| 42 | test/qtest/aspeed_smc-test: Introducing a "page_addr" data field | ||
| 43 | test/qtest/aspeed_smc-test: Support to test AST2500 | ||
| 44 | test/qtest/aspeed_smc-test: Support to test AST2600 | ||
| 45 | test/qtest/aspeed_smc-test: Support to test AST1030 | ||
| 46 | test/qtest/aspeed_smc-test: Support write page command with QPI mode | ||
| 47 | test/qtest: Introduce a new aspeed-smc-utils.c to place common testcases | ||
| 48 | test/qtest/ast2700-smc-test: Support to test AST2700 | ||
| 26 | 49 | ||
| 27 | John Wang (3): | 50 | docs/about/deprecated.rst | 8 - |
| 28 | hw/misc: add an EMC141{3,4} device model | 51 | docs/about/removed-features.rst | 10 + |
| 29 | aspeed: Add support for the g220a-bmc board | 52 | docs/system/arm/aspeed.rst | 1 - |
| 30 | aspeed: g220a-bmc: Add an FRU | 53 | include/hw/sd/aspeed_sdhci.h | 13 +- |
| 54 | tests/qtest/aspeed-smc-utils.h | 95 ++++ | ||
| 55 | hw/arm/aspeed.c | 28 - | ||
| 56 | hw/arm/aspeed_ast2400.c | 3 +- | ||
| 57 | hw/arm/aspeed_ast2600.c | 10 +- | ||
| 58 | hw/arm/aspeed_ast27x0.c | 35 ++ | ||
| 59 | hw/sd/aspeed_sdhci.c | 67 ++- | ||
| 60 | tests/qtest/aspeed-smc-utils.c | 686 ++++++++++++++++++++++++ | ||
| 61 | tests/qtest/aspeed_smc-test.c | 775 ++++++--------------------- | ||
| 62 | tests/qtest/ast2700-smc-test.c | 71 +++ | ||
| 63 | tests/avocado/boot_linux_console.py | 26 - | ||
| 64 | tests/functional/aspeed.py | 56 ++ | ||
| 65 | tests/functional/meson.build | 13 +- | ||
| 66 | tests/functional/test_arm_aspeed.py | 351 ------------ | ||
| 67 | tests/functional/test_arm_aspeed_ast1030.py | 81 +++ | ||
| 68 | tests/functional/test_arm_aspeed_ast2500.py | 59 ++ | ||
| 69 | tests/functional/test_arm_aspeed_ast2600.py | 143 +++++ | ||
| 70 | tests/functional/test_arm_aspeed_palmetto.py | 24 + | ||
| 71 | tests/functional/test_arm_aspeed_rainier.py | 64 +++ | ||
| 72 | tests/functional/test_arm_aspeed_romulus.py | 24 + | ||
| 73 | tests/qtest/meson.build | 5 +- | ||
| 74 | 24 files changed, 1623 insertions(+), 1025 deletions(-) | ||
| 75 | create mode 100644 tests/qtest/aspeed-smc-utils.h | ||
| 76 | create mode 100644 tests/qtest/aspeed-smc-utils.c | ||
| 77 | create mode 100644 tests/qtest/ast2700-smc-test.c | ||
| 78 | create mode 100644 tests/functional/aspeed.py | ||
| 79 | delete mode 100755 tests/functional/test_arm_aspeed.py | ||
| 80 | create mode 100644 tests/functional/test_arm_aspeed_ast1030.py | ||
| 81 | create mode 100644 tests/functional/test_arm_aspeed_ast2500.py | ||
| 82 | create mode 100644 tests/functional/test_arm_aspeed_ast2600.py | ||
| 83 | create mode 100644 tests/functional/test_arm_aspeed_palmetto.py | ||
| 84 | create mode 100644 tests/functional/test_arm_aspeed_rainier.py | ||
| 85 | create mode 100644 tests/functional/test_arm_aspeed_romulus.py | ||
| 31 | 86 | ||
| 32 | include/hw/misc/emc141x_regs.h | 37 +++++ | ||
| 33 | hw/arm/aspeed.c | 72 +++++++++ | ||
| 34 | hw/arm/aspeed_ast2600.c | 2 +- | ||
| 35 | hw/misc/emc141x.c | 326 +++++++++++++++++++++++++++++++++++++++++ | ||
| 36 | hw/ssi/aspeed_smc.c | 25 +++- | ||
| 37 | tests/qtest/emc141x-test.c | 81 ++++++++++ | ||
| 38 | hw/arm/Kconfig | 1 + | ||
| 39 | hw/misc/Kconfig | 4 + | ||
| 40 | hw/misc/meson.build | 1 + | ||
| 41 | tests/qtest/meson.build | 1 + | ||
| 42 | 10 files changed, 542 insertions(+), 8 deletions(-) | ||
| 43 | create mode 100644 include/hw/misc/emc141x_regs.h | ||
| 44 | create mode 100644 hw/misc/emc141x.c | ||
| 45 | create mode 100644 tests/qtest/emc141x-test.c | ||
| 46 | 87 | diff view generated by jsdifflib |
| 1 | From: John Wang <wangzhiqiang.bj@bytedance.com> | 1 | Removal was scheduled for 10.0. Use the rainier-bmc machine or the |
|---|---|---|---|
| 2 | ast2600-evb as a replacement. | ||
| 2 | 3 | ||
| 3 | Add an eeprom device and fill it with fru | 4 | Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org> |
| 4 | information | 5 | Link: https://lore.kernel.org/r/20241119071352.515790-1-clg@redhat.com |
| 6 | Signed-off-by: Cédric Le Goater <clg@redhat.com> | ||
| 7 | --- | ||
| 8 | docs/about/deprecated.rst | 8 -------- | ||
| 9 | docs/about/removed-features.rst | 10 ++++++++++ | ||
| 10 | docs/system/arm/aspeed.rst | 1 - | ||
| 11 | hw/arm/aspeed.c | 28 ---------------------------- | ||
| 12 | 4 files changed, 10 insertions(+), 37 deletions(-) | ||
| 5 | 13 | ||
| 6 | $ ipmitool fru print 0 | 14 | diff --git a/docs/about/deprecated.rst b/docs/about/deprecated.rst |
| 7 | Product Manufacturer : Bytedance | 15 | index XXXXXXX..XXXXXXX 100644 |
| 8 | Product Name : G220A | 16 | --- a/docs/about/deprecated.rst |
| 9 | 17 | +++ b/docs/about/deprecated.rst | |
| 10 | Signed-off-by: John Wang <wangzhiqiang.bj@bytedance.com> | 18 | @@ -XXX,XX +XXX,XX @@ images are not available, OpenWRT dropped support in 2019, U-Boot in |
| 11 | Reviewed-by: Cédric Le Goater <clg@kaod.org> | 19 | 2017, Linux also is dropping support in 2024. It is time to let go of |
| 12 | Message-Id: <20201210103607.556-1-wangzhiqiang.bj@bytedance.com> | 20 | this ancient hardware and focus on newer CPUs and platforms. |
| 13 | Signed-off-by: Cédric Le Goater <clg@kaod.org> | 21 | |
| 14 | --- | 22 | -Arm ``tacoma-bmc`` machine (since 9.1) |
| 15 | hw/arm/aspeed.c | 12 ++++++++++++ | 23 | -'''''''''''''''''''''''''''''''''''''''' |
| 16 | 1 file changed, 12 insertions(+) | 24 | - |
| 17 | 25 | -The ``tacoma-bmc`` machine was a board including an AST2600 SoC based | |
| 26 | -BMC and a witherspoon like OpenPOWER system. It was used for bring up | ||
| 27 | -of the AST2600 SoC in labs. It can be easily replaced by the | ||
| 28 | -``rainier-bmc`` machine which is a real product. | ||
| 29 | - | ||
| 30 | Big-Endian variants of MicroBlaze ``petalogix-ml605`` and ``xlnx-zynqmp-pmu`` machines (since 9.2) | ||
| 31 | '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' | ||
| 32 | |||
| 33 | diff --git a/docs/about/removed-features.rst b/docs/about/removed-features.rst | ||
| 34 | index XXXXXXX..XXXXXXX 100644 | ||
| 35 | --- a/docs/about/removed-features.rst | ||
| 36 | +++ b/docs/about/removed-features.rst | ||
| 37 | @@ -XXX,XX +XXX,XX @@ Aspeed ``swift-bmc`` machine (removed in 7.0) | ||
| 38 | This machine was removed because it was unused. Alternative AST2500 based | ||
| 39 | OpenPOWER machines are ``witherspoon-bmc`` and ``romulus-bmc``. | ||
| 40 | |||
| 41 | +Aspeed ``tacoma-bmc`` machine (removed in 10.0) | ||
| 42 | +''''''''''''''''''''''''''''''''''''''''''''''' | ||
| 43 | + | ||
| 44 | +The ``tacoma-bmc`` machine was removed because it didn't bring much | ||
| 45 | +compared to the ``rainier-bmc`` machine. Also, the ``tacoma-bmc`` was | ||
| 46 | +a board used for bring up of the AST2600 SoC that never left the | ||
| 47 | +labs. It can be easily replaced by the ``rainier-bmc`` machine, which | ||
| 48 | +was the actual final product, or by the ``ast2600-evb`` with some | ||
| 49 | +tweaks. | ||
| 50 | + | ||
| 51 | ppc ``taihu`` machine (removed in 7.2) | ||
| 52 | ''''''''''''''''''''''''''''''''''''''''''''' | ||
| 53 | |||
| 54 | diff --git a/docs/system/arm/aspeed.rst b/docs/system/arm/aspeed.rst | ||
| 55 | index XXXXXXX..XXXXXXX 100644 | ||
| 56 | --- a/docs/system/arm/aspeed.rst | ||
| 57 | +++ b/docs/system/arm/aspeed.rst | ||
| 58 | @@ -XXX,XX +XXX,XX @@ AST2500 SoC based machines : | ||
| 59 | AST2600 SoC based machines : | ||
| 60 | |||
| 61 | - ``ast2600-evb`` Aspeed AST2600 Evaluation board (Cortex-A7) | ||
| 62 | -- ``tacoma-bmc`` OpenPOWER Witherspoon POWER9 AST2600 BMC | ||
| 63 | - ``rainier-bmc`` IBM Rainier POWER10 BMC | ||
| 64 | - ``fuji-bmc`` Facebook Fuji BMC | ||
| 65 | - ``bletchley-bmc`` Facebook Bletchley BMC | ||
| 18 | diff --git a/hw/arm/aspeed.c b/hw/arm/aspeed.c | 66 | diff --git a/hw/arm/aspeed.c b/hw/arm/aspeed.c |
| 19 | index XXXXXXX..XXXXXXX 100644 | 67 | index XXXXXXX..XXXXXXX 100644 |
| 20 | --- a/hw/arm/aspeed.c | 68 | --- a/hw/arm/aspeed.c |
| 21 | +++ b/hw/arm/aspeed.c | 69 | +++ b/hw/arm/aspeed.c |
| 22 | @@ -XXX,XX +XXX,XX @@ static void g220a_bmc_i2c_init(AspeedMachineState *bmc) | 70 | @@ -XXX,XX +XXX,XX @@ struct AspeedMachineState { |
| 23 | object_property_set_int(OBJECT(dev), "temperature0", 31000, &error_abort); | 71 | #define AST2700_EVB_HW_STRAP2 0x00000003 |
| 24 | object_property_set_int(OBJECT(dev), "temperature1", 28000, &error_abort); | 72 | #endif |
| 25 | object_property_set_int(OBJECT(dev), "temperature2", 20000, &error_abort); | 73 | |
| 26 | + | 74 | -/* Tacoma hardware value */ |
| 27 | + static uint8_t eeprom_buf[2 * 1024] = { | 75 | -#define TACOMA_BMC_HW_STRAP1 0x00000000 |
| 28 | + 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0xfe, | 76 | -#define TACOMA_BMC_HW_STRAP2 0x00000040 |
| 29 | + 0x01, 0x06, 0x00, 0xc9, 0x42, 0x79, 0x74, 0x65, | 77 | - |
| 30 | + 0x64, 0x61, 0x6e, 0x63, 0x65, 0xc5, 0x47, 0x32, | 78 | /* Rainier hardware value: (QEMU prototype) */ |
| 31 | + 0x32, 0x30, 0x41, 0xc4, 0x41, 0x41, 0x42, 0x42, | 79 | #define RAINIER_BMC_HW_STRAP1 (0x00422016 | SCU_AST2600_HW_STRAP_BOOT_SRC_EMMC) |
| 32 | + 0xc4, 0x43, 0x43, 0x44, 0x44, 0xc4, 0x45, 0x45, | 80 | #define RAINIER_BMC_HW_STRAP2 0x80000848 |
| 33 | + 0x46, 0x46, 0xc4, 0x48, 0x48, 0x47, 0x47, 0xc1, | 81 | @@ -XXX,XX +XXX,XX @@ static void aspeed_machine_ast2600_evb_class_init(ObjectClass *oc, void *data) |
| 34 | + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa7, | 82 | aspeed_machine_ast2600_class_emmc_init(oc); |
| 35 | + }; | 83 | }; |
| 36 | + smbus_eeprom_init_one(aspeed_i2c_get_bus(&soc->i2c, 4), 0x57, | 84 | |
| 37 | + eeprom_buf); | 85 | -static void aspeed_machine_tacoma_class_init(ObjectClass *oc, void *data) |
| 38 | } | 86 | -{ |
| 39 | 87 | - MachineClass *mc = MACHINE_CLASS(oc); | |
| 40 | static bool aspeed_get_mmio_exec(Object *obj, Error **errp) | 88 | - AspeedMachineClass *amc = ASPEED_MACHINE_CLASS(oc); |
| 89 | - | ||
| 90 | - mc->desc = "OpenPOWER Tacoma BMC (Cortex-A7)"; | ||
| 91 | - amc->soc_name = "ast2600-a3"; | ||
| 92 | - amc->hw_strap1 = TACOMA_BMC_HW_STRAP1; | ||
| 93 | - amc->hw_strap2 = TACOMA_BMC_HW_STRAP2; | ||
| 94 | - amc->fmc_model = "mx66l1g45g"; | ||
| 95 | - amc->spi_model = "mx66l1g45g"; | ||
| 96 | - amc->num_cs = 2; | ||
| 97 | - amc->macs_mask = ASPEED_MAC2_ON; | ||
| 98 | - amc->i2c_init = witherspoon_bmc_i2c_init; /* Same board layout */ | ||
| 99 | - mc->default_ram_size = 1 * GiB; | ||
| 100 | - aspeed_machine_class_init_cpus_defaults(mc); | ||
| 101 | - | ||
| 102 | - mc->deprecation_reason = "Please use the similar 'rainier-bmc' machine"; | ||
| 103 | -}; | ||
| 104 | - | ||
| 105 | static void aspeed_machine_g220a_class_init(ObjectClass *oc, void *data) | ||
| 106 | { | ||
| 107 | MachineClass *mc = MACHINE_CLASS(oc); | ||
| 108 | @@ -XXX,XX +XXX,XX @@ static const TypeInfo aspeed_machine_types[] = { | ||
| 109 | .name = MACHINE_TYPE_NAME("yosemitev2-bmc"), | ||
| 110 | .parent = TYPE_ASPEED_MACHINE, | ||
| 111 | .class_init = aspeed_machine_yosemitev2_class_init, | ||
| 112 | - }, { | ||
| 113 | - .name = MACHINE_TYPE_NAME("tacoma-bmc"), | ||
| 114 | - .parent = TYPE_ASPEED_MACHINE, | ||
| 115 | - .class_init = aspeed_machine_tacoma_class_init, | ||
| 116 | }, { | ||
| 117 | .name = MACHINE_TYPE_NAME("tiogapass-bmc"), | ||
| 118 | .parent = TYPE_ASPEED_MACHINE, | ||
| 41 | -- | 119 | -- |
| 42 | 2.26.2 | 120 | 2.47.1 |
| 43 | 121 | ||
| 44 | 122 | diff view generated by jsdifflib |
New patch | |||
|---|---|---|---|
| 1 | From: Jamin Lin <jamin_lin@aspeedtech.com> | ||
| 1 | 2 | ||
| 3 | Fix coding style issues from checkpatch.pl. | ||
| 4 | |||
| 5 | Signed-off-by: Jamin Lin <jamin_lin@aspeedtech.com> | ||
| 6 | Reviewed-by: Cédric Le Goater <clg@redhat.com> | ||
| 7 | Link: https://lore.kernel.org/r/20241204084453.610660-2-jamin_lin@aspeedtech.com | ||
| 8 | Signed-off-by: Cédric Le Goater <clg@redhat.com> | ||
| 9 | --- | ||
| 10 | hw/sd/aspeed_sdhci.c | 6 ++++-- | ||
| 11 | 1 file changed, 4 insertions(+), 2 deletions(-) | ||
| 12 | |||
| 13 | diff --git a/hw/sd/aspeed_sdhci.c b/hw/sd/aspeed_sdhci.c | ||
| 14 | index XXXXXXX..XXXXXXX 100644 | ||
| 15 | --- a/hw/sd/aspeed_sdhci.c | ||
| 16 | +++ b/hw/sd/aspeed_sdhci.c | ||
| 17 | @@ -XXX,XX +XXX,XX @@ static void aspeed_sdhci_write(void *opaque, hwaddr addr, uint64_t val, | ||
| 18 | sdhci->regs[TO_REG(addr)] = (uint32_t)val & ~ASPEED_SDHCI_INFO_RESET; | ||
| 19 | break; | ||
| 20 | case ASPEED_SDHCI_SDIO_140: | ||
| 21 | - sdhci->slots[0].capareg = deposit64(sdhci->slots[0].capareg, 0, 32, val); | ||
| 22 | + sdhci->slots[0].capareg = deposit64(sdhci->slots[0].capareg, | ||
| 23 | + 0, 32, val); | ||
| 24 | break; | ||
| 25 | case ASPEED_SDHCI_SDIO_144: | ||
| 26 | - sdhci->slots[0].capareg = deposit64(sdhci->slots[0].capareg, 32, 32, val); | ||
| 27 | + sdhci->slots[0].capareg = deposit64(sdhci->slots[0].capareg, | ||
| 28 | + 32, 32, val); | ||
| 29 | break; | ||
| 30 | case ASPEED_SDHCI_SDIO_148: | ||
| 31 | sdhci->slots[0].maxcurr = deposit64(sdhci->slots[0].maxcurr, | ||
| 32 | -- | ||
| 33 | 2.47.1 | ||
| 34 | |||
| 35 | diff view generated by jsdifflib |
| 1 | From: Joel Stanley <joel@jms.id.au> | 1 | From: Jamin Lin <jamin_lin@aspeedtech.com> |
|---|---|---|---|
| 2 | 2 | ||
| 3 | On the AST2600A1, the SRAM size was increased to 89KB. | 3 | Fix coding style issues from checkpatch.pl. |
| 4 | 4 | ||
| 5 | Fixes: 7582591ae745 ("aspeed: Support AST2600A1 silicon revision") | 5 | Signed-off-by: Jamin Lin <jamin_lin@aspeedtech.com> |
| 6 | Signed-off-by: Joel Stanley <joel@jms.id.au> | 6 | Reviewed-by: Cédric Le Goater <clg@redhat.com> |
| 7 | Reviewed-by: Cédric Le Goater <clg@kaod.org> | 7 | Link: https://lore.kernel.org/r/20241204084453.610660-3-jamin_lin@aspeedtech.com |
| 8 | Message-Id: <20201112012113.835858-1-joel@jms.id.au> | 8 | Signed-off-by: Cédric Le Goater <clg@redhat.com> |
| 9 | Signed-off-by: Cédric Le Goater <clg@kaod.org> | ||
| 10 | --- | 9 | --- |
| 11 | hw/arm/aspeed_ast2600.c | 2 +- | 10 | hw/arm/aspeed_ast2600.c | 3 ++- |
| 12 | 1 file changed, 1 insertion(+), 1 deletion(-) | 11 | 1 file changed, 2 insertions(+), 1 deletion(-) |
| 13 | 12 | ||
| 14 | diff --git a/hw/arm/aspeed_ast2600.c b/hw/arm/aspeed_ast2600.c | 13 | diff --git a/hw/arm/aspeed_ast2600.c b/hw/arm/aspeed_ast2600.c |
| 15 | index XXXXXXX..XXXXXXX 100644 | 14 | index XXXXXXX..XXXXXXX 100644 |
| 16 | --- a/hw/arm/aspeed_ast2600.c | 15 | --- a/hw/arm/aspeed_ast2600.c |
| 17 | +++ b/hw/arm/aspeed_ast2600.c | 16 | +++ b/hw/arm/aspeed_ast2600.c |
| 18 | @@ -XXX,XX +XXX,XX @@ static void aspeed_soc_ast2600_class_init(ObjectClass *oc, void *data) | 17 | @@ -XXX,XX +XXX,XX @@ static void aspeed_soc_ast2600_realize(DeviceState *dev, Error **errp) |
| 19 | sc->name = "ast2600-a1"; | 18 | if (!sysbus_realize(SYS_BUS_DEVICE(&s->gpio), errp)) { |
| 20 | sc->cpu_type = ARM_CPU_TYPE_NAME("cortex-a7"); | 19 | return; |
| 21 | sc->silicon_rev = AST2600_A1_SILICON_REV; | 20 | } |
| 22 | - sc->sram_size = 0x10000; | 21 | - aspeed_mmio_map(s, SYS_BUS_DEVICE(&s->gpio), 0, sc->memmap[ASPEED_DEV_GPIO]); |
| 23 | + sc->sram_size = 0x16400; | 22 | + aspeed_mmio_map(s, SYS_BUS_DEVICE(&s->gpio), 0, |
| 24 | sc->spis_num = 2; | 23 | + sc->memmap[ASPEED_DEV_GPIO]); |
| 25 | sc->ehcis_num = 2; | 24 | sysbus_connect_irq(SYS_BUS_DEVICE(&s->gpio), 0, |
| 26 | sc->wdts_num = 4; | 25 | aspeed_soc_get_irq(s, ASPEED_DEV_GPIO)); |
| 26 | |||
| 27 | -- | 27 | -- |
| 28 | 2.26.2 | 28 | 2.47.1 |
| 29 | 29 | ||
| 30 | 30 | diff view generated by jsdifflib |
| 1 | From: John Wang <wangzhiqiang.bj@bytedance.com> | 1 | From: Jamin Lin <jamin_lin@aspeedtech.com> |
|---|---|---|---|
| 2 | 2 | ||
| 3 | G220A is a 2 socket x86 motherboard supported by OpenBMC. | 3 | Currently, it set the hardcode value of capability registers to all ASPEED SOCs |
| 4 | Strapping configuration was obtained from hardware. | 4 | However, the value of capability registers should be different for all ASPEED |
| 5 | SOCs. For example: the bit 28 of the Capability Register 1 should be 1 for | ||
| 6 | 64-bits System Bus support for AST2700. | ||
| 5 | 7 | ||
| 6 | Signed-off-by: John Wang <wangzhiqiang.bj@bytedance.com> | 8 | Introduce a new "capareg" class member whose data type is uint_64 to set the |
| 7 | Reviewed-by: Cédric Le Goater <clg@kaod.org> | 9 | different Capability Registers to all ASPEED SOCs. |
| 8 | Reviewed-by: Joel Stanley <joel@jms.id.au> | 10 | |
| 9 | Message-Id: <20201122105134.671-2-wangzhiqiang.bj@bytedance.com> | 11 | The value of Capability Register is "0x0000000001e80080" for AST2400 and |
| 10 | Signed-off-by: Cédric Le Goater <clg@kaod.org> | 12 | AST2500. The value of Capability Register is "0x0000000701f80080" for AST2600. |
| 13 | |||
| 14 | Signed-off-by: Jamin Lin <jamin_lin@aspeedtech.com> | ||
| 15 | Reviewed-by: Cédric Le Goater <clg@redhat.com> | ||
| 16 | Link: https://lore.kernel.org/r/20241204084453.610660-4-jamin_lin@aspeedtech.com | ||
| 17 | Signed-off-by: Cédric Le Goater <clg@redhat.com> | ||
| 11 | --- | 18 | --- |
| 12 | hw/arm/aspeed.c | 60 +++++++++++++++++++++++++++++++++++++++++++++++++ | 19 | include/hw/sd/aspeed_sdhci.h | 12 +++++++-- |
| 13 | 1 file changed, 60 insertions(+) | 20 | hw/arm/aspeed_ast2400.c | 3 ++- |
| 21 | hw/arm/aspeed_ast2600.c | 7 +++--- | ||
| 22 | hw/sd/aspeed_sdhci.c | 47 +++++++++++++++++++++++++++++++++++- | ||
| 23 | 4 files changed, 61 insertions(+), 8 deletions(-) | ||
| 14 | 24 | ||
| 15 | diff --git a/hw/arm/aspeed.c b/hw/arm/aspeed.c | 25 | diff --git a/include/hw/sd/aspeed_sdhci.h b/include/hw/sd/aspeed_sdhci.h |
| 16 | index XXXXXXX..XXXXXXX 100644 | 26 | index XXXXXXX..XXXXXXX 100644 |
| 17 | --- a/hw/arm/aspeed.c | 27 | --- a/include/hw/sd/aspeed_sdhci.h |
| 18 | +++ b/hw/arm/aspeed.c | 28 | +++ b/include/hw/sd/aspeed_sdhci.h |
| 19 | @@ -XXX,XX +XXX,XX @@ struct AspeedMachineState { | 29 | @@ -XXX,XX +XXX,XX @@ |
| 20 | SCU_AST2500_HW_STRAP_ACPI_ENABLE | \ | 30 | #include "qom/object.h" |
| 21 | SCU_HW_STRAP_SPI_MODE(SCU_HW_STRAP_SPI_MASTER)) | 31 | |
| 22 | 32 | #define TYPE_ASPEED_SDHCI "aspeed.sdhci" | |
| 23 | +#define G220A_BMC_HW_STRAP1 ( \ | 33 | -OBJECT_DECLARE_SIMPLE_TYPE(AspeedSDHCIState, ASPEED_SDHCI) |
| 24 | + SCU_AST2500_HW_STRAP_SPI_AUTOFETCH_ENABLE | \ | 34 | +#define TYPE_ASPEED_2400_SDHCI TYPE_ASPEED_SDHCI "-ast2400" |
| 25 | + SCU_AST2500_HW_STRAP_GPIO_STRAP_ENABLE | \ | 35 | +#define TYPE_ASPEED_2500_SDHCI TYPE_ASPEED_SDHCI "-ast2500" |
| 26 | + SCU_AST2500_HW_STRAP_UART_DEBUG | \ | 36 | +#define TYPE_ASPEED_2600_SDHCI TYPE_ASPEED_SDHCI "-ast2600" |
| 27 | + SCU_AST2500_HW_STRAP_RESERVED28 | \ | 37 | +OBJECT_DECLARE_TYPE(AspeedSDHCIState, AspeedSDHCIClass, ASPEED_SDHCI) |
| 28 | + SCU_AST2500_HW_STRAP_DDR4_ENABLE | \ | 38 | |
| 29 | + SCU_HW_STRAP_2ND_BOOT_WDT | \ | 39 | -#define ASPEED_SDHCI_CAPABILITIES 0x01E80080 |
| 30 | + SCU_HW_STRAP_VGA_CLASS_CODE | \ | 40 | #define ASPEED_SDHCI_NUM_SLOTS 2 |
| 31 | + SCU_HW_STRAP_LPC_RESET_PIN | \ | 41 | #define ASPEED_SDHCI_NUM_REGS (ASPEED_SDHCI_REG_SIZE / sizeof(uint32_t)) |
| 32 | + SCU_HW_STRAP_SPI_MODE(SCU_HW_STRAP_SPI_MASTER) | \ | 42 | #define ASPEED_SDHCI_REG_SIZE 0x100 |
| 33 | + SCU_AST2500_HW_STRAP_SET_AXI_AHB_RATIO(AXI_AHB_RATIO_2_1) | \ | 43 | @@ -XXX,XX +XXX,XX @@ struct AspeedSDHCIState { |
| 34 | + SCU_HW_STRAP_VGA_SIZE_SET(VGA_64M_DRAM) | \ | 44 | uint32_t regs[ASPEED_SDHCI_NUM_REGS]; |
| 35 | + SCU_AST2500_HW_STRAP_RESERVED1) | 45 | }; |
| 46 | |||
| 47 | +struct AspeedSDHCIClass { | ||
| 48 | + SysBusDeviceClass parent_class; | ||
| 36 | + | 49 | + |
| 37 | /* Witherspoon hardware value: 0xF10AD216 (but use romulus definition) */ | 50 | + uint64_t capareg; |
| 38 | #define WITHERSPOON_BMC_HW_STRAP1 ROMULUS_BMC_HW_STRAP1 | 51 | +}; |
| 39 | 52 | + | |
| 40 | @@ -XXX,XX +XXX,XX @@ static void witherspoon_bmc_i2c_init(AspeedMachineState *bmc) | 53 | #endif /* ASPEED_SDHCI_H */ |
| 41 | /* Bus 11: TODO ucd90160@64 */ | 54 | diff --git a/hw/arm/aspeed_ast2400.c b/hw/arm/aspeed_ast2400.c |
| 55 | index XXXXXXX..XXXXXXX 100644 | ||
| 56 | --- a/hw/arm/aspeed_ast2400.c | ||
| 57 | +++ b/hw/arm/aspeed_ast2400.c | ||
| 58 | @@ -XXX,XX +XXX,XX @@ static void aspeed_ast2400_soc_init(Object *obj) | ||
| 59 | snprintf(typename, sizeof(typename), "aspeed.gpio-%s", socname); | ||
| 60 | object_initialize_child(obj, "gpio", &s->gpio, typename); | ||
| 61 | |||
| 62 | - object_initialize_child(obj, "sdc", &s->sdhci, TYPE_ASPEED_SDHCI); | ||
| 63 | + snprintf(typename, sizeof(typename), "aspeed.sdhci-%s", socname); | ||
| 64 | + object_initialize_child(obj, "sdc", &s->sdhci, typename); | ||
| 65 | |||
| 66 | object_property_set_int(OBJECT(&s->sdhci), "num-slots", 2, &error_abort); | ||
| 67 | |||
| 68 | diff --git a/hw/arm/aspeed_ast2600.c b/hw/arm/aspeed_ast2600.c | ||
| 69 | index XXXXXXX..XXXXXXX 100644 | ||
| 70 | --- a/hw/arm/aspeed_ast2600.c | ||
| 71 | +++ b/hw/arm/aspeed_ast2600.c | ||
| 72 | @@ -XXX,XX +XXX,XX @@ static void aspeed_soc_ast2600_init(Object *obj) | ||
| 73 | snprintf(typename, sizeof(typename), "aspeed.gpio-%s-1_8v", socname); | ||
| 74 | object_initialize_child(obj, "gpio_1_8v", &s->gpio_1_8v, typename); | ||
| 75 | |||
| 76 | - object_initialize_child(obj, "sd-controller", &s->sdhci, | ||
| 77 | - TYPE_ASPEED_SDHCI); | ||
| 78 | + snprintf(typename, sizeof(typename), "aspeed.sdhci-%s", socname); | ||
| 79 | + object_initialize_child(obj, "sd-controller", &s->sdhci, typename); | ||
| 80 | |||
| 81 | object_property_set_int(OBJECT(&s->sdhci), "num-slots", 2, &error_abort); | ||
| 82 | |||
| 83 | @@ -XXX,XX +XXX,XX @@ static void aspeed_soc_ast2600_init(Object *obj) | ||
| 84 | &s->sdhci.slots[i], TYPE_SYSBUS_SDHCI); | ||
| 85 | } | ||
| 86 | |||
| 87 | - object_initialize_child(obj, "emmc-controller", &s->emmc, | ||
| 88 | - TYPE_ASPEED_SDHCI); | ||
| 89 | + object_initialize_child(obj, "emmc-controller", &s->emmc, typename); | ||
| 90 | |||
| 91 | object_property_set_int(OBJECT(&s->emmc), "num-slots", 1, &error_abort); | ||
| 92 | |||
| 93 | diff --git a/hw/sd/aspeed_sdhci.c b/hw/sd/aspeed_sdhci.c | ||
| 94 | index XXXXXXX..XXXXXXX 100644 | ||
| 95 | --- a/hw/sd/aspeed_sdhci.c | ||
| 96 | +++ b/hw/sd/aspeed_sdhci.c | ||
| 97 | @@ -XXX,XX +XXX,XX @@ static void aspeed_sdhci_realize(DeviceState *dev, Error **errp) | ||
| 98 | { | ||
| 99 | SysBusDevice *sbd = SYS_BUS_DEVICE(dev); | ||
| 100 | AspeedSDHCIState *sdhci = ASPEED_SDHCI(dev); | ||
| 101 | + AspeedSDHCIClass *asc = ASPEED_SDHCI_GET_CLASS(sdhci); | ||
| 102 | |||
| 103 | /* Create input irqs for the slots */ | ||
| 104 | qdev_init_gpio_in_named_with_opaque(DEVICE(sbd), aspeed_sdhci_set_irq, | ||
| 105 | @@ -XXX,XX +XXX,XX @@ static void aspeed_sdhci_realize(DeviceState *dev, Error **errp) | ||
| 106 | } | ||
| 107 | |||
| 108 | if (!object_property_set_uint(sdhci_slot, "capareg", | ||
| 109 | - ASPEED_SDHCI_CAPABILITIES, errp)) { | ||
| 110 | + asc->capareg, errp)) { | ||
| 111 | return; | ||
| 112 | } | ||
| 113 | |||
| 114 | @@ -XXX,XX +XXX,XX @@ static void aspeed_sdhci_class_init(ObjectClass *classp, void *data) | ||
| 115 | device_class_set_props(dc, aspeed_sdhci_properties); | ||
| 42 | } | 116 | } |
| 43 | 117 | ||
| 44 | +static void g220a_bmc_i2c_init(AspeedMachineState *bmc) | 118 | +static void aspeed_2400_sdhci_class_init(ObjectClass *klass, void *data) |
| 45 | +{ | 119 | +{ |
| 46 | + AspeedSoCState *soc = &bmc->soc; | 120 | + DeviceClass *dc = DEVICE_CLASS(klass); |
| 47 | + DeviceState *dev; | 121 | + AspeedSDHCIClass *asc = ASPEED_SDHCI_CLASS(klass); |
| 48 | + | 122 | + |
| 49 | + dev = DEVICE(i2c_slave_create_simple(aspeed_i2c_get_bus(&soc->i2c, 3), | 123 | + dc->desc = "ASPEED 2400 SDHCI Controller"; |
| 50 | + "emc1413", 0x4c)); | 124 | + asc->capareg = 0x0000000001e80080; |
| 51 | + object_property_set_int(OBJECT(dev), "temperature0", 31000, &error_abort); | ||
| 52 | + object_property_set_int(OBJECT(dev), "temperature1", 28000, &error_abort); | ||
| 53 | + object_property_set_int(OBJECT(dev), "temperature2", 20000, &error_abort); | ||
| 54 | + | ||
| 55 | + dev = DEVICE(i2c_slave_create_simple(aspeed_i2c_get_bus(&soc->i2c, 12), | ||
| 56 | + "emc1413", 0x4c)); | ||
| 57 | + object_property_set_int(OBJECT(dev), "temperature0", 31000, &error_abort); | ||
| 58 | + object_property_set_int(OBJECT(dev), "temperature1", 28000, &error_abort); | ||
| 59 | + object_property_set_int(OBJECT(dev), "temperature2", 20000, &error_abort); | ||
| 60 | + | ||
| 61 | + dev = DEVICE(i2c_slave_create_simple(aspeed_i2c_get_bus(&soc->i2c, 13), | ||
| 62 | + "emc1413", 0x4c)); | ||
| 63 | + object_property_set_int(OBJECT(dev), "temperature0", 31000, &error_abort); | ||
| 64 | + object_property_set_int(OBJECT(dev), "temperature1", 28000, &error_abort); | ||
| 65 | + object_property_set_int(OBJECT(dev), "temperature2", 20000, &error_abort); | ||
| 66 | +} | 125 | +} |
| 67 | + | 126 | + |
| 68 | static bool aspeed_get_mmio_exec(Object *obj, Error **errp) | 127 | +static void aspeed_2500_sdhci_class_init(ObjectClass *klass, void *data) |
| 69 | { | 128 | +{ |
| 70 | return ASPEED_MACHINE(obj)->mmio_exec; | 129 | + DeviceClass *dc = DEVICE_CLASS(klass); |
| 71 | @@ -XXX,XX +XXX,XX @@ static void aspeed_machine_tacoma_class_init(ObjectClass *oc, void *data) | 130 | + AspeedSDHCIClass *asc = ASPEED_SDHCI_CLASS(klass); |
| 72 | aspeed_soc_num_cpus(amc->soc_name); | 131 | + |
| 132 | + dc->desc = "ASPEED 2500 SDHCI Controller"; | ||
| 133 | + asc->capareg = 0x0000000001e80080; | ||
| 134 | +} | ||
| 135 | + | ||
| 136 | +static void aspeed_2600_sdhci_class_init(ObjectClass *klass, void *data) | ||
| 137 | +{ | ||
| 138 | + DeviceClass *dc = DEVICE_CLASS(klass); | ||
| 139 | + AspeedSDHCIClass *asc = ASPEED_SDHCI_CLASS(klass); | ||
| 140 | + | ||
| 141 | + dc->desc = "ASPEED 2600 SDHCI Controller"; | ||
| 142 | + asc->capareg = 0x0000000701f80080; | ||
| 143 | +} | ||
| 144 | + | ||
| 145 | static const TypeInfo aspeed_sdhci_types[] = { | ||
| 146 | { | ||
| 147 | .name = TYPE_ASPEED_SDHCI, | ||
| 148 | .parent = TYPE_SYS_BUS_DEVICE, | ||
| 149 | .instance_size = sizeof(AspeedSDHCIState), | ||
| 150 | .class_init = aspeed_sdhci_class_init, | ||
| 151 | + .class_size = sizeof(AspeedSDHCIClass), | ||
| 152 | + .abstract = true, | ||
| 153 | + }, | ||
| 154 | + { | ||
| 155 | + .name = TYPE_ASPEED_2400_SDHCI, | ||
| 156 | + .parent = TYPE_ASPEED_SDHCI, | ||
| 157 | + .class_init = aspeed_2400_sdhci_class_init, | ||
| 158 | + }, | ||
| 159 | + { | ||
| 160 | + .name = TYPE_ASPEED_2500_SDHCI, | ||
| 161 | + .parent = TYPE_ASPEED_SDHCI, | ||
| 162 | + .class_init = aspeed_2500_sdhci_class_init, | ||
| 163 | + }, | ||
| 164 | + { | ||
| 165 | + .name = TYPE_ASPEED_2600_SDHCI, | ||
| 166 | + .parent = TYPE_ASPEED_SDHCI, | ||
| 167 | + .class_init = aspeed_2600_sdhci_class_init, | ||
| 168 | }, | ||
| 73 | }; | 169 | }; |
| 74 | 170 | ||
| 75 | +static void aspeed_machine_g220a_class_init(ObjectClass *oc, void *data) | ||
| 76 | +{ | ||
| 77 | + MachineClass *mc = MACHINE_CLASS(oc); | ||
| 78 | + AspeedMachineClass *amc = ASPEED_MACHINE_CLASS(oc); | ||
| 79 | + | ||
| 80 | + mc->desc = "Bytedance G220A BMC (ARM1176)"; | ||
| 81 | + amc->soc_name = "ast2500-a1"; | ||
| 82 | + amc->hw_strap1 = G220A_BMC_HW_STRAP1; | ||
| 83 | + amc->fmc_model = "n25q512a"; | ||
| 84 | + amc->spi_model = "mx25l25635e"; | ||
| 85 | + amc->num_cs = 2; | ||
| 86 | + amc->macs_mask = ASPEED_MAC1_ON | ASPEED_MAC2_ON; | ||
| 87 | + amc->i2c_init = g220a_bmc_i2c_init; | ||
| 88 | + mc->default_ram_size = 1024 * MiB; | ||
| 89 | + mc->default_cpus = mc->min_cpus = mc->max_cpus = | ||
| 90 | + aspeed_soc_num_cpus(amc->soc_name); | ||
| 91 | +}; | ||
| 92 | + | ||
| 93 | static const TypeInfo aspeed_machine_types[] = { | ||
| 94 | { | ||
| 95 | .name = MACHINE_TYPE_NAME("palmetto-bmc"), | ||
| 96 | @@ -XXX,XX +XXX,XX @@ static const TypeInfo aspeed_machine_types[] = { | ||
| 97 | .name = MACHINE_TYPE_NAME("tacoma-bmc"), | ||
| 98 | .parent = TYPE_ASPEED_MACHINE, | ||
| 99 | .class_init = aspeed_machine_tacoma_class_init, | ||
| 100 | + }, { | ||
| 101 | + .name = MACHINE_TYPE_NAME("g220a-bmc"), | ||
| 102 | + .parent = TYPE_ASPEED_MACHINE, | ||
| 103 | + .class_init = aspeed_machine_g220a_class_init, | ||
| 104 | }, { | ||
| 105 | .name = TYPE_ASPEED_MACHINE, | ||
| 106 | .parent = TYPE_MACHINE, | ||
| 107 | -- | 171 | -- |
| 108 | 2.26.2 | 172 | 2.47.1 |
| 109 | 173 | ||
| 110 | 174 | diff view generated by jsdifflib |
New patch | |||
|---|---|---|---|
| 1 | From: Jamin Lin <jamin_lin@aspeedtech.com> | ||
| 1 | 2 | ||
| 3 | Introduce a new ast2700 class to support AST2700. Add a new ast2700 SDHCI class | ||
| 4 | init function and set the value of capability register to "0x0000000719f80080". | ||
| 5 | |||
| 6 | Signed-off-by: Jamin Lin <jamin_lin@aspeedtech.com> | ||
| 7 | Reviewed-by: Cédric Le Goater <clg@redhat.com> | ||
| 8 | Link: https://lore.kernel.org/r/20241204084453.610660-5-jamin_lin@aspeedtech.com | ||
| 9 | Signed-off-by: Cédric Le Goater <clg@redhat.com> | ||
| 10 | --- | ||
| 11 | include/hw/sd/aspeed_sdhci.h | 1 + | ||
| 12 | hw/sd/aspeed_sdhci.c | 14 ++++++++++++++ | ||
| 13 | 2 files changed, 15 insertions(+) | ||
| 14 | |||
| 15 | diff --git a/include/hw/sd/aspeed_sdhci.h b/include/hw/sd/aspeed_sdhci.h | ||
| 16 | index XXXXXXX..XXXXXXX 100644 | ||
| 17 | --- a/include/hw/sd/aspeed_sdhci.h | ||
| 18 | +++ b/include/hw/sd/aspeed_sdhci.h | ||
| 19 | @@ -XXX,XX +XXX,XX @@ | ||
| 20 | #define TYPE_ASPEED_2400_SDHCI TYPE_ASPEED_SDHCI "-ast2400" | ||
| 21 | #define TYPE_ASPEED_2500_SDHCI TYPE_ASPEED_SDHCI "-ast2500" | ||
| 22 | #define TYPE_ASPEED_2600_SDHCI TYPE_ASPEED_SDHCI "-ast2600" | ||
| 23 | +#define TYPE_ASPEED_2700_SDHCI TYPE_ASPEED_SDHCI "-ast2700" | ||
| 24 | OBJECT_DECLARE_TYPE(AspeedSDHCIState, AspeedSDHCIClass, ASPEED_SDHCI) | ||
| 25 | |||
| 26 | #define ASPEED_SDHCI_NUM_SLOTS 2 | ||
| 27 | diff --git a/hw/sd/aspeed_sdhci.c b/hw/sd/aspeed_sdhci.c | ||
| 28 | index XXXXXXX..XXXXXXX 100644 | ||
| 29 | --- a/hw/sd/aspeed_sdhci.c | ||
| 30 | +++ b/hw/sd/aspeed_sdhci.c | ||
| 31 | @@ -XXX,XX +XXX,XX @@ static void aspeed_2600_sdhci_class_init(ObjectClass *klass, void *data) | ||
| 32 | asc->capareg = 0x0000000701f80080; | ||
| 33 | } | ||
| 34 | |||
| 35 | +static void aspeed_2700_sdhci_class_init(ObjectClass *klass, void *data) | ||
| 36 | +{ | ||
| 37 | + DeviceClass *dc = DEVICE_CLASS(klass); | ||
| 38 | + AspeedSDHCIClass *asc = ASPEED_SDHCI_CLASS(klass); | ||
| 39 | + | ||
| 40 | + dc->desc = "ASPEED 2700 SDHCI Controller"; | ||
| 41 | + asc->capareg = 0x0000000719f80080; | ||
| 42 | +} | ||
| 43 | + | ||
| 44 | static const TypeInfo aspeed_sdhci_types[] = { | ||
| 45 | { | ||
| 46 | .name = TYPE_ASPEED_SDHCI, | ||
| 47 | @@ -XXX,XX +XXX,XX @@ static const TypeInfo aspeed_sdhci_types[] = { | ||
| 48 | .parent = TYPE_ASPEED_SDHCI, | ||
| 49 | .class_init = aspeed_2600_sdhci_class_init, | ||
| 50 | }, | ||
| 51 | + { | ||
| 52 | + .name = TYPE_ASPEED_2700_SDHCI, | ||
| 53 | + .parent = TYPE_ASPEED_SDHCI, | ||
| 54 | + .class_init = aspeed_2700_sdhci_class_init, | ||
| 55 | + }, | ||
| 56 | }; | ||
| 57 | |||
| 58 | DEFINE_TYPES(aspeed_sdhci_types) | ||
| 59 | -- | ||
| 60 | 2.47.1 | ||
| 61 | |||
| 62 | diff view generated by jsdifflib |
New patch | |||
|---|---|---|---|
| 1 | From: Jamin Lin <jamin_lin@aspeedtech.com> | ||
| 1 | 2 | ||
| 3 | Add SDHCI model for AST2700 SDHCI support. The SDHCI controller only support 1 | ||
| 4 | slot and registers base address is start at 0x1408_0000 and its interrupt is | ||
| 5 | connected to GICINT133_INTC at bit 1. | ||
| 6 | |||
| 7 | Signed-off-by: Jamin Lin <jamin_lin@aspeedtech.com> | ||
| 8 | Reviewed-by: Cédric Le Goater <clg@redhat.com> | ||
| 9 | Link: https://lore.kernel.org/r/20241204084453.610660-6-jamin_lin@aspeedtech.com | ||
| 10 | Signed-off-by: Cédric Le Goater <clg@redhat.com> | ||
| 11 | --- | ||
| 12 | hw/arm/aspeed_ast27x0.c | 20 ++++++++++++++++++++ | ||
| 13 | 1 file changed, 20 insertions(+) | ||
| 14 | |||
| 15 | diff --git a/hw/arm/aspeed_ast27x0.c b/hw/arm/aspeed_ast27x0.c | ||
| 16 | index XXXXXXX..XXXXXXX 100644 | ||
| 17 | --- a/hw/arm/aspeed_ast27x0.c | ||
| 18 | +++ b/hw/arm/aspeed_ast27x0.c | ||
| 19 | @@ -XXX,XX +XXX,XX @@ static const hwaddr aspeed_soc_ast2700_memmap[] = { | ||
| 20 | [ASPEED_DEV_I2C] = 0x14C0F000, | ||
| 21 | [ASPEED_DEV_GPIO] = 0x14C0B000, | ||
| 22 | [ASPEED_DEV_RTC] = 0x12C0F000, | ||
| 23 | + [ASPEED_DEV_SDHCI] = 0x14080000, | ||
| 24 | }; | ||
| 25 | |||
| 26 | #define AST2700_MAX_IRQ 256 | ||
| 27 | @@ -XXX,XX +XXX,XX @@ static const int aspeed_soc_ast2700_irqmap[] = { | ||
| 28 | [ASPEED_DEV_KCS] = 128, | ||
| 29 | [ASPEED_DEV_DP] = 28, | ||
| 30 | [ASPEED_DEV_I3C] = 131, | ||
| 31 | + [ASPEED_DEV_SDHCI] = 133, | ||
| 32 | }; | ||
| 33 | |||
| 34 | /* GICINT 128 */ | ||
| 35 | @@ -XXX,XX +XXX,XX @@ static const int aspeed_soc_ast2700_gic132_intcmap[] = { | ||
| 36 | |||
| 37 | /* GICINT 133 */ | ||
| 38 | static const int aspeed_soc_ast2700_gic133_intcmap[] = { | ||
| 39 | + [ASPEED_DEV_SDHCI] = 1, | ||
| 40 | [ASPEED_DEV_PECI] = 4, | ||
| 41 | }; | ||
| 42 | |||
| 43 | @@ -XXX,XX +XXX,XX @@ static void aspeed_soc_ast2700_init(Object *obj) | ||
| 44 | object_initialize_child(obj, "gpio", &s->gpio, typename); | ||
| 45 | |||
| 46 | object_initialize_child(obj, "rtc", &s->rtc, TYPE_ASPEED_RTC); | ||
| 47 | + | ||
| 48 | + snprintf(typename, sizeof(typename), "aspeed.sdhci-%s", socname); | ||
| 49 | + object_initialize_child(obj, "sd-controller", &s->sdhci, typename); | ||
| 50 | + object_property_set_int(OBJECT(&s->sdhci), "num-slots", 1, &error_abort); | ||
| 51 | + | ||
| 52 | + /* Init sd card slot class here so that they're under the correct parent */ | ||
| 53 | + object_initialize_child(obj, "sd-controller.sdhci", | ||
| 54 | + &s->sdhci.slots[0], TYPE_SYSBUS_SDHCI); | ||
| 55 | } | ||
| 56 | |||
| 57 | /* | ||
| 58 | @@ -XXX,XX +XXX,XX @@ static void aspeed_soc_ast2700_realize(DeviceState *dev, Error **errp) | ||
| 59 | sysbus_connect_irq(SYS_BUS_DEVICE(&s->rtc), 0, | ||
| 60 | aspeed_soc_get_irq(s, ASPEED_DEV_RTC)); | ||
| 61 | |||
| 62 | + /* SDHCI */ | ||
| 63 | + if (!sysbus_realize(SYS_BUS_DEVICE(&s->sdhci), errp)) { | ||
| 64 | + return; | ||
| 65 | + } | ||
| 66 | + aspeed_mmio_map(s, SYS_BUS_DEVICE(&s->sdhci), 0, | ||
| 67 | + sc->memmap[ASPEED_DEV_SDHCI]); | ||
| 68 | + sysbus_connect_irq(SYS_BUS_DEVICE(&s->sdhci), 0, | ||
| 69 | + aspeed_soc_get_irq(s, ASPEED_DEV_SDHCI)); | ||
| 70 | + | ||
| 71 | create_unimplemented_device("ast2700.dpmcu", 0x11000000, 0x40000); | ||
| 72 | create_unimplemented_device("ast2700.iomem0", 0x12000000, 0x01000000); | ||
| 73 | create_unimplemented_device("ast2700.iomem1", 0x14000000, 0x01000000); | ||
| 74 | -- | ||
| 75 | 2.47.1 | ||
| 76 | |||
| 77 | diff view generated by jsdifflib |
New patch | |||
|---|---|---|---|
| 1 | From: Jamin Lin <jamin_lin@aspeedtech.com> | ||
| 1 | 2 | ||
| 3 | Add SDHCI model for AST2700 eMMC support. The eMMC controller only support 1 | ||
| 4 | slot and registers base address is start at 0x1209_0000 and its interrupt is | ||
| 5 | connected to GICINT 15. | ||
| 6 | |||
| 7 | Signed-off-by: Jamin Lin <jamin_lin@aspeedtech.com> | ||
| 8 | Reviewed-by: Cédric Le Goater <clg@redhat.com> | ||
| 9 | Link: https://lore.kernel.org/r/20241204084453.610660-7-jamin_lin@aspeedtech.com | ||
| 10 | Signed-off-by: Cédric Le Goater <clg@redhat.com> | ||
| 11 | --- | ||
| 12 | hw/arm/aspeed_ast27x0.c | 15 +++++++++++++++ | ||
| 13 | 1 file changed, 15 insertions(+) | ||
| 14 | |||
| 15 | diff --git a/hw/arm/aspeed_ast27x0.c b/hw/arm/aspeed_ast27x0.c | ||
| 16 | index XXXXXXX..XXXXXXX 100644 | ||
| 17 | --- a/hw/arm/aspeed_ast27x0.c | ||
| 18 | +++ b/hw/arm/aspeed_ast27x0.c | ||
| 19 | @@ -XXX,XX +XXX,XX @@ static void aspeed_soc_ast2700_init(Object *obj) | ||
| 20 | /* Init sd card slot class here so that they're under the correct parent */ | ||
| 21 | object_initialize_child(obj, "sd-controller.sdhci", | ||
| 22 | &s->sdhci.slots[0], TYPE_SYSBUS_SDHCI); | ||
| 23 | + | ||
| 24 | + object_initialize_child(obj, "emmc-controller", &s->emmc, typename); | ||
| 25 | + object_property_set_int(OBJECT(&s->emmc), "num-slots", 1, &error_abort); | ||
| 26 | + | ||
| 27 | + object_initialize_child(obj, "emmc-controller.sdhci", &s->emmc.slots[0], | ||
| 28 | + TYPE_SYSBUS_SDHCI); | ||
| 29 | } | ||
| 30 | |||
| 31 | /* | ||
| 32 | @@ -XXX,XX +XXX,XX @@ static void aspeed_soc_ast2700_realize(DeviceState *dev, Error **errp) | ||
| 33 | sysbus_connect_irq(SYS_BUS_DEVICE(&s->sdhci), 0, | ||
| 34 | aspeed_soc_get_irq(s, ASPEED_DEV_SDHCI)); | ||
| 35 | |||
| 36 | + /* eMMC */ | ||
| 37 | + if (!sysbus_realize(SYS_BUS_DEVICE(&s->emmc), errp)) { | ||
| 38 | + return; | ||
| 39 | + } | ||
| 40 | + aspeed_mmio_map(s, SYS_BUS_DEVICE(&s->emmc), 0, | ||
| 41 | + sc->memmap[ASPEED_DEV_EMMC]); | ||
| 42 | + sysbus_connect_irq(SYS_BUS_DEVICE(&s->emmc), 0, | ||
| 43 | + aspeed_soc_get_irq(s, ASPEED_DEV_EMMC)); | ||
| 44 | + | ||
| 45 | create_unimplemented_device("ast2700.dpmcu", 0x11000000, 0x40000); | ||
| 46 | create_unimplemented_device("ast2700.iomem0", 0x12000000, 0x01000000); | ||
| 47 | create_unimplemented_device("ast2700.iomem1", 0x14000000, 0x01000000); | ||
| 48 | -- | ||
| 49 | 2.47.1 | ||
| 50 | |||
| 51 | diff view generated by jsdifflib |
New patch | |||
|---|---|---|---|
| 1 | This simply moves the ast1030 tests to a new test file. No changes. | ||
| 1 | 2 | ||
| 3 | Reviewed-by: Thomas Huth <thuth@redhat.com> | ||
| 4 | Link: https://lore.kernel.org/r/20241206131132.520911-2-clg@redhat.com | ||
| 5 | Signed-off-by: Cédric Le Goater <clg@redhat.com> | ||
| 6 | --- | ||
| 7 | tests/functional/meson.build | 1 + | ||
| 8 | tests/functional/test_arm_aspeed.py | 64 ---------------- | ||
| 9 | tests/functional/test_arm_aspeed_ast1030.py | 81 +++++++++++++++++++++ | ||
| 10 | 3 files changed, 82 insertions(+), 64 deletions(-) | ||
| 11 | create mode 100644 tests/functional/test_arm_aspeed_ast1030.py | ||
| 12 | |||
| 13 | diff --git a/tests/functional/meson.build b/tests/functional/meson.build | ||
| 14 | index XXXXXXX..XXXXXXX 100644 | ||
| 15 | --- a/tests/functional/meson.build | ||
| 16 | +++ b/tests/functional/meson.build | ||
| 17 | @@ -XXX,XX +XXX,XX @@ tests_alpha_system_thorough = [ | ||
| 18 | |||
| 19 | tests_arm_system_thorough = [ | ||
| 20 | 'arm_aspeed', | ||
| 21 | + 'arm_aspeed_ast1030', | ||
| 22 | 'arm_bpim2u', | ||
| 23 | 'arm_canona1100', | ||
| 24 | 'arm_collie', | ||
| 25 | diff --git a/tests/functional/test_arm_aspeed.py b/tests/functional/test_arm_aspeed.py | ||
| 26 | index XXXXXXX..XXXXXXX 100755 | ||
| 27 | --- a/tests/functional/test_arm_aspeed.py | ||
| 28 | +++ b/tests/functional/test_arm_aspeed.py | ||
| 29 | @@ -XXX,XX +XXX,XX @@ | ||
| 30 | from zipfile import ZipFile | ||
| 31 | from unittest import skipUnless | ||
| 32 | |||
| 33 | -class AST1030Machine(LinuxKernelTest): | ||
| 34 | - | ||
| 35 | - ASSET_ZEPHYR_1_04 = Asset( | ||
| 36 | - ('https://github.com/AspeedTech-BMC' | ||
| 37 | - '/zephyr/releases/download/v00.01.04/ast1030-evb-demo.zip'), | ||
| 38 | - '4ac6210adcbc61294927918707c6762483fd844dde5e07f3ba834ad1f91434d3') | ||
| 39 | - | ||
| 40 | - def test_ast1030_zephyros_1_04(self): | ||
| 41 | - self.set_machine('ast1030-evb') | ||
| 42 | - | ||
| 43 | - zip_file = self.ASSET_ZEPHYR_1_04.fetch() | ||
| 44 | - | ||
| 45 | - kernel_name = "ast1030-evb-demo/zephyr.elf" | ||
| 46 | - with ZipFile(zip_file, 'r') as zf: | ||
| 47 | - zf.extract(kernel_name, path=self.workdir) | ||
| 48 | - kernel_file = os.path.join(self.workdir, kernel_name) | ||
| 49 | - | ||
| 50 | - self.vm.set_console() | ||
| 51 | - self.vm.add_args('-kernel', kernel_file, '-nographic') | ||
| 52 | - self.vm.launch() | ||
| 53 | - self.wait_for_console_pattern("Booting Zephyr OS") | ||
| 54 | - exec_command_and_wait_for_pattern(self, "help", | ||
| 55 | - "Available commands") | ||
| 56 | - | ||
| 57 | - ASSET_ZEPHYR_1_07 = Asset( | ||
| 58 | - ('https://github.com/AspeedTech-BMC' | ||
| 59 | - '/zephyr/releases/download/v00.01.07/ast1030-evb-demo.zip'), | ||
| 60 | - 'ad52e27959746988afaed8429bf4e12ab988c05c4d07c9d90e13ec6f7be4574c') | ||
| 61 | - | ||
| 62 | - def test_ast1030_zephyros_1_07(self): | ||
| 63 | - self.set_machine('ast1030-evb') | ||
| 64 | - | ||
| 65 | - zip_file = self.ASSET_ZEPHYR_1_07.fetch() | ||
| 66 | - | ||
| 67 | - kernel_name = "ast1030-evb-demo/zephyr.bin" | ||
| 68 | - with ZipFile(zip_file, 'r') as zf: | ||
| 69 | - zf.extract(kernel_name, path=self.workdir) | ||
| 70 | - kernel_file = os.path.join(self.workdir, kernel_name) | ||
| 71 | - | ||
| 72 | - self.vm.set_console() | ||
| 73 | - self.vm.add_args('-kernel', kernel_file, '-nographic') | ||
| 74 | - self.vm.launch() | ||
| 75 | - self.wait_for_console_pattern("Booting Zephyr OS") | ||
| 76 | - for shell_cmd in [ | ||
| 77 | - 'kernel stacks', | ||
| 78 | - 'otp info conf', | ||
| 79 | - 'otp info scu', | ||
| 80 | - 'hwinfo devid', | ||
| 81 | - 'crypto aes256_cbc_vault', | ||
| 82 | - 'random get', | ||
| 83 | - 'jtag JTAG1 sw_xfer high TMS', | ||
| 84 | - 'adc ADC0 resolution 12', | ||
| 85 | - 'adc ADC0 read 42', | ||
| 86 | - 'adc ADC1 read 69', | ||
| 87 | - 'i2c scan I2C_0', | ||
| 88 | - 'i3c attach I3C_0', | ||
| 89 | - 'hash test', | ||
| 90 | - 'kernel uptime', | ||
| 91 | - 'kernel reboot warm', | ||
| 92 | - 'kernel uptime', | ||
| 93 | - 'kernel reboot cold', | ||
| 94 | - 'kernel uptime', | ||
| 95 | - ]: exec_command_and_wait_for_pattern(self, shell_cmd, "uart:~$") | ||
| 96 | - | ||
| 97 | class AST2x00Machine(LinuxKernelTest): | ||
| 98 | |||
| 99 | def do_test_arm_aspeed(self, machine, image): | ||
| 100 | diff --git a/tests/functional/test_arm_aspeed_ast1030.py b/tests/functional/test_arm_aspeed_ast1030.py | ||
| 101 | new file mode 100644 | ||
| 102 | index XXXXXXX..XXXXXXX | ||
| 103 | --- /dev/null | ||
| 104 | +++ b/tests/functional/test_arm_aspeed_ast1030.py | ||
| 105 | @@ -XXX,XX +XXX,XX @@ | ||
| 106 | +#!/usr/bin/env python3 | ||
| 107 | +# | ||
| 108 | +# Functional test that boots the ASPEED SoCs with firmware | ||
| 109 | +# | ||
| 110 | +# Copyright (C) 2022 ASPEED Technology Inc | ||
| 111 | +# | ||
| 112 | +# SPDX-License-Identifier: GPL-2.0-or-later | ||
| 113 | + | ||
| 114 | +import os | ||
| 115 | + | ||
| 116 | +from qemu_test import LinuxKernelTest, Asset | ||
| 117 | +from qemu_test import exec_command_and_wait_for_pattern | ||
| 118 | +from zipfile import ZipFile | ||
| 119 | + | ||
| 120 | +class AST1030Machine(LinuxKernelTest): | ||
| 121 | + | ||
| 122 | + ASSET_ZEPHYR_1_04 = Asset( | ||
| 123 | + ('https://github.com/AspeedTech-BMC' | ||
| 124 | + '/zephyr/releases/download/v00.01.04/ast1030-evb-demo.zip'), | ||
| 125 | + '4ac6210adcbc61294927918707c6762483fd844dde5e07f3ba834ad1f91434d3') | ||
| 126 | + | ||
| 127 | + def test_ast1030_zephyros_1_04(self): | ||
| 128 | + self.set_machine('ast1030-evb') | ||
| 129 | + | ||
| 130 | + zip_file = self.ASSET_ZEPHYR_1_04.fetch() | ||
| 131 | + | ||
| 132 | + kernel_name = "ast1030-evb-demo/zephyr.elf" | ||
| 133 | + with ZipFile(zip_file, 'r') as zf: | ||
| 134 | + zf.extract(kernel_name, path=self.workdir) | ||
| 135 | + kernel_file = os.path.join(self.workdir, kernel_name) | ||
| 136 | + | ||
| 137 | + self.vm.set_console() | ||
| 138 | + self.vm.add_args('-kernel', kernel_file, '-nographic') | ||
| 139 | + self.vm.launch() | ||
| 140 | + self.wait_for_console_pattern("Booting Zephyr OS") | ||
| 141 | + exec_command_and_wait_for_pattern(self, "help", | ||
| 142 | + "Available commands") | ||
| 143 | + | ||
| 144 | + ASSET_ZEPHYR_1_07 = Asset( | ||
| 145 | + ('https://github.com/AspeedTech-BMC' | ||
| 146 | + '/zephyr/releases/download/v00.01.07/ast1030-evb-demo.zip'), | ||
| 147 | + 'ad52e27959746988afaed8429bf4e12ab988c05c4d07c9d90e13ec6f7be4574c') | ||
| 148 | + | ||
| 149 | + def test_ast1030_zephyros_1_07(self): | ||
| 150 | + self.set_machine('ast1030-evb') | ||
| 151 | + | ||
| 152 | + zip_file = self.ASSET_ZEPHYR_1_07.fetch() | ||
| 153 | + | ||
| 154 | + kernel_name = "ast1030-evb-demo/zephyr.bin" | ||
| 155 | + with ZipFile(zip_file, 'r') as zf: | ||
| 156 | + zf.extract(kernel_name, path=self.workdir) | ||
| 157 | + kernel_file = os.path.join(self.workdir, kernel_name) | ||
| 158 | + | ||
| 159 | + self.vm.set_console() | ||
| 160 | + self.vm.add_args('-kernel', kernel_file, '-nographic') | ||
| 161 | + self.vm.launch() | ||
| 162 | + self.wait_for_console_pattern("Booting Zephyr OS") | ||
| 163 | + for shell_cmd in [ | ||
| 164 | + 'kernel stacks', | ||
| 165 | + 'otp info conf', | ||
| 166 | + 'otp info scu', | ||
| 167 | + 'hwinfo devid', | ||
| 168 | + 'crypto aes256_cbc_vault', | ||
| 169 | + 'random get', | ||
| 170 | + 'jtag JTAG1 sw_xfer high TMS', | ||
| 171 | + 'adc ADC0 resolution 12', | ||
| 172 | + 'adc ADC0 read 42', | ||
| 173 | + 'adc ADC1 read 69', | ||
| 174 | + 'i2c scan I2C_0', | ||
| 175 | + 'i3c attach I3C_0', | ||
| 176 | + 'hash test', | ||
| 177 | + 'kernel uptime', | ||
| 178 | + 'kernel reboot warm', | ||
| 179 | + 'kernel uptime', | ||
| 180 | + 'kernel reboot cold', | ||
| 181 | + 'kernel uptime', | ||
| 182 | + ]: exec_command_and_wait_for_pattern(self, shell_cmd, "uart:~$") | ||
| 183 | + | ||
| 184 | + | ||
| 185 | +if __name__ == '__main__': | ||
| 186 | + LinuxKernelTest.main() | ||
| 187 | -- | ||
| 188 | 2.47.1 | ||
| 189 | |||
| 190 | diff view generated by jsdifflib |
New patch | |||
|---|---|---|---|
| 1 | This introduces a new aspeed module for sharing code between tests and | ||
| 2 | moves the palmetto test to a new test file. No changes in the test. | ||
| 1 | 3 | ||
| 4 | Reviewed-by: Thomas Huth <thuth@redhat.com> | ||
| 5 | Link: https://lore.kernel.org/r/20241206131132.520911-3-clg@redhat.com | ||
| 6 | Signed-off-by: Cédric Le Goater <clg@redhat.com> | ||
| 7 | --- | ||
| 8 | tests/functional/aspeed.py | 23 +++++++++++++++++++ | ||
| 9 | tests/functional/meson.build | 2 ++ | ||
| 10 | tests/functional/test_arm_aspeed.py | 10 -------- | ||
| 11 | tests/functional/test_arm_aspeed_palmetto.py | 24 ++++++++++++++++++++ | ||
| 12 | 4 files changed, 49 insertions(+), 10 deletions(-) | ||
| 13 | create mode 100644 tests/functional/aspeed.py | ||
| 14 | create mode 100644 tests/functional/test_arm_aspeed_palmetto.py | ||
| 15 | |||
| 16 | diff --git a/tests/functional/aspeed.py b/tests/functional/aspeed.py | ||
| 17 | new file mode 100644 | ||
| 18 | index XXXXXXX..XXXXXXX | ||
| 19 | --- /dev/null | ||
| 20 | +++ b/tests/functional/aspeed.py | ||
| 21 | @@ -XXX,XX +XXX,XX @@ | ||
| 22 | +# Test class to boot aspeed machines | ||
| 23 | +# | ||
| 24 | +# SPDX-License-Identifier: GPL-2.0-or-later | ||
| 25 | + | ||
| 26 | +from qemu_test import LinuxKernelTest | ||
| 27 | + | ||
| 28 | +class AspeedTest(LinuxKernelTest): | ||
| 29 | + | ||
| 30 | + def do_test_arm_aspeed(self, machine, image): | ||
| 31 | + self.set_machine(machine) | ||
| 32 | + self.vm.set_console() | ||
| 33 | + self.vm.add_args('-drive', 'file=' + image + ',if=mtd,format=raw', | ||
| 34 | + '-net', 'nic', '-snapshot') | ||
| 35 | + self.vm.launch() | ||
| 36 | + | ||
| 37 | + self.wait_for_console_pattern("U-Boot 2016.07") | ||
| 38 | + self.wait_for_console_pattern("## Loading kernel from FIT Image at 20080000") | ||
| 39 | + self.wait_for_console_pattern("Starting kernel ...") | ||
| 40 | + self.wait_for_console_pattern("Booting Linux on physical CPU 0x0") | ||
| 41 | + self.wait_for_console_pattern( | ||
| 42 | + "aspeed-smc 1e620000.spi: read control register: 203b0641") | ||
| 43 | + self.wait_for_console_pattern("ftgmac100 1e660000.ethernet eth0: irq ") | ||
| 44 | + self.wait_for_console_pattern("systemd[1]: Set hostname to") | ||
| 45 | diff --git a/tests/functional/meson.build b/tests/functional/meson.build | ||
| 46 | index XXXXXXX..XXXXXXX 100644 | ||
| 47 | --- a/tests/functional/meson.build | ||
| 48 | +++ b/tests/functional/meson.build | ||
| 49 | @@ -XXX,XX +XXX,XX @@ test_timeouts = { | ||
| 50 | 'aarch64_tuxrun' : 240, | ||
| 51 | 'aarch64_virt' : 720, | ||
| 52 | 'acpi_bits' : 420, | ||
| 53 | + 'arm_aspeed_palmetto' : 120, | ||
| 54 | 'arm_aspeed' : 600, | ||
| 55 | 'arm_bpim2u' : 500, | ||
| 56 | 'arm_collie' : 180, | ||
| 57 | @@ -XXX,XX +XXX,XX @@ tests_alpha_system_thorough = [ | ||
| 58 | tests_arm_system_thorough = [ | ||
| 59 | 'arm_aspeed', | ||
| 60 | 'arm_aspeed_ast1030', | ||
| 61 | + 'arm_aspeed_palmetto', | ||
| 62 | 'arm_bpim2u', | ||
| 63 | 'arm_canona1100', | ||
| 64 | 'arm_collie', | ||
| 65 | diff --git a/tests/functional/test_arm_aspeed.py b/tests/functional/test_arm_aspeed.py | ||
| 66 | index XXXXXXX..XXXXXXX 100755 | ||
| 67 | --- a/tests/functional/test_arm_aspeed.py | ||
| 68 | +++ b/tests/functional/test_arm_aspeed.py | ||
| 69 | @@ -XXX,XX +XXX,XX @@ def do_test_arm_aspeed(self, machine, image): | ||
| 70 | self.wait_for_console_pattern("ftgmac100 1e660000.ethernet eth0: irq ") | ||
| 71 | self.wait_for_console_pattern("systemd[1]: Set hostname to") | ||
| 72 | |||
| 73 | - ASSET_PALMETTO_FLASH = Asset( | ||
| 74 | - ('https://github.com/openbmc/openbmc/releases/download/2.9.0/' | ||
| 75 | - 'obmc-phosphor-image-palmetto.static.mtd'), | ||
| 76 | - '3e13bbbc28e424865dc42f35ad672b10f2e82cdb11846bb28fa625b48beafd0d'); | ||
| 77 | - | ||
| 78 | - def test_arm_ast2400_palmetto_openbmc_v2_9_0(self): | ||
| 79 | - image_path = self.ASSET_PALMETTO_FLASH.fetch() | ||
| 80 | - | ||
| 81 | - self.do_test_arm_aspeed('palmetto-bmc', image_path) | ||
| 82 | - | ||
| 83 | ASSET_ROMULUS_FLASH = Asset( | ||
| 84 | ('https://github.com/openbmc/openbmc/releases/download/2.9.0/' | ||
| 85 | 'obmc-phosphor-image-romulus.static.mtd'), | ||
| 86 | diff --git a/tests/functional/test_arm_aspeed_palmetto.py b/tests/functional/test_arm_aspeed_palmetto.py | ||
| 87 | new file mode 100644 | ||
| 88 | index XXXXXXX..XXXXXXX | ||
| 89 | --- /dev/null | ||
| 90 | +++ b/tests/functional/test_arm_aspeed_palmetto.py | ||
| 91 | @@ -XXX,XX +XXX,XX @@ | ||
| 92 | +#!/usr/bin/env python3 | ||
| 93 | +# | ||
| 94 | +# Functional test that boots the ASPEED machines | ||
| 95 | +# | ||
| 96 | +# SPDX-License-Identifier: GPL-2.0-or-later | ||
| 97 | + | ||
| 98 | +from qemu_test import Asset | ||
| 99 | +from aspeed import AspeedTest | ||
| 100 | + | ||
| 101 | +class PalmettoMachine(AspeedTest): | ||
| 102 | + | ||
| 103 | + ASSET_PALMETTO_FLASH = Asset( | ||
| 104 | + ('https://github.com/openbmc/openbmc/releases/download/2.9.0/' | ||
| 105 | + 'obmc-phosphor-image-palmetto.static.mtd'), | ||
| 106 | + '3e13bbbc28e424865dc42f35ad672b10f2e82cdb11846bb28fa625b48beafd0d'); | ||
| 107 | + | ||
| 108 | + def test_arm_ast2400_palmetto_openbmc_v2_9_0(self): | ||
| 109 | + image_path = self.ASSET_PALMETTO_FLASH.fetch() | ||
| 110 | + | ||
| 111 | + self.do_test_arm_aspeed('palmetto-bmc', image_path) | ||
| 112 | + | ||
| 113 | + | ||
| 114 | +if __name__ == '__main__': | ||
| 115 | + AspeedTest.main() | ||
| 116 | -- | ||
| 117 | 2.47.1 | ||
| 118 | |||
| 119 | diff view generated by jsdifflib |
New patch | |||
|---|---|---|---|
| 1 | This simply moves the romulus-bmc test to a new test file. No changes | ||
| 2 | in the test. The do_test_arm_aspeed routine is removed from the | ||
| 3 | test_arm_aspeed.py file because it is now unused. | ||
| 1 | 4 | ||
| 5 | Reviewed-by: Thomas Huth <thuth@redhat.com> | ||
| 6 | Link: https://lore.kernel.org/r/20241206131132.520911-4-clg@redhat.com | ||
| 7 | Signed-off-by: Cédric Le Goater <clg@redhat.com> | ||
| 8 | --- | ||
| 9 | tests/functional/meson.build | 2 ++ | ||
| 10 | tests/functional/test_arm_aspeed.py | 26 --------------------- | ||
| 11 | tests/functional/test_arm_aspeed_romulus.py | 24 +++++++++++++++++++ | ||
| 12 | 3 files changed, 26 insertions(+), 26 deletions(-) | ||
| 13 | create mode 100644 tests/functional/test_arm_aspeed_romulus.py | ||
| 14 | |||
| 15 | diff --git a/tests/functional/meson.build b/tests/functional/meson.build | ||
| 16 | index XXXXXXX..XXXXXXX 100644 | ||
| 17 | --- a/tests/functional/meson.build | ||
| 18 | +++ b/tests/functional/meson.build | ||
| 19 | @@ -XXX,XX +XXX,XX @@ test_timeouts = { | ||
| 20 | 'aarch64_virt' : 720, | ||
| 21 | 'acpi_bits' : 420, | ||
| 22 | 'arm_aspeed_palmetto' : 120, | ||
| 23 | + 'arm_aspeed_romulus' : 120, | ||
| 24 | 'arm_aspeed' : 600, | ||
| 25 | 'arm_bpim2u' : 500, | ||
| 26 | 'arm_collie' : 180, | ||
| 27 | @@ -XXX,XX +XXX,XX @@ tests_arm_system_thorough = [ | ||
| 28 | 'arm_aspeed', | ||
| 29 | 'arm_aspeed_ast1030', | ||
| 30 | 'arm_aspeed_palmetto', | ||
| 31 | + 'arm_aspeed_romulus', | ||
| 32 | 'arm_bpim2u', | ||
| 33 | 'arm_canona1100', | ||
| 34 | 'arm_collie', | ||
| 35 | diff --git a/tests/functional/test_arm_aspeed.py b/tests/functional/test_arm_aspeed.py | ||
| 36 | index XXXXXXX..XXXXXXX 100755 | ||
| 37 | --- a/tests/functional/test_arm_aspeed.py | ||
| 38 | +++ b/tests/functional/test_arm_aspeed.py | ||
| 39 | @@ -XXX,XX +XXX,XX @@ | ||
| 40 | |||
| 41 | class AST2x00Machine(LinuxKernelTest): | ||
| 42 | |||
| 43 | - def do_test_arm_aspeed(self, machine, image): | ||
| 44 | - self.set_machine(machine) | ||
| 45 | - self.vm.set_console() | ||
| 46 | - self.vm.add_args('-drive', 'file=' + image + ',if=mtd,format=raw', | ||
| 47 | - '-net', 'nic', '-snapshot') | ||
| 48 | - self.vm.launch() | ||
| 49 | - | ||
| 50 | - self.wait_for_console_pattern("U-Boot 2016.07") | ||
| 51 | - self.wait_for_console_pattern("## Loading kernel from FIT Image at 20080000") | ||
| 52 | - self.wait_for_console_pattern("Starting kernel ...") | ||
| 53 | - self.wait_for_console_pattern("Booting Linux on physical CPU 0x0") | ||
| 54 | - self.wait_for_console_pattern( | ||
| 55 | - "aspeed-smc 1e620000.spi: read control register: 203b0641") | ||
| 56 | - self.wait_for_console_pattern("ftgmac100 1e660000.ethernet eth0: irq ") | ||
| 57 | - self.wait_for_console_pattern("systemd[1]: Set hostname to") | ||
| 58 | - | ||
| 59 | - ASSET_ROMULUS_FLASH = Asset( | ||
| 60 | - ('https://github.com/openbmc/openbmc/releases/download/2.9.0/' | ||
| 61 | - 'obmc-phosphor-image-romulus.static.mtd'), | ||
| 62 | - '820341076803f1955bc31e647a512c79f9add4f5233d0697678bab4604c7bb25') | ||
| 63 | - | ||
| 64 | - def test_arm_ast2500_romulus_openbmc_v2_9_0(self): | ||
| 65 | - image_path = self.ASSET_ROMULUS_FLASH.fetch() | ||
| 66 | - | ||
| 67 | - self.do_test_arm_aspeed('romulus-bmc', image_path) | ||
| 68 | - | ||
| 69 | def do_test_arm_aspeed_buildroot_start(self, image, cpu_id, pattern='Aspeed EVB'): | ||
| 70 | self.require_netdev('user') | ||
| 71 | self.vm.set_console() | ||
| 72 | diff --git a/tests/functional/test_arm_aspeed_romulus.py b/tests/functional/test_arm_aspeed_romulus.py | ||
| 73 | new file mode 100644 | ||
| 74 | index XXXXXXX..XXXXXXX | ||
| 75 | --- /dev/null | ||
| 76 | +++ b/tests/functional/test_arm_aspeed_romulus.py | ||
| 77 | @@ -XXX,XX +XXX,XX @@ | ||
| 78 | +#!/usr/bin/env python3 | ||
| 79 | +# | ||
| 80 | +# Functional test that boots the ASPEED machines | ||
| 81 | +# | ||
| 82 | +# SPDX-License-Identifier: GPL-2.0-or-later | ||
| 83 | + | ||
| 84 | +from qemu_test import Asset | ||
| 85 | +from aspeed import AspeedTest | ||
| 86 | + | ||
| 87 | +class RomulusMachine(AspeedTest): | ||
| 88 | + | ||
| 89 | + ASSET_ROMULUS_FLASH = Asset( | ||
| 90 | + ('https://github.com/openbmc/openbmc/releases/download/2.9.0/' | ||
| 91 | + 'obmc-phosphor-image-romulus.static.mtd'), | ||
| 92 | + '820341076803f1955bc31e647a512c79f9add4f5233d0697678bab4604c7bb25') | ||
| 93 | + | ||
| 94 | + def test_arm_ast2500_romulus_openbmc_v2_9_0(self): | ||
| 95 | + image_path = self.ASSET_ROMULUS_FLASH.fetch() | ||
| 96 | + | ||
| 97 | + self.do_test_arm_aspeed('romulus-bmc', image_path) | ||
| 98 | + | ||
| 99 | + | ||
| 100 | +if __name__ == '__main__': | ||
| 101 | + AspeedTest.main() | ||
| 102 | -- | ||
| 103 | 2.47.1 | ||
| 104 | |||
| 105 | diff view generated by jsdifflib |
New patch | |||
|---|---|---|---|
| 1 | 1 | This moves the ast2500-evb tests to a new test file and extends the | |
| 2 | aspeed module with routines used to run the buildroot and sdk | ||
| 3 | tests. No changes in the test. | ||
| 4 | |||
| 5 | Reviewed-by: Thomas Huth <thuth@redhat.com> | ||
| 6 | Link: https://lore.kernel.org/r/20241206131132.520911-5-clg@redhat.com | ||
| 7 | Signed-off-by: Cédric Le Goater <clg@redhat.com> | ||
| 8 | --- | ||
| 9 | tests/functional/aspeed.py | 33 ++++++++++++ | ||
| 10 | tests/functional/meson.build | 2 + | ||
| 11 | tests/functional/test_arm_aspeed.py | 44 --------------- | ||
| 12 | tests/functional/test_arm_aspeed_ast2500.py | 59 +++++++++++++++++++++ | ||
| 13 | 4 files changed, 94 insertions(+), 44 deletions(-) | ||
| 14 | create mode 100644 tests/functional/test_arm_aspeed_ast2500.py | ||
| 15 | |||
| 16 | diff --git a/tests/functional/aspeed.py b/tests/functional/aspeed.py | ||
| 17 | index XXXXXXX..XXXXXXX 100644 | ||
| 18 | --- a/tests/functional/aspeed.py | ||
| 19 | +++ b/tests/functional/aspeed.py | ||
| 20 | @@ -XXX,XX +XXX,XX @@ | ||
| 21 | # | ||
| 22 | # SPDX-License-Identifier: GPL-2.0-or-later | ||
| 23 | |||
| 24 | +from qemu_test import exec_command_and_wait_for_pattern | ||
| 25 | from qemu_test import LinuxKernelTest | ||
| 26 | |||
| 27 | class AspeedTest(LinuxKernelTest): | ||
| 28 | @@ -XXX,XX +XXX,XX @@ def do_test_arm_aspeed(self, machine, image): | ||
| 29 | "aspeed-smc 1e620000.spi: read control register: 203b0641") | ||
| 30 | self.wait_for_console_pattern("ftgmac100 1e660000.ethernet eth0: irq ") | ||
| 31 | self.wait_for_console_pattern("systemd[1]: Set hostname to") | ||
| 32 | + | ||
| 33 | + def do_test_arm_aspeed_buildroot_start(self, image, cpu_id, pattern='Aspeed EVB'): | ||
| 34 | + self.require_netdev('user') | ||
| 35 | + self.vm.set_console() | ||
| 36 | + self.vm.add_args('-drive', 'file=' + image + ',if=mtd,format=raw,read-only=true', | ||
| 37 | + '-net', 'nic', '-net', 'user') | ||
| 38 | + self.vm.launch() | ||
| 39 | + | ||
| 40 | + self.wait_for_console_pattern('U-Boot 2019.04') | ||
| 41 | + self.wait_for_console_pattern('## Loading kernel from FIT Image') | ||
| 42 | + self.wait_for_console_pattern('Starting kernel ...') | ||
| 43 | + self.wait_for_console_pattern('Booting Linux on physical CPU ' + cpu_id) | ||
| 44 | + self.wait_for_console_pattern('lease of 10.0.2.15') | ||
| 45 | + # the line before login: | ||
| 46 | + self.wait_for_console_pattern(pattern) | ||
| 47 | + exec_command_and_wait_for_pattern(self, 'root', 'Password:') | ||
| 48 | + exec_command_and_wait_for_pattern(self, 'passw0rd', '#') | ||
| 49 | + | ||
| 50 | + def do_test_arm_aspeed_buildroot_poweroff(self): | ||
| 51 | + exec_command_and_wait_for_pattern(self, 'poweroff', | ||
| 52 | + 'reboot: System halted'); | ||
| 53 | + | ||
| 54 | + def do_test_arm_aspeed_sdk_start(self, image): | ||
| 55 | + self.require_netdev('user') | ||
| 56 | + self.vm.set_console() | ||
| 57 | + self.vm.add_args('-drive', 'file=' + image + ',if=mtd,format=raw', | ||
| 58 | + '-net', 'nic', '-net', 'user', '-snapshot') | ||
| 59 | + self.vm.launch() | ||
| 60 | + | ||
| 61 | + self.wait_for_console_pattern('U-Boot 2019.04') | ||
| 62 | + self.wait_for_console_pattern('## Loading kernel from FIT Image') | ||
| 63 | + self.wait_for_console_pattern('Starting kernel ...') | ||
| 64 | diff --git a/tests/functional/meson.build b/tests/functional/meson.build | ||
| 65 | index XXXXXXX..XXXXXXX 100644 | ||
| 66 | --- a/tests/functional/meson.build | ||
| 67 | +++ b/tests/functional/meson.build | ||
| 68 | @@ -XXX,XX +XXX,XX @@ test_timeouts = { | ||
| 69 | 'acpi_bits' : 420, | ||
| 70 | 'arm_aspeed_palmetto' : 120, | ||
| 71 | 'arm_aspeed_romulus' : 120, | ||
| 72 | + 'arm_aspeed_ast2500' : 480, | ||
| 73 | 'arm_aspeed' : 600, | ||
| 74 | 'arm_bpim2u' : 500, | ||
| 75 | 'arm_collie' : 180, | ||
| 76 | @@ -XXX,XX +XXX,XX @@ tests_arm_system_thorough = [ | ||
| 77 | 'arm_aspeed_ast1030', | ||
| 78 | 'arm_aspeed_palmetto', | ||
| 79 | 'arm_aspeed_romulus', | ||
| 80 | + 'arm_aspeed_ast2500', | ||
| 81 | 'arm_bpim2u', | ||
| 82 | 'arm_canona1100', | ||
| 83 | 'arm_collie', | ||
| 84 | diff --git a/tests/functional/test_arm_aspeed.py b/tests/functional/test_arm_aspeed.py | ||
| 85 | index XXXXXXX..XXXXXXX 100755 | ||
| 86 | --- a/tests/functional/test_arm_aspeed.py | ||
| 87 | +++ b/tests/functional/test_arm_aspeed.py | ||
| 88 | @@ -XXX,XX +XXX,XX @@ def do_test_arm_aspeed_buildroot_start(self, image, cpu_id, pattern='Aspeed EVB' | ||
| 89 | def do_test_arm_aspeed_buildroot_poweroff(self): | ||
| 90 | exec_command_and_wait_for_pattern(self, 'poweroff', | ||
| 91 | 'reboot: System halted'); | ||
| 92 | - | ||
| 93 | - ASSET_BR2_202311_AST2500_FLASH = Asset( | ||
| 94 | - ('https://github.com/legoater/qemu-aspeed-boot/raw/master/' | ||
| 95 | - 'images/ast2500-evb/buildroot-2023.11/flash.img'), | ||
| 96 | - 'c23db6160cf77d0258397eb2051162c8473a56c441417c52a91ba217186e715f') | ||
| 97 | - | ||
| 98 | - def test_arm_ast2500_evb_buildroot(self): | ||
| 99 | - self.set_machine('ast2500-evb') | ||
| 100 | - | ||
| 101 | - image_path = self.ASSET_BR2_202311_AST2500_FLASH.fetch() | ||
| 102 | - | ||
| 103 | - self.vm.add_args('-device', | ||
| 104 | - 'tmp105,bus=aspeed.i2c.bus.3,address=0x4d,id=tmp-test'); | ||
| 105 | - self.do_test_arm_aspeed_buildroot_start(image_path, '0x0', | ||
| 106 | - 'ast2500-evb login:') | ||
| 107 | - | ||
| 108 | - exec_command_and_wait_for_pattern(self, | ||
| 109 | - 'echo lm75 0x4d > /sys/class/i2c-dev/i2c-3/device/new_device', | ||
| 110 | - 'i2c i2c-3: new_device: Instantiated device lm75 at 0x4d'); | ||
| 111 | - exec_command_and_wait_for_pattern(self, | ||
| 112 | - 'cat /sys/class/hwmon/hwmon1/temp1_input', '0') | ||
| 113 | - self.vm.cmd('qom-set', path='/machine/peripheral/tmp-test', | ||
| 114 | - property='temperature', value=18000); | ||
| 115 | - exec_command_and_wait_for_pattern(self, | ||
| 116 | - 'cat /sys/class/hwmon/hwmon1/temp1_input', '18000') | ||
| 117 | - | ||
| 118 | - self.do_test_arm_aspeed_buildroot_poweroff() | ||
| 119 | - | ||
| 120 | ASSET_BR2_202311_AST2600_FLASH = Asset( | ||
| 121 | ('https://github.com/legoater/qemu-aspeed-boot/raw/master/' | ||
| 122 | 'images/ast2600-evb/buildroot-2023.11/flash.img'), | ||
| 123 | @@ -XXX,XX +XXX,XX @@ def do_test_arm_aspeed_sdk_start(self, image): | ||
| 124 | self.wait_for_console_pattern('## Loading kernel from FIT Image') | ||
| 125 | self.wait_for_console_pattern('Starting kernel ...') | ||
| 126 | |||
| 127 | - ASSET_SDK_V806_AST2500 = Asset( | ||
| 128 | - 'https://github.com/AspeedTech-BMC/openbmc/releases/download/v08.06/ast2500-default-obmc.tar.gz', | ||
| 129 | - 'e1755f3cadff69190438c688d52dd0f0d399b70a1e14b1d3d5540fc4851d38ca') | ||
| 130 | - | ||
| 131 | - def test_arm_ast2500_evb_sdk(self): | ||
| 132 | - self.set_machine('ast2500-evb') | ||
| 133 | - | ||
| 134 | - image_path = self.ASSET_SDK_V806_AST2500.fetch() | ||
| 135 | - | ||
| 136 | - archive_extract(image_path, self.workdir) | ||
| 137 | - | ||
| 138 | - self.do_test_arm_aspeed_sdk_start( | ||
| 139 | - self.workdir + '/ast2500-default/image-bmc') | ||
| 140 | - | ||
| 141 | - self.wait_for_console_pattern('ast2500-default login:') | ||
| 142 | - | ||
| 143 | ASSET_SDK_V806_AST2600_A2 = Asset( | ||
| 144 | 'https://github.com/AspeedTech-BMC/openbmc/releases/download/v08.06/ast2600-a2-obmc.tar.gz', | ||
| 145 | '9083506135f622d5e7351fcf7d4e1c7125cee5ba16141220c0ba88931f3681a4') | ||
| 146 | diff --git a/tests/functional/test_arm_aspeed_ast2500.py b/tests/functional/test_arm_aspeed_ast2500.py | ||
| 147 | new file mode 100644 | ||
| 148 | index XXXXXXX..XXXXXXX | ||
| 149 | --- /dev/null | ||
| 150 | +++ b/tests/functional/test_arm_aspeed_ast2500.py | ||
| 151 | @@ -XXX,XX +XXX,XX @@ | ||
| 152 | +#!/usr/bin/env python3 | ||
| 153 | +# | ||
| 154 | +# Functional test that boots the ASPEED machines | ||
| 155 | +# | ||
| 156 | +# SPDX-License-Identifier: GPL-2.0-or-later | ||
| 157 | + | ||
| 158 | +from qemu_test import Asset | ||
| 159 | +from aspeed import AspeedTest | ||
| 160 | +from qemu_test import exec_command_and_wait_for_pattern | ||
| 161 | +from qemu_test.utils import archive_extract | ||
| 162 | + | ||
| 163 | +class AST2500Machine(AspeedTest): | ||
| 164 | + | ||
| 165 | + ASSET_BR2_202311_AST2500_FLASH = Asset( | ||
| 166 | + ('https://github.com/legoater/qemu-aspeed-boot/raw/master/' | ||
| 167 | + 'images/ast2500-evb/buildroot-2023.11/flash.img'), | ||
| 168 | + 'c23db6160cf77d0258397eb2051162c8473a56c441417c52a91ba217186e715f') | ||
| 169 | + | ||
| 170 | + def test_arm_ast2500_evb_buildroot(self): | ||
| 171 | + self.set_machine('ast2500-evb') | ||
| 172 | + | ||
| 173 | + image_path = self.ASSET_BR2_202311_AST2500_FLASH.fetch() | ||
| 174 | + | ||
| 175 | + self.vm.add_args('-device', | ||
| 176 | + 'tmp105,bus=aspeed.i2c.bus.3,address=0x4d,id=tmp-test'); | ||
| 177 | + self.do_test_arm_aspeed_buildroot_start(image_path, '0x0', | ||
| 178 | + 'ast2500-evb login:') | ||
| 179 | + | ||
| 180 | + exec_command_and_wait_for_pattern(self, | ||
| 181 | + 'echo lm75 0x4d > /sys/class/i2c-dev/i2c-3/device/new_device', | ||
| 182 | + 'i2c i2c-3: new_device: Instantiated device lm75 at 0x4d'); | ||
| 183 | + exec_command_and_wait_for_pattern(self, | ||
| 184 | + 'cat /sys/class/hwmon/hwmon1/temp1_input', '0') | ||
| 185 | + self.vm.cmd('qom-set', path='/machine/peripheral/tmp-test', | ||
| 186 | + property='temperature', value=18000); | ||
| 187 | + exec_command_and_wait_for_pattern(self, | ||
| 188 | + 'cat /sys/class/hwmon/hwmon1/temp1_input', '18000') | ||
| 189 | + | ||
| 190 | + self.do_test_arm_aspeed_buildroot_poweroff() | ||
| 191 | + | ||
| 192 | + ASSET_SDK_V806_AST2500 = Asset( | ||
| 193 | + 'https://github.com/AspeedTech-BMC/openbmc/releases/download/v08.06/ast2500-default-obmc.tar.gz', | ||
| 194 | + 'e1755f3cadff69190438c688d52dd0f0d399b70a1e14b1d3d5540fc4851d38ca') | ||
| 195 | + | ||
| 196 | + def test_arm_ast2500_evb_sdk(self): | ||
| 197 | + self.set_machine('ast2500-evb') | ||
| 198 | + | ||
| 199 | + image_path = self.ASSET_SDK_V806_AST2500.fetch() | ||
| 200 | + | ||
| 201 | + archive_extract(image_path, self.workdir) | ||
| 202 | + | ||
| 203 | + self.do_test_arm_aspeed_sdk_start( | ||
| 204 | + self.workdir + '/ast2500-default/image-bmc') | ||
| 205 | + | ||
| 206 | + self.wait_for_console_pattern('ast2500-default login:') | ||
| 207 | + | ||
| 208 | + | ||
| 209 | +if __name__ == '__main__': | ||
| 210 | + AspeedTest.main() | ||
| 211 | -- | ||
| 212 | 2.47.1 | ||
| 213 | |||
| 214 | diff view generated by jsdifflib |
New patch | |||
|---|---|---|---|
| 1 | This moves the ast2600-evb tests to a new test file. No changes in the | ||
| 2 | test. The routines used to run the buildroot and sdk tests are removed | ||
| 3 | from the test_arm_aspeed.py file because now unused. | ||
| 1 | 4 | ||
| 5 | Reviewed-by: Thomas Huth <thuth@redhat.com> | ||
| 6 | Link: https://lore.kernel.org/r/20241206131132.520911-6-clg@redhat.com | ||
| 7 | Signed-off-by: Cédric Le Goater <clg@redhat.com> | ||
| 8 | --- | ||
| 9 | tests/functional/meson.build | 2 + | ||
| 10 | tests/functional/test_arm_aspeed.py | 155 -------------------- | ||
| 11 | tests/functional/test_arm_aspeed_ast2600.py | 143 ++++++++++++++++++ | ||
| 12 | 3 files changed, 145 insertions(+), 155 deletions(-) | ||
| 13 | create mode 100644 tests/functional/test_arm_aspeed_ast2600.py | ||
| 14 | |||
| 15 | diff --git a/tests/functional/meson.build b/tests/functional/meson.build | ||
| 16 | index XXXXXXX..XXXXXXX 100644 | ||
| 17 | --- a/tests/functional/meson.build | ||
| 18 | +++ b/tests/functional/meson.build | ||
| 19 | @@ -XXX,XX +XXX,XX @@ test_timeouts = { | ||
| 20 | 'arm_aspeed_palmetto' : 120, | ||
| 21 | 'arm_aspeed_romulus' : 120, | ||
| 22 | 'arm_aspeed_ast2500' : 480, | ||
| 23 | + 'arm_aspeed_ast2600' : 720, | ||
| 24 | 'arm_aspeed' : 600, | ||
| 25 | 'arm_bpim2u' : 500, | ||
| 26 | 'arm_collie' : 180, | ||
| 27 | @@ -XXX,XX +XXX,XX @@ tests_arm_system_thorough = [ | ||
| 28 | 'arm_aspeed_palmetto', | ||
| 29 | 'arm_aspeed_romulus', | ||
| 30 | 'arm_aspeed_ast2500', | ||
| 31 | + 'arm_aspeed_ast2600', | ||
| 32 | 'arm_bpim2u', | ||
| 33 | 'arm_canona1100', | ||
| 34 | 'arm_collie', | ||
| 35 | diff --git a/tests/functional/test_arm_aspeed.py b/tests/functional/test_arm_aspeed.py | ||
| 36 | index XXXXXXX..XXXXXXX 100755 | ||
| 37 | --- a/tests/functional/test_arm_aspeed.py | ||
| 38 | +++ b/tests/functional/test_arm_aspeed.py | ||
| 39 | @@ -XXX,XX +XXX,XX @@ | ||
| 40 | from zipfile import ZipFile | ||
| 41 | from unittest import skipUnless | ||
| 42 | |||
| 43 | -class AST2x00Machine(LinuxKernelTest): | ||
| 44 | - | ||
| 45 | - def do_test_arm_aspeed_buildroot_start(self, image, cpu_id, pattern='Aspeed EVB'): | ||
| 46 | - self.require_netdev('user') | ||
| 47 | - self.vm.set_console() | ||
| 48 | - self.vm.add_args('-drive', 'file=' + image + ',if=mtd,format=raw,read-only=true', | ||
| 49 | - '-net', 'nic', '-net', 'user') | ||
| 50 | - self.vm.launch() | ||
| 51 | - | ||
| 52 | - self.wait_for_console_pattern('U-Boot 2019.04') | ||
| 53 | - self.wait_for_console_pattern('## Loading kernel from FIT Image') | ||
| 54 | - self.wait_for_console_pattern('Starting kernel ...') | ||
| 55 | - self.wait_for_console_pattern('Booting Linux on physical CPU ' + cpu_id) | ||
| 56 | - self.wait_for_console_pattern('lease of 10.0.2.15') | ||
| 57 | - # the line before login: | ||
| 58 | - self.wait_for_console_pattern(pattern) | ||
| 59 | - exec_command_and_wait_for_pattern(self, 'root', 'Password:') | ||
| 60 | - exec_command_and_wait_for_pattern(self, 'passw0rd', '#') | ||
| 61 | - | ||
| 62 | - def do_test_arm_aspeed_buildroot_poweroff(self): | ||
| 63 | - exec_command_and_wait_for_pattern(self, 'poweroff', | ||
| 64 | - 'reboot: System halted'); | ||
| 65 | - ASSET_BR2_202311_AST2600_FLASH = Asset( | ||
| 66 | - ('https://github.com/legoater/qemu-aspeed-boot/raw/master/' | ||
| 67 | - 'images/ast2600-evb/buildroot-2023.11/flash.img'), | ||
| 68 | - 'b62808daef48b438d0728ee07662290490ecfa65987bb91294cafb1bb7ad1a68') | ||
| 69 | - | ||
| 70 | - def test_arm_ast2600_evb_buildroot(self): | ||
| 71 | - self.set_machine('ast2600-evb') | ||
| 72 | - | ||
| 73 | - image_path = self.ASSET_BR2_202311_AST2600_FLASH.fetch() | ||
| 74 | - | ||
| 75 | - self.vm.add_args('-device', | ||
| 76 | - 'tmp105,bus=aspeed.i2c.bus.3,address=0x4d,id=tmp-test'); | ||
| 77 | - self.vm.add_args('-device', | ||
| 78 | - 'ds1338,bus=aspeed.i2c.bus.3,address=0x32'); | ||
| 79 | - self.vm.add_args('-device', | ||
| 80 | - 'i2c-echo,bus=aspeed.i2c.bus.3,address=0x42'); | ||
| 81 | - self.do_test_arm_aspeed_buildroot_start(image_path, '0xf00', | ||
| 82 | - 'ast2600-evb login:') | ||
| 83 | - | ||
| 84 | - exec_command_and_wait_for_pattern(self, | ||
| 85 | - 'echo lm75 0x4d > /sys/class/i2c-dev/i2c-3/device/new_device', | ||
| 86 | - 'i2c i2c-3: new_device: Instantiated device lm75 at 0x4d'); | ||
| 87 | - exec_command_and_wait_for_pattern(self, | ||
| 88 | - 'cat /sys/class/hwmon/hwmon1/temp1_input', '0') | ||
| 89 | - self.vm.cmd('qom-set', path='/machine/peripheral/tmp-test', | ||
| 90 | - property='temperature', value=18000); | ||
| 91 | - exec_command_and_wait_for_pattern(self, | ||
| 92 | - 'cat /sys/class/hwmon/hwmon1/temp1_input', '18000') | ||
| 93 | - | ||
| 94 | - exec_command_and_wait_for_pattern(self, | ||
| 95 | - 'echo ds1307 0x32 > /sys/class/i2c-dev/i2c-3/device/new_device', | ||
| 96 | - 'i2c i2c-3: new_device: Instantiated device ds1307 at 0x32'); | ||
| 97 | - year = time.strftime("%Y") | ||
| 98 | - exec_command_and_wait_for_pattern(self, 'hwclock -f /dev/rtc1', year); | ||
| 99 | - | ||
| 100 | - exec_command_and_wait_for_pattern(self, | ||
| 101 | - 'echo slave-24c02 0x1064 > /sys/bus/i2c/devices/i2c-3/new_device', | ||
| 102 | - 'i2c i2c-3: new_device: Instantiated device slave-24c02 at 0x64'); | ||
| 103 | - exec_command_and_wait_for_pattern(self, | ||
| 104 | - 'i2cset -y 3 0x42 0x64 0x00 0xaa i', '#'); | ||
| 105 | - exec_command_and_wait_for_pattern(self, | ||
| 106 | - 'hexdump /sys/bus/i2c/devices/3-1064/slave-eeprom', | ||
| 107 | - '0000000 ffaa ffff ffff ffff ffff ffff ffff ffff'); | ||
| 108 | - self.do_test_arm_aspeed_buildroot_poweroff() | ||
| 109 | - | ||
| 110 | - ASSET_BR2_202302_AST2600_TPM_FLASH = Asset( | ||
| 111 | - ('https://github.com/legoater/qemu-aspeed-boot/raw/master/' | ||
| 112 | - 'images/ast2600-evb/buildroot-2023.02-tpm/flash.img'), | ||
| 113 | - 'a46009ae8a5403a0826d607215e731a8c68d27c14c41e55331706b8f9c7bd997') | ||
| 114 | - | ||
| 115 | - @skipUnless(*has_cmd('swtpm')) | ||
| 116 | - def test_arm_ast2600_evb_buildroot_tpm(self): | ||
| 117 | - self.set_machine('ast2600-evb') | ||
| 118 | - | ||
| 119 | - image_path = self.ASSET_BR2_202302_AST2600_TPM_FLASH.fetch() | ||
| 120 | - | ||
| 121 | - tpmstate_dir = tempfile.TemporaryDirectory(prefix="qemu_") | ||
| 122 | - socket = os.path.join(tpmstate_dir.name, 'swtpm-socket') | ||
| 123 | - | ||
| 124 | - # We must put the TPM state dir in /tmp/, not the build dir, | ||
| 125 | - # because some distros use AppArmor to lock down swtpm and | ||
| 126 | - # restrict the set of locations it can access files in. | ||
| 127 | - subprocess.run(['swtpm', 'socket', '-d', '--tpm2', | ||
| 128 | - '--tpmstate', f'dir={tpmstate_dir.name}', | ||
| 129 | - '--ctrl', f'type=unixio,path={socket}']) | ||
| 130 | - | ||
| 131 | - self.vm.add_args('-chardev', f'socket,id=chrtpm,path={socket}') | ||
| 132 | - self.vm.add_args('-tpmdev', 'emulator,id=tpm0,chardev=chrtpm') | ||
| 133 | - self.vm.add_args('-device', | ||
| 134 | - 'tpm-tis-i2c,tpmdev=tpm0,bus=aspeed.i2c.bus.12,address=0x2e') | ||
| 135 | - self.do_test_arm_aspeed_buildroot_start(image_path, '0xf00', 'Aspeed AST2600 EVB') | ||
| 136 | - | ||
| 137 | - exec_command_and_wait_for_pattern(self, | ||
| 138 | - 'echo tpm_tis_i2c 0x2e > /sys/bus/i2c/devices/i2c-12/new_device', | ||
| 139 | - 'tpm_tis_i2c 12-002e: 2.0 TPM (device-id 0x1, rev-id 1)'); | ||
| 140 | - exec_command_and_wait_for_pattern(self, | ||
| 141 | - 'cat /sys/class/tpm/tpm0/pcr-sha256/0', | ||
| 142 | - 'B804724EA13F52A9072BA87FE8FDCC497DFC9DF9AA15B9088694639C431688E0'); | ||
| 143 | - | ||
| 144 | - self.do_test_arm_aspeed_buildroot_poweroff() | ||
| 145 | - | ||
| 146 | - def do_test_arm_aspeed_sdk_start(self, image): | ||
| 147 | - self.require_netdev('user') | ||
| 148 | - self.vm.set_console() | ||
| 149 | - self.vm.add_args('-drive', 'file=' + image + ',if=mtd,format=raw', | ||
| 150 | - '-net', 'nic', '-net', 'user', '-snapshot') | ||
| 151 | - self.vm.launch() | ||
| 152 | - | ||
| 153 | - self.wait_for_console_pattern('U-Boot 2019.04') | ||
| 154 | - self.wait_for_console_pattern('## Loading kernel from FIT Image') | ||
| 155 | - self.wait_for_console_pattern('Starting kernel ...') | ||
| 156 | - | ||
| 157 | - ASSET_SDK_V806_AST2600_A2 = Asset( | ||
| 158 | - 'https://github.com/AspeedTech-BMC/openbmc/releases/download/v08.06/ast2600-a2-obmc.tar.gz', | ||
| 159 | - '9083506135f622d5e7351fcf7d4e1c7125cee5ba16141220c0ba88931f3681a4') | ||
| 160 | - | ||
| 161 | - def test_arm_ast2600_evb_sdk(self): | ||
| 162 | - self.set_machine('ast2600-evb') | ||
| 163 | - | ||
| 164 | - image_path = self.ASSET_SDK_V806_AST2600_A2.fetch() | ||
| 165 | - | ||
| 166 | - archive_extract(image_path, self.workdir) | ||
| 167 | - | ||
| 168 | - self.vm.add_args('-device', | ||
| 169 | - 'tmp105,bus=aspeed.i2c.bus.5,address=0x4d,id=tmp-test'); | ||
| 170 | - self.vm.add_args('-device', | ||
| 171 | - 'ds1338,bus=aspeed.i2c.bus.5,address=0x32'); | ||
| 172 | - self.do_test_arm_aspeed_sdk_start( | ||
| 173 | - self.workdir + '/ast2600-a2/image-bmc') | ||
| 174 | - | ||
| 175 | - self.wait_for_console_pattern('ast2600-a2 login:') | ||
| 176 | - | ||
| 177 | - exec_command_and_wait_for_pattern(self, 'root', 'Password:') | ||
| 178 | - exec_command_and_wait_for_pattern(self, '0penBmc', 'root@ast2600-a2:~#') | ||
| 179 | - | ||
| 180 | - exec_command_and_wait_for_pattern(self, | ||
| 181 | - 'echo lm75 0x4d > /sys/class/i2c-dev/i2c-5/device/new_device', | ||
| 182 | - 'i2c i2c-5: new_device: Instantiated device lm75 at 0x4d'); | ||
| 183 | - exec_command_and_wait_for_pattern(self, | ||
| 184 | - 'cat /sys/class/hwmon/hwmon19/temp1_input', '0') | ||
| 185 | - self.vm.cmd('qom-set', path='/machine/peripheral/tmp-test', | ||
| 186 | - property='temperature', value=18000); | ||
| 187 | - exec_command_and_wait_for_pattern(self, | ||
| 188 | - 'cat /sys/class/hwmon/hwmon19/temp1_input', '18000') | ||
| 189 | - | ||
| 190 | - exec_command_and_wait_for_pattern(self, | ||
| 191 | - 'echo ds1307 0x32 > /sys/class/i2c-dev/i2c-5/device/new_device', | ||
| 192 | - 'i2c i2c-5: new_device: Instantiated device ds1307 at 0x32'); | ||
| 193 | - year = time.strftime("%Y") | ||
| 194 | - exec_command_and_wait_for_pattern(self, | ||
| 195 | - '/sbin/hwclock -f /dev/rtc1', year); | ||
| 196 | - | ||
| 197 | - | ||
| 198 | class AST2x00MachineMMC(LinuxKernelTest): | ||
| 199 | |||
| 200 | ASSET_RAINIER_EMMC = Asset( | ||
| 201 | diff --git a/tests/functional/test_arm_aspeed_ast2600.py b/tests/functional/test_arm_aspeed_ast2600.py | ||
| 202 | new file mode 100644 | ||
| 203 | index XXXXXXX..XXXXXXX | ||
| 204 | --- /dev/null | ||
| 205 | +++ b/tests/functional/test_arm_aspeed_ast2600.py | ||
| 206 | @@ -XXX,XX +XXX,XX @@ | ||
| 207 | +#!/usr/bin/env python3 | ||
| 208 | +# | ||
| 209 | +# Functional test that boots the ASPEED machines | ||
| 210 | +# | ||
| 211 | +# SPDX-License-Identifier: GPL-2.0-or-later | ||
| 212 | + | ||
| 213 | +import os | ||
| 214 | +import time | ||
| 215 | +import tempfile | ||
| 216 | +import subprocess | ||
| 217 | + | ||
| 218 | +from qemu_test import Asset | ||
| 219 | +from aspeed import AspeedTest | ||
| 220 | +from qemu_test import exec_command_and_wait_for_pattern | ||
| 221 | +from qemu_test import has_cmd | ||
| 222 | +from qemu_test.utils import archive_extract | ||
| 223 | +from unittest import skipUnless | ||
| 224 | + | ||
| 225 | +class AST2600Machine(AspeedTest): | ||
| 226 | + | ||
| 227 | + ASSET_BR2_202311_AST2600_FLASH = Asset( | ||
| 228 | + ('https://github.com/legoater/qemu-aspeed-boot/raw/master/' | ||
| 229 | + 'images/ast2600-evb/buildroot-2023.11/flash.img'), | ||
| 230 | + 'b62808daef48b438d0728ee07662290490ecfa65987bb91294cafb1bb7ad1a68') | ||
| 231 | + | ||
| 232 | + def test_arm_ast2600_evb_buildroot(self): | ||
| 233 | + self.set_machine('ast2600-evb') | ||
| 234 | + | ||
| 235 | + image_path = self.ASSET_BR2_202311_AST2600_FLASH.fetch() | ||
| 236 | + | ||
| 237 | + self.vm.add_args('-device', | ||
| 238 | + 'tmp105,bus=aspeed.i2c.bus.3,address=0x4d,id=tmp-test'); | ||
| 239 | + self.vm.add_args('-device', | ||
| 240 | + 'ds1338,bus=aspeed.i2c.bus.3,address=0x32'); | ||
| 241 | + self.vm.add_args('-device', | ||
| 242 | + 'i2c-echo,bus=aspeed.i2c.bus.3,address=0x42'); | ||
| 243 | + self.do_test_arm_aspeed_buildroot_start(image_path, '0xf00', | ||
| 244 | + 'ast2600-evb login:') | ||
| 245 | + | ||
| 246 | + exec_command_and_wait_for_pattern(self, | ||
| 247 | + 'echo lm75 0x4d > /sys/class/i2c-dev/i2c-3/device/new_device', | ||
| 248 | + 'i2c i2c-3: new_device: Instantiated device lm75 at 0x4d'); | ||
| 249 | + exec_command_and_wait_for_pattern(self, | ||
| 250 | + 'cat /sys/class/hwmon/hwmon1/temp1_input', '0') | ||
| 251 | + self.vm.cmd('qom-set', path='/machine/peripheral/tmp-test', | ||
| 252 | + property='temperature', value=18000); | ||
| 253 | + exec_command_and_wait_for_pattern(self, | ||
| 254 | + 'cat /sys/class/hwmon/hwmon1/temp1_input', '18000') | ||
| 255 | + | ||
| 256 | + exec_command_and_wait_for_pattern(self, | ||
| 257 | + 'echo ds1307 0x32 > /sys/class/i2c-dev/i2c-3/device/new_device', | ||
| 258 | + 'i2c i2c-3: new_device: Instantiated device ds1307 at 0x32'); | ||
| 259 | + year = time.strftime("%Y") | ||
| 260 | + exec_command_and_wait_for_pattern(self, 'hwclock -f /dev/rtc1', year); | ||
| 261 | + | ||
| 262 | + exec_command_and_wait_for_pattern(self, | ||
| 263 | + 'echo slave-24c02 0x1064 > /sys/bus/i2c/devices/i2c-3/new_device', | ||
| 264 | + 'i2c i2c-3: new_device: Instantiated device slave-24c02 at 0x64'); | ||
| 265 | + exec_command_and_wait_for_pattern(self, | ||
| 266 | + 'i2cset -y 3 0x42 0x64 0x00 0xaa i', '#'); | ||
| 267 | + exec_command_and_wait_for_pattern(self, | ||
| 268 | + 'hexdump /sys/bus/i2c/devices/3-1064/slave-eeprom', | ||
| 269 | + '0000000 ffaa ffff ffff ffff ffff ffff ffff ffff'); | ||
| 270 | + self.do_test_arm_aspeed_buildroot_poweroff() | ||
| 271 | + | ||
| 272 | + ASSET_BR2_202302_AST2600_TPM_FLASH = Asset( | ||
| 273 | + ('https://github.com/legoater/qemu-aspeed-boot/raw/master/' | ||
| 274 | + 'images/ast2600-evb/buildroot-2023.02-tpm/flash.img'), | ||
| 275 | + 'a46009ae8a5403a0826d607215e731a8c68d27c14c41e55331706b8f9c7bd997') | ||
| 276 | + | ||
| 277 | + @skipUnless(*has_cmd('swtpm')) | ||
| 278 | + def test_arm_ast2600_evb_buildroot_tpm(self): | ||
| 279 | + self.set_machine('ast2600-evb') | ||
| 280 | + | ||
| 281 | + image_path = self.ASSET_BR2_202302_AST2600_TPM_FLASH.fetch() | ||
| 282 | + | ||
| 283 | + tpmstate_dir = tempfile.TemporaryDirectory(prefix="qemu_") | ||
| 284 | + socket = os.path.join(tpmstate_dir.name, 'swtpm-socket') | ||
| 285 | + | ||
| 286 | + # We must put the TPM state dir in /tmp/, not the build dir, | ||
| 287 | + # because some distros use AppArmor to lock down swtpm and | ||
| 288 | + # restrict the set of locations it can access files in. | ||
| 289 | + subprocess.run(['swtpm', 'socket', '-d', '--tpm2', | ||
| 290 | + '--tpmstate', f'dir={tpmstate_dir.name}', | ||
| 291 | + '--ctrl', f'type=unixio,path={socket}']) | ||
| 292 | + | ||
| 293 | + self.vm.add_args('-chardev', f'socket,id=chrtpm,path={socket}') | ||
| 294 | + self.vm.add_args('-tpmdev', 'emulator,id=tpm0,chardev=chrtpm') | ||
| 295 | + self.vm.add_args('-device', | ||
| 296 | + 'tpm-tis-i2c,tpmdev=tpm0,bus=aspeed.i2c.bus.12,address=0x2e') | ||
| 297 | + self.do_test_arm_aspeed_buildroot_start(image_path, '0xf00', 'Aspeed AST2600 EVB') | ||
| 298 | + | ||
| 299 | + exec_command_and_wait_for_pattern(self, | ||
| 300 | + 'echo tpm_tis_i2c 0x2e > /sys/bus/i2c/devices/i2c-12/new_device', | ||
| 301 | + 'tpm_tis_i2c 12-002e: 2.0 TPM (device-id 0x1, rev-id 1)'); | ||
| 302 | + exec_command_and_wait_for_pattern(self, | ||
| 303 | + 'cat /sys/class/tpm/tpm0/pcr-sha256/0', | ||
| 304 | + 'B804724EA13F52A9072BA87FE8FDCC497DFC9DF9AA15B9088694639C431688E0'); | ||
| 305 | + | ||
| 306 | + self.do_test_arm_aspeed_buildroot_poweroff() | ||
| 307 | + | ||
| 308 | + ASSET_SDK_V806_AST2600_A2 = Asset( | ||
| 309 | + 'https://github.com/AspeedTech-BMC/openbmc/releases/download/v08.06/ast2600-a2-obmc.tar.gz', | ||
| 310 | + '9083506135f622d5e7351fcf7d4e1c7125cee5ba16141220c0ba88931f3681a4') | ||
| 311 | + | ||
| 312 | + def test_arm_ast2600_evb_sdk(self): | ||
| 313 | + self.set_machine('ast2600-evb') | ||
| 314 | + | ||
| 315 | + image_path = self.ASSET_SDK_V806_AST2600_A2.fetch() | ||
| 316 | + | ||
| 317 | + archive_extract(image_path, self.workdir) | ||
| 318 | + | ||
| 319 | + self.vm.add_args('-device', | ||
| 320 | + 'tmp105,bus=aspeed.i2c.bus.5,address=0x4d,id=tmp-test'); | ||
| 321 | + self.vm.add_args('-device', | ||
| 322 | + 'ds1338,bus=aspeed.i2c.bus.5,address=0x32'); | ||
| 323 | + self.do_test_arm_aspeed_sdk_start( | ||
| 324 | + self.workdir + '/ast2600-a2/image-bmc') | ||
| 325 | + | ||
| 326 | + self.wait_for_console_pattern('ast2600-a2 login:') | ||
| 327 | + | ||
| 328 | + exec_command_and_wait_for_pattern(self, 'root', 'Password:') | ||
| 329 | + exec_command_and_wait_for_pattern(self, '0penBmc', 'root@ast2600-a2:~#') | ||
| 330 | + | ||
| 331 | + exec_command_and_wait_for_pattern(self, | ||
| 332 | + 'echo lm75 0x4d > /sys/class/i2c-dev/i2c-5/device/new_device', | ||
| 333 | + 'i2c i2c-5: new_device: Instantiated device lm75 at 0x4d'); | ||
| 334 | + exec_command_and_wait_for_pattern(self, | ||
| 335 | + 'cat /sys/class/hwmon/hwmon19/temp1_input', '0') | ||
| 336 | + self.vm.cmd('qom-set', path='/machine/peripheral/tmp-test', | ||
| 337 | + property='temperature', value=18000); | ||
| 338 | + exec_command_and_wait_for_pattern(self, | ||
| 339 | + 'cat /sys/class/hwmon/hwmon19/temp1_input', '18000') | ||
| 340 | + | ||
| 341 | + exec_command_and_wait_for_pattern(self, | ||
| 342 | + 'echo ds1307 0x32 > /sys/class/i2c-dev/i2c-5/device/new_device', | ||
| 343 | + 'i2c i2c-5: new_device: Instantiated device ds1307 at 0x32'); | ||
| 344 | + year = time.strftime("%Y") | ||
| 345 | + exec_command_and_wait_for_pattern(self, | ||
| 346 | + '/sbin/hwclock -f /dev/rtc1', year); | ||
| 347 | + | ||
| 348 | +if __name__ == '__main__': | ||
| 349 | + AspeedTest.main() | ||
| 350 | -- | ||
| 351 | 2.47.1 | ||
| 352 | |||
| 353 | diff view generated by jsdifflib |
New patch | |||
|---|---|---|---|
| 1 | This simply moves the rainier-bmc test to a new test file. No changes | ||
| 2 | in the test. The test_arm_aspeed.py is deleted. | ||
| 1 | 3 | ||
| 4 | Reviewed-by: Thomas Huth <thuth@redhat.com> | ||
| 5 | Link: https://lore.kernel.org/r/20241206131132.520911-7-clg@redhat.com | ||
| 6 | Signed-off-by: Cédric Le Goater <clg@redhat.com> | ||
| 7 | --- | ||
| 8 | tests/functional/meson.build | 4 ++-- | ||
| 9 | ...m_aspeed.py => test_arm_aspeed_rainier.py} | 22 +++++-------------- | ||
| 10 | 2 files changed, 7 insertions(+), 19 deletions(-) | ||
| 11 | rename tests/functional/{test_arm_aspeed.py => test_arm_aspeed_rainier.py} (71%) | ||
| 12 | mode change 100755 => 100644 | ||
| 13 | |||
| 14 | diff --git a/tests/functional/meson.build b/tests/functional/meson.build | ||
| 15 | index XXXXXXX..XXXXXXX 100644 | ||
| 16 | --- a/tests/functional/meson.build | ||
| 17 | +++ b/tests/functional/meson.build | ||
| 18 | @@ -XXX,XX +XXX,XX @@ test_timeouts = { | ||
| 19 | 'arm_aspeed_romulus' : 120, | ||
| 20 | 'arm_aspeed_ast2500' : 480, | ||
| 21 | 'arm_aspeed_ast2600' : 720, | ||
| 22 | - 'arm_aspeed' : 600, | ||
| 23 | + 'arm_aspeed_rainier' : 240, | ||
| 24 | 'arm_bpim2u' : 500, | ||
| 25 | 'arm_collie' : 180, | ||
| 26 | 'arm_orangepi' : 540, | ||
| 27 | @@ -XXX,XX +XXX,XX @@ tests_alpha_system_thorough = [ | ||
| 28 | ] | ||
| 29 | |||
| 30 | tests_arm_system_thorough = [ | ||
| 31 | - 'arm_aspeed', | ||
| 32 | 'arm_aspeed_ast1030', | ||
| 33 | 'arm_aspeed_palmetto', | ||
| 34 | 'arm_aspeed_romulus', | ||
| 35 | 'arm_aspeed_ast2500', | ||
| 36 | 'arm_aspeed_ast2600', | ||
| 37 | + 'arm_aspeed_rainier', | ||
| 38 | 'arm_bpim2u', | ||
| 39 | 'arm_canona1100', | ||
| 40 | 'arm_collie', | ||
| 41 | diff --git a/tests/functional/test_arm_aspeed.py b/tests/functional/test_arm_aspeed_rainier.py | ||
| 42 | old mode 100755 | ||
| 43 | new mode 100644 | ||
| 44 | similarity index 71% | ||
| 45 | rename from tests/functional/test_arm_aspeed.py | ||
| 46 | rename to tests/functional/test_arm_aspeed_rainier.py | ||
| 47 | index XXXXXXX..XXXXXXX | ||
| 48 | --- a/tests/functional/test_arm_aspeed.py | ||
| 49 | +++ b/tests/functional/test_arm_aspeed_rainier.py | ||
| 50 | @@ -XXX,XX +XXX,XX @@ | ||
| 51 | #!/usr/bin/env python3 | ||
| 52 | # | ||
| 53 | -# Functional test that boots the ASPEED SoCs with firmware | ||
| 54 | -# | ||
| 55 | -# Copyright (C) 2022 ASPEED Technology Inc | ||
| 56 | +# Functional test that boots the ASPEED machines | ||
| 57 | # | ||
| 58 | # SPDX-License-Identifier: GPL-2.0-or-later | ||
| 59 | |||
| 60 | -import os | ||
| 61 | -import time | ||
| 62 | -import subprocess | ||
| 63 | -import tempfile | ||
| 64 | - | ||
| 65 | -from qemu_test import LinuxKernelTest, Asset | ||
| 66 | -from qemu_test import exec_command_and_wait_for_pattern | ||
| 67 | -from qemu_test import interrupt_interactive_console_until_pattern | ||
| 68 | -from qemu_test import has_cmd | ||
| 69 | -from qemu_test.utils import archive_extract | ||
| 70 | -from zipfile import ZipFile | ||
| 71 | -from unittest import skipUnless | ||
| 72 | +from qemu_test import Asset | ||
| 73 | +from aspeed import AspeedTest | ||
| 74 | |||
| 75 | -class AST2x00MachineMMC(LinuxKernelTest): | ||
| 76 | +class RainierMachine(AspeedTest): | ||
| 77 | |||
| 78 | ASSET_RAINIER_EMMC = Asset( | ||
| 79 | ('https://fileserver.linaro.org/s/B6pJTwWEkzSDi36/download/' | ||
| 80 | @@ -XXX,XX +XXX,XX @@ def test_arm_aspeed_emmc_boot(self): | ||
| 81 | self.wait_for_console_pattern('IBM eBMC (OpenBMC for IBM Enterprise') | ||
| 82 | |||
| 83 | if __name__ == '__main__': | ||
| 84 | - LinuxKernelTest.main() | ||
| 85 | + AspeedTest.main() | ||
| 86 | -- | ||
| 87 | 2.47.1 | ||
| 88 | |||
| 89 | diff view generated by jsdifflib |
New patch | |||
|---|---|---|---|
| 1 | This simply moves the debian boot test from the avocado testsuite to | ||
| 2 | the new functional testsuite. No changes in the test. | ||
| 1 | 3 | ||
| 4 | Reviewed-by: Thomas Huth <thuth@redhat.com> | ||
| 5 | Link: https://lore.kernel.org/r/20241206131132.520911-8-clg@redhat.com | ||
| 6 | Signed-off-by: Cédric Le Goater <clg@redhat.com> | ||
| 7 | --- | ||
| 8 | tests/avocado/boot_linux_console.py | 26 --------------------- | ||
| 9 | tests/functional/test_arm_aspeed_rainier.py | 24 +++++++++++++++++++ | ||
| 10 | 2 files changed, 24 insertions(+), 26 deletions(-) | ||
| 11 | |||
| 12 | diff --git a/tests/avocado/boot_linux_console.py b/tests/avocado/boot_linux_console.py | ||
| 13 | index XXXXXXX..XXXXXXX 100644 | ||
| 14 | --- a/tests/avocado/boot_linux_console.py | ||
| 15 | +++ b/tests/avocado/boot_linux_console.py | ||
| 16 | @@ -XXX,XX +XXX,XX @@ def test_arm_quanta_gsj_initrd(self): | ||
| 17 | self.wait_for_console_pattern('CPU1: thread -1, cpu 1, socket 0') | ||
| 18 | self.wait_for_console_pattern( | ||
| 19 | 'Give root password for system maintenance') | ||
| 20 | - | ||
| 21 | - def test_arm_ast2600_debian(self): | ||
| 22 | - """ | ||
| 23 | - :avocado: tags=arch:arm | ||
| 24 | - :avocado: tags=machine:rainier-bmc | ||
| 25 | - """ | ||
| 26 | - deb_url = ('http://snapshot.debian.org/archive/debian/' | ||
| 27 | - '20220606T211338Z/' | ||
| 28 | - 'pool/main/l/linux/' | ||
| 29 | - 'linux-image-5.17.0-2-armmp_5.17.6-1%2Bb1_armhf.deb') | ||
| 30 | - deb_hash = '8acb2b4439faedc2f3ed4bdb2847ad4f6e0491f73debaeb7f660c8abe4dcdc0e' | ||
| 31 | - deb_path = self.fetch_asset(deb_url, asset_hash=deb_hash, | ||
| 32 | - algorithm='sha256') | ||
| 33 | - kernel_path = self.extract_from_deb(deb_path, '/boot/vmlinuz-5.17.0-2-armmp') | ||
| 34 | - dtb_path = self.extract_from_deb(deb_path, | ||
| 35 | - '/usr/lib/linux-image-5.17.0-2-armmp/aspeed-bmc-ibm-rainier.dtb') | ||
| 36 | - | ||
| 37 | - self.vm.set_console() | ||
| 38 | - self.vm.add_args('-kernel', kernel_path, | ||
| 39 | - '-dtb', dtb_path, | ||
| 40 | - '-net', 'nic') | ||
| 41 | - self.vm.launch() | ||
| 42 | - self.wait_for_console_pattern("Booting Linux on physical CPU 0xf00") | ||
| 43 | - self.wait_for_console_pattern("SMP: Total of 2 processors activated") | ||
| 44 | - self.wait_for_console_pattern("No filesystem could mount root") | ||
| 45 | - | ||
| 46 | diff --git a/tests/functional/test_arm_aspeed_rainier.py b/tests/functional/test_arm_aspeed_rainier.py | ||
| 47 | index XXXXXXX..XXXXXXX 100644 | ||
| 48 | --- a/tests/functional/test_arm_aspeed_rainier.py | ||
| 49 | +++ b/tests/functional/test_arm_aspeed_rainier.py | ||
| 50 | @@ -XXX,XX +XXX,XX @@ def test_arm_aspeed_emmc_boot(self): | ||
| 51 | self.wait_for_console_pattern('mmcblk0: p1 p2 p3 p4 p5 p6 p7') | ||
| 52 | self.wait_for_console_pattern('IBM eBMC (OpenBMC for IBM Enterprise') | ||
| 53 | |||
| 54 | + ASSET_DEBIAN_LINUX_ARMHF_DEB = Asset( | ||
| 55 | + ('http://snapshot.debian.org/archive/debian/20220606T211338Z/pool/main/l/linux/linux-image-5.17.0-2-armmp_5.17.6-1%2Bb1_armhf.deb'), | ||
| 56 | + '8acb2b4439faedc2f3ed4bdb2847ad4f6e0491f73debaeb7f660c8abe4dcdc0e') | ||
| 57 | + | ||
| 58 | + def test_arm_debian_kernel_boot(self): | ||
| 59 | + self.set_machine('rainier-bmc') | ||
| 60 | + | ||
| 61 | + deb_path = self.ASSET_DEBIAN_LINUX_ARMHF_DEB.fetch() | ||
| 62 | + | ||
| 63 | + kernel_path = self.extract_from_deb(deb_path, '/boot/vmlinuz-5.17.0-2-armmp') | ||
| 64 | + dtb_path = self.extract_from_deb(deb_path, | ||
| 65 | + '/usr/lib/linux-image-5.17.0-2-armmp/aspeed-bmc-ibm-rainier.dtb') | ||
| 66 | + | ||
| 67 | + self.vm.set_console() | ||
| 68 | + self.vm.add_args('-kernel', kernel_path, | ||
| 69 | + '-dtb', dtb_path, | ||
| 70 | + '-net', 'nic') | ||
| 71 | + self.vm.launch() | ||
| 72 | + | ||
| 73 | + self.wait_for_console_pattern("Booting Linux on physical CPU 0xf00") | ||
| 74 | + self.wait_for_console_pattern("SMP: Total of 2 processors activated") | ||
| 75 | + self.wait_for_console_pattern("No filesystem could mount root") | ||
| 76 | + | ||
| 77 | + | ||
| 78 | if __name__ == '__main__': | ||
| 79 | AspeedTest.main() | ||
| 80 | -- | ||
| 81 | 2.47.1 | ||
| 82 | |||
| 83 | diff view generated by jsdifflib |
New patch | |||
|---|---|---|---|
| 1 | From: Jamin Lin <jamin_lin@aspeedtech.com> | ||
| 1 | 2 | ||
| 3 | So far, the test cases are used for testing SMC model with AST2400 BMC. | ||
| 4 | However, AST2400 is end off live and ASPEED is no longer support this SOC. | ||
| 5 | To test SMC model for AST2500, AST2600 and AST1030, move the test cases | ||
| 6 | from main to test_palmetto_bmc function. | ||
| 7 | |||
| 8 | Signed-off-by: Jamin Lin <jamin_lin@aspeedtech.com> | ||
| 9 | Reviewed-by: Cédric Le Goater <clg@redhat.com> | ||
| 10 | Link: https://lore.kernel.org/r/20241127091543.1243114-2-jamin_lin@aspeedtech.com | ||
| 11 | Signed-off-by: Cédric Le Goater <clg@redhat.com> | ||
| 12 | --- | ||
| 13 | tests/qtest/aspeed_smc-test.c | 16 ++++++++++++---- | ||
| 14 | 1 file changed, 12 insertions(+), 4 deletions(-) | ||
| 15 | |||
| 16 | diff --git a/tests/qtest/aspeed_smc-test.c b/tests/qtest/aspeed_smc-test.c | ||
| 17 | index XXXXXXX..XXXXXXX 100644 | ||
| 18 | --- a/tests/qtest/aspeed_smc-test.c | ||
| 19 | +++ b/tests/qtest/aspeed_smc-test.c | ||
| 20 | @@ -XXX,XX +XXX,XX @@ static void test_write_block_protect_bottom_bit(void) | ||
| 21 | flash_reset(); | ||
| 22 | } | ||
| 23 | |||
| 24 | -int main(int argc, char **argv) | ||
| 25 | +static int test_palmetto_bmc(void) | ||
| 26 | { | ||
| 27 | g_autofree char *tmp_path = NULL; | ||
| 28 | int ret; | ||
| 29 | int fd; | ||
| 30 | |||
| 31 | - g_test_init(&argc, &argv, NULL); | ||
| 32 | - | ||
| 33 | fd = g_file_open_tmp("qtest.m25p80.XXXXXX", &tmp_path, NULL); | ||
| 34 | g_assert(fd >= 0); | ||
| 35 | ret = ftruncate(fd, FLASH_SIZE); | ||
| 36 | @@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv) | ||
| 37 | |||
| 38 | flash_reset(); | ||
| 39 | ret = g_test_run(); | ||
| 40 | - | ||
| 41 | qtest_quit(global_qtest); | ||
| 42 | unlink(tmp_path); | ||
| 43 | + | ||
| 44 | + return ret; | ||
| 45 | +} | ||
| 46 | + | ||
| 47 | +int main(int argc, char **argv) | ||
| 48 | +{ | ||
| 49 | + int ret; | ||
| 50 | + | ||
| 51 | + g_test_init(&argc, &argv, NULL); | ||
| 52 | + ret = test_palmetto_bmc(); | ||
| 53 | + | ||
| 54 | return ret; | ||
| 55 | } | ||
| 56 | -- | ||
| 57 | 2.47.1 | ||
| 58 | |||
| 59 | diff view generated by jsdifflib |
New patch | |||
|---|---|---|---|
| 1 | From: Jamin Lin <jamin_lin@aspeedtech.com> | ||
| 1 | 2 | ||
| 3 | Currently, these test cases are only used for testing fmc_cs0 for AST2400. | ||
| 4 | To test others BMC SOCs, introduces a new TestData structure. | ||
| 5 | Users can set the spi base address, flash base address, jedesc id and so on | ||
| 6 | for different BMC SOCs and flash model testing. | ||
| 7 | |||
| 8 | Introduce new helper functions to make the test case more readable. | ||
| 9 | |||
| 10 | Set spi base address 0x1E620000, flash_base address 0x20000000 | ||
| 11 | and jedec id 0x20ba19 for fmc_cs0 with n25q256a flash for AST2400 | ||
| 12 | SMC model testing. | ||
| 13 | |||
| 14 | To pass the TestData into the test case, replace qtest_add_func with | ||
| 15 | qtest_add_data_func. | ||
| 16 | |||
| 17 | Signed-off-by: Jamin Lin <jamin_lin@aspeedtech.com> | ||
| 18 | Reviewed-by: Cédric Le Goater <clg@redhat.com> | ||
| 19 | Link: https://lore.kernel.org/r/20241127091543.1243114-3-jamin_lin@aspeedtech.com | ||
| 20 | Signed-off-by: Cédric Le Goater <clg@redhat.com> | ||
| 21 | --- | ||
| 22 | tests/qtest/aspeed_smc-test.c | 546 +++++++++++++++++++--------------- | ||
| 23 | 1 file changed, 299 insertions(+), 247 deletions(-) | ||
| 24 | |||
| 25 | diff --git a/tests/qtest/aspeed_smc-test.c b/tests/qtest/aspeed_smc-test.c | ||
| 26 | index XXXXXXX..XXXXXXX 100644 | ||
| 27 | --- a/tests/qtest/aspeed_smc-test.c | ||
| 28 | +++ b/tests/qtest/aspeed_smc-test.c | ||
| 29 | @@ -XXX,XX +XXX,XX @@ | ||
| 30 | #define CTRL_USERMODE 0x3 | ||
| 31 | #define SR_WEL BIT(1) | ||
| 32 | |||
| 33 | -#define ASPEED_FMC_BASE 0x1E620000 | ||
| 34 | -#define ASPEED_FLASH_BASE 0x20000000 | ||
| 35 | - | ||
| 36 | /* | ||
| 37 | * Flash commands | ||
| 38 | */ | ||
| 39 | @@ -XXX,XX +XXX,XX @@ enum { | ||
| 40 | ERASE_SECTOR = 0xd8, | ||
| 41 | }; | ||
| 42 | |||
| 43 | -#define FLASH_JEDEC 0x20ba19 /* n25q256a */ | ||
| 44 | -#define FLASH_SIZE (32 * 1024 * 1024) | ||
| 45 | - | ||
| 46 | #define FLASH_PAGE_SIZE 256 | ||
| 47 | |||
| 48 | +typedef struct TestData { | ||
| 49 | + QTestState *s; | ||
| 50 | + uint64_t spi_base; | ||
| 51 | + uint64_t flash_base; | ||
| 52 | + uint32_t jedec_id; | ||
| 53 | + char *tmp_path; | ||
| 54 | +} TestData; | ||
| 55 | + | ||
| 56 | /* | ||
| 57 | * Use an explicit bswap for the values read/wrote to the flash region | ||
| 58 | * as they are BE and the Aspeed CPU is LE. | ||
| 59 | @@ -XXX,XX +XXX,XX @@ static inline uint32_t make_be32(uint32_t data) | ||
| 60 | return bswap32(data); | ||
| 61 | } | ||
| 62 | |||
| 63 | -static void spi_conf(uint32_t value) | ||
| 64 | +static inline void spi_writel(const TestData *data, uint64_t offset, | ||
| 65 | + uint32_t value) | ||
| 66 | +{ | ||
| 67 | + qtest_writel(data->s, data->spi_base + offset, value); | ||
| 68 | +} | ||
| 69 | + | ||
| 70 | +static inline uint32_t spi_readl(const TestData *data, uint64_t offset) | ||
| 71 | +{ | ||
| 72 | + return qtest_readl(data->s, data->spi_base + offset); | ||
| 73 | +} | ||
| 74 | + | ||
| 75 | +static inline void flash_writeb(const TestData *data, uint64_t offset, | ||
| 76 | + uint8_t value) | ||
| 77 | +{ | ||
| 78 | + qtest_writeb(data->s, data->flash_base + offset, value); | ||
| 79 | +} | ||
| 80 | + | ||
| 81 | +static inline void flash_writel(const TestData *data, uint64_t offset, | ||
| 82 | + uint32_t value) | ||
| 83 | +{ | ||
| 84 | + qtest_writel(data->s, data->flash_base + offset, value); | ||
| 85 | +} | ||
| 86 | + | ||
| 87 | +static inline uint8_t flash_readb(const TestData *data, uint64_t offset) | ||
| 88 | { | ||
| 89 | - uint32_t conf = readl(ASPEED_FMC_BASE + R_CONF); | ||
| 90 | + return qtest_readb(data->s, data->flash_base + offset); | ||
| 91 | +} | ||
| 92 | + | ||
| 93 | +static inline uint32_t flash_readl(const TestData *data, uint64_t offset) | ||
| 94 | +{ | ||
| 95 | + return qtest_readl(data->s, data->flash_base + offset); | ||
| 96 | +} | ||
| 97 | + | ||
| 98 | +static void spi_conf(const TestData *data, uint32_t value) | ||
| 99 | +{ | ||
| 100 | + uint32_t conf = spi_readl(data, R_CONF); | ||
| 101 | |||
| 102 | conf |= value; | ||
| 103 | - writel(ASPEED_FMC_BASE + R_CONF, conf); | ||
| 104 | + spi_writel(data, R_CONF, conf); | ||
| 105 | } | ||
| 106 | |||
| 107 | -static void spi_conf_remove(uint32_t value) | ||
| 108 | +static void spi_conf_remove(const TestData *data, uint32_t value) | ||
| 109 | { | ||
| 110 | - uint32_t conf = readl(ASPEED_FMC_BASE + R_CONF); | ||
| 111 | + uint32_t conf = spi_readl(data, R_CONF); | ||
| 112 | |||
| 113 | conf &= ~value; | ||
| 114 | - writel(ASPEED_FMC_BASE + R_CONF, conf); | ||
| 115 | + spi_writel(data, R_CONF, conf); | ||
| 116 | } | ||
| 117 | |||
| 118 | -static void spi_ce_ctrl(uint32_t value) | ||
| 119 | +static void spi_ce_ctrl(const TestData *data, uint32_t value) | ||
| 120 | { | ||
| 121 | - uint32_t conf = readl(ASPEED_FMC_BASE + R_CE_CTRL); | ||
| 122 | + uint32_t conf = spi_readl(data, R_CE_CTRL); | ||
| 123 | |||
| 124 | conf |= value; | ||
| 125 | - writel(ASPEED_FMC_BASE + R_CE_CTRL, conf); | ||
| 126 | + spi_writel(data, R_CE_CTRL, conf); | ||
| 127 | } | ||
| 128 | |||
| 129 | -static void spi_ctrl_setmode(uint8_t mode, uint8_t cmd) | ||
| 130 | +static void spi_ctrl_setmode(const TestData *data, uint8_t mode, uint8_t cmd) | ||
| 131 | { | ||
| 132 | - uint32_t ctrl = readl(ASPEED_FMC_BASE + R_CTRL0); | ||
| 133 | + uint32_t ctrl = spi_readl(data, R_CTRL0); | ||
| 134 | ctrl &= ~(CTRL_USERMODE | 0xff << 16); | ||
| 135 | ctrl |= mode | (cmd << 16); | ||
| 136 | - writel(ASPEED_FMC_BASE + R_CTRL0, ctrl); | ||
| 137 | + spi_writel(data, R_CTRL0, ctrl); | ||
| 138 | } | ||
| 139 | |||
| 140 | -static void spi_ctrl_start_user(void) | ||
| 141 | +static void spi_ctrl_start_user(const TestData *data) | ||
| 142 | { | ||
| 143 | - uint32_t ctrl = readl(ASPEED_FMC_BASE + R_CTRL0); | ||
| 144 | + uint32_t ctrl = spi_readl(data, R_CTRL0); | ||
| 145 | |||
| 146 | ctrl |= CTRL_USERMODE | CTRL_CE_STOP_ACTIVE; | ||
| 147 | - writel(ASPEED_FMC_BASE + R_CTRL0, ctrl); | ||
| 148 | + spi_writel(data, R_CTRL0, ctrl); | ||
| 149 | |||
| 150 | ctrl &= ~CTRL_CE_STOP_ACTIVE; | ||
| 151 | - writel(ASPEED_FMC_BASE + R_CTRL0, ctrl); | ||
| 152 | + spi_writel(data, R_CTRL0, ctrl); | ||
| 153 | } | ||
| 154 | |||
| 155 | -static void spi_ctrl_stop_user(void) | ||
| 156 | +static void spi_ctrl_stop_user(const TestData *data) | ||
| 157 | { | ||
| 158 | - uint32_t ctrl = readl(ASPEED_FMC_BASE + R_CTRL0); | ||
| 159 | + uint32_t ctrl = spi_readl(data, R_CTRL0); | ||
| 160 | |||
| 161 | ctrl |= CTRL_USERMODE | CTRL_CE_STOP_ACTIVE; | ||
| 162 | - writel(ASPEED_FMC_BASE + R_CTRL0, ctrl); | ||
| 163 | + spi_writel(data, R_CTRL0, ctrl); | ||
| 164 | } | ||
| 165 | |||
| 166 | -static void flash_reset(void) | ||
| 167 | +static void flash_reset(const TestData *data) | ||
| 168 | { | ||
| 169 | - spi_conf(CONF_ENABLE_W0); | ||
| 170 | + spi_conf(data, CONF_ENABLE_W0); | ||
| 171 | |||
| 172 | - spi_ctrl_start_user(); | ||
| 173 | - writeb(ASPEED_FLASH_BASE, RESET_ENABLE); | ||
| 174 | - writeb(ASPEED_FLASH_BASE, RESET_MEMORY); | ||
| 175 | - writeb(ASPEED_FLASH_BASE, WREN); | ||
| 176 | - writeb(ASPEED_FLASH_BASE, BULK_ERASE); | ||
| 177 | - writeb(ASPEED_FLASH_BASE, WRDI); | ||
| 178 | - spi_ctrl_stop_user(); | ||
| 179 | + spi_ctrl_start_user(data); | ||
| 180 | + flash_writeb(data, 0, RESET_ENABLE); | ||
| 181 | + flash_writeb(data, 0, RESET_MEMORY); | ||
| 182 | + flash_writeb(data, 0, WREN); | ||
| 183 | + flash_writeb(data, 0, BULK_ERASE); | ||
| 184 | + flash_writeb(data, 0, WRDI); | ||
| 185 | + spi_ctrl_stop_user(data); | ||
| 186 | |||
| 187 | - spi_conf_remove(CONF_ENABLE_W0); | ||
| 188 | + spi_conf_remove(data, CONF_ENABLE_W0); | ||
| 189 | } | ||
| 190 | |||
| 191 | -static void test_read_jedec(void) | ||
| 192 | +static void test_read_jedec(const void *data) | ||
| 193 | { | ||
| 194 | + const TestData *test_data = (const TestData *)data; | ||
| 195 | uint32_t jedec = 0x0; | ||
| 196 | |||
| 197 | - spi_conf(CONF_ENABLE_W0); | ||
| 198 | + spi_conf(test_data, CONF_ENABLE_W0); | ||
| 199 | |||
| 200 | - spi_ctrl_start_user(); | ||
| 201 | - writeb(ASPEED_FLASH_BASE, JEDEC_READ); | ||
| 202 | - jedec |= readb(ASPEED_FLASH_BASE) << 16; | ||
| 203 | - jedec |= readb(ASPEED_FLASH_BASE) << 8; | ||
| 204 | - jedec |= readb(ASPEED_FLASH_BASE); | ||
| 205 | - spi_ctrl_stop_user(); | ||
| 206 | + spi_ctrl_start_user(test_data); | ||
| 207 | + flash_writeb(test_data, 0, JEDEC_READ); | ||
| 208 | + jedec |= flash_readb(test_data, 0) << 16; | ||
| 209 | + jedec |= flash_readb(test_data, 0) << 8; | ||
| 210 | + jedec |= flash_readb(test_data, 0); | ||
| 211 | + spi_ctrl_stop_user(test_data); | ||
| 212 | |||
| 213 | - flash_reset(); | ||
| 214 | + flash_reset(test_data); | ||
| 215 | |||
| 216 | - g_assert_cmphex(jedec, ==, FLASH_JEDEC); | ||
| 217 | + g_assert_cmphex(jedec, ==, test_data->jedec_id); | ||
| 218 | } | ||
| 219 | |||
| 220 | -static void read_page(uint32_t addr, uint32_t *page) | ||
| 221 | +static void read_page(const TestData *data, uint32_t addr, uint32_t *page) | ||
| 222 | { | ||
| 223 | int i; | ||
| 224 | |||
| 225 | - spi_ctrl_start_user(); | ||
| 226 | + spi_ctrl_start_user(data); | ||
| 227 | |||
| 228 | - writeb(ASPEED_FLASH_BASE, EN_4BYTE_ADDR); | ||
| 229 | - writeb(ASPEED_FLASH_BASE, READ); | ||
| 230 | - writel(ASPEED_FLASH_BASE, make_be32(addr)); | ||
| 231 | + flash_writeb(data, 0, EN_4BYTE_ADDR); | ||
| 232 | + flash_writeb(data, 0, READ); | ||
| 233 | + flash_writel(data, 0, make_be32(addr)); | ||
| 234 | |||
| 235 | /* Continuous read are supported */ | ||
| 236 | for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 237 | - page[i] = make_be32(readl(ASPEED_FLASH_BASE)); | ||
| 238 | + page[i] = make_be32(flash_readl(data, 0)); | ||
| 239 | } | ||
| 240 | - spi_ctrl_stop_user(); | ||
| 241 | + spi_ctrl_stop_user(data); | ||
| 242 | } | ||
| 243 | |||
| 244 | -static void read_page_mem(uint32_t addr, uint32_t *page) | ||
| 245 | +static void read_page_mem(const TestData *data, uint32_t addr, uint32_t *page) | ||
| 246 | { | ||
| 247 | int i; | ||
| 248 | |||
| 249 | /* move out USER mode to use direct reads from the AHB bus */ | ||
| 250 | - spi_ctrl_setmode(CTRL_READMODE, READ); | ||
| 251 | + spi_ctrl_setmode(data, CTRL_READMODE, READ); | ||
| 252 | |||
| 253 | for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 254 | - page[i] = make_be32(readl(ASPEED_FLASH_BASE + addr + i * 4)); | ||
| 255 | + page[i] = make_be32(flash_readl(data, addr + i * 4)); | ||
| 256 | } | ||
| 257 | } | ||
| 258 | |||
| 259 | -static void write_page_mem(uint32_t addr, uint32_t write_value) | ||
| 260 | +static void write_page_mem(const TestData *data, uint32_t addr, | ||
| 261 | + uint32_t write_value) | ||
| 262 | { | ||
| 263 | - spi_ctrl_setmode(CTRL_WRITEMODE, PP); | ||
| 264 | + spi_ctrl_setmode(data, CTRL_WRITEMODE, PP); | ||
| 265 | |||
| 266 | for (int i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 267 | - writel(ASPEED_FLASH_BASE + addr + i * 4, write_value); | ||
| 268 | + flash_writel(data, addr + i * 4, write_value); | ||
| 269 | } | ||
| 270 | } | ||
| 271 | |||
| 272 | -static void assert_page_mem(uint32_t addr, uint32_t expected_value) | ||
| 273 | +static void assert_page_mem(const TestData *data, uint32_t addr, | ||
| 274 | + uint32_t expected_value) | ||
| 275 | { | ||
| 276 | uint32_t page[FLASH_PAGE_SIZE / 4]; | ||
| 277 | - read_page_mem(addr, page); | ||
| 278 | + read_page_mem(data, addr, page); | ||
| 279 | for (int i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 280 | g_assert_cmphex(page[i], ==, expected_value); | ||
| 281 | } | ||
| 282 | } | ||
| 283 | |||
| 284 | -static void test_erase_sector(void) | ||
| 285 | +static void test_erase_sector(const void *data) | ||
| 286 | { | ||
| 287 | + const TestData *test_data = (const TestData *)data; | ||
| 288 | uint32_t some_page_addr = 0x600 * FLASH_PAGE_SIZE; | ||
| 289 | uint32_t page[FLASH_PAGE_SIZE / 4]; | ||
| 290 | int i; | ||
| 291 | |||
| 292 | - spi_conf(CONF_ENABLE_W0); | ||
| 293 | + spi_conf(test_data, CONF_ENABLE_W0); | ||
| 294 | |||
| 295 | /* | ||
| 296 | * Previous page should be full of 0xffs after backend is | ||
| 297 | * initialized | ||
| 298 | */ | ||
| 299 | - read_page(some_page_addr - FLASH_PAGE_SIZE, page); | ||
| 300 | + read_page(test_data, some_page_addr - FLASH_PAGE_SIZE, page); | ||
| 301 | for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 302 | g_assert_cmphex(page[i], ==, 0xffffffff); | ||
| 303 | } | ||
| 304 | |||
| 305 | - spi_ctrl_start_user(); | ||
| 306 | - writeb(ASPEED_FLASH_BASE, EN_4BYTE_ADDR); | ||
| 307 | - writeb(ASPEED_FLASH_BASE, WREN); | ||
| 308 | - writeb(ASPEED_FLASH_BASE, PP); | ||
| 309 | - writel(ASPEED_FLASH_BASE, make_be32(some_page_addr)); | ||
| 310 | + spi_ctrl_start_user(test_data); | ||
| 311 | + flash_writeb(test_data, 0, EN_4BYTE_ADDR); | ||
| 312 | + flash_writeb(test_data, 0, WREN); | ||
| 313 | + flash_writeb(test_data, 0, PP); | ||
| 314 | + flash_writel(test_data, 0, make_be32(some_page_addr)); | ||
| 315 | |||
| 316 | /* Fill the page with its own addresses */ | ||
| 317 | for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 318 | - writel(ASPEED_FLASH_BASE, make_be32(some_page_addr + i * 4)); | ||
| 319 | + flash_writel(test_data, 0, make_be32(some_page_addr + i * 4)); | ||
| 320 | } | ||
| 321 | - spi_ctrl_stop_user(); | ||
| 322 | + spi_ctrl_stop_user(test_data); | ||
| 323 | |||
| 324 | /* Check the page is correctly written */ | ||
| 325 | - read_page(some_page_addr, page); | ||
| 326 | + read_page(test_data, some_page_addr, page); | ||
| 327 | for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 328 | g_assert_cmphex(page[i], ==, some_page_addr + i * 4); | ||
| 329 | } | ||
| 330 | |||
| 331 | - spi_ctrl_start_user(); | ||
| 332 | - writeb(ASPEED_FLASH_BASE, WREN); | ||
| 333 | - writeb(ASPEED_FLASH_BASE, EN_4BYTE_ADDR); | ||
| 334 | - writeb(ASPEED_FLASH_BASE, ERASE_SECTOR); | ||
| 335 | - writel(ASPEED_FLASH_BASE, make_be32(some_page_addr)); | ||
| 336 | - spi_ctrl_stop_user(); | ||
| 337 | + spi_ctrl_start_user(test_data); | ||
| 338 | + flash_writeb(test_data, 0, WREN); | ||
| 339 | + flash_writeb(test_data, 0, EN_4BYTE_ADDR); | ||
| 340 | + flash_writeb(test_data, 0, ERASE_SECTOR); | ||
| 341 | + flash_writel(test_data, 0, make_be32(some_page_addr)); | ||
| 342 | + spi_ctrl_stop_user(test_data); | ||
| 343 | |||
| 344 | /* Check the page is erased */ | ||
| 345 | - read_page(some_page_addr, page); | ||
| 346 | + read_page(test_data, some_page_addr, page); | ||
| 347 | for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 348 | g_assert_cmphex(page[i], ==, 0xffffffff); | ||
| 349 | } | ||
| 350 | |||
| 351 | - flash_reset(); | ||
| 352 | + flash_reset(test_data); | ||
| 353 | } | ||
| 354 | |||
| 355 | -static void test_erase_all(void) | ||
| 356 | +static void test_erase_all(const void *data) | ||
| 357 | { | ||
| 358 | + const TestData *test_data = (const TestData *)data; | ||
| 359 | uint32_t some_page_addr = 0x15000 * FLASH_PAGE_SIZE; | ||
| 360 | uint32_t page[FLASH_PAGE_SIZE / 4]; | ||
| 361 | int i; | ||
| 362 | |||
| 363 | - spi_conf(CONF_ENABLE_W0); | ||
| 364 | + spi_conf(test_data, CONF_ENABLE_W0); | ||
| 365 | |||
| 366 | /* | ||
| 367 | * Previous page should be full of 0xffs after backend is | ||
| 368 | * initialized | ||
| 369 | */ | ||
| 370 | - read_page(some_page_addr - FLASH_PAGE_SIZE, page); | ||
| 371 | + read_page(test_data, some_page_addr - FLASH_PAGE_SIZE, page); | ||
| 372 | for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 373 | g_assert_cmphex(page[i], ==, 0xffffffff); | ||
| 374 | } | ||
| 375 | |||
| 376 | - spi_ctrl_start_user(); | ||
| 377 | - writeb(ASPEED_FLASH_BASE, EN_4BYTE_ADDR); | ||
| 378 | - writeb(ASPEED_FLASH_BASE, WREN); | ||
| 379 | - writeb(ASPEED_FLASH_BASE, PP); | ||
| 380 | - writel(ASPEED_FLASH_BASE, make_be32(some_page_addr)); | ||
| 381 | + spi_ctrl_start_user(test_data); | ||
| 382 | + flash_writeb(test_data, 0, EN_4BYTE_ADDR); | ||
| 383 | + flash_writeb(test_data, 0, WREN); | ||
| 384 | + flash_writeb(test_data, 0, PP); | ||
| 385 | + flash_writel(test_data, 0, make_be32(some_page_addr)); | ||
| 386 | |||
| 387 | /* Fill the page with its own addresses */ | ||
| 388 | for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 389 | - writel(ASPEED_FLASH_BASE, make_be32(some_page_addr + i * 4)); | ||
| 390 | + flash_writel(test_data, 0, make_be32(some_page_addr + i * 4)); | ||
| 391 | } | ||
| 392 | - spi_ctrl_stop_user(); | ||
| 393 | + spi_ctrl_stop_user(test_data); | ||
| 394 | |||
| 395 | /* Check the page is correctly written */ | ||
| 396 | - read_page(some_page_addr, page); | ||
| 397 | + read_page(test_data, some_page_addr, page); | ||
| 398 | for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 399 | g_assert_cmphex(page[i], ==, some_page_addr + i * 4); | ||
| 400 | } | ||
| 401 | |||
| 402 | - spi_ctrl_start_user(); | ||
| 403 | - writeb(ASPEED_FLASH_BASE, WREN); | ||
| 404 | - writeb(ASPEED_FLASH_BASE, BULK_ERASE); | ||
| 405 | - spi_ctrl_stop_user(); | ||
| 406 | + spi_ctrl_start_user(test_data); | ||
| 407 | + flash_writeb(test_data, 0, WREN); | ||
| 408 | + flash_writeb(test_data, 0, BULK_ERASE); | ||
| 409 | + spi_ctrl_stop_user(test_data); | ||
| 410 | |||
| 411 | /* Check the page is erased */ | ||
| 412 | - read_page(some_page_addr, page); | ||
| 413 | + read_page(test_data, some_page_addr, page); | ||
| 414 | for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 415 | g_assert_cmphex(page[i], ==, 0xffffffff); | ||
| 416 | } | ||
| 417 | |||
| 418 | - flash_reset(); | ||
| 419 | + flash_reset(test_data); | ||
| 420 | } | ||
| 421 | |||
| 422 | -static void test_write_page(void) | ||
| 423 | +static void test_write_page(const void *data) | ||
| 424 | { | ||
| 425 | + const TestData *test_data = (const TestData *)data; | ||
| 426 | uint32_t my_page_addr = 0x14000 * FLASH_PAGE_SIZE; /* beyond 16MB */ | ||
| 427 | uint32_t some_page_addr = 0x15000 * FLASH_PAGE_SIZE; | ||
| 428 | uint32_t page[FLASH_PAGE_SIZE / 4]; | ||
| 429 | int i; | ||
| 430 | |||
| 431 | - spi_conf(CONF_ENABLE_W0); | ||
| 432 | + spi_conf(test_data, CONF_ENABLE_W0); | ||
| 433 | |||
| 434 | - spi_ctrl_start_user(); | ||
| 435 | - writeb(ASPEED_FLASH_BASE, EN_4BYTE_ADDR); | ||
| 436 | - writeb(ASPEED_FLASH_BASE, WREN); | ||
| 437 | - writeb(ASPEED_FLASH_BASE, PP); | ||
| 438 | - writel(ASPEED_FLASH_BASE, make_be32(my_page_addr)); | ||
| 439 | + spi_ctrl_start_user(test_data); | ||
| 440 | + flash_writeb(test_data, 0, EN_4BYTE_ADDR); | ||
| 441 | + flash_writeb(test_data, 0, WREN); | ||
| 442 | + flash_writeb(test_data, 0, PP); | ||
| 443 | + flash_writel(test_data, 0, make_be32(my_page_addr)); | ||
| 444 | |||
| 445 | /* Fill the page with its own addresses */ | ||
| 446 | for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 447 | - writel(ASPEED_FLASH_BASE, make_be32(my_page_addr + i * 4)); | ||
| 448 | + flash_writel(test_data, 0, make_be32(my_page_addr + i * 4)); | ||
| 449 | } | ||
| 450 | - spi_ctrl_stop_user(); | ||
| 451 | + spi_ctrl_stop_user(test_data); | ||
| 452 | |||
| 453 | /* Check what was written */ | ||
| 454 | - read_page(my_page_addr, page); | ||
| 455 | + read_page(test_data, my_page_addr, page); | ||
| 456 | for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 457 | g_assert_cmphex(page[i], ==, my_page_addr + i * 4); | ||
| 458 | } | ||
| 459 | |||
| 460 | /* Check some other page. It should be full of 0xff */ | ||
| 461 | - read_page(some_page_addr, page); | ||
| 462 | + read_page(test_data, some_page_addr, page); | ||
| 463 | for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 464 | g_assert_cmphex(page[i], ==, 0xffffffff); | ||
| 465 | } | ||
| 466 | |||
| 467 | - flash_reset(); | ||
| 468 | + flash_reset(test_data); | ||
| 469 | } | ||
| 470 | |||
| 471 | -static void test_read_page_mem(void) | ||
| 472 | +static void test_read_page_mem(const void *data) | ||
| 473 | { | ||
| 474 | + const TestData *test_data = (const TestData *)data; | ||
| 475 | uint32_t my_page_addr = 0x14000 * FLASH_PAGE_SIZE; /* beyond 16MB */ | ||
| 476 | uint32_t some_page_addr = 0x15000 * FLASH_PAGE_SIZE; | ||
| 477 | uint32_t page[FLASH_PAGE_SIZE / 4]; | ||
| 478 | @@ -XXX,XX +XXX,XX @@ static void test_read_page_mem(void) | ||
| 479 | * Enable 4BYTE mode for controller. This is should be strapped by | ||
| 480 | * HW for CE0 anyhow. | ||
| 481 | */ | ||
| 482 | - spi_ce_ctrl(1 << CRTL_EXTENDED0); | ||
| 483 | + spi_ce_ctrl(test_data, 1 << CRTL_EXTENDED0); | ||
| 484 | |||
| 485 | /* Enable 4BYTE mode for flash. */ | ||
| 486 | - spi_conf(CONF_ENABLE_W0); | ||
| 487 | - spi_ctrl_start_user(); | ||
| 488 | - writeb(ASPEED_FLASH_BASE, EN_4BYTE_ADDR); | ||
| 489 | - writeb(ASPEED_FLASH_BASE, WREN); | ||
| 490 | - writeb(ASPEED_FLASH_BASE, PP); | ||
| 491 | - writel(ASPEED_FLASH_BASE, make_be32(my_page_addr)); | ||
| 492 | + spi_conf(test_data, CONF_ENABLE_W0); | ||
| 493 | + spi_ctrl_start_user(test_data); | ||
| 494 | + flash_writeb(test_data, 0, EN_4BYTE_ADDR); | ||
| 495 | + flash_writeb(test_data, 0, WREN); | ||
| 496 | + flash_writeb(test_data, 0, PP); | ||
| 497 | + flash_writel(test_data, 0, make_be32(my_page_addr)); | ||
| 498 | |||
| 499 | /* Fill the page with its own addresses */ | ||
| 500 | for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 501 | - writel(ASPEED_FLASH_BASE, make_be32(my_page_addr + i * 4)); | ||
| 502 | + flash_writel(test_data, 0, make_be32(my_page_addr + i * 4)); | ||
| 503 | } | ||
| 504 | - spi_ctrl_stop_user(); | ||
| 505 | - spi_conf_remove(CONF_ENABLE_W0); | ||
| 506 | + spi_ctrl_stop_user(test_data); | ||
| 507 | + spi_conf_remove(test_data, CONF_ENABLE_W0); | ||
| 508 | |||
| 509 | /* Check what was written */ | ||
| 510 | - read_page_mem(my_page_addr, page); | ||
| 511 | + read_page_mem(test_data, my_page_addr, page); | ||
| 512 | for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 513 | g_assert_cmphex(page[i], ==, my_page_addr + i * 4); | ||
| 514 | } | ||
| 515 | |||
| 516 | /* Check some other page. It should be full of 0xff */ | ||
| 517 | - read_page_mem(some_page_addr, page); | ||
| 518 | + read_page_mem(test_data, some_page_addr, page); | ||
| 519 | for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 520 | g_assert_cmphex(page[i], ==, 0xffffffff); | ||
| 521 | } | ||
| 522 | |||
| 523 | - flash_reset(); | ||
| 524 | + flash_reset(test_data); | ||
| 525 | } | ||
| 526 | |||
| 527 | -static void test_write_page_mem(void) | ||
| 528 | +static void test_write_page_mem(const void *data) | ||
| 529 | { | ||
| 530 | + const TestData *test_data = (const TestData *)data; | ||
| 531 | uint32_t my_page_addr = 0x15000 * FLASH_PAGE_SIZE; | ||
| 532 | uint32_t page[FLASH_PAGE_SIZE / 4]; | ||
| 533 | int i; | ||
| 534 | @@ -XXX,XX +XXX,XX @@ static void test_write_page_mem(void) | ||
| 535 | * Enable 4BYTE mode for controller. This is should be strapped by | ||
| 536 | * HW for CE0 anyhow. | ||
| 537 | */ | ||
| 538 | - spi_ce_ctrl(1 << CRTL_EXTENDED0); | ||
| 539 | + spi_ce_ctrl(test_data, 1 << CRTL_EXTENDED0); | ||
| 540 | |||
| 541 | /* Enable 4BYTE mode for flash. */ | ||
| 542 | - spi_conf(CONF_ENABLE_W0); | ||
| 543 | - spi_ctrl_start_user(); | ||
| 544 | - writeb(ASPEED_FLASH_BASE, EN_4BYTE_ADDR); | ||
| 545 | - writeb(ASPEED_FLASH_BASE, WREN); | ||
| 546 | - spi_ctrl_stop_user(); | ||
| 547 | + spi_conf(test_data, CONF_ENABLE_W0); | ||
| 548 | + spi_ctrl_start_user(test_data); | ||
| 549 | + flash_writeb(test_data, 0, EN_4BYTE_ADDR); | ||
| 550 | + flash_writeb(test_data, 0, WREN); | ||
| 551 | + spi_ctrl_stop_user(test_data); | ||
| 552 | |||
| 553 | /* move out USER mode to use direct writes to the AHB bus */ | ||
| 554 | - spi_ctrl_setmode(CTRL_WRITEMODE, PP); | ||
| 555 | + spi_ctrl_setmode(test_data, CTRL_WRITEMODE, PP); | ||
| 556 | |||
| 557 | for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 558 | - writel(ASPEED_FLASH_BASE + my_page_addr + i * 4, | ||
| 559 | + flash_writel(test_data, my_page_addr + i * 4, | ||
| 560 | make_be32(my_page_addr + i * 4)); | ||
| 561 | } | ||
| 562 | |||
| 563 | /* Check what was written */ | ||
| 564 | - read_page_mem(my_page_addr, page); | ||
| 565 | + read_page_mem(test_data, my_page_addr, page); | ||
| 566 | for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 567 | g_assert_cmphex(page[i], ==, my_page_addr + i * 4); | ||
| 568 | } | ||
| 569 | |||
| 570 | - flash_reset(); | ||
| 571 | + flash_reset(test_data); | ||
| 572 | } | ||
| 573 | |||
| 574 | -static void test_read_status_reg(void) | ||
| 575 | +static void test_read_status_reg(const void *data) | ||
| 576 | { | ||
| 577 | + const TestData *test_data = (const TestData *)data; | ||
| 578 | uint8_t r; | ||
| 579 | |||
| 580 | - spi_conf(CONF_ENABLE_W0); | ||
| 581 | + spi_conf(test_data, CONF_ENABLE_W0); | ||
| 582 | |||
| 583 | - spi_ctrl_start_user(); | ||
| 584 | - writeb(ASPEED_FLASH_BASE, RDSR); | ||
| 585 | - r = readb(ASPEED_FLASH_BASE); | ||
| 586 | - spi_ctrl_stop_user(); | ||
| 587 | + spi_ctrl_start_user(test_data); | ||
| 588 | + flash_writeb(test_data, 0, RDSR); | ||
| 589 | + r = flash_readb(test_data, 0); | ||
| 590 | + spi_ctrl_stop_user(test_data); | ||
| 591 | |||
| 592 | g_assert_cmphex(r & SR_WEL, ==, 0); | ||
| 593 | g_assert(!qtest_qom_get_bool | ||
| 594 | - (global_qtest, "/machine/soc/fmc/ssi.0/child[0]", "write-enable")); | ||
| 595 | + (test_data->s, "/machine/soc/fmc/ssi.0/child[0]", "write-enable")); | ||
| 596 | |||
| 597 | - spi_ctrl_start_user(); | ||
| 598 | - writeb(ASPEED_FLASH_BASE, WREN); | ||
| 599 | - writeb(ASPEED_FLASH_BASE, RDSR); | ||
| 600 | - r = readb(ASPEED_FLASH_BASE); | ||
| 601 | - spi_ctrl_stop_user(); | ||
| 602 | + spi_ctrl_start_user(test_data); | ||
| 603 | + flash_writeb(test_data, 0, WREN); | ||
| 604 | + flash_writeb(test_data, 0, RDSR); | ||
| 605 | + r = flash_readb(test_data, 0); | ||
| 606 | + spi_ctrl_stop_user(test_data); | ||
| 607 | |||
| 608 | g_assert_cmphex(r & SR_WEL, ==, SR_WEL); | ||
| 609 | g_assert(qtest_qom_get_bool | ||
| 610 | - (global_qtest, "/machine/soc/fmc/ssi.0/child[0]", "write-enable")); | ||
| 611 | + (test_data->s, "/machine/soc/fmc/ssi.0/child[0]", "write-enable")); | ||
| 612 | |||
| 613 | - spi_ctrl_start_user(); | ||
| 614 | - writeb(ASPEED_FLASH_BASE, WRDI); | ||
| 615 | - writeb(ASPEED_FLASH_BASE, RDSR); | ||
| 616 | - r = readb(ASPEED_FLASH_BASE); | ||
| 617 | - spi_ctrl_stop_user(); | ||
| 618 | + spi_ctrl_start_user(test_data); | ||
| 619 | + flash_writeb(test_data, 0, WRDI); | ||
| 620 | + flash_writeb(test_data, 0, RDSR); | ||
| 621 | + r = flash_readb(test_data, 0); | ||
| 622 | + spi_ctrl_stop_user(test_data); | ||
| 623 | |||
| 624 | g_assert_cmphex(r & SR_WEL, ==, 0); | ||
| 625 | g_assert(!qtest_qom_get_bool | ||
| 626 | - (global_qtest, "/machine/soc/fmc/ssi.0/child[0]", "write-enable")); | ||
| 627 | + (test_data->s, "/machine/soc/fmc/ssi.0/child[0]", "write-enable")); | ||
| 628 | |||
| 629 | - flash_reset(); | ||
| 630 | + flash_reset(test_data); | ||
| 631 | } | ||
| 632 | |||
| 633 | -static void test_status_reg_write_protection(void) | ||
| 634 | +static void test_status_reg_write_protection(const void *data) | ||
| 635 | { | ||
| 636 | + const TestData *test_data = (const TestData *)data; | ||
| 637 | uint8_t r; | ||
| 638 | |||
| 639 | - spi_conf(CONF_ENABLE_W0); | ||
| 640 | + spi_conf(test_data, CONF_ENABLE_W0); | ||
| 641 | |||
| 642 | /* default case: WP# is high and SRWD is low -> status register writable */ | ||
| 643 | - spi_ctrl_start_user(); | ||
| 644 | - writeb(ASPEED_FLASH_BASE, WREN); | ||
| 645 | + spi_ctrl_start_user(test_data); | ||
| 646 | + flash_writeb(test_data, 0, WREN); | ||
| 647 | /* test ability to write SRWD */ | ||
| 648 | - writeb(ASPEED_FLASH_BASE, WRSR); | ||
| 649 | - writeb(ASPEED_FLASH_BASE, SRWD); | ||
| 650 | - writeb(ASPEED_FLASH_BASE, RDSR); | ||
| 651 | - r = readb(ASPEED_FLASH_BASE); | ||
| 652 | - spi_ctrl_stop_user(); | ||
| 653 | + flash_writeb(test_data, 0, WRSR); | ||
| 654 | + flash_writeb(test_data, 0, SRWD); | ||
| 655 | + flash_writeb(test_data, 0, RDSR); | ||
| 656 | + r = flash_readb(test_data, 0); | ||
| 657 | + spi_ctrl_stop_user(test_data); | ||
| 658 | g_assert_cmphex(r & SRWD, ==, SRWD); | ||
| 659 | |||
| 660 | /* WP# high and SRWD high -> status register writable */ | ||
| 661 | - spi_ctrl_start_user(); | ||
| 662 | - writeb(ASPEED_FLASH_BASE, WREN); | ||
| 663 | + spi_ctrl_start_user(test_data); | ||
| 664 | + flash_writeb(test_data, 0, WREN); | ||
| 665 | /* test ability to write SRWD */ | ||
| 666 | - writeb(ASPEED_FLASH_BASE, WRSR); | ||
| 667 | - writeb(ASPEED_FLASH_BASE, 0); | ||
| 668 | - writeb(ASPEED_FLASH_BASE, RDSR); | ||
| 669 | - r = readb(ASPEED_FLASH_BASE); | ||
| 670 | - spi_ctrl_stop_user(); | ||
| 671 | + flash_writeb(test_data, 0, WRSR); | ||
| 672 | + flash_writeb(test_data, 0, 0); | ||
| 673 | + flash_writeb(test_data, 0, RDSR); | ||
| 674 | + r = flash_readb(test_data, 0); | ||
| 675 | + spi_ctrl_stop_user(test_data); | ||
| 676 | g_assert_cmphex(r & SRWD, ==, 0); | ||
| 677 | |||
| 678 | /* WP# low and SRWD low -> status register writable */ | ||
| 679 | - qtest_set_irq_in(global_qtest, | ||
| 680 | + qtest_set_irq_in(test_data->s, | ||
| 681 | "/machine/soc/fmc/ssi.0/child[0]", "WP#", 0, 0); | ||
| 682 | - spi_ctrl_start_user(); | ||
| 683 | - writeb(ASPEED_FLASH_BASE, WREN); | ||
| 684 | + spi_ctrl_start_user(test_data); | ||
| 685 | + flash_writeb(test_data, 0, WREN); | ||
| 686 | /* test ability to write SRWD */ | ||
| 687 | - writeb(ASPEED_FLASH_BASE, WRSR); | ||
| 688 | - writeb(ASPEED_FLASH_BASE, SRWD); | ||
| 689 | - writeb(ASPEED_FLASH_BASE, RDSR); | ||
| 690 | - r = readb(ASPEED_FLASH_BASE); | ||
| 691 | - spi_ctrl_stop_user(); | ||
| 692 | + flash_writeb(test_data, 0, WRSR); | ||
| 693 | + flash_writeb(test_data, 0, SRWD); | ||
| 694 | + flash_writeb(test_data, 0, RDSR); | ||
| 695 | + r = flash_readb(test_data, 0); | ||
| 696 | + spi_ctrl_stop_user(test_data); | ||
| 697 | g_assert_cmphex(r & SRWD, ==, SRWD); | ||
| 698 | |||
| 699 | /* WP# low and SRWD high -> status register NOT writable */ | ||
| 700 | - spi_ctrl_start_user(); | ||
| 701 | - writeb(ASPEED_FLASH_BASE, WREN); | ||
| 702 | + spi_ctrl_start_user(test_data); | ||
| 703 | + flash_writeb(test_data, 0 , WREN); | ||
| 704 | /* test ability to write SRWD */ | ||
| 705 | - writeb(ASPEED_FLASH_BASE, WRSR); | ||
| 706 | - writeb(ASPEED_FLASH_BASE, 0); | ||
| 707 | - writeb(ASPEED_FLASH_BASE, RDSR); | ||
| 708 | - r = readb(ASPEED_FLASH_BASE); | ||
| 709 | - spi_ctrl_stop_user(); | ||
| 710 | + flash_writeb(test_data, 0, WRSR); | ||
| 711 | + flash_writeb(test_data, 0, 0); | ||
| 712 | + flash_writeb(test_data, 0, RDSR); | ||
| 713 | + r = flash_readb(test_data, 0); | ||
| 714 | + spi_ctrl_stop_user(test_data); | ||
| 715 | /* write is not successful */ | ||
| 716 | g_assert_cmphex(r & SRWD, ==, SRWD); | ||
| 717 | |||
| 718 | - qtest_set_irq_in(global_qtest, | ||
| 719 | + qtest_set_irq_in(test_data->s, | ||
| 720 | "/machine/soc/fmc/ssi.0/child[0]", "WP#", 0, 1); | ||
| 721 | - flash_reset(); | ||
| 722 | + flash_reset(test_data); | ||
| 723 | } | ||
| 724 | |||
| 725 | -static void test_write_block_protect(void) | ||
| 726 | +static void test_write_block_protect(const void *data) | ||
| 727 | { | ||
| 728 | + const TestData *test_data = (const TestData *)data; | ||
| 729 | uint32_t sector_size = 65536; | ||
| 730 | uint32_t n_sectors = 512; | ||
| 731 | |||
| 732 | - spi_ce_ctrl(1 << CRTL_EXTENDED0); | ||
| 733 | - spi_conf(CONF_ENABLE_W0); | ||
| 734 | + spi_ce_ctrl(test_data, 1 << CRTL_EXTENDED0); | ||
| 735 | + spi_conf(test_data, CONF_ENABLE_W0); | ||
| 736 | |||
| 737 | uint32_t bp_bits = 0b0; | ||
| 738 | |||
| 739 | for (int i = 0; i < 16; i++) { | ||
| 740 | bp_bits = ((i & 0b1000) << 3) | ((i & 0b0111) << 2); | ||
| 741 | |||
| 742 | - spi_ctrl_start_user(); | ||
| 743 | - writeb(ASPEED_FLASH_BASE, WREN); | ||
| 744 | - writeb(ASPEED_FLASH_BASE, BULK_ERASE); | ||
| 745 | - writeb(ASPEED_FLASH_BASE, WREN); | ||
| 746 | - writeb(ASPEED_FLASH_BASE, WRSR); | ||
| 747 | - writeb(ASPEED_FLASH_BASE, bp_bits); | ||
| 748 | - writeb(ASPEED_FLASH_BASE, EN_4BYTE_ADDR); | ||
| 749 | - writeb(ASPEED_FLASH_BASE, WREN); | ||
| 750 | - spi_ctrl_stop_user(); | ||
| 751 | + spi_ctrl_start_user(test_data); | ||
| 752 | + flash_writeb(test_data, 0, WREN); | ||
| 753 | + flash_writeb(test_data, 0, BULK_ERASE); | ||
| 754 | + flash_writeb(test_data, 0, WREN); | ||
| 755 | + flash_writeb(test_data, 0, WRSR); | ||
| 756 | + flash_writeb(test_data, 0, bp_bits); | ||
| 757 | + flash_writeb(test_data, 0, EN_4BYTE_ADDR); | ||
| 758 | + flash_writeb(test_data, 0, WREN); | ||
| 759 | + spi_ctrl_stop_user(test_data); | ||
| 760 | |||
| 761 | uint32_t num_protected_sectors = i ? MIN(1 << (i - 1), n_sectors) : 0; | ||
| 762 | uint32_t protection_start = n_sectors - num_protected_sectors; | ||
| 763 | @@ -XXX,XX +XXX,XX @@ static void test_write_block_protect(void) | ||
| 764 | for (int sector = 0; sector < n_sectors; sector++) { | ||
| 765 | uint32_t addr = sector * sector_size; | ||
| 766 | |||
| 767 | - assert_page_mem(addr, 0xffffffff); | ||
| 768 | - write_page_mem(addr, make_be32(0xabcdef12)); | ||
| 769 | + assert_page_mem(test_data, addr, 0xffffffff); | ||
| 770 | + write_page_mem(test_data, addr, make_be32(0xabcdef12)); | ||
| 771 | |||
| 772 | uint32_t expected_value = protection_start <= sector | ||
| 773 | && sector < protection_end | ||
| 774 | ? 0xffffffff : 0xabcdef12; | ||
| 775 | |||
| 776 | - assert_page_mem(addr, expected_value); | ||
| 777 | + assert_page_mem(test_data, addr, expected_value); | ||
| 778 | } | ||
| 779 | } | ||
| 780 | |||
| 781 | - flash_reset(); | ||
| 782 | + flash_reset(test_data); | ||
| 783 | } | ||
| 784 | |||
| 785 | -static void test_write_block_protect_bottom_bit(void) | ||
| 786 | +static void test_write_block_protect_bottom_bit(const void *data) | ||
| 787 | { | ||
| 788 | + const TestData *test_data = (const TestData *)data; | ||
| 789 | uint32_t sector_size = 65536; | ||
| 790 | uint32_t n_sectors = 512; | ||
| 791 | |||
| 792 | - spi_ce_ctrl(1 << CRTL_EXTENDED0); | ||
| 793 | - spi_conf(CONF_ENABLE_W0); | ||
| 794 | + spi_ce_ctrl(test_data, 1 << CRTL_EXTENDED0); | ||
| 795 | + spi_conf(test_data, CONF_ENABLE_W0); | ||
| 796 | |||
| 797 | /* top bottom bit is enabled */ | ||
| 798 | uint32_t bp_bits = 0b00100 << 3; | ||
| 799 | @@ -XXX,XX +XXX,XX @@ static void test_write_block_protect_bottom_bit(void) | ||
| 800 | for (int i = 0; i < 16; i++) { | ||
| 801 | bp_bits = (((i & 0b1000) | 0b0100) << 3) | ((i & 0b0111) << 2); | ||
| 802 | |||
| 803 | - spi_ctrl_start_user(); | ||
| 804 | - writeb(ASPEED_FLASH_BASE, WREN); | ||
| 805 | - writeb(ASPEED_FLASH_BASE, BULK_ERASE); | ||
| 806 | - writeb(ASPEED_FLASH_BASE, WREN); | ||
| 807 | - writeb(ASPEED_FLASH_BASE, WRSR); | ||
| 808 | - writeb(ASPEED_FLASH_BASE, bp_bits); | ||
| 809 | - writeb(ASPEED_FLASH_BASE, EN_4BYTE_ADDR); | ||
| 810 | - writeb(ASPEED_FLASH_BASE, WREN); | ||
| 811 | - spi_ctrl_stop_user(); | ||
| 812 | + spi_ctrl_start_user(test_data); | ||
| 813 | + flash_writeb(test_data, 0, WREN); | ||
| 814 | + flash_writeb(test_data, 0, BULK_ERASE); | ||
| 815 | + flash_writeb(test_data, 0, WREN); | ||
| 816 | + flash_writeb(test_data, 0, WRSR); | ||
| 817 | + flash_writeb(test_data, 0, bp_bits); | ||
| 818 | + flash_writeb(test_data, 0, EN_4BYTE_ADDR); | ||
| 819 | + flash_writeb(test_data, 0, WREN); | ||
| 820 | + spi_ctrl_stop_user(test_data); | ||
| 821 | |||
| 822 | uint32_t num_protected_sectors = i ? MIN(1 << (i - 1), n_sectors) : 0; | ||
| 823 | uint32_t protection_start = 0; | ||
| 824 | @@ -XXX,XX +XXX,XX @@ static void test_write_block_protect_bottom_bit(void) | ||
| 825 | for (int sector = 0; sector < n_sectors; sector++) { | ||
| 826 | uint32_t addr = sector * sector_size; | ||
| 827 | |||
| 828 | - assert_page_mem(addr, 0xffffffff); | ||
| 829 | - write_page_mem(addr, make_be32(0xabcdef12)); | ||
| 830 | + assert_page_mem(test_data, addr, 0xffffffff); | ||
| 831 | + write_page_mem(test_data, addr, make_be32(0xabcdef12)); | ||
| 832 | |||
| 833 | uint32_t expected_value = protection_start <= sector | ||
| 834 | && sector < protection_end | ||
| 835 | ? 0xffffffff : 0xabcdef12; | ||
| 836 | |||
| 837 | - assert_page_mem(addr, expected_value); | ||
| 838 | + assert_page_mem(test_data, addr, expected_value); | ||
| 839 | } | ||
| 840 | } | ||
| 841 | |||
| 842 | - flash_reset(); | ||
| 843 | + flash_reset(test_data); | ||
| 844 | } | ||
| 845 | |||
| 846 | -static int test_palmetto_bmc(void) | ||
| 847 | +static void test_palmetto_bmc(TestData *data) | ||
| 848 | { | ||
| 849 | - g_autofree char *tmp_path = NULL; | ||
| 850 | int ret; | ||
| 851 | int fd; | ||
| 852 | |||
| 853 | - fd = g_file_open_tmp("qtest.m25p80.XXXXXX", &tmp_path, NULL); | ||
| 854 | + fd = g_file_open_tmp("qtest.m25p80.n25q256a.XXXXXX", &data->tmp_path, NULL); | ||
| 855 | g_assert(fd >= 0); | ||
| 856 | - ret = ftruncate(fd, FLASH_SIZE); | ||
| 857 | + ret = ftruncate(fd, 32 * 1024 * 1024); | ||
| 858 | g_assert(ret == 0); | ||
| 859 | close(fd); | ||
| 860 | |||
| 861 | - global_qtest = qtest_initf("-m 256 -machine palmetto-bmc " | ||
| 862 | - "-drive file=%s,format=raw,if=mtd", | ||
| 863 | - tmp_path); | ||
| 864 | - | ||
| 865 | - qtest_add_func("/ast2400/smc/read_jedec", test_read_jedec); | ||
| 866 | - qtest_add_func("/ast2400/smc/erase_sector", test_erase_sector); | ||
| 867 | - qtest_add_func("/ast2400/smc/erase_all", test_erase_all); | ||
| 868 | - qtest_add_func("/ast2400/smc/write_page", test_write_page); | ||
| 869 | - qtest_add_func("/ast2400/smc/read_page_mem", test_read_page_mem); | ||
| 870 | - qtest_add_func("/ast2400/smc/write_page_mem", test_write_page_mem); | ||
| 871 | - qtest_add_func("/ast2400/smc/read_status_reg", test_read_status_reg); | ||
| 872 | - qtest_add_func("/ast2400/smc/status_reg_write_protection", | ||
| 873 | - test_status_reg_write_protection); | ||
| 874 | - qtest_add_func("/ast2400/smc/write_block_protect", | ||
| 875 | - test_write_block_protect); | ||
| 876 | - qtest_add_func("/ast2400/smc/write_block_protect_bottom_bit", | ||
| 877 | - test_write_block_protect_bottom_bit); | ||
| 878 | - | ||
| 879 | - flash_reset(); | ||
| 880 | - ret = g_test_run(); | ||
| 881 | - qtest_quit(global_qtest); | ||
| 882 | - unlink(tmp_path); | ||
| 883 | - | ||
| 884 | - return ret; | ||
| 885 | + data->s = qtest_initf("-m 256 -machine palmetto-bmc " | ||
| 886 | + "-drive file=%s,format=raw,if=mtd", | ||
| 887 | + data->tmp_path); | ||
| 888 | + | ||
| 889 | + /* fmc cs0 with n25q256a flash */ | ||
| 890 | + data->flash_base = 0x20000000; | ||
| 891 | + data->spi_base = 0x1E620000; | ||
| 892 | + data->jedec_id = 0x20ba19; | ||
| 893 | + | ||
| 894 | + qtest_add_data_func("/ast2400/smc/read_jedec", data, test_read_jedec); | ||
| 895 | + qtest_add_data_func("/ast2400/smc/erase_sector", data, test_erase_sector); | ||
| 896 | + qtest_add_data_func("/ast2400/smc/erase_all", data, test_erase_all); | ||
| 897 | + qtest_add_data_func("/ast2400/smc/write_page", data, test_write_page); | ||
| 898 | + qtest_add_data_func("/ast2400/smc/read_page_mem", | ||
| 899 | + data, test_read_page_mem); | ||
| 900 | + qtest_add_data_func("/ast2400/smc/write_page_mem", | ||
| 901 | + data, test_write_page_mem); | ||
| 902 | + qtest_add_data_func("/ast2400/smc/read_status_reg", | ||
| 903 | + data, test_read_status_reg); | ||
| 904 | + qtest_add_data_func("/ast2400/smc/status_reg_write_protection", | ||
| 905 | + data, test_status_reg_write_protection); | ||
| 906 | + qtest_add_data_func("/ast2400/smc/write_block_protect", | ||
| 907 | + data, test_write_block_protect); | ||
| 908 | + qtest_add_data_func("/ast2400/smc/write_block_protect_bottom_bit", | ||
| 909 | + data, test_write_block_protect_bottom_bit); | ||
| 910 | } | ||
| 911 | |||
| 912 | int main(int argc, char **argv) | ||
| 913 | { | ||
| 914 | + TestData palmetto_data; | ||
| 915 | int ret; | ||
| 916 | |||
| 917 | g_test_init(&argc, &argv, NULL); | ||
| 918 | - ret = test_palmetto_bmc(); | ||
| 919 | |||
| 920 | + test_palmetto_bmc(&palmetto_data); | ||
| 921 | + ret = g_test_run(); | ||
| 922 | + | ||
| 923 | + qtest_quit(palmetto_data.s); | ||
| 924 | + unlink(palmetto_data.tmp_path); | ||
| 925 | return ret; | ||
| 926 | } | ||
| 927 | -- | ||
| 928 | 2.47.1 | ||
| 929 | |||
| 930 | diff view generated by jsdifflib |
New patch | |||
|---|---|---|---|
| 1 | 1 | From: Jamin Lin <jamin_lin@aspeedtech.com> | |
| 2 | |||
| 3 | Currently, these test cases only support to test CE0. To test all CE pins, | ||
| 4 | introduces new ce and node members in TestData structure. The ce member is used | ||
| 5 | for saving the ce index and node member is used for saving the node path, | ||
| 6 | respectively. | ||
| 7 | |||
| 8 | Signed-off-by: Jamin Lin <jamin_lin@aspeedtech.com> | ||
| 9 | Reviewed-by: Cédric Le Goater <clg@redhat.com> | ||
| 10 | Link: https://lore.kernel.org/r/20241127091543.1243114-4-jamin_lin@aspeedtech.com | ||
| 11 | Signed-off-by: Cédric Le Goater <clg@redhat.com> | ||
| 12 | --- | ||
| 13 | tests/qtest/aspeed_smc-test.c | 77 ++++++++++++++++++----------------- | ||
| 14 | 1 file changed, 40 insertions(+), 37 deletions(-) | ||
| 15 | |||
| 16 | diff --git a/tests/qtest/aspeed_smc-test.c b/tests/qtest/aspeed_smc-test.c | ||
| 17 | index XXXXXXX..XXXXXXX 100644 | ||
| 18 | --- a/tests/qtest/aspeed_smc-test.c | ||
| 19 | +++ b/tests/qtest/aspeed_smc-test.c | ||
| 20 | @@ -XXX,XX +XXX,XX @@ | ||
| 21 | * ASPEED SPI Controller registers | ||
| 22 | */ | ||
| 23 | #define R_CONF 0x00 | ||
| 24 | -#define CONF_ENABLE_W0 (1 << 16) | ||
| 25 | +#define CONF_ENABLE_W0 16 | ||
| 26 | #define R_CE_CTRL 0x04 | ||
| 27 | #define CRTL_EXTENDED0 0 /* 32 bit addressing for SPI */ | ||
| 28 | #define R_CTRL0 0x10 | ||
| 29 | -#define CTRL_CE_STOP_ACTIVE (1 << 2) | ||
| 30 | +#define CTRL_CE_STOP_ACTIVE BIT(2) | ||
| 31 | #define CTRL_READMODE 0x0 | ||
| 32 | #define CTRL_FREADMODE 0x1 | ||
| 33 | #define CTRL_WRITEMODE 0x2 | ||
| 34 | @@ -XXX,XX +XXX,XX @@ typedef struct TestData { | ||
| 35 | uint64_t flash_base; | ||
| 36 | uint32_t jedec_id; | ||
| 37 | char *tmp_path; | ||
| 38 | + uint8_t cs; | ||
| 39 | + const char *node; | ||
| 40 | } TestData; | ||
| 41 | |||
| 42 | /* | ||
| 43 | @@ -XXX,XX +XXX,XX @@ static void spi_ce_ctrl(const TestData *data, uint32_t value) | ||
| 44 | |||
| 45 | static void spi_ctrl_setmode(const TestData *data, uint8_t mode, uint8_t cmd) | ||
| 46 | { | ||
| 47 | - uint32_t ctrl = spi_readl(data, R_CTRL0); | ||
| 48 | + uint32_t ctrl_reg = R_CTRL0 + data->cs * 4; | ||
| 49 | + uint32_t ctrl = spi_readl(data, ctrl_reg); | ||
| 50 | ctrl &= ~(CTRL_USERMODE | 0xff << 16); | ||
| 51 | ctrl |= mode | (cmd << 16); | ||
| 52 | - spi_writel(data, R_CTRL0, ctrl); | ||
| 53 | + spi_writel(data, ctrl_reg, ctrl); | ||
| 54 | } | ||
| 55 | |||
| 56 | static void spi_ctrl_start_user(const TestData *data) | ||
| 57 | { | ||
| 58 | - uint32_t ctrl = spi_readl(data, R_CTRL0); | ||
| 59 | + uint32_t ctrl_reg = R_CTRL0 + data->cs * 4; | ||
| 60 | + uint32_t ctrl = spi_readl(data, ctrl_reg); | ||
| 61 | |||
| 62 | ctrl |= CTRL_USERMODE | CTRL_CE_STOP_ACTIVE; | ||
| 63 | - spi_writel(data, R_CTRL0, ctrl); | ||
| 64 | + spi_writel(data, ctrl_reg, ctrl); | ||
| 65 | |||
| 66 | ctrl &= ~CTRL_CE_STOP_ACTIVE; | ||
| 67 | - spi_writel(data, R_CTRL0, ctrl); | ||
| 68 | + spi_writel(data, ctrl_reg, ctrl); | ||
| 69 | } | ||
| 70 | |||
| 71 | static void spi_ctrl_stop_user(const TestData *data) | ||
| 72 | { | ||
| 73 | - uint32_t ctrl = spi_readl(data, R_CTRL0); | ||
| 74 | + uint32_t ctrl_reg = R_CTRL0 + data->cs * 4; | ||
| 75 | + uint32_t ctrl = spi_readl(data, ctrl_reg); | ||
| 76 | |||
| 77 | ctrl |= CTRL_USERMODE | CTRL_CE_STOP_ACTIVE; | ||
| 78 | - spi_writel(data, R_CTRL0, ctrl); | ||
| 79 | + spi_writel(data, ctrl_reg, ctrl); | ||
| 80 | } | ||
| 81 | |||
| 82 | static void flash_reset(const TestData *data) | ||
| 83 | { | ||
| 84 | - spi_conf(data, CONF_ENABLE_W0); | ||
| 85 | + spi_conf(data, 1 << (CONF_ENABLE_W0 + data->cs)); | ||
| 86 | |||
| 87 | spi_ctrl_start_user(data); | ||
| 88 | flash_writeb(data, 0, RESET_ENABLE); | ||
| 89 | @@ -XXX,XX +XXX,XX @@ static void flash_reset(const TestData *data) | ||
| 90 | flash_writeb(data, 0, WRDI); | ||
| 91 | spi_ctrl_stop_user(data); | ||
| 92 | |||
| 93 | - spi_conf_remove(data, CONF_ENABLE_W0); | ||
| 94 | + spi_conf_remove(data, 1 << (CONF_ENABLE_W0 + data->cs)); | ||
| 95 | } | ||
| 96 | |||
| 97 | static void test_read_jedec(const void *data) | ||
| 98 | @@ -XXX,XX +XXX,XX @@ static void test_read_jedec(const void *data) | ||
| 99 | const TestData *test_data = (const TestData *)data; | ||
| 100 | uint32_t jedec = 0x0; | ||
| 101 | |||
| 102 | - spi_conf(test_data, CONF_ENABLE_W0); | ||
| 103 | + spi_conf(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 104 | |||
| 105 | spi_ctrl_start_user(test_data); | ||
| 106 | flash_writeb(test_data, 0, JEDEC_READ); | ||
| 107 | @@ -XXX,XX +XXX,XX @@ static void test_erase_sector(const void *data) | ||
| 108 | uint32_t page[FLASH_PAGE_SIZE / 4]; | ||
| 109 | int i; | ||
| 110 | |||
| 111 | - spi_conf(test_data, CONF_ENABLE_W0); | ||
| 112 | + spi_conf(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 113 | |||
| 114 | /* | ||
| 115 | * Previous page should be full of 0xffs after backend is | ||
| 116 | @@ -XXX,XX +XXX,XX @@ static void test_erase_all(const void *data) | ||
| 117 | uint32_t page[FLASH_PAGE_SIZE / 4]; | ||
| 118 | int i; | ||
| 119 | |||
| 120 | - spi_conf(test_data, CONF_ENABLE_W0); | ||
| 121 | + spi_conf(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 122 | |||
| 123 | /* | ||
| 124 | * Previous page should be full of 0xffs after backend is | ||
| 125 | @@ -XXX,XX +XXX,XX @@ static void test_write_page(const void *data) | ||
| 126 | uint32_t page[FLASH_PAGE_SIZE / 4]; | ||
| 127 | int i; | ||
| 128 | |||
| 129 | - spi_conf(test_data, CONF_ENABLE_W0); | ||
| 130 | + spi_conf(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 131 | |||
| 132 | spi_ctrl_start_user(test_data); | ||
| 133 | flash_writeb(test_data, 0, EN_4BYTE_ADDR); | ||
| 134 | @@ -XXX,XX +XXX,XX @@ static void test_read_page_mem(const void *data) | ||
| 135 | int i; | ||
| 136 | |||
| 137 | /* | ||
| 138 | - * Enable 4BYTE mode for controller. This is should be strapped by | ||
| 139 | - * HW for CE0 anyhow. | ||
| 140 | + * Enable 4BYTE mode for controller. | ||
| 141 | */ | ||
| 142 | - spi_ce_ctrl(test_data, 1 << CRTL_EXTENDED0); | ||
| 143 | + spi_ce_ctrl(test_data, 1 << (CRTL_EXTENDED0 + test_data->cs)); | ||
| 144 | |||
| 145 | /* Enable 4BYTE mode for flash. */ | ||
| 146 | - spi_conf(test_data, CONF_ENABLE_W0); | ||
| 147 | + spi_conf(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 148 | spi_ctrl_start_user(test_data); | ||
| 149 | flash_writeb(test_data, 0, EN_4BYTE_ADDR); | ||
| 150 | flash_writeb(test_data, 0, WREN); | ||
| 151 | @@ -XXX,XX +XXX,XX @@ static void test_read_page_mem(const void *data) | ||
| 152 | flash_writel(test_data, 0, make_be32(my_page_addr + i * 4)); | ||
| 153 | } | ||
| 154 | spi_ctrl_stop_user(test_data); | ||
| 155 | - spi_conf_remove(test_data, CONF_ENABLE_W0); | ||
| 156 | + spi_conf_remove(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 157 | |||
| 158 | /* Check what was written */ | ||
| 159 | read_page_mem(test_data, my_page_addr, page); | ||
| 160 | @@ -XXX,XX +XXX,XX @@ static void test_write_page_mem(const void *data) | ||
| 161 | int i; | ||
| 162 | |||
| 163 | /* | ||
| 164 | - * Enable 4BYTE mode for controller. This is should be strapped by | ||
| 165 | - * HW for CE0 anyhow. | ||
| 166 | + * Enable 4BYTE mode for controller. | ||
| 167 | */ | ||
| 168 | - spi_ce_ctrl(test_data, 1 << CRTL_EXTENDED0); | ||
| 169 | + spi_ce_ctrl(test_data, 1 << (CRTL_EXTENDED0 + test_data->cs)); | ||
| 170 | |||
| 171 | /* Enable 4BYTE mode for flash. */ | ||
| 172 | - spi_conf(test_data, CONF_ENABLE_W0); | ||
| 173 | + spi_conf(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 174 | spi_ctrl_start_user(test_data); | ||
| 175 | flash_writeb(test_data, 0, EN_4BYTE_ADDR); | ||
| 176 | flash_writeb(test_data, 0, WREN); | ||
| 177 | @@ -XXX,XX +XXX,XX @@ static void test_read_status_reg(const void *data) | ||
| 178 | const TestData *test_data = (const TestData *)data; | ||
| 179 | uint8_t r; | ||
| 180 | |||
| 181 | - spi_conf(test_data, CONF_ENABLE_W0); | ||
| 182 | + spi_conf(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 183 | |||
| 184 | spi_ctrl_start_user(test_data); | ||
| 185 | flash_writeb(test_data, 0, RDSR); | ||
| 186 | @@ -XXX,XX +XXX,XX @@ static void test_read_status_reg(const void *data) | ||
| 187 | |||
| 188 | g_assert_cmphex(r & SR_WEL, ==, 0); | ||
| 189 | g_assert(!qtest_qom_get_bool | ||
| 190 | - (test_data->s, "/machine/soc/fmc/ssi.0/child[0]", "write-enable")); | ||
| 191 | + (test_data->s, test_data->node, "write-enable")); | ||
| 192 | |||
| 193 | spi_ctrl_start_user(test_data); | ||
| 194 | flash_writeb(test_data, 0, WREN); | ||
| 195 | @@ -XXX,XX +XXX,XX @@ static void test_read_status_reg(const void *data) | ||
| 196 | |||
| 197 | g_assert_cmphex(r & SR_WEL, ==, SR_WEL); | ||
| 198 | g_assert(qtest_qom_get_bool | ||
| 199 | - (test_data->s, "/machine/soc/fmc/ssi.0/child[0]", "write-enable")); | ||
| 200 | + (test_data->s, test_data->node, "write-enable")); | ||
| 201 | |||
| 202 | spi_ctrl_start_user(test_data); | ||
| 203 | flash_writeb(test_data, 0, WRDI); | ||
| 204 | @@ -XXX,XX +XXX,XX @@ static void test_read_status_reg(const void *data) | ||
| 205 | |||
| 206 | g_assert_cmphex(r & SR_WEL, ==, 0); | ||
| 207 | g_assert(!qtest_qom_get_bool | ||
| 208 | - (test_data->s, "/machine/soc/fmc/ssi.0/child[0]", "write-enable")); | ||
| 209 | + (test_data->s, test_data->node, "write-enable")); | ||
| 210 | |||
| 211 | flash_reset(test_data); | ||
| 212 | } | ||
| 213 | @@ -XXX,XX +XXX,XX @@ static void test_status_reg_write_protection(const void *data) | ||
| 214 | const TestData *test_data = (const TestData *)data; | ||
| 215 | uint8_t r; | ||
| 216 | |||
| 217 | - spi_conf(test_data, CONF_ENABLE_W0); | ||
| 218 | + spi_conf(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 219 | |||
| 220 | /* default case: WP# is high and SRWD is low -> status register writable */ | ||
| 221 | spi_ctrl_start_user(test_data); | ||
| 222 | @@ -XXX,XX +XXX,XX @@ static void test_status_reg_write_protection(const void *data) | ||
| 223 | g_assert_cmphex(r & SRWD, ==, 0); | ||
| 224 | |||
| 225 | /* WP# low and SRWD low -> status register writable */ | ||
| 226 | - qtest_set_irq_in(test_data->s, | ||
| 227 | - "/machine/soc/fmc/ssi.0/child[0]", "WP#", 0, 0); | ||
| 228 | + qtest_set_irq_in(test_data->s, test_data->node, "WP#", 0, 0); | ||
| 229 | spi_ctrl_start_user(test_data); | ||
| 230 | flash_writeb(test_data, 0, WREN); | ||
| 231 | /* test ability to write SRWD */ | ||
| 232 | @@ -XXX,XX +XXX,XX @@ static void test_status_reg_write_protection(const void *data) | ||
| 233 | /* write is not successful */ | ||
| 234 | g_assert_cmphex(r & SRWD, ==, SRWD); | ||
| 235 | |||
| 236 | - qtest_set_irq_in(test_data->s, | ||
| 237 | - "/machine/soc/fmc/ssi.0/child[0]", "WP#", 0, 1); | ||
| 238 | + qtest_set_irq_in(test_data->s, test_data->node, "WP#", 0, 1); | ||
| 239 | flash_reset(test_data); | ||
| 240 | } | ||
| 241 | |||
| 242 | @@ -XXX,XX +XXX,XX @@ static void test_write_block_protect(const void *data) | ||
| 243 | uint32_t sector_size = 65536; | ||
| 244 | uint32_t n_sectors = 512; | ||
| 245 | |||
| 246 | - spi_ce_ctrl(test_data, 1 << CRTL_EXTENDED0); | ||
| 247 | - spi_conf(test_data, CONF_ENABLE_W0); | ||
| 248 | + spi_ce_ctrl(test_data, 1 << (CRTL_EXTENDED0 + test_data->cs)); | ||
| 249 | + spi_conf(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 250 | |||
| 251 | uint32_t bp_bits = 0b0; | ||
| 252 | |||
| 253 | @@ -XXX,XX +XXX,XX @@ static void test_write_block_protect_bottom_bit(const void *data) | ||
| 254 | uint32_t sector_size = 65536; | ||
| 255 | uint32_t n_sectors = 512; | ||
| 256 | |||
| 257 | - spi_ce_ctrl(test_data, 1 << CRTL_EXTENDED0); | ||
| 258 | - spi_conf(test_data, CONF_ENABLE_W0); | ||
| 259 | + spi_ce_ctrl(test_data, 1 << (CRTL_EXTENDED0 + test_data->cs)); | ||
| 260 | + spi_conf(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 261 | |||
| 262 | /* top bottom bit is enabled */ | ||
| 263 | uint32_t bp_bits = 0b00100 << 3; | ||
| 264 | @@ -XXX,XX +XXX,XX @@ static void test_palmetto_bmc(TestData *data) | ||
| 265 | data->flash_base = 0x20000000; | ||
| 266 | data->spi_base = 0x1E620000; | ||
| 267 | data->jedec_id = 0x20ba19; | ||
| 268 | + data->cs = 0; | ||
| 269 | + data->node = "/machine/soc/fmc/ssi.0/child[0]"; | ||
| 270 | |||
| 271 | qtest_add_data_func("/ast2400/smc/read_jedec", data, test_read_jedec); | ||
| 272 | qtest_add_data_func("/ast2400/smc/erase_sector", data, test_erase_sector); | ||
| 273 | -- | ||
| 274 | 2.47.1 | ||
| 275 | |||
| 276 | diff view generated by jsdifflib |
New patch | |||
|---|---|---|---|
| 1 | From: Jamin Lin <jamin_lin@aspeedtech.com> | ||
| 1 | 2 | ||
| 3 | Currently, these test cases used the hardcode offset 0x1400000 (0x14000 * 256) | ||
| 4 | which was beyond the 16MB flash size for flash page read/write command testing. | ||
| 5 | However, the default fmc flash model of ast1030-a1 EVB is "w25q80bl" whose size | ||
| 6 | is 1MB. To test SoC flash models, introduces a new page_addr member in TestData | ||
| 7 | structure, so users can set the offset for flash page read/write command | ||
| 8 | testing. | ||
| 9 | |||
| 10 | Signed-off-by: Jamin Lin <jamin_lin@aspeedtech.com> | ||
| 11 | Reviewed-by: Cédric Le Goater <clg@redhat.com> | ||
| 12 | Link: https://lore.kernel.org/r/20241127091543.1243114-5-jamin_lin@aspeedtech.com | ||
| 13 | Signed-off-by: Cédric Le Goater <clg@redhat.com> | ||
| 14 | --- | ||
| 15 | tests/qtest/aspeed_smc-test.c | 17 ++++++++++------- | ||
| 16 | 1 file changed, 10 insertions(+), 7 deletions(-) | ||
| 17 | |||
| 18 | diff --git a/tests/qtest/aspeed_smc-test.c b/tests/qtest/aspeed_smc-test.c | ||
| 19 | index XXXXXXX..XXXXXXX 100644 | ||
| 20 | --- a/tests/qtest/aspeed_smc-test.c | ||
| 21 | +++ b/tests/qtest/aspeed_smc-test.c | ||
| 22 | @@ -XXX,XX +XXX,XX @@ typedef struct TestData { | ||
| 23 | char *tmp_path; | ||
| 24 | uint8_t cs; | ||
| 25 | const char *node; | ||
| 26 | + uint32_t page_addr; | ||
| 27 | } TestData; | ||
| 28 | |||
| 29 | /* | ||
| 30 | @@ -XXX,XX +XXX,XX @@ static void assert_page_mem(const TestData *data, uint32_t addr, | ||
| 31 | static void test_erase_sector(const void *data) | ||
| 32 | { | ||
| 33 | const TestData *test_data = (const TestData *)data; | ||
| 34 | - uint32_t some_page_addr = 0x600 * FLASH_PAGE_SIZE; | ||
| 35 | + uint32_t some_page_addr = test_data->page_addr; | ||
| 36 | uint32_t page[FLASH_PAGE_SIZE / 4]; | ||
| 37 | int i; | ||
| 38 | |||
| 39 | @@ -XXX,XX +XXX,XX @@ static void test_erase_sector(const void *data) | ||
| 40 | static void test_erase_all(const void *data) | ||
| 41 | { | ||
| 42 | const TestData *test_data = (const TestData *)data; | ||
| 43 | - uint32_t some_page_addr = 0x15000 * FLASH_PAGE_SIZE; | ||
| 44 | + uint32_t some_page_addr = test_data->page_addr; | ||
| 45 | uint32_t page[FLASH_PAGE_SIZE / 4]; | ||
| 46 | int i; | ||
| 47 | |||
| 48 | @@ -XXX,XX +XXX,XX @@ static void test_erase_all(const void *data) | ||
| 49 | static void test_write_page(const void *data) | ||
| 50 | { | ||
| 51 | const TestData *test_data = (const TestData *)data; | ||
| 52 | - uint32_t my_page_addr = 0x14000 * FLASH_PAGE_SIZE; /* beyond 16MB */ | ||
| 53 | - uint32_t some_page_addr = 0x15000 * FLASH_PAGE_SIZE; | ||
| 54 | + uint32_t my_page_addr = test_data->page_addr; | ||
| 55 | + uint32_t some_page_addr = my_page_addr + FLASH_PAGE_SIZE; | ||
| 56 | uint32_t page[FLASH_PAGE_SIZE / 4]; | ||
| 57 | int i; | ||
| 58 | |||
| 59 | @@ -XXX,XX +XXX,XX @@ static void test_write_page(const void *data) | ||
| 60 | static void test_read_page_mem(const void *data) | ||
| 61 | { | ||
| 62 | const TestData *test_data = (const TestData *)data; | ||
| 63 | - uint32_t my_page_addr = 0x14000 * FLASH_PAGE_SIZE; /* beyond 16MB */ | ||
| 64 | - uint32_t some_page_addr = 0x15000 * FLASH_PAGE_SIZE; | ||
| 65 | + uint32_t my_page_addr = test_data->page_addr; | ||
| 66 | + uint32_t some_page_addr = my_page_addr + FLASH_PAGE_SIZE; | ||
| 67 | uint32_t page[FLASH_PAGE_SIZE / 4]; | ||
| 68 | int i; | ||
| 69 | |||
| 70 | @@ -XXX,XX +XXX,XX @@ static void test_read_page_mem(const void *data) | ||
| 71 | static void test_write_page_mem(const void *data) | ||
| 72 | { | ||
| 73 | const TestData *test_data = (const TestData *)data; | ||
| 74 | - uint32_t my_page_addr = 0x15000 * FLASH_PAGE_SIZE; | ||
| 75 | + uint32_t my_page_addr = test_data->page_addr; | ||
| 76 | uint32_t page[FLASH_PAGE_SIZE / 4]; | ||
| 77 | int i; | ||
| 78 | |||
| 79 | @@ -XXX,XX +XXX,XX @@ static void test_palmetto_bmc(TestData *data) | ||
| 80 | data->jedec_id = 0x20ba19; | ||
| 81 | data->cs = 0; | ||
| 82 | data->node = "/machine/soc/fmc/ssi.0/child[0]"; | ||
| 83 | + /* beyond 16MB */ | ||
| 84 | + data->page_addr = 0x14000 * FLASH_PAGE_SIZE; | ||
| 85 | |||
| 86 | qtest_add_data_func("/ast2400/smc/read_jedec", data, test_read_jedec); | ||
| 87 | qtest_add_data_func("/ast2400/smc/erase_sector", data, test_erase_sector); | ||
| 88 | -- | ||
| 89 | 2.47.1 | ||
| 90 | |||
| 91 | diff view generated by jsdifflib |
New patch | |||
|---|---|---|---|
| 1 | From: Jamin Lin <jamin_lin@aspeedtech.com> | ||
| 1 | 2 | ||
| 3 | Add test_ast2500_evb function and reused testcases for AST2500 testing. | ||
| 4 | The spi base address, flash base address and ce index of fmc_cs0 are | ||
| 5 | 0x1E620000, 0x20000000 and 0, respectively. | ||
| 6 | The default flash model of fmc_cs0 is "mx25l25635e" whose size is 32MB, | ||
| 7 | so set jedec_id 0xc22019. | ||
| 8 | |||
| 9 | Signed-off-by: Jamin Lin <jamin_lin@aspeedtech.com> | ||
| 10 | Reviewed-by: Cédric Le Goater <clg@redhat.com> | ||
| 11 | Link: https://lore.kernel.org/r/20241127091543.1243114-6-jamin_lin@aspeedtech.com | ||
| 12 | Signed-off-by: Cédric Le Goater <clg@redhat.com> | ||
| 13 | --- | ||
| 14 | tests/qtest/aspeed_smc-test.c | 40 +++++++++++++++++++++++++++++++++++ | ||
| 15 | 1 file changed, 40 insertions(+) | ||
| 16 | |||
| 17 | diff --git a/tests/qtest/aspeed_smc-test.c b/tests/qtest/aspeed_smc-test.c | ||
| 18 | index XXXXXXX..XXXXXXX 100644 | ||
| 19 | --- a/tests/qtest/aspeed_smc-test.c | ||
| 20 | +++ b/tests/qtest/aspeed_smc-test.c | ||
| 21 | @@ -XXX,XX +XXX,XX @@ static void test_palmetto_bmc(TestData *data) | ||
| 22 | data, test_write_block_protect_bottom_bit); | ||
| 23 | } | ||
| 24 | |||
| 25 | +static void test_ast2500_evb(TestData *data) | ||
| 26 | +{ | ||
| 27 | + int ret; | ||
| 28 | + int fd; | ||
| 29 | + | ||
| 30 | + fd = g_file_open_tmp("qtest.m25p80.mx25l25635e.XXXXXX", | ||
| 31 | + &data->tmp_path, NULL); | ||
| 32 | + g_assert(fd >= 0); | ||
| 33 | + ret = ftruncate(fd, 32 * 1024 * 1024); | ||
| 34 | + g_assert(ret == 0); | ||
| 35 | + close(fd); | ||
| 36 | + | ||
| 37 | + data->s = qtest_initf("-machine ast2500-evb " | ||
| 38 | + "-drive file=%s,format=raw,if=mtd", | ||
| 39 | + data->tmp_path); | ||
| 40 | + | ||
| 41 | + /* fmc cs0 with mx25l25635e flash */ | ||
| 42 | + data->flash_base = 0x20000000; | ||
| 43 | + data->spi_base = 0x1E620000; | ||
| 44 | + data->jedec_id = 0xc22019; | ||
| 45 | + data->cs = 0; | ||
| 46 | + data->node = "/machine/soc/fmc/ssi.0/child[0]"; | ||
| 47 | + /* beyond 16MB */ | ||
| 48 | + data->page_addr = 0x14000 * FLASH_PAGE_SIZE; | ||
| 49 | + | ||
| 50 | + qtest_add_data_func("/ast2500/smc/read_jedec", data, test_read_jedec); | ||
| 51 | + qtest_add_data_func("/ast2500/smc/erase_sector", data, test_erase_sector); | ||
| 52 | + qtest_add_data_func("/ast2500/smc/erase_all", data, test_erase_all); | ||
| 53 | + qtest_add_data_func("/ast2500/smc/write_page", data, test_write_page); | ||
| 54 | + qtest_add_data_func("/ast2500/smc/read_page_mem", | ||
| 55 | + data, test_read_page_mem); | ||
| 56 | + qtest_add_data_func("/ast2500/smc/write_page_mem", | ||
| 57 | + data, test_write_page_mem); | ||
| 58 | + qtest_add_data_func("/ast2500/smc/read_status_reg", | ||
| 59 | + data, test_read_status_reg); | ||
| 60 | +} | ||
| 61 | int main(int argc, char **argv) | ||
| 62 | { | ||
| 63 | TestData palmetto_data; | ||
| 64 | + TestData ast2500_evb_data; | ||
| 65 | int ret; | ||
| 66 | |||
| 67 | g_test_init(&argc, &argv, NULL); | ||
| 68 | |||
| 69 | test_palmetto_bmc(&palmetto_data); | ||
| 70 | + test_ast2500_evb(&ast2500_evb_data); | ||
| 71 | ret = g_test_run(); | ||
| 72 | |||
| 73 | qtest_quit(palmetto_data.s); | ||
| 74 | + qtest_quit(ast2500_evb_data.s); | ||
| 75 | unlink(palmetto_data.tmp_path); | ||
| 76 | + unlink(ast2500_evb_data.tmp_path); | ||
| 77 | return ret; | ||
| 78 | } | ||
| 79 | -- | ||
| 80 | 2.47.1 | ||
| 81 | |||
| 82 | diff view generated by jsdifflib |
New patch | |||
|---|---|---|---|
| 1 | From: Jamin Lin <jamin_lin@aspeedtech.com> | ||
| 1 | 2 | ||
| 3 | Add test_ast2600_evb function and reused testcases for AST2600 testing. | ||
| 4 | The spi base address, flash base address and ce index of fmc_cs0 are | ||
| 5 | 0x1E620000, 0x20000000 and 0, respectively. | ||
| 6 | The default flash model of fmc_cs0 is "mx66u51235f" whose size is 64MB, | ||
| 7 | so set jedec_id 0xc2253a. | ||
| 8 | |||
| 9 | Signed-off-by: Jamin Lin <jamin_lin@aspeedtech.com> | ||
| 10 | Reviewed-by: Cédric Le Goater <clg@redhat.com> | ||
| 11 | Link: https://lore.kernel.org/r/20241127091543.1243114-7-jamin_lin@aspeedtech.com | ||
| 12 | Signed-off-by: Cédric Le Goater <clg@redhat.com> | ||
| 13 | --- | ||
| 14 | tests/qtest/aspeed_smc-test.c | 41 +++++++++++++++++++++++++++++++++++ | ||
| 15 | 1 file changed, 41 insertions(+) | ||
| 16 | |||
| 17 | diff --git a/tests/qtest/aspeed_smc-test.c b/tests/qtest/aspeed_smc-test.c | ||
| 18 | index XXXXXXX..XXXXXXX 100644 | ||
| 19 | --- a/tests/qtest/aspeed_smc-test.c | ||
| 20 | +++ b/tests/qtest/aspeed_smc-test.c | ||
| 21 | @@ -XXX,XX +XXX,XX @@ static void test_ast2500_evb(TestData *data) | ||
| 22 | qtest_add_data_func("/ast2500/smc/read_status_reg", | ||
| 23 | data, test_read_status_reg); | ||
| 24 | } | ||
| 25 | + | ||
| 26 | +static void test_ast2600_evb(TestData *data) | ||
| 27 | +{ | ||
| 28 | + int ret; | ||
| 29 | + int fd; | ||
| 30 | + | ||
| 31 | + fd = g_file_open_tmp("qtest.m25p80.mx66u51235f.XXXXXX", | ||
| 32 | + &data->tmp_path, NULL); | ||
| 33 | + g_assert(fd >= 0); | ||
| 34 | + ret = ftruncate(fd, 64 * 1024 * 1024); | ||
| 35 | + g_assert(ret == 0); | ||
| 36 | + close(fd); | ||
| 37 | + | ||
| 38 | + data->s = qtest_initf("-machine ast2600-evb " | ||
| 39 | + "-drive file=%s,format=raw,if=mtd", | ||
| 40 | + data->tmp_path); | ||
| 41 | + | ||
| 42 | + /* fmc cs0 with mx66u51235f flash */ | ||
| 43 | + data->flash_base = 0x20000000; | ||
| 44 | + data->spi_base = 0x1E620000; | ||
| 45 | + data->jedec_id = 0xc2253a; | ||
| 46 | + data->cs = 0; | ||
| 47 | + data->node = "/machine/soc/fmc/ssi.0/child[0]"; | ||
| 48 | + /* beyond 16MB */ | ||
| 49 | + data->page_addr = 0x14000 * FLASH_PAGE_SIZE; | ||
| 50 | + | ||
| 51 | + qtest_add_data_func("/ast2600/smc/read_jedec", data, test_read_jedec); | ||
| 52 | + qtest_add_data_func("/ast2600/smc/erase_sector", data, test_erase_sector); | ||
| 53 | + qtest_add_data_func("/ast2600/smc/erase_all", data, test_erase_all); | ||
| 54 | + qtest_add_data_func("/ast2600/smc/write_page", data, test_write_page); | ||
| 55 | + qtest_add_data_func("/ast2600/smc/read_page_mem", | ||
| 56 | + data, test_read_page_mem); | ||
| 57 | + qtest_add_data_func("/ast2600/smc/write_page_mem", | ||
| 58 | + data, test_write_page_mem); | ||
| 59 | + qtest_add_data_func("/ast2600/smc/read_status_reg", | ||
| 60 | + data, test_read_status_reg); | ||
| 61 | +} | ||
| 62 | int main(int argc, char **argv) | ||
| 63 | { | ||
| 64 | TestData palmetto_data; | ||
| 65 | TestData ast2500_evb_data; | ||
| 66 | + TestData ast2600_evb_data; | ||
| 67 | int ret; | ||
| 68 | |||
| 69 | g_test_init(&argc, &argv, NULL); | ||
| 70 | |||
| 71 | test_palmetto_bmc(&palmetto_data); | ||
| 72 | test_ast2500_evb(&ast2500_evb_data); | ||
| 73 | + test_ast2600_evb(&ast2600_evb_data); | ||
| 74 | ret = g_test_run(); | ||
| 75 | |||
| 76 | qtest_quit(palmetto_data.s); | ||
| 77 | qtest_quit(ast2500_evb_data.s); | ||
| 78 | + qtest_quit(ast2600_evb_data.s); | ||
| 79 | unlink(palmetto_data.tmp_path); | ||
| 80 | unlink(ast2500_evb_data.tmp_path); | ||
| 81 | + unlink(ast2600_evb_data.tmp_path); | ||
| 82 | return ret; | ||
| 83 | } | ||
| 84 | -- | ||
| 85 | 2.47.1 | ||
| 86 | |||
| 87 | diff view generated by jsdifflib |
New patch | |||
|---|---|---|---|
| 1 | From: Jamin Lin <jamin_lin@aspeedtech.com> | ||
| 1 | 2 | ||
| 3 | Add test_ast1030_evb function and reused testcases for AST1030 testing. | ||
| 4 | The base address, flash base address and ce index of fmc_cs0 are | ||
| 5 | 0x7E620000, 0x80000000 and 0, respectively. | ||
| 6 | The default flash model of fmc_cs0 is "w25q80bl" whose size is 1MB, | ||
| 7 | so set jedec_id 0xef4014. | ||
| 8 | |||
| 9 | Signed-off-by: Jamin Lin <jamin_lin@aspeedtech.com> | ||
| 10 | Reviewed-by: Cédric Le Goater <clg@redhat.com> | ||
| 11 | Link: https://lore.kernel.org/r/20241127091543.1243114-8-jamin_lin@aspeedtech.com | ||
| 12 | Signed-off-by: Cédric Le Goater <clg@redhat.com> | ||
| 13 | --- | ||
| 14 | tests/qtest/aspeed_smc-test.c | 42 +++++++++++++++++++++++++++++++++++ | ||
| 15 | 1 file changed, 42 insertions(+) | ||
| 16 | |||
| 17 | diff --git a/tests/qtest/aspeed_smc-test.c b/tests/qtest/aspeed_smc-test.c | ||
| 18 | index XXXXXXX..XXXXXXX 100644 | ||
| 19 | --- a/tests/qtest/aspeed_smc-test.c | ||
| 20 | +++ b/tests/qtest/aspeed_smc-test.c | ||
| 21 | @@ -XXX,XX +XXX,XX @@ static void test_ast2600_evb(TestData *data) | ||
| 22 | qtest_add_data_func("/ast2600/smc/read_status_reg", | ||
| 23 | data, test_read_status_reg); | ||
| 24 | } | ||
| 25 | + | ||
| 26 | +static void test_ast1030_evb(TestData *data) | ||
| 27 | +{ | ||
| 28 | + int ret; | ||
| 29 | + int fd; | ||
| 30 | + | ||
| 31 | + fd = g_file_open_tmp("qtest.m25p80.w25q80bl.XXXXXX", | ||
| 32 | + &data->tmp_path, NULL); | ||
| 33 | + g_assert(fd >= 0); | ||
| 34 | + ret = ftruncate(fd, 1 * 1024 * 1024); | ||
| 35 | + g_assert(ret == 0); | ||
| 36 | + close(fd); | ||
| 37 | + | ||
| 38 | + data->s = qtest_initf("-machine ast1030-evb " | ||
| 39 | + "-drive file=%s,format=raw,if=mtd", | ||
| 40 | + data->tmp_path); | ||
| 41 | + | ||
| 42 | + /* fmc cs0 with w25q80bl flash */ | ||
| 43 | + data->flash_base = 0x80000000; | ||
| 44 | + data->spi_base = 0x7E620000; | ||
| 45 | + data->jedec_id = 0xef4014; | ||
| 46 | + data->cs = 0; | ||
| 47 | + data->node = "/machine/soc/fmc/ssi.0/child[0]"; | ||
| 48 | + /* beyond 512KB */ | ||
| 49 | + data->page_addr = 0x800 * FLASH_PAGE_SIZE; | ||
| 50 | + | ||
| 51 | + qtest_add_data_func("/ast1030/smc/read_jedec", data, test_read_jedec); | ||
| 52 | + qtest_add_data_func("/ast1030/smc/erase_sector", data, test_erase_sector); | ||
| 53 | + qtest_add_data_func("/ast1030/smc/erase_all", data, test_erase_all); | ||
| 54 | + qtest_add_data_func("/ast1030/smc/write_page", data, test_write_page); | ||
| 55 | + qtest_add_data_func("/ast1030/smc/read_page_mem", | ||
| 56 | + data, test_read_page_mem); | ||
| 57 | + qtest_add_data_func("/ast1030/smc/write_page_mem", | ||
| 58 | + data, test_write_page_mem); | ||
| 59 | + qtest_add_data_func("/ast1030/smc/read_status_reg", | ||
| 60 | + data, test_read_status_reg); | ||
| 61 | +} | ||
| 62 | + | ||
| 63 | int main(int argc, char **argv) | ||
| 64 | { | ||
| 65 | TestData palmetto_data; | ||
| 66 | TestData ast2500_evb_data; | ||
| 67 | TestData ast2600_evb_data; | ||
| 68 | + TestData ast1030_evb_data; | ||
| 69 | int ret; | ||
| 70 | |||
| 71 | g_test_init(&argc, &argv, NULL); | ||
| 72 | @@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv) | ||
| 73 | test_palmetto_bmc(&palmetto_data); | ||
| 74 | test_ast2500_evb(&ast2500_evb_data); | ||
| 75 | test_ast2600_evb(&ast2600_evb_data); | ||
| 76 | + test_ast1030_evb(&ast1030_evb_data); | ||
| 77 | ret = g_test_run(); | ||
| 78 | |||
| 79 | qtest_quit(palmetto_data.s); | ||
| 80 | qtest_quit(ast2500_evb_data.s); | ||
| 81 | qtest_quit(ast2600_evb_data.s); | ||
| 82 | + qtest_quit(ast1030_evb_data.s); | ||
| 83 | unlink(palmetto_data.tmp_path); | ||
| 84 | unlink(ast2500_evb_data.tmp_path); | ||
| 85 | unlink(ast2600_evb_data.tmp_path); | ||
| 86 | + unlink(ast1030_evb_data.tmp_path); | ||
| 87 | return ret; | ||
| 88 | } | ||
| 89 | -- | ||
| 90 | 2.47.1 | ||
| 91 | |||
| 92 | diff view generated by jsdifflib |
New patch | |||
|---|---|---|---|
| 1 | From: Jamin Lin <jamin_lin@aspeedtech.com> | ||
| 1 | 2 | ||
| 3 | Add a new testcase for write page command with QPI mode testing. | ||
| 4 | Currently, only run this testcase for AST2500, AST2600 and AST1030. | ||
| 5 | |||
| 6 | Signed-off-by: Jamin Lin <jamin_lin@aspeedtech.com> | ||
| 7 | Reviewed-by: Cédric Le Goater <clg@redhat.com> | ||
| 8 | Link: https://lore.kernel.org/r/20241127091543.1243114-9-jamin_lin@aspeedtech.com | ||
| 9 | Signed-off-by: Cédric Le Goater <clg@redhat.com> | ||
| 10 | --- | ||
| 11 | tests/qtest/aspeed_smc-test.c | 74 +++++++++++++++++++++++++++++++++++ | ||
| 12 | 1 file changed, 74 insertions(+) | ||
| 13 | |||
| 14 | diff --git a/tests/qtest/aspeed_smc-test.c b/tests/qtest/aspeed_smc-test.c | ||
| 15 | index XXXXXXX..XXXXXXX 100644 | ||
| 16 | --- a/tests/qtest/aspeed_smc-test.c | ||
| 17 | +++ b/tests/qtest/aspeed_smc-test.c | ||
| 18 | @@ -XXX,XX +XXX,XX @@ | ||
| 19 | #define R_CE_CTRL 0x04 | ||
| 20 | #define CRTL_EXTENDED0 0 /* 32 bit addressing for SPI */ | ||
| 21 | #define R_CTRL0 0x10 | ||
| 22 | +#define CTRL_IO_QUAD_IO BIT(31) | ||
| 23 | #define CTRL_CE_STOP_ACTIVE BIT(2) | ||
| 24 | #define CTRL_READMODE 0x0 | ||
| 25 | #define CTRL_FREADMODE 0x1 | ||
| 26 | @@ -XXX,XX +XXX,XX @@ enum { | ||
| 27 | ERASE_SECTOR = 0xd8, | ||
| 28 | }; | ||
| 29 | |||
| 30 | +#define CTRL_IO_MODE_MASK (BIT(31) | BIT(30) | BIT(29) | BIT(28)) | ||
| 31 | #define FLASH_PAGE_SIZE 256 | ||
| 32 | |||
| 33 | typedef struct TestData { | ||
| 34 | @@ -XXX,XX +XXX,XX @@ static void spi_ctrl_stop_user(const TestData *data) | ||
| 35 | spi_writel(data, ctrl_reg, ctrl); | ||
| 36 | } | ||
| 37 | |||
| 38 | +static void spi_ctrl_set_io_mode(const TestData *data, uint32_t value) | ||
| 39 | +{ | ||
| 40 | + uint32_t ctrl_reg = R_CTRL0 + data->cs * 4; | ||
| 41 | + uint32_t ctrl = spi_readl(data, ctrl_reg); | ||
| 42 | + uint32_t mode; | ||
| 43 | + | ||
| 44 | + mode = value & CTRL_IO_MODE_MASK; | ||
| 45 | + ctrl &= ~CTRL_IO_MODE_MASK; | ||
| 46 | + ctrl |= mode; | ||
| 47 | + spi_writel(data, ctrl_reg, ctrl); | ||
| 48 | +} | ||
| 49 | + | ||
| 50 | static void flash_reset(const TestData *data) | ||
| 51 | { | ||
| 52 | spi_conf(data, 1 << (CONF_ENABLE_W0 + data->cs)); | ||
| 53 | @@ -XXX,XX +XXX,XX @@ static void test_write_block_protect_bottom_bit(const void *data) | ||
| 54 | flash_reset(test_data); | ||
| 55 | } | ||
| 56 | |||
| 57 | +static void test_write_page_qpi(const void *data) | ||
| 58 | +{ | ||
| 59 | + const TestData *test_data = (const TestData *)data; | ||
| 60 | + uint32_t my_page_addr = test_data->page_addr; | ||
| 61 | + uint32_t some_page_addr = my_page_addr + FLASH_PAGE_SIZE; | ||
| 62 | + uint32_t page[FLASH_PAGE_SIZE / 4]; | ||
| 63 | + uint32_t page_pattern[] = { | ||
| 64 | + 0xebd8c134, 0x5da196bc, 0xae15e729, 0x5085ccdf | ||
| 65 | + }; | ||
| 66 | + int i; | ||
| 67 | + | ||
| 68 | + spi_conf(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 69 | + | ||
| 70 | + spi_ctrl_start_user(test_data); | ||
| 71 | + flash_writeb(test_data, 0, EN_4BYTE_ADDR); | ||
| 72 | + flash_writeb(test_data, 0, WREN); | ||
| 73 | + flash_writeb(test_data, 0, PP); | ||
| 74 | + flash_writel(test_data, 0, make_be32(my_page_addr)); | ||
| 75 | + | ||
| 76 | + /* Set QPI mode */ | ||
| 77 | + spi_ctrl_set_io_mode(test_data, CTRL_IO_QUAD_IO); | ||
| 78 | + | ||
| 79 | + /* Fill the page pattern */ | ||
| 80 | + for (i = 0; i < ARRAY_SIZE(page_pattern); i++) { | ||
| 81 | + flash_writel(test_data, 0, make_be32(page_pattern[i])); | ||
| 82 | + } | ||
| 83 | + | ||
| 84 | + /* Fill the page with its own addresses */ | ||
| 85 | + for (; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 86 | + flash_writel(test_data, 0, make_be32(my_page_addr + i * 4)); | ||
| 87 | + } | ||
| 88 | + | ||
| 89 | + /* Restore io mode */ | ||
| 90 | + spi_ctrl_set_io_mode(test_data, 0); | ||
| 91 | + spi_ctrl_stop_user(test_data); | ||
| 92 | + | ||
| 93 | + /* Check what was written */ | ||
| 94 | + read_page(test_data, my_page_addr, page); | ||
| 95 | + for (i = 0; i < ARRAY_SIZE(page_pattern); i++) { | ||
| 96 | + g_assert_cmphex(page[i], ==, page_pattern[i]); | ||
| 97 | + } | ||
| 98 | + for (; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 99 | + g_assert_cmphex(page[i], ==, my_page_addr + i * 4); | ||
| 100 | + } | ||
| 101 | + | ||
| 102 | + /* Check some other page. It should be full of 0xff */ | ||
| 103 | + read_page(test_data, some_page_addr, page); | ||
| 104 | + for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 105 | + g_assert_cmphex(page[i], ==, 0xffffffff); | ||
| 106 | + } | ||
| 107 | + | ||
| 108 | + flash_reset(test_data); | ||
| 109 | +} | ||
| 110 | + | ||
| 111 | static void test_palmetto_bmc(TestData *data) | ||
| 112 | { | ||
| 113 | int ret; | ||
| 114 | @@ -XXX,XX +XXX,XX @@ static void test_ast2500_evb(TestData *data) | ||
| 115 | data, test_write_page_mem); | ||
| 116 | qtest_add_data_func("/ast2500/smc/read_status_reg", | ||
| 117 | data, test_read_status_reg); | ||
| 118 | + qtest_add_data_func("/ast2500/smc/write_page_qpi", | ||
| 119 | + data, test_write_page_qpi); | ||
| 120 | } | ||
| 121 | |||
| 122 | static void test_ast2600_evb(TestData *data) | ||
| 123 | @@ -XXX,XX +XXX,XX @@ static void test_ast2600_evb(TestData *data) | ||
| 124 | data, test_write_page_mem); | ||
| 125 | qtest_add_data_func("/ast2600/smc/read_status_reg", | ||
| 126 | data, test_read_status_reg); | ||
| 127 | + qtest_add_data_func("/ast2600/smc/write_page_qpi", | ||
| 128 | + data, test_write_page_qpi); | ||
| 129 | } | ||
| 130 | |||
| 131 | static void test_ast1030_evb(TestData *data) | ||
| 132 | @@ -XXX,XX +XXX,XX @@ static void test_ast1030_evb(TestData *data) | ||
| 133 | data, test_write_page_mem); | ||
| 134 | qtest_add_data_func("/ast1030/smc/read_status_reg", | ||
| 135 | data, test_read_status_reg); | ||
| 136 | + qtest_add_data_func("/ast1030/smc/write_page_qpi", | ||
| 137 | + data, test_write_page_qpi); | ||
| 138 | } | ||
| 139 | |||
| 140 | int main(int argc, char **argv) | ||
| 141 | -- | ||
| 142 | 2.47.1 | ||
| 143 | |||
| 144 | diff view generated by jsdifflib |
| 1 | From: John Wang <wangzhiqiang.bj@bytedance.com> | 1 | From: Jamin Lin <jamin_lin@aspeedtech.com> |
|---|---|---|---|
| 2 | 2 | ||
| 3 | Largely inspired by the TMP421 temperature sensor, here is a model for | 3 | The testcases for ASPEED SMC model were placed in aspeed_smc-test.c. |
| 4 | the EMC1413/EMC1414 temperature sensors. | 4 | However, this test file only supports for ARM32. To support all ASPEED SOCs |
| 5 | such as AST2700 whose CPU architecture is aarch64, introduces a new | ||
| 6 | aspeed-smc-utils source file and move all common APIs and testcases | ||
| 7 | from aspeed_smc-test.c to aspeed-smc-utils.c. | ||
| 5 | 8 | ||
| 6 | Specs can be found here : | 9 | Finally, users are able to re-used these testcase for AST2700 and future |
| 7 | http://ww1.microchip.com/downloads/en/DeviceDoc/20005274A.pdf | 10 | ASPEED SOCs testing. |
| 8 | 11 | ||
| 9 | Cc: Philippe Mathieu-Daudé <philmd@redhat.com> | 12 | Signed-off-by: Jamin Lin <jamin_lin@aspeedtech.com> |
| 10 | Signed-off-by: John Wang <wangzhiqiang.bj@bytedance.com> | 13 | Reviewed-by: Cédric Le Goater <clg@redhat.com> |
| 11 | Reviewed-by: Cédric Le Goater <clg@kaod.org> | 14 | Link: https://lore.kernel.org/r/20241127091543.1243114-10-jamin_lin@aspeedtech.com |
| 12 | Message-Id: <20201122105134.671-1-wangzhiqiang.bj@bytedance.com> | 15 | Signed-off-by: Cédric Le Goater <clg@redhat.com> |
| 13 | Signed-off-by: Cédric Le Goater <clg@kaod.org> | ||
| 14 | --- | 16 | --- |
| 15 | include/hw/misc/emc141x_regs.h | 37 ++++ | 17 | tests/qtest/aspeed-smc-utils.h | 95 ++++ |
| 16 | hw/misc/emc141x.c | 326 +++++++++++++++++++++++++++++++++ | 18 | tests/qtest/aspeed-smc-utils.c | 686 ++++++++++++++++++++++++++++ |
| 17 | tests/qtest/emc141x-test.c | 81 ++++++++ | 19 | tests/qtest/aspeed_smc-test.c | 800 +++------------------------------ |
| 18 | hw/arm/Kconfig | 1 + | ||
| 19 | hw/misc/Kconfig | 4 + | ||
| 20 | hw/misc/meson.build | 1 + | ||
| 21 | tests/qtest/meson.build | 1 + | 20 | tests/qtest/meson.build | 1 + |
| 22 | 7 files changed, 451 insertions(+) | 21 | 4 files changed, 841 insertions(+), 741 deletions(-) |
| 23 | create mode 100644 include/hw/misc/emc141x_regs.h | 22 | create mode 100644 tests/qtest/aspeed-smc-utils.h |
| 24 | create mode 100644 hw/misc/emc141x.c | 23 | create mode 100644 tests/qtest/aspeed-smc-utils.c |
| 25 | create mode 100644 tests/qtest/emc141x-test.c | ||
| 26 | 24 | ||
| 27 | diff --git a/include/hw/misc/emc141x_regs.h b/include/hw/misc/emc141x_regs.h | 25 | diff --git a/tests/qtest/aspeed-smc-utils.h b/tests/qtest/aspeed-smc-utils.h |
| 28 | new file mode 100644 | 26 | new file mode 100644 |
| 29 | index XXXXXXX..XXXXXXX | 27 | index XXXXXXX..XXXXXXX |
| 30 | --- /dev/null | 28 | --- /dev/null |
| 31 | +++ b/include/hw/misc/emc141x_regs.h | 29 | +++ b/tests/qtest/aspeed-smc-utils.h |
| 32 | @@ -XXX,XX +XXX,XX @@ | 30 | @@ -XXX,XX +XXX,XX @@ |
| 33 | +/* | 31 | +/* |
| 34 | + * SMSC EMC141X temperature sensor. | 32 | + * QTest testcase for the M25P80 Flash (Using the Aspeed SPI |
| 33 | + * Controller) | ||
| 35 | + * | 34 | + * |
| 36 | + * Browse the data sheet: | 35 | + * Copyright (C) 2016 IBM Corp. |
| 37 | + * | 36 | + * |
| 38 | + * http://ww1.microchip.com/downloads/en/DeviceDoc/20005274A.pdf | 37 | + * Permission is hereby granted, free of charge, to any person obtaining a copy |
| 38 | + * of this software and associated documentation files (the "Software"), to deal | ||
| 39 | + * in the Software without restriction, including without limitation the rights | ||
| 40 | + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | ||
| 41 | + * copies of the Software, and to permit persons to whom the Software is | ||
| 42 | + * furnished to do so, subject to the following conditions: | ||
| 39 | + * | 43 | + * |
| 40 | + * This work is licensed under the terms of the GNU GPL, version 2 or | 44 | + * The above copyright notice and this permission notice shall be included in |
| 41 | + * later. See the COPYING file in the top-level directory. | 45 | + * all copies or substantial portions of the Software. |
| 46 | + * | ||
| 47 | + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
| 48 | + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
| 49 | + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | ||
| 50 | + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | ||
| 51 | + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | ||
| 52 | + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | ||
| 53 | + * THE SOFTWARE. | ||
| 42 | + */ | 54 | + */ |
| 43 | + | 55 | + |
| 44 | +#ifndef TMP105_REGS_H | 56 | +#ifndef TESTS_ASPEED_SMC_UTILS_H |
| 45 | +#define TMP105_REGS_H | 57 | +#define TESTS_ASPEED_SMC_UTILS_H |
| 46 | + | 58 | + |
| 47 | +#define EMC1413_DEVICE_ID 0x21 | 59 | +#include "qemu/osdep.h" |
| 48 | +#define EMC1414_DEVICE_ID 0x25 | 60 | +#include "qemu/bswap.h" |
| 49 | +#define MANUFACTURER_ID 0x5d | 61 | +#include "libqtest-single.h" |
| 50 | +#define REVISION 0x04 | 62 | +#include "qemu/bitops.h" |
| 51 | + | 63 | + |
| 52 | +/* the EMC141X registers */ | 64 | +/* |
| 53 | +#define EMC141X_TEMP_HIGH0 0x00 | 65 | + * ASPEED SPI Controller registers |
| 54 | +#define EMC141X_TEMP_HIGH1 0x01 | 66 | + */ |
| 55 | +#define EMC141X_TEMP_HIGH2 0x23 | 67 | +#define R_CONF 0x00 |
| 56 | +#define EMC141X_TEMP_HIGH3 0x2a | 68 | +#define CONF_ENABLE_W0 16 |
| 57 | +#define EMC141X_TEMP_MAX_HIGH0 0x05 | 69 | +#define R_CE_CTRL 0x04 |
| 58 | +#define EMC141X_TEMP_MIN_HIGH0 0x06 | 70 | +#define CRTL_EXTENDED0 0 /* 32 bit addressing for SPI */ |
| 59 | +#define EMC141X_TEMP_MAX_HIGH1 0x07 | 71 | +#define R_CTRL0 0x10 |
| 60 | +#define EMC141X_TEMP_MIN_HIGH1 0x08 | 72 | +#define CTRL_IO_QUAD_IO BIT(31) |
| 61 | +#define EMC141X_TEMP_MAX_HIGH2 0x15 | 73 | +#define CTRL_CE_STOP_ACTIVE BIT(2) |
| 62 | +#define EMC141X_TEMP_MIN_HIGH2 0x16 | 74 | +#define CTRL_READMODE 0x0 |
| 63 | +#define EMC141X_TEMP_MAX_HIGH3 0x2c | 75 | +#define CTRL_FREADMODE 0x1 |
| 64 | +#define EMC141X_TEMP_MIN_HIGH3 0x2d | 76 | +#define CTRL_WRITEMODE 0x2 |
| 65 | +#define EMC141X_DEVICE_ID 0xfd | 77 | +#define CTRL_USERMODE 0x3 |
| 66 | +#define EMC141X_MANUFACTURER_ID 0xfe | 78 | +#define SR_WEL BIT(1) |
| 67 | +#define EMC141X_REVISION 0xff | 79 | + |
| 68 | + | 80 | +/* |
| 69 | +#endif | 81 | + * Flash commands |
| 70 | diff --git a/hw/misc/emc141x.c b/hw/misc/emc141x.c | 82 | + */ |
| 83 | +enum { | ||
| 84 | + JEDEC_READ = 0x9f, | ||
| 85 | + RDSR = 0x5, | ||
| 86 | + WRDI = 0x4, | ||
| 87 | + BULK_ERASE = 0xc7, | ||
| 88 | + READ = 0x03, | ||
| 89 | + PP = 0x02, | ||
| 90 | + WRSR = 0x1, | ||
| 91 | + WREN = 0x6, | ||
| 92 | + SRWD = 0x80, | ||
| 93 | + RESET_ENABLE = 0x66, | ||
| 94 | + RESET_MEMORY = 0x99, | ||
| 95 | + EN_4BYTE_ADDR = 0xB7, | ||
| 96 | + ERASE_SECTOR = 0xd8, | ||
| 97 | +}; | ||
| 98 | + | ||
| 99 | +#define CTRL_IO_MODE_MASK (BIT(31) | BIT(30) | BIT(29) | BIT(28)) | ||
| 100 | +#define FLASH_PAGE_SIZE 256 | ||
| 101 | + | ||
| 102 | +typedef struct AspeedSMCTestData { | ||
| 103 | + QTestState *s; | ||
| 104 | + uint64_t spi_base; | ||
| 105 | + uint64_t flash_base; | ||
| 106 | + uint32_t jedec_id; | ||
| 107 | + char *tmp_path; | ||
| 108 | + uint8_t cs; | ||
| 109 | + const char *node; | ||
| 110 | + uint32_t page_addr; | ||
| 111 | +} AspeedSMCTestData; | ||
| 112 | + | ||
| 113 | +void aspeed_smc_test_read_jedec(const void *data); | ||
| 114 | +void aspeed_smc_test_erase_sector(const void *data); | ||
| 115 | +void aspeed_smc_test_erase_all(const void *data); | ||
| 116 | +void aspeed_smc_test_write_page(const void *data); | ||
| 117 | +void aspeed_smc_test_read_page_mem(const void *data); | ||
| 118 | +void aspeed_smc_test_write_page_mem(const void *data); | ||
| 119 | +void aspeed_smc_test_read_status_reg(const void *data); | ||
| 120 | +void aspeed_smc_test_status_reg_write_protection(const void *data); | ||
| 121 | +void aspeed_smc_test_write_block_protect(const void *data); | ||
| 122 | +void aspeed_smc_test_write_block_protect_bottom_bit(const void *data); | ||
| 123 | +void aspeed_smc_test_write_page_qpi(const void *data); | ||
| 124 | + | ||
| 125 | +#endif /* TESTS_ASPEED_SMC_UTILS_H */ | ||
| 126 | diff --git a/tests/qtest/aspeed-smc-utils.c b/tests/qtest/aspeed-smc-utils.c | ||
| 71 | new file mode 100644 | 127 | new file mode 100644 |
| 72 | index XXXXXXX..XXXXXXX | 128 | index XXXXXXX..XXXXXXX |
| 73 | --- /dev/null | 129 | --- /dev/null |
| 74 | +++ b/hw/misc/emc141x.c | 130 | +++ b/tests/qtest/aspeed-smc-utils.c |
| 75 | @@ -XXX,XX +XXX,XX @@ | 131 | @@ -XXX,XX +XXX,XX @@ |
| 76 | +/* | 132 | +/* |
| 77 | + * SMSC EMC141X temperature sensor. | 133 | + * QTest testcase for the M25P80 Flash (Using the Aspeed SPI |
| 134 | + * Controller) | ||
| 78 | + * | 135 | + * |
| 79 | + * Copyright (c) 2020 Bytedance Corporation | 136 | + * Copyright (C) 2016 IBM Corp. |
| 80 | + * Written by John Wang <wangzhiqiang.bj@bytedance.com> | ||
| 81 | + * | 137 | + * |
| 82 | + * This program is free software; you can redistribute it and/or | 138 | + * Permission is hereby granted, free of charge, to any person obtaining a copy |
| 83 | + * modify it under the terms of the GNU General Public License as | 139 | + * of this software and associated documentation files (the "Software"), to deal |
| 84 | + * published by the Free Software Foundation; either version 2 or | 140 | + * in the Software without restriction, including without limitation the rights |
| 85 | + * (at your option) version 3 of the License. | 141 | + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| 142 | + * copies of the Software, and to permit persons to whom the Software is | ||
| 143 | + * furnished to do so, subject to the following conditions: | ||
| 86 | + * | 144 | + * |
| 87 | + * This program is distributed in the hope that it will be useful, | 145 | + * The above copyright notice and this permission notice shall be included in |
| 88 | + * but WITHOUT ANY WARRANTY; without even the implied warranty of | 146 | + * all copies or substantial portions of the Software. |
| 89 | + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
| 90 | + * GNU General Public License for more details. | ||
| 91 | + * | 147 | + * |
| 92 | + * You should have received a copy of the GNU General Public License along | 148 | + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 93 | + * with this program; if not, see <http://www.gnu.org/licenses/>. | 149 | + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 150 | + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | ||
| 151 | + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | ||
| 152 | + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | ||
| 153 | + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | ||
| 154 | + * THE SOFTWARE. | ||
| 94 | + */ | 155 | + */ |
| 95 | + | 156 | + |
| 96 | +#include "qemu/osdep.h" | 157 | +#include "qemu/osdep.h" |
| 97 | +#include "hw/i2c/i2c.h" | 158 | +#include "qemu/bswap.h" |
| 98 | +#include "migration/vmstate.h" | 159 | +#include "libqtest-single.h" |
| 99 | +#include "qapi/error.h" | 160 | +#include "qemu/bitops.h" |
| 100 | +#include "qapi/visitor.h" | 161 | +#include "aspeed-smc-utils.h" |
| 101 | +#include "qemu/module.h" | 162 | + |
| 102 | +#include "qom/object.h" | 163 | +/* |
| 103 | +#include "hw/misc/emc141x_regs.h" | 164 | + * Use an explicit bswap for the values read/wrote to the flash region |
| 104 | + | 165 | + * as they are BE and the Aspeed CPU is LE. |
| 105 | +#define SENSORS_COUNT_MAX 4 | 166 | + */ |
| 106 | + | 167 | +static inline uint32_t make_be32(uint32_t data) |
| 107 | +struct EMC141XState { | 168 | +{ |
| 108 | + I2CSlave parent_obj; | 169 | + return bswap32(data); |
| 109 | + struct { | 170 | +} |
| 110 | + uint8_t raw_temp_min; | 171 | + |
| 111 | + uint8_t raw_temp_current; | 172 | +static inline void spi_writel(const AspeedSMCTestData *data, uint64_t offset, |
| 112 | + uint8_t raw_temp_max; | 173 | + uint32_t value) |
| 113 | + } sensor[SENSORS_COUNT_MAX]; | 174 | +{ |
| 114 | + uint8_t len; | 175 | + qtest_writel(data->s, data->spi_base + offset, value); |
| 115 | + uint8_t data; | 176 | +} |
| 116 | + uint8_t pointer; | 177 | + |
| 117 | +}; | 178 | +static inline uint32_t spi_readl(const AspeedSMCTestData *data, uint64_t offset) |
| 118 | + | 179 | +{ |
| 119 | +struct EMC141XClass { | 180 | + return qtest_readl(data->s, data->spi_base + offset); |
| 120 | + I2CSlaveClass parent_class; | 181 | +} |
| 121 | + uint8_t model; | 182 | + |
| 122 | + unsigned sensors_count; | 183 | +static inline void flash_writeb(const AspeedSMCTestData *data, uint64_t offset, |
| 123 | +}; | 184 | + uint8_t value) |
| 124 | + | 185 | +{ |
| 125 | +#define TYPE_EMC141X "emc141x" | 186 | + qtest_writeb(data->s, data->flash_base + offset, value); |
| 126 | +OBJECT_DECLARE_TYPE(EMC141XState, EMC141XClass, EMC141X) | 187 | +} |
| 127 | + | 188 | + |
| 128 | +static void emc141x_get_temperature(Object *obj, Visitor *v, const char *name, | 189 | +static inline void flash_writel(const AspeedSMCTestData *data, uint64_t offset, |
| 129 | + void *opaque, Error **errp) | 190 | + uint32_t value) |
| 130 | +{ | 191 | +{ |
| 131 | + EMC141XState *s = EMC141X(obj); | 192 | + qtest_writel(data->s, data->flash_base + offset, value); |
| 132 | + EMC141XClass *sc = EMC141X_GET_CLASS(s); | 193 | +} |
| 133 | + int64_t value; | 194 | + |
| 134 | + unsigned tempid; | 195 | +static inline uint8_t flash_readb(const AspeedSMCTestData *data, |
| 135 | + | 196 | + uint64_t offset) |
| 136 | + if (sscanf(name, "temperature%u", &tempid) != 1) { | 197 | +{ |
| 137 | + error_setg(errp, "error reading %s: %s", name, g_strerror(errno)); | 198 | + return qtest_readb(data->s, data->flash_base + offset); |
| 138 | + return; | 199 | +} |
| 139 | + } | 200 | + |
| 140 | + | 201 | +static inline uint32_t flash_readl(const AspeedSMCTestData *data, |
| 141 | + if (tempid >= sc->sensors_count) { | 202 | + uint64_t offset) |
| 142 | + error_setg(errp, "error reading %s", name); | 203 | +{ |
| 143 | + return; | 204 | + return qtest_readl(data->s, data->flash_base + offset); |
| 144 | + } | 205 | +} |
| 145 | + | 206 | + |
| 146 | + value = s->sensor[tempid].raw_temp_current * 1000; | 207 | +static void spi_conf(const AspeedSMCTestData *data, uint32_t value) |
| 147 | + | 208 | +{ |
| 148 | + visit_type_int(v, name, &value, errp); | 209 | + uint32_t conf = spi_readl(data, R_CONF); |
| 149 | +} | 210 | + |
| 150 | + | 211 | + conf |= value; |
| 151 | +static void emc141x_set_temperature(Object *obj, Visitor *v, const char *name, | 212 | + spi_writel(data, R_CONF, conf); |
| 152 | + void *opaque, Error **errp) | 213 | +} |
| 153 | +{ | 214 | + |
| 154 | + EMC141XState *s = EMC141X(obj); | 215 | +static void spi_conf_remove(const AspeedSMCTestData *data, uint32_t value) |
| 155 | + EMC141XClass *sc = EMC141X_GET_CLASS(s); | 216 | +{ |
| 156 | + int64_t temp; | 217 | + uint32_t conf = spi_readl(data, R_CONF); |
| 157 | + unsigned tempid; | 218 | + |
| 158 | + | 219 | + conf &= ~value; |
| 159 | + if (!visit_type_int(v, name, &temp, errp)) { | 220 | + spi_writel(data, R_CONF, conf); |
| 160 | + return; | 221 | +} |
| 161 | + } | 222 | + |
| 162 | + | 223 | +static void spi_ce_ctrl(const AspeedSMCTestData *data, uint32_t value) |
| 163 | + if (sscanf(name, "temperature%u", &tempid) != 1) { | 224 | +{ |
| 164 | + error_setg(errp, "error reading %s: %s", name, g_strerror(errno)); | 225 | + uint32_t conf = spi_readl(data, R_CE_CTRL); |
| 165 | + return; | 226 | + |
| 166 | + } | 227 | + conf |= value; |
| 167 | + | 228 | + spi_writel(data, R_CE_CTRL, conf); |
| 168 | + if (tempid >= sc->sensors_count) { | 229 | +} |
| 169 | + error_setg(errp, "error reading %s", name); | 230 | + |
| 170 | + return; | 231 | +static void spi_ctrl_setmode(const AspeedSMCTestData *data, uint8_t mode, |
| 171 | + } | 232 | + uint8_t cmd) |
| 172 | + | 233 | +{ |
| 173 | + s->sensor[tempid].raw_temp_current = temp / 1000; | 234 | + uint32_t ctrl_reg = R_CTRL0 + data->cs * 4; |
| 174 | +} | 235 | + uint32_t ctrl = spi_readl(data, ctrl_reg); |
| 175 | + | 236 | + ctrl &= ~(CTRL_USERMODE | 0xff << 16); |
| 176 | +static void emc141x_read(EMC141XState *s) | 237 | + ctrl |= mode | (cmd << 16); |
| 177 | +{ | 238 | + spi_writel(data, ctrl_reg, ctrl); |
| 178 | + EMC141XClass *sc = EMC141X_GET_CLASS(s); | 239 | +} |
| 179 | + switch (s->pointer) { | 240 | + |
| 180 | + case EMC141X_DEVICE_ID: | 241 | +static void spi_ctrl_start_user(const AspeedSMCTestData *data) |
| 181 | + s->data = sc->model; | 242 | +{ |
| 182 | + break; | 243 | + uint32_t ctrl_reg = R_CTRL0 + data->cs * 4; |
| 183 | + case EMC141X_MANUFACTURER_ID: | 244 | + uint32_t ctrl = spi_readl(data, ctrl_reg); |
| 184 | + s->data = MANUFACTURER_ID; | 245 | + |
| 185 | + break; | 246 | + ctrl |= CTRL_USERMODE | CTRL_CE_STOP_ACTIVE; |
| 186 | + case EMC141X_REVISION: | 247 | + spi_writel(data, ctrl_reg, ctrl); |
| 187 | + s->data = REVISION; | 248 | + |
| 188 | + break; | 249 | + ctrl &= ~CTRL_CE_STOP_ACTIVE; |
| 189 | + case EMC141X_TEMP_HIGH0: | 250 | + spi_writel(data, ctrl_reg, ctrl); |
| 190 | + s->data = s->sensor[0].raw_temp_current; | 251 | +} |
| 191 | + break; | 252 | + |
| 192 | + case EMC141X_TEMP_HIGH1: | 253 | +static void spi_ctrl_stop_user(const AspeedSMCTestData *data) |
| 193 | + s->data = s->sensor[1].raw_temp_current; | 254 | +{ |
| 194 | + break; | 255 | + uint32_t ctrl_reg = R_CTRL0 + data->cs * 4; |
| 195 | + case EMC141X_TEMP_HIGH2: | 256 | + uint32_t ctrl = spi_readl(data, ctrl_reg); |
| 196 | + s->data = s->sensor[2].raw_temp_current; | 257 | + |
| 197 | + break; | 258 | + ctrl |= CTRL_USERMODE | CTRL_CE_STOP_ACTIVE; |
| 198 | + case EMC141X_TEMP_HIGH3: | 259 | + spi_writel(data, ctrl_reg, ctrl); |
| 199 | + s->data = s->sensor[3].raw_temp_current; | 260 | +} |
| 200 | + break; | 261 | + |
| 201 | + case EMC141X_TEMP_MAX_HIGH0: | 262 | +static void spi_ctrl_set_io_mode(const AspeedSMCTestData *data, uint32_t value) |
| 202 | + s->data = s->sensor[0].raw_temp_max; | 263 | +{ |
| 203 | + break; | 264 | + uint32_t ctrl_reg = R_CTRL0 + data->cs * 4; |
| 204 | + case EMC141X_TEMP_MAX_HIGH1: | 265 | + uint32_t ctrl = spi_readl(data, ctrl_reg); |
| 205 | + s->data = s->sensor[1].raw_temp_max; | 266 | + uint32_t mode; |
| 206 | + break; | 267 | + |
| 207 | + case EMC141X_TEMP_MAX_HIGH2: | 268 | + mode = value & CTRL_IO_MODE_MASK; |
| 208 | + s->data = s->sensor[2].raw_temp_max; | 269 | + ctrl &= ~CTRL_IO_MODE_MASK; |
| 209 | + break; | 270 | + ctrl |= mode; |
| 210 | + case EMC141X_TEMP_MAX_HIGH3: | 271 | + spi_writel(data, ctrl_reg, ctrl); |
| 211 | + s->data = s->sensor[3].raw_temp_max; | 272 | +} |
| 212 | + break; | 273 | + |
| 213 | + case EMC141X_TEMP_MIN_HIGH0: | 274 | +static void flash_reset(const AspeedSMCTestData *data) |
| 214 | + s->data = s->sensor[0].raw_temp_min; | 275 | +{ |
| 215 | + break; | 276 | + spi_conf(data, 1 << (CONF_ENABLE_W0 + data->cs)); |
| 216 | + case EMC141X_TEMP_MIN_HIGH1: | 277 | + |
| 217 | + s->data = s->sensor[1].raw_temp_min; | 278 | + spi_ctrl_start_user(data); |
| 218 | + break; | 279 | + flash_writeb(data, 0, RESET_ENABLE); |
| 219 | + case EMC141X_TEMP_MIN_HIGH2: | 280 | + flash_writeb(data, 0, RESET_MEMORY); |
| 220 | + s->data = s->sensor[2].raw_temp_min; | 281 | + flash_writeb(data, 0, WREN); |
| 221 | + break; | 282 | + flash_writeb(data, 0, BULK_ERASE); |
| 222 | + case EMC141X_TEMP_MIN_HIGH3: | 283 | + flash_writeb(data, 0, WRDI); |
| 223 | + s->data = s->sensor[3].raw_temp_min; | 284 | + spi_ctrl_stop_user(data); |
| 224 | + break; | 285 | + |
| 225 | + default: | 286 | + spi_conf_remove(data, 1 << (CONF_ENABLE_W0 + data->cs)); |
| 226 | + s->data = 0; | 287 | +} |
| 227 | + } | 288 | + |
| 228 | +} | 289 | +static void read_page(const AspeedSMCTestData *data, uint32_t addr, |
| 229 | + | 290 | + uint32_t *page) |
| 230 | +static void emc141x_write(EMC141XState *s) | 291 | +{ |
| 231 | +{ | ||
| 232 | + switch (s->pointer) { | ||
| 233 | + case EMC141X_TEMP_MAX_HIGH0: | ||
| 234 | + s->sensor[0].raw_temp_max = s->data; | ||
| 235 | + break; | ||
| 236 | + case EMC141X_TEMP_MAX_HIGH1: | ||
| 237 | + s->sensor[1].raw_temp_max = s->data; | ||
| 238 | + break; | ||
| 239 | + case EMC141X_TEMP_MAX_HIGH2: | ||
| 240 | + s->sensor[2].raw_temp_max = s->data; | ||
| 241 | + break; | ||
| 242 | + case EMC141X_TEMP_MAX_HIGH3: | ||
| 243 | + s->sensor[3].raw_temp_max = s->data; | ||
| 244 | + break; | ||
| 245 | + case EMC141X_TEMP_MIN_HIGH0: | ||
| 246 | + s->sensor[0].raw_temp_min = s->data; | ||
| 247 | + break; | ||
| 248 | + case EMC141X_TEMP_MIN_HIGH1: | ||
| 249 | + s->sensor[1].raw_temp_min = s->data; | ||
| 250 | + break; | ||
| 251 | + case EMC141X_TEMP_MIN_HIGH2: | ||
| 252 | + s->sensor[2].raw_temp_min = s->data; | ||
| 253 | + break; | ||
| 254 | + case EMC141X_TEMP_MIN_HIGH3: | ||
| 255 | + s->sensor[3].raw_temp_min = s->data; | ||
| 256 | + break; | ||
| 257 | + default: | ||
| 258 | + s->data = 0; | ||
| 259 | + } | ||
| 260 | +} | ||
| 261 | + | ||
| 262 | +static uint8_t emc141x_rx(I2CSlave *i2c) | ||
| 263 | +{ | ||
| 264 | + EMC141XState *s = EMC141X(i2c); | ||
| 265 | + | ||
| 266 | + if (s->len == 0) { | ||
| 267 | + s->len++; | ||
| 268 | + return s->data; | ||
| 269 | + } else { | ||
| 270 | + return 0xff; | ||
| 271 | + } | ||
| 272 | +} | ||
| 273 | + | ||
| 274 | +static int emc141x_tx(I2CSlave *i2c, uint8_t data) | ||
| 275 | +{ | ||
| 276 | + EMC141XState *s = EMC141X(i2c); | ||
| 277 | + | ||
| 278 | + if (s->len == 0) { | ||
| 279 | + /* first byte is the reg pointer */ | ||
| 280 | + s->pointer = data; | ||
| 281 | + s->len++; | ||
| 282 | + } else if (s->len == 1) { | ||
| 283 | + s->data = data; | ||
| 284 | + emc141x_write(s); | ||
| 285 | + } | ||
| 286 | + | ||
| 287 | + return 0; | ||
| 288 | +} | ||
| 289 | + | ||
| 290 | +static int emc141x_event(I2CSlave *i2c, enum i2c_event event) | ||
| 291 | +{ | ||
| 292 | + EMC141XState *s = EMC141X(i2c); | ||
| 293 | + | ||
| 294 | + if (event == I2C_START_RECV) { | ||
| 295 | + emc141x_read(s); | ||
| 296 | + } | ||
| 297 | + | ||
| 298 | + s->len = 0; | ||
| 299 | + return 0; | ||
| 300 | +} | ||
| 301 | + | ||
| 302 | +static const VMStateDescription vmstate_emc141x = { | ||
| 303 | + .name = "EMC141X", | ||
| 304 | + .version_id = 0, | ||
| 305 | + .minimum_version_id = 0, | ||
| 306 | + .fields = (VMStateField[]) { | ||
| 307 | + VMSTATE_UINT8(len, EMC141XState), | ||
| 308 | + VMSTATE_UINT8(data, EMC141XState), | ||
| 309 | + VMSTATE_UINT8(pointer, EMC141XState), | ||
| 310 | + VMSTATE_I2C_SLAVE(parent_obj, EMC141XState), | ||
| 311 | + VMSTATE_END_OF_LIST() | ||
| 312 | + } | ||
| 313 | +}; | ||
| 314 | + | ||
| 315 | +static void emc141x_reset(DeviceState *dev) | ||
| 316 | +{ | ||
| 317 | + EMC141XState *s = EMC141X(dev); | ||
| 318 | + int i; | 292 | + int i; |
| 319 | + | 293 | + |
| 320 | + for (i = 0; i < SENSORS_COUNT_MAX; i++) { | 294 | + spi_ctrl_start_user(data); |
| 321 | + s->sensor[i].raw_temp_max = 0x55; | 295 | + |
| 322 | + } | 296 | + flash_writeb(data, 0, EN_4BYTE_ADDR); |
| 323 | + s->pointer = 0; | 297 | + flash_writeb(data, 0, READ); |
| 324 | + s->len = 0; | 298 | + flash_writel(data, 0, make_be32(addr)); |
| 325 | +} | 299 | + |
| 326 | + | 300 | + /* Continuous read are supported */ |
| 327 | +static void emc141x_initfn(Object *obj) | 301 | + for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { |
| 328 | +{ | 302 | + page[i] = make_be32(flash_readl(data, 0)); |
| 329 | + object_property_add(obj, "temperature0", "int", | 303 | + } |
| 330 | + emc141x_get_temperature, | 304 | + spi_ctrl_stop_user(data); |
| 331 | + emc141x_set_temperature, NULL, NULL); | 305 | +} |
| 332 | + object_property_add(obj, "temperature1", "int", | 306 | + |
| 333 | + emc141x_get_temperature, | 307 | +static void read_page_mem(const AspeedSMCTestData *data, uint32_t addr, |
| 334 | + emc141x_set_temperature, NULL, NULL); | 308 | + uint32_t *page) |
| 335 | + object_property_add(obj, "temperature2", "int", | 309 | +{ |
| 336 | + emc141x_get_temperature, | 310 | + int i; |
| 337 | + emc141x_set_temperature, NULL, NULL); | 311 | + |
| 338 | + object_property_add(obj, "temperature3", "int", | 312 | + /* move out USER mode to use direct reads from the AHB bus */ |
| 339 | + emc141x_get_temperature, | 313 | + spi_ctrl_setmode(data, CTRL_READMODE, READ); |
| 340 | + emc141x_set_temperature, NULL, NULL); | 314 | + |
| 341 | +} | 315 | + for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { |
| 342 | + | 316 | + page[i] = make_be32(flash_readl(data, addr + i * 4)); |
| 343 | +static void emc141x_class_init(ObjectClass *klass, void *data) | 317 | + } |
| 344 | +{ | 318 | +} |
| 345 | + DeviceClass *dc = DEVICE_CLASS(klass); | 319 | + |
| 346 | + I2CSlaveClass *k = I2C_SLAVE_CLASS(klass); | 320 | +static void write_page_mem(const AspeedSMCTestData *data, uint32_t addr, |
| 347 | + | 321 | + uint32_t write_value) |
| 348 | + dc->reset = emc141x_reset; | 322 | +{ |
| 349 | + k->event = emc141x_event; | 323 | + spi_ctrl_setmode(data, CTRL_WRITEMODE, PP); |
| 350 | + k->recv = emc141x_rx; | 324 | + |
| 351 | + k->send = emc141x_tx; | 325 | + for (int i = 0; i < FLASH_PAGE_SIZE / 4; i++) { |
| 352 | + dc->vmsd = &vmstate_emc141x; | 326 | + flash_writel(data, addr + i * 4, write_value); |
| 353 | +} | 327 | + } |
| 354 | + | 328 | +} |
| 355 | +static void emc1413_class_init(ObjectClass *klass, void *data) | 329 | + |
| 356 | +{ | 330 | +static void assert_page_mem(const AspeedSMCTestData *data, uint32_t addr, |
| 357 | + EMC141XClass *ec = EMC141X_CLASS(klass); | 331 | + uint32_t expected_value) |
| 358 | + | 332 | +{ |
| 359 | + emc141x_class_init(klass, data); | 333 | + uint32_t page[FLASH_PAGE_SIZE / 4]; |
| 360 | + ec->model = EMC1413_DEVICE_ID; | 334 | + read_page_mem(data, addr, page); |
| 361 | + ec->sensors_count = 3; | 335 | + for (int i = 0; i < FLASH_PAGE_SIZE / 4; i++) { |
| 362 | +} | 336 | + g_assert_cmphex(page[i], ==, expected_value); |
| 363 | + | 337 | + } |
| 364 | +static void emc1414_class_init(ObjectClass *klass, void *data) | 338 | +} |
| 365 | +{ | 339 | + |
| 366 | + EMC141XClass *ec = EMC141X_CLASS(klass); | 340 | +void aspeed_smc_test_read_jedec(const void *data) |
| 367 | + | 341 | +{ |
| 368 | + emc141x_class_init(klass, data); | 342 | + const AspeedSMCTestData *test_data = (const AspeedSMCTestData *)data; |
| 369 | + ec->model = EMC1414_DEVICE_ID; | 343 | + uint32_t jedec = 0x0; |
| 370 | + ec->sensors_count = 4; | 344 | + |
| 371 | +} | 345 | + spi_conf(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); |
| 372 | + | 346 | + |
| 373 | +static const TypeInfo emc141x_info = { | 347 | + spi_ctrl_start_user(test_data); |
| 374 | + .name = TYPE_EMC141X, | 348 | + flash_writeb(test_data, 0, JEDEC_READ); |
| 375 | + .parent = TYPE_I2C_SLAVE, | 349 | + jedec |= flash_readb(test_data, 0) << 16; |
| 376 | + .instance_size = sizeof(EMC141XState), | 350 | + jedec |= flash_readb(test_data, 0) << 8; |
| 377 | + .class_size = sizeof(EMC141XClass), | 351 | + jedec |= flash_readb(test_data, 0); |
| 378 | + .instance_init = emc141x_initfn, | 352 | + spi_ctrl_stop_user(test_data); |
| 379 | + .abstract = true, | 353 | + |
| 380 | +}; | 354 | + flash_reset(test_data); |
| 381 | + | 355 | + |
| 382 | +static const TypeInfo emc1413_info = { | 356 | + g_assert_cmphex(jedec, ==, test_data->jedec_id); |
| 383 | + .name = "emc1413", | 357 | +} |
| 384 | + .parent = TYPE_EMC141X, | 358 | + |
| 385 | + .class_init = emc1413_class_init, | 359 | +void aspeed_smc_test_erase_sector(const void *data) |
| 386 | +}; | 360 | +{ |
| 387 | + | 361 | + const AspeedSMCTestData *test_data = (const AspeedSMCTestData *)data; |
| 388 | +static const TypeInfo emc1414_info = { | 362 | + uint32_t some_page_addr = test_data->page_addr; |
| 389 | + .name = "emc1414", | 363 | + uint32_t page[FLASH_PAGE_SIZE / 4]; |
| 390 | + .parent = TYPE_EMC141X, | 364 | + int i; |
| 391 | + .class_init = emc1414_class_init, | 365 | + |
| 392 | +}; | 366 | + spi_conf(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); |
| 393 | + | 367 | + |
| 394 | +static void emc141x_register_types(void) | 368 | + /* |
| 395 | +{ | 369 | + * Previous page should be full of 0xffs after backend is |
| 396 | + type_register_static(&emc141x_info); | 370 | + * initialized |
| 397 | + type_register_static(&emc1413_info); | 371 | + */ |
| 398 | + type_register_static(&emc1414_info); | 372 | + read_page(test_data, some_page_addr - FLASH_PAGE_SIZE, page); |
| 399 | +} | 373 | + for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { |
| 400 | + | 374 | + g_assert_cmphex(page[i], ==, 0xffffffff); |
| 401 | +type_init(emc141x_register_types) | 375 | + } |
| 402 | diff --git a/tests/qtest/emc141x-test.c b/tests/qtest/emc141x-test.c | 376 | + |
| 403 | new file mode 100644 | 377 | + spi_ctrl_start_user(test_data); |
| 404 | index XXXXXXX..XXXXXXX | 378 | + flash_writeb(test_data, 0, EN_4BYTE_ADDR); |
| 405 | --- /dev/null | 379 | + flash_writeb(test_data, 0, WREN); |
| 406 | +++ b/tests/qtest/emc141x-test.c | 380 | + flash_writeb(test_data, 0, PP); |
| 381 | + flash_writel(test_data, 0, make_be32(some_page_addr)); | ||
| 382 | + | ||
| 383 | + /* Fill the page with its own addresses */ | ||
| 384 | + for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 385 | + flash_writel(test_data, 0, make_be32(some_page_addr + i * 4)); | ||
| 386 | + } | ||
| 387 | + spi_ctrl_stop_user(test_data); | ||
| 388 | + | ||
| 389 | + /* Check the page is correctly written */ | ||
| 390 | + read_page(test_data, some_page_addr, page); | ||
| 391 | + for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 392 | + g_assert_cmphex(page[i], ==, some_page_addr + i * 4); | ||
| 393 | + } | ||
| 394 | + | ||
| 395 | + spi_ctrl_start_user(test_data); | ||
| 396 | + flash_writeb(test_data, 0, WREN); | ||
| 397 | + flash_writeb(test_data, 0, EN_4BYTE_ADDR); | ||
| 398 | + flash_writeb(test_data, 0, ERASE_SECTOR); | ||
| 399 | + flash_writel(test_data, 0, make_be32(some_page_addr)); | ||
| 400 | + spi_ctrl_stop_user(test_data); | ||
| 401 | + | ||
| 402 | + /* Check the page is erased */ | ||
| 403 | + read_page(test_data, some_page_addr, page); | ||
| 404 | + for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 405 | + g_assert_cmphex(page[i], ==, 0xffffffff); | ||
| 406 | + } | ||
| 407 | + | ||
| 408 | + flash_reset(test_data); | ||
| 409 | +} | ||
| 410 | + | ||
| 411 | +void aspeed_smc_test_erase_all(const void *data) | ||
| 412 | +{ | ||
| 413 | + const AspeedSMCTestData *test_data = (const AspeedSMCTestData *)data; | ||
| 414 | + uint32_t some_page_addr = test_data->page_addr; | ||
| 415 | + uint32_t page[FLASH_PAGE_SIZE / 4]; | ||
| 416 | + int i; | ||
| 417 | + | ||
| 418 | + spi_conf(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 419 | + | ||
| 420 | + /* | ||
| 421 | + * Previous page should be full of 0xffs after backend is | ||
| 422 | + * initialized | ||
| 423 | + */ | ||
| 424 | + read_page(test_data, some_page_addr - FLASH_PAGE_SIZE, page); | ||
| 425 | + for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 426 | + g_assert_cmphex(page[i], ==, 0xffffffff); | ||
| 427 | + } | ||
| 428 | + | ||
| 429 | + spi_ctrl_start_user(test_data); | ||
| 430 | + flash_writeb(test_data, 0, EN_4BYTE_ADDR); | ||
| 431 | + flash_writeb(test_data, 0, WREN); | ||
| 432 | + flash_writeb(test_data, 0, PP); | ||
| 433 | + flash_writel(test_data, 0, make_be32(some_page_addr)); | ||
| 434 | + | ||
| 435 | + /* Fill the page with its own addresses */ | ||
| 436 | + for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 437 | + flash_writel(test_data, 0, make_be32(some_page_addr + i * 4)); | ||
| 438 | + } | ||
| 439 | + spi_ctrl_stop_user(test_data); | ||
| 440 | + | ||
| 441 | + /* Check the page is correctly written */ | ||
| 442 | + read_page(test_data, some_page_addr, page); | ||
| 443 | + for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 444 | + g_assert_cmphex(page[i], ==, some_page_addr + i * 4); | ||
| 445 | + } | ||
| 446 | + | ||
| 447 | + spi_ctrl_start_user(test_data); | ||
| 448 | + flash_writeb(test_data, 0, WREN); | ||
| 449 | + flash_writeb(test_data, 0, BULK_ERASE); | ||
| 450 | + spi_ctrl_stop_user(test_data); | ||
| 451 | + | ||
| 452 | + /* Check the page is erased */ | ||
| 453 | + read_page(test_data, some_page_addr, page); | ||
| 454 | + for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 455 | + g_assert_cmphex(page[i], ==, 0xffffffff); | ||
| 456 | + } | ||
| 457 | + | ||
| 458 | + flash_reset(test_data); | ||
| 459 | +} | ||
| 460 | + | ||
| 461 | +void aspeed_smc_test_write_page(const void *data) | ||
| 462 | +{ | ||
| 463 | + const AspeedSMCTestData *test_data = (const AspeedSMCTestData *)data; | ||
| 464 | + uint32_t my_page_addr = test_data->page_addr; | ||
| 465 | + uint32_t some_page_addr = my_page_addr + FLASH_PAGE_SIZE; | ||
| 466 | + uint32_t page[FLASH_PAGE_SIZE / 4]; | ||
| 467 | + int i; | ||
| 468 | + | ||
| 469 | + spi_conf(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 470 | + | ||
| 471 | + spi_ctrl_start_user(test_data); | ||
| 472 | + flash_writeb(test_data, 0, EN_4BYTE_ADDR); | ||
| 473 | + flash_writeb(test_data, 0, WREN); | ||
| 474 | + flash_writeb(test_data, 0, PP); | ||
| 475 | + flash_writel(test_data, 0, make_be32(my_page_addr)); | ||
| 476 | + | ||
| 477 | + /* Fill the page with its own addresses */ | ||
| 478 | + for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 479 | + flash_writel(test_data, 0, make_be32(my_page_addr + i * 4)); | ||
| 480 | + } | ||
| 481 | + spi_ctrl_stop_user(test_data); | ||
| 482 | + | ||
| 483 | + /* Check what was written */ | ||
| 484 | + read_page(test_data, my_page_addr, page); | ||
| 485 | + for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 486 | + g_assert_cmphex(page[i], ==, my_page_addr + i * 4); | ||
| 487 | + } | ||
| 488 | + | ||
| 489 | + /* Check some other page. It should be full of 0xff */ | ||
| 490 | + read_page(test_data, some_page_addr, page); | ||
| 491 | + for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 492 | + g_assert_cmphex(page[i], ==, 0xffffffff); | ||
| 493 | + } | ||
| 494 | + | ||
| 495 | + flash_reset(test_data); | ||
| 496 | +} | ||
| 497 | + | ||
| 498 | +void aspeed_smc_test_read_page_mem(const void *data) | ||
| 499 | +{ | ||
| 500 | + const AspeedSMCTestData *test_data = (const AspeedSMCTestData *)data; | ||
| 501 | + uint32_t my_page_addr = test_data->page_addr; | ||
| 502 | + uint32_t some_page_addr = my_page_addr + FLASH_PAGE_SIZE; | ||
| 503 | + uint32_t page[FLASH_PAGE_SIZE / 4]; | ||
| 504 | + int i; | ||
| 505 | + | ||
| 506 | + /* | ||
| 507 | + * Enable 4BYTE mode for controller. | ||
| 508 | + */ | ||
| 509 | + spi_ce_ctrl(test_data, 1 << (CRTL_EXTENDED0 + test_data->cs)); | ||
| 510 | + | ||
| 511 | + /* Enable 4BYTE mode for flash. */ | ||
| 512 | + spi_conf(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 513 | + spi_ctrl_start_user(test_data); | ||
| 514 | + flash_writeb(test_data, 0, EN_4BYTE_ADDR); | ||
| 515 | + flash_writeb(test_data, 0, WREN); | ||
| 516 | + flash_writeb(test_data, 0, PP); | ||
| 517 | + flash_writel(test_data, 0, make_be32(my_page_addr)); | ||
| 518 | + | ||
| 519 | + /* Fill the page with its own addresses */ | ||
| 520 | + for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 521 | + flash_writel(test_data, 0, make_be32(my_page_addr + i * 4)); | ||
| 522 | + } | ||
| 523 | + spi_ctrl_stop_user(test_data); | ||
| 524 | + spi_conf_remove(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 525 | + | ||
| 526 | + /* Check what was written */ | ||
| 527 | + read_page_mem(test_data, my_page_addr, page); | ||
| 528 | + for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 529 | + g_assert_cmphex(page[i], ==, my_page_addr + i * 4); | ||
| 530 | + } | ||
| 531 | + | ||
| 532 | + /* Check some other page. It should be full of 0xff */ | ||
| 533 | + read_page_mem(test_data, some_page_addr, page); | ||
| 534 | + for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 535 | + g_assert_cmphex(page[i], ==, 0xffffffff); | ||
| 536 | + } | ||
| 537 | + | ||
| 538 | + flash_reset(test_data); | ||
| 539 | +} | ||
| 540 | + | ||
| 541 | +void aspeed_smc_test_write_page_mem(const void *data) | ||
| 542 | +{ | ||
| 543 | + const AspeedSMCTestData *test_data = (const AspeedSMCTestData *)data; | ||
| 544 | + uint32_t my_page_addr = test_data->page_addr; | ||
| 545 | + uint32_t page[FLASH_PAGE_SIZE / 4]; | ||
| 546 | + int i; | ||
| 547 | + | ||
| 548 | + /* | ||
| 549 | + * Enable 4BYTE mode for controller. | ||
| 550 | + */ | ||
| 551 | + spi_ce_ctrl(test_data, 1 << (CRTL_EXTENDED0 + test_data->cs)); | ||
| 552 | + | ||
| 553 | + /* Enable 4BYTE mode for flash. */ | ||
| 554 | + spi_conf(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 555 | + spi_ctrl_start_user(test_data); | ||
| 556 | + flash_writeb(test_data, 0, EN_4BYTE_ADDR); | ||
| 557 | + flash_writeb(test_data, 0, WREN); | ||
| 558 | + spi_ctrl_stop_user(test_data); | ||
| 559 | + | ||
| 560 | + /* move out USER mode to use direct writes to the AHB bus */ | ||
| 561 | + spi_ctrl_setmode(test_data, CTRL_WRITEMODE, PP); | ||
| 562 | + | ||
| 563 | + for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 564 | + flash_writel(test_data, my_page_addr + i * 4, | ||
| 565 | + make_be32(my_page_addr + i * 4)); | ||
| 566 | + } | ||
| 567 | + | ||
| 568 | + /* Check what was written */ | ||
| 569 | + read_page_mem(test_data, my_page_addr, page); | ||
| 570 | + for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 571 | + g_assert_cmphex(page[i], ==, my_page_addr + i * 4); | ||
| 572 | + } | ||
| 573 | + | ||
| 574 | + flash_reset(test_data); | ||
| 575 | +} | ||
| 576 | + | ||
| 577 | +void aspeed_smc_test_read_status_reg(const void *data) | ||
| 578 | +{ | ||
| 579 | + const AspeedSMCTestData *test_data = (const AspeedSMCTestData *)data; | ||
| 580 | + uint8_t r; | ||
| 581 | + | ||
| 582 | + spi_conf(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 583 | + | ||
| 584 | + spi_ctrl_start_user(test_data); | ||
| 585 | + flash_writeb(test_data, 0, RDSR); | ||
| 586 | + r = flash_readb(test_data, 0); | ||
| 587 | + spi_ctrl_stop_user(test_data); | ||
| 588 | + | ||
| 589 | + g_assert_cmphex(r & SR_WEL, ==, 0); | ||
| 590 | + g_assert(!qtest_qom_get_bool | ||
| 591 | + (test_data->s, test_data->node, "write-enable")); | ||
| 592 | + | ||
| 593 | + spi_ctrl_start_user(test_data); | ||
| 594 | + flash_writeb(test_data, 0, WREN); | ||
| 595 | + flash_writeb(test_data, 0, RDSR); | ||
| 596 | + r = flash_readb(test_data, 0); | ||
| 597 | + spi_ctrl_stop_user(test_data); | ||
| 598 | + | ||
| 599 | + g_assert_cmphex(r & SR_WEL, ==, SR_WEL); | ||
| 600 | + g_assert(qtest_qom_get_bool | ||
| 601 | + (test_data->s, test_data->node, "write-enable")); | ||
| 602 | + | ||
| 603 | + spi_ctrl_start_user(test_data); | ||
| 604 | + flash_writeb(test_data, 0, WRDI); | ||
| 605 | + flash_writeb(test_data, 0, RDSR); | ||
| 606 | + r = flash_readb(test_data, 0); | ||
| 607 | + spi_ctrl_stop_user(test_data); | ||
| 608 | + | ||
| 609 | + g_assert_cmphex(r & SR_WEL, ==, 0); | ||
| 610 | + g_assert(!qtest_qom_get_bool | ||
| 611 | + (test_data->s, test_data->node, "write-enable")); | ||
| 612 | + | ||
| 613 | + flash_reset(test_data); | ||
| 614 | +} | ||
| 615 | + | ||
| 616 | +void aspeed_smc_test_status_reg_write_protection(const void *data) | ||
| 617 | +{ | ||
| 618 | + const AspeedSMCTestData *test_data = (const AspeedSMCTestData *)data; | ||
| 619 | + uint8_t r; | ||
| 620 | + | ||
| 621 | + spi_conf(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 622 | + | ||
| 623 | + /* default case: WP# is high and SRWD is low -> status register writable */ | ||
| 624 | + spi_ctrl_start_user(test_data); | ||
| 625 | + flash_writeb(test_data, 0, WREN); | ||
| 626 | + /* test ability to write SRWD */ | ||
| 627 | + flash_writeb(test_data, 0, WRSR); | ||
| 628 | + flash_writeb(test_data, 0, SRWD); | ||
| 629 | + flash_writeb(test_data, 0, RDSR); | ||
| 630 | + r = flash_readb(test_data, 0); | ||
| 631 | + spi_ctrl_stop_user(test_data); | ||
| 632 | + g_assert_cmphex(r & SRWD, ==, SRWD); | ||
| 633 | + | ||
| 634 | + /* WP# high and SRWD high -> status register writable */ | ||
| 635 | + spi_ctrl_start_user(test_data); | ||
| 636 | + flash_writeb(test_data, 0, WREN); | ||
| 637 | + /* test ability to write SRWD */ | ||
| 638 | + flash_writeb(test_data, 0, WRSR); | ||
| 639 | + flash_writeb(test_data, 0, 0); | ||
| 640 | + flash_writeb(test_data, 0, RDSR); | ||
| 641 | + r = flash_readb(test_data, 0); | ||
| 642 | + spi_ctrl_stop_user(test_data); | ||
| 643 | + g_assert_cmphex(r & SRWD, ==, 0); | ||
| 644 | + | ||
| 645 | + /* WP# low and SRWD low -> status register writable */ | ||
| 646 | + qtest_set_irq_in(test_data->s, test_data->node, "WP#", 0, 0); | ||
| 647 | + spi_ctrl_start_user(test_data); | ||
| 648 | + flash_writeb(test_data, 0, WREN); | ||
| 649 | + /* test ability to write SRWD */ | ||
| 650 | + flash_writeb(test_data, 0, WRSR); | ||
| 651 | + flash_writeb(test_data, 0, SRWD); | ||
| 652 | + flash_writeb(test_data, 0, RDSR); | ||
| 653 | + r = flash_readb(test_data, 0); | ||
| 654 | + spi_ctrl_stop_user(test_data); | ||
| 655 | + g_assert_cmphex(r & SRWD, ==, SRWD); | ||
| 656 | + | ||
| 657 | + /* WP# low and SRWD high -> status register NOT writable */ | ||
| 658 | + spi_ctrl_start_user(test_data); | ||
| 659 | + flash_writeb(test_data, 0 , WREN); | ||
| 660 | + /* test ability to write SRWD */ | ||
| 661 | + flash_writeb(test_data, 0, WRSR); | ||
| 662 | + flash_writeb(test_data, 0, 0); | ||
| 663 | + flash_writeb(test_data, 0, RDSR); | ||
| 664 | + r = flash_readb(test_data, 0); | ||
| 665 | + spi_ctrl_stop_user(test_data); | ||
| 666 | + /* write is not successful */ | ||
| 667 | + g_assert_cmphex(r & SRWD, ==, SRWD); | ||
| 668 | + | ||
| 669 | + qtest_set_irq_in(test_data->s, test_data->node, "WP#", 0, 1); | ||
| 670 | + flash_reset(test_data); | ||
| 671 | +} | ||
| 672 | + | ||
| 673 | +void aspeed_smc_test_write_block_protect(const void *data) | ||
| 674 | +{ | ||
| 675 | + const AspeedSMCTestData *test_data = (const AspeedSMCTestData *)data; | ||
| 676 | + uint32_t sector_size = 65536; | ||
| 677 | + uint32_t n_sectors = 512; | ||
| 678 | + | ||
| 679 | + spi_ce_ctrl(test_data, 1 << (CRTL_EXTENDED0 + test_data->cs)); | ||
| 680 | + spi_conf(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 681 | + | ||
| 682 | + uint32_t bp_bits = 0b0; | ||
| 683 | + | ||
| 684 | + for (int i = 0; i < 16; i++) { | ||
| 685 | + bp_bits = ((i & 0b1000) << 3) | ((i & 0b0111) << 2); | ||
| 686 | + | ||
| 687 | + spi_ctrl_start_user(test_data); | ||
| 688 | + flash_writeb(test_data, 0, WREN); | ||
| 689 | + flash_writeb(test_data, 0, BULK_ERASE); | ||
| 690 | + flash_writeb(test_data, 0, WREN); | ||
| 691 | + flash_writeb(test_data, 0, WRSR); | ||
| 692 | + flash_writeb(test_data, 0, bp_bits); | ||
| 693 | + flash_writeb(test_data, 0, EN_4BYTE_ADDR); | ||
| 694 | + flash_writeb(test_data, 0, WREN); | ||
| 695 | + spi_ctrl_stop_user(test_data); | ||
| 696 | + | ||
| 697 | + uint32_t num_protected_sectors = i ? MIN(1 << (i - 1), n_sectors) : 0; | ||
| 698 | + uint32_t protection_start = n_sectors - num_protected_sectors; | ||
| 699 | + uint32_t protection_end = n_sectors; | ||
| 700 | + | ||
| 701 | + for (int sector = 0; sector < n_sectors; sector++) { | ||
| 702 | + uint32_t addr = sector * sector_size; | ||
| 703 | + | ||
| 704 | + assert_page_mem(test_data, addr, 0xffffffff); | ||
| 705 | + write_page_mem(test_data, addr, make_be32(0xabcdef12)); | ||
| 706 | + | ||
| 707 | + uint32_t expected_value = protection_start <= sector | ||
| 708 | + && sector < protection_end | ||
| 709 | + ? 0xffffffff : 0xabcdef12; | ||
| 710 | + | ||
| 711 | + assert_page_mem(test_data, addr, expected_value); | ||
| 712 | + } | ||
| 713 | + } | ||
| 714 | + | ||
| 715 | + flash_reset(test_data); | ||
| 716 | +} | ||
| 717 | + | ||
| 718 | +void aspeed_smc_test_write_block_protect_bottom_bit(const void *data) | ||
| 719 | +{ | ||
| 720 | + const AspeedSMCTestData *test_data = (const AspeedSMCTestData *)data; | ||
| 721 | + uint32_t sector_size = 65536; | ||
| 722 | + uint32_t n_sectors = 512; | ||
| 723 | + | ||
| 724 | + spi_ce_ctrl(test_data, 1 << (CRTL_EXTENDED0 + test_data->cs)); | ||
| 725 | + spi_conf(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 726 | + | ||
| 727 | + /* top bottom bit is enabled */ | ||
| 728 | + uint32_t bp_bits = 0b00100 << 3; | ||
| 729 | + | ||
| 730 | + for (int i = 0; i < 16; i++) { | ||
| 731 | + bp_bits = (((i & 0b1000) | 0b0100) << 3) | ((i & 0b0111) << 2); | ||
| 732 | + | ||
| 733 | + spi_ctrl_start_user(test_data); | ||
| 734 | + flash_writeb(test_data, 0, WREN); | ||
| 735 | + flash_writeb(test_data, 0, BULK_ERASE); | ||
| 736 | + flash_writeb(test_data, 0, WREN); | ||
| 737 | + flash_writeb(test_data, 0, WRSR); | ||
| 738 | + flash_writeb(test_data, 0, bp_bits); | ||
| 739 | + flash_writeb(test_data, 0, EN_4BYTE_ADDR); | ||
| 740 | + flash_writeb(test_data, 0, WREN); | ||
| 741 | + spi_ctrl_stop_user(test_data); | ||
| 742 | + | ||
| 743 | + uint32_t num_protected_sectors = i ? MIN(1 << (i - 1), n_sectors) : 0; | ||
| 744 | + uint32_t protection_start = 0; | ||
| 745 | + uint32_t protection_end = num_protected_sectors; | ||
| 746 | + | ||
| 747 | + for (int sector = 0; sector < n_sectors; sector++) { | ||
| 748 | + uint32_t addr = sector * sector_size; | ||
| 749 | + | ||
| 750 | + assert_page_mem(test_data, addr, 0xffffffff); | ||
| 751 | + write_page_mem(test_data, addr, make_be32(0xabcdef12)); | ||
| 752 | + | ||
| 753 | + uint32_t expected_value = protection_start <= sector | ||
| 754 | + && sector < protection_end | ||
| 755 | + ? 0xffffffff : 0xabcdef12; | ||
| 756 | + | ||
| 757 | + assert_page_mem(test_data, addr, expected_value); | ||
| 758 | + } | ||
| 759 | + } | ||
| 760 | + | ||
| 761 | + flash_reset(test_data); | ||
| 762 | +} | ||
| 763 | + | ||
| 764 | +void aspeed_smc_test_write_page_qpi(const void *data) | ||
| 765 | +{ | ||
| 766 | + const AspeedSMCTestData *test_data = (const AspeedSMCTestData *)data; | ||
| 767 | + uint32_t my_page_addr = test_data->page_addr; | ||
| 768 | + uint32_t some_page_addr = my_page_addr + FLASH_PAGE_SIZE; | ||
| 769 | + uint32_t page[FLASH_PAGE_SIZE / 4]; | ||
| 770 | + uint32_t page_pattern[] = { | ||
| 771 | + 0xebd8c134, 0x5da196bc, 0xae15e729, 0x5085ccdf | ||
| 772 | + }; | ||
| 773 | + int i; | ||
| 774 | + | ||
| 775 | + spi_conf(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 776 | + | ||
| 777 | + spi_ctrl_start_user(test_data); | ||
| 778 | + flash_writeb(test_data, 0, EN_4BYTE_ADDR); | ||
| 779 | + flash_writeb(test_data, 0, WREN); | ||
| 780 | + flash_writeb(test_data, 0, PP); | ||
| 781 | + flash_writel(test_data, 0, make_be32(my_page_addr)); | ||
| 782 | + | ||
| 783 | + /* Set QPI mode */ | ||
| 784 | + spi_ctrl_set_io_mode(test_data, CTRL_IO_QUAD_IO); | ||
| 785 | + | ||
| 786 | + /* Fill the page pattern */ | ||
| 787 | + for (i = 0; i < ARRAY_SIZE(page_pattern); i++) { | ||
| 788 | + flash_writel(test_data, 0, make_be32(page_pattern[i])); | ||
| 789 | + } | ||
| 790 | + | ||
| 791 | + /* Fill the page with its own addresses */ | ||
| 792 | + for (; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 793 | + flash_writel(test_data, 0, make_be32(my_page_addr + i * 4)); | ||
| 794 | + } | ||
| 795 | + | ||
| 796 | + /* Restore io mode */ | ||
| 797 | + spi_ctrl_set_io_mode(test_data, 0); | ||
| 798 | + spi_ctrl_stop_user(test_data); | ||
| 799 | + | ||
| 800 | + /* Check what was written */ | ||
| 801 | + read_page(test_data, my_page_addr, page); | ||
| 802 | + for (i = 0; i < ARRAY_SIZE(page_pattern); i++) { | ||
| 803 | + g_assert_cmphex(page[i], ==, page_pattern[i]); | ||
| 804 | + } | ||
| 805 | + for (; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 806 | + g_assert_cmphex(page[i], ==, my_page_addr + i * 4); | ||
| 807 | + } | ||
| 808 | + | ||
| 809 | + /* Check some other page. It should be full of 0xff */ | ||
| 810 | + read_page(test_data, some_page_addr, page); | ||
| 811 | + for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 812 | + g_assert_cmphex(page[i], ==, 0xffffffff); | ||
| 813 | + } | ||
| 814 | + | ||
| 815 | + flash_reset(test_data); | ||
| 816 | +} | ||
| 817 | + | ||
| 818 | diff --git a/tests/qtest/aspeed_smc-test.c b/tests/qtest/aspeed_smc-test.c | ||
| 819 | index XXXXXXX..XXXXXXX 100644 | ||
| 820 | --- a/tests/qtest/aspeed_smc-test.c | ||
| 821 | +++ b/tests/qtest/aspeed_smc-test.c | ||
| 407 | @@ -XXX,XX +XXX,XX @@ | 822 | @@ -XXX,XX +XXX,XX @@ |
| 408 | +/* | 823 | #include "qemu/bswap.h" |
| 409 | + * QTest testcase for the EMC141X temperature sensor | 824 | #include "libqtest-single.h" |
| 410 | + * | 825 | #include "qemu/bitops.h" |
| 411 | + * This work is licensed under the terms of the GNU GPL, version 2 or later. | 826 | +#include "aspeed-smc-utils.h" |
| 412 | + * See the COPYING file in the top-level directory. | 827 | |
| 413 | + */ | 828 | -/* |
| 414 | + | 829 | - * ASPEED SPI Controller registers |
| 415 | +#include "qemu/osdep.h" | 830 | - */ |
| 416 | + | 831 | -#define R_CONF 0x00 |
| 417 | +#include "libqtest-single.h" | 832 | -#define CONF_ENABLE_W0 16 |
| 418 | +#include "libqos/qgraph.h" | 833 | -#define R_CE_CTRL 0x04 |
| 419 | +#include "libqos/i2c.h" | 834 | -#define CRTL_EXTENDED0 0 /* 32 bit addressing for SPI */ |
| 420 | +#include "qapi/qmp/qdict.h" | 835 | -#define R_CTRL0 0x10 |
| 421 | +#include "hw/misc/emc141x_regs.h" | 836 | -#define CTRL_IO_QUAD_IO BIT(31) |
| 422 | + | 837 | -#define CTRL_CE_STOP_ACTIVE BIT(2) |
| 423 | +#define EMC1414_TEST_ID "emc1414-test" | 838 | -#define CTRL_READMODE 0x0 |
| 424 | + | 839 | -#define CTRL_FREADMODE 0x1 |
| 425 | +static int qmp_emc1414_get_temperature(const char *id) | 840 | -#define CTRL_WRITEMODE 0x2 |
| 426 | +{ | 841 | -#define CTRL_USERMODE 0x3 |
| 427 | + QDict *response; | 842 | -#define SR_WEL BIT(1) |
| 428 | + int ret; | 843 | - |
| 429 | + | 844 | -/* |
| 430 | + response = qmp("{ 'execute': 'qom-get', 'arguments': { 'path': %s, " | 845 | - * Flash commands |
| 431 | + "'property': 'temperature0' } }", id); | 846 | - */ |
| 432 | + g_assert(qdict_haskey(response, "return")); | 847 | -enum { |
| 433 | + ret = qdict_get_int(response, "return"); | 848 | - JEDEC_READ = 0x9f, |
| 434 | + qobject_unref(response); | 849 | - RDSR = 0x5, |
| 435 | + return ret; | 850 | - WRDI = 0x4, |
| 436 | +} | 851 | - BULK_ERASE = 0xc7, |
| 437 | + | 852 | - READ = 0x03, |
| 438 | +static void qmp_emc1414_set_temperature(const char *id, int value) | 853 | - PP = 0x02, |
| 439 | +{ | 854 | - WRSR = 0x1, |
| 440 | + QDict *response; | 855 | - WREN = 0x6, |
| 441 | + | 856 | - SRWD = 0x80, |
| 442 | + response = qmp("{ 'execute': 'qom-set', 'arguments': { 'path': %s, " | 857 | - RESET_ENABLE = 0x66, |
| 443 | + "'property': 'temperature0', 'value': %d } }", id, value); | 858 | - RESET_MEMORY = 0x99, |
| 444 | + g_assert(qdict_haskey(response, "return")); | 859 | - EN_4BYTE_ADDR = 0xB7, |
| 445 | + qobject_unref(response); | 860 | - ERASE_SECTOR = 0xd8, |
| 446 | +} | 861 | -}; |
| 447 | + | 862 | - |
| 448 | +static void send_and_receive(void *obj, void *data, QGuestAllocator *alloc) | 863 | -#define CTRL_IO_MODE_MASK (BIT(31) | BIT(30) | BIT(29) | BIT(28)) |
| 449 | +{ | 864 | -#define FLASH_PAGE_SIZE 256 |
| 450 | + uint16_t value; | 865 | - |
| 451 | + QI2CDevice *i2cdev = (QI2CDevice *)obj; | 866 | -typedef struct TestData { |
| 452 | + | 867 | - QTestState *s; |
| 453 | + value = qmp_emc1414_get_temperature(EMC1414_TEST_ID); | 868 | - uint64_t spi_base; |
| 454 | + g_assert_cmpuint(value, ==, 0); | 869 | - uint64_t flash_base; |
| 455 | + | 870 | - uint32_t jedec_id; |
| 456 | + value = i2c_get8(i2cdev, EMC141X_TEMP_HIGH0); | 871 | - char *tmp_path; |
| 457 | + g_assert_cmphex(value, ==, 0); | 872 | - uint8_t cs; |
| 458 | + | 873 | - const char *node; |
| 459 | + /* The default max value is 85C, 0x55=85 */ | 874 | - uint32_t page_addr; |
| 460 | + value = i2c_get8(i2cdev, EMC141X_TEMP_MAX_HIGH0); | 875 | -} TestData; |
| 461 | + g_assert_cmphex(value, ==, 0x55); | 876 | - |
| 462 | + | 877 | -/* |
| 463 | + value = i2c_get8(i2cdev, EMC141X_TEMP_MIN_HIGH0); | 878 | - * Use an explicit bswap for the values read/wrote to the flash region |
| 464 | + g_assert_cmphex(value, ==, 0); | 879 | - * as they are BE and the Aspeed CPU is LE. |
| 465 | + | 880 | - */ |
| 466 | + /* 3000mc = 30C */ | 881 | -static inline uint32_t make_be32(uint32_t data) |
| 467 | + qmp_emc1414_set_temperature(EMC1414_TEST_ID, 30000); | 882 | -{ |
| 468 | + value = qmp_emc1414_get_temperature(EMC1414_TEST_ID); | 883 | - return bswap32(data); |
| 469 | + g_assert_cmpuint(value, ==, 30000); | 884 | -} |
| 470 | + | 885 | - |
| 471 | + value = i2c_get8(i2cdev, EMC141X_TEMP_HIGH0); | 886 | -static inline void spi_writel(const TestData *data, uint64_t offset, |
| 472 | + g_assert_cmphex(value, ==, 30); | 887 | - uint32_t value) |
| 473 | + | 888 | -{ |
| 474 | +} | 889 | - qtest_writel(data->s, data->spi_base + offset, value); |
| 475 | + | 890 | -} |
| 476 | +static void emc1414_register_nodes(void) | 891 | - |
| 477 | +{ | 892 | -static inline uint32_t spi_readl(const TestData *data, uint64_t offset) |
| 478 | + QOSGraphEdgeOptions opts = { | 893 | -{ |
| 479 | + .extra_device_opts = "id=" EMC1414_TEST_ID ",address=0x70" | 894 | - return qtest_readl(data->s, data->spi_base + offset); |
| 480 | + }; | 895 | -} |
| 481 | + add_qi2c_address(&opts, &(QI2CAddress) { 0x70 }); | 896 | - |
| 482 | + | 897 | -static inline void flash_writeb(const TestData *data, uint64_t offset, |
| 483 | + qos_node_create_driver("emc1414", i2c_device_create); | 898 | - uint8_t value) |
| 484 | + qos_node_consumes("emc1414", "i2c-bus", &opts); | 899 | -{ |
| 485 | + | 900 | - qtest_writeb(data->s, data->flash_base + offset, value); |
| 486 | + qos_add_test("tx-rx", "emc1414", send_and_receive, NULL); | 901 | -} |
| 487 | +} | 902 | - |
| 488 | +libqos_init(emc1414_register_nodes); | 903 | -static inline void flash_writel(const TestData *data, uint64_t offset, |
| 489 | diff --git a/hw/arm/Kconfig b/hw/arm/Kconfig | 904 | - uint32_t value) |
| 490 | index XXXXXXX..XXXXXXX 100644 | 905 | -{ |
| 491 | --- a/hw/arm/Kconfig | 906 | - qtest_writel(data->s, data->flash_base + offset, value); |
| 492 | +++ b/hw/arm/Kconfig | 907 | -} |
| 493 | @@ -XXX,XX +XXX,XX @@ config ASPEED_SOC | 908 | - |
| 494 | select SSI_M25P80 | 909 | -static inline uint8_t flash_readb(const TestData *data, uint64_t offset) |
| 495 | select TMP105 | 910 | -{ |
| 496 | select TMP421 | 911 | - return qtest_readb(data->s, data->flash_base + offset); |
| 497 | + select EMC141X | 912 | -} |
| 498 | select UNIMP | 913 | - |
| 499 | select LED | 914 | -static inline uint32_t flash_readl(const TestData *data, uint64_t offset) |
| 500 | 915 | -{ | |
| 501 | diff --git a/hw/misc/Kconfig b/hw/misc/Kconfig | 916 | - return qtest_readl(data->s, data->flash_base + offset); |
| 502 | index XXXXXXX..XXXXXXX 100644 | 917 | -} |
| 503 | --- a/hw/misc/Kconfig | 918 | - |
| 504 | +++ b/hw/misc/Kconfig | 919 | -static void spi_conf(const TestData *data, uint32_t value) |
| 505 | @@ -XXX,XX +XXX,XX @@ config TMP421 | 920 | -{ |
| 506 | bool | 921 | - uint32_t conf = spi_readl(data, R_CONF); |
| 507 | depends on I2C | 922 | - |
| 508 | 923 | - conf |= value; | |
| 509 | +config EMC141X | 924 | - spi_writel(data, R_CONF, conf); |
| 510 | + bool | 925 | -} |
| 511 | + depends on I2C | 926 | - |
| 512 | + | 927 | -static void spi_conf_remove(const TestData *data, uint32_t value) |
| 513 | config ISA_DEBUG | 928 | -{ |
| 514 | bool | 929 | - uint32_t conf = spi_readl(data, R_CONF); |
| 515 | depends on ISA_BUS | 930 | - |
| 516 | diff --git a/hw/misc/meson.build b/hw/misc/meson.build | 931 | - conf &= ~value; |
| 517 | index XXXXXXX..XXXXXXX 100644 | 932 | - spi_writel(data, R_CONF, conf); |
| 518 | --- a/hw/misc/meson.build | 933 | -} |
| 519 | +++ b/hw/misc/meson.build | 934 | - |
| 520 | @@ -XXX,XX +XXX,XX @@ softmmu_ss.add(when: 'CONFIG_PCI_TESTDEV', if_true: files('pci-testdev.c')) | 935 | -static void spi_ce_ctrl(const TestData *data, uint32_t value) |
| 521 | softmmu_ss.add(when: 'CONFIG_SGA', if_true: files('sga.c')) | 936 | -{ |
| 522 | softmmu_ss.add(when: 'CONFIG_TMP105', if_true: files('tmp105.c')) | 937 | - uint32_t conf = spi_readl(data, R_CE_CTRL); |
| 523 | softmmu_ss.add(when: 'CONFIG_TMP421', if_true: files('tmp421.c')) | 938 | - |
| 524 | +softmmu_ss.add(when: 'CONFIG_EMC141X', if_true: files('emc141x.c')) | 939 | - conf |= value; |
| 525 | softmmu_ss.add(when: 'CONFIG_UNIMP', if_true: files('unimp.c')) | 940 | - spi_writel(data, R_CE_CTRL, conf); |
| 526 | softmmu_ss.add(when: 'CONFIG_EMPTY_SLOT', if_true: files('empty_slot.c')) | 941 | -} |
| 527 | softmmu_ss.add(when: 'CONFIG_LED', if_true: files('led.c')) | 942 | - |
| 943 | -static void spi_ctrl_setmode(const TestData *data, uint8_t mode, uint8_t cmd) | ||
| 944 | -{ | ||
| 945 | - uint32_t ctrl_reg = R_CTRL0 + data->cs * 4; | ||
| 946 | - uint32_t ctrl = spi_readl(data, ctrl_reg); | ||
| 947 | - ctrl &= ~(CTRL_USERMODE | 0xff << 16); | ||
| 948 | - ctrl |= mode | (cmd << 16); | ||
| 949 | - spi_writel(data, ctrl_reg, ctrl); | ||
| 950 | -} | ||
| 951 | - | ||
| 952 | -static void spi_ctrl_start_user(const TestData *data) | ||
| 953 | -{ | ||
| 954 | - uint32_t ctrl_reg = R_CTRL0 + data->cs * 4; | ||
| 955 | - uint32_t ctrl = spi_readl(data, ctrl_reg); | ||
| 956 | - | ||
| 957 | - ctrl |= CTRL_USERMODE | CTRL_CE_STOP_ACTIVE; | ||
| 958 | - spi_writel(data, ctrl_reg, ctrl); | ||
| 959 | - | ||
| 960 | - ctrl &= ~CTRL_CE_STOP_ACTIVE; | ||
| 961 | - spi_writel(data, ctrl_reg, ctrl); | ||
| 962 | -} | ||
| 963 | - | ||
| 964 | -static void spi_ctrl_stop_user(const TestData *data) | ||
| 965 | -{ | ||
| 966 | - uint32_t ctrl_reg = R_CTRL0 + data->cs * 4; | ||
| 967 | - uint32_t ctrl = spi_readl(data, ctrl_reg); | ||
| 968 | - | ||
| 969 | - ctrl |= CTRL_USERMODE | CTRL_CE_STOP_ACTIVE; | ||
| 970 | - spi_writel(data, ctrl_reg, ctrl); | ||
| 971 | -} | ||
| 972 | - | ||
| 973 | -static void spi_ctrl_set_io_mode(const TestData *data, uint32_t value) | ||
| 974 | -{ | ||
| 975 | - uint32_t ctrl_reg = R_CTRL0 + data->cs * 4; | ||
| 976 | - uint32_t ctrl = spi_readl(data, ctrl_reg); | ||
| 977 | - uint32_t mode; | ||
| 978 | - | ||
| 979 | - mode = value & CTRL_IO_MODE_MASK; | ||
| 980 | - ctrl &= ~CTRL_IO_MODE_MASK; | ||
| 981 | - ctrl |= mode; | ||
| 982 | - spi_writel(data, ctrl_reg, ctrl); | ||
| 983 | -} | ||
| 984 | - | ||
| 985 | -static void flash_reset(const TestData *data) | ||
| 986 | -{ | ||
| 987 | - spi_conf(data, 1 << (CONF_ENABLE_W0 + data->cs)); | ||
| 988 | - | ||
| 989 | - spi_ctrl_start_user(data); | ||
| 990 | - flash_writeb(data, 0, RESET_ENABLE); | ||
| 991 | - flash_writeb(data, 0, RESET_MEMORY); | ||
| 992 | - flash_writeb(data, 0, WREN); | ||
| 993 | - flash_writeb(data, 0, BULK_ERASE); | ||
| 994 | - flash_writeb(data, 0, WRDI); | ||
| 995 | - spi_ctrl_stop_user(data); | ||
| 996 | - | ||
| 997 | - spi_conf_remove(data, 1 << (CONF_ENABLE_W0 + data->cs)); | ||
| 998 | -} | ||
| 999 | - | ||
| 1000 | -static void test_read_jedec(const void *data) | ||
| 1001 | -{ | ||
| 1002 | - const TestData *test_data = (const TestData *)data; | ||
| 1003 | - uint32_t jedec = 0x0; | ||
| 1004 | - | ||
| 1005 | - spi_conf(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 1006 | - | ||
| 1007 | - spi_ctrl_start_user(test_data); | ||
| 1008 | - flash_writeb(test_data, 0, JEDEC_READ); | ||
| 1009 | - jedec |= flash_readb(test_data, 0) << 16; | ||
| 1010 | - jedec |= flash_readb(test_data, 0) << 8; | ||
| 1011 | - jedec |= flash_readb(test_data, 0); | ||
| 1012 | - spi_ctrl_stop_user(test_data); | ||
| 1013 | - | ||
| 1014 | - flash_reset(test_data); | ||
| 1015 | - | ||
| 1016 | - g_assert_cmphex(jedec, ==, test_data->jedec_id); | ||
| 1017 | -} | ||
| 1018 | - | ||
| 1019 | -static void read_page(const TestData *data, uint32_t addr, uint32_t *page) | ||
| 1020 | -{ | ||
| 1021 | - int i; | ||
| 1022 | - | ||
| 1023 | - spi_ctrl_start_user(data); | ||
| 1024 | - | ||
| 1025 | - flash_writeb(data, 0, EN_4BYTE_ADDR); | ||
| 1026 | - flash_writeb(data, 0, READ); | ||
| 1027 | - flash_writel(data, 0, make_be32(addr)); | ||
| 1028 | - | ||
| 1029 | - /* Continuous read are supported */ | ||
| 1030 | - for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 1031 | - page[i] = make_be32(flash_readl(data, 0)); | ||
| 1032 | - } | ||
| 1033 | - spi_ctrl_stop_user(data); | ||
| 1034 | -} | ||
| 1035 | - | ||
| 1036 | -static void read_page_mem(const TestData *data, uint32_t addr, uint32_t *page) | ||
| 1037 | -{ | ||
| 1038 | - int i; | ||
| 1039 | - | ||
| 1040 | - /* move out USER mode to use direct reads from the AHB bus */ | ||
| 1041 | - spi_ctrl_setmode(data, CTRL_READMODE, READ); | ||
| 1042 | - | ||
| 1043 | - for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 1044 | - page[i] = make_be32(flash_readl(data, addr + i * 4)); | ||
| 1045 | - } | ||
| 1046 | -} | ||
| 1047 | - | ||
| 1048 | -static void write_page_mem(const TestData *data, uint32_t addr, | ||
| 1049 | - uint32_t write_value) | ||
| 1050 | -{ | ||
| 1051 | - spi_ctrl_setmode(data, CTRL_WRITEMODE, PP); | ||
| 1052 | - | ||
| 1053 | - for (int i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 1054 | - flash_writel(data, addr + i * 4, write_value); | ||
| 1055 | - } | ||
| 1056 | -} | ||
| 1057 | - | ||
| 1058 | -static void assert_page_mem(const TestData *data, uint32_t addr, | ||
| 1059 | - uint32_t expected_value) | ||
| 1060 | -{ | ||
| 1061 | - uint32_t page[FLASH_PAGE_SIZE / 4]; | ||
| 1062 | - read_page_mem(data, addr, page); | ||
| 1063 | - for (int i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 1064 | - g_assert_cmphex(page[i], ==, expected_value); | ||
| 1065 | - } | ||
| 1066 | -} | ||
| 1067 | - | ||
| 1068 | -static void test_erase_sector(const void *data) | ||
| 1069 | -{ | ||
| 1070 | - const TestData *test_data = (const TestData *)data; | ||
| 1071 | - uint32_t some_page_addr = test_data->page_addr; | ||
| 1072 | - uint32_t page[FLASH_PAGE_SIZE / 4]; | ||
| 1073 | - int i; | ||
| 1074 | - | ||
| 1075 | - spi_conf(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 1076 | - | ||
| 1077 | - /* | ||
| 1078 | - * Previous page should be full of 0xffs after backend is | ||
| 1079 | - * initialized | ||
| 1080 | - */ | ||
| 1081 | - read_page(test_data, some_page_addr - FLASH_PAGE_SIZE, page); | ||
| 1082 | - for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 1083 | - g_assert_cmphex(page[i], ==, 0xffffffff); | ||
| 1084 | - } | ||
| 1085 | - | ||
| 1086 | - spi_ctrl_start_user(test_data); | ||
| 1087 | - flash_writeb(test_data, 0, EN_4BYTE_ADDR); | ||
| 1088 | - flash_writeb(test_data, 0, WREN); | ||
| 1089 | - flash_writeb(test_data, 0, PP); | ||
| 1090 | - flash_writel(test_data, 0, make_be32(some_page_addr)); | ||
| 1091 | - | ||
| 1092 | - /* Fill the page with its own addresses */ | ||
| 1093 | - for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 1094 | - flash_writel(test_data, 0, make_be32(some_page_addr + i * 4)); | ||
| 1095 | - } | ||
| 1096 | - spi_ctrl_stop_user(test_data); | ||
| 1097 | - | ||
| 1098 | - /* Check the page is correctly written */ | ||
| 1099 | - read_page(test_data, some_page_addr, page); | ||
| 1100 | - for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 1101 | - g_assert_cmphex(page[i], ==, some_page_addr + i * 4); | ||
| 1102 | - } | ||
| 1103 | - | ||
| 1104 | - spi_ctrl_start_user(test_data); | ||
| 1105 | - flash_writeb(test_data, 0, WREN); | ||
| 1106 | - flash_writeb(test_data, 0, EN_4BYTE_ADDR); | ||
| 1107 | - flash_writeb(test_data, 0, ERASE_SECTOR); | ||
| 1108 | - flash_writel(test_data, 0, make_be32(some_page_addr)); | ||
| 1109 | - spi_ctrl_stop_user(test_data); | ||
| 1110 | - | ||
| 1111 | - /* Check the page is erased */ | ||
| 1112 | - read_page(test_data, some_page_addr, page); | ||
| 1113 | - for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 1114 | - g_assert_cmphex(page[i], ==, 0xffffffff); | ||
| 1115 | - } | ||
| 1116 | - | ||
| 1117 | - flash_reset(test_data); | ||
| 1118 | -} | ||
| 1119 | - | ||
| 1120 | -static void test_erase_all(const void *data) | ||
| 1121 | -{ | ||
| 1122 | - const TestData *test_data = (const TestData *)data; | ||
| 1123 | - uint32_t some_page_addr = test_data->page_addr; | ||
| 1124 | - uint32_t page[FLASH_PAGE_SIZE / 4]; | ||
| 1125 | - int i; | ||
| 1126 | - | ||
| 1127 | - spi_conf(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 1128 | - | ||
| 1129 | - /* | ||
| 1130 | - * Previous page should be full of 0xffs after backend is | ||
| 1131 | - * initialized | ||
| 1132 | - */ | ||
| 1133 | - read_page(test_data, some_page_addr - FLASH_PAGE_SIZE, page); | ||
| 1134 | - for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 1135 | - g_assert_cmphex(page[i], ==, 0xffffffff); | ||
| 1136 | - } | ||
| 1137 | - | ||
| 1138 | - spi_ctrl_start_user(test_data); | ||
| 1139 | - flash_writeb(test_data, 0, EN_4BYTE_ADDR); | ||
| 1140 | - flash_writeb(test_data, 0, WREN); | ||
| 1141 | - flash_writeb(test_data, 0, PP); | ||
| 1142 | - flash_writel(test_data, 0, make_be32(some_page_addr)); | ||
| 1143 | - | ||
| 1144 | - /* Fill the page with its own addresses */ | ||
| 1145 | - for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 1146 | - flash_writel(test_data, 0, make_be32(some_page_addr + i * 4)); | ||
| 1147 | - } | ||
| 1148 | - spi_ctrl_stop_user(test_data); | ||
| 1149 | - | ||
| 1150 | - /* Check the page is correctly written */ | ||
| 1151 | - read_page(test_data, some_page_addr, page); | ||
| 1152 | - for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 1153 | - g_assert_cmphex(page[i], ==, some_page_addr + i * 4); | ||
| 1154 | - } | ||
| 1155 | - | ||
| 1156 | - spi_ctrl_start_user(test_data); | ||
| 1157 | - flash_writeb(test_data, 0, WREN); | ||
| 1158 | - flash_writeb(test_data, 0, BULK_ERASE); | ||
| 1159 | - spi_ctrl_stop_user(test_data); | ||
| 1160 | - | ||
| 1161 | - /* Check the page is erased */ | ||
| 1162 | - read_page(test_data, some_page_addr, page); | ||
| 1163 | - for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 1164 | - g_assert_cmphex(page[i], ==, 0xffffffff); | ||
| 1165 | - } | ||
| 1166 | - | ||
| 1167 | - flash_reset(test_data); | ||
| 1168 | -} | ||
| 1169 | - | ||
| 1170 | -static void test_write_page(const void *data) | ||
| 1171 | -{ | ||
| 1172 | - const TestData *test_data = (const TestData *)data; | ||
| 1173 | - uint32_t my_page_addr = test_data->page_addr; | ||
| 1174 | - uint32_t some_page_addr = my_page_addr + FLASH_PAGE_SIZE; | ||
| 1175 | - uint32_t page[FLASH_PAGE_SIZE / 4]; | ||
| 1176 | - int i; | ||
| 1177 | - | ||
| 1178 | - spi_conf(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 1179 | - | ||
| 1180 | - spi_ctrl_start_user(test_data); | ||
| 1181 | - flash_writeb(test_data, 0, EN_4BYTE_ADDR); | ||
| 1182 | - flash_writeb(test_data, 0, WREN); | ||
| 1183 | - flash_writeb(test_data, 0, PP); | ||
| 1184 | - flash_writel(test_data, 0, make_be32(my_page_addr)); | ||
| 1185 | - | ||
| 1186 | - /* Fill the page with its own addresses */ | ||
| 1187 | - for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 1188 | - flash_writel(test_data, 0, make_be32(my_page_addr + i * 4)); | ||
| 1189 | - } | ||
| 1190 | - spi_ctrl_stop_user(test_data); | ||
| 1191 | - | ||
| 1192 | - /* Check what was written */ | ||
| 1193 | - read_page(test_data, my_page_addr, page); | ||
| 1194 | - for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 1195 | - g_assert_cmphex(page[i], ==, my_page_addr + i * 4); | ||
| 1196 | - } | ||
| 1197 | - | ||
| 1198 | - /* Check some other page. It should be full of 0xff */ | ||
| 1199 | - read_page(test_data, some_page_addr, page); | ||
| 1200 | - for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 1201 | - g_assert_cmphex(page[i], ==, 0xffffffff); | ||
| 1202 | - } | ||
| 1203 | - | ||
| 1204 | - flash_reset(test_data); | ||
| 1205 | -} | ||
| 1206 | - | ||
| 1207 | -static void test_read_page_mem(const void *data) | ||
| 1208 | -{ | ||
| 1209 | - const TestData *test_data = (const TestData *)data; | ||
| 1210 | - uint32_t my_page_addr = test_data->page_addr; | ||
| 1211 | - uint32_t some_page_addr = my_page_addr + FLASH_PAGE_SIZE; | ||
| 1212 | - uint32_t page[FLASH_PAGE_SIZE / 4]; | ||
| 1213 | - int i; | ||
| 1214 | - | ||
| 1215 | - /* | ||
| 1216 | - * Enable 4BYTE mode for controller. | ||
| 1217 | - */ | ||
| 1218 | - spi_ce_ctrl(test_data, 1 << (CRTL_EXTENDED0 + test_data->cs)); | ||
| 1219 | - | ||
| 1220 | - /* Enable 4BYTE mode for flash. */ | ||
| 1221 | - spi_conf(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 1222 | - spi_ctrl_start_user(test_data); | ||
| 1223 | - flash_writeb(test_data, 0, EN_4BYTE_ADDR); | ||
| 1224 | - flash_writeb(test_data, 0, WREN); | ||
| 1225 | - flash_writeb(test_data, 0, PP); | ||
| 1226 | - flash_writel(test_data, 0, make_be32(my_page_addr)); | ||
| 1227 | - | ||
| 1228 | - /* Fill the page with its own addresses */ | ||
| 1229 | - for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 1230 | - flash_writel(test_data, 0, make_be32(my_page_addr + i * 4)); | ||
| 1231 | - } | ||
| 1232 | - spi_ctrl_stop_user(test_data); | ||
| 1233 | - spi_conf_remove(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 1234 | - | ||
| 1235 | - /* Check what was written */ | ||
| 1236 | - read_page_mem(test_data, my_page_addr, page); | ||
| 1237 | - for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 1238 | - g_assert_cmphex(page[i], ==, my_page_addr + i * 4); | ||
| 1239 | - } | ||
| 1240 | - | ||
| 1241 | - /* Check some other page. It should be full of 0xff */ | ||
| 1242 | - read_page_mem(test_data, some_page_addr, page); | ||
| 1243 | - for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 1244 | - g_assert_cmphex(page[i], ==, 0xffffffff); | ||
| 1245 | - } | ||
| 1246 | - | ||
| 1247 | - flash_reset(test_data); | ||
| 1248 | -} | ||
| 1249 | - | ||
| 1250 | -static void test_write_page_mem(const void *data) | ||
| 1251 | -{ | ||
| 1252 | - const TestData *test_data = (const TestData *)data; | ||
| 1253 | - uint32_t my_page_addr = test_data->page_addr; | ||
| 1254 | - uint32_t page[FLASH_PAGE_SIZE / 4]; | ||
| 1255 | - int i; | ||
| 1256 | - | ||
| 1257 | - /* | ||
| 1258 | - * Enable 4BYTE mode for controller. | ||
| 1259 | - */ | ||
| 1260 | - spi_ce_ctrl(test_data, 1 << (CRTL_EXTENDED0 + test_data->cs)); | ||
| 1261 | - | ||
| 1262 | - /* Enable 4BYTE mode for flash. */ | ||
| 1263 | - spi_conf(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 1264 | - spi_ctrl_start_user(test_data); | ||
| 1265 | - flash_writeb(test_data, 0, EN_4BYTE_ADDR); | ||
| 1266 | - flash_writeb(test_data, 0, WREN); | ||
| 1267 | - spi_ctrl_stop_user(test_data); | ||
| 1268 | - | ||
| 1269 | - /* move out USER mode to use direct writes to the AHB bus */ | ||
| 1270 | - spi_ctrl_setmode(test_data, CTRL_WRITEMODE, PP); | ||
| 1271 | - | ||
| 1272 | - for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 1273 | - flash_writel(test_data, my_page_addr + i * 4, | ||
| 1274 | - make_be32(my_page_addr + i * 4)); | ||
| 1275 | - } | ||
| 1276 | - | ||
| 1277 | - /* Check what was written */ | ||
| 1278 | - read_page_mem(test_data, my_page_addr, page); | ||
| 1279 | - for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 1280 | - g_assert_cmphex(page[i], ==, my_page_addr + i * 4); | ||
| 1281 | - } | ||
| 1282 | - | ||
| 1283 | - flash_reset(test_data); | ||
| 1284 | -} | ||
| 1285 | - | ||
| 1286 | -static void test_read_status_reg(const void *data) | ||
| 1287 | -{ | ||
| 1288 | - const TestData *test_data = (const TestData *)data; | ||
| 1289 | - uint8_t r; | ||
| 1290 | - | ||
| 1291 | - spi_conf(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 1292 | - | ||
| 1293 | - spi_ctrl_start_user(test_data); | ||
| 1294 | - flash_writeb(test_data, 0, RDSR); | ||
| 1295 | - r = flash_readb(test_data, 0); | ||
| 1296 | - spi_ctrl_stop_user(test_data); | ||
| 1297 | - | ||
| 1298 | - g_assert_cmphex(r & SR_WEL, ==, 0); | ||
| 1299 | - g_assert(!qtest_qom_get_bool | ||
| 1300 | - (test_data->s, test_data->node, "write-enable")); | ||
| 1301 | - | ||
| 1302 | - spi_ctrl_start_user(test_data); | ||
| 1303 | - flash_writeb(test_data, 0, WREN); | ||
| 1304 | - flash_writeb(test_data, 0, RDSR); | ||
| 1305 | - r = flash_readb(test_data, 0); | ||
| 1306 | - spi_ctrl_stop_user(test_data); | ||
| 1307 | - | ||
| 1308 | - g_assert_cmphex(r & SR_WEL, ==, SR_WEL); | ||
| 1309 | - g_assert(qtest_qom_get_bool | ||
| 1310 | - (test_data->s, test_data->node, "write-enable")); | ||
| 1311 | - | ||
| 1312 | - spi_ctrl_start_user(test_data); | ||
| 1313 | - flash_writeb(test_data, 0, WRDI); | ||
| 1314 | - flash_writeb(test_data, 0, RDSR); | ||
| 1315 | - r = flash_readb(test_data, 0); | ||
| 1316 | - spi_ctrl_stop_user(test_data); | ||
| 1317 | - | ||
| 1318 | - g_assert_cmphex(r & SR_WEL, ==, 0); | ||
| 1319 | - g_assert(!qtest_qom_get_bool | ||
| 1320 | - (test_data->s, test_data->node, "write-enable")); | ||
| 1321 | - | ||
| 1322 | - flash_reset(test_data); | ||
| 1323 | -} | ||
| 1324 | - | ||
| 1325 | -static void test_status_reg_write_protection(const void *data) | ||
| 1326 | -{ | ||
| 1327 | - const TestData *test_data = (const TestData *)data; | ||
| 1328 | - uint8_t r; | ||
| 1329 | - | ||
| 1330 | - spi_conf(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 1331 | - | ||
| 1332 | - /* default case: WP# is high and SRWD is low -> status register writable */ | ||
| 1333 | - spi_ctrl_start_user(test_data); | ||
| 1334 | - flash_writeb(test_data, 0, WREN); | ||
| 1335 | - /* test ability to write SRWD */ | ||
| 1336 | - flash_writeb(test_data, 0, WRSR); | ||
| 1337 | - flash_writeb(test_data, 0, SRWD); | ||
| 1338 | - flash_writeb(test_data, 0, RDSR); | ||
| 1339 | - r = flash_readb(test_data, 0); | ||
| 1340 | - spi_ctrl_stop_user(test_data); | ||
| 1341 | - g_assert_cmphex(r & SRWD, ==, SRWD); | ||
| 1342 | - | ||
| 1343 | - /* WP# high and SRWD high -> status register writable */ | ||
| 1344 | - spi_ctrl_start_user(test_data); | ||
| 1345 | - flash_writeb(test_data, 0, WREN); | ||
| 1346 | - /* test ability to write SRWD */ | ||
| 1347 | - flash_writeb(test_data, 0, WRSR); | ||
| 1348 | - flash_writeb(test_data, 0, 0); | ||
| 1349 | - flash_writeb(test_data, 0, RDSR); | ||
| 1350 | - r = flash_readb(test_data, 0); | ||
| 1351 | - spi_ctrl_stop_user(test_data); | ||
| 1352 | - g_assert_cmphex(r & SRWD, ==, 0); | ||
| 1353 | - | ||
| 1354 | - /* WP# low and SRWD low -> status register writable */ | ||
| 1355 | - qtest_set_irq_in(test_data->s, test_data->node, "WP#", 0, 0); | ||
| 1356 | - spi_ctrl_start_user(test_data); | ||
| 1357 | - flash_writeb(test_data, 0, WREN); | ||
| 1358 | - /* test ability to write SRWD */ | ||
| 1359 | - flash_writeb(test_data, 0, WRSR); | ||
| 1360 | - flash_writeb(test_data, 0, SRWD); | ||
| 1361 | - flash_writeb(test_data, 0, RDSR); | ||
| 1362 | - r = flash_readb(test_data, 0); | ||
| 1363 | - spi_ctrl_stop_user(test_data); | ||
| 1364 | - g_assert_cmphex(r & SRWD, ==, SRWD); | ||
| 1365 | - | ||
| 1366 | - /* WP# low and SRWD high -> status register NOT writable */ | ||
| 1367 | - spi_ctrl_start_user(test_data); | ||
| 1368 | - flash_writeb(test_data, 0 , WREN); | ||
| 1369 | - /* test ability to write SRWD */ | ||
| 1370 | - flash_writeb(test_data, 0, WRSR); | ||
| 1371 | - flash_writeb(test_data, 0, 0); | ||
| 1372 | - flash_writeb(test_data, 0, RDSR); | ||
| 1373 | - r = flash_readb(test_data, 0); | ||
| 1374 | - spi_ctrl_stop_user(test_data); | ||
| 1375 | - /* write is not successful */ | ||
| 1376 | - g_assert_cmphex(r & SRWD, ==, SRWD); | ||
| 1377 | - | ||
| 1378 | - qtest_set_irq_in(test_data->s, test_data->node, "WP#", 0, 1); | ||
| 1379 | - flash_reset(test_data); | ||
| 1380 | -} | ||
| 1381 | - | ||
| 1382 | -static void test_write_block_protect(const void *data) | ||
| 1383 | -{ | ||
| 1384 | - const TestData *test_data = (const TestData *)data; | ||
| 1385 | - uint32_t sector_size = 65536; | ||
| 1386 | - uint32_t n_sectors = 512; | ||
| 1387 | - | ||
| 1388 | - spi_ce_ctrl(test_data, 1 << (CRTL_EXTENDED0 + test_data->cs)); | ||
| 1389 | - spi_conf(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 1390 | - | ||
| 1391 | - uint32_t bp_bits = 0b0; | ||
| 1392 | - | ||
| 1393 | - for (int i = 0; i < 16; i++) { | ||
| 1394 | - bp_bits = ((i & 0b1000) << 3) | ((i & 0b0111) << 2); | ||
| 1395 | - | ||
| 1396 | - spi_ctrl_start_user(test_data); | ||
| 1397 | - flash_writeb(test_data, 0, WREN); | ||
| 1398 | - flash_writeb(test_data, 0, BULK_ERASE); | ||
| 1399 | - flash_writeb(test_data, 0, WREN); | ||
| 1400 | - flash_writeb(test_data, 0, WRSR); | ||
| 1401 | - flash_writeb(test_data, 0, bp_bits); | ||
| 1402 | - flash_writeb(test_data, 0, EN_4BYTE_ADDR); | ||
| 1403 | - flash_writeb(test_data, 0, WREN); | ||
| 1404 | - spi_ctrl_stop_user(test_data); | ||
| 1405 | - | ||
| 1406 | - uint32_t num_protected_sectors = i ? MIN(1 << (i - 1), n_sectors) : 0; | ||
| 1407 | - uint32_t protection_start = n_sectors - num_protected_sectors; | ||
| 1408 | - uint32_t protection_end = n_sectors; | ||
| 1409 | - | ||
| 1410 | - for (int sector = 0; sector < n_sectors; sector++) { | ||
| 1411 | - uint32_t addr = sector * sector_size; | ||
| 1412 | - | ||
| 1413 | - assert_page_mem(test_data, addr, 0xffffffff); | ||
| 1414 | - write_page_mem(test_data, addr, make_be32(0xabcdef12)); | ||
| 1415 | - | ||
| 1416 | - uint32_t expected_value = protection_start <= sector | ||
| 1417 | - && sector < protection_end | ||
| 1418 | - ? 0xffffffff : 0xabcdef12; | ||
| 1419 | - | ||
| 1420 | - assert_page_mem(test_data, addr, expected_value); | ||
| 1421 | - } | ||
| 1422 | - } | ||
| 1423 | - | ||
| 1424 | - flash_reset(test_data); | ||
| 1425 | -} | ||
| 1426 | - | ||
| 1427 | -static void test_write_block_protect_bottom_bit(const void *data) | ||
| 1428 | -{ | ||
| 1429 | - const TestData *test_data = (const TestData *)data; | ||
| 1430 | - uint32_t sector_size = 65536; | ||
| 1431 | - uint32_t n_sectors = 512; | ||
| 1432 | - | ||
| 1433 | - spi_ce_ctrl(test_data, 1 << (CRTL_EXTENDED0 + test_data->cs)); | ||
| 1434 | - spi_conf(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 1435 | - | ||
| 1436 | - /* top bottom bit is enabled */ | ||
| 1437 | - uint32_t bp_bits = 0b00100 << 3; | ||
| 1438 | - | ||
| 1439 | - for (int i = 0; i < 16; i++) { | ||
| 1440 | - bp_bits = (((i & 0b1000) | 0b0100) << 3) | ((i & 0b0111) << 2); | ||
| 1441 | - | ||
| 1442 | - spi_ctrl_start_user(test_data); | ||
| 1443 | - flash_writeb(test_data, 0, WREN); | ||
| 1444 | - flash_writeb(test_data, 0, BULK_ERASE); | ||
| 1445 | - flash_writeb(test_data, 0, WREN); | ||
| 1446 | - flash_writeb(test_data, 0, WRSR); | ||
| 1447 | - flash_writeb(test_data, 0, bp_bits); | ||
| 1448 | - flash_writeb(test_data, 0, EN_4BYTE_ADDR); | ||
| 1449 | - flash_writeb(test_data, 0, WREN); | ||
| 1450 | - spi_ctrl_stop_user(test_data); | ||
| 1451 | - | ||
| 1452 | - uint32_t num_protected_sectors = i ? MIN(1 << (i - 1), n_sectors) : 0; | ||
| 1453 | - uint32_t protection_start = 0; | ||
| 1454 | - uint32_t protection_end = num_protected_sectors; | ||
| 1455 | - | ||
| 1456 | - for (int sector = 0; sector < n_sectors; sector++) { | ||
| 1457 | - uint32_t addr = sector * sector_size; | ||
| 1458 | - | ||
| 1459 | - assert_page_mem(test_data, addr, 0xffffffff); | ||
| 1460 | - write_page_mem(test_data, addr, make_be32(0xabcdef12)); | ||
| 1461 | - | ||
| 1462 | - uint32_t expected_value = protection_start <= sector | ||
| 1463 | - && sector < protection_end | ||
| 1464 | - ? 0xffffffff : 0xabcdef12; | ||
| 1465 | - | ||
| 1466 | - assert_page_mem(test_data, addr, expected_value); | ||
| 1467 | - } | ||
| 1468 | - } | ||
| 1469 | - | ||
| 1470 | - flash_reset(test_data); | ||
| 1471 | -} | ||
| 1472 | - | ||
| 1473 | -static void test_write_page_qpi(const void *data) | ||
| 1474 | -{ | ||
| 1475 | - const TestData *test_data = (const TestData *)data; | ||
| 1476 | - uint32_t my_page_addr = test_data->page_addr; | ||
| 1477 | - uint32_t some_page_addr = my_page_addr + FLASH_PAGE_SIZE; | ||
| 1478 | - uint32_t page[FLASH_PAGE_SIZE / 4]; | ||
| 1479 | - uint32_t page_pattern[] = { | ||
| 1480 | - 0xebd8c134, 0x5da196bc, 0xae15e729, 0x5085ccdf | ||
| 1481 | - }; | ||
| 1482 | - int i; | ||
| 1483 | - | ||
| 1484 | - spi_conf(test_data, 1 << (CONF_ENABLE_W0 + test_data->cs)); | ||
| 1485 | - | ||
| 1486 | - spi_ctrl_start_user(test_data); | ||
| 1487 | - flash_writeb(test_data, 0, EN_4BYTE_ADDR); | ||
| 1488 | - flash_writeb(test_data, 0, WREN); | ||
| 1489 | - flash_writeb(test_data, 0, PP); | ||
| 1490 | - flash_writel(test_data, 0, make_be32(my_page_addr)); | ||
| 1491 | - | ||
| 1492 | - /* Set QPI mode */ | ||
| 1493 | - spi_ctrl_set_io_mode(test_data, CTRL_IO_QUAD_IO); | ||
| 1494 | - | ||
| 1495 | - /* Fill the page pattern */ | ||
| 1496 | - for (i = 0; i < ARRAY_SIZE(page_pattern); i++) { | ||
| 1497 | - flash_writel(test_data, 0, make_be32(page_pattern[i])); | ||
| 1498 | - } | ||
| 1499 | - | ||
| 1500 | - /* Fill the page with its own addresses */ | ||
| 1501 | - for (; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 1502 | - flash_writel(test_data, 0, make_be32(my_page_addr + i * 4)); | ||
| 1503 | - } | ||
| 1504 | - | ||
| 1505 | - /* Restore io mode */ | ||
| 1506 | - spi_ctrl_set_io_mode(test_data, 0); | ||
| 1507 | - spi_ctrl_stop_user(test_data); | ||
| 1508 | - | ||
| 1509 | - /* Check what was written */ | ||
| 1510 | - read_page(test_data, my_page_addr, page); | ||
| 1511 | - for (i = 0; i < ARRAY_SIZE(page_pattern); i++) { | ||
| 1512 | - g_assert_cmphex(page[i], ==, page_pattern[i]); | ||
| 1513 | - } | ||
| 1514 | - for (; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 1515 | - g_assert_cmphex(page[i], ==, my_page_addr + i * 4); | ||
| 1516 | - } | ||
| 1517 | - | ||
| 1518 | - /* Check some other page. It should be full of 0xff */ | ||
| 1519 | - read_page(test_data, some_page_addr, page); | ||
| 1520 | - for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) { | ||
| 1521 | - g_assert_cmphex(page[i], ==, 0xffffffff); | ||
| 1522 | - } | ||
| 1523 | - | ||
| 1524 | - flash_reset(test_data); | ||
| 1525 | -} | ||
| 1526 | - | ||
| 1527 | -static void test_palmetto_bmc(TestData *data) | ||
| 1528 | +static void test_palmetto_bmc(AspeedSMCTestData *data) | ||
| 1529 | { | ||
| 1530 | int ret; | ||
| 1531 | int fd; | ||
| 1532 | @@ -XXX,XX +XXX,XX @@ static void test_palmetto_bmc(TestData *data) | ||
| 1533 | /* beyond 16MB */ | ||
| 1534 | data->page_addr = 0x14000 * FLASH_PAGE_SIZE; | ||
| 1535 | |||
| 1536 | - qtest_add_data_func("/ast2400/smc/read_jedec", data, test_read_jedec); | ||
| 1537 | - qtest_add_data_func("/ast2400/smc/erase_sector", data, test_erase_sector); | ||
| 1538 | - qtest_add_data_func("/ast2400/smc/erase_all", data, test_erase_all); | ||
| 1539 | - qtest_add_data_func("/ast2400/smc/write_page", data, test_write_page); | ||
| 1540 | + qtest_add_data_func("/ast2400/smc/read_jedec", | ||
| 1541 | + data, aspeed_smc_test_read_jedec); | ||
| 1542 | + qtest_add_data_func("/ast2400/smc/erase_sector", | ||
| 1543 | + data, aspeed_smc_test_erase_sector); | ||
| 1544 | + qtest_add_data_func("/ast2400/smc/erase_all", | ||
| 1545 | + data, aspeed_smc_test_erase_all); | ||
| 1546 | + qtest_add_data_func("/ast2400/smc/write_page", | ||
| 1547 | + data, aspeed_smc_test_write_page); | ||
| 1548 | qtest_add_data_func("/ast2400/smc/read_page_mem", | ||
| 1549 | - data, test_read_page_mem); | ||
| 1550 | + data, aspeed_smc_test_read_page_mem); | ||
| 1551 | qtest_add_data_func("/ast2400/smc/write_page_mem", | ||
| 1552 | - data, test_write_page_mem); | ||
| 1553 | + data, aspeed_smc_test_write_page_mem); | ||
| 1554 | qtest_add_data_func("/ast2400/smc/read_status_reg", | ||
| 1555 | - data, test_read_status_reg); | ||
| 1556 | + data, aspeed_smc_test_read_status_reg); | ||
| 1557 | qtest_add_data_func("/ast2400/smc/status_reg_write_protection", | ||
| 1558 | - data, test_status_reg_write_protection); | ||
| 1559 | + data, aspeed_smc_test_status_reg_write_protection); | ||
| 1560 | qtest_add_data_func("/ast2400/smc/write_block_protect", | ||
| 1561 | - data, test_write_block_protect); | ||
| 1562 | + data, aspeed_smc_test_write_block_protect); | ||
| 1563 | qtest_add_data_func("/ast2400/smc/write_block_protect_bottom_bit", | ||
| 1564 | - data, test_write_block_protect_bottom_bit); | ||
| 1565 | + data, aspeed_smc_test_write_block_protect_bottom_bit); | ||
| 1566 | } | ||
| 1567 | |||
| 1568 | -static void test_ast2500_evb(TestData *data) | ||
| 1569 | +static void test_ast2500_evb(AspeedSMCTestData *data) | ||
| 1570 | { | ||
| 1571 | int ret; | ||
| 1572 | int fd; | ||
| 1573 | @@ -XXX,XX +XXX,XX @@ static void test_ast2500_evb(TestData *data) | ||
| 1574 | /* beyond 16MB */ | ||
| 1575 | data->page_addr = 0x14000 * FLASH_PAGE_SIZE; | ||
| 1576 | |||
| 1577 | - qtest_add_data_func("/ast2500/smc/read_jedec", data, test_read_jedec); | ||
| 1578 | - qtest_add_data_func("/ast2500/smc/erase_sector", data, test_erase_sector); | ||
| 1579 | - qtest_add_data_func("/ast2500/smc/erase_all", data, test_erase_all); | ||
| 1580 | - qtest_add_data_func("/ast2500/smc/write_page", data, test_write_page); | ||
| 1581 | + qtest_add_data_func("/ast2500/smc/read_jedec", | ||
| 1582 | + data, aspeed_smc_test_read_jedec); | ||
| 1583 | + qtest_add_data_func("/ast2500/smc/erase_sector", | ||
| 1584 | + data, aspeed_smc_test_erase_sector); | ||
| 1585 | + qtest_add_data_func("/ast2500/smc/erase_all", | ||
| 1586 | + data, aspeed_smc_test_erase_all); | ||
| 1587 | + qtest_add_data_func("/ast2500/smc/write_page", | ||
| 1588 | + data, aspeed_smc_test_write_page); | ||
| 1589 | qtest_add_data_func("/ast2500/smc/read_page_mem", | ||
| 1590 | - data, test_read_page_mem); | ||
| 1591 | + data, aspeed_smc_test_read_page_mem); | ||
| 1592 | qtest_add_data_func("/ast2500/smc/write_page_mem", | ||
| 1593 | - data, test_write_page_mem); | ||
| 1594 | + data, aspeed_smc_test_write_page_mem); | ||
| 1595 | qtest_add_data_func("/ast2500/smc/read_status_reg", | ||
| 1596 | - data, test_read_status_reg); | ||
| 1597 | + data, aspeed_smc_test_read_status_reg); | ||
| 1598 | qtest_add_data_func("/ast2500/smc/write_page_qpi", | ||
| 1599 | - data, test_write_page_qpi); | ||
| 1600 | + data, aspeed_smc_test_write_page_qpi); | ||
| 1601 | } | ||
| 1602 | |||
| 1603 | -static void test_ast2600_evb(TestData *data) | ||
| 1604 | +static void test_ast2600_evb(AspeedSMCTestData *data) | ||
| 1605 | { | ||
| 1606 | int ret; | ||
| 1607 | int fd; | ||
| 1608 | @@ -XXX,XX +XXX,XX @@ static void test_ast2600_evb(TestData *data) | ||
| 1609 | /* beyond 16MB */ | ||
| 1610 | data->page_addr = 0x14000 * FLASH_PAGE_SIZE; | ||
| 1611 | |||
| 1612 | - qtest_add_data_func("/ast2600/smc/read_jedec", data, test_read_jedec); | ||
| 1613 | - qtest_add_data_func("/ast2600/smc/erase_sector", data, test_erase_sector); | ||
| 1614 | - qtest_add_data_func("/ast2600/smc/erase_all", data, test_erase_all); | ||
| 1615 | - qtest_add_data_func("/ast2600/smc/write_page", data, test_write_page); | ||
| 1616 | + qtest_add_data_func("/ast2600/smc/read_jedec", | ||
| 1617 | + data, aspeed_smc_test_read_jedec); | ||
| 1618 | + qtest_add_data_func("/ast2600/smc/erase_sector", | ||
| 1619 | + data, aspeed_smc_test_erase_sector); | ||
| 1620 | + qtest_add_data_func("/ast2600/smc/erase_all", | ||
| 1621 | + data, aspeed_smc_test_erase_all); | ||
| 1622 | + qtest_add_data_func("/ast2600/smc/write_page", | ||
| 1623 | + data, aspeed_smc_test_write_page); | ||
| 1624 | qtest_add_data_func("/ast2600/smc/read_page_mem", | ||
| 1625 | - data, test_read_page_mem); | ||
| 1626 | + data, aspeed_smc_test_read_page_mem); | ||
| 1627 | qtest_add_data_func("/ast2600/smc/write_page_mem", | ||
| 1628 | - data, test_write_page_mem); | ||
| 1629 | + data, aspeed_smc_test_write_page_mem); | ||
| 1630 | qtest_add_data_func("/ast2600/smc/read_status_reg", | ||
| 1631 | - data, test_read_status_reg); | ||
| 1632 | + data, aspeed_smc_test_read_status_reg); | ||
| 1633 | qtest_add_data_func("/ast2600/smc/write_page_qpi", | ||
| 1634 | - data, test_write_page_qpi); | ||
| 1635 | + data, aspeed_smc_test_write_page_qpi); | ||
| 1636 | } | ||
| 1637 | |||
| 1638 | -static void test_ast1030_evb(TestData *data) | ||
| 1639 | +static void test_ast1030_evb(AspeedSMCTestData *data) | ||
| 1640 | { | ||
| 1641 | int ret; | ||
| 1642 | int fd; | ||
| 1643 | @@ -XXX,XX +XXX,XX @@ static void test_ast1030_evb(TestData *data) | ||
| 1644 | /* beyond 512KB */ | ||
| 1645 | data->page_addr = 0x800 * FLASH_PAGE_SIZE; | ||
| 1646 | |||
| 1647 | - qtest_add_data_func("/ast1030/smc/read_jedec", data, test_read_jedec); | ||
| 1648 | - qtest_add_data_func("/ast1030/smc/erase_sector", data, test_erase_sector); | ||
| 1649 | - qtest_add_data_func("/ast1030/smc/erase_all", data, test_erase_all); | ||
| 1650 | - qtest_add_data_func("/ast1030/smc/write_page", data, test_write_page); | ||
| 1651 | + qtest_add_data_func("/ast1030/smc/read_jedec", | ||
| 1652 | + data, aspeed_smc_test_read_jedec); | ||
| 1653 | + qtest_add_data_func("/ast1030/smc/erase_sector", | ||
| 1654 | + data, aspeed_smc_test_erase_sector); | ||
| 1655 | + qtest_add_data_func("/ast1030/smc/erase_all", | ||
| 1656 | + data, aspeed_smc_test_erase_all); | ||
| 1657 | + qtest_add_data_func("/ast1030/smc/write_page", | ||
| 1658 | + data, aspeed_smc_test_write_page); | ||
| 1659 | qtest_add_data_func("/ast1030/smc/read_page_mem", | ||
| 1660 | - data, test_read_page_mem); | ||
| 1661 | + data, aspeed_smc_test_read_page_mem); | ||
| 1662 | qtest_add_data_func("/ast1030/smc/write_page_mem", | ||
| 1663 | - data, test_write_page_mem); | ||
| 1664 | + data, aspeed_smc_test_write_page_mem); | ||
| 1665 | qtest_add_data_func("/ast1030/smc/read_status_reg", | ||
| 1666 | - data, test_read_status_reg); | ||
| 1667 | + data, aspeed_smc_test_read_status_reg); | ||
| 1668 | qtest_add_data_func("/ast1030/smc/write_page_qpi", | ||
| 1669 | - data, test_write_page_qpi); | ||
| 1670 | + data, aspeed_smc_test_write_page_qpi); | ||
| 1671 | } | ||
| 1672 | |||
| 1673 | int main(int argc, char **argv) | ||
| 1674 | { | ||
| 1675 | - TestData palmetto_data; | ||
| 1676 | - TestData ast2500_evb_data; | ||
| 1677 | - TestData ast2600_evb_data; | ||
| 1678 | - TestData ast1030_evb_data; | ||
| 1679 | + AspeedSMCTestData palmetto_data; | ||
| 1680 | + AspeedSMCTestData ast2500_evb_data; | ||
| 1681 | + AspeedSMCTestData ast2600_evb_data; | ||
| 1682 | + AspeedSMCTestData ast1030_evb_data; | ||
| 1683 | int ret; | ||
| 1684 | |||
| 1685 | g_test_init(&argc, &argv, NULL); | ||
| 528 | diff --git a/tests/qtest/meson.build b/tests/qtest/meson.build | 1686 | diff --git a/tests/qtest/meson.build b/tests/qtest/meson.build |
| 529 | index XXXXXXX..XXXXXXX 100644 | 1687 | index XXXXXXX..XXXXXXX 100644 |
| 530 | --- a/tests/qtest/meson.build | 1688 | --- a/tests/qtest/meson.build |
| 531 | +++ b/tests/qtest/meson.build | 1689 | +++ b/tests/qtest/meson.build |
| 532 | @@ -XXX,XX +XXX,XX @@ qos_test_ss.add( | 1690 | @@ -XXX,XX +XXX,XX @@ qtests = { |
| 533 | 'sdhci-test.c', | 1691 | 'virtio-net-failover': files('migration-helpers.c'), |
| 534 | 'spapr-phb-test.c', | 1692 | 'vmgenid-test': files('boot-sector.c', 'acpi-utils.c'), |
| 535 | 'tmp105-test.c', | 1693 | 'netdev-socket': files('netdev-socket.c', '../unit/socket-helpers.c'), |
| 536 | + 'emc141x-test.c', | 1694 | + 'aspeed_smc-test': files('aspeed-smc-utils.c', 'aspeed_smc-test.c'), |
| 537 | 'usb-hcd-ohci-test.c', | 1695 | } |
| 538 | 'virtio-test.c', | 1696 | |
| 539 | 'virtio-blk-test.c', | 1697 | if vnc.found() |
| 540 | -- | 1698 | -- |
| 541 | 2.26.2 | 1699 | 2.47.1 |
| 542 | 1700 | ||
| 543 | 1701 | diff view generated by jsdifflib |
| 1 | The controller can be configured to disable or enable address and data | 1 | From: Jamin Lin <jamin_lin@aspeedtech.com> |
|---|---|---|---|
| 2 | byte lanes when issuing commands. This is useful in read command mode | ||
| 3 | to send SPI NOR commands that don't have an address space, such as | ||
| 4 | RDID. It's a good way to have a unified read operation for registers | ||
| 5 | and flash contents accesses. | ||
| 6 | 2 | ||
| 7 | A new SPI driver proposed by Aspeed makes use of this feature. Add | 3 | Add test_ast2700_evb function and reused testcases which are from |
| 8 | support for address lanes to start with. We will do the same for the | 4 | aspeed_smc-test.c for AST2700 testing. The base address, flash base address |
| 9 | data lanes if they are controlled one day. | 5 | and ce index of fmc_cs0 are 0x14000000, 0x100000000 and 0, respectively. |
| 6 | The default flash model of fmc_cs0 is "w25q01jvq" whose size is 128MB, | ||
| 7 | so set jedec_id 0xef4021. | ||
| 10 | 8 | ||
| 11 | Cc: Chin-Ting Kuo <chin-ting_kuo@aspeedtech.com> | 9 | Signed-off-by: Jamin Lin <jamin_lin@aspeedtech.com> |
| 12 | Signed-off-by: Cédric Le Goater <clg@kaod.org> | 10 | Reviewed-by: Cédric Le Goater <clg@redhat.com> |
| 13 | Reviewed-by: Joel Stanley <joel@jms.id.au> | 11 | Link: https://lore.kernel.org/r/20241127091543.1243114-11-jamin_lin@aspeedtech.com |
| 14 | Message-Id: <20201120161547.740806-2-clg@kaod.org> | 12 | Signed-off-by: Cédric Le Goater <clg@redhat.com> |
| 15 | Signed-off-by: Cédric Le Goater <clg@kaod.org> | ||
| 16 | --- | 13 | --- |
| 17 | hw/ssi/aspeed_smc.c | 25 ++++++++++++++++++------- | 14 | tests/qtest/ast2700-smc-test.c | 71 ++++++++++++++++++++++++++++++++++ |
| 18 | 1 file changed, 18 insertions(+), 7 deletions(-) | 15 | tests/qtest/meson.build | 4 +- |
| 16 | 2 files changed, 74 insertions(+), 1 deletion(-) | ||
| 17 | create mode 100644 tests/qtest/ast2700-smc-test.c | ||
| 19 | 18 | ||
| 20 | diff --git a/hw/ssi/aspeed_smc.c b/hw/ssi/aspeed_smc.c | 19 | diff --git a/tests/qtest/ast2700-smc-test.c b/tests/qtest/ast2700-smc-test.c |
| 20 | new file mode 100644 | ||
| 21 | index XXXXXXX..XXXXXXX | ||
| 22 | --- /dev/null | ||
| 23 | +++ b/tests/qtest/ast2700-smc-test.c | ||
| 24 | @@ -XXX,XX +XXX,XX @@ | ||
| 25 | +/* | ||
| 26 | + * QTest testcase for the M25P80 Flash using the ASPEED SPI Controller since | ||
| 27 | + * AST2700. | ||
| 28 | + * | ||
| 29 | + * SPDX-License-Identifier: GPL-2.0-or-later | ||
| 30 | + * Copyright (C) 2024 ASPEED Technology Inc. | ||
| 31 | + */ | ||
| 32 | + | ||
| 33 | +#include "qemu/osdep.h" | ||
| 34 | +#include "qemu/bswap.h" | ||
| 35 | +#include "libqtest-single.h" | ||
| 36 | +#include "qemu/bitops.h" | ||
| 37 | +#include "aspeed-smc-utils.h" | ||
| 38 | + | ||
| 39 | +static void test_ast2700_evb(AspeedSMCTestData *data) | ||
| 40 | +{ | ||
| 41 | + int ret; | ||
| 42 | + int fd; | ||
| 43 | + | ||
| 44 | + fd = g_file_open_tmp("qtest.m25p80.w25q01jvq.XXXXXX", | ||
| 45 | + &data->tmp_path, NULL); | ||
| 46 | + g_assert(fd >= 0); | ||
| 47 | + ret = ftruncate(fd, 128 * 1024 * 1024); | ||
| 48 | + g_assert(ret == 0); | ||
| 49 | + close(fd); | ||
| 50 | + | ||
| 51 | + data->s = qtest_initf("-machine ast2700-evb " | ||
| 52 | + "-drive file=%s,format=raw,if=mtd", | ||
| 53 | + data->tmp_path); | ||
| 54 | + | ||
| 55 | + /* fmc cs0 with w25q01jvq flash */ | ||
| 56 | + data->flash_base = 0x100000000; | ||
| 57 | + data->spi_base = 0x14000000; | ||
| 58 | + data->jedec_id = 0xef4021; | ||
| 59 | + data->cs = 0; | ||
| 60 | + data->node = "/machine/soc/fmc/ssi.0/child[0]"; | ||
| 61 | + /* beyond 64MB */ | ||
| 62 | + data->page_addr = 0x40000 * FLASH_PAGE_SIZE; | ||
| 63 | + | ||
| 64 | + qtest_add_data_func("/ast2700/smc/read_jedec", | ||
| 65 | + data, aspeed_smc_test_read_jedec); | ||
| 66 | + qtest_add_data_func("/ast2700/smc/erase_sector", | ||
| 67 | + data, aspeed_smc_test_erase_sector); | ||
| 68 | + qtest_add_data_func("/ast2700/smc/erase_all", | ||
| 69 | + data, aspeed_smc_test_erase_all); | ||
| 70 | + qtest_add_data_func("/ast2700/smc/write_page", | ||
| 71 | + data, aspeed_smc_test_write_page); | ||
| 72 | + qtest_add_data_func("/ast2700/smc/read_page_mem", | ||
| 73 | + data, aspeed_smc_test_read_page_mem); | ||
| 74 | + qtest_add_data_func("/ast2700/smc/write_page_mem", | ||
| 75 | + data, aspeed_smc_test_write_page_mem); | ||
| 76 | + qtest_add_data_func("/ast2700/smc/read_status_reg", | ||
| 77 | + data, aspeed_smc_test_read_status_reg); | ||
| 78 | + qtest_add_data_func("/ast2700/smc/write_page_qpi", | ||
| 79 | + data, aspeed_smc_test_write_page_qpi); | ||
| 80 | +} | ||
| 81 | + | ||
| 82 | +int main(int argc, char **argv) | ||
| 83 | +{ | ||
| 84 | + AspeedSMCTestData ast2700_evb_data; | ||
| 85 | + int ret; | ||
| 86 | + | ||
| 87 | + g_test_init(&argc, &argv, NULL); | ||
| 88 | + | ||
| 89 | + test_ast2700_evb(&ast2700_evb_data); | ||
| 90 | + ret = g_test_run(); | ||
| 91 | + | ||
| 92 | + qtest_quit(ast2700_evb_data.s); | ||
| 93 | + unlink(ast2700_evb_data.tmp_path); | ||
| 94 | + return ret; | ||
| 95 | +} | ||
| 96 | diff --git a/tests/qtest/meson.build b/tests/qtest/meson.build | ||
| 21 | index XXXXXXX..XXXXXXX 100644 | 97 | index XXXXXXX..XXXXXXX 100644 |
| 22 | --- a/hw/ssi/aspeed_smc.c | 98 | --- a/tests/qtest/meson.build |
| 23 | +++ b/hw/ssi/aspeed_smc.c | 99 | +++ b/tests/qtest/meson.build |
| 24 | @@ -XXX,XX +XXX,XX @@ | 100 | @@ -XXX,XX +XXX,XX @@ qtests_aspeed = \ |
| 25 | #define INTR_CTRL_CMD_ABORT_EN (1 << 2) | 101 | 'aspeed_smc-test', |
| 26 | #define INTR_CTRL_WRITE_PROTECT_EN (1 << 1) | 102 | 'aspeed_gpio-test'] |
| 27 | 103 | qtests_aspeed64 = \ | |
| 28 | +/* Command Control Register */ | 104 | - ['ast2700-gpio-test'] |
| 29 | +#define R_CE_CMD_CTRL (0x0C / 4) | 105 | + ['ast2700-gpio-test', |
| 30 | +#define CTRL_ADDR_BYTE0_DISABLE_SHIFT 4 | 106 | + 'ast2700-smc-test'] |
| 31 | +#define CTRL_DATA_BYTE0_DISABLE_SHIFT 0 | 107 | |
| 32 | + | 108 | qtests_stm32l4x5 = \ |
| 33 | +#define aspeed_smc_addr_byte_enabled(s, i) \ | 109 | ['stm32l4x5_exti-test', |
| 34 | + (!((s)->regs[R_CE_CMD_CTRL] & (1 << (CTRL_ADDR_BYTE0_DISABLE_SHIFT + (i))))) | 110 | @@ -XXX,XX +XXX,XX @@ qtests = { |
| 35 | +#define aspeed_smc_data_byte_enabled(s, i) \ | 111 | 'vmgenid-test': files('boot-sector.c', 'acpi-utils.c'), |
| 36 | + (!((s)->regs[R_CE_CMD_CTRL] & (1 << (CTRL_DATA_BYTE0_DISABLE_SHIFT + (i))))) | 112 | 'netdev-socket': files('netdev-socket.c', '../unit/socket-helpers.c'), |
| 37 | + | 113 | 'aspeed_smc-test': files('aspeed-smc-utils.c', 'aspeed_smc-test.c'), |
| 38 | /* CEx Control Register */ | 114 | + 'ast2700-smc-test': files('aspeed-smc-utils.c', 'ast2700-smc-test.c'), |
| 39 | #define R_CTRL0 (0x10 / 4) | 115 | } |
| 40 | #define CTRL_IO_QPI (1 << 31) | 116 | |
| 41 | @@ -XXX,XX +XXX,XX @@ static void aspeed_smc_flash_setup(AspeedSMCFlash *fl, uint32_t addr) | 117 | if vnc.found() |
| 42 | { | ||
| 43 | const AspeedSMCState *s = fl->controller; | ||
| 44 | uint8_t cmd = aspeed_smc_flash_cmd(fl); | ||
| 45 | - int i; | ||
| 46 | + int i = aspeed_smc_flash_is_4byte(fl) ? 4 : 3; | ||
| 47 | |||
| 48 | /* Flash access can not exceed CS segment */ | ||
| 49 | addr = aspeed_smc_check_segment_addr(fl, addr); | ||
| 50 | |||
| 51 | ssi_transfer(s->spi, cmd); | ||
| 52 | - | ||
| 53 | - if (aspeed_smc_flash_is_4byte(fl)) { | ||
| 54 | - ssi_transfer(s->spi, (addr >> 24) & 0xff); | ||
| 55 | + while (i--) { | ||
| 56 | + if (aspeed_smc_addr_byte_enabled(s, i)) { | ||
| 57 | + ssi_transfer(s->spi, (addr >> (i * 8)) & 0xff); | ||
| 58 | + } | ||
| 59 | } | ||
| 60 | - ssi_transfer(s->spi, (addr >> 16) & 0xff); | ||
| 61 | - ssi_transfer(s->spi, (addr >> 8) & 0xff); | ||
| 62 | - ssi_transfer(s->spi, (addr & 0xff)); | ||
| 63 | |||
| 64 | /* | ||
| 65 | * Use fake transfers to model dummy bytes. The value should | ||
| 66 | @@ -XXX,XX +XXX,XX @@ static uint64_t aspeed_smc_read(void *opaque, hwaddr addr, unsigned int size) | ||
| 67 | (addr >= s->r_timings && | ||
| 68 | addr < s->r_timings + s->ctrl->nregs_timings) || | ||
| 69 | addr == s->r_ce_ctrl || | ||
| 70 | + addr == R_CE_CMD_CTRL || | ||
| 71 | addr == R_INTR_CTRL || | ||
| 72 | addr == R_DUMMY_DATA || | ||
| 73 | (s->ctrl->has_dma && addr == R_DMA_CTRL) || | ||
| 74 | @@ -XXX,XX +XXX,XX @@ static void aspeed_smc_write(void *opaque, hwaddr addr, uint64_t data, | ||
| 75 | if (value != s->regs[R_SEG_ADDR0 + cs]) { | ||
| 76 | aspeed_smc_flash_set_segment(s, cs, value); | ||
| 77 | } | ||
| 78 | + } else if (addr == R_CE_CMD_CTRL) { | ||
| 79 | + s->regs[addr] = value & 0xff; | ||
| 80 | } else if (addr == R_DUMMY_DATA) { | ||
| 81 | s->regs[addr] = value & 0xff; | ||
| 82 | } else if (addr == R_INTR_CTRL) { | ||
| 83 | -- | 118 | -- |
| 84 | 2.26.2 | 119 | 2.47.1 |
| 85 | 120 | ||
| 86 | 121 | diff view generated by jsdifflib |