| // SPDX-License-Identifier: GPL-2.0-only | |
| /* | |
| * Copyright (c) 2017-2026 Morse Micro | |
| */ | |
| #include <linux/kernel.h> | |
| #include <linux/module.h> | |
| #include <linux/slab.h> | |
| #include <linux/workqueue.h> | |
| #include <linux/mmc/card.h> | |
| #include <linux/mmc/mmc.h> | |
| #include <linux/mmc/host.h> | |
| #include <linux/mmc/sdio_func.h> | |
| #include <linux/mmc/sdio_ids.h> | |
| #include <linux/mmc/sdio.h> | |
| #include <linux/mmc/sd.h> | |
| #include "hw.h" | |
| #include "core.h" | |
| #include "bus.h" | |
| #include "mac.h" | |
| #include "fw.h" | |
| #include "hif.h" | |
| /* | |
| * Value to indicate that the base address for bulk/register | |
| * read/writes has yet to be set | |
| */ | |
| #define MM81X_SDIO_BASE_ADDR_UNSET 0xFFFFFFFF | |
| #define MM81X_SDIO_ALIGNMENT (8) | |
| #define MM81X_SDIO_REG_ADDRESS_BASE 0x10000 | |
| #define MM81X_SDIO_REG_ADDRESS_WINDOW_0 MM81X_SDIO_REG_ADDRESS_BASE | |
| #define MM81X_SDIO_REG_ADDRESS_WINDOW_1 (MM81X_SDIO_REG_ADDRESS_BASE + 1) | |
| #define MM81X_SDIO_REG_ADDRESS_CONFIG (MM81X_SDIO_REG_ADDRESS_BASE + 2) | |
| struct mm81x_sdio { | |
| bool enabled; | |
| u32 bulk_addr_base; | |
| u32 register_addr_base; | |
| struct sdio_func *func; | |
| const struct sdio_device_id *id; | |
| }; | |
| static void irq_handler(struct sdio_func *func1) | |
| { | |
| struct sdio_func *func = func1->card->sdio_func[1]; | |
| struct mm81x *mors = sdio_get_drvdata(func); | |
| mm81x_hw_irq_handle(mors); | |
| } | |
| static int mm81x_sdio_enable_irq(struct mm81x_sdio *sdio) | |
| { | |
| int ret; | |
| struct sdio_func *func = sdio->func; | |
| struct sdio_func *func1 = func->card->sdio_func[0]; | |
| struct mm81x *mors = sdio_get_drvdata(func); | |
| sdio_claim_host(func); | |
| ret = sdio_claim_irq(func1, irq_handler); | |
| if (ret) | |
| dev_err(mors->dev, "Failed to enable sdio irq: %d\n", ret); | |
| sdio_release_host(func); | |
| return ret; | |
| } | |
| static void mm81x_sdio_disable_irq(struct mm81x_sdio *sdio) | |
| { | |
| struct sdio_func *func = sdio->func; | |
| struct sdio_func *func1 = func->card->sdio_func[0]; | |
| sdio_claim_host(func); | |
| sdio_release_irq(func1); | |
| sdio_release_host(func); | |
| } | |
| static void mm81x_sdio_set_irq(struct mm81x *mors, bool enable) | |
| { | |
| struct mm81x_sdio *sdio = (struct mm81x_sdio *)mors->drv_priv; | |
| if (enable) | |
| mm81x_sdio_enable_irq(sdio); | |
| else | |
| mm81x_sdio_disable_irq(sdio); | |
| } | |
| static u32 mm81x_sdio_calculate_base_address(u32 address, u8 access) | |
| { | |
| return (address & MM81X_SDIO_RW_ADDR_BOUNDARY_MASK) | (access & 0x3); | |
| } | |
| static void mm81x_sdio_reset_base_address(struct mm81x_sdio *sdio) | |
| { | |
| sdio->bulk_addr_base = MM81X_SDIO_BASE_ADDR_UNSET; | |
| sdio->register_addr_base = MM81X_SDIO_BASE_ADDR_UNSET; | |
| } | |
| static int mm81x_sdio_set_func_address_base(struct mm81x_sdio *sdio, | |
| struct sdio_func *func, u32 address, | |
| u8 access) | |
| { | |
| int ret = 0; | |
| int retries = 0; | |
| static const int max_retries = 3; | |
| struct sdio_func *func2 = sdio->func; | |
| struct mm81x *mors = sdio_get_drvdata(sdio->func); | |
| s32 calculated_addr_base = | |
| mm81x_sdio_calculate_base_address(address, access); | |
| u32 *current_addr_base = func == func2 ? &sdio->bulk_addr_base : | |
| &sdio->register_addr_base; | |
| if ((*current_addr_base) == calculated_addr_base && | |
| *current_addr_base != MM81X_SDIO_BASE_ADDR_UNSET) | |
| return ret; | |
| retry: | |
| sdio_writeb(func, (u8)u32_get_bits(address, GENMASK(23, 16)), | |
| MM81X_SDIO_REG_ADDRESS_WINDOW_0, &ret); | |
| if (ret) | |
| goto err; | |
| sdio_writeb(func, (u8)u32_get_bits(address, GENMASK(31, 24)), | |
| MM81X_SDIO_REG_ADDRESS_WINDOW_1, &ret); | |
| if (ret) | |
| goto err; | |
| sdio_writeb(func, access & 0x3, MM81X_SDIO_REG_ADDRESS_CONFIG, &ret); | |
| if (ret) | |
| goto err; | |
| *current_addr_base = calculated_addr_base; | |
| if (retries) | |
| dev_dbg(mors->dev, "%s succeeded after %d retries\n", __func__, | |
| retries); | |
| return ret; | |
| err: | |
| retries++; | |
| if (ret == -ETIMEDOUT && retries <= max_retries) { | |
| dev_dbg(mors->dev, "%s failed (%d), retrying (%d/%d)\n", | |
| __func__, ret, retries, max_retries); | |
| goto retry; | |
| } | |
| *current_addr_base = MM81X_SDIO_BASE_ADDR_UNSET; | |
| return ret; | |
| } | |
| static int mm81x_sdio_mem_write_block(struct mm81x_sdio *sdio, u32 address, | |
| u8 *data, ssize_t size) | |
| { | |
| int ret; | |
| struct sdio_func *func2 = sdio->func; | |
| struct mm81x *mors = sdio_get_drvdata(sdio->func); | |
| mm81x_sdio_set_func_address_base(sdio, func2, address, | |
| MM81X_CONFIG_ACCESS_4BYTE); | |
| if (unlikely(!IS_ALIGNED((uintptr_t)data, | |
| mors->bus_ops->bulk_alignment))) { | |
| ret = -EBADE; | |
| goto exit; | |
| } | |
| address &= 0x0000FFFF; /* remove base and keep offset */ | |
| ret = sdio_memcpy_toio(func2, address, data, size); | |
| if (ret) | |
| goto exit; | |
| ret = size; | |
| exit: | |
| return ret; | |
| } | |
| static int mm81x_sdio_mem_write_byte(struct mm81x_sdio *sdio, u32 address, | |
| u8 *data, ssize_t size) | |
| { | |
| int i, ret; | |
| struct sdio_func *func1 = sdio->func->card->sdio_func[0]; | |
| mm81x_sdio_set_func_address_base(sdio, func1, address, | |
| MM81X_CONFIG_ACCESS_1BYTE); | |
| address &= 0x0000FFFF; /* remove base and keep offset */ | |
| for (i = 0; i < size; i++) { | |
| sdio_writeb(func1, data[i], address + i, (int *)&ret); | |
| if (ret) | |
| goto exit; | |
| } | |
| ret = size; | |
| exit: | |
| return ret; | |
| } | |
| static void mm81x_sdio_claim_host(struct mm81x *mors) | |
| { | |
| struct mm81x_sdio *sdio = (struct mm81x_sdio *)mors->drv_priv; | |
| struct sdio_func *func = sdio->func; | |
| sdio_claim_host(func); | |
| } | |
| static void mm81x_sdio_release_host(struct mm81x *mors) | |
| { | |
| struct mm81x_sdio *sdio = (struct mm81x_sdio *)mors->drv_priv; | |
| struct sdio_func *func = sdio->func; | |
| sdio_release_host(func); | |
| } | |
| static int mm81x_sdio_mem_read_block(struct mm81x_sdio *sdio, u32 address, | |
| u8 *data, ssize_t size) | |
| { | |
| int ret; | |
| struct sdio_func *func2 = sdio->func; | |
| struct mm81x *mors = sdio_get_drvdata(sdio->func); | |
| mm81x_sdio_set_func_address_base(sdio, func2, address, | |
| MM81X_CONFIG_ACCESS_4BYTE); | |
| if (unlikely(!IS_ALIGNED((uintptr_t)data, | |
| mors->bus_ops->bulk_alignment))) { | |
| ret = -EBADE; | |
| goto exit; | |
| } | |
| address &= 0x0000FFFF; /* remove base and keep offset */ | |
| ret = sdio_memcpy_fromio(func2, data, address, size); | |
| if (ret) | |
| goto exit; | |
| /* | |
| * Observed sometimes that SDIO read repeats the first 4-bytes | |
| * word twice, overwriting second word (hence, tail will be | |
| * overwritten with 'sync' byte). When this happens, reading | |
| * will fetch the correct word. NB: if repeated again, pass it | |
| * anyway and upper layers will handle it | |
| */ | |
| if (size >= 8 && memcmp(data, data + 4, 4) == 0) | |
| sdio_memcpy_fromio(func2, data, address, 8); | |
| ret = size; | |
| exit: | |
| return ret; | |
| } | |
| static int mm81x_sdio_mem_read_byte(struct mm81x_sdio *sdio, u32 address, | |
| u8 *data, ssize_t size) | |
| { | |
| int i, ret; | |
| struct sdio_func *func1 = sdio->func->card->sdio_func[0]; | |
| mm81x_sdio_set_func_address_base(sdio, func1, address, | |
| MM81X_CONFIG_ACCESS_1BYTE); | |
| address &= 0x0000FFFF; /* remove base and keep offset */ | |
| for (i = 0; i < size; i++) { | |
| data[i] = sdio_readb(func1, address + i, (int *)&ret); | |
| if (ret) | |
| goto exit; | |
| } | |
| ret = size; | |
| exit: | |
| return ret; | |
| } | |
| static int mm81x_sdio_dm_write(struct mm81x *mors, u32 address, const u8 *data, | |
| int len) | |
| { | |
| int ret = 0; | |
| int block_len, byte_len; | |
| struct mm81x_sdio *sdio = (struct mm81x_sdio *)mors->drv_priv; | |
| int remaining = len; | |
| int offset = 0; | |
| if (remaining > 0 && address & 0x3) { | |
| len = 4 - (address & 0x3); | |
| ret = mm81x_sdio_mem_write_byte(sdio, address, (u8 *)data, len); | |
| if (ret != len) | |
| return -EIO; | |
| offset += len; | |
| remaining -= len; | |
| } | |
| while ((remaining) > 0) { | |
| /* | |
| * We can only write up to the end of a single window in | |
| * each write operation. | |
| */ | |
| u32 window_end = (address + offset) | | |
| ~MM81X_SDIO_RW_ADDR_BOUNDARY_MASK; | |
| len = min(remaining, (int)(window_end + 1 - address - offset)); | |
| block_len = len & ~0x3; | |
| byte_len = len & 0x3; | |
| if (block_len) { | |
| ret = mm81x_sdio_mem_write_block(sdio, address + offset, | |
| (u8 *)(data + offset), | |
| block_len); | |
| if (ret != block_len) | |
| return -EIO; | |
| offset += block_len; | |
| } | |
| if (byte_len) { | |
| ret = mm81x_sdio_mem_write_byte(sdio, address + offset, | |
| (u8 *)(data + offset), | |
| byte_len); | |
| if (ret != byte_len) | |
| return -EIO; | |
| offset += byte_len; | |
| } | |
| remaining -= len; | |
| } | |
| return 0; | |
| } | |
| static int mm81x_sdio_dm_read(struct mm81x *mors, u32 address, u8 *data, | |
| int len) | |
| { | |
| int ret = 0; | |
| int block_len, byte_len; | |
| struct mm81x_sdio *sdio = (struct mm81x_sdio *)mors->drv_priv; | |
| int remaining = len; | |
| int offset = 0; | |
| if (remaining > 0 && address & 0x3) { | |
| len = 4 - (address & 0x3); | |
| ret = mm81x_sdio_mem_read_byte(sdio, address, data, len); | |
| if (ret != len) | |
| return -EIO; | |
| offset += len; | |
| remaining -= len; | |
| } | |
| while (remaining > 0) { | |
| /* | |
| * We can only read up to the end of a single window in | |
| * each read operation. | |
| */ | |
| u32 window_end = (address + offset) | | |
| ~MM81X_SDIO_RW_ADDR_BOUNDARY_MASK; | |
| len = min(remaining, (int)(window_end + 1 - address - offset)); | |
| block_len = len & ~0x3; | |
| byte_len = len & 0x3; | |
| if (block_len) { | |
| ret = mm81x_sdio_mem_read_block(sdio, address + offset, | |
| data + offset, | |
| block_len); | |
| if (ret != block_len) | |
| return -EIO; | |
| offset += block_len; | |
| } | |
| if (byte_len) { | |
| ret = mm81x_sdio_mem_read_byte(sdio, address + offset, | |
| data + offset, byte_len); | |
| if (ret != byte_len) | |
| return -EIO; | |
| offset += byte_len; | |
| } | |
| remaining -= len; | |
| } | |
| return 0; | |
| } | |
| static int mm81x_sdio_reg32_write(struct mm81x *mors, u32 address, u32 val) | |
| { | |
| int ret = 0; | |
| u32 original_address = address; | |
| struct mm81x_sdio *sdio = (struct mm81x_sdio *)mors->drv_priv; | |
| struct sdio_func *func1 = sdio->func->card->sdio_func[0]; | |
| mm81x_sdio_set_func_address_base(sdio, func1, address, | |
| MM81X_CONFIG_ACCESS_4BYTE); | |
| address &= 0x0000FFFF; | |
| sdio_writel(func1, (__force u32)cpu_to_le32(val), | |
| (__force u32)cpu_to_le32(address), &ret); | |
| if (ret) | |
| goto error; | |
| return 0; | |
| error: | |
| if (original_address == MM81X_REG_RESET(mors) && | |
| val == MM81X_REG_RESET_VALUE(mors)) { | |
| dev_dbg(mors->dev, | |
| "SDIO reset detected, invalidating base addr\n"); | |
| mm81x_sdio_reset_base_address(sdio); | |
| } | |
| return -EIO; | |
| } | |
| static int mm81x_sdio_reg32_read(struct mm81x *mors, u32 address, u32 *val) | |
| { | |
| u32 value; | |
| int ret = 0; | |
| struct mm81x_sdio *sdio = (struct mm81x_sdio *)mors->drv_priv; | |
| struct sdio_func *func1 = sdio->func->card->sdio_func[0]; | |
| mm81x_sdio_set_func_address_base(sdio, func1, address, | |
| MM81X_CONFIG_ACCESS_4BYTE); | |
| address &= 0x0000FFFF; | |
| value = sdio_readl(func1, (__force u32)cpu_to_le32(address), &ret); | |
| if (ret) | |
| return ret; | |
| *val = le32_to_cpup((__le32 *)&value); | |
| return 0; | |
| } | |
| static void mm81x_sdio_bus_enable(struct mm81x *mors, bool enable) | |
| { | |
| struct mm81x_sdio *sdio = (struct mm81x_sdio *)mors->drv_priv; | |
| struct sdio_func *func = sdio->func; | |
| struct mmc_host *host = func->card->host; | |
| sdio_claim_host(func); | |
| if (enable) { | |
| /* | |
| * No need to do anything special to re-enable the sdio bus. | |
| * This will happen automatically when a read/write is | |
| * attempted and sdio->bulk_addr_base == 0. | |
| */ | |
| sdio->enabled = true; | |
| host->ops->enable_sdio_irq(host, 1); | |
| dev_dbg(mors->dev, "%s: enabling bus\n", __func__); | |
| } else { | |
| host->ops->enable_sdio_irq(host, 0); | |
| mm81x_sdio_reset_base_address(sdio); | |
| sdio->enabled = false; | |
| dev_dbg(mors->dev, "%s: disabling bus\n", __func__); | |
| } | |
| sdio_release_host(func); | |
| } | |
| static void mm81x_sdio_reset(struct sdio_func *func) | |
| { | |
| sdio_claim_host(func); | |
| sdio_disable_func(func); | |
| sdio_release_host(func); | |
| mdelay(20); | |
| sdio_claim_host(func); | |
| sdio_disable_func(func); | |
| mmc_hw_reset(func->card); | |
| sdio_enable_func(func); | |
| sdio_release_host(func); | |
| } | |
| static void mm81x_sdio_config_burst_mode(struct mm81x *mors, bool enable_burst) | |
| { | |
| u8 burst_mode = (enable_burst) ? SDIO_WORD_BURST_SIZE_16 : | |
| SDIO_WORD_BURST_DISABLE; | |
| mm81x_hw_enable_burst_mode(mors, burst_mode); | |
| } | |
| static const struct mm81x_bus_ops mm81x_sdio_ops = { | |
| .dm_read = mm81x_sdio_dm_read, | |
| .dm_write = mm81x_sdio_dm_write, | |
| .reg32_read = mm81x_sdio_reg32_read, | |
| .reg32_write = mm81x_sdio_reg32_write, | |
| .set_bus_enable = mm81x_sdio_bus_enable, | |
| .claim = mm81x_sdio_claim_host, | |
| .release = mm81x_sdio_release_host, | |
| .config_burst_mode = mm81x_sdio_config_burst_mode, | |
| .set_irq = mm81x_sdio_set_irq, | |
| .bulk_alignment = MM81X_SDIO_ALIGNMENT | |
| }; | |
| static int mm81x_sdio_enable(struct mm81x_sdio *sdio) | |
| { | |
| int ret; | |
| struct sdio_func *func = sdio->func; | |
| struct mm81x *mors = sdio_get_drvdata(func); | |
| sdio_claim_host(func); | |
| ret = sdio_enable_func(func); | |
| if (ret) | |
| dev_err(mors->dev, "sdio_enable_func failed: %d\n", ret); | |
| sdio_release_host(func); | |
| return ret; | |
| } | |
| static void mm81x_sdio_release(struct mm81x_sdio *sdio) | |
| { | |
| struct sdio_func *func = sdio->func; | |
| sdio_claim_host(func); | |
| sdio_disable_func(func); | |
| sdio_release_host(func); | |
| } | |
| static int mm81x_sdio_probe(struct sdio_func *func, | |
| const struct sdio_device_id *id) | |
| { | |
| int ret = 0; | |
| struct mm81x *mors = NULL; | |
| struct mm81x_sdio *sdio; | |
| struct device *dev = &func->dev; | |
| if (func->num == 1) | |
| return 0; | |
| if (func->num != 2) | |
| return -ENODEV; | |
| mors = mm81x_core_alloc(sizeof(*sdio), dev); | |
| if (!mors) | |
| return -ENOMEM; | |
| mors->bus_ops = &mm81x_sdio_ops; | |
| mors->bus_type = MM81X_BUS_TYPE_SDIO; | |
| sdio = (struct mm81x_sdio *)mors->drv_priv; | |
| sdio->func = func; | |
| sdio->id = id; | |
| sdio->enabled = true; | |
| mm81x_sdio_reset_base_address(sdio); | |
| sdio_set_drvdata(func, mors); | |
| ret = mm81x_sdio_enable(sdio); | |
| if (ret) | |
| goto err_core_free; | |
| mm81x_sdio_config_burst_mode(mors, true); | |
| ret = mm81x_core_init(mors); | |
| if (ret) | |
| goto err_sdio_release; | |
| ret = mm81x_sdio_enable_irq(sdio); | |
| if (ret) | |
| goto err_core_deinit; | |
| ret = mm81x_core_register(mors); | |
| if (ret) | |
| goto err_disable_irq; | |
| return 0; | |
| err_disable_irq: | |
| mm81x_sdio_disable_irq(sdio); | |
| err_core_deinit: | |
| mm81x_core_deinit(mors); | |
| err_sdio_release: | |
| mm81x_sdio_release(sdio); | |
| err_core_free: | |
| mm81x_core_free(mors); | |
| return ret; | |
| } | |
| static void mm81x_sdio_remove(struct sdio_func *func) | |
| { | |
| struct mm81x *mors = sdio_get_drvdata(func); | |
| struct mm81x_sdio *sdio = (struct mm81x_sdio *)mors->drv_priv; | |
| if (!mors) | |
| return; | |
| mm81x_core_unregister(mors); | |
| mm81x_sdio_disable_irq(sdio); | |
| mm81x_core_deinit(mors); | |
| mm81x_sdio_release(sdio); | |
| mm81x_sdio_reset(func); | |
| mm81x_core_free(mors); | |
| sdio_set_drvdata(func, NULL); | |
| } | |
| static const struct sdio_device_id mm81x_sdio_devices[] = { | |
| { SDIO_DEVICE(SDIO_VENDOR_ID_MORSEMICRO, | |
| SDIO_DEVICE_ID_MORSEMICRO_MM8108) }, | |
| {}, | |
| }; | |
| MODULE_DEVICE_TABLE(sdio, mm81x_sdio_devices); | |
| static struct sdio_driver mm81x_sdio_driver = { | |
| .name = "mm81x_sdio", | |
| .id_table = mm81x_sdio_devices, | |
| .probe = mm81x_sdio_probe, | |
| .remove = mm81x_sdio_remove, | |
| }; | |
| module_sdio_driver(mm81x_sdio_driver); | |
| MODULE_AUTHOR("Morse Micro"); | |
| MODULE_DESCRIPTION("Driver support for Morse Micro MM81X SDIO devices"); | |
| MODULE_LICENSE("Dual BSD/GPL"); |