1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (c) 2012 - 2018 Microchip Technology Inc., and its subsidiaries.
8 #include <linux/mmc/sdio_func.h>
9 #include <linux/mmc/sdio_ids.h>
10 #include <linux/mmc/host.h>
11 #include <linux/mmc/sdio.h>
12 #include <linux/of_irq.h>
17 #define SDIO_MODALIAS "wilc1000_sdio"
19 static const struct sdio_device_id wilc_sdio_ids[] = {
20 { SDIO_DEVICE(SDIO_VENDOR_ID_MICROCHIP_WILC, SDIO_DEVICE_ID_MICROCHIP_WILC1000) },
24 #define WILC_SDIO_BLOCK_SIZE 512
51 static const struct wilc_hif_func wilc_hif_sdio;
53 static void wilc_sdio_interrupt(struct sdio_func *func)
55 sdio_release_host(func);
56 wilc_handle_isr(sdio_get_drvdata(func));
57 sdio_claim_host(func);
60 static int wilc_sdio_cmd52(struct wilc *wilc, struct sdio_cmd52 *cmd)
62 struct sdio_func *func = container_of(wilc->dev, struct sdio_func, dev);
66 sdio_claim_host(func);
68 func->num = cmd->function;
69 if (cmd->read_write) { /* write */
71 sdio_writeb(func, cmd->data, cmd->address, &ret);
72 data = sdio_readb(func, cmd->address, &ret);
75 sdio_writeb(func, cmd->data, cmd->address, &ret);
78 data = sdio_readb(func, cmd->address, &ret);
82 sdio_release_host(func);
85 dev_err(&func->dev, "%s..failed, err(%d)\n", __func__, ret);
89 static int wilc_sdio_cmd53(struct wilc *wilc, struct sdio_cmd53 *cmd)
91 struct sdio_func *func = container_of(wilc->dev, struct sdio_func, dev);
94 sdio_claim_host(func);
96 func->num = cmd->function;
97 func->cur_blksize = cmd->block_size;
99 size = cmd->count * cmd->block_size;
103 if (cmd->read_write) { /* write */
104 ret = sdio_memcpy_toio(func, cmd->address,
105 (void *)cmd->buffer, size);
107 ret = sdio_memcpy_fromio(func, (void *)cmd->buffer,
111 sdio_release_host(func);
114 dev_err(&func->dev, "%s..failed, err(%d)\n", __func__, ret);
119 static int wilc_sdio_probe(struct sdio_func *func,
120 const struct sdio_device_id *id)
124 struct wilc_sdio *sdio_priv;
126 sdio_priv = kzalloc(sizeof(*sdio_priv), GFP_KERNEL);
130 ret = wilc_cfg80211_init(&wilc, &func->dev, WILC_HIF_SDIO,
135 if (IS_ENABLED(CONFIG_WILC1000_HW_OOB_INTR)) {
136 struct device_node *np = func->card->dev.of_node;
137 int irq_num = of_irq_get(np, 0);
140 wilc->dev_irq_num = irq_num;
141 sdio_priv->irq_gpio = true;
145 sdio_set_drvdata(func, wilc);
146 wilc->bus_data = sdio_priv;
147 wilc->dev = &func->dev;
149 wilc->rtc_clk = devm_clk_get_optional(&func->card->dev, "rtc");
150 if (IS_ERR(wilc->rtc_clk)) {
151 ret = PTR_ERR(wilc->rtc_clk);
154 clk_prepare_enable(wilc->rtc_clk);
156 dev_info(&func->dev, "Driver Initializing success\n");
160 irq_dispose_mapping(wilc->dev_irq_num);
161 wilc_netdev_cleanup(wilc);
167 static void wilc_sdio_remove(struct sdio_func *func)
169 struct wilc *wilc = sdio_get_drvdata(func);
170 struct wilc_sdio *sdio_priv = wilc->bus_data;
172 clk_disable_unprepare(wilc->rtc_clk);
173 wilc_netdev_cleanup(wilc);
177 static int wilc_sdio_reset(struct wilc *wilc)
179 struct sdio_cmd52 cmd;
181 struct sdio_func *func = dev_to_sdio_func(wilc->dev);
186 cmd.address = SDIO_CCCR_ABORT;
187 cmd.data = WILC_SDIO_CCCR_ABORT_RESET;
188 ret = wilc_sdio_cmd52(wilc, &cmd);
190 dev_err(&func->dev, "Fail cmd 52, reset cmd ...\n");
196 static int wilc_sdio_suspend(struct device *dev)
198 struct sdio_func *func = dev_to_sdio_func(dev);
199 struct wilc *wilc = sdio_get_drvdata(func);
202 dev_info(dev, "sdio suspend\n");
205 if (!IS_ERR(wilc->rtc_clk))
206 clk_disable_unprepare(wilc->rtc_clk);
208 if (wilc->suspend_event) {
209 host_sleep_notify(wilc);
210 chip_allow_sleep(wilc);
213 ret = wilc_sdio_reset(wilc);
215 dev_err(&func->dev, "Fail reset sdio\n");
218 sdio_claim_host(func);
223 static int wilc_sdio_enable_interrupt(struct wilc *dev)
225 struct sdio_func *func = container_of(dev->dev, struct sdio_func, dev);
228 sdio_claim_host(func);
229 ret = sdio_claim_irq(func, wilc_sdio_interrupt);
230 sdio_release_host(func);
233 dev_err(&func->dev, "can't claim sdio_irq, err(%d)\n", ret);
239 static void wilc_sdio_disable_interrupt(struct wilc *dev)
241 struct sdio_func *func = container_of(dev->dev, struct sdio_func, dev);
244 sdio_claim_host(func);
245 ret = sdio_release_irq(func);
247 dev_err(&func->dev, "can't release sdio_irq, err(%d)\n", ret);
248 sdio_release_host(func);
251 /********************************************
255 ********************************************/
257 static int wilc_sdio_set_func0_csa_address(struct wilc *wilc, u32 adr)
259 struct sdio_func *func = dev_to_sdio_func(wilc->dev);
260 struct sdio_cmd52 cmd;
269 cmd.address = WILC_SDIO_FBR_CSA_REG;
271 ret = wilc_sdio_cmd52(wilc, &cmd);
273 dev_err(&func->dev, "Failed cmd52, set %04x data...\n",
278 cmd.address = WILC_SDIO_FBR_CSA_REG + 1;
279 cmd.data = (u8)(adr >> 8);
280 ret = wilc_sdio_cmd52(wilc, &cmd);
282 dev_err(&func->dev, "Failed cmd52, set %04x data...\n",
287 cmd.address = WILC_SDIO_FBR_CSA_REG + 2;
288 cmd.data = (u8)(adr >> 16);
289 ret = wilc_sdio_cmd52(wilc, &cmd);
291 dev_err(&func->dev, "Failed cmd52, set %04x data...\n",
299 static int wilc_sdio_set_block_size(struct wilc *wilc, u8 func_num,
302 struct sdio_func *func = dev_to_sdio_func(wilc->dev);
303 struct sdio_cmd52 cmd;
309 cmd.address = SDIO_FBR_BASE(func_num) + SDIO_CCCR_BLKSIZE;
310 cmd.data = (u8)block_size;
311 ret = wilc_sdio_cmd52(wilc, &cmd);
313 dev_err(&func->dev, "Failed cmd52, set %04x data...\n",
318 cmd.address = SDIO_FBR_BASE(func_num) + SDIO_CCCR_BLKSIZE + 1;
319 cmd.data = (u8)(block_size >> 8);
320 ret = wilc_sdio_cmd52(wilc, &cmd);
322 dev_err(&func->dev, "Failed cmd52, set %04x data...\n",
330 /********************************************
334 ********************************************/
335 static int wilc_sdio_write_reg(struct wilc *wilc, u32 addr, u32 data)
337 struct sdio_func *func = dev_to_sdio_func(wilc->dev);
338 struct wilc_sdio *sdio_priv = wilc->bus_data;
343 if (addr >= 0xf0 && addr <= 0xff) { /* only vendor specific registers */
344 struct sdio_cmd52 cmd;
351 ret = wilc_sdio_cmd52(wilc, &cmd);
354 "Failed cmd 52, read reg (%08x) ...\n", addr);
356 struct sdio_cmd53 cmd;
359 * set the AHB address
361 ret = wilc_sdio_set_func0_csa_address(wilc, addr);
367 cmd.address = WILC_SDIO_FBR_DATA_REG;
371 cmd.buffer = (u8 *)&data;
372 cmd.block_size = sdio_priv->block_size;
373 ret = wilc_sdio_cmd53(wilc, &cmd);
376 "Failed cmd53, write reg (%08x)...\n", addr);
382 static int wilc_sdio_write(struct wilc *wilc, u32 addr, u8 *buf, u32 size)
384 struct sdio_func *func = dev_to_sdio_func(wilc->dev);
385 struct wilc_sdio *sdio_priv = wilc->bus_data;
386 u32 block_size = sdio_priv->block_size;
387 struct sdio_cmd53 cmd;
388 int nblk, nleft, ret;
396 cmd.address = WILC_SDIO_FBR_DATA_REG;
402 cmd.address = WILC_SDIO_F1_DATA_REG;
405 size = ALIGN(size, 4);
406 nblk = size / block_size;
407 nleft = size % block_size;
414 cmd.block_size = block_size;
416 ret = wilc_sdio_set_func0_csa_address(wilc, addr);
420 ret = wilc_sdio_cmd53(wilc, &cmd);
423 "Failed cmd53 [%x], block send...\n", addr);
427 addr += nblk * block_size;
428 buf += nblk * block_size;
437 cmd.block_size = block_size;
440 ret = wilc_sdio_set_func0_csa_address(wilc, addr);
444 ret = wilc_sdio_cmd53(wilc, &cmd);
447 "Failed cmd53 [%x], bytes send...\n", addr);
455 static int wilc_sdio_read_reg(struct wilc *wilc, u32 addr, u32 *data)
457 struct sdio_func *func = dev_to_sdio_func(wilc->dev);
458 struct wilc_sdio *sdio_priv = wilc->bus_data;
461 if (addr >= 0xf0 && addr <= 0xff) { /* only vendor specific registers */
462 struct sdio_cmd52 cmd;
468 ret = wilc_sdio_cmd52(wilc, &cmd);
471 "Failed cmd 52, read reg (%08x) ...\n", addr);
476 struct sdio_cmd53 cmd;
478 ret = wilc_sdio_set_func0_csa_address(wilc, addr);
484 cmd.address = WILC_SDIO_FBR_DATA_REG;
488 cmd.buffer = (u8 *)data;
490 cmd.block_size = sdio_priv->block_size;
491 ret = wilc_sdio_cmd53(wilc, &cmd);
494 "Failed cmd53, read reg (%08x)...\n", addr);
503 static int wilc_sdio_read(struct wilc *wilc, u32 addr, u8 *buf, u32 size)
505 struct sdio_func *func = dev_to_sdio_func(wilc->dev);
506 struct wilc_sdio *sdio_priv = wilc->bus_data;
507 u32 block_size = sdio_priv->block_size;
508 struct sdio_cmd53 cmd;
509 int nblk, nleft, ret;
517 cmd.address = WILC_SDIO_FBR_DATA_REG;
523 cmd.address = WILC_SDIO_F1_DATA_REG;
526 size = ALIGN(size, 4);
527 nblk = size / block_size;
528 nleft = size % block_size;
535 cmd.block_size = block_size;
537 ret = wilc_sdio_set_func0_csa_address(wilc, addr);
541 ret = wilc_sdio_cmd53(wilc, &cmd);
544 "Failed cmd53 [%x], block read...\n", addr);
548 addr += nblk * block_size;
549 buf += nblk * block_size;
550 } /* if (nblk > 0) */
558 cmd.block_size = block_size;
561 ret = wilc_sdio_set_func0_csa_address(wilc, addr);
565 ret = wilc_sdio_cmd53(wilc, &cmd);
568 "Failed cmd53 [%x], bytes read...\n", addr);
576 /********************************************
580 ********************************************/
582 static int wilc_sdio_deinit(struct wilc *wilc)
587 static int wilc_sdio_init(struct wilc *wilc, bool resume)
589 struct sdio_func *func = dev_to_sdio_func(wilc->dev);
590 struct wilc_sdio *sdio_priv = wilc->bus_data;
591 struct sdio_cmd52 cmd;
596 * function 0 csa enable
601 cmd.address = SDIO_FBR_BASE(1);
602 cmd.data = SDIO_FBR_ENABLE_CSA;
603 ret = wilc_sdio_cmd52(wilc, &cmd);
605 dev_err(&func->dev, "Fail cmd 52, enable csa...\n");
610 * function 0 block size
612 ret = wilc_sdio_set_block_size(wilc, 0, WILC_SDIO_BLOCK_SIZE);
614 dev_err(&func->dev, "Fail cmd 52, set func 0 block size...\n");
617 sdio_priv->block_size = WILC_SDIO_BLOCK_SIZE;
625 cmd.address = SDIO_CCCR_IOEx;
626 cmd.data = WILC_SDIO_CCCR_IO_EN_FUNC1;
627 ret = wilc_sdio_cmd52(wilc, &cmd);
630 "Fail cmd 52, set IOE register...\n");
635 * make sure func 1 is up
640 cmd.address = SDIO_CCCR_IORx;
644 ret = wilc_sdio_cmd52(wilc, &cmd);
647 "Fail cmd 52, get IOR register...\n");
650 if (cmd.data == WILC_SDIO_CCCR_IO_EN_FUNC1)
655 dev_err(&func->dev, "Fail func 1 is not ready...\n");
660 * func 1 is ready, set func 1 block size
662 ret = wilc_sdio_set_block_size(wilc, 1, WILC_SDIO_BLOCK_SIZE);
664 dev_err(&func->dev, "Fail set func 1 block size...\n");
669 * func 1 interrupt enable
674 cmd.address = SDIO_CCCR_IENx;
675 cmd.data = WILC_SDIO_CCCR_IEN_MASTER | WILC_SDIO_CCCR_IEN_FUNC1;
676 ret = wilc_sdio_cmd52(wilc, &cmd);
678 dev_err(&func->dev, "Fail cmd 52, set IEN register...\n");
683 * make sure can read back chip id correctly
688 ret = wilc_sdio_read_reg(wilc, WILC_CHIPID, &chipid);
690 dev_err(&func->dev, "Fail cmd read chip id...\n");
693 dev_err(&func->dev, "chipid (%08x)\n", chipid);
694 rev = FIELD_GET(WILC_CHIP_REV_FIELD, chipid);
695 if (rev > FIELD_GET(WILC_CHIP_REV_FIELD, WILC_1000_BASE_ID_2A))
696 sdio_priv->has_thrpt_enh3 = 1;
698 sdio_priv->has_thrpt_enh3 = 0;
699 dev_info(&func->dev, "has_thrpt_enh3 = %d...\n",
700 sdio_priv->has_thrpt_enh3);
706 static int wilc_sdio_read_size(struct wilc *wilc, u32 *size)
709 struct sdio_cmd52 cmd;
712 * Read DMA count in words
717 cmd.address = WILC_SDIO_INTERRUPT_DATA_SZ_REG;
719 wilc_sdio_cmd52(wilc, &cmd);
722 cmd.address = WILC_SDIO_INTERRUPT_DATA_SZ_REG + 1;
724 wilc_sdio_cmd52(wilc, &cmd);
725 tmp |= (cmd.data << 8);
731 static int wilc_sdio_read_int(struct wilc *wilc, u32 *int_status)
733 struct sdio_func *func = dev_to_sdio_func(wilc->dev);
734 struct wilc_sdio *sdio_priv = wilc->bus_data;
737 struct sdio_cmd52 cmd;
739 wilc_sdio_read_size(wilc, &tmp);
744 if (!sdio_priv->irq_gpio) {
746 cmd.address = WILC_SDIO_EXT_IRQ_FLAG_REG;
749 cmd.address = WILC_SDIO_IRQ_FLAG_REG;
754 wilc_sdio_cmd52(wilc, &cmd);
755 irq_flags = cmd.data;
756 tmp |= FIELD_PREP(IRG_FLAGS_MASK, cmd.data);
758 if (FIELD_GET(UNHANDLED_IRQ_MASK, irq_flags))
759 dev_err(&func->dev, "Unexpected interrupt (1) int=%lx\n",
760 FIELD_GET(UNHANDLED_IRQ_MASK, irq_flags));
767 static int wilc_sdio_clear_int_ext(struct wilc *wilc, u32 val)
769 struct sdio_func *func = dev_to_sdio_func(wilc->dev);
770 struct wilc_sdio *sdio_priv = wilc->bus_data;
774 if (sdio_priv->has_thrpt_enh3) {
777 if (sdio_priv->irq_gpio)
778 reg = val & (BIT(MAX_NUM_INT) - 1);
780 /* select VMM table 0 */
781 if (val & SEL_VMM_TBL0)
783 /* select VMM table 1 */
784 if (val & SEL_VMM_TBL1)
790 struct sdio_cmd52 cmd;
795 cmd.address = WILC_SDIO_IRQ_CLEAR_FLAG_REG;
798 ret = wilc_sdio_cmd52(wilc, &cmd);
801 "Failed cmd52, set (%02x) data (%d) ...\n",
802 cmd.address, __LINE__);
808 if (sdio_priv->irq_gpio) {
809 /* has_thrpt_enh2 uses register 0xf8 to clear interrupts. */
811 * Cannot clear multiple interrupts.
812 * Must clear each interrupt individually.
817 flags = val & (BIT(MAX_NUM_INT) - 1);
818 for (i = 0; i < NUM_INT_EXT && flags; i++) {
819 if (flags & BIT(i)) {
820 struct sdio_cmd52 cmd;
825 cmd.address = WILC_SDIO_IRQ_CLEAR_FLAG_REG;
828 ret = wilc_sdio_cmd52(wilc, &cmd);
831 "Failed cmd52, set (%02x) data (%d) ...\n",
832 cmd.address, __LINE__);
839 for (i = NUM_INT_EXT; i < MAX_NUM_INT && flags; i++) {
840 if (flags & BIT(i)) {
842 "Unexpected interrupt cleared %d...\n",
850 /* select VMM table 0 */
851 if (val & SEL_VMM_TBL0)
853 /* select VMM table 1 */
854 if (val & SEL_VMM_TBL1)
861 struct sdio_cmd52 cmd;
866 cmd.address = WILC_SDIO_VMM_TBL_CTRL_REG;
868 ret = wilc_sdio_cmd52(wilc, &cmd);
871 "Failed cmd52, set (%02x) data (%d) ...\n",
872 cmd.address, __LINE__);
879 static int wilc_sdio_sync_ext(struct wilc *wilc, int nint)
881 struct sdio_func *func = dev_to_sdio_func(wilc->dev);
882 struct wilc_sdio *sdio_priv = wilc->bus_data;
885 if (nint > MAX_NUM_INT) {
886 dev_err(&func->dev, "Too many interrupts (%d)...\n", nint);
891 * Disable power sequencer
893 if (wilc_sdio_read_reg(wilc, WILC_MISC, ®)) {
894 dev_err(&func->dev, "Failed read misc reg...\n");
899 if (wilc_sdio_write_reg(wilc, WILC_MISC, reg)) {
900 dev_err(&func->dev, "Failed write misc reg...\n");
904 if (sdio_priv->irq_gpio) {
909 * interrupt pin mux select
911 ret = wilc_sdio_read_reg(wilc, WILC_PIN_MUX_0, ®);
913 dev_err(&func->dev, "Failed read reg (%08x)...\n",
918 ret = wilc_sdio_write_reg(wilc, WILC_PIN_MUX_0, reg);
920 dev_err(&func->dev, "Failed write reg (%08x)...\n",
928 ret = wilc_sdio_read_reg(wilc, WILC_INTR_ENABLE, ®);
930 dev_err(&func->dev, "Failed read reg (%08x)...\n",
935 for (i = 0; (i < 5) && (nint > 0); i++, nint--)
936 reg |= BIT((27 + i));
937 ret = wilc_sdio_write_reg(wilc, WILC_INTR_ENABLE, reg);
939 dev_err(&func->dev, "Failed write reg (%08x)...\n",
944 ret = wilc_sdio_read_reg(wilc, WILC_INTR2_ENABLE, ®);
947 "Failed read reg (%08x)...\n",
952 for (i = 0; (i < 3) && (nint > 0); i++, nint--)
955 ret = wilc_sdio_write_reg(wilc, WILC_INTR2_ENABLE, reg);
958 "Failed write reg (%08x)...\n",
967 /* Global sdio HIF function table */
968 static const struct wilc_hif_func wilc_hif_sdio = {
969 .hif_init = wilc_sdio_init,
970 .hif_deinit = wilc_sdio_deinit,
971 .hif_read_reg = wilc_sdio_read_reg,
972 .hif_write_reg = wilc_sdio_write_reg,
973 .hif_block_rx = wilc_sdio_read,
974 .hif_block_tx = wilc_sdio_write,
975 .hif_read_int = wilc_sdio_read_int,
976 .hif_clear_int_ext = wilc_sdio_clear_int_ext,
977 .hif_read_size = wilc_sdio_read_size,
978 .hif_block_tx_ext = wilc_sdio_write,
979 .hif_block_rx_ext = wilc_sdio_read,
980 .hif_sync_ext = wilc_sdio_sync_ext,
981 .enable_interrupt = wilc_sdio_enable_interrupt,
982 .disable_interrupt = wilc_sdio_disable_interrupt,
983 .hif_reset = wilc_sdio_reset,
986 static int wilc_sdio_resume(struct device *dev)
988 struct sdio_func *func = dev_to_sdio_func(dev);
989 struct wilc *wilc = sdio_get_drvdata(func);
991 dev_info(dev, "sdio resume\n");
992 sdio_release_host(func);
994 wilc_sdio_init(wilc, true);
996 if (wilc->suspend_event)
997 host_wakeup_notify(wilc);
999 chip_allow_sleep(wilc);
1004 static const struct of_device_id wilc_of_match[] = {
1005 { .compatible = "microchip,wilc1000", },
1008 MODULE_DEVICE_TABLE(of, wilc_of_match);
1010 static const struct dev_pm_ops wilc_sdio_pm_ops = {
1011 .suspend = wilc_sdio_suspend,
1012 .resume = wilc_sdio_resume,
1015 static struct sdio_driver wilc_sdio_driver = {
1016 .name = SDIO_MODALIAS,
1017 .id_table = wilc_sdio_ids,
1018 .probe = wilc_sdio_probe,
1019 .remove = wilc_sdio_remove,
1021 .pm = &wilc_sdio_pm_ops,
1022 .of_match_table = wilc_of_match,
1025 module_driver(wilc_sdio_driver,
1026 sdio_register_driver,
1027 sdio_unregister_driver);
1028 MODULE_LICENSE("GPL");