From patchwork Wed Dec 23 15:39:09 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?b?SsOpcsO0bWUgUG91aWxsZXI=?= X-Patchwork-Id: 352199 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.7 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID, HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_CR_TRAILER, INCLUDES_PATCH, MAILING_LIST_MULTI, MSGID_FROM_MTA_HEADER, SPF_HELO_NONE, SPF_PASS, URIBL_BLOCKED, USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 7B18BC433E9 for ; Wed, 23 Dec 2020 15:45:32 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 61B322074A for ; Wed, 23 Dec 2020 15:45:32 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728633AbgLWPlC (ORCPT ); Wed, 23 Dec 2020 10:41:02 -0500 Received: from mail-bn8nam08on2089.outbound.protection.outlook.com ([40.107.100.89]:24001 "EHLO NAM04-BN8-obe.outbound.protection.outlook.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1727923AbgLWPlB (ORCPT ); Wed, 23 Dec 2020 10:41:01 -0500 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=d87Rh2Nu+kFW44bRGRXrov16iAkXR1EwOyLUDm/9ecXWPhTPR6M6VDQTeqI5tgClxakmrzQDL5IMSVqxgu6pfRrNINfI5M3RSWot8lJxT3DpA/ejZo/BpQMHdYXVTNgNJsoQqF8rvQffOJk5xnIa0RDtXJKYFP4UBO5gY0KoXMRzL1VLnztixCfnusIMMYhKSMCRk5Ds/ZCrgDweJN68zNy0kRV14zfEjk5o+HYTOU0MuiDws2op1p7FxgsfmO1TWcdY3duX7NPnMDdTR5Hj/S14npn0lcEwrQz1zNYrEGGPt/Hkd99dXbTD6uA+Sf6AoRpLoKD9O8TvN7MsnSN0tQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=vCqXGUxMRk5myw5s1WtOu8LLWAybc/TZwZqRQ4tRNxw=; b=W1XZYqKHhhErw50ay0YFvZ1t9nNW/ove2ZqQHDudwTPQfxpMRFAy13YaXQvU7ruwb9E8AaXsa/k7/LNWdJkcEKG1BroNBeTyK+POfCyOBxCq28z3KCl9P4l5vWL2ZSyPTfW33+wuz811ul7d00PdxqvIHaxiM2NtsEiGVGZbHQsXlzru7x9JQEq7GqlkulrkxBetFkxjqbrpc4rWH7/Q45e9L91U+eyG2XZ3QtscBjv118800PfvMiPhC1mRvATmQ6DxRM/1vIVwvG7ANzsbqJO+G86EK3Nb8VUYZr+gmA7jew3cVylADrGIXy2gLuKNhle9n/0gHHzMpHWakbnNDA== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=silabs.com; dmarc=pass action=none header.from=silabs.com; dkim=pass header.d=silabs.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=silabs.onmicrosoft.com; s=selector2-silabs-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=vCqXGUxMRk5myw5s1WtOu8LLWAybc/TZwZqRQ4tRNxw=; b=MpkBXRHhlh31hosVrSjUw7hNhqu3lWPXko/ehhH5S5DEwpndJyMWFAIe5QNF/p+ZALXbUevlVuh7oaV74jPkoxqZUebrklX6ZE++yForSP6WWeX2W/72nr8q6oG5YkKYA9tV3AM6s3VOs+oTBE3e1sgfOm3W6khMOCY9EMICeAQ= Authentication-Results: vger.kernel.org; dkim=none (message not signed) header.d=none; vger.kernel.org; dmarc=none action=none header.from=silabs.com; Received: from SN6PR11MB2718.namprd11.prod.outlook.com (2603:10b6:805:63::18) by SA0PR11MB4543.namprd11.prod.outlook.com (2603:10b6:806:99::13) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.3676.29; Wed, 23 Dec 2020 15:40:01 +0000 Received: from SN6PR11MB2718.namprd11.prod.outlook.com ([fe80::a989:f850:6736:97ca]) by SN6PR11MB2718.namprd11.prod.outlook.com ([fe80::a989:f850:6736:97ca%5]) with mapi id 15.20.3700.026; Wed, 23 Dec 2020 15:40:01 +0000 From: Jerome Pouiller To: linux-wireless@vger.kernel.org, netdev@vger.kernel.org Cc: devel@driverdev.osuosl.org, linux-kernel@vger.kernel.org, Greg Kroah-Hartman , Kalle Valo , "David S . Miller" , devicetree@vger.kernel.org, Rob Herring , linux-mmc@vger.kernel.org, =?utf-8?q?Pali_Roh=C3=A1r?= , Ulf Hansson , =?utf-8?b?SsOpcsO0bWUg?= =?utf-8?q?Pouiller?= Subject: [PATCH v4 08/24] wfx: add bus_sdio.c Date: Wed, 23 Dec 2020 16:39:09 +0100 Message-Id: <20201223153925.73742-9-Jerome.Pouiller@silabs.com> X-Mailer: git-send-email 2.29.2 In-Reply-To: <20201223153925.73742-1-Jerome.Pouiller@silabs.com> References: <20201223153925.73742-1-Jerome.Pouiller@silabs.com> X-Originating-IP: [82.67.86.106] X-ClientProxiedBy: SA0PR12CA0024.namprd12.prod.outlook.com (2603:10b6:806:6f::29) To SN6PR11MB2718.namprd11.prod.outlook.com (2603:10b6:805:63::18) MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 Received: from pc-42.silabs.com (82.67.86.106) by SA0PR12CA0024.namprd12.prod.outlook.com (2603:10b6:806:6f::29) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.3700.27 via Frontend Transport; Wed, 23 Dec 2020 15:39:59 +0000 X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 9df904fb-0f8f-43f4-676b-08d8a75902a2 X-MS-TrafficTypeDiagnostic: SA0PR11MB4543: X-MS-Exchange-Transport-Forked: True X-Microsoft-Antispam-PRVS: X-MS-Oob-TLC-OOBClassifiers: OLM:3968; X-MS-Exchange-SenderADCheck: 1 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: CpwdmEeGfap17LTZMfQ1ebWgfO1y/emZlloC0Ys5NEc2K6sM2QtUl0CzHxyWw9dTcV3RHI6IMvOEROgxqusPDvxFsJvy7vOTqDxCb5ixjwxmaw6cDEhvY6hoOUFjoiUz4aLru/eW48q6w6WwBuvcDxNeaY0ZeHeISigKaMeEvHLMC0r2+iRyyR+fkemeV0ayy0Zo70dba6ssYxkhxGcZ8Szvksvz5sINDtzw2Hir0a+0nFhByY5cKmHw6fonOz8ZzWDWaSABGGtpql0cpUola8UCQDjSmnhI/OXp+8tcosrp7Vdm0Y1RqNPO+Van2gpUKw6wGAGxupBe1/67syiAMb5y39vrEavnGpU4iPHH50UxjLkdNkN02CmbMIt8w44ZpwrbpBlZNff1aG9FAW625Q== X-Forefront-Antispam-Report: CIP:255.255.255.255; CTRY:; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:SN6PR11MB2718.namprd11.prod.outlook.com; PTR:; CAT:NONE; SFS:(136003)(376002)(366004)(346002)(396003)(39850400004)(5660300002)(956004)(2616005)(66476007)(66556008)(86362001)(36756003)(107886003)(66574015)(66946007)(6486002)(4326008)(83380400001)(6666004)(8676002)(186003)(52116002)(16526019)(7416002)(478600001)(26005)(1076003)(316002)(7696005)(54906003)(8936002)(2906002); DIR:OUT; SFP:1101; X-MS-Exchange-AntiSpam-MessageData: =?utf-8?q?0SeyFhTHI5u9NjwZIaOGngCIFKc?= =?utf-8?q?kiaY+Bt0XsyW3+us6+pk7UGBeUN0w/X0F+/w9PXXNuGdntlvwOv+3jZh?= =?utf-8?q?uST9kCi/Kzk1w+XaJ58p7vqLlEwqgOdh/6qRDetj7F5FPzV1F5Jx6AK+?= =?utf-8?q?O13ksbkX8gpmnSxWJq+A/loRpL0mcmcBt7CqmSVx4ldJrhdrKRDYkr+x?= =?utf-8?q?R4e8r4sYsu1VGbcIngv+ZpYTHdItn4Ww+dYdOGGwELEhvBRYQgACYKjT?= =?utf-8?q?XVVcl14FMiDoUNLLC+aLp5WwrwM5/I/0ZrQIKEuLZso8ZiVQxKybwtHW?= =?utf-8?q?rFe59E9pVrHS5HEL/z2cL061xEs9KTEoAdt1ACAU3Nj7I3jyFGbHPQm7?= =?utf-8?q?+OPUEVhp98VqbzZjZ00rCC5IAzg7u+4vTqwv89Ppmk8TuwcDVQG7bTfL?= =?utf-8?q?Z/Qtief3+F6StMEPhoUtw89sEnvu/njhX7M81mExksr2Z/dZt85BKMvR?= =?utf-8?q?vJ/2Qh5NjuJ8lANI+gsgvUivcSvcAiDIm0a80WrA8NpziQK5359TkoEY?= =?utf-8?q?1ZspKBWycZnEXwWwcuxlltQQSnEp343FxKzhKJe8LHZo/guSsaJd7hw1?= =?utf-8?q?vIsml5+Nb3J0583khCTFd5kt0MYJFmS/7/1oWXsHCWI7xLLx53b+Ste3?= =?utf-8?q?9Zl8RdmV1wduMvDsRIBFDIDvkWVpC5NTwqGj0nnzmX6JqN7yiVa3kD+f?= =?utf-8?q?ByGa0tHlswEGgO+zkYl/YuxS73BiTtWbBq5Xq9pr+/zUkwT8nfCmo3fY?= =?utf-8?q?HDP4EaMmyCwha8ersBCYNOUChNfB4ql8invsttkaUjiTlOGgJDZ90Bmp?= =?utf-8?q?+mJSeKJLdwFGJ6W6vkKm//WJ+ljGFRzG6E9PadQ96GTur/a8a+/WdvvQ?= =?utf-8?q?aEDNwGgOB/oshT1R3pDeXpdEWIRsAfFFmYyr1F2FRypOGhbyYAOo05te?= =?utf-8?q?AX6MGaqpsV8+VziAlPpOgxt9a9rUSGWJ+kGZwdjhbjUy8Tw5nK9GWF13?= =?utf-8?q?BiTXQY066tzbkQbAI2w4/GAvMXGYEP+wBkRqOWSApssPj?= X-OriginatorOrg: silabs.com X-MS-Exchange-CrossTenant-AuthSource: SN6PR11MB2718.namprd11.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 23 Dec 2020 15:40:01.0321 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 54dbd822-5231-4b20-944d-6f4abcd541fb X-MS-Exchange-CrossTenant-Network-Message-Id: 9df904fb-0f8f-43f4-676b-08d8a75902a2 X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: 2qPJteYZDXaJ4cBROM0ojv5DXbyUTAdzjlh6qznNtdQcumQn8P8n1AFE1lidCAciJFduXWk99bGA26rpxlT/HQ== X-MS-Exchange-Transport-CrossTenantHeadersStamped: SA0PR11MB4543 Precedence: bulk List-ID: X-Mailing-List: linux-wireless@vger.kernel.org From: Jérôme Pouiller Signed-off-by: Jérôme Pouiller --- drivers/net/wireless/silabs/wfx/bus_sdio.c | 258 +++++++++++++++++++++ 1 file changed, 258 insertions(+) create mode 100644 drivers/net/wireless/silabs/wfx/bus_sdio.c diff --git a/drivers/net/wireless/silabs/wfx/bus_sdio.c b/drivers/net/wireless/silabs/wfx/bus_sdio.c new file mode 100644 index 000000000000..2f6488e36e86 --- /dev/null +++ b/drivers/net/wireless/silabs/wfx/bus_sdio.c @@ -0,0 +1,258 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * SDIO interface. + * + * Copyright (c) 2017-2020, Silicon Laboratories, Inc. + * Copyright (c) 2010, ST-Ericsson + */ +#include +#include +#include +#include +#include +#include +#include + +#include "bus.h" +#include "wfx.h" +#include "hwio.h" +#include "main.h" +#include "bh.h" + +static const struct wfx_platform_data wfx_sdio_pdata = { + .file_fw = "wfm_wf200", + .file_pds = "wf200.pds", +}; + +struct wfx_sdio_priv { + struct sdio_func *func; + struct wfx_dev *core; + u8 buf_id_tx; + u8 buf_id_rx; + int of_irq; +}; + +static int wfx_sdio_copy_from_io(void *priv, unsigned int reg_id, + void *dst, size_t count) +{ + struct wfx_sdio_priv *bus = priv; + unsigned int sdio_addr = reg_id << 2; + int ret; + + WARN(reg_id > 7, "chip only has 7 registers"); + WARN(((uintptr_t)dst) & 3, "unaligned buffer size"); + WARN(count & 3, "unaligned buffer address"); + + /* Use queue mode buffers */ + if (reg_id == WFX_REG_IN_OUT_QUEUE) + sdio_addr |= (bus->buf_id_rx + 1) << 7; + ret = sdio_memcpy_fromio(bus->func, dst, sdio_addr, count); + if (!ret && reg_id == WFX_REG_IN_OUT_QUEUE) + bus->buf_id_rx = (bus->buf_id_rx + 1) % 4; + + return ret; +} + +static int wfx_sdio_copy_to_io(void *priv, unsigned int reg_id, + const void *src, size_t count) +{ + struct wfx_sdio_priv *bus = priv; + unsigned int sdio_addr = reg_id << 2; + int ret; + + WARN(reg_id > 7, "chip only has 7 registers"); + WARN(((uintptr_t)src) & 3, "unaligned buffer size"); + WARN(count & 3, "unaligned buffer address"); + + /* Use queue mode buffers */ + if (reg_id == WFX_REG_IN_OUT_QUEUE) + sdio_addr |= bus->buf_id_tx << 7; + /* FIXME: discards 'const' qualifier for src */ + ret = sdio_memcpy_toio(bus->func, sdio_addr, (void *)src, count); + if (!ret && reg_id == WFX_REG_IN_OUT_QUEUE) + bus->buf_id_tx = (bus->buf_id_tx + 1) % 32; + + return ret; +} + +static void wfx_sdio_lock(void *priv) +{ + struct wfx_sdio_priv *bus = priv; + + sdio_claim_host(bus->func); +} + +static void wfx_sdio_unlock(void *priv) +{ + struct wfx_sdio_priv *bus = priv; + + sdio_release_host(bus->func); +} + +static void wfx_sdio_irq_handler(struct sdio_func *func) +{ + struct wfx_sdio_priv *bus = sdio_get_drvdata(func); + + wfx_bh_request_rx(bus->core); +} + +static irqreturn_t wfx_sdio_irq_handler_ext(int irq, void *priv) +{ + struct wfx_sdio_priv *bus = priv; + + sdio_claim_host(bus->func); + wfx_bh_request_rx(bus->core); + sdio_release_host(bus->func); + return IRQ_HANDLED; +} + +static int wfx_sdio_irq_subscribe(void *priv) +{ + struct wfx_sdio_priv *bus = priv; + u32 flags; + int ret; + u8 cccr; + + if (!bus->of_irq) { + sdio_claim_host(bus->func); + ret = sdio_claim_irq(bus->func, wfx_sdio_irq_handler); + sdio_release_host(bus->func); + return ret; + } + + sdio_claim_host(bus->func); + cccr = sdio_f0_readb(bus->func, SDIO_CCCR_IENx, NULL); + cccr |= BIT(0); + cccr |= BIT(bus->func->num); + sdio_f0_writeb(bus->func, cccr, SDIO_CCCR_IENx, NULL); + sdio_release_host(bus->func); + flags = irq_get_trigger_type(bus->of_irq); + if (!flags) + flags = IRQF_TRIGGER_HIGH; + flags |= IRQF_ONESHOT; + return devm_request_threaded_irq(&bus->func->dev, bus->of_irq, NULL, + wfx_sdio_irq_handler_ext, flags, + "wfx", bus); +} + +static int wfx_sdio_irq_unsubscribe(void *priv) +{ + struct wfx_sdio_priv *bus = priv; + int ret; + + if (bus->of_irq) + devm_free_irq(&bus->func->dev, bus->of_irq, bus); + sdio_claim_host(bus->func); + ret = sdio_release_irq(bus->func); + sdio_release_host(bus->func); + return ret; +} + +static size_t wfx_sdio_align_size(void *priv, size_t size) +{ + struct wfx_sdio_priv *bus = priv; + + return sdio_align_size(bus->func, size); +} + +static const struct hwbus_ops wfx_sdio_hwbus_ops = { + .copy_from_io = wfx_sdio_copy_from_io, + .copy_to_io = wfx_sdio_copy_to_io, + .irq_subscribe = wfx_sdio_irq_subscribe, + .irq_unsubscribe = wfx_sdio_irq_unsubscribe, + .lock = wfx_sdio_lock, + .unlock = wfx_sdio_unlock, + .align_size = wfx_sdio_align_size, +}; + +static const struct of_device_id wfx_sdio_of_match[] = { + { .compatible = "silabs,wfx-sdio" }, + { .compatible = "silabs,wf200" }, + { }, +}; +MODULE_DEVICE_TABLE(of, wfx_sdio_of_match); + +static int wfx_sdio_probe(struct sdio_func *func, + const struct sdio_device_id *id) +{ + struct device_node *np = func->dev.of_node; + struct wfx_sdio_priv *bus; + int ret; + + if (func->num != 1) { + dev_err(&func->dev, "SDIO function number is %d while it should always be 1 (unsupported chip?)\n", + func->num); + return -ENODEV; + } + + bus = devm_kzalloc(&func->dev, sizeof(*bus), GFP_KERNEL); + if (!bus) + return -ENOMEM; + + if (!np || !of_match_node(wfx_sdio_of_match, np)) { + dev_warn(&func->dev, "no compatible device found in DT\n"); + return -ENODEV; + } + + bus->func = func; + bus->of_irq = irq_of_parse_and_map(np, 0); + sdio_set_drvdata(func, bus); + func->card->quirks |= MMC_QUIRK_LENIENT_FN0 | + MMC_QUIRK_BLKSZ_FOR_BYTE_MODE | + MMC_QUIRK_BROKEN_BYTE_MODE_512; + + sdio_claim_host(func); + ret = sdio_enable_func(func); + /* Block of 64 bytes is more efficient than 512B for frame sizes < 4k */ + sdio_set_block_size(func, 64); + sdio_release_host(func); + if (ret) + goto err0; + + bus->core = wfx_init_common(&func->dev, &wfx_sdio_pdata, + &wfx_sdio_hwbus_ops, bus); + if (!bus->core) { + ret = -EIO; + goto err1; + } + + ret = wfx_probe(bus->core); + if (ret) + goto err1; + + return 0; + +err1: + sdio_claim_host(func); + sdio_disable_func(func); + sdio_release_host(func); +err0: + return ret; +} + +static void wfx_sdio_remove(struct sdio_func *func) +{ + struct wfx_sdio_priv *bus = sdio_get_drvdata(func); + + wfx_release(bus->core); + sdio_claim_host(func); + sdio_disable_func(func); + sdio_release_host(func); +} + +static const struct sdio_device_id wfx_sdio_ids[] = { + { SDIO_DEVICE(SDIO_VENDOR_ID_SILABS, SDIO_DEVICE_ID_SILABS_WF200) }, + { }, +}; +MODULE_DEVICE_TABLE(sdio, wfx_sdio_ids); + +struct sdio_driver wfx_sdio_driver = { + .name = "wfx-sdio", + .id_table = wfx_sdio_ids, + .probe = wfx_sdio_probe, + .remove = wfx_sdio_remove, + .drv = { + .owner = THIS_MODULE, + .of_match_table = wfx_sdio_of_match, + } +};