February 2019 - U-Boot

[U-Boot] [RFC 0/9] Convert Pico-Pi i.MX7D to DM
by Joris Offouga 15 Feb '19

15 Feb '19

Hi all, Pinctrl, GPIO, I2C, MMC, ETH are converted. Convert PMIC is the same of warp7 but i have a some erros, si this log : U-Boot SPL 2019.01-00197-ga524e5d-dirty (Jan 20 2019 - 21:09:49 +0100) Trying to boot from USB SDP SDP: initialize... SDP: handle requests... Downloading file of size 556397 to 0x877fffc0... done Jumping to header at 0x877fffc0 Header Tag is not an IMX image U-Boot 2019.01-00197-ga524e5d-dirty (Jan 20 2019 - 21:09:49 +0100) CPU: Freescale i.MX7D rev1.2 1000 MHz (running at 792 MHz) CPU: Commercial temperature grade (0C to 95C) at 43C Reset cause: POR Model: TechNexion PICO-IMX7D Board and PI baseboard Board: i.MX7D PICOSOM DRAM: 512 MiB read error from device: 9df65458 register: 0x3! PMIC: PFUZE3000 DEV_ID=0x0 REV_ID=0xfffffffb read error from device: 9df65458 register: 0x69! write error to device: 9df65458 register: 0x23! write error to device: 9df65458 register: 0x31! write error to device: 9df65458 register: 0x21! write error to device: 9df65458 register: 0x2f! read error from device: 9df65458 register: 0x2e! write error to device: 9df65458 register: 0x2e! MMC: FSL_SDHC: 2, FSL_SDHC: 1, FSL_SDHC: 0 Loading Environment from MMC... OK In: serial@30a70000 Out: serial@30a70000 Err: serial@30a70000 Net: Warning: ethernet@30be0000 using MAC address from ROM eth0: ethernet@30be0000 Hit any key to stop autoboot: 0 USB is convert but update u-boot with dfu log a error : => dfu 0 mmc 0 Request would exceed designated area! #Deferred dfu_flush() failed!=> Thanks a advance for your help. Best Regards, Joris Offouga Joris Offouga (9): Arm: dts: imx7d-pico: Import Linux pico-pi dts Arm: imx7d-pico: Add DT file hooks pico-pi-imx7d: defconfig Enable DM gpio pinctrl and pinctrl_imx7 arm: imx7d-pico-pi: Convert to DM MMC initialization pico-pi-imx7d: defconfig: Switch to DM for I2C pico-imx7d-pico: defconfig: Switch to DM for UART pico-imx7d: Convert to DM PMIC arm: pico-pi-imx7d: Convert to DM USB pico-imx7d: Convert to DM Ethernet arch/arm/dts/Makefile | 3 +- arch/arm/dts/imx7d-pico-pi.dts | 102 ++++++ arch/arm/dts/imx7d-pico.dtsi | 588 +++++++++++++++++++++++++++++++ board/technexion/pico-imx7d/pico-imx7d.c | 105 +----- configs/pico-pi-imx7d_defconfig | 17 +- include/configs/pico-imx7d.h | 11 - 6 files changed, 726 insertions(+), 100 deletions(-) create mode 100644 arch/arm/dts/imx7d-pico-pi.dts create mode 100644 arch/arm/dts/imx7d-pico.dtsi -- 2.7.4

6 33

[U-Boot] [PATCH] ARM: tegra: enable ums on nyan boards
by Tristan Bastian 14 Feb '19

14 Feb '19

This patch enables UMS on the nyan devices like the nyan-big. A patch like this has been sent in by Stephen Warren some time ago for other tegra devices: commit e6607cffef965011ef0ddc0fbe6f4b7c0d53aeec But the nyan devices never received that functionality. Signed-off-by: Tristan Bastian <tristan-c.bastian(a)gmx.de> --- arch/arm/dts/tegra124-nyan.dtsi | 1 + 1 file changed, 1 insertion(+) diff --git a/arch/arm/dts/tegra124-nyan.dtsi b/arch/arm/dts/tegra124-nyan.dtsi index 51895e4816..2b28fe1497 100644 --- a/arch/arm/dts/tegra124-nyan.dtsi +++ b/arch/arm/dts/tegra124-nyan.dtsi @@ -414,6 +414,7 @@ usb@7d000000 { /* Rear external USB port. */ status = "okay"; + dr_mode = "otg"; nvidia,vbus-gpio = <&gpio TEGRA_GPIO(N, 4) GPIO_ACTIVE_HIGH>; }; -- 2.19.1

2 1

[U-Boot] [REGRESSION] tegra: efi: EFI boot on nyan-big/tegra124 not possible
by Tristan Bastian 14 Feb '19

14 Feb '19

Hello, On my nyan-big Chromebook(tegra124) efi booting is broken since stable v2019.01. v2018.11 is working fine.. I'm not sure if other tegra devices are working or not.. I'm getting the following output with u-boot v2019.01 if I try to start grub-efi-arm to boot ubuntu: [...] 67482 bytes read in 17 ms (3.8 MiB/s) Found EFI removable media binary efi/boot/bootarm.efi Error: Cannot set up EFI drivers, r = 14 87040 bytes read in 12 ms (6.9 MiB/s) Error: Cannot set up EFI drivers, r = 14 EFI LOAD FAILED: continuing... [...] The same setup is working if I use the v2018.11 branch. Any ideas? Tristan

1 0

[U-Boot] [PATCH 0/2] Make nyan-big working..
by Tristan Bastian 14 Feb '19

14 Feb '19

Another problem is, that the internal keyboard is not working on the current master. A change of the SPI deactive delay solves that. A workaround for the current master was to press [reload/refresh]+[power] button. With the second patch this is no longer needed.

2 6

[U-Boot] mx6cuboxi: Detecting wrong .dtb (v2019.01)
by Vagrant Cascadian 14 Feb '19

14 Feb '19

I *think* this board is getting the wrong fdtfile set: U-Boot 2019.01+dfsg-1 (Jan 15 2019 - 00:36:19 +0000) CPU: Freescale i.MX6Q rev1.5 996 MHz (running at 792 MHz) CPU: Extended Commercial temperature grade (-20C to 105C) at 37C Reset cause: WDOG Board: MX6 Cubox-i DRAM: 3.8 GiB MMC: FSL_SDHC: 0, FSL_SDHC: 1 Loading Environment from MMC... *** Warning - bad CRC, using default environment No panel detected: default to HDMI Display: HDMI (1024x768) In: serial Out: serial Err: serial Card did not respond to voltage select! Net: FEC Hit any key to stop autoboot: 0 => printenv som_rev som_rev=undefined => printenv has_emmc has_emmc=undefined => printenv findfdt findfdt=if test ${board_rev} = MX6Q; then setenv fdtprefix imx6q; fi; if test ${board_rev} = MX6DL; then setenv fdtprefix imx6dl; fi; if test ${som_rev} = V15; then setenv fdtsuffix -som-v15; fi; if test ${has_emmc} = yes; then setenv emmcsuffix -emmc; fi; if test ${board_name} = HUMMINGBOARD2 ; then setenv fdtfile ${fdtprefix}-hummingboard2${emmcsuffix}${fdtsuffix}.dtb; fi; if test ${board_name} = HUMMINGBOARD ; then setenv fdtfile ${fdtprefix}-hummingboard${emmcsuffix}${fdtsuffix}.dtb; fi; if test ${board_name} = CUBOXI ; t=> => run findfdt => printenv fdtfile fdtfile=imx6q-cubox-i.dtb It pretty clearly identifies itself as a rev1.5 in the boot message, but som_rev is set to undefined, and so it sets fdtfile to the default version. I haven't had a chance to check a newer version of u-boot, but I don't see any obvious changes for this board since v2019.01. My *hunch* is it's either of these two commits, since it was detecting it correctly in v2018.07: 19ed6063a567c6924dbfc358bf4ce9a60a31c567 mx6cuboxi: Use mmc_get_op_cond() to check for an eMMC 86e5a7fc13d4eb7e21630b9d421469c663dc8c77 mx6cuboxi: Add support for eMMC booting live well, vagrant

3 5

[U-Boot] [PATCH v4 1/1] avb: add support for named persistent values
by Igor Opaniuk 14 Feb '19

14 Feb '19

AVB version 1.1 introduces support for named persistent values that must be tamper evident and allows AVB to store arbitrary key-value pairs [1]. Introduce implementation of two additional AVB operations read_persistent_value()/write_persistent_value() for retrieving/storing named persistent values. Correspondent pull request in the OP-TEE OS project repo [2]. [1]: https://android.googlesource.com/platform/external/avb/+/android-9.0.0_r22 [2]: https://github.com/OP-TEE/optee_os/pull/2699 Signed-off-by: Igor Opaniuk <igor.opaniuk(a)linaro.org> --- v4: - extend tee sandbox tee driver to support persistent values - fix/re-test avb_persistent test on sandbox configuration: $ ./test/py/test.py --bd sandbox --build -s -i avb_per U-Boot 2019.01-06051-gd01806a-dirty (Jan 27 2019 - 11:56:41 +0200) Model: sandbox DRAM: 128 MiB MMC: MMC probed MMC probed MMC probed mmc2: 2 (SD), mmc1: 1 (SD), mmc0: 0 (SD) In: serial Out: vidconsole Err: vidconsole Model: sandbox SCSI: Net: eth0: eth@10002000, eth5: eth@10003000, eth3: sbe5, eth1: eth@10004000 Hit any key to stop autoboot: 0 => => avb init 1 => => avb write_pvalue test value_value Wrote 12 bytes => => avb read_pvalue test 12 Read 12 bytes, value = value_value => test/py/tests/test_avb.py . ===== 464 tests deselected by '-kavb_per' ====== === 1 passed, 464 deselected in 0.16 seconds === v3: - fix possible mem lick in avb_read_persistent/avb_write_persistent - add additional sanity checks - cover avb read_pvalue/write_pvalue commands with python tests v2: - fix output format for avb read_pvalue/write_pvalue commands - fix issue with named value buffer size cmd/avb.c | 78 ++++++++++++++++++++++++++++ common/avb_verify.c | 125 +++++++++++++++++++++++++++++++++++++++++++++ drivers/tee/sandbox.c | 80 +++++++++++++++++++++++++++++ include/tee.h | 2 + include/tee/optee_ta_avb.h | 16 ++++++ test/py/tests/test_avb.py | 16 ++++++ 6 files changed, 317 insertions(+) diff --git a/cmd/avb.c b/cmd/avb.c index ff00be4..c5af4a2 100644 --- a/cmd/avb.c +++ b/cmd/avb.c @@ -340,6 +340,76 @@ int do_avb_is_unlocked(cmd_tbl_t *cmdtp, int flag, return CMD_RET_FAILURE; } +int do_avb_read_pvalue(cmd_tbl_t *cmdtp, int flag, int argc, + char * const argv[]) +{ + const char *name; + size_t bytes; + size_t bytes_read; + void *buffer; + char *endp; + + if (!avb_ops) { + printf("AVB 2.0 is not initialized, run 'avb init' first\n"); + return CMD_RET_FAILURE; + } + + if (argc != 3) + return CMD_RET_USAGE; + + name = argv[1]; + bytes = simple_strtoul(argv[2], &endp, 10); + if (*endp && *endp != '\n') + return CMD_RET_USAGE; + + buffer = malloc(bytes); + if (!buffer) + return CMD_RET_FAILURE; + + if (avb_ops->read_persistent_value(avb_ops, name, bytes, buffer, + &bytes_read) == AVB_IO_RESULT_OK) { + printf("Read %ld bytes, value = %s\n", bytes_read, + (char *)buffer); + free(buffer); + return CMD_RET_SUCCESS; + } + + printf("Failed to read persistent value\n"); + + free(buffer); + + return CMD_RET_FAILURE; +} + +int do_avb_write_pvalue(cmd_tbl_t *cmdtp, int flag, int argc, + char * const argv[]) +{ + const char *name; + const char *value; + + if (!avb_ops) { + printf("AVB 2.0 is not initialized, run 'avb init' first\n"); + return CMD_RET_FAILURE; + } + + if (argc != 3) + return CMD_RET_USAGE; + + name = argv[1]; + value = argv[2]; + + if (avb_ops->write_persistent_value(avb_ops, name, strlen(value) + 1, + (const uint8_t *)value) == + AVB_IO_RESULT_OK) { + printf("Wrote %ld bytes\n", strlen(value) + 1); + return CMD_RET_SUCCESS; + } + + printf("Failed to write persistent value\n"); + + return CMD_RET_FAILURE; +} + static cmd_tbl_t cmd_avb[] = { U_BOOT_CMD_MKENT(init, 2, 0, do_avb_init, "", ""), U_BOOT_CMD_MKENT(read_rb, 2, 0, do_avb_read_rb, "", ""), @@ -350,6 +420,10 @@ static cmd_tbl_t cmd_avb[] = { U_BOOT_CMD_MKENT(read_part_hex, 4, 0, do_avb_read_part_hex, "", ""), U_BOOT_CMD_MKENT(write_part, 5, 0, do_avb_write_part, "", ""), U_BOOT_CMD_MKENT(verify, 1, 0, do_avb_verify_part, "", ""), +#ifdef CONFIG_OPTEE_TA_AVB + U_BOOT_CMD_MKENT(read_pvalue, 3, 0, do_avb_read_pvalue, "", ""), + U_BOOT_CMD_MKENT(write_pvalue, 3, 0, do_avb_write_pvalue, "", ""), +#endif }; static int do_avb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) @@ -384,6 +458,10 @@ U_BOOT_CMD( " partition <partname> and print to stdout\n" "avb write_part <partname> <offset> <num> <addr> - write <num> bytes to\n" " <partname> by <offset> using data from <addr>\n" +#ifdef CONFIG_OPTEE_TA_AVB + "avb read_pvalue <name> <bytes> - read a persistent value <name>\n" + "avb write_pvalue <name> <value> - write a persistent value <name>\n" +#endif "avb verify - run verification process using hash data\n" " from vbmeta structure\n" ); diff --git a/common/avb_verify.c b/common/avb_verify.c index a8c5a3e..32034d9 100644 --- a/common/avb_verify.c +++ b/common/avb_verify.c @@ -647,6 +647,10 @@ static AvbIOResult invoke_func(struct AvbOpsData *ops_data, u32 func, return AVB_IO_RESULT_OK; case TEE_ERROR_OUT_OF_MEMORY: return AVB_IO_RESULT_ERROR_OOM; + case TEE_ERROR_STORAGE_NO_SPACE: + return AVB_IO_RESULT_ERROR_INSUFFICIENT_SPACE; + case TEE_ERROR_ITEM_NOT_FOUND: + return AVB_IO_RESULT_ERROR_NO_SUCH_VALUE; case TEE_ERROR_TARGET_DEAD: /* * The TA has paniced, close the session to reload the TA @@ -847,6 +851,123 @@ static AvbIOResult get_size_of_partition(AvbOps *ops, return AVB_IO_RESULT_OK; } +static AvbIOResult read_persistent_value(AvbOps *ops, + const char *name, + size_t buffer_size, + u8 *out_buffer, + size_t *out_num_bytes_read) +{ + AvbIOResult rc; + struct tee_shm *shm_name; + struct tee_shm *shm_buf; + struct tee_param param[2]; + struct udevice *tee; + size_t name_size = strlen(name) + 1; + + if (get_open_session(ops->user_data)) + return AVB_IO_RESULT_ERROR_IO; + + tee = ((struct AvbOpsData *)ops->user_data)->tee; + + rc = tee_shm_alloc(tee, name_size, + TEE_SHM_ALLOC, &shm_name); + if (rc) + return AVB_IO_RESULT_ERROR_OOM; + + rc = tee_shm_alloc(tee, buffer_size, + TEE_SHM_ALLOC, &shm_buf); + if (rc) { + rc = AVB_IO_RESULT_ERROR_OOM; + goto free_name; + } + + memcpy(shm_name->addr, name, name_size); + + memset(param, 0, sizeof(param)); + param[0].attr = TEE_PARAM_ATTR_TYPE_MEMREF_INPUT; + param[0].u.memref.shm = shm_name; + param[0].u.memref.size = name_size; + param[1].attr = TEE_PARAM_ATTR_TYPE_MEMREF_INOUT; + param[1].u.memref.shm = shm_buf; + param[1].u.memref.size = buffer_size; + + rc = invoke_func(ops->user_data, TA_AVB_CMD_READ_PERSIST_VALUE, + 2, param); + if (rc) + goto out; + + if (param[1].u.memref.size > buffer_size) { + rc = AVB_IO_RESULT_ERROR_NO_SUCH_VALUE; + goto out; + } + + *out_num_bytes_read = param[1].u.memref.size; + + memcpy(out_buffer, shm_buf->addr, *out_num_bytes_read); + +out: + tee_shm_free(shm_buf); +free_name: + tee_shm_free(shm_name); + + return rc; +} + +static AvbIOResult write_persistent_value(AvbOps *ops, + const char *name, + size_t value_size, + const u8 *value) +{ + AvbIOResult rc; + struct tee_shm *shm_name; + struct tee_shm *shm_buf; + struct tee_param param[2]; + struct udevice *tee; + size_t name_size = strlen(name) + 1; + + if (get_open_session(ops->user_data)) + return AVB_IO_RESULT_ERROR_IO; + + tee = ((struct AvbOpsData *)ops->user_data)->tee; + + if (!value_size) + return AVB_IO_RESULT_ERROR_NO_SUCH_VALUE; + + rc = tee_shm_alloc(tee, name_size, + TEE_SHM_ALLOC, &shm_name); + if (rc) + return AVB_IO_RESULT_ERROR_OOM; + + rc = tee_shm_alloc(tee, value_size, + TEE_SHM_ALLOC, &shm_buf); + if (rc) { + rc = AVB_IO_RESULT_ERROR_OOM; + goto free_name; + } + + memcpy(shm_name->addr, name, name_size); + memcpy(shm_buf->addr, value, value_size); + + memset(param, 0, sizeof(param)); + param[0].attr = TEE_PARAM_ATTR_TYPE_MEMREF_INPUT; + param[0].u.memref.shm = shm_name; + param[0].u.memref.size = name_size; + param[1].attr = TEE_PARAM_ATTR_TYPE_MEMREF_INPUT; + param[1].u.memref.shm = shm_buf; + param[1].u.memref.size = value_size; + + rc = invoke_func(ops->user_data, TA_AVB_CMD_WRITE_PERSIST_VALUE, + 2, param); + if (rc) + goto out; + +out: + tee_shm_free(shm_buf); +free_name: + tee_shm_free(shm_name); + + return rc; +} /** * ============================================================================ * AVB2.0 AvbOps alloc/initialisation/free @@ -870,6 +991,10 @@ AvbOps *avb_ops_alloc(int boot_device) ops_data->ops.read_is_device_unlocked = read_is_device_unlocked; ops_data->ops.get_unique_guid_for_partition = get_unique_guid_for_partition; +#ifdef CONFIG_OPTEE_TA_AVB + ops_data->ops.write_persistent_value = write_persistent_value; + ops_data->ops.read_persistent_value = read_persistent_value; +#endif ops_data->ops.get_size_of_partition = get_size_of_partition; ops_data->mmc_dev = boot_device; diff --git a/drivers/tee/sandbox.c b/drivers/tee/sandbox.c index ccddb03..5fecce0 100644 --- a/drivers/tee/sandbox.c +++ b/drivers/tee/sandbox.c @@ -5,6 +5,7 @@ #include <common.h> #include <dm.h> #include <sandboxtee.h> +#include <search.h> #include <tee.h> #include <tee/optee_ta_avb.h> @@ -61,6 +62,8 @@ bad_params: static u64 ta_avb_rollback_indexes[TA_AVB_MAX_ROLLBACK_LOCATIONS]; static u32 ta_avb_lock_state; +static struct hsearch_data pstorage_htab; +static const u32 pstorage_max = 16; static u32 ta_avb_open_session(uint num_params, struct tee_param *params) { @@ -76,9 +79,13 @@ static u32 ta_avb_open_session(uint num_params, struct tee_param *params) static u32 ta_avb_invoke_func(u32 func, uint num_params, struct tee_param *params) { + ENTRY e, *ep; + char *name; u32 res; uint slot; u64 val; + char *value; + u32 value_sz; switch (func) { case TA_AVB_CMD_READ_ROLLBACK_INDEX: @@ -151,6 +158,57 @@ static u32 ta_avb_invoke_func(u32 func, uint num_params, } return TEE_SUCCESS; + case TA_AVB_CMD_READ_PERSIST_VALUE: + res = check_params(TEE_PARAM_ATTR_TYPE_MEMREF_INPUT, + TEE_PARAM_ATTR_TYPE_MEMREF_INOUT, + TEE_PARAM_ATTR_TYPE_NONE, + TEE_PARAM_ATTR_TYPE_NONE, + num_params, params); + if (res) + return res; + + name = params[0].u.memref.shm->addr; + + value = params[1].u.memref.shm->addr; + value_sz = params[1].u.memref.size; + + e.key = name; + e.data = NULL; + hsearch_r(e, FIND, &ep, &pstorage_htab, 0); + if (!ep) + return TEE_ERROR_ITEM_NOT_FOUND; + + value_sz = strlen(ep->data); + memcpy(value, ep->data, value_sz); + + return TEE_SUCCESS; + case TA_AVB_CMD_WRITE_PERSIST_VALUE: + res = check_params(TEE_PARAM_ATTR_TYPE_MEMREF_INPUT, + TEE_PARAM_ATTR_TYPE_MEMREF_INPUT, + TEE_PARAM_ATTR_TYPE_NONE, + TEE_PARAM_ATTR_TYPE_NONE, + num_params, params); + if (res) + return res; + + name = params[0].u.memref.shm->addr; + + value = params[1].u.memref.shm->addr; + value_sz = params[1].u.memref.size; + + e.key = name; + e.data = NULL; + hsearch_r(e, FIND, &ep, &pstorage_htab, 0); + if (ep) + hdelete_r(e.key, &pstorage_htab, 0); + + e.key = name; + e.data = value; + hsearch_r(e, ENTER, &ep, &pstorage_htab, 0); + if (!ep) + return TEE_ERROR_OUT_OF_MEMORY; + + return TEE_SUCCESS; default: return TEE_ERROR_NOT_SUPPORTED; @@ -285,6 +343,26 @@ static int sandbox_tee_shm_unregister(struct udevice *dev, struct tee_shm *shm) return 0; } +static int sandbox_tee_remove(struct udevice *dev) +{ + hdestroy_r(&pstorage_htab); + + return 0; +} + +static int sandbox_tee_probe(struct udevice *dev) +{ + /* + * With this hastable we emulate persistent storage, + * which should contain persistent values + * between different sessions/command invocations. + */ + if (!hcreate_r(pstorage_max, &pstorage_htab)) + return TEE_ERROR_OUT_OF_MEMORY; + + return 0; +} + static const struct tee_driver_ops sandbox_tee_ops = { .get_version = sandbox_tee_get_version, .open_session = sandbox_tee_open_session, @@ -305,4 +383,6 @@ U_BOOT_DRIVER(sandbox_tee) = { .of_match = sandbox_tee_match, .ops = &sandbox_tee_ops, .priv_auto_alloc_size = sizeof(struct sandbox_tee_state), + .probe = sandbox_tee_probe, + .remove = sandbox_tee_remove, }; diff --git a/include/tee.h b/include/tee.h index edd9f9b..02bcd9e 100644 --- a/include/tee.h +++ b/include/tee.h @@ -43,7 +43,9 @@ #define TEE_ERROR_COMMUNICATION 0xffff000e #define TEE_ERROR_SECURITY 0xffff000f #define TEE_ERROR_OUT_OF_MEMORY 0xffff000c +#define TEE_ERROR_OVERFLOW 0xffff300f #define TEE_ERROR_TARGET_DEAD 0xffff3024 +#define TEE_ERROR_STORAGE_NO_SPACE 0xffff3041 #define TEE_ORIGIN_COMMS 0x00000002 #define TEE_ORIGIN_TEE 0x00000003 diff --git a/include/tee/optee_ta_avb.h b/include/tee/optee_ta_avb.h index 074386a..949875a 100644 --- a/include/tee/optee_ta_avb.h +++ b/include/tee/optee_ta_avb.h @@ -45,4 +45,20 @@ */ #define TA_AVB_CMD_WRITE_LOCK_STATE 3 +/* + * Reads a persistent value corresponding to the given name. + * + * in params[0].u.memref: persistent value name + * out params[1].u.memref: read persistent value buffer + */ +#define TA_AVB_CMD_READ_PERSIST_VALUE 4 + +/* + * Writes a persistent value corresponding to the given name. + * + * in params[0].u.memref: persistent value name + * in params[1].u.memref: persistent value buffer to write + */ +#define TA_AVB_CMD_WRITE_PERSIST_VALUE 5 + #endif /* __TA_AVB_H */ diff --git a/test/py/tests/test_avb.py b/test/py/tests/test_avb.py index e70a010..2bb75ed 100644 --- a/test/py/tests/test_avb.py +++ b/test/py/tests/test_avb.py @@ -116,3 +116,19 @@ def test_avb_mmc_read(u_boot_console): response = u_boot_console.run_command('cmp 0x%x 0x%x 40' % (temp_addr, temp_addr2)) assert response.find('64 word') + + +(a)pytest.mark.buildconfigspec('cmd_avb') +(a)pytest.mark.buildconfigspec('optee_ta_avb') +def test_avb_persistent_values(u_boot_console): + """Test reading/writing persistent storage to avb + """ + + response = u_boot_console.run_command('avb init %s' % str(mmc_dev)) + assert response == '' + + response = u_boot_console.run_command('avb write_pvalue test value_value') + assert response == 'Wrote 12 bytes' + + response = u_boot_console.run_command('avb read_pvalue test 12') + assert response == 'Read 12 bytes, value = value_value' -- 2.7.4

3 12

[U-Boot] [PATCH v2 0/7] Add support for symlink creation in EXT4
by Jean-Jacques Hiblot 14 Feb '19

14 Feb '19

This series adds support for the creation of symbolic links on ext4 file-systems. The motivation behind this work is to have the ability to "do" the job of update-alternatives in u-boot. Firmware on TI's platform are usually managed with update-alternatives and are thus targeted by a symbolic link. In some situations we need the ability to select an alternate firmware before the linux kernel is started so that when a early driver needing the firmware comes up, it can be fed the firmware of our choice. Tested on a am57xx_evm, using a EXT4 partition on external SDcard. The filesystem can be checked later with: fsck.ext4 -f <dev> usage example: => ln mmc 0:2 zImage /boot/the_linux_kernel Changes in v2: - Prevent write access if metadata checksum is enabled - Add a FS integrity check at the end of the FS tests - Fix issue in ext4fs_delete_file() when target in not stored in an allocated block - Added python tests for symlinks under sandbox Jean-Jacques Hiblot (7): fs: ext4: do not allow writes if metadata checksum is active test: fs: disable the metadata checksums on ext4 filesystems test: fs: run fsck after on fs image after the tests are run fs: ext4: constify the buffer passed to write functions fs: ext4: Add support for the creation of symbolic links fs: Add a new command to create symbolic links test: fs: Added tests for symlinks cmd/fs.c | 14 +++ fs/ext4/ext4_common.c | 4 +- fs/ext4/ext4_common.h | 2 +- fs/ext4/ext4_write.c | 76 ++++++++++++---- fs/fs.c | 44 +++++++++ include/ext4fs.h | 6 +- include/fs.h | 2 + test/py/tests/test_fs/conftest.py | 91 +++++++++++++++++++ test/py/tests/test_fs/fstest_defs.py | 3 + test/py/tests/test_fs/test_symlink.py | 125 ++++++++++++++++++++++++++ 10 files changed, 345 insertions(+), 22 deletions(-) create mode 100644 test/py/tests/test_fs/test_symlink.py -- 2.17.1

2 19

[U-Boot] [PATCH] arm: socfpga: move gen5 SDR driver to DM
by Simon Goldschmidt 14 Feb '19

14 Feb '19

To clean up reset handling for socfpga gen5, let's move the code snippet taking the DDR controller out of reset from SPL to the DDR driver. While at it, port the ddr driver to UCLASS_RAM and use dts. Signed-off-by: Simon Goldschmidt <simon.k.r.goldschmidt(a)gmail.com> --- This is an RFC to show what the SDRAM driver moved to DM (UCLASS_RAM) would look like. It's RFC both because Dinh did not seem too fond of changing the register address of the SDR in devicetree to include what the undocumented registers 'sequencer.c' uses as well as because of my observed code growth. Basically, I want to move this to UCLASS_RAM and I want to read the reset property for SDR from devicetree. What remains RFC is: do we want/need to read the base address from devicetree, or can we live with it being hard- coded (and maybe sanity-checked during probe)? Note that converting sequencer.c from hard-coded address to pointers read from devicetree and passed around to every function increased code size by ~700 bytes. Not too much, but enough to stop my socrates board working (yes, the SPL size check does not work :-( - I'll work on that). Also note that this is an integrated patch for SoCrates to show what it would look like. In the series I prepared, it's better separated and all boards are adjusted. (And yes, checkpatch warnings/errors are fully ignored in this RFC...) Any comments? --- arch/arm/Kconfig | 2 + arch/arm/dts/socfpga.dtsi | 5 +- .../dts/socfpga_cyclone5_socrates-u-boot.dtsi | 8 + .../mach-socfpga/include/mach/sdram_gen5.h | 4 - arch/arm/mach-socfpga/spl_gen5.c | 37 +- drivers/ddr/altera/Kconfig | 1 + drivers/ddr/altera/sdram_gen5.c | 133 ++- drivers/ddr/altera/sequencer.c | 958 +++++++++--------- drivers/ddr/altera/sequencer.h | 28 +- 9 files changed, 653 insertions(+), 523 deletions(-) diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig index f0edb10003..20ccd70f10 100644 --- a/arch/arm/Kconfig +++ b/arch/arm/Kconfig @@ -815,12 +815,14 @@ config ARCH_SOCFPGA select DM_SERIAL select ENABLE_ARM_SOC_BOOT0_HOOK if TARGET_SOCFPGA_GEN5 || TARGET_SOCFPGA_ARRIA10 select OF_CONTROL + select RAM if TARGET_SOCFPGA_GEN5 select SPL_DM_RESET if DM_RESET select SPL_DM_SERIAL select SPL_LIBCOMMON_SUPPORT select SPL_LIBGENERIC_SUPPORT select SPL_NAND_SUPPORT if SPL_NAND_DENALI select SPL_OF_CONTROL + select SPL_RAM if TARGET_SOCFPGA_GEN5 select SPL_SEPARATE_BSS if TARGET_SOCFPGA_STRATIX10 select SPL_SERIAL_SUPPORT select SPL_WATCHDOG_SUPPORT diff --git a/arch/arm/dts/socfpga.dtsi b/arch/arm/dts/socfpga.dtsi index 2458d6707d..88d02c2b1a 100644 --- a/arch/arm/dts/socfpga.dtsi +++ b/arch/arm/dts/socfpga.dtsi @@ -783,9 +783,10 @@ reg = <0xfffec000 0x100>; }; - sdr: sdr@ffc25000 { + sdr: sdr@ffc20000 { compatible = "altr,sdr-ctl", "syscon"; - reg = <0xffc25000 0x1000>; + reg = <0xffc20000 0x6000>; + resets = <&rst SDR_RESET>; }; sdramedac { diff --git a/arch/arm/dts/socfpga_cyclone5_socrates-u-boot.dtsi b/arch/arm/dts/socfpga_cyclone5_socrates-u-boot.dtsi index 31bd1dba0f..ffe5a0edfe 100644 --- a/arch/arm/dts/socfpga_cyclone5_socrates-u-boot.dtsi +++ b/arch/arm/dts/socfpga_cyclone5_socrates-u-boot.dtsi @@ -21,6 +21,14 @@ status = "disabled"; }; +&rst { + u-boot,dm-pre-reloc; +}; + +&sdr { + u-boot,dm-pre-reloc; +}; + &mmc { u-boot,dm-pre-reloc; }; diff --git a/arch/arm/mach-socfpga/include/mach/sdram_gen5.h b/arch/arm/mach-socfpga/include/mach/sdram_gen5.h index a238d5d17f..c41208591a 100644 --- a/arch/arm/mach-socfpga/include/mach/sdram_gen5.h +++ b/arch/arm/mach-socfpga/include/mach/sdram_gen5.h @@ -7,10 +7,6 @@ #ifndef __ASSEMBLY__ -unsigned long sdram_calculate_size(void); -int sdram_mmr_init_full(unsigned int sdr_phy_reg); -int sdram_calibration_full(void); - const struct socfpga_sdram_config *socfpga_get_sdram_config(void); void socfpga_get_seq_ac_init(const u32 **init, unsigned int *nelem); diff --git a/arch/arm/mach-socfpga/spl_gen5.c b/arch/arm/mach-socfpga/spl_gen5.c index 4c9f7997be..7c266dd46e 100644 --- a/arch/arm/mach-socfpga/spl_gen5.c +++ b/arch/arm/mach-socfpga/spl_gen5.c @@ -20,6 +20,7 @@ #include <debug_uart.h> #include <fdtdec.h> #include <watchdog.h> +#include <dm/uclass.h> DECLARE_GLOBAL_DATA_PTR; @@ -66,9 +67,9 @@ u32 spl_boot_mode(const u32 boot_device) void board_init_f(ulong dummy) { const struct cm_config *cm_default_cfg = cm_get_default_config(); - unsigned long sdram_size; unsigned long reg; int ret; + struct udevice *dev; /* * First C code to run. Clear fake OCRAM ECC first as SBE @@ -98,7 +99,6 @@ void board_init_f(ulong dummy) socfpga_bridges_reset(1); } - socfpga_per_reset(SOCFPGA_RESET(SDR), 0); socfpga_per_reset(SOCFPGA_RESET(UART0), 0); socfpga_per_reset(SOCFPGA_RESET(OSC1TIMER0), 0); @@ -142,29 +142,24 @@ void board_init_f(ulong dummy) hang(); } - /* enable console uart printing */ - preloader_console_init(); - - if (sdram_mmr_init_full(0xffffffff) != 0) { - puts("SDRAM init failed.\n"); - hang(); - } - - debug("SDRAM: Calibrating PHY\n"); - /* SDRAM calibration */ - if (sdram_calibration_full() == 0) { - puts("SDRAM calibration failed.\n"); - hang(); + debug("checking UCLASS_RESET\n"); + ret = uclass_get_device(UCLASS_RESET, 0, &dev); + if (ret) { + debug("Reset init failed: %d\n", ret); + return; } + debug("UCLASS_RESET OK\n"); - sdram_size = sdram_calculate_size(); - debug("SDRAM: %ld MiB\n", sdram_size >> 20); + /* enable console uart printing */ + preloader_console_init(); - /* Sanity check ensure correct SDRAM size specified */ - if (get_ram_size(0, sdram_size) != sdram_size) { - puts("SDRAM size check failed!\n"); - hang(); + debug("checking UCLASS_RAM\n"); + ret = uclass_get_device(UCLASS_RAM, 0, &dev); + if (ret) { + debug("DRAM init failed: %d\n", ret); + return; } + debug("UCLASS_RAM OK\n"); if (!socfpga_is_booting_from_fpga()) socfpga_bridges_reset(1); diff --git a/drivers/ddr/altera/Kconfig b/drivers/ddr/altera/Kconfig index 2b28a97f6e..7370d4133a 100644 --- a/drivers/ddr/altera/Kconfig +++ b/drivers/ddr/altera/Kconfig @@ -1,5 +1,6 @@ config ALTERA_SDRAM bool "SoCFPGA DDR SDRAM driver" + depends on RAM depends on TARGET_SOCFPGA_GEN5 || TARGET_SOCFPGA_ARRIA10 help Enable DDR SDRAM controller for the SoCFPGA devices. diff --git a/drivers/ddr/altera/sdram_gen5.c b/drivers/ddr/altera/sdram_gen5.c index 821060459c..ff1b130614 100644 --- a/drivers/ddr/altera/sdram_gen5.c +++ b/drivers/ddr/altera/sdram_gen5.c @@ -3,14 +3,21 @@ * Copyright Altera Corporation (C) 2014-2015 */ #include <common.h> +#include <dm.h> #include <errno.h> #include <div64.h> +#include <ram.h> #include <watchdog.h> #include <asm/arch/fpga_manager.h> +#include <asm/arch/reset_manager.h> #include <asm/arch/sdram.h> #include <asm/arch/system_manager.h> #include <asm/io.h> +#include "sequencer.h" + +#ifdef CONFIG_SPL_BUILD + struct sdram_prot_rule { u32 sdram_start; /* SDRAM start address */ u32 sdram_end; /* SDRAM end address */ @@ -26,8 +33,8 @@ struct sdram_prot_rule { static struct socfpga_system_manager *sysmgr_regs = (struct socfpga_system_manager *)SOCFPGA_SYSMGR_ADDRESS; -static struct socfpga_sdr_ctrl *sdr_ctrl = - (struct socfpga_sdr_ctrl *)SDR_CTRLGRP_ADDRESS; + +static unsigned long sdram_calculate_size(struct socfpga_sdr_ctrl *sdr_ctrl); /** * get_errata_rows() - Up the number of DRAM rows to cover entire address space @@ -104,7 +111,8 @@ static int get_errata_rows(const struct socfpga_sdram_config *cfg) } /* SDRAM protection rules vary from 0-19, a total of 20 rules. */ -static void sdram_set_rule(struct sdram_prot_rule *prule) +static void sdram_set_rule(struct socfpga_sdr_ctrl *sdr_ctrl, + struct sdram_prot_rule *prule) { u32 lo_addr_bits; u32 hi_addr_bits; @@ -141,7 +149,8 @@ static void sdram_set_rule(struct sdram_prot_rule *prule) writel(0, &sdr_ctrl->prot_rule_rdwr); } -static void sdram_get_rule(struct sdram_prot_rule *prule) +static void sdram_get_rule(struct socfpga_sdr_ctrl *sdr_ctrl, + struct sdram_prot_rule *prule) { u32 addr; u32 id; @@ -172,7 +181,8 @@ static void sdram_get_rule(struct sdram_prot_rule *prule) } static void -sdram_set_protection_config(const u32 sdram_start, const u32 sdram_end) +sdram_set_protection_config(struct socfpga_sdr_ctrl *sdr_ctrl, + const u32 sdram_start, const u32 sdram_end) { struct sdram_prot_rule rule; int rules; @@ -185,7 +195,7 @@ sdram_set_protection_config(const u32 sdram_start, const u32 sdram_end) for (rules = 0; rules < 20; rules++) { rule.rule = rules; - sdram_set_rule(&rule); + sdram_set_rule(sdr_ctrl, &rule); } /* new rule: accept SDRAM */ @@ -200,13 +210,13 @@ sdram_set_protection_config(const u32 sdram_start, const u32 sdram_end) rule.rule = 0; /* set new rule */ - sdram_set_rule(&rule); + sdram_set_rule(sdr_ctrl, &rule); /* default rule: reject everything */ writel(0x3ff, &sdr_ctrl->protport_default); } -static void sdram_dump_protection_config(void) +static void sdram_dump_protection_config(struct socfpga_sdr_ctrl *sdr_ctrl) { struct sdram_prot_rule rule; int rules; @@ -216,7 +226,7 @@ static void sdram_dump_protection_config(void) for (rules = 0; rules < 20; rules++) { rule.rule = rules; - sdram_get_rule(&rule); + sdram_get_rule(sdr_ctrl, &rule); debug("Rule %d, rules ...\n", rules); debug(" sdram start %x\n", rule.sdram_start); debug(" sdram end %x\n", rule.sdram_end); @@ -322,7 +332,8 @@ static u32 sdr_get_addr_rw(const struct socfpga_sdram_config *cfg) * * This function loads the register values into the SDRAM controller block. */ -static void sdr_load_regs(const struct socfpga_sdram_config *cfg) +static void sdr_load_regs(struct socfpga_sdr_ctrl *sdr_ctrl, + const struct socfpga_sdram_config *cfg) { const u32 ctrl_cfg = sdr_get_ctrlcfg(cfg); const u32 dram_addrw = sdr_get_addr_rw(cfg); @@ -426,7 +437,8 @@ static void sdr_load_regs(const struct socfpga_sdram_config *cfg) * * Initialize the SDRAM MMR. */ -int sdram_mmr_init_full(unsigned int sdr_phy_reg) +int sdram_mmr_init_full(struct socfpga_sdr_ctrl *sdr_ctrl, + unsigned int sdr_phy_reg) { const struct socfpga_sdram_config *cfg = socfpga_get_sdram_config(); const unsigned int rows = @@ -434,9 +446,12 @@ int sdram_mmr_init_full(unsigned int sdr_phy_reg) SDR_CTRLGRP_DRAMADDRW_ROWBITS_LSB; int ret; + /* release DDR from reset */ + socfpga_per_reset(SOCFPGA_RESET(SDR), 0); + writel(rows, &sysmgr_regs->iswgrp_handoff[4]); - sdr_load_regs(cfg); + sdr_load_regs(sdr_ctrl, cfg); /* saving this value to SYSMGR.ISWGRP.HANDOFF.FPGA2SDR */ writel(cfg->fpgaport_rst, &sysmgr_regs->iswgrp_handoff[3]); @@ -459,9 +474,9 @@ int sdram_mmr_init_full(unsigned int sdr_phy_reg) SDR_CTRLGRP_STATICCFG_APPLYCFG_MASK, 1 << SDR_CTRLGRP_STATICCFG_APPLYCFG_LSB); - sdram_set_protection_config(0, sdram_calculate_size() - 1); + sdram_set_protection_config(sdr_ctrl, 0, sdram_calculate_size(sdr_ctrl) - 1); - sdram_dump_protection_config(); + sdram_dump_protection_config(sdr_ctrl); return 0; } @@ -472,7 +487,7 @@ int sdram_mmr_init_full(unsigned int sdr_phy_reg) * Calculate SDRAM device size based on SDRAM controller parameters. * Size is specified in bytes. */ -unsigned long sdram_calculate_size(void) +static unsigned long sdram_calculate_size(struct socfpga_sdr_ctrl *sdr_ctrl) { unsigned long temp; unsigned long row, bank, col, cs, width; @@ -534,3 +549,91 @@ unsigned long sdram_calculate_size(void) return temp; } + +struct altera_gen5_sdram_priv +{ + struct ram_info info; +}; + +struct altera_gen5_sdram_platdata +{ + struct socfpga_sdr *sdr; +}; + +static int altera_gen5_sdram_ofdata_to_platdata(struct udevice *dev) +{ + struct altera_gen5_sdram_platdata *plat = dev->platdata; + + plat->sdr = (struct socfpga_sdr *)devfdt_get_addr_index(dev, 0); + if (!plat->sdr) + return -ENODEV; + + return 0; +} + +static int altera_gen5_sdram_probe(struct udevice *dev) +{ + unsigned long sdram_size; + struct altera_gen5_sdram_platdata *plat = dev->platdata; + struct altera_gen5_sdram_priv *priv = dev_get_priv(dev); + struct socfpga_sdr_ctrl *sdr_ctrl = &plat->sdr->sdr_ctrl; + + puts("altera_gen5_sdram_probe\n"); + if (sdram_mmr_init_full(sdr_ctrl, 0xffffffff) != 0) { + puts("SDRAM init failed.\n"); + hang(); + } + + debug("SDRAM: Calibrating PHY\n"); + /* SDRAM calibration */ + if (sdram_calibration_full(plat->sdr) == 0) { + puts("SDRAM calibration failed.\n"); + hang(); + } + + sdram_size = sdram_calculate_size(sdr_ctrl); + debug("SDRAM: %ld MiB\n", sdram_size >> 20); + + /* Sanity check ensure correct SDRAM size specified */ + if (get_ram_size(0, sdram_size) != sdram_size) { + puts("SDRAM size check failed!\n"); + hang(); + } + + priv->info.base = 0; + priv->info.size = sdram_size; + + return 0; +} + +static int altera_gen5_sdram_get_info(struct udevice *dev, struct ram_info *info) +{ + struct altera_gen5_sdram_priv *priv = dev_get_priv(dev); + + info->base = priv->info.base; + info->size = priv->info.size; + + return 0; +} + +static struct ram_ops altera_gen5_sdram_ops = { + .get_info = altera_gen5_sdram_get_info, +}; + +static const struct udevice_id altera_gen5_sdram_ids[] = { + { .compatible = "altr,sdr-ctl" }, + { /* sentinel */ } +}; + +U_BOOT_DRIVER(altera_gen5_sdram) = { + .name = "altr_sdr_ctl", + .id = UCLASS_RAM, + .of_match = altera_gen5_sdram_ids, + .ops = &altera_gen5_sdram_ops, + .ofdata_to_platdata = altera_gen5_sdram_ofdata_to_platdata, + .platdata_auto_alloc_size = sizeof(struct altera_gen5_sdram_platdata), + .probe = altera_gen5_sdram_probe, + .priv_auto_alloc_size = sizeof(struct altera_gen5_sdram_priv), +}; + +#endif /* CONFIG_SPL_BUILD */ diff --git a/drivers/ddr/altera/sequencer.c b/drivers/ddr/altera/sequencer.c index 5e7a943b68..02ee2a0bd8 100644 --- a/drivers/ddr/altera/sequencer.c +++ b/drivers/ddr/altera/sequencer.c @@ -9,7 +9,7 @@ #include <errno.h> #include "sequencer.h" -static struct socfpga_sdr_rw_load_manager *sdr_rw_load_mgr_regs = +/*static struct socfpga_sdr_rw_load_manager *sdr_rw_load_mgr_regs = (struct socfpga_sdr_rw_load_manager *) (SDR_PHYGRP_RWMGRGRP_ADDRESS | 0x800); static struct socfpga_sdr_rw_load_jump_manager *sdr_rw_load_jump_mgr_regs = @@ -28,7 +28,7 @@ static struct socfpga_phy_mgr_cfg *phy_mgr_cfg = static struct socfpga_data_mgr *data_mgr = (struct socfpga_data_mgr *)SDR_PHYGRP_DATAMGRGRP_ADDRESS; static struct socfpga_sdr_ctrl *sdr_ctrl = - (struct socfpga_sdr_ctrl *)SDR_CTRLGRP_ADDRESS; + (struct socfpga_sdr_ctrl *)SDR_CTRLGRP_ADDRESS;*/ const struct socfpga_sdram_rw_mgr_config *rwcfg; const struct socfpga_sdram_io_config *iocfg; @@ -89,20 +89,20 @@ static void set_failing_group_stage(u32 group, u32 stage, } } -static void reg_file_set_group(u16 set_group) +static void reg_file_set_group(struct socfpga_sdr *sdr, u16 set_group) { - clrsetbits_le32(&sdr_reg_file->cur_stage, 0xffff0000, set_group << 16); + clrsetbits_le32(&sdr->sdr_reg_file.cur_stage, 0xffff0000, set_group << 16); } -static void reg_file_set_stage(u8 set_stage) +static void reg_file_set_stage(struct socfpga_sdr *sdr, u8 set_stage) { - clrsetbits_le32(&sdr_reg_file->cur_stage, 0xffff, set_stage & 0xff); + clrsetbits_le32(&sdr->sdr_reg_file.cur_stage, 0xffff, set_stage & 0xff); } -static void reg_file_set_sub_stage(u8 set_sub_stage) +static void reg_file_set_sub_stage(struct socfpga_sdr *sdr, u8 set_sub_stage) { set_sub_stage &= 0xff; - clrsetbits_le32(&sdr_reg_file->cur_stage, 0xff00, set_sub_stage << 8); + clrsetbits_le32(&sdr->sdr_reg_file.cur_stage, 0xff00, set_sub_stage << 8); } /** @@ -110,7 +110,7 @@ static void reg_file_set_sub_stage(u8 set_sub_stage) * * Initialize PHY Manager. */ -static void phy_mgr_initialize(void) +static void phy_mgr_initialize(struct socfpga_sdr *sdr) { u32 ratio; @@ -121,15 +121,15 @@ static void phy_mgr_initialize(void) * 0: AFI Mux Select * 1: DDIO Mux Select */ - writel(0x3, &phy_mgr_cfg->mux_sel); + writel(0x3, &sdr->phy_mgr_cfg.mux_sel); /* USER memory clock is not stable we begin initialization */ - writel(0, &phy_mgr_cfg->reset_mem_stbl); + writel(0, &sdr->phy_mgr_cfg.reset_mem_stbl); /* USER calibration status all set to zero */ - writel(0, &phy_mgr_cfg->cal_status); + writel(0, &sdr->phy_mgr_cfg.cal_status); - writel(0, &phy_mgr_cfg->cal_debug_info); + writel(0, &sdr->phy_mgr_cfg.cal_debug_info); /* Init params only if we do NOT skip calibration. */ if ((dyn_calib_steps & CALIB_SKIP_ALL) == CALIB_SKIP_ALL) @@ -150,7 +150,7 @@ static void phy_mgr_initialize(void) * * Set Rank and ODT mask (On-Die Termination). */ -static void set_rank_and_odt_mask(const u32 rank, const u32 odt_mode) +static void set_rank_and_odt_mask(struct socfpga_sdr *sdr, const u32 rank, const u32 odt_mode) { u32 odt_mask_0 = 0; u32 odt_mask_1 = 0; @@ -243,7 +243,7 @@ static void set_rank_and_odt_mask(const u32 rank, const u32 odt_mode) cs_and_odt_mask = (0xFF & ~(1 << rank)) | ((0xFF & odt_mask_0) << 8) | ((0xFF & odt_mask_1) << 16); - writel(cs_and_odt_mask, SDR_PHYGRP_RWMGRGRP_ADDRESS | + writel(cs_and_odt_mask, ((u32)(&sdr->rwmgr_grp)) | RW_MGR_SET_CS_AND_ODT_MASK_OFFSET); } @@ -255,9 +255,9 @@ static void set_rank_and_odt_mask(const u32 rank, const u32 odt_mode) * * This function sets the SCC Manager (Scan Chain Control Manager) register. */ -static void scc_mgr_set(u32 off, u32 grp, u32 val) +static void scc_mgr_set(struct socfpga_sdr *sdr, u32 off, u32 grp, u32 val) { - writel(val, SDR_PHYGRP_SCCGRP_ADDRESS | off | (grp << 2)); + writel(val, (void*)sdr + off + (grp << 2)); } /** @@ -265,7 +265,7 @@ static void scc_mgr_set(u32 off, u32 grp, u32 val) * * Initialize SCC Manager registers. */ -static void scc_mgr_initialize(void) +static void scc_mgr_initialize(struct socfpga_sdr *sdr) { /* * Clear register file for HPS. 16 (2^4) is the size of the @@ -278,88 +278,88 @@ static void scc_mgr_initialize(void) for (i = 0; i < 16; i++) { debug_cond(DLEVEL >= 1, "%s:%d: Clearing SCC RFILE index %u\n", __func__, __LINE__, i); - scc_mgr_set(SCC_MGR_HHP_RFILE_OFFSET, i, 0); + scc_mgr_set(sdr, SCC_MGR_HHP_RFILE_OFFSET, i, 0); } } -static void scc_mgr_set_dqdqs_output_phase(u32 write_group, u32 phase) +static void scc_mgr_set_dqdqs_output_phase(struct socfpga_sdr *sdr, u32 write_group, u32 phase) { - scc_mgr_set(SCC_MGR_DQDQS_OUT_PHASE_OFFSET, write_group, phase); + scc_mgr_set(sdr, SCC_MGR_DQDQS_OUT_PHASE_OFFSET, write_group, phase); } -static void scc_mgr_set_dqs_bus_in_delay(u32 read_group, u32 delay) +static void scc_mgr_set_dqs_bus_in_delay(struct socfpga_sdr *sdr, u32 read_group, u32 delay) { - scc_mgr_set(SCC_MGR_DQS_IN_DELAY_OFFSET, read_group, delay); + scc_mgr_set(sdr, SCC_MGR_DQS_IN_DELAY_OFFSET, read_group, delay); } -static void scc_mgr_set_dqs_en_phase(u32 read_group, u32 phase) +static void scc_mgr_set_dqs_en_phase(struct socfpga_sdr *sdr, u32 read_group, u32 phase) { - scc_mgr_set(SCC_MGR_DQS_EN_PHASE_OFFSET, read_group, phase); + scc_mgr_set(sdr, SCC_MGR_DQS_EN_PHASE_OFFSET, read_group, phase); } -static void scc_mgr_set_dqs_en_delay(u32 read_group, u32 delay) +static void scc_mgr_set_dqs_en_delay(struct socfpga_sdr *sdr, u32 read_group, u32 delay) { - scc_mgr_set(SCC_MGR_DQS_EN_DELAY_OFFSET, read_group, delay); + scc_mgr_set(sdr, SCC_MGR_DQS_EN_DELAY_OFFSET, read_group, delay); } -static void scc_mgr_set_dq_in_delay(u32 dq_in_group, u32 delay) +static void scc_mgr_set_dq_in_delay(struct socfpga_sdr *sdr, u32 dq_in_group, u32 delay) { - scc_mgr_set(SCC_MGR_IO_IN_DELAY_OFFSET, dq_in_group, delay); + scc_mgr_set(sdr, SCC_MGR_IO_IN_DELAY_OFFSET, dq_in_group, delay); } -static void scc_mgr_set_dqs_io_in_delay(u32 delay) +static void scc_mgr_set_dqs_io_in_delay(struct socfpga_sdr *sdr, u32 delay) { - scc_mgr_set(SCC_MGR_IO_IN_DELAY_OFFSET, rwcfg->mem_dq_per_write_dqs, + scc_mgr_set(sdr, SCC_MGR_IO_IN_DELAY_OFFSET, rwcfg->mem_dq_per_write_dqs, delay); } -static void scc_mgr_set_dm_in_delay(u32 dm, u32 delay) +static void scc_mgr_set_dm_in_delay(struct socfpga_sdr *sdr, u32 dm, u32 delay) { - scc_mgr_set(SCC_MGR_IO_IN_DELAY_OFFSET, + scc_mgr_set(sdr, SCC_MGR_IO_IN_DELAY_OFFSET, rwcfg->mem_dq_per_write_dqs + 1 + dm, delay); } -static void scc_mgr_set_dq_out1_delay(u32 dq_in_group, u32 delay) +static void scc_mgr_set_dq_out1_delay(struct socfpga_sdr *sdr, u32 dq_in_group, u32 delay) { - scc_mgr_set(SCC_MGR_IO_OUT1_DELAY_OFFSET, dq_in_group, delay); + scc_mgr_set(sdr, SCC_MGR_IO_OUT1_DELAY_OFFSET, dq_in_group, delay); } -static void scc_mgr_set_dqs_out1_delay(u32 delay) +static void scc_mgr_set_dqs_out1_delay(struct socfpga_sdr *sdr, u32 delay) { - scc_mgr_set(SCC_MGR_IO_OUT1_DELAY_OFFSET, rwcfg->mem_dq_per_write_dqs, + scc_mgr_set(sdr, SCC_MGR_IO_OUT1_DELAY_OFFSET, rwcfg->mem_dq_per_write_dqs, delay); } -static void scc_mgr_set_dm_out1_delay(u32 dm, u32 delay) +static void scc_mgr_set_dm_out1_delay(struct socfpga_sdr *sdr, u32 dm, u32 delay) { - scc_mgr_set(SCC_MGR_IO_OUT1_DELAY_OFFSET, + scc_mgr_set(sdr, SCC_MGR_IO_OUT1_DELAY_OFFSET, rwcfg->mem_dq_per_write_dqs + 1 + dm, delay); } /* load up dqs config settings */ -static void scc_mgr_load_dqs(u32 dqs) +static void scc_mgr_load_dqs(struct socfpga_sdr *sdr, u32 dqs) { - writel(dqs, &sdr_scc_mgr->dqs_ena); + writel(dqs, &sdr->sdr_scc_mgr.dqs_ena); } /* load up dqs io config settings */ -static void scc_mgr_load_dqs_io(void) +static void scc_mgr_load_dqs_io(struct socfpga_sdr *sdr) { - writel(0, &sdr_scc_mgr->dqs_io_ena); + writel(0, &sdr->sdr_scc_mgr.dqs_io_ena); } /* load up dq config settings */ -static void scc_mgr_load_dq(u32 dq_in_group) +static void scc_mgr_load_dq(struct socfpga_sdr *sdr, u32 dq_in_group) { - writel(dq_in_group, &sdr_scc_mgr->dq_ena); + writel(dq_in_group, &sdr->sdr_scc_mgr.dq_ena); } /* load up dm config settings */ -static void scc_mgr_load_dm(u32 dm) +static void scc_mgr_load_dm(struct socfpga_sdr *sdr, u32 dm) { - writel(dm, &sdr_scc_mgr->dm_ena); + writel(dm, &sdr->sdr_scc_mgr.dm_ena); } /** @@ -372,23 +372,23 @@ static void scc_mgr_load_dm(u32 dm) * This function sets the SCC Manager (Scan Chain Control Manager) register * and optionally triggers the SCC update for all ranks. */ -static void scc_mgr_set_all_ranks(const u32 off, const u32 grp, const u32 val, +static void scc_mgr_set_all_ranks(struct socfpga_sdr *sdr, const u32 off, const u32 grp, const u32 val, const int update) { u32 r; for (r = 0; r < rwcfg->mem_number_of_ranks; r += NUM_RANKS_PER_SHADOW_REG) { - scc_mgr_set(off, grp, val); + scc_mgr_set(sdr, off, grp, val); if (update || (r == 0)) { - writel(grp, &sdr_scc_mgr->dqs_ena); - writel(0, &sdr_scc_mgr->update); + writel(grp, &sdr->sdr_scc_mgr.dqs_ena); + writel(0, &sdr->sdr_scc_mgr.update); } } } -static void scc_mgr_set_dqs_en_phase_all_ranks(u32 read_group, u32 phase) +static void scc_mgr_set_dqs_en_phase_all_ranks(struct socfpga_sdr *sdr, u32 read_group, u32 phase) { /* * USER although the h/w doesn't support different phases per @@ -398,11 +398,11 @@ static void scc_mgr_set_dqs_en_phase_all_ranks(u32 read_group, u32 phase) * for efficiency, the scan chain update should occur only * once to sr0. */ - scc_mgr_set_all_ranks(SCC_MGR_DQS_EN_PHASE_OFFSET, + scc_mgr_set_all_ranks(sdr, SCC_MGR_DQS_EN_PHASE_OFFSET, read_group, phase, 0); } -static void scc_mgr_set_dqdqs_output_phase_all_ranks(u32 write_group, +static void scc_mgr_set_dqdqs_output_phase_all_ranks(struct socfpga_sdr *sdr, u32 write_group, u32 phase) { /* @@ -413,11 +413,11 @@ static void scc_mgr_set_dqdqs_output_phase_all_ranks(u32 write_group, * for efficiency, the scan chain update should occur only * once to sr0. */ - scc_mgr_set_all_ranks(SCC_MGR_DQDQS_OUT_PHASE_OFFSET, + scc_mgr_set_all_ranks(sdr, SCC_MGR_DQDQS_OUT_PHASE_OFFSET, write_group, phase, 0); } -static void scc_mgr_set_dqs_en_delay_all_ranks(u32 read_group, +static void scc_mgr_set_dqs_en_delay_all_ranks(struct socfpga_sdr *sdr, u32 read_group, u32 delay) { /* @@ -428,7 +428,7 @@ static void scc_mgr_set_dqs_en_delay_all_ranks(u32 read_group, * select_shadow_regs_for_update with update_scan_chains * set to 0. */ - scc_mgr_set_all_ranks(SCC_MGR_DQS_EN_DELAY_OFFSET, + scc_mgr_set_all_ranks(sdr, SCC_MGR_DQS_EN_DELAY_OFFSET, read_group, delay, 1); } @@ -439,7 +439,7 @@ static void scc_mgr_set_dqs_en_delay_all_ranks(u32 read_group, * * This function sets the OCT output delay in SCC manager. */ -static void scc_mgr_set_oct_out1_delay(const u32 write_group, const u32 delay) +static void scc_mgr_set_oct_out1_delay(struct socfpga_sdr *sdr, const u32 write_group, const u32 delay) { const int ratio = rwcfg->mem_if_read_dqs_width / rwcfg->mem_if_write_dqs_width; @@ -453,7 +453,7 @@ static void scc_mgr_set_oct_out1_delay(const u32 write_group, const u32 delay) * the setting must be set multiple times. */ for (i = 0; i < ratio; i++) - scc_mgr_set(SCC_MGR_OCT_OUT1_DELAY_OFFSET, base + i, delay); + scc_mgr_set(sdr, SCC_MGR_OCT_OUT1_DELAY_OFFSET, base + i, delay); } /** @@ -461,7 +461,7 @@ static void scc_mgr_set_oct_out1_delay(const u32 write_group, const u32 delay) * * Load the fixed setting in the SCC manager HHP extras. */ -static void scc_mgr_set_hhp_extras(void) +static void scc_mgr_set_hhp_extras(struct socfpga_sdr *sdr) { /* * Load the fixed setting in the SCC manager @@ -474,7 +474,7 @@ static void scc_mgr_set_hhp_extras(void) */ const u32 value = (0 << 8) | (0 << 7) | (1 << 5) | (1 << 2) | (1 << 1) | (1 << 0); - const u32 addr = SDR_PHYGRP_SCCGRP_ADDRESS | + const u32 addr = (u32)sdr | SCC_MGR_HHP_GLOBALS_OFFSET | SCC_MGR_HHP_EXTRAS_OFFSET; @@ -490,7 +490,7 @@ static void scc_mgr_set_hhp_extras(void) * * Zero all DQS config. */ -static void scc_mgr_zero_all(void) +static void scc_mgr_zero_all(struct socfpga_sdr *sdr) { int i, r; @@ -506,21 +506,21 @@ static void scc_mgr_zero_all(void) * but there's no harm updating them several times, so * let's keep the code simple. */ - scc_mgr_set_dqs_bus_in_delay(i, iocfg->dqs_in_reserve); - scc_mgr_set_dqs_en_phase(i, 0); - scc_mgr_set_dqs_en_delay(i, 0); + scc_mgr_set_dqs_bus_in_delay(sdr, i, iocfg->dqs_in_reserve); + scc_mgr_set_dqs_en_phase(sdr, i, 0); + scc_mgr_set_dqs_en_delay(sdr, i, 0); } for (i = 0; i < rwcfg->mem_if_write_dqs_width; i++) { - scc_mgr_set_dqdqs_output_phase(i, 0); + scc_mgr_set_dqdqs_output_phase(sdr, i, 0); /* Arria V/Cyclone V don't have out2. */ - scc_mgr_set_oct_out1_delay(i, iocfg->dqs_out_reserve); + scc_mgr_set_oct_out1_delay(sdr, i, iocfg->dqs_out_reserve); } } /* Multicast to all DQS group enables. */ - writel(0xff, &sdr_scc_mgr->dqs_ena); - writel(0, &sdr_scc_mgr->update); + writel(0xff, &sdr->sdr_scc_mgr.dqs_ena); + writel(0, &sdr->sdr_scc_mgr.update); } /** @@ -529,20 +529,20 @@ static void scc_mgr_zero_all(void) * * Set bypass mode and trigger SCC update. */ -static void scc_set_bypass_mode(const u32 write_group) +static void scc_set_bypass_mode(struct socfpga_sdr *sdr, const u32 write_group) { /* Multicast to all DQ enables. */ - writel(0xff, &sdr_scc_mgr->dq_ena); - writel(0xff, &sdr_scc_mgr->dm_ena); + writel(0xff, &sdr->sdr_scc_mgr.dq_ena); + writel(0xff, &sdr->sdr_scc_mgr.dm_ena); /* Update current DQS IO enable. */ - writel(0, &sdr_scc_mgr->dqs_io_ena); + writel(0, &sdr->sdr_scc_mgr.dqs_io_ena); /* Update the DQS logic. */ - writel(write_group, &sdr_scc_mgr->dqs_ena); + writel(write_group, &sdr->sdr_scc_mgr.dqs_ena); /* Hit update. */ - writel(0, &sdr_scc_mgr->update); + writel(0, &sdr->sdr_scc_mgr.update); } /** @@ -551,7 +551,7 @@ static void scc_set_bypass_mode(const u32 write_group) * * Load DQS settings for Write Group, do not trigger SCC update. */ -static void scc_mgr_load_dqs_for_write_group(const u32 write_group) +static void scc_mgr_load_dqs_for_write_group(struct socfpga_sdr *sdr, const u32 write_group) { const int ratio = rwcfg->mem_if_read_dqs_width / rwcfg->mem_if_write_dqs_width; @@ -565,7 +565,7 @@ static void scc_mgr_load_dqs_for_write_group(const u32 write_group) * the setting must be set multiple times. */ for (i = 0; i < ratio; i++) - writel(base + i, &sdr_scc_mgr->dqs_ena); + writel(base + i, &sdr->sdr_scc_mgr.dqs_ena); } /** @@ -573,7 +573,7 @@ static void scc_mgr_load_dqs_for_write_group(const u32 write_group) * * Zero DQ, DM, DQS and OCT configs for a group. */ -static void scc_mgr_zero_group(const u32 write_group, const int out_only) +static void scc_mgr_zero_group(struct socfpga_sdr *sdr, const u32 write_group, const int out_only) { int i, r; @@ -581,38 +581,38 @@ static void scc_mgr_zero_group(const u32 write_group, const int out_only) r += NUM_RANKS_PER_SHADOW_REG) { /* Zero all DQ config settings. */ for (i = 0; i < rwcfg->mem_dq_per_write_dqs; i++) { - scc_mgr_set_dq_out1_delay(i, 0); + scc_mgr_set_dq_out1_delay(sdr, i, 0); if (!out_only) - scc_mgr_set_dq_in_delay(i, 0); + scc_mgr_set_dq_in_delay(sdr, i, 0); } /* Multicast to all DQ enables. */ - writel(0xff, &sdr_scc_mgr->dq_ena); + writel(0xff, &sdr->sdr_scc_mgr.dq_ena); /* Zero all DM config settings. */ for (i = 0; i < RW_MGR_NUM_DM_PER_WRITE_GROUP; i++) { if (!out_only) - scc_mgr_set_dm_in_delay(i, 0); - scc_mgr_set_dm_out1_delay(i, 0); + scc_mgr_set_dm_in_delay(sdr, i, 0); + scc_mgr_set_dm_out1_delay(sdr, i, 0); } /* Multicast to all DM enables. */ - writel(0xff, &sdr_scc_mgr->dm_ena); + writel(0xff, &sdr->sdr_scc_mgr.dm_ena); /* Zero all DQS IO settings. */ if (!out_only) - scc_mgr_set_dqs_io_in_delay(0); + scc_mgr_set_dqs_io_in_delay(sdr, 0); /* Arria V/Cyclone V don't have out2. */ - scc_mgr_set_dqs_out1_delay(iocfg->dqs_out_reserve); - scc_mgr_set_oct_out1_delay(write_group, iocfg->dqs_out_reserve); - scc_mgr_load_dqs_for_write_group(write_group); + scc_mgr_set_dqs_out1_delay(sdr, iocfg->dqs_out_reserve); + scc_mgr_set_oct_out1_delay(sdr, write_group, iocfg->dqs_out_reserve); + scc_mgr_load_dqs_for_write_group(sdr, write_group); /* Multicast to all DQS IO enables (only 1 in total). */ - writel(0, &sdr_scc_mgr->dqs_io_ena); + writel(0, &sdr->sdr_scc_mgr.dqs_io_ena); /* Hit update to zero everything. */ - writel(0, &sdr_scc_mgr->update); + writel(0, &sdr->sdr_scc_mgr.update); } } @@ -620,13 +620,13 @@ static void scc_mgr_zero_group(const u32 write_group, const int out_only) * apply and load a particular input delay for the DQ pins in a group * group_bgn is the index of the first dq pin (in the write group) */ -static void scc_mgr_apply_group_dq_in_delay(u32 group_bgn, u32 delay) +static void scc_mgr_apply_group_dq_in_delay(struct socfpga_sdr *sdr, u32 group_bgn, u32 delay) { u32 i, p; for (i = 0, p = group_bgn; i < rwcfg->mem_dq_per_read_dqs; i++, p++) { - scc_mgr_set_dq_in_delay(p, delay); - scc_mgr_load_dq(p); + scc_mgr_set_dq_in_delay(sdr, p, delay); + scc_mgr_load_dq(sdr, p); } } @@ -636,37 +636,37 @@ static void scc_mgr_apply_group_dq_in_delay(u32 group_bgn, u32 delay) * * Apply and load a particular output delay for the DQ pins in a group. */ -static void scc_mgr_apply_group_dq_out1_delay(const u32 delay) +static void scc_mgr_apply_group_dq_out1_delay(struct socfpga_sdr *sdr, const u32 delay) { int i; for (i = 0; i < rwcfg->mem_dq_per_write_dqs; i++) { - scc_mgr_set_dq_out1_delay(i, delay); - scc_mgr_load_dq(i); + scc_mgr_set_dq_out1_delay(sdr, i, delay); + scc_mgr_load_dq(sdr, i); } } /* apply and load a particular output delay for the DM pins in a group */ -static void scc_mgr_apply_group_dm_out1_delay(u32 delay1) +static void scc_mgr_apply_group_dm_out1_delay(struct socfpga_sdr *sdr, u32 delay1) { u32 i; for (i = 0; i < RW_MGR_NUM_DM_PER_WRITE_GROUP; i++) { - scc_mgr_set_dm_out1_delay(i, delay1); - scc_mgr_load_dm(i); + scc_mgr_set_dm_out1_delay(sdr, i, delay1); + scc_mgr_load_dm(sdr, i); } } /* apply and load delay on both DQS and OCT out1 */ -static void scc_mgr_apply_group_dqs_io_and_oct_out1(u32 write_group, +static void scc_mgr_apply_group_dqs_io_and_oct_out1(struct socfpga_sdr *sdr, u32 write_group, u32 delay) { - scc_mgr_set_dqs_out1_delay(delay); - scc_mgr_load_dqs_io(); + scc_mgr_set_dqs_out1_delay(sdr, delay); + scc_mgr_load_dqs_io(sdr); - scc_mgr_set_oct_out1_delay(write_group, delay); - scc_mgr_load_dqs_for_write_group(write_group); + scc_mgr_set_oct_out1_delay(sdr, write_group, delay); + scc_mgr_load_dqs_for_write_group(sdr, write_group); } /** @@ -676,18 +676,18 @@ static void scc_mgr_apply_group_dqs_io_and_oct_out1(u32 write_group, * * Apply a delay to the entire output side: DQ, DM, DQS, OCT. */ -static void scc_mgr_apply_group_all_out_delay_add(const u32 write_group, +static void scc_mgr_apply_group_all_out_delay_add(struct socfpga_sdr *sdr, const u32 write_group, const u32 delay) { u32 i, new_delay; /* DQ shift */ for (i = 0; i < rwcfg->mem_dq_per_write_dqs; i++) - scc_mgr_load_dq(i); + scc_mgr_load_dq(sdr, i); /* DM shift */ for (i = 0; i < RW_MGR_NUM_DM_PER_WRITE_GROUP; i++) - scc_mgr_load_dm(i); + scc_mgr_load_dm(sdr, i); /* DQS shift */ new_delay = READ_SCC_DQS_IO_OUT2_DELAY + delay; @@ -698,10 +698,10 @@ static void scc_mgr_apply_group_all_out_delay_add(const u32 write_group, iocfg->io_out2_delay_max, new_delay - iocfg->io_out2_delay_max); new_delay -= iocfg->io_out2_delay_max; - scc_mgr_set_dqs_out1_delay(new_delay); + scc_mgr_set_dqs_out1_delay(sdr, new_delay); } - scc_mgr_load_dqs_io(); + scc_mgr_load_dqs_io(sdr); /* OCT shift */ new_delay = READ_SCC_OCT_OUT2_DELAY + delay; @@ -712,10 +712,10 @@ static void scc_mgr_apply_group_all_out_delay_add(const u32 write_group, new_delay, iocfg->io_out2_delay_max, new_delay - iocfg->io_out2_delay_max); new_delay -= iocfg->io_out2_delay_max; - scc_mgr_set_oct_out1_delay(write_group, new_delay); + scc_mgr_set_oct_out1_delay(sdr, write_group, new_delay); } - scc_mgr_load_dqs_for_write_group(write_group); + scc_mgr_load_dqs_for_write_group(sdr, write_group); } /** @@ -726,15 +726,15 @@ static void scc_mgr_apply_group_all_out_delay_add(const u32 write_group, * Apply a delay to the entire output side (DQ, DM, DQS, OCT) to all ranks. */ static void -scc_mgr_apply_group_all_out_delay_add_all_ranks(const u32 write_group, +scc_mgr_apply_group_all_out_delay_add_all_ranks(struct socfpga_sdr *sdr, const u32 write_group, const u32 delay) { int r; for (r = 0; r < rwcfg->mem_number_of_ranks; r += NUM_RANKS_PER_SHADOW_REG) { - scc_mgr_apply_group_all_out_delay_add(write_group, delay); - writel(0, &sdr_scc_mgr->update); + scc_mgr_apply_group_all_out_delay_add(sdr, write_group, delay); + writel(0, &sdr->sdr_scc_mgr.update); } } @@ -744,15 +744,15 @@ scc_mgr_apply_group_all_out_delay_add_all_ranks(const u32 write_group, * Optimization used to recover some slots in ddr3 inst_rom could be * applied to other protocols if we wanted to */ -static void set_jump_as_return(void) +static void set_jump_as_return(struct socfpga_sdr *sdr) { /* * To save space, we replace return with jump to special shared * RETURN instruction so we set the counter to large value so that * we always jump. */ - writel(0xff, &sdr_rw_load_mgr_regs->load_cntr0); - writel(rwcfg->rreturn, &sdr_rw_load_jump_mgr_regs->load_jump_add0); + writel(0xff, &sdr->sdr_rw_load_mgr_regs.load_cntr0); + writel(rwcfg->rreturn, &sdr->sdr_rw_load_jump_mgr_regs.load_jump_add0); } /** @@ -761,7 +761,7 @@ static void set_jump_as_return(void) * * Delay for N memory clocks. */ -static void delay_for_n_mem_clocks(const u32 clocks) +static void delay_for_n_mem_clocks(struct socfpga_sdr *sdr, const u32 clocks) { u32 afi_clocks; u16 c_loop; @@ -805,29 +805,29 @@ static void delay_for_n_mem_clocks(const u32 clocks) */ if (afi_clocks < 0x100) { writel(SKIP_DELAY_LOOP_VALUE_OR_ZERO(inner), - &sdr_rw_load_mgr_regs->load_cntr1); + &sdr->sdr_rw_load_mgr_regs.load_cntr1); writel(rwcfg->idle_loop1, - &sdr_rw_load_jump_mgr_regs->load_jump_add1); + &sdr->sdr_rw_load_jump_mgr_regs.load_jump_add1); - writel(rwcfg->idle_loop1, SDR_PHYGRP_RWMGRGRP_ADDRESS | + writel(rwcfg->idle_loop1, ((u32)(&sdr->rwmgr_grp)) | RW_MGR_RUN_SINGLE_GROUP_OFFSET); } else { writel(SKIP_DELAY_LOOP_VALUE_OR_ZERO(inner), - &sdr_rw_load_mgr_regs->load_cntr0); + &sdr->sdr_rw_load_mgr_regs.load_cntr0); writel(SKIP_DELAY_LOOP_VALUE_OR_ZERO(outer), - &sdr_rw_load_mgr_regs->load_cntr1); + &sdr->sdr_rw_load_mgr_regs.load_cntr1); writel(rwcfg->idle_loop2, - &sdr_rw_load_jump_mgr_regs->load_jump_add0); + &sdr->sdr_rw_load_jump_mgr_regs.load_jump_add0); writel(rwcfg->idle_loop2, - &sdr_rw_load_jump_mgr_regs->load_jump_add1); + &sdr->sdr_rw_load_jump_mgr_regs.load_jump_add1); do { writel(rwcfg->idle_loop2, - SDR_PHYGRP_RWMGRGRP_ADDRESS | + ((u32)(&sdr->rwmgr_grp)) | RW_MGR_RUN_SINGLE_GROUP_OFFSET); } while (c_loop-- != 0); } @@ -843,23 +843,23 @@ static void delay_for_n_mem_clocks(const u32 clocks) * * Load instruction registers. */ -static void rw_mgr_mem_init_load_regs(u32 cntr0, u32 cntr1, u32 cntr2, u32 jump) +static void rw_mgr_mem_init_load_regs(struct socfpga_sdr *sdr, u32 cntr0, u32 cntr1, u32 cntr2, u32 jump) { - u32 grpaddr = SDR_PHYGRP_RWMGRGRP_ADDRESS | + u32 grpaddr = ((u32)(&sdr->rwmgr_grp)) | RW_MGR_RUN_SINGLE_GROUP_OFFSET; /* Load counters */ writel(SKIP_DELAY_LOOP_VALUE_OR_ZERO(cntr0), - &sdr_rw_load_mgr_regs->load_cntr0); + &sdr->sdr_rw_load_mgr_regs.load_cntr0); writel(SKIP_DELAY_LOOP_VALUE_OR_ZERO(cntr1), - &sdr_rw_load_mgr_regs->load_cntr1); + &sdr->sdr_rw_load_mgr_regs.load_cntr1); writel(SKIP_DELAY_LOOP_VALUE_OR_ZERO(cntr2), - &sdr_rw_load_mgr_regs->load_cntr2); + &sdr->sdr_rw_load_mgr_regs.load_cntr2); /* Load jump address */ - writel(jump, &sdr_rw_load_jump_mgr_regs->load_jump_add0); - writel(jump, &sdr_rw_load_jump_mgr_regs->load_jump_add1); - writel(jump, &sdr_rw_load_jump_mgr_regs->load_jump_add2); + writel(jump, &sdr->sdr_rw_load_jump_mgr_regs.load_jump_add0); + writel(jump, &sdr->sdr_rw_load_jump_mgr_regs.load_jump_add1); + writel(jump, &sdr->sdr_rw_load_jump_mgr_regs.load_jump_add2); /* Execute count instruction */ writel(jump, grpaddr); @@ -873,16 +873,16 @@ static void rw_mgr_mem_init_load_regs(u32 cntr0, u32 cntr1, u32 cntr2, u32 jump) * * Load user calibration values and optionally precharge the banks. */ -static void rw_mgr_mem_load_user(const u32 fin1, const u32 fin2, +static void rw_mgr_mem_load_user(struct socfpga_sdr *sdr, const u32 fin1, const u32 fin2, const int precharge) { - u32 grpaddr = SDR_PHYGRP_RWMGRGRP_ADDRESS | + u32 grpaddr = ((u32)(&sdr->rwmgr_grp)) | RW_MGR_RUN_SINGLE_GROUP_OFFSET; u32 r; for (r = 0; r < rwcfg->mem_number_of_ranks; r++) { /* set rank */ - set_rank_and_odt_mask(r, RW_MGR_ODT_MODE_OFF); + set_rank_and_odt_mask(sdr, r, RW_MGR_ODT_MODE_OFF); /* precharge all banks ... */ if (precharge) @@ -893,38 +893,38 @@ static void rw_mgr_mem_load_user(const u32 fin1, const u32 fin2, * mirrorring is on */ if ((rwcfg->mem_address_mirroring >> r) & 0x1) { - set_jump_as_return(); + set_jump_as_return(sdr); writel(rwcfg->mrs2_mirr, grpaddr); - delay_for_n_mem_clocks(4); - set_jump_as_return(); + delay_for_n_mem_clocks(sdr, 4); + set_jump_as_return(sdr); writel(rwcfg->mrs3_mirr, grpaddr); - delay_for_n_mem_clocks(4); - set_jump_as_return(); + delay_for_n_mem_clocks(sdr, 4); + set_jump_as_return(sdr); writel(rwcfg->mrs1_mirr, grpaddr); - delay_for_n_mem_clocks(4); - set_jump_as_return(); + delay_for_n_mem_clocks(sdr, 4); + set_jump_as_return(sdr); writel(fin1, grpaddr); } else { - set_jump_as_return(); + set_jump_as_return(sdr); writel(rwcfg->mrs2, grpaddr); - delay_for_n_mem_clocks(4); - set_jump_as_return(); + delay_for_n_mem_clocks(sdr, 4); + set_jump_as_return(sdr); writel(rwcfg->mrs3, grpaddr); - delay_for_n_mem_clocks(4); - set_jump_as_return(); + delay_for_n_mem_clocks(sdr, 4); + set_jump_as_return(sdr); writel(rwcfg->mrs1, grpaddr); - set_jump_as_return(); + set_jump_as_return(sdr); writel(fin2, grpaddr); } if (precharge) continue; - set_jump_as_return(); + set_jump_as_return(sdr); writel(rwcfg->zqcl, grpaddr); /* tZQinit = tDLLK = 512 ck cycles */ - delay_for_n_mem_clocks(512); + delay_for_n_mem_clocks(sdr, 512); } } @@ -933,12 +933,12 @@ static void rw_mgr_mem_load_user(const u32 fin1, const u32 fin2, * * Initialize RW Manager. */ -static void rw_mgr_mem_initialize(void) +static void rw_mgr_mem_initialize(struct socfpga_sdr *sdr) { debug("%s:%d\n", __func__, __LINE__); /* The reset / cke part of initialization is broadcasted to all ranks */ - writel(RW_MGR_RANK_ALL, SDR_PHYGRP_RWMGRGRP_ADDRESS | + writel(RW_MGR_RANK_ALL, ((u32)(&sdr->rwmgr_grp)) | RW_MGR_SET_CS_AND_ODT_MASK_OFFSET); /* @@ -964,13 +964,13 @@ static void rw_mgr_mem_initialize(void) * One possible solution is n = 0 , a = 256 , b = 106 => a = FF, * b = 6A */ - rw_mgr_mem_init_load_regs(misccfg->tinit_cntr0_val, + rw_mgr_mem_init_load_regs(sdr, misccfg->tinit_cntr0_val, misccfg->tinit_cntr1_val, misccfg->tinit_cntr2_val, rwcfg->init_reset_0_cke_0); /* Indicate that memory is stable. */ - writel(1, &phy_mgr_cfg->reset_mem_stbl); + writel(1, &sdr->phy_mgr_cfg.reset_mem_stbl); /* * transition the RESET to high @@ -986,7 +986,7 @@ static void rw_mgr_mem_initialize(void) * One possible solution is n = 2 , a = 131 , b = 256 => a = 83, * b = FF */ - rw_mgr_mem_init_load_regs(misccfg->treset_cntr0_val, + rw_mgr_mem_init_load_regs(sdr, misccfg->treset_cntr0_val, misccfg->treset_cntr1_val, misccfg->treset_cntr2_val, rwcfg->init_reset_1_cke_0); @@ -994,9 +994,9 @@ static void rw_mgr_mem_initialize(void) /* Bring up clock enable. */ /* tXRP < 250 ck cycles */ - delay_for_n_mem_clocks(250); + delay_for_n_mem_clocks(sdr, 250); - rw_mgr_mem_load_user(rwcfg->mrs0_dll_reset_mirr, rwcfg->mrs0_dll_reset, + rw_mgr_mem_load_user(sdr, rwcfg->mrs0_dll_reset_mirr, rwcfg->mrs0_dll_reset, 0); } @@ -1006,9 +1006,9 @@ static void rw_mgr_mem_initialize(void) * At the end of calibration we have to program the user settings in * and hand off the memory to the user. */ -static void rw_mgr_mem_handoff(void) +static void rw_mgr_mem_handoff(struct socfpga_sdr *sdr) { - rw_mgr_mem_load_user(rwcfg->mrs0_user_mirr, rwcfg->mrs0_user, 1); + rw_mgr_mem_load_user(sdr, rwcfg->mrs0_user_mirr, rwcfg->mrs0_user, 1); /* * Need to wait tMOD (12CK or 15ns) time before issuing other * commands, but we will have plenty of NIOS cycles before actual @@ -1024,7 +1024,7 @@ static void rw_mgr_mem_handoff(void) * Issue write test command. Two variants are provided, one that just tests * a write pattern and another that tests datamask functionality. */ -static void rw_mgr_mem_calibrate_write_test_issue(u32 group, +static void rw_mgr_mem_calibrate_write_test_issue(struct socfpga_sdr *sdr, u32 group, u32 test_dm) { const u32 quick_write_mode = @@ -1068,21 +1068,21 @@ static void rw_mgr_mem_calibrate_write_test_issue(u32 group, * instruction that sends out the data. We set the counter to a * large number so that the jump is always taken. */ - writel(0xFF, &sdr_rw_load_mgr_regs->load_cntr2); + writel(0xFF, &sdr->sdr_rw_load_mgr_regs.load_cntr2); /* CNTR 3 - Not used */ if (test_dm) { mcc_instruction = rwcfg->lfsr_wr_rd_dm_bank_0_wl_1; writel(rwcfg->lfsr_wr_rd_dm_bank_0_data, - &sdr_rw_load_jump_mgr_regs->load_jump_add2); + &sdr->sdr_rw_load_jump_mgr_regs.load_jump_add2); writel(rwcfg->lfsr_wr_rd_dm_bank_0_nop, - &sdr_rw_load_jump_mgr_regs->load_jump_add3); + &sdr->sdr_rw_load_jump_mgr_regs.load_jump_add3); } else { mcc_instruction = rwcfg->lfsr_wr_rd_bank_0_wl_1; writel(rwcfg->lfsr_wr_rd_bank_0_data, - &sdr_rw_load_jump_mgr_regs->load_jump_add2); + &sdr->sdr_rw_load_jump_mgr_regs.load_jump_add2); writel(rwcfg->lfsr_wr_rd_bank_0_nop, - &sdr_rw_load_jump_mgr_regs->load_jump_add3); + &sdr->sdr_rw_load_jump_mgr_regs.load_jump_add3); } } else if (rw_wl_nop_cycles == 0) { /* @@ -1090,17 +1090,17 @@ static void rw_mgr_mem_calibrate_write_test_issue(u32 group, * to the DQS enable instruction. We set the counter to a large * number so that the jump is always taken. */ - writel(0xFF, &sdr_rw_load_mgr_regs->load_cntr2); + writel(0xFF, &sdr->sdr_rw_load_mgr_regs.load_cntr2); /* CNTR 3 - Not used */ if (test_dm) { mcc_instruction = rwcfg->lfsr_wr_rd_dm_bank_0; writel(rwcfg->lfsr_wr_rd_dm_bank_0_dqs, - &sdr_rw_load_jump_mgr_regs->load_jump_add2); + &sdr->sdr_rw_load_jump_mgr_regs.load_jump_add2); } else { mcc_instruction = rwcfg->lfsr_wr_rd_bank_0; writel(rwcfg->lfsr_wr_rd_bank_0_dqs, - &sdr_rw_load_jump_mgr_regs->load_jump_add2); + &sdr->sdr_rw_load_jump_mgr_regs.load_jump_add2); } } else { /* @@ -1108,50 +1108,50 @@ static void rw_mgr_mem_calibrate_write_test_issue(u32 group, * and NOT take the jump. So we set the counter to 0. The jump * address doesn't count. */ - writel(0x0, &sdr_rw_load_mgr_regs->load_cntr2); - writel(0x0, &sdr_rw_load_jump_mgr_regs->load_jump_add2); + writel(0x0, &sdr->sdr_rw_load_mgr_regs.load_cntr2); + writel(0x0, &sdr->sdr_rw_load_jump_mgr_regs.load_jump_add2); /* * CNTR 3 - Set the nop counter to the number of cycles we * need to loop for, minus 1. */ - writel(rw_wl_nop_cycles - 1, &sdr_rw_load_mgr_regs->load_cntr3); + writel(rw_wl_nop_cycles - 1, &sdr->sdr_rw_load_mgr_regs.load_cntr3); if (test_dm) { mcc_instruction = rwcfg->lfsr_wr_rd_dm_bank_0; writel(rwcfg->lfsr_wr_rd_dm_bank_0_nop, - &sdr_rw_load_jump_mgr_regs->load_jump_add3); + &sdr->sdr_rw_load_jump_mgr_regs.load_jump_add3); } else { mcc_instruction = rwcfg->lfsr_wr_rd_bank_0; writel(rwcfg->lfsr_wr_rd_bank_0_nop, - &sdr_rw_load_jump_mgr_regs->load_jump_add3); + &sdr->sdr_rw_load_jump_mgr_regs.load_jump_add3); } } - writel(0, SDR_PHYGRP_RWMGRGRP_ADDRESS | + writel(0, ((u32)(&sdr->rwmgr_grp)) | RW_MGR_RESET_READ_DATAPATH_OFFSET); if (quick_write_mode) - writel(0x08, &sdr_rw_load_mgr_regs->load_cntr0); + writel(0x08, &sdr->sdr_rw_load_mgr_regs.load_cntr0); else - writel(0x40, &sdr_rw_load_mgr_regs->load_cntr0); + writel(0x40, &sdr->sdr_rw_load_mgr_regs.load_cntr0); - writel(mcc_instruction, &sdr_rw_load_jump_mgr_regs->load_jump_add0); + writel(mcc_instruction, &sdr->sdr_rw_load_jump_mgr_regs.load_jump_add0); /* * CNTR 1 - This is used to ensure enough time elapses * for read data to come back. */ - writel(0x30, &sdr_rw_load_mgr_regs->load_cntr1); + writel(0x30, &sdr->sdr_rw_load_mgr_regs.load_cntr1); if (test_dm) { writel(rwcfg->lfsr_wr_rd_dm_bank_0_wait, - &sdr_rw_load_jump_mgr_regs->load_jump_add1); + &sdr->sdr_rw_load_jump_mgr_regs.load_jump_add1); } else { writel(rwcfg->lfsr_wr_rd_bank_0_wait, - &sdr_rw_load_jump_mgr_regs->load_jump_add1); + &sdr->sdr_rw_load_jump_mgr_regs.load_jump_add1); } - writel(mcc_instruction, (SDR_PHYGRP_RWMGRGRP_ADDRESS | + writel(mcc_instruction, (((u32)(&sdr->rwmgr_grp)) | RW_MGR_RUN_SINGLE_GROUP_OFFSET) + (group << 2)); } @@ -1168,7 +1168,7 @@ static void rw_mgr_mem_calibrate_write_test_issue(u32 group, * Test writes, can check for a single bit pass or multiple bit pass. */ static int -rw_mgr_mem_calibrate_write_test(const u32 rank_bgn, const u32 write_group, +rw_mgr_mem_calibrate_write_test(struct socfpga_sdr *sdr, const u32 rank_bgn, const u32 write_group, const u32 use_dm, const u32 all_correct, u32 *bit_chk, const u32 all_ranks) { @@ -1186,20 +1186,20 @@ rw_mgr_mem_calibrate_write_test(const u32 rank_bgn, const u32 write_group, for (r = rank_bgn; r < rank_end; r++) { /* Set rank */ - set_rank_and_odt_mask(r, RW_MGR_ODT_MODE_READ_WRITE); + set_rank_and_odt_mask(sdr, r, RW_MGR_ODT_MODE_READ_WRITE); tmp_bit_chk = 0; for (vg = rwcfg->mem_virtual_groups_per_write_dqs - 1; vg >= 0; vg--) { /* Reset the FIFOs to get pointers to known state. */ - writel(0, &phy_mgr_cmd->fifo_reset); + writel(0, &sdr->phy_mgr_cmd.fifo_reset); - rw_mgr_mem_calibrate_write_test_issue( + rw_mgr_mem_calibrate_write_test_issue(sdr, write_group * rwcfg->mem_virtual_groups_per_write_dqs + vg, use_dm); - base_rw_mgr = readl(SDR_PHYGRP_RWMGRGRP_ADDRESS); + base_rw_mgr = readl((u32)(&sdr->rwmgr_grp)); tmp_bit_chk <<= shift_ratio; tmp_bit_chk |= (correct_mask_vg & ~(base_rw_mgr)); } @@ -1207,7 +1207,7 @@ rw_mgr_mem_calibrate_write_test(const u32 rank_bgn, const u32 write_group, *bit_chk &= tmp_bit_chk; } - set_rank_and_odt_mask(0, RW_MGR_ODT_MODE_OFF); + set_rank_and_odt_mask(sdr, 0, RW_MGR_ODT_MODE_OFF); if (all_correct) { debug_cond(DLEVEL >= 2, "write_test(%u,%u,ALL) : %u == %u => %i\n", @@ -1233,10 +1233,10 @@ rw_mgr_mem_calibrate_write_test(const u32 rank_bgn, const u32 write_group, * read test to ensure memory works. */ static int -rw_mgr_mem_calibrate_read_test_patterns(const u32 rank_bgn, const u32 group, +rw_mgr_mem_calibrate_read_test_patterns(struct socfpga_sdr *sdr, const u32 rank_bgn, const u32 group, const u32 all_ranks) { - const u32 addr = SDR_PHYGRP_RWMGRGRP_ADDRESS | + const u32 addr = ((u32)(&sdr->rwmgr_grp)) | RW_MGR_RUN_SINGLE_GROUP_OFFSET; const u32 addr_offset = (group * rwcfg->mem_virtual_groups_per_read_dqs) << 2; @@ -1255,28 +1255,28 @@ rw_mgr_mem_calibrate_read_test_patterns(const u32 rank_bgn, const u32 group, for (r = rank_bgn; r < rank_end; r++) { /* Set rank */ - set_rank_and_odt_mask(r, RW_MGR_ODT_MODE_READ_WRITE); + set_rank_and_odt_mask(sdr, r, RW_MGR_ODT_MODE_READ_WRITE); /* Load up a constant bursts of read commands */ - writel(0x20, &sdr_rw_load_mgr_regs->load_cntr0); + writel(0x20, &sdr->sdr_rw_load_mgr_regs.load_cntr0); writel(rwcfg->guaranteed_read, - &sdr_rw_load_jump_mgr_regs->load_jump_add0); + &sdr->sdr_rw_load_jump_mgr_regs.load_jump_add0); - writel(0x20, &sdr_rw_load_mgr_regs->load_cntr1); + writel(0x20, &sdr->sdr_rw_load_mgr_regs.load_cntr1); writel(rwcfg->guaranteed_read_cont, - &sdr_rw_load_jump_mgr_regs->load_jump_add1); + &sdr->sdr_rw_load_jump_mgr_regs.load_jump_add1); tmp_bit_chk = 0; for (vg = rwcfg->mem_virtual_groups_per_read_dqs - 1; vg >= 0; vg--) { /* Reset the FIFOs to get pointers to known state. */ - writel(0, &phy_mgr_cmd->fifo_reset); - writel(0, SDR_PHYGRP_RWMGRGRP_ADDRESS | + writel(0, &sdr->phy_mgr_cmd.fifo_reset); + writel(0, ((u32)(&sdr->rwmgr_grp)) | RW_MGR_RESET_READ_DATAPATH_OFFSET); writel(rwcfg->guaranteed_read, addr + addr_offset + (vg << 2)); - base_rw_mgr = readl(SDR_PHYGRP_RWMGRGRP_ADDRESS); + base_rw_mgr = readl((u32)(&sdr->rwmgr_grp)); tmp_bit_chk <<= shift_ratio; tmp_bit_chk |= correct_mask_vg & ~base_rw_mgr; } @@ -1286,7 +1286,7 @@ rw_mgr_mem_calibrate_read_test_patterns(const u32 rank_bgn, const u32 group, writel(rwcfg->clear_dqs_enable, addr + (group << 2)); - set_rank_and_odt_mask(0, RW_MGR_ODT_MODE_OFF); + set_rank_and_odt_mask(sdr, 0, RW_MGR_ODT_MODE_OFF); if (bit_chk != param->read_correct_mask) ret = -EIO; @@ -1306,7 +1306,7 @@ rw_mgr_mem_calibrate_read_test_patterns(const u32 rank_bgn, const u32 group, * * Load up the patterns we are going to use during a read test. */ -static void rw_mgr_mem_calibrate_read_load_patterns(const u32 rank_bgn, +static void rw_mgr_mem_calibrate_read_load_patterns(struct socfpga_sdr *sdr, const u32 rank_bgn, const int all_ranks) { const u32 rank_end = all_ranks ? @@ -1318,34 +1318,34 @@ static void rw_mgr_mem_calibrate_read_load_patterns(const u32 rank_bgn, for (r = rank_bgn; r < rank_end; r++) { /* set rank */ - set_rank_and_odt_mask(r, RW_MGR_ODT_MODE_READ_WRITE); + set_rank_and_odt_mask(sdr, r, RW_MGR_ODT_MODE_READ_WRITE); /* Load up a constant bursts */ - writel(0x20, &sdr_rw_load_mgr_regs->load_cntr0); + writel(0x20, &sdr->sdr_rw_load_mgr_regs.load_cntr0); writel(rwcfg->guaranteed_write_wait0, - &sdr_rw_load_jump_mgr_regs->load_jump_add0); + &sdr->sdr_rw_load_jump_mgr_regs.load_jump_add0); - writel(0x20, &sdr_rw_load_mgr_regs->load_cntr1); + writel(0x20, &sdr->sdr_rw_load_mgr_regs.load_cntr1); writel(rwcfg->guaranteed_write_wait1, - &sdr_rw_load_jump_mgr_regs->load_jump_add1); + &sdr->sdr_rw_load_jump_mgr_regs.load_jump_add1); - writel(0x04, &sdr_rw_load_mgr_regs->load_cntr2); + writel(0x04, &sdr->sdr_rw_load_mgr_regs.load_cntr2); writel(rwcfg->guaranteed_write_wait2, - &sdr_rw_load_jump_mgr_regs->load_jump_add2); + &sdr->sdr_rw_load_jump_mgr_regs.load_jump_add2); - writel(0x04, &sdr_rw_load_mgr_regs->load_cntr3); + writel(0x04, &sdr->sdr_rw_load_mgr_regs.load_cntr3); writel(rwcfg->guaranteed_write_wait3, - &sdr_rw_load_jump_mgr_regs->load_jump_add3); + &sdr->sdr_rw_load_jump_mgr_regs.load_jump_add3); - writel(rwcfg->guaranteed_write, SDR_PHYGRP_RWMGRGRP_ADDRESS | + writel(rwcfg->guaranteed_write, ((u32)(&sdr->rwmgr_grp)) | RW_MGR_RUN_SINGLE_GROUP_OFFSET); } - set_rank_and_odt_mask(0, RW_MGR_ODT_MODE_OFF); + set_rank_and_odt_mask(sdr, 0, RW_MGR_ODT_MODE_OFF); } /** @@ -1363,7 +1363,7 @@ static void rw_mgr_mem_calibrate_read_load_patterns(const u32 rank_bgn, * checks than the regular read test. */ static int -rw_mgr_mem_calibrate_read_test(const u32 rank_bgn, const u32 group, +rw_mgr_mem_calibrate_read_test(struct socfpga_sdr *sdr, const u32 rank_bgn, const u32 group, const u32 num_tries, const u32 all_correct, u32 *bit_chk, const u32 all_groups, const u32 all_ranks) @@ -1384,50 +1384,50 @@ rw_mgr_mem_calibrate_read_test(const u32 rank_bgn, const u32 group, for (r = rank_bgn; r < rank_end; r++) { /* set rank */ - set_rank_and_odt_mask(r, RW_MGR_ODT_MODE_READ_WRITE); + set_rank_and_odt_mask(sdr, r, RW_MGR_ODT_MODE_READ_WRITE); - writel(0x10, &sdr_rw_load_mgr_regs->load_cntr1); + writel(0x10, &sdr->sdr_rw_load_mgr_regs.load_cntr1); writel(rwcfg->read_b2b_wait1, - &sdr_rw_load_jump_mgr_regs->load_jump_add1); + &sdr->sdr_rw_load_jump_mgr_regs.load_jump_add1); - writel(0x10, &sdr_rw_load_mgr_regs->load_cntr2); + writel(0x10, &sdr->sdr_rw_load_mgr_regs.load_cntr2); writel(rwcfg->read_b2b_wait2, - &sdr_rw_load_jump_mgr_regs->load_jump_add2); + &sdr->sdr_rw_load_jump_mgr_regs.load_jump_add2); if (quick_read_mode) - writel(0x1, &sdr_rw_load_mgr_regs->load_cntr0); + writel(0x1, &sdr->sdr_rw_load_mgr_regs.load_cntr0); /* need at least two (1+1) reads to capture failures */ else if (all_groups) - writel(0x06, &sdr_rw_load_mgr_regs->load_cntr0); + writel(0x06, &sdr->sdr_rw_load_mgr_regs.load_cntr0); else - writel(0x32, &sdr_rw_load_mgr_regs->load_cntr0); + writel(0x32, &sdr->sdr_rw_load_mgr_regs.load_cntr0); writel(rwcfg->read_b2b, - &sdr_rw_load_jump_mgr_regs->load_jump_add0); + &sdr->sdr_rw_load_jump_mgr_regs.load_jump_add0); if (all_groups) writel(rwcfg->mem_if_read_dqs_width * rwcfg->mem_virtual_groups_per_read_dqs - 1, - &sdr_rw_load_mgr_regs->load_cntr3); + &sdr->sdr_rw_load_mgr_regs.load_cntr3); else - writel(0x0, &sdr_rw_load_mgr_regs->load_cntr3); + writel(0x0, &sdr->sdr_rw_load_mgr_regs.load_cntr3); writel(rwcfg->read_b2b, - &sdr_rw_load_jump_mgr_regs->load_jump_add3); + &sdr->sdr_rw_load_jump_mgr_regs.load_jump_add3); tmp_bit_chk = 0; for (vg = rwcfg->mem_virtual_groups_per_read_dqs - 1; vg >= 0; vg--) { /* Reset the FIFOs to get pointers to known state. */ - writel(0, &phy_mgr_cmd->fifo_reset); - writel(0, SDR_PHYGRP_RWMGRGRP_ADDRESS | + writel(0, &sdr->phy_mgr_cmd.fifo_reset); + writel(0, ((u32)(&sdr->rwmgr_grp)) | RW_MGR_RESET_READ_DATAPATH_OFFSET); if (all_groups) { - addr = SDR_PHYGRP_RWMGRGRP_ADDRESS | + addr = ((u32)(&sdr->rwmgr_grp)) | RW_MGR_RUN_ALL_GROUPS_OFFSET; } else { - addr = SDR_PHYGRP_RWMGRGRP_ADDRESS | + addr = ((u32)(&sdr->rwmgr_grp)) | RW_MGR_RUN_SINGLE_GROUP_OFFSET; } @@ -1436,7 +1436,7 @@ rw_mgr_mem_calibrate_read_test(const u32 rank_bgn, const u32 group, rwcfg->mem_virtual_groups_per_read_dqs + vg) << 2)); - base_rw_mgr = readl(SDR_PHYGRP_RWMGRGRP_ADDRESS); + base_rw_mgr = readl(&sdr->rwmgr_grp); tmp_bit_chk <<= rwcfg->mem_dq_per_read_dqs / rwcfg->mem_virtual_groups_per_read_dqs; tmp_bit_chk |= correct_mask_vg & ~(base_rw_mgr); @@ -1445,10 +1445,10 @@ rw_mgr_mem_calibrate_read_test(const u32 rank_bgn, const u32 group, *bit_chk &= tmp_bit_chk; } - addr = SDR_PHYGRP_RWMGRGRP_ADDRESS | RW_MGR_RUN_SINGLE_GROUP_OFFSET; + addr = ((u32)(&sdr->rwmgr_grp)) | RW_MGR_RUN_SINGLE_GROUP_OFFSET; writel(rwcfg->clear_dqs_enable, addr + (group << 2)); - set_rank_and_odt_mask(0, RW_MGR_ODT_MODE_OFF); + set_rank_and_odt_mask(sdr, 0, RW_MGR_ODT_MODE_OFF); if (all_correct) { ret = (*bit_chk == param->read_correct_mask); @@ -1477,12 +1477,12 @@ rw_mgr_mem_calibrate_read_test(const u32 rank_bgn, const u32 group, * Perform a READ test across all memory ranks. */ static int -rw_mgr_mem_calibrate_read_test_all_ranks(const u32 grp, const u32 num_tries, +rw_mgr_mem_calibrate_read_test_all_ranks(struct socfpga_sdr *sdr, const u32 grp, const u32 num_tries, const u32 all_correct, const u32 all_groups) { u32 bit_chk; - return rw_mgr_mem_calibrate_read_test(0, grp, num_tries, all_correct, + return rw_mgr_mem_calibrate_read_test(sdr, 0, grp, num_tries, all_correct, &bit_chk, all_groups, 1); } @@ -1492,9 +1492,9 @@ rw_mgr_mem_calibrate_read_test_all_ranks(const u32 grp, const u32 num_tries, * * Increase VFIFO value. */ -static void rw_mgr_incr_vfifo(const u32 grp) +static void rw_mgr_incr_vfifo(struct socfpga_sdr *sdr, const u32 grp) { - writel(grp, &phy_mgr_cmd->inc_vfifo_hard_phy); + writel(grp, &sdr->phy_mgr_cmd.inc_vfifo_hard_phy); } /** @@ -1503,12 +1503,12 @@ static void rw_mgr_incr_vfifo(const u32 grp) * * Decrease VFIFO value. */ -static void rw_mgr_decr_vfifo(const u32 grp) +static void rw_mgr_decr_vfifo(struct socfpga_sdr *sdr, const u32 grp) { u32 i; for (i = 0; i < misccfg->read_valid_fifo_size - 1; i++) - rw_mgr_incr_vfifo(grp); + rw_mgr_incr_vfifo(sdr, grp); } /** @@ -1517,14 +1517,14 @@ static void rw_mgr_decr_vfifo(const u32 grp) * * Push VFIFO until a failing read happens. */ -static int find_vfifo_failing_read(const u32 grp) +static int find_vfifo_failing_read(struct socfpga_sdr *sdr, const u32 grp) { u32 v, ret, fail_cnt = 0; for (v = 0; v < misccfg->read_valid_fifo_size; v++) { debug_cond(DLEVEL >= 2, "%s:%d: vfifo %u\n", __func__, __LINE__, v); - ret = rw_mgr_mem_calibrate_read_test_all_ranks(grp, 1, + ret = rw_mgr_mem_calibrate_read_test_all_ranks(sdr, grp, 1, PASS_ONE_BIT, 0); if (!ret) { fail_cnt++; @@ -1534,7 +1534,7 @@ static int find_vfifo_failing_read(const u32 grp) } /* Fiddle with FIFO. */ - rw_mgr_incr_vfifo(grp); + rw_mgr_incr_vfifo(sdr, grp); } /* No failing read found! Something must have gone wrong. */ @@ -1553,7 +1553,7 @@ static int find_vfifo_failing_read(const u32 grp) * * Find working or non-working DQS enable phase setting. */ -static int sdr_find_phase_delay(int working, int delay, const u32 grp, +static int sdr_find_phase_delay(struct socfpga_sdr *sdr, int working, int delay, const u32 grp, u32 *work, const u32 work_inc, u32 *pd) { const u32 max = delay ? iocfg->dqs_en_delay_max : @@ -1562,11 +1562,11 @@ static int sdr_find_phase_delay(int working, int delay, const u32 grp, for (; *pd <= max; (*pd)++) { if (delay) - scc_mgr_set_dqs_en_delay_all_ranks(grp, *pd); + scc_mgr_set_dqs_en_delay_all_ranks(sdr, grp, *pd); else - scc_mgr_set_dqs_en_phase_all_ranks(grp, *pd); + scc_mgr_set_dqs_en_phase_all_ranks(sdr, grp, *pd); - ret = rw_mgr_mem_calibrate_read_test_all_ranks(grp, 1, + ret = rw_mgr_mem_calibrate_read_test_all_ranks(sdr, grp, 1, PASS_ONE_BIT, 0); if (!working) ret = !ret; @@ -1590,7 +1590,7 @@ static int sdr_find_phase_delay(int working, int delay, const u32 grp, * * Find working or non-working DQS enable phase setting. */ -static int sdr_find_phase(int working, const u32 grp, u32 *work, +static int sdr_find_phase(struct socfpga_sdr *sdr, int working, const u32 grp, u32 *work, u32 *i, u32 *p) { const u32 end = misccfg->read_valid_fifo_size + (working ? 0 : 1); @@ -1600,14 +1600,14 @@ static int sdr_find_phase(int working, const u32 grp, u32 *work, if (working) *p = 0; - ret = sdr_find_phase_delay(working, 0, grp, work, + ret = sdr_find_phase_delay(sdr, working, 0, grp, work, iocfg->delay_per_opa_tap, p); if (!ret) return 0; if (*p > iocfg->dqs_en_phase_max) { /* Fiddle with FIFO. */ - rw_mgr_incr_vfifo(grp); + rw_mgr_incr_vfifo(sdr, grp); if (!working) *p = 0; } @@ -1626,7 +1626,7 @@ static int sdr_find_phase(int working, const u32 grp, u32 *work, * * Find working DQS enable phase setting. */ -static int sdr_working_phase(const u32 grp, u32 *work_bgn, u32 *d, +static int sdr_working_phase(struct socfpga_sdr *sdr, const u32 grp, u32 *work_bgn, u32 *d, u32 *p, u32 *i) { const u32 dtaps_per_ptap = iocfg->delay_per_opa_tap / @@ -1637,8 +1637,8 @@ static int sdr_working_phase(const u32 grp, u32 *work_bgn, u32 *d, for (*d = 0; *d <= dtaps_per_ptap; (*d)++) { *i = 0; - scc_mgr_set_dqs_en_delay_all_ranks(grp, *d); - ret = sdr_find_phase(1, grp, work_bgn, i, p); + scc_mgr_set_dqs_en_delay_all_ranks(sdr, grp, *d); + ret = sdr_find_phase(sdr, 1, grp, work_bgn, i, p); if (!ret) return 0; *work_bgn += iocfg->delay_per_dqs_en_dchain_tap; @@ -1658,7 +1658,7 @@ static int sdr_working_phase(const u32 grp, u32 *work_bgn, u32 *d, * * Find DQS enable backup phase setting. */ -static void sdr_backup_phase(const u32 grp, u32 *work_bgn, u32 *p) +static void sdr_backup_phase(struct socfpga_sdr *sdr, const u32 grp, u32 *work_bgn, u32 *p) { u32 tmp_delay, d; int ret; @@ -1666,18 +1666,18 @@ static void sdr_backup_phase(const u32 grp, u32 *work_bgn, u32 *p) /* Special case code for backing up a phase */ if (*p == 0) { *p = iocfg->dqs_en_phase_max; - rw_mgr_decr_vfifo(grp); + rw_mgr_decr_vfifo(sdr, grp); } else { (*p)--; } tmp_delay = *work_bgn - iocfg->delay_per_opa_tap; - scc_mgr_set_dqs_en_phase_all_ranks(grp, *p); + scc_mgr_set_dqs_en_phase_all_ranks(sdr, grp, *p); for (d = 0; d <= iocfg->dqs_en_delay_max && tmp_delay < *work_bgn; d++) { - scc_mgr_set_dqs_en_delay_all_ranks(grp, d); + scc_mgr_set_dqs_en_delay_all_ranks(sdr, grp, d); - ret = rw_mgr_mem_calibrate_read_test_all_ranks(grp, 1, + ret = rw_mgr_mem_calibrate_read_test_all_ranks(sdr, grp, 1, PASS_ONE_BIT, 0); if (ret) { *work_bgn = tmp_delay; @@ -1691,10 +1691,10 @@ static void sdr_backup_phase(const u32 grp, u32 *work_bgn, u32 *p) (*p)++; if (*p > iocfg->dqs_en_phase_max) { *p = 0; - rw_mgr_incr_vfifo(grp); + rw_mgr_incr_vfifo(sdr, grp); } - scc_mgr_set_dqs_en_delay_all_ranks(grp, 0); + scc_mgr_set_dqs_en_delay_all_ranks(sdr, grp, 0); } /** @@ -1706,7 +1706,7 @@ static void sdr_backup_phase(const u32 grp, u32 *work_bgn, u32 *p) * * Find non-working DQS enable phase setting. */ -static int sdr_nonworking_phase(const u32 grp, u32 *work_end, u32 *p, u32 *i) +static int sdr_nonworking_phase(struct socfpga_sdr *sdr, const u32 grp, u32 *work_end, u32 *p, u32 *i) { int ret; @@ -1715,10 +1715,10 @@ static int sdr_nonworking_phase(const u32 grp, u32 *work_end, u32 *p, u32 *i) if (*p > iocfg->dqs_en_phase_max) { /* Fiddle with FIFO. */ *p = 0; - rw_mgr_incr_vfifo(grp); + rw_mgr_incr_vfifo(sdr, grp); } - ret = sdr_find_phase(0, grp, work_end, i, p); + ret = sdr_find_phase(sdr, 0, grp, work_end, i, p); if (ret) { /* Cannot see edge of failing read. */ debug_cond(DLEVEL >= 2, "%s:%d: end: failed\n", @@ -1736,7 +1736,7 @@ static int sdr_nonworking_phase(const u32 grp, u32 *work_end, u32 *p, u32 *i) * * Find center of the working DQS enable window. */ -static int sdr_find_window_center(const u32 grp, const u32 work_bgn, +static int sdr_find_window_center(struct socfpga_sdr *sdr, const u32 grp, const u32 work_bgn, const u32 work_end) { u32 work_mid; @@ -1769,8 +1769,8 @@ static int sdr_find_window_center(const u32 grp, const u32 work_bgn, debug_cond(DLEVEL >= 2, "new d %d, tmp_delay=%d\n", d, tmp_delay); - scc_mgr_set_dqs_en_phase_all_ranks(grp, p); - scc_mgr_set_dqs_en_delay_all_ranks(grp, d); + scc_mgr_set_dqs_en_phase_all_ranks(sdr, grp, p); + scc_mgr_set_dqs_en_delay_all_ranks(sdr, grp, d); /* * push vfifo until we can successfully calibrate. We can do this @@ -1778,7 +1778,7 @@ static int sdr_find_window_center(const u32 grp, const u32 work_bgn, */ for (i = 0; i < misccfg->read_valid_fifo_size; i++) { debug_cond(DLEVEL >= 2, "find_dqs_en_phase: center\n"); - if (rw_mgr_mem_calibrate_read_test_all_ranks(grp, 1, + if (rw_mgr_mem_calibrate_read_test_all_ranks(sdr, grp, 1, PASS_ONE_BIT, 0)) { debug_cond(DLEVEL >= 2, @@ -1788,7 +1788,7 @@ static int sdr_find_window_center(const u32 grp, const u32 work_bgn, } /* Fiddle with FIFO. */ - rw_mgr_incr_vfifo(grp); + rw_mgr_incr_vfifo(sdr, grp); } debug_cond(DLEVEL >= 2, "%s:%d center: failed.\n", @@ -1802,7 +1802,7 @@ static int sdr_find_window_center(const u32 grp, const u32 work_bgn, * * Find a good DQS enable to use. */ -static int rw_mgr_mem_calibrate_vfifo_find_dqs_en_phase(const u32 grp) +static int rw_mgr_mem_calibrate_vfifo_find_dqs_en_phase(struct socfpga_sdr *sdr, const u32 grp) { u32 d, p, i; u32 dtaps_per_ptap; @@ -1812,21 +1812,21 @@ static int rw_mgr_mem_calibrate_vfifo_find_dqs_en_phase(const u32 grp) debug("%s:%d %u\n", __func__, __LINE__, grp); - reg_file_set_sub_stage(CAL_SUBSTAGE_VFIFO_CENTER); + reg_file_set_sub_stage(sdr, CAL_SUBSTAGE_VFIFO_CENTER); - scc_mgr_set_dqs_en_delay_all_ranks(grp, 0); - scc_mgr_set_dqs_en_phase_all_ranks(grp, 0); + scc_mgr_set_dqs_en_delay_all_ranks(sdr, grp, 0); + scc_mgr_set_dqs_en_phase_all_ranks(sdr, grp, 0); /* Step 0: Determine number of delay taps for each phase tap. */ dtaps_per_ptap = iocfg->delay_per_opa_tap / iocfg->delay_per_dqs_en_dchain_tap; /* Step 1: First push vfifo until we get a failing read. */ - find_vfifo_failing_read(grp); + find_vfifo_failing_read(sdr, grp); /* Step 2: Find first working phase, increment in ptaps. */ work_bgn = 0; - ret = sdr_working_phase(grp, &work_bgn, &d, &p, &i); + ret = sdr_working_phase(sdr, grp, &work_bgn, &d, &p, &i); if (ret) return ret; @@ -1842,13 +1842,13 @@ static int rw_mgr_mem_calibrate_vfifo_find_dqs_en_phase(const u32 grp) * Step 3a: If we have room, back off by one and * increment in dtaps. */ - sdr_backup_phase(grp, &work_bgn, &p); + sdr_backup_phase(sdr, grp, &work_bgn, &p); /* * Step 4a: go forward from working phase to non working * phase, increment in ptaps. */ - ret = sdr_nonworking_phase(grp, &work_end, &p, &i); + ret = sdr_nonworking_phase(sdr, grp, &work_end, &p, &i); if (ret) return ret; @@ -1857,13 +1857,13 @@ static int rw_mgr_mem_calibrate_vfifo_find_dqs_en_phase(const u32 grp) /* Special case code for backing up a phase */ if (p == 0) { p = iocfg->dqs_en_phase_max; - rw_mgr_decr_vfifo(grp); + rw_mgr_decr_vfifo(sdr, grp); } else { p = p - 1; } work_end -= iocfg->delay_per_opa_tap; - scc_mgr_set_dqs_en_phase_all_ranks(grp, p); + scc_mgr_set_dqs_en_phase_all_ranks(sdr, grp, p); d = 0; @@ -1872,7 +1872,7 @@ static int rw_mgr_mem_calibrate_vfifo_find_dqs_en_phase(const u32 grp) } /* The dtap increment to find the failing edge is done here. */ - sdr_find_phase_delay(0, 1, grp, &work_end, + sdr_find_phase_delay(sdr, 0, 1, grp, &work_end, iocfg->delay_per_dqs_en_dchain_tap, &d); /* Go back to working dtap */ @@ -1904,7 +1904,7 @@ static int rw_mgr_mem_calibrate_vfifo_find_dqs_en_phase(const u32 grp) /* Special case code for backing up a phase */ if (p == 0) { p = iocfg->dqs_en_phase_max; - rw_mgr_decr_vfifo(grp); + rw_mgr_decr_vfifo(sdr, grp); debug_cond(DLEVEL >= 2, "%s:%d backedup cycle/phase: p=%u\n", __func__, __LINE__, p); } else { @@ -1913,7 +1913,7 @@ static int rw_mgr_mem_calibrate_vfifo_find_dqs_en_phase(const u32 grp) __func__, __LINE__, p); } - scc_mgr_set_dqs_en_phase_all_ranks(grp, p); + scc_mgr_set_dqs_en_phase_all_ranks(sdr, grp, p); /* * Increase dtap until we first see a passing read (in case the @@ -1927,13 +1927,13 @@ static int rw_mgr_mem_calibrate_vfifo_find_dqs_en_phase(const u32 grp) initial_failing_dtap = d; - found_passing_read = !sdr_find_phase_delay(1, 1, grp, NULL, 0, &d); + found_passing_read = !sdr_find_phase_delay(sdr, 1, 1, grp, NULL, 0, &d); if (found_passing_read) { /* Find a failing read. */ debug_cond(DLEVEL >= 2, "%s:%d find failing read\n", __func__, __LINE__); d++; - found_failing_read = !sdr_find_phase_delay(0, 1, grp, NULL, 0, + found_failing_read = !sdr_find_phase_delay(sdr, 0, 1, grp, NULL, 0, &d); } else { debug_cond(DLEVEL >= 1, @@ -1950,12 +1950,12 @@ static int rw_mgr_mem_calibrate_vfifo_find_dqs_en_phase(const u32 grp) if (found_passing_read && found_failing_read) dtaps_per_ptap = d - initial_failing_dtap; - writel(dtaps_per_ptap, &sdr_reg_file->dtaps_per_ptap); + writel(dtaps_per_ptap, &sdr->sdr_reg_file.dtaps_per_ptap); debug_cond(DLEVEL >= 2, "%s:%d dtaps_per_ptap=%u - %u = %u", __func__, __LINE__, d, initial_failing_dtap, dtaps_per_ptap); /* Step 6: Find the centre of the window. */ - ret = sdr_find_window_center(grp, work_bgn, work_end); + ret = sdr_find_window_center(sdr, grp, work_bgn, work_end); return ret; } @@ -1973,7 +1973,7 @@ static int rw_mgr_mem_calibrate_vfifo_find_dqs_en_phase(const u32 grp) * * Test if the found edge is valid. */ -static u32 search_stop_check(const int write, const int d, const int rank_bgn, +static u32 search_stop_check(struct socfpga_sdr *sdr, const int write, const int d, const int rank_bgn, const u32 write_group, const u32 read_group, u32 *bit_chk, u32 *sticky_bit_chk, const u32 use_read_test) @@ -1990,16 +1990,16 @@ static u32 search_stop_check(const int write, const int d, const int rank_bgn, * we've seen a passing read on every bit. */ if (write) { /* WRITE-ONLY */ - ret = !rw_mgr_mem_calibrate_write_test(rank_bgn, write_group, + ret = !rw_mgr_mem_calibrate_write_test(sdr, rank_bgn, write_group, 0, PASS_ONE_BIT, bit_chk, 0); } else if (use_read_test) { /* READ-ONLY */ - ret = !rw_mgr_mem_calibrate_read_test(rank_bgn, read_group, + ret = !rw_mgr_mem_calibrate_read_test(sdr, rank_bgn, read_group, NUM_READ_PB_TESTS, PASS_ONE_BIT, bit_chk, 0, 0); } else { /* READ-ONLY */ - rw_mgr_mem_calibrate_write_test(rank_bgn, write_group, 0, + rw_mgr_mem_calibrate_write_test(sdr, rank_bgn, write_group, 0, PASS_ONE_BIT, bit_chk, 0); *bit_chk = *bit_chk >> (per_dqs * (read_group - (write_group * ratio))); @@ -2028,7 +2028,7 @@ static u32 search_stop_check(const int write, const int d, const int rank_bgn, * * Find left edge of DQ/DQS working phase. */ -static void search_left_edge(const int write, const int rank_bgn, +static void search_left_edge(struct socfpga_sdr *sdr, const int write, const int rank_bgn, const u32 write_group, const u32 read_group, const u32 test_bgn, u32 *sticky_bit_chk, int *left_edge, int *right_edge, const u32 use_read_test) @@ -2044,13 +2044,13 @@ static void search_left_edge(const int write, const int rank_bgn, for (d = 0; d <= dqs_max; d++) { if (write) - scc_mgr_apply_group_dq_out1_delay(d); + scc_mgr_apply_group_dq_out1_delay(sdr, d); else - scc_mgr_apply_group_dq_in_delay(test_bgn, d); + scc_mgr_apply_group_dq_in_delay(sdr, test_bgn, d); - writel(0, &sdr_scc_mgr->update); + writel(0, &sdr->sdr_scc_mgr.update); - stop = search_stop_check(write, d, rank_bgn, write_group, + stop = search_stop_check(sdr, write, d, rank_bgn, write_group, read_group, &bit_chk, sticky_bit_chk, use_read_test); if (stop == 1) @@ -2080,9 +2080,9 @@ static void search_left_edge(const int write, const int rank_bgn, /* Reset DQ delay chains to 0 */ if (write) - scc_mgr_apply_group_dq_out1_delay(0); + scc_mgr_apply_group_dq_out1_delay(sdr, 0); else - scc_mgr_apply_group_dq_in_delay(test_bgn, 0); + scc_mgr_apply_group_dq_in_delay(sdr, test_bgn, 0); *sticky_bit_chk = 0; for (i = per_dqs - 1; i >= 0; i--) { @@ -2138,7 +2138,7 @@ static void search_left_edge(const int write, const int rank_bgn, * * Find right edge of DQ/DQS working phase. */ -static int search_right_edge(const int write, const int rank_bgn, +static int search_right_edge(struct socfpga_sdr *sdr, const int write, const int rank_bgn, const u32 write_group, const u32 read_group, const int start_dqs, const int start_dqs_en, u32 *sticky_bit_chk, @@ -2155,22 +2155,22 @@ static int search_right_edge(const int write, const int rank_bgn, for (d = 0; d <= dqs_max - start_dqs; d++) { if (write) { /* WRITE-ONLY */ - scc_mgr_apply_group_dqs_io_and_oct_out1(write_group, + scc_mgr_apply_group_dqs_io_and_oct_out1(sdr, write_group, d + start_dqs); } else { /* READ-ONLY */ - scc_mgr_set_dqs_bus_in_delay(read_group, d + start_dqs); + scc_mgr_set_dqs_bus_in_delay(sdr, read_group, d + start_dqs); if (iocfg->shift_dqs_en_when_shift_dqs) { u32 delay = d + start_dqs_en; if (delay > iocfg->dqs_en_delay_max) delay = iocfg->dqs_en_delay_max; - scc_mgr_set_dqs_en_delay(read_group, delay); + scc_mgr_set_dqs_en_delay(sdr, read_group, delay); } - scc_mgr_load_dqs(read_group); + scc_mgr_load_dqs(sdr, read_group); } - writel(0, &sdr_scc_mgr->update); + writel(0, &sdr->sdr_scc_mgr.update); - stop = search_stop_check(write, d, rank_bgn, write_group, + stop = search_stop_check(sdr, write, d, rank_bgn, write_group, read_group, &bit_chk, sticky_bit_chk, use_read_test); if (stop == 1) { @@ -2310,7 +2310,7 @@ static int get_window_mid_index(const int write, int *left_edge, * * Align the DQ/DQS windows in each group. */ -static void center_dq_windows(const int write, int *left_edge, int *right_edge, +static void center_dq_windows(struct socfpga_sdr *sdr, const int write, int *left_edge, int *right_edge, const int mid_min, const int orig_mid_min, const int min_index, const int test_bgn, int *dq_margin, int *dqs_margin) @@ -2321,7 +2321,7 @@ static void center_dq_windows(const int write, int *left_edge, int *right_edge, rwcfg->mem_dq_per_read_dqs; const s32 delay_off = write ? SCC_MGR_IO_OUT1_DELAY_OFFSET : SCC_MGR_IO_IN_DELAY_OFFSET; - const s32 addr = SDR_PHYGRP_SCCGRP_ADDRESS | delay_off; + const s32 addr = (u32)sdr | delay_off; s32 temp_dq_io_delay1; int shift_dq, i, p; @@ -2353,13 +2353,13 @@ static void center_dq_windows(const int write, int *left_edge, int *right_edge, i, shift_dq); if (write) - scc_mgr_set_dq_out1_delay(i, + scc_mgr_set_dq_out1_delay(sdr, i, temp_dq_io_delay1 + shift_dq); else - scc_mgr_set_dq_in_delay(p, + scc_mgr_set_dq_in_delay(sdr, p, temp_dq_io_delay1 + shift_dq); - scc_mgr_load_dq(p); + scc_mgr_load_dq(sdr, p); debug_cond(DLEVEL >= 2, "vfifo_center: margin[%u]=[%d,%d]\n", i, @@ -2385,12 +2385,12 @@ static void center_dq_windows(const int write, int *left_edge, int *right_edge, * * Per-bit deskew DQ and centering. */ -static int rw_mgr_mem_calibrate_vfifo_center(const u32 rank_bgn, +static int rw_mgr_mem_calibrate_vfifo_center(struct socfpga_sdr *sdr, const u32 rank_bgn, const u32 rw_group, const u32 test_bgn, const int use_read_test, const int update_fom) { const u32 addr = - SDR_PHYGRP_SCCGRP_ADDRESS + SCC_MGR_DQS_IN_DELAY_OFFSET + + (u32)sdr + SCC_MGR_DQS_IN_DELAY_OFFSET + (rw_group << 2); /* * Store these as signed since there are comparisons with @@ -2420,13 +2420,13 @@ static int rw_mgr_mem_calibrate_vfifo_center(const u32 rank_bgn, } /* Search for the left edge of the window for each bit */ - search_left_edge(0, rank_bgn, rw_group, rw_group, test_bgn, + search_left_edge(sdr, 0, rank_bgn, rw_group, rw_group, test_bgn, &sticky_bit_chk, left_edge, right_edge, use_read_test); /* Search for the right edge of the window for each bit */ - ret = search_right_edge(0, rank_bgn, rw_group, rw_group, + ret = search_right_edge(sdr, 0, rank_bgn, rw_group, rw_group, start_dqs, start_dqs_en, &sticky_bit_chk, left_edge, right_edge, use_read_test); @@ -2436,12 +2436,12 @@ static int rw_mgr_mem_calibrate_vfifo_center(const u32 rank_bgn, * in rw_mgr_mem_calibrate_vfifo to retry different * dqs/ck relationships. */ - scc_mgr_set_dqs_bus_in_delay(rw_group, start_dqs); + scc_mgr_set_dqs_bus_in_delay(sdr, rw_group, start_dqs); if (iocfg->shift_dqs_en_when_shift_dqs) - scc_mgr_set_dqs_en_delay(rw_group, start_dqs_en); + scc_mgr_set_dqs_en_delay(sdr, rw_group, start_dqs_en); - scc_mgr_load_dqs(rw_group); - writel(0, &sdr_scc_mgr->update); + scc_mgr_load_dqs(sdr, rw_group); + writel(0, &sdr->sdr_scc_mgr.update); debug_cond(DLEVEL >= 1, "%s:%d vfifo_center: failed to find edge [%u]: %d %d", @@ -2490,19 +2490,19 @@ static int rw_mgr_mem_calibrate_vfifo_center(const u32 rank_bgn, new_dqs, mid_min); /* Add delay to bring centre of all DQ windows to the same "level". */ - center_dq_windows(0, left_edge, right_edge, mid_min, orig_mid_min, + center_dq_windows(sdr, 0, left_edge, right_edge, mid_min, orig_mid_min, min_index, test_bgn, &dq_margin, &dqs_margin); /* Move DQS-en */ if (iocfg->shift_dqs_en_when_shift_dqs) { final_dqs_en = start_dqs_en - mid_min; - scc_mgr_set_dqs_en_delay(rw_group, final_dqs_en); - scc_mgr_load_dqs(rw_group); + scc_mgr_set_dqs_en_delay(sdr, rw_group, final_dqs_en); + scc_mgr_load_dqs(sdr, rw_group); } /* Move DQS */ - scc_mgr_set_dqs_bus_in_delay(rw_group, new_dqs); - scc_mgr_load_dqs(rw_group); + scc_mgr_set_dqs_bus_in_delay(sdr, rw_group, new_dqs); + scc_mgr_load_dqs(sdr, rw_group); debug_cond(DLEVEL >= 2, "%s:%d vfifo_center: dq_margin=%d dqs_margin=%d", __func__, __LINE__, dq_margin, dqs_margin); @@ -2511,7 +2511,7 @@ static int rw_mgr_mem_calibrate_vfifo_center(const u32 rank_bgn, * Do not remove this line as it makes sure all of our decisions * have been applied. Apply the update bit. */ - writel(0, &sdr_scc_mgr->update); + writel(0, &sdr->sdr_scc_mgr.update); if ((dq_margin < 0) || (dqs_margin < 0)) return -EINVAL; @@ -2528,13 +2528,13 @@ static int rw_mgr_mem_calibrate_vfifo_center(const u32 rank_bgn, * device, the sequencer uses a guaranteed write mechanism to write data into * the memory device. */ -static int rw_mgr_mem_calibrate_guaranteed_write(const u32 rw_group, +static int rw_mgr_mem_calibrate_guaranteed_write(struct socfpga_sdr *sdr, const u32 rw_group, const u32 phase) { int ret; /* Set a particular DQ/DQS phase. */ - scc_mgr_set_dqdqs_output_phase_all_ranks(rw_group, phase); + scc_mgr_set_dqdqs_output_phase_all_ranks(sdr, rw_group, phase); debug_cond(DLEVEL >= 1, "%s:%d guaranteed write: g=%u p=%u\n", __func__, __LINE__, rw_group, phase); @@ -2544,7 +2544,7 @@ static int rw_mgr_mem_calibrate_guaranteed_write(const u32 rw_group, * Load up the patterns used by read calibration using the * current DQDQS phase. */ - rw_mgr_mem_calibrate_read_load_patterns(0, 1); + rw_mgr_mem_calibrate_read_load_patterns(sdr, 0, 1); if (gbl->phy_debug_mode_flags & PHY_DEBUG_DISABLE_GUARANTEED_READ) return 0; @@ -2553,7 +2553,7 @@ static int rw_mgr_mem_calibrate_guaranteed_write(const u32 rw_group, * Altera EMI_RM 2015.05.04 :: Figure 1-26 * Back-to-Back reads of the patterns used for calibration. */ - ret = rw_mgr_mem_calibrate_read_test_patterns(0, rw_group, 1); + ret = rw_mgr_mem_calibrate_read_test_patterns(sdr, 0, rw_group, 1); if (ret) debug_cond(DLEVEL >= 1, "%s:%d Guaranteed read test failed: g=%u p=%u\n", @@ -2569,7 +2569,7 @@ static int rw_mgr_mem_calibrate_guaranteed_write(const u32 rw_group, * DQS enable calibration ensures reliable capture of the DQ signal without * glitches on the DQS line. */ -static int rw_mgr_mem_calibrate_dqs_enable_calibration(const u32 rw_group, +static int rw_mgr_mem_calibrate_dqs_enable_calibration(struct socfpga_sdr *sdr, const u32 rw_group, const u32 test_bgn) { /* @@ -2595,18 +2595,18 @@ static int rw_mgr_mem_calibrate_dqs_enable_calibration(const u32 rw_group, "%s:%d: g=%u r=%u i=%u p=%u d=%u\n", __func__, __LINE__, rw_group, r, i, p, d); - scc_mgr_set_dq_in_delay(p, d); - scc_mgr_load_dq(p); + scc_mgr_set_dq_in_delay(sdr, p, d); + scc_mgr_load_dq(sdr, p); } - writel(0, &sdr_scc_mgr->update); + writel(0, &sdr->sdr_scc_mgr.update); } /* * Try rw_mgr_mem_calibrate_vfifo_find_dqs_en_phase across different * dq_in_delay values */ - ret = rw_mgr_mem_calibrate_vfifo_find_dqs_en_phase(rw_group); + ret = rw_mgr_mem_calibrate_vfifo_find_dqs_en_phase(sdr, rw_group); debug_cond(DLEVEL >= 1, "%s:%d: g=%u found=%u; Reseting delay chain to zero\n", @@ -2614,8 +2614,8 @@ static int rw_mgr_mem_calibrate_dqs_enable_calibration(const u32 rw_group, for (r = 0; r < rwcfg->mem_number_of_ranks; r += NUM_RANKS_PER_SHADOW_REG) { - scc_mgr_apply_group_dq_in_delay(test_bgn, 0); - writel(0, &sdr_scc_mgr->update); + scc_mgr_apply_group_dq_in_delay(sdr, test_bgn, 0); + writel(0, &sdr->sdr_scc_mgr.update); } return ret; @@ -2632,7 +2632,7 @@ static int rw_mgr_mem_calibrate_dqs_enable_calibration(const u32 rw_group, * within a group. */ static int -rw_mgr_mem_calibrate_dq_dqs_centering(const u32 rw_group, const u32 test_bgn, +rw_mgr_mem_calibrate_dq_dqs_centering(struct socfpga_sdr *sdr, const u32 rw_group, const u32 test_bgn, const int use_read_test, const int update_fom) @@ -2648,7 +2648,7 @@ rw_mgr_mem_calibrate_dq_dqs_centering(const u32 rw_group, const u32 test_bgn, for (rank_bgn = 0, sr = 0; rank_bgn < rwcfg->mem_number_of_ranks; rank_bgn += NUM_RANKS_PER_SHADOW_REG, sr++) { - ret = rw_mgr_mem_calibrate_vfifo_center(rank_bgn, rw_group, + ret = rw_mgr_mem_calibrate_vfifo_center(sdr, rank_bgn, rw_group, test_bgn, use_read_test, update_fom); @@ -2679,7 +2679,7 @@ rw_mgr_mem_calibrate_dq_dqs_centering(const u32 rw_group, const u32 test_bgn, * - DQS input phase and DQS input delay (DQ/DQS Centering) * - we also do a per-bit deskew on the DQ lines. */ -static int rw_mgr_mem_calibrate_vfifo(const u32 rw_group, const u32 test_bgn) +static int rw_mgr_mem_calibrate_vfifo(struct socfpga_sdr *sdr, const u32 rw_group, const u32 test_bgn) { u32 p, d; u32 dtaps_per_ptap; @@ -2690,9 +2690,9 @@ static int rw_mgr_mem_calibrate_vfifo(const u32 rw_group, const u32 test_bgn) debug("%s:%d: %u %u\n", __func__, __LINE__, rw_group, test_bgn); /* Update info for sims */ - reg_file_set_group(rw_group); - reg_file_set_stage(CAL_STAGE_VFIFO); - reg_file_set_sub_stage(CAL_SUBSTAGE_GUARANTEED_READ); + reg_file_set_group(sdr, rw_group); + reg_file_set_stage(sdr, CAL_STAGE_VFIFO); + reg_file_set_sub_stage(sdr, CAL_SUBSTAGE_GUARANTEED_READ); failed_substage = CAL_SUBSTAGE_GUARANTEED_READ; @@ -2708,18 +2708,18 @@ static int rw_mgr_mem_calibrate_vfifo(const u32 rw_group, const u32 test_bgn) * output side yet. */ if (d > 0) { - scc_mgr_apply_group_all_out_delay_add_all_ranks( + scc_mgr_apply_group_all_out_delay_add_all_ranks(sdr, rw_group, d); } for (p = 0; p <= iocfg->dqdqs_out_phase_max; p++) { /* 1) Guaranteed Write */ - ret = rw_mgr_mem_calibrate_guaranteed_write(rw_group, p); + ret = rw_mgr_mem_calibrate_guaranteed_write(sdr, rw_group, p); if (ret) break; /* 2) DQS Enable Calibration */ - ret = rw_mgr_mem_calibrate_dqs_enable_calibration(rw_group, + ret = rw_mgr_mem_calibrate_dqs_enable_calibration(sdr, rw_group, test_bgn); if (ret) { failed_substage = CAL_SUBSTAGE_DQS_EN_PHASE; @@ -2731,7 +2731,7 @@ static int rw_mgr_mem_calibrate_vfifo(const u32 rw_group, const u32 test_bgn) * If doing read after write calibration, do not update * FOM now. Do it then. */ - ret = rw_mgr_mem_calibrate_dq_dqs_centering(rw_group, + ret = rw_mgr_mem_calibrate_dq_dqs_centering(sdr, rw_group, test_bgn, 1, 0); if (ret) { failed_substage = CAL_SUBSTAGE_VFIFO_CENTER; @@ -2755,7 +2755,7 @@ cal_done_ok: * first case). */ if (d > 2) - scc_mgr_zero_group(rw_group, 1); + scc_mgr_zero_group(sdr, rw_group, 1); return 1; } @@ -2770,7 +2770,7 @@ cal_done_ok: * This function implements UniPHY calibration Stage 3, as explained in * detail in Altera EMI_RM 2015.05.04 , "UniPHY Calibration Stages". */ -static int rw_mgr_mem_calibrate_vfifo_end(const u32 rw_group, +static int rw_mgr_mem_calibrate_vfifo_end(struct socfpga_sdr *sdr, const u32 rw_group, const u32 test_bgn) { int ret; @@ -2778,11 +2778,11 @@ static int rw_mgr_mem_calibrate_vfifo_end(const u32 rw_group, debug("%s:%d %u %u", __func__, __LINE__, rw_group, test_bgn); /* Update info for sims. */ - reg_file_set_group(rw_group); - reg_file_set_stage(CAL_STAGE_VFIFO_AFTER_WRITES); - reg_file_set_sub_stage(CAL_SUBSTAGE_VFIFO_CENTER); + reg_file_set_group(sdr, rw_group); + reg_file_set_stage(sdr, CAL_STAGE_VFIFO_AFTER_WRITES); + reg_file_set_sub_stage(sdr, CAL_SUBSTAGE_VFIFO_CENTER); - ret = rw_mgr_mem_calibrate_dq_dqs_centering(rw_group, test_bgn, 0, 1); + ret = rw_mgr_mem_calibrate_dq_dqs_centering(sdr, rw_group, test_bgn, 0, 1); if (ret) set_failing_group_stage(rw_group, CAL_STAGE_VFIFO_AFTER_WRITES, @@ -2799,25 +2799,25 @@ static int rw_mgr_mem_calibrate_vfifo_end(const u32 rw_group, * detail in Altera EMI_RM 2015.05.04 , "UniPHY Calibration Stages". * Calibrate LFIFO to find smallest read latency. */ -static u32 rw_mgr_mem_calibrate_lfifo(void) +static u32 rw_mgr_mem_calibrate_lfifo(struct socfpga_sdr *sdr) { int found_one = 0; debug("%s:%d\n", __func__, __LINE__); /* Update info for sims. */ - reg_file_set_stage(CAL_STAGE_LFIFO); - reg_file_set_sub_stage(CAL_SUBSTAGE_READ_LATENCY); + reg_file_set_stage(sdr, CAL_STAGE_LFIFO); + reg_file_set_sub_stage(sdr, CAL_SUBSTAGE_READ_LATENCY); /* Load up the patterns used by read calibration for all ranks */ - rw_mgr_mem_calibrate_read_load_patterns(0, 1); + rw_mgr_mem_calibrate_read_load_patterns(sdr, 0, 1); do { - writel(gbl->curr_read_lat, &phy_mgr_cfg->phy_rlat); + writel(gbl->curr_read_lat, &sdr->phy_mgr_cfg.phy_rlat); debug_cond(DLEVEL >= 2, "%s:%d lfifo: read_lat=%u", __func__, __LINE__, gbl->curr_read_lat); - if (!rw_mgr_mem_calibrate_read_test_all_ranks(0, NUM_READ_TESTS, + if (!rw_mgr_mem_calibrate_read_test_all_ranks(sdr, 0, NUM_READ_TESTS, PASS_ALL_BITS, 1)) break; @@ -2830,12 +2830,12 @@ static u32 rw_mgr_mem_calibrate_lfifo(void) } while (gbl->curr_read_lat > 0); /* Reset the fifos to get pointers to known state. */ - writel(0, &phy_mgr_cmd->fifo_reset); + writel(0, &sdr->phy_mgr_cmd.fifo_reset); if (found_one) { /* Add a fudge factor to the read latency that was determined */ gbl->curr_read_lat += 2; - writel(gbl->curr_read_lat, &phy_mgr_cfg->phy_rlat); + writel(gbl->curr_read_lat, &sdr->phy_mgr_cfg.phy_rlat); debug_cond(DLEVEL >= 2, "%s:%d lfifo: success: using read_lat=%u\n", __func__, __LINE__, gbl->curr_read_lat); @@ -2865,7 +2865,7 @@ static u32 rw_mgr_mem_calibrate_lfifo(void) * * Search for the/part of the window with DM/DQS shift. */ -static void search_window(const int search_dm, +static void search_window(struct socfpga_sdr *sdr, const int search_dm, const u32 rank_bgn, const u32 write_group, int *bgn_curr, int *end_curr, int *bgn_best, int *end_best, int *win_best, int new_dqs) @@ -2878,7 +2878,7 @@ static void search_window(const int search_dm, for (di = max; di >= 0; di -= DELTA_D) { if (search_dm) { d = di; - scc_mgr_apply_group_dm_out1_delay(d); + scc_mgr_apply_group_dm_out1_delay(sdr, d); } else { /* For DQS, we go from 0...max */ d = max - di; @@ -2886,13 +2886,13 @@ static void search_window(const int search_dm, * Note: This only shifts DQS, so are we limiting * ourselves to width of DQ unnecessarily. */ - scc_mgr_apply_group_dqs_io_and_oct_out1(write_group, + scc_mgr_apply_group_dqs_io_and_oct_out1(sdr, write_group, d + new_dqs); } - writel(0, &sdr_scc_mgr->update); + writel(0, &sdr->sdr_scc_mgr.update); - if (rw_mgr_mem_calibrate_write_test(rank_bgn, write_group, 1, + if (rw_mgr_mem_calibrate_write_test(sdr, rank_bgn, write_group, 1, PASS_ALL_BITS, &bit_chk, 0)) { /* Set current end of the window. */ @@ -2944,7 +2944,7 @@ static void search_window(const int search_dm, * certain windows. */ static int -rw_mgr_mem_calibrate_writes_center(const u32 rank_bgn, const u32 write_group, +rw_mgr_mem_calibrate_writes_center(struct socfpga_sdr *sdr, const u32 rank_bgn, const u32 write_group, const u32 test_bgn) { int i; @@ -2968,7 +2968,7 @@ rw_mgr_mem_calibrate_writes_center(const u32 rank_bgn, const u32 write_group, dm_margin = 0; - start_dqs = readl((SDR_PHYGRP_SCCGRP_ADDRESS | + start_dqs = readl(((u32)sdr | SCC_MGR_IO_OUT1_DELAY_OFFSET) + (rwcfg->mem_dq_per_write_dqs << 2)); @@ -2985,12 +2985,12 @@ rw_mgr_mem_calibrate_writes_center(const u32 rank_bgn, const u32 write_group, } /* Search for the left edge of the window for each bit. */ - search_left_edge(1, rank_bgn, write_group, 0, test_bgn, + search_left_edge(sdr, 1, rank_bgn, write_group, 0, test_bgn, &sticky_bit_chk, left_edge, right_edge, 0); /* Search for the right edge of the window for each bit. */ - ret = search_right_edge(1, rank_bgn, write_group, 0, + ret = search_right_edge(sdr, 1, rank_bgn, write_group, 0, start_dqs, 0, &sticky_bit_chk, left_edge, right_edge, 0); @@ -3011,12 +3011,12 @@ rw_mgr_mem_calibrate_writes_center(const u32 rank_bgn, const u32 write_group, __func__, __LINE__, start_dqs, new_dqs, mid_min); /* Add delay to bring centre of all DQ windows to the same "level". */ - center_dq_windows(1, left_edge, right_edge, mid_min, orig_mid_min, + center_dq_windows(sdr, 1, left_edge, right_edge, mid_min, orig_mid_min, min_index, 0, &dq_margin, &dqs_margin); /* Move DQS */ - scc_mgr_apply_group_dqs_io_and_oct_out1(write_group, new_dqs); - writel(0, &sdr_scc_mgr->update); + scc_mgr_apply_group_dqs_io_and_oct_out1(sdr, write_group, new_dqs); + writel(0, &sdr->sdr_scc_mgr.update); /* Centre DM */ debug_cond(DLEVEL >= 2, "%s:%d write_center: DM\n", __func__, __LINE__); @@ -3029,11 +3029,11 @@ rw_mgr_mem_calibrate_writes_center(const u32 rank_bgn, const u32 write_group, right_edge[0] = iocfg->io_out1_delay_max + 1; /* Search for the/part of the window with DM shift. */ - search_window(1, rank_bgn, write_group, &bgn_curr, &end_curr, + search_window(sdr, 1, rank_bgn, write_group, &bgn_curr, &end_curr, &bgn_best, &end_best, &win_best, 0); /* Reset DM delay chains to 0. */ - scc_mgr_apply_group_dm_out1_delay(0); + scc_mgr_apply_group_dm_out1_delay(sdr, 0); /* * Check to see if the current window nudges up aganist 0 delay. @@ -3046,7 +3046,7 @@ rw_mgr_mem_calibrate_writes_center(const u32 rank_bgn, const u32 write_group, } /* Search for the/part of the window with DQS shifts. */ - search_window(0, rank_bgn, write_group, &bgn_curr, &end_curr, + search_window(sdr, 0, rank_bgn, write_group, &bgn_curr, &end_curr, &bgn_best, &end_best, &win_best, new_dqs); /* Assign left and right edge for cal and reporting. */ @@ -3057,7 +3057,7 @@ rw_mgr_mem_calibrate_writes_center(const u32 rank_bgn, const u32 write_group, __func__, __LINE__, left_edge[0], right_edge[0]); /* Move DQS (back to orig). */ - scc_mgr_apply_group_dqs_io_and_oct_out1(write_group, new_dqs); + scc_mgr_apply_group_dqs_io_and_oct_out1(sdr, write_group, new_dqs); /* Move DM */ @@ -3074,8 +3074,8 @@ rw_mgr_mem_calibrate_writes_center(const u32 rank_bgn, const u32 write_group, else dm_margin = left_edge[0] - mid; - scc_mgr_apply_group_dm_out1_delay(mid); - writel(0, &sdr_scc_mgr->update); + scc_mgr_apply_group_dm_out1_delay(sdr, mid); + writel(0, &sdr->sdr_scc_mgr.update); debug_cond(DLEVEL >= 2, "%s:%d dm_calib: left=%d right=%d mid=%d dm_margin=%d\n", @@ -3092,7 +3092,7 @@ rw_mgr_mem_calibrate_writes_center(const u32 rank_bgn, const u32 write_group, * Do not remove this line as it makes sure all of our * decisions have been applied. */ - writel(0, &sdr_scc_mgr->update); + writel(0, &sdr->sdr_scc_mgr.update); if ((dq_margin < 0) || (dqs_margin < 0) || (dm_margin < 0)) return -EINVAL; @@ -3111,7 +3111,7 @@ rw_mgr_mem_calibrate_writes_center(const u32 rank_bgn, const u32 write_group, * This function implements UniPHY calibration Stage 2, as explained in * detail in Altera EMI_RM 2015.05.04 , "UniPHY Calibration Stages". */ -static int rw_mgr_mem_calibrate_writes(const u32 rank_bgn, const u32 group, +static int rw_mgr_mem_calibrate_writes(struct socfpga_sdr *sdr, const u32 rank_bgn, const u32 group, const u32 test_bgn) { int ret; @@ -3119,11 +3119,11 @@ static int rw_mgr_mem_calibrate_writes(const u32 rank_bgn, const u32 group, /* Update info for sims */ debug("%s:%d %u %u\n", __func__, __LINE__, group, test_bgn); - reg_file_set_group(group); - reg_file_set_stage(CAL_STAGE_WRITES); - reg_file_set_sub_stage(CAL_SUBSTAGE_WRITES_CENTER); + reg_file_set_group(sdr, group); + reg_file_set_stage(sdr, CAL_STAGE_WRITES); + reg_file_set_sub_stage(sdr, CAL_SUBSTAGE_WRITES_CENTER); - ret = rw_mgr_mem_calibrate_writes_center(rank_bgn, group, test_bgn); + ret = rw_mgr_mem_calibrate_writes_center(sdr, rank_bgn, group, test_bgn); if (ret) set_failing_group_stage(group, CAL_STAGE_WRITES, CAL_SUBSTAGE_WRITES_CENTER); @@ -3136,28 +3136,28 @@ static int rw_mgr_mem_calibrate_writes(const u32 rank_bgn, const u32 group, * * Precharge all banks and activate row 0 in bank "000..." and bank "111...". */ -static void mem_precharge_and_activate(void) +static void mem_precharge_and_activate(struct socfpga_sdr *sdr) { int r; for (r = 0; r < rwcfg->mem_number_of_ranks; r++) { /* Set rank. */ - set_rank_and_odt_mask(r, RW_MGR_ODT_MODE_OFF); + set_rank_and_odt_mask(sdr, r, RW_MGR_ODT_MODE_OFF); /* Precharge all banks. */ - writel(rwcfg->precharge_all, SDR_PHYGRP_RWMGRGRP_ADDRESS | + writel(rwcfg->precharge_all, ((u32)(&sdr->rwmgr_grp)) | RW_MGR_RUN_SINGLE_GROUP_OFFSET); - writel(0x0F, &sdr_rw_load_mgr_regs->load_cntr0); + writel(0x0F, &sdr->sdr_rw_load_mgr_regs.load_cntr0); writel(rwcfg->activate_0_and_1_wait1, - &sdr_rw_load_jump_mgr_regs->load_jump_add0); + &sdr->sdr_rw_load_jump_mgr_regs.load_jump_add0); - writel(0x0F, &sdr_rw_load_mgr_regs->load_cntr1); + writel(0x0F, &sdr->sdr_rw_load_mgr_regs.load_cntr1); writel(rwcfg->activate_0_and_1_wait2, - &sdr_rw_load_jump_mgr_regs->load_jump_add1); + &sdr->sdr_rw_load_jump_mgr_regs.load_jump_add1); /* Activate rows. */ - writel(rwcfg->activate_0_and_1, SDR_PHYGRP_RWMGRGRP_ADDRESS | + writel(rwcfg->activate_0_and_1, ((u32)(&sdr->rwmgr_grp)) | RW_MGR_RUN_SINGLE_GROUP_OFFSET); } } @@ -3167,7 +3167,7 @@ static void mem_precharge_and_activate(void) * * Configure memory RLAT and WLAT parameters. */ -static void mem_init_latency(void) +static void mem_init_latency(struct socfpga_sdr *sdr) { /* * For AV/CV, LFIFO is hardened and always runs at full rate @@ -3183,23 +3183,23 @@ static void mem_init_latency(void) * Read in write latency. * WL for Hard PHY does not include additive latency. */ - wlat = readl(&data_mgr->t_wl_add); - wlat += readl(&data_mgr->mem_t_add); + wlat = readl(&sdr->data_mgr.t_wl_add); + wlat += readl(&sdr->data_mgr.mem_t_add); gbl->rw_wl_nop_cycles = wlat - 1; /* Read in readl latency. */ - rlat = readl(&data_mgr->t_rl_add); + rlat = readl(&sdr->data_mgr.t_rl_add); /* Set a pretty high read latency initially. */ gbl->curr_read_lat = rlat + 16; if (gbl->curr_read_lat > max_latency) gbl->curr_read_lat = max_latency; - writel(gbl->curr_read_lat, &phy_mgr_cfg->phy_rlat); + writel(gbl->curr_read_lat, &sdr->phy_mgr_cfg.phy_rlat); /* Advertise write latency. */ - writel(wlat, &phy_mgr_cfg->afi_wlat); + writel(wlat, &sdr->phy_mgr_cfg.afi_wlat); } /** @@ -3207,7 +3207,7 @@ static void mem_init_latency(void) * * Set VFIFO and LFIFO to instant-on settings in skip calibration mode. */ -static void mem_skip_calibrate(void) +static void mem_skip_calibrate(struct socfpga_sdr *sdr) { u32 vfifo_offset; u32 i, j, r; @@ -3221,11 +3221,11 @@ static void mem_skip_calibrate(void) * skip calibration. */ for (i = 0; i < rwcfg->mem_if_read_dqs_width; i++) { - scc_mgr_set_dqs_en_phase(i, 0); + scc_mgr_set_dqs_en_phase(sdr, i, 0); if (iocfg->dll_chain_length == 6) - scc_mgr_set_dqdqs_output_phase(i, 6); + scc_mgr_set_dqdqs_output_phase(sdr, i, 6); else - scc_mgr_set_dqdqs_output_phase(i, 7); + scc_mgr_set_dqdqs_output_phase(sdr, i, 7); /* * Case:33398 * @@ -3252,27 +3252,27 @@ static void mem_skip_calibrate(void) * * (1.25 * iocfg->dll_chain_length - 2) */ - scc_mgr_set_dqdqs_output_phase(i, + scc_mgr_set_dqdqs_output_phase(sdr, i, ((125 * iocfg->dll_chain_length) / 100) - 2); } - writel(0xff, &sdr_scc_mgr->dqs_ena); - writel(0xff, &sdr_scc_mgr->dqs_io_ena); + writel(0xff, &sdr->sdr_scc_mgr.dqs_ena); + writel(0xff, &sdr->sdr_scc_mgr.dqs_io_ena); for (i = 0; i < rwcfg->mem_if_write_dqs_width; i++) { - writel(i, SDR_PHYGRP_SCCGRP_ADDRESS | + writel(i, (u32)sdr | SCC_MGR_GROUP_COUNTER_OFFSET); } - writel(0xff, &sdr_scc_mgr->dq_ena); - writel(0xff, &sdr_scc_mgr->dm_ena); - writel(0, &sdr_scc_mgr->update); + writel(0xff, &sdr->sdr_scc_mgr.dq_ena); + writel(0xff, &sdr->sdr_scc_mgr.dm_ena); + writel(0, &sdr->sdr_scc_mgr.update); } /* Compensate for simulation model behaviour */ for (i = 0; i < rwcfg->mem_if_read_dqs_width; i++) { - scc_mgr_set_dqs_bus_in_delay(i, 10); - scc_mgr_load_dqs(i); + scc_mgr_set_dqs_bus_in_delay(sdr, i, 10); + scc_mgr_load_dqs(sdr, i); } - writel(0, &sdr_scc_mgr->update); + writel(0, &sdr->sdr_scc_mgr.update); /* * ArriaV has hard FIFOs that can only be initialized by incrementing @@ -3280,15 +3280,15 @@ static void mem_skip_calibrate(void) */ vfifo_offset = misccfg->calib_vfifo_offset; for (j = 0; j < vfifo_offset; j++) - writel(0xff, &phy_mgr_cmd->inc_vfifo_hard_phy); - writel(0, &phy_mgr_cmd->fifo_reset); + writel(0xff, &sdr->phy_mgr_cmd.inc_vfifo_hard_phy); + writel(0, &sdr->phy_mgr_cmd.fifo_reset); /* * For Arria V and Cyclone V with hard LFIFO, we get the skip-cal * setting from generation-time constant. */ gbl->curr_read_lat = misccfg->calib_lfifo_offset; - writel(gbl->curr_read_lat, &phy_mgr_cfg->phy_rlat); + writel(gbl->curr_read_lat, &sdr->phy_mgr_cfg.phy_rlat); } /** @@ -3296,7 +3296,7 @@ static void mem_skip_calibrate(void) * * Perform memory calibration. */ -static u32 mem_calibrate(void) +static u32 mem_calibrate(struct socfpga_sdr *sdr) { u32 i; u32 rank_bgn, sr; @@ -3319,19 +3319,19 @@ static u32 mem_calibrate(void) gbl->fom_out = 0; /* Initialize WLAT and RLAT. */ - mem_init_latency(); + mem_init_latency(sdr); /* Initialize bit slips. */ - mem_precharge_and_activate(); + mem_precharge_and_activate(sdr); for (i = 0; i < rwcfg->mem_if_read_dqs_width; i++) { - writel(i, SDR_PHYGRP_SCCGRP_ADDRESS | + writel(i, (u32)sdr | SCC_MGR_GROUP_COUNTER_OFFSET); /* Only needed once to set all groups, pins, DQ, DQS, DM. */ if (i == 0) - scc_mgr_set_hhp_extras(); + scc_mgr_set_hhp_extras(sdr); - scc_set_bypass_mode(i); + scc_set_bypass_mode(sdr, i); } /* Calibration is skipped. */ @@ -3340,13 +3340,13 @@ static u32 mem_calibrate(void) * Set VFIFO and LFIFO to instant-on settings in skip * calibration mode. */ - mem_skip_calibrate(); + mem_skip_calibrate(sdr); /* * Do not remove this line as it makes sure all of our * decisions have been applied. */ - writel(0, &sdr_scc_mgr->update); + writel(0, &sdr->sdr_scc_mgr.update); return 1; } @@ -3356,7 +3356,7 @@ static u32 mem_calibrate(void) * Zero all delay chain/phase settings for all * groups and all shadow register sets. */ - scc_mgr_zero_all(); + scc_mgr_zero_all(sdr); run_groups = ~0; @@ -3374,9 +3374,9 @@ static u32 mem_calibrate(void) if (current_run == 0) continue; - writel(write_group, SDR_PHYGRP_SCCGRP_ADDRESS | + writel(write_group, (u32)sdr | SCC_MGR_GROUP_COUNTER_OFFSET); - scc_mgr_zero_group(write_group, 0); + scc_mgr_zero_group(sdr, write_group, 0); for (read_group = write_group * rwdqs_ratio, read_test_bgn = 0; @@ -3387,7 +3387,7 @@ static u32 mem_calibrate(void) continue; /* Calibrate the VFIFO */ - if (rw_mgr_mem_calibrate_vfifo(read_group, + if (rw_mgr_mem_calibrate_vfifo(sdr, read_group, read_test_bgn)) continue; @@ -3412,7 +3412,7 @@ static u32 mem_calibrate(void) continue; /* Calibrate WRITEs */ - if (!rw_mgr_mem_calibrate_writes(rank_bgn, + if (!rw_mgr_mem_calibrate_writes(sdr, rank_bgn, write_group, write_test_bgn)) continue; @@ -3435,7 +3435,7 @@ static u32 mem_calibrate(void) if (STATIC_CALIB_STEPS & CALIB_SKIP_WRITES) continue; - if (!rw_mgr_mem_calibrate_vfifo_end(read_group, + if (!rw_mgr_mem_calibrate_vfifo_end(sdr, read_group, read_test_bgn)) continue; @@ -3465,7 +3465,7 @@ grp_failed: /* A group failed, increment the counter. */ continue; /* Calibrate the LFIFO */ - if (!rw_mgr_mem_calibrate_lfifo()) + if (!rw_mgr_mem_calibrate_lfifo(sdr)) return 0; } @@ -3473,7 +3473,7 @@ grp_failed: /* A group failed, increment the counter. */ * Do not remove this line as it makes sure all of our decisions * have been applied. */ - writel(0, &sdr_scc_mgr->update); + writel(0, &sdr->sdr_scc_mgr.update); return 1; } @@ -3482,7 +3482,7 @@ grp_failed: /* A group failed, increment the counter. */ * * This function triggers the entire memory calibration procedure. */ -static int run_mem_calibrate(void) +static int run_mem_calibrate(struct socfpga_sdr *sdr) { int pass; u32 ctrl_cfg; @@ -3490,33 +3490,33 @@ static int run_mem_calibrate(void) debug("%s:%d\n", __func__, __LINE__); /* Reset pass/fail status shown on afi_cal_success/fail */ - writel(PHY_MGR_CAL_RESET, &phy_mgr_cfg->cal_status); + writel(PHY_MGR_CAL_RESET, &sdr->phy_mgr_cfg.cal_status); /* Stop tracking manager. */ - ctrl_cfg = readl(&sdr_ctrl->ctrl_cfg); + ctrl_cfg = readl(&sdr->sdr_ctrl.ctrl_cfg); writel(ctrl_cfg & ~SDR_CTRLGRP_CTRLCFG_DQSTRKEN_MASK, - &sdr_ctrl->ctrl_cfg); + &sdr->sdr_ctrl.ctrl_cfg); - phy_mgr_initialize(); - rw_mgr_mem_initialize(); + phy_mgr_initialize(sdr); + rw_mgr_mem_initialize(sdr); /* Perform the actual memory calibration. */ - pass = mem_calibrate(); + pass = mem_calibrate(sdr); - mem_precharge_and_activate(); - writel(0, &phy_mgr_cmd->fifo_reset); + mem_precharge_and_activate(sdr); + writel(0, &sdr->phy_mgr_cmd.fifo_reset); /* Handoff. */ - rw_mgr_mem_handoff(); + rw_mgr_mem_handoff(sdr); /* * In Hard PHY this is a 2-bit control: * 0: AFI Mux Select * 1: DDIO Mux Select */ - writel(0x2, &phy_mgr_cfg->mux_sel); + writel(0x2, &sdr->phy_mgr_cfg.mux_sel); /* Start tracking manager. */ - writel(ctrl_cfg, &sdr_ctrl->ctrl_cfg); + writel(ctrl_cfg, &sdr->sdr_ctrl.ctrl_cfg); return pass; } @@ -3528,7 +3528,7 @@ static int run_mem_calibrate(void) * This function reports the results of the memory calibration * and writes debug information into the register file. */ -static void debug_mem_calibrate(int pass) +static void debug_mem_calibrate(struct socfpga_sdr *sdr, int pass) { u32 debug_info; @@ -3547,10 +3547,10 @@ static void debug_mem_calibrate(int pass) /* Update the FOM in the register file */ debug_info = gbl->fom_in; debug_info |= gbl->fom_out << 8; - writel(debug_info, &sdr_reg_file->fom); + writel(debug_info, &sdr->sdr_reg_file.fom); - writel(debug_info, &phy_mgr_cfg->cal_debug_info); - writel(PHY_MGR_CAL_SUCCESS, &phy_mgr_cfg->cal_status); + writel(debug_info, &sdr->phy_mgr_cfg.cal_debug_info); + writel(PHY_MGR_CAL_SUCCESS, &sdr->phy_mgr_cfg.cal_status); } else { debug("%s: CALIBRATION FAILED\n", __FILE__); @@ -3558,15 +3558,15 @@ static void debug_mem_calibrate(int pass) debug_info |= gbl->error_substage << 8; debug_info |= gbl->error_group << 16; - writel(debug_info, &sdr_reg_file->failing_stage); - writel(debug_info, &phy_mgr_cfg->cal_debug_info); - writel(PHY_MGR_CAL_FAIL, &phy_mgr_cfg->cal_status); + writel(debug_info, &sdr->sdr_reg_file.failing_stage); + writel(debug_info, &sdr->phy_mgr_cfg.cal_debug_info); + writel(PHY_MGR_CAL_FAIL, &sdr->phy_mgr_cfg.cal_status); /* Update the failing group/stage in the register file */ debug_info = gbl->error_stage; debug_info |= gbl->error_substage << 8; debug_info |= gbl->error_group << 16; - writel(debug_info, &sdr_reg_file->failing_stage); + writel(debug_info, &sdr->sdr_reg_file.failing_stage); } debug("%s: Calibration complete\n", __FILE__); @@ -3577,19 +3577,19 @@ static void debug_mem_calibrate(int pass) * * Initialize ROM data. */ -static void hc_initialize_rom_data(void) +static void hc_initialize_rom_data(struct socfpga_sdr *sdr) { unsigned int nelem = 0; const u32 *rom_init; u32 i, addr; socfpga_get_seq_inst_init(&rom_init, &nelem); - addr = SDR_PHYGRP_RWMGRGRP_ADDRESS | RW_MGR_INST_ROM_WRITE_OFFSET; + addr = ((u32)(&sdr->rwmgr_grp)) | RW_MGR_INST_ROM_WRITE_OFFSET; for (i = 0; i < nelem; i++) writel(rom_init[i], addr + (i << 2)); socfpga_get_seq_ac_init(&rom_init, &nelem); - addr = SDR_PHYGRP_RWMGRGRP_ADDRESS | RW_MGR_AC_ROM_WRITE_OFFSET; + addr = ((u32)(&sdr->rwmgr_grp)) | RW_MGR_AC_ROM_WRITE_OFFSET; for (i = 0; i < nelem; i++) writel(rom_init[i], addr + (i << 2)); } @@ -3599,16 +3599,16 @@ static void hc_initialize_rom_data(void) * * Initialize SDR register file. */ -static void initialize_reg_file(void) +static void initialize_reg_file(struct socfpga_sdr *sdr) { /* Initialize the register file with the correct data */ - writel(misccfg->reg_file_init_seq_signature, &sdr_reg_file->signature); - writel(0, &sdr_reg_file->debug_data_addr); - writel(0, &sdr_reg_file->cur_stage); - writel(0, &sdr_reg_file->fom); - writel(0, &sdr_reg_file->failing_stage); - writel(0, &sdr_reg_file->debug1); - writel(0, &sdr_reg_file->debug2); + writel(misccfg->reg_file_init_seq_signature, &sdr->sdr_reg_file.signature); + writel(0, &sdr->sdr_reg_file.debug_data_addr); + writel(0, &sdr->sdr_reg_file.cur_stage); + writel(0, &sdr->sdr_reg_file.fom); + writel(0, &sdr->sdr_reg_file.failing_stage); + writel(0, &sdr->sdr_reg_file.debug1); + writel(0, &sdr->sdr_reg_file.debug2); } /** @@ -3616,7 +3616,7 @@ static void initialize_reg_file(void) * * Initialize HPS PHY. */ -static void initialize_hps_phy(void) +static void initialize_hps_phy(struct socfpga_sdr *sdr) { u32 reg; /* @@ -3644,7 +3644,7 @@ static void initialize_hps_phy(void) reg |= SDR_CTRLGRP_PHYCTRL_PHYCTRL_0_ADDLATSEL_SET(0); reg |= SDR_CTRLGRP_PHYCTRL_PHYCTRL_0_SAMPLECOUNT_19_0_SET( trk_sample_count); - writel(reg, &sdr_ctrl->phy_ctrl0); + writel(reg, &sdr->sdr_ctrl.phy_ctrl0); reg = 0; reg |= SDR_CTRLGRP_PHYCTRL_PHYCTRL_1_SAMPLECOUNT_31_20_SET( @@ -3652,13 +3652,13 @@ static void initialize_hps_phy(void) SDR_CTRLGRP_PHYCTRL_PHYCTRL_0_SAMPLECOUNT_19_0_WIDTH); reg |= SDR_CTRLGRP_PHYCTRL_PHYCTRL_1_LONGIDLESAMPLECOUNT_19_0_SET( trk_long_idle_sample_count); - writel(reg, &sdr_ctrl->phy_ctrl1); + writel(reg, &sdr->sdr_ctrl.phy_ctrl1); reg = 0; reg |= SDR_CTRLGRP_PHYCTRL_PHYCTRL_2_LONGIDLESAMPLECOUNT_31_20_SET( trk_long_idle_sample_count >> SDR_CTRLGRP_PHYCTRL_PHYCTRL_1_LONGIDLESAMPLECOUNT_19_0_WIDTH); - writel(reg, &sdr_ctrl->phy_ctrl2); + writel(reg, &sdr->sdr_ctrl.phy_ctrl2); } /** @@ -3666,7 +3666,7 @@ static void initialize_hps_phy(void) * * Initialize the register file with usable initial data. */ -static void initialize_tracking(void) +static void initialize_tracking(struct socfpga_sdr *sdr) { /* * Initialize the register file with the correct data. @@ -3675,13 +3675,13 @@ static void initialize_tracking(void) */ writel(DIV_ROUND_UP(iocfg->delay_per_opa_tap, iocfg->delay_per_dchain_tap) - 1, - &sdr_reg_file->dtaps_per_ptap); + &sdr->sdr_reg_file.dtaps_per_ptap); /* trk_sample_count */ - writel(7500, &sdr_reg_file->trk_sample_count); + writel(7500, &sdr->sdr_reg_file.trk_sample_count); /* longidle outer loop [15:0] */ - writel((10 << 16) | (100 << 0), &sdr_reg_file->trk_longidle); + writel((10 << 16) | (100 << 0), &sdr->sdr_reg_file.trk_longidle); /* * longidle sample count [31:24] @@ -3690,22 +3690,22 @@ static void initialize_tracking(void) * vfifo wait [7:0] */ writel((243 << 24) | (14 << 16) | (10 << 8) | (4 << 0), - &sdr_reg_file->delays); + &sdr->sdr_reg_file.delays); /* mux delay */ writel((rwcfg->idle << 24) | (rwcfg->activate_1 << 16) | (rwcfg->sgle_read << 8) | (rwcfg->precharge_all << 0), - &sdr_reg_file->trk_rw_mgr_addr); + &sdr->sdr_reg_file.trk_rw_mgr_addr); writel(rwcfg->mem_if_read_dqs_width, - &sdr_reg_file->trk_read_dqs_width); + &sdr->sdr_reg_file.trk_read_dqs_width); /* trefi [7:0] */ writel((rwcfg->refresh_all << 24) | (1000 << 0), - &sdr_reg_file->trk_rfsh); + &sdr->sdr_reg_file.trk_rfsh); } -int sdram_calibration_full(void) +int sdram_calibration_full(struct socfpga_sdr *sdr) { struct param_type my_param; struct gbl_type my_gbl; @@ -3731,14 +3731,14 @@ int sdram_calibration_full(void) gbl->phy_debug_mode_flags |= PHY_DEBUG_DISABLE_GUARANTEED_READ; #endif /* Initialize the register file */ - initialize_reg_file(); + initialize_reg_file(sdr); /* Initialize any PHY CSR */ - initialize_hps_phy(); + initialize_hps_phy(sdr); - scc_mgr_initialize(); + scc_mgr_initialize(sdr); - initialize_tracking(); + initialize_tracking(sdr); debug("%s: Preparing to start memory calibration\n", __FILE__); @@ -3766,11 +3766,11 @@ int sdram_calibration_full(void) debug_cond(DLEVEL >= 1, "dqs_in_reserve=%u dqs_out_reserve=%u\n", iocfg->dqs_in_reserve, iocfg->dqs_out_reserve); - hc_initialize_rom_data(); + hc_initialize_rom_data(sdr); /* update info for sims */ - reg_file_set_stage(CAL_STAGE_NIL); - reg_file_set_group(0); + reg_file_set_stage(sdr, CAL_STAGE_NIL); + reg_file_set_group(sdr, 0); /* * Load global needed for those actions that require @@ -3786,7 +3786,7 @@ int sdram_calibration_full(void) else skip_delay_mask = 0x0; - pass = run_mem_calibrate(); - debug_mem_calibrate(pass); + pass = run_mem_calibrate(sdr); + debug_mem_calibrate(sdr, pass); return pass; } diff --git a/drivers/ddr/altera/sequencer.h b/drivers/ddr/altera/sequencer.h index a5760b03a5..7e182f0140 100644 --- a/drivers/ddr/altera/sequencer.h +++ b/drivers/ddr/altera/sequencer.h @@ -80,11 +80,11 @@ #define SCC_MGR_HHP_RFILE_OFFSET 0x0B00 #define SCC_MGR_AFI_CAL_INIT_OFFSET 0x0D00 -#define SDR_PHYGRP_SCCGRP_ADDRESS (SOCFPGA_SDR_ADDRESS | 0x0) +/*#define SDR_PHYGRP_SCCGRP_ADDRESS (SOCFPGA_SDR_ADDRESS | 0x0) #define SDR_PHYGRP_PHYMGRGRP_ADDRESS (SOCFPGA_SDR_ADDRESS | 0x1000) #define SDR_PHYGRP_RWMGRGRP_ADDRESS (SOCFPGA_SDR_ADDRESS | 0x2000) #define SDR_PHYGRP_DATAMGRGRP_ADDRESS (SOCFPGA_SDR_ADDRESS | 0x4000) -#define SDR_PHYGRP_REGFILEGRP_ADDRESS (SOCFPGA_SDR_ADDRESS | 0x4800) +#define SDR_PHYGRP_REGFILEGRP_ADDRESS (SOCFPGA_SDR_ADDRESS | 0x4800)*/ #define PHY_MGR_CAL_RESET (0) #define PHY_MGR_CAL_SUCCESS (1) @@ -223,4 +223,28 @@ struct socfpga_data_mgr { u32 mem_t_add; u32 t_rl_add; }; + +struct socfpga_sdr { /* SOCFPGA_SDR_ADDRESS, SDR_PHYGRP_SCCGRP_ADDRESS */ + u8 _align1[0xe00]; + struct socfpga_sdr_scc_mgr sdr_scc_mgr; /* @ SDR_PHYGRP_SCCGRP_ADDRESS | 0xe00 -> SOCFPGA_SDR_ADDRESS | 0xe00 */ + u8 _align2[0x1bc]; + struct socfpga_phy_mgr_cmd phy_mgr_cmd; /* SDR_PHYGRP_PHYMGRGRP_ADDRESS -> SOCFPGA_SDR_ADDRESS | 0x1000 */ + u8 _align3[0x2c]; + struct socfpga_phy_mgr_cfg phy_mgr_cfg; /* SDR_PHYGRP_PHYMGRGRP_ADDRESS | 0x40 -> SOCFPGA_SDR_ADDRESS | 0x1040 */ + u8 _align4[0xfa0]; + u8 rwmgr_grp[0x800]; /* SDR_PHYGRP_RWMGRGRP_ADDRESS -> SOCFPGA_SDR_ADDRESS | 0x2000 */ + struct socfpga_sdr_rw_load_manager sdr_rw_load_mgr_regs; /* SDR_PHYGRP_RWMGRGRP_ADDRESS | 0x800 -> SOCFPGA_SDR_ADDRESS | 0x2800 */ + u8 _align5[0x3f0]; + struct socfpga_sdr_rw_load_jump_manager sdr_rw_load_jump_mgr_regs; /* SDR_PHYGRP_RWMGRGRP_ADDRESS | 0xC00 -> SOCFPGA_SDR_ADDRESS | 0x2C00 */ + u8 _align6[0x13f0]; + struct socfpga_data_mgr data_mgr; /* SDR_PHYGRP_DATAMGRGRP_ADDRESS -> SOCFPGA_SDR_ADDRESS | 0x4000 */ + u8 _align7[0x7f0]; + struct socfpga_sdr_reg_file sdr_reg_file; /* SDR_PHYGRP_REGFILEGRP_ADDRESS -> SOCFPGA_SDR_ADDRESS | 0x4800 */ + u8 _align8[0x7c8]; + struct socfpga_sdr_ctrl sdr_ctrl; /* SDR_CTRLGRP_ADDRESS -> SOCFPGA_SDR_ADDRESS | 0x5000 */ + u8 _align9[0xea4]; +}; + +int sdram_calibration_full(struct socfpga_sdr *sdr); + #endif /* _SEQUENCER_H_ */ -- 2.17.1

4 11

[U-Boot] [PATCH v2] warp7: README: Adjust the binary name after DM conversion
by Fabio Estevam 14 Feb '19

14 Feb '19

After the conversion to DM the U-Boot binary is called u-boot-dtb.imx, so fix the README file accordingly. Signed-off-by: Fabio Estevam <festevam(a)gmail.com> --- Changes since v1: - Fix all occurrances board/warp7/README | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/board/warp7/README b/board/warp7/README index 60339da543..579bb2de38 100644 --- a/board/warp7/README +++ b/board/warp7/README @@ -17,7 +17,7 @@ $ make mrproper $ make warp7_config $ make -This will generate the U-Boot binary called u-boot.imx. +This will generate the U-Boot binary called u-boot-dtb.imx. Put warp7 board in USB download mode: @@ -28,11 +28,11 @@ Connect a USB to serial adapter between the host PC and warp7 Connect a USB cable between the OTG warp7 port and the host PC -Copy u-boot.imx to the imx_usb_loader folder. +Copy u-boot-dtb.imx to the imx_usb_loader folder. -Load u-boot.imx via USB: +Load u-boot-dtb.imx via USB: -$ sudo ./imx_usb u-boot.imx +$ sudo ./imx_usb u-boot-dtb.imx Then U-Boot should start and its messages will appear in the console program. @@ -46,9 +46,9 @@ Use the default environment variables: Run the DFU command: => dfu 0 mmc 0 -Transfer u-boot.imx that will be flashed into the eMMC: +Transfer u-boot-dtb.imx that will be flashed into the eMMC: -$ sudo dfu-util -D u-boot.imx -a boot +$ sudo dfu-util -D u-boot-dtb.imx -a boot Then on the U-Boot prompt the following message should be seen after a successful upgrade: -- 2.17.1

4 4

[U-Boot] [PATCH v2] rpi: add Compute Module 3+
by Jonathan Gray 14 Feb '19

14 Feb '19

Add Raspberry Pi Compute Module 3+ to list of models, the revision code is 0x10 according to the list on raspberrypi.org. v2: Use the same dtb name as CM3 as CM3+ is a drop in replacement for CM3. Signed-off-by: Jonathan Gray <jsg(a)jsg.id.au> --- board/raspberrypi/rpi/rpi.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/board/raspberrypi/rpi/rpi.c b/board/raspberrypi/rpi/rpi.c index 153a1fdcb7..617c892dde 100644 --- a/board/raspberrypi/rpi/rpi.c +++ b/board/raspberrypi/rpi/rpi.c @@ -143,6 +143,11 @@ static const struct rpi_model rpi_models_new_scheme[] = { DTB_DIR "bcm2837-rpi-3-a-plus.dtb", false, }, + [0x10] = { + "Compute Module 3+", + DTB_DIR "bcm2837-rpi-cm3.dtb", + false, + }, }; static const struct rpi_model rpi_models_old_scheme[] = { -- 2.20.1

2 1