From nobody Mon Feb 9 14:32:40 2026 Received: from mx0b-0024c301.pphosted.com (mx0b-0024c301.pphosted.com [148.163.153.153]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id BE30C2BFC85 for ; Thu, 15 Jan 2026 16:01:33 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=fail smtp.client-ip=148.163.153.153 ARC-Seal: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1768492895; cv=fail; b=EawvByp2RFcZtB0wsM0TSjwt1MxOW/SNI9fpB2SHl2xSBt/Gg/ri+cSXelsooA+AS3TM6uRPg4DKn4Zx4ulD7qyfF7ZTzsehHcpAj0QjTYa6OX00oRf4WtZf4w4ZKQJqGngf7y/h5ibH8T47DYTVwXnV+SDkiFcUnUH02wabuVY= ARC-Message-Signature: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1768492895; c=relaxed/simple; bh=wJNsBnMY2qFM3n2LmOlnTYMZQf8ul/wywbrioDvDTjw=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: Content-Type:MIME-Version; b=p2v8OUKBMy+GBti3bNMCmeuSnHdn7Hpo9+Uixy3u5vRvMCsFu9qUEbALeq2MvoVYQxYKDMOHYCasOqBQvisKz3tzTghsqV9+RycmsSpQsPzGdz70VNfo3u5zmr2uit2i1eGaJhx3mSLVa/bWDw73x5pH65khxwg+I/DuNnbxKfE= ARC-Authentication-Results: i=2; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=silabs.com; spf=pass smtp.mailfrom=silabs.com; dkim=pass (2048-bit key) header.d=silabs.com header.i=@silabs.com header.b=AQ+TjHrd; dkim=pass (1024-bit key) header.d=silabs.com header.i=@silabs.com header.b=Ybs0oCcn; arc=fail smtp.client-ip=148.163.153.153 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=silabs.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=silabs.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=silabs.com header.i=@silabs.com header.b="AQ+TjHrd"; dkim=pass (1024-bit key) header.d=silabs.com header.i=@silabs.com header.b="Ybs0oCcn" Received: from pps.filterd (m0101742.ppops.net [127.0.0.1]) by mx0a-0024c301.pphosted.com (8.18.1.11/8.18.1.11) with ESMTP id 60FFlYo9459381; Thu, 15 Jan 2026 09:58:46 -0600 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=silabs.com; h=cc :content-transfer-encoding:content-type:date:from:in-reply-to :message-id:mime-version:references:subject:to; s=pps12202023; bh=wX4mgiKiMh5m9eVFFQe5fDFOFjkeKELAsuU9KpghTWc=; b=AQ+TjHrdiRjn TcIV3Klr53/ZVLJQhuPM7P2ohqc4rsSturCRqbQpAd2BaMfepHvmQcH3QGIYX3Ge 24XlLqG8IoGPSqdVH3E8euzfMLFzPdryzTPSJLnRleipzdWpfPo9PxWzbjr4rkt3 c3Uaj+vBU5tjAu0owS8paCV1HnczFnngPVmJrv6Z9mNx9y1eoSVBgOie2hMVQF3N xf1z8ltpaHF4cZ7VEuhW3/dGCikSqzFgIFHvRCrWG38Jr1Q3W78KWDTM+EE4rNyD vaRSr14m9w9bFiu+25brIOeplRIMusHSNb86e6wwzS6dzMadIHCDEpk9F1ZsylnR SQg29woEvg== Received: from cy7pr03cu001.outbound.protection.outlook.com (mail-westcentralusazon11020081.outbound.protection.outlook.com [40.93.198.81]) by mx0a-0024c301.pphosted.com (PPS) with ESMTPS id 4bq36kr0v2-3 (version=TLSv1.3 cipher=TLS_AES_256_GCM_SHA384 bits=256 verify=NOT); Thu, 15 Jan 2026 09:58:45 -0600 (CST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=none; b=AW7gepucfUqWuYtFjIDcLlkaQqIea0J8/WgCt4FiOnZDw6jp3PhH3THDzjT6xrRy0fDG5eFXoJMPGxQmldGydYQXWfJv+7Z9Q99D3xtdt7hQcrbcAV4ljsNdC8GCBkmGWoUHUfPlakbG4d5CLi5iRCp8QkNet2GwxVZr+GePqwoYl/A3hPmwSnT+Fkni3RxltwogeHZclBNrULzUhatqZ88Ov3RHMtXnBKG/B3Fq6orfmqb7xUZNqOkcDR2QuvEUwRnmMLuNDq0RKs9a1lhE0/PdEoT+fNsuFRL110KJGjHBxC4JLJ6AJBHy/7X9QithZh8RvUcVS7JCX3gSF/ITCg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector10001; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=wX4mgiKiMh5m9eVFFQe5fDFOFjkeKELAsuU9KpghTWc=; b=kl/MPPxj+5XdepbgpuhrSWtzlwFKul/mAbAfTy2OKm7aOenO4S+K4yaOjpbxHGd8CbFvxgGs7mXyDPySjQecWcGaHEGXdTnj1ET5DYDqkX7MwgJqsS1lGZPX4smt16XPfUVyjfQHpzdt7Zj7QixFWsOZuVDKUjCHyfbu482sGe6hW2YjmDTmCW5u7/bKvV8Z4EvJOxdS3f+fgI1Zp1jPNvJXRUAfNXL05RqQE0mkoh4iCvy8IMUkj49Gcvvo0mycUJoiwHoacQJQs/XEZJHJFsIpQp4EoUKtpEc5UkSwDc6XkSwpIOf/mCRfGw5N1ohn1b/3wIyKPnMjnrL5Lqq7sA== 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.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=wX4mgiKiMh5m9eVFFQe5fDFOFjkeKELAsuU9KpghTWc=; b=Ybs0oCcnykdvN7bfQoB6YVGfGupIxCJkSTRw6SMGPnNfl3WhqW/6s/MaHRQs3z7CiZAwTDSI3BM2qofw2jvBa5bfu2crDnjdyYSloTyuSy2S3jRu3UJNiM5DVe7YEZzd4q9jL+X4/W4JLFBnl3Fsnmy0UvIG+xdkIOLjRF2+st8= Received: from DS0PR11MB8205.namprd11.prod.outlook.com (2603:10b6:8:162::17) by SA2PR11MB5097.namprd11.prod.outlook.com (2603:10b6:806:11a::24) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.9499.7; Thu, 15 Jan 2026 15:58:44 +0000 Received: from DS0PR11MB8205.namprd11.prod.outlook.com ([fe80::2de6:bc88:2af7:3583]) by DS0PR11MB8205.namprd11.prod.outlook.com ([fe80::2de6:bc88:2af7:3583%3]) with mapi id 15.20.9520.005; Thu, 15 Jan 2026 15:58:42 +0000 From: =?UTF-8?q?Damien=20Ri=C3=A9gel?= To: greybus-dev@lists.linaro.org, Johan Hovold , Alex Elder , Greg Kroah-Hartman , linux-kernel@vger.kernel.org Cc: Silicon Labs Kernel Team , Gabriel Beaulieu , =?UTF-8?q?Damien=20Ri=C3=A9gel?= Subject: [PATCH v2 14/14] greybus: cpc: add CPC SDIO host driver Date: Thu, 15 Jan 2026 10:58:07 -0500 Message-ID: <20260115155808.36102-15-damien.riegel@silabs.com> X-Mailer: git-send-email 2.52.0 In-Reply-To: <20260115155808.36102-1-damien.riegel@silabs.com> References: <20260115155808.36102-1-damien.riegel@silabs.com> Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable X-ClientProxiedBy: YQZPR01CA0025.CANPRD01.PROD.OUTLOOK.COM (2603:10b6:c01:86::22) To DS0PR11MB8205.namprd11.prod.outlook.com (2603:10b6:8:162::17) Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: DS0PR11MB8205:EE_|SA2PR11MB5097:EE_ X-MS-Office365-Filtering-Correlation-Id: 628c3b90-ef4f-4244-591e-08de544ef4a2 X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0;ARA:13230040|1800799024|52116014|376014|366016|38350700014; X-Microsoft-Antispam-Message-Info: =?utf-8?B?UkZHWFlENDVobXBNbHptOFRoSWtNNlNzc2ZlTTZUdGJMTDF4NWpUd2h4ZWJt?= =?utf-8?B?c2ZodS9NZkk4NUFGSERMTFUzZ3YrdzMzbUdDc2hjaGtlRVNQZzJMNUlnOC9G?= =?utf-8?B?bmh2cmxDbU1KbUlTWG5zNFhGL0dpL0NlTEtZMUk3MG4zUzF1WlNiWWNKQnI5?= =?utf-8?B?anVLeUdhRmRCb2k0eFdGOG9FME5BelFVOWllUlpLSUxZSzkxcmxTaHBPRmtF?= =?utf-8?B?eHNzN1djcU5tR2p2NDVrTkxCanBPR0ZoZGxNK3A2aThlUmhjbnNyQ1lGanRK?= =?utf-8?B?cXNkMk00c3JLc25UaFBxQ210K00vSFU1WGZYSlVROWYrMHJnVVBHSjY2R1Fa?= =?utf-8?B?Y1VUaU82T3I1Ry9hMEVyeWl6Y2k2L0xIdVZDdHVkcmVlbmFoY1FDNFpVYUFz?= =?utf-8?B?NTh3Qlh0eE11TWc4QlBsTFpGcUR6WFREN3hldVhxRTQ4YW44RlpGd3dqa0c5?= =?utf-8?B?S1Jjak9EdEJmWnN5b1BrQUhmdjBvc08wc0hYRXRUUU44RzA2bUlieHI3NjZP?= =?utf-8?B?WnlMcm1SOTdYRVAwZElHVStBdXpnek1TSExSWHB2TVYrNHlnUVJJM1NBanNG?= =?utf-8?B?UG5VNi9pakh2Mk83R2tkeE0wOThpMWU1N3Y3VEVLQm5XUGt2RW05ZjJOT0FQ?= =?utf-8?B?UlFjbGtibmlWZEhnM2VlUU5KQWVySEJGeDFLZmxNQWVraStMRmlIVjBzYkJv?= =?utf-8?B?YWdZS1dBTVdBMS9tVUM2YUU3TjZvRjFSZEtwVmtvVGNadnFxbXZEVWs3bGNW?= =?utf-8?B?VWZ4YmpZK25yWkdrZjNBYndlN3g4aE5xMWlSWVVvejZWaEFZcWtTZXBQY1hp?= =?utf-8?B?alA4TXR5U3pwMmRyS1I2K2RrbVErWHhmNTJVaWxpQ2xGVENhQjNSQmovKzYv?= =?utf-8?B?OWdGMTJYb2pWVDBQWHJXSWMxM1FqcWxobkhTR0dsbkxaWmZoLzNqQVZvK2xL?= =?utf-8?B?MXlQcDBSUzNRL0IyWUJUT2M1cnhkVzlHTnFYcFlXUWEyZXJTS1RwbFUyWUtM?= =?utf-8?B?L0Y4WU5pa2FQdXBiMTNkTmNyZ1IrM1FGUUdQSDhDbW1FeWJremRzc1JraXE4?= =?utf-8?B?S29uNXlyeXVGdEhXSFlXM0NFUHE0VGs1c2hVRGIvWERCSDNGZmQ1VkpDV2Y0?= =?utf-8?B?c280b0NxSEx5UEZSVndPVTRsL2I3MWYzZTN2WlNZYUV6aFN3RUowY0FoVmhS?= =?utf-8?B?TTY5S0oxYlNsdWlsVEQrQTdpbUprQzZqTk80YWlGTktXakhTQW9McXo2czRj?= =?utf-8?B?cVlIYUlJcVFqeUljaEZ6aUtPRmRNYzNDcUVDMGpIbldmNGV2MXJacUVJSFpK?= =?utf-8?B?SFZSaWFqWmdodVlwakxySU1RMU9PNjhQaGUyTkRMNCsvMW1GL0MwVnAxQ09F?= =?utf-8?B?eENWOEtmWmkvK3dJSXNnMHo3Zkt5c0ZsVmk1SEhoYUMxQWphK1dvUkhCZ3d5?= =?utf-8?B?QlY4UDRhVklod0N4a2FFZzA5VmRqc0U1OFl0STF0RENPTC8zdjdBM2QzeWxn?= =?utf-8?B?TStBUjVzSVVUbU4vRkIrSEZZK1NMVXNJemFKaTB1SjkxVHFUa1dlOFN3V0w2?= =?utf-8?B?RTg3SU1RTVpkTG9hd3Q5WjZ6WmpOR01IOW11QjFnZjNIc1ZFcS9wWlNUZFlv?= =?utf-8?B?S3FUY0hjRTg1cnYya1ZrQUZ6QjNJaFFlblVhL1FzK0tCSi90MWE3eGRSdmFL?= =?utf-8?B?cnE0bWorckVGek5aM1FScVR6NENJZVZPcFoxaXBZelFaYVZrV0p5MnJyUHVu?= =?utf-8?B?REpXQTNKSnhwTXlKQ0hqV0p6Z0dGNGN2dkRLNkF0b2N1SjFpelBkc3ZaWllz?= =?utf-8?B?bXB6N2o5azF6Wjg5R0xBZUgramxnOWdtTFloQzdFd3JrYUlwazJzNi9OQnBr?= =?utf-8?B?WHh1UUtDUjRvM1l3UTArVmwvRk8vcHQ4MkpRYkE0T1I0SmV1eEdzMUoxSmxn?= =?utf-8?B?VDVwSEd3b2N2VFlLbjlNYjJxNmN4SGI0VlFQa0pNYzhYeHBHQ3NwNndJTVhM?= =?utf-8?B?Ykp5bWlDOUpFTDIxa2NFUTV4YmpUcDJHd2ZhRndSaTRXYWhEN05XMnR2K0VP?= =?utf-8?B?REoyK1lSVGpXNTdUTVdNY29tSWU0U2UvdHpEYk5BT1l6MkdNRlI1V2hBMmZU?= =?utf-8?B?VHBPOGxFY0tpQTYyUGFSNFdFemEwVWJHRlNpOGVscE0vTzhBMGVCK3lkOGNK?= =?utf-8?Q?JUjx2KmmEqLuOVGZhNuSK+4=3D?= X-Forefront-Antispam-Report: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:DS0PR11MB8205.namprd11.prod.outlook.com;PTR:;CAT:NONE;SFS:(13230040)(1800799024)(52116014)(376014)(366016)(38350700014);DIR:OUT;SFP:1102; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?utf-8?B?OENuTWpBWUhhcWZaLzRMWi8wRitFZlJPR2xOSFRJT0JXVSsvaXo5eG16ci9m?= =?utf-8?B?b3E2SEplU0hvbndQRldRL0JUSExtUzk5U0V1OWlDZnd4bEY2QmVsdWcxc3lw?= =?utf-8?B?OUZiaGpTdzZ0TFRYenBxeEhhWmlHTC95RXdId2hiMFU2TVVld043Z3BJMlBQ?= =?utf-8?B?N1Nqb0VPSVYxRXR2ZmN6cTVocW5rZzk4WFY3QW12UC90akY0NzZiZk1qZFRQ?= =?utf-8?B?ZW1vR0o4VWlzRzZTOFhaeldTQjM0cjRJTkpRQStCVDA3MTRGSXp2UWhNSWdV?= =?utf-8?B?cm9VZU5VT252MU1XQ3ZxZGxuZTh1Qjc0Vng0Zk5MaUtteThBdmd5aklOWFNW?= =?utf-8?B?dTYzalprWXZoNldrNWIvbUFEYU4wRXpzWDZYcVQ3d252WnpWeVVEOXNuTks5?= =?utf-8?B?N0d3NnRlc3F2alBpalMxUTlKY053SHJ6SlljcTZQN3A1UnI1ZlVmNXlMMXZj?= =?utf-8?B?UzQ4YVRWZGZJZzRsankvc0pLbDd5NXBObTlNMHkwdzNsc2JNT21nb2xUc2NE?= =?utf-8?B?NFppd3lEdkNibDhhZ0wwazFQZWM1b21WRFU3MURIMXRpaUJxZUZIaUxRc0Vt?= =?utf-8?B?eUdNaDQ2aUxQYnN1amVqYnUyVWpYVnMzM1lMZmI5amxGcGY4cW4vQmc1bWMr?= =?utf-8?B?VEhQUFA4UTNDcmFCbDRUc3FMbEIwM2lmRFVVcnBhbTc5eEdGVnAwZzNuU2p3?= =?utf-8?B?a25FLzRHVEpZb0hqUEMzMDFwa2ZYRDJYWmFsV21KWHlITUlObWRwVHJXb3Yx?= =?utf-8?B?RlRJckRLcDZxZ2pWblVhc2ZJSzd0bFZ1QmVIeWlTMGhYRk54NWR6Z2hNQ0tU?= =?utf-8?B?bjZ4dHF0RVp6enZiSVl4ZmNPVzNVcTV6ekdQRXZqV25XenRFMU1KZ3JIYitZ?= =?utf-8?B?cGVuZ01OeXRnQ2lGT0JQZmRPQ0xMYWFydGRRY3Q3RmRVbmU2OWdEdzVEMlA2?= =?utf-8?B?Q3lKQ1NIbEM5T0VkZ2ZaUXY3a1dMWi9URW1qV3JrK3NjRjJORitUVm9remhr?= =?utf-8?B?V29CTC9DVHZhb3ZxTU5SNUR5WVlRVkF3VDFIcTFiQXFmbUg5bmVRWDY4d0VX?= =?utf-8?B?dk1hVnQ0bFd2RkJTU01NWFVCZzREREJKcDh6OHNmT2IvOVV3NUZwSnA4VWhE?= =?utf-8?B?RzZDOWxrYlNDSzY5U0RDWnM3UXJyZWFCb3Q2RURxN3NUYnpXVlIzTlFhT3F5?= =?utf-8?B?Mjl6RkJwaUtEbHFaRDhYU3BZMXRBMTFucUZjSjhnd0t3bXhtWm1mL3NSc01k?= =?utf-8?B?NElRbVpURE1PZ1FlRHJKbFAxaXZlcWh0V0Z6S0ZtTTViWUdYUWQwVDMyWVdU?= =?utf-8?B?UTdmQ09lbFUzazh0KzQvaGhMOVFpdENUa3V6UTZqWUNZZDZpWi93ZkRSYUov?= =?utf-8?B?Wm5kSXRSK2M3VHB5VUNzZSs1a3Q2VDdWWGJOK3c5amFLZkpWVERSN25ZejNW?= =?utf-8?B?ODNvZFl4djJ6ckxaUVo1WEhqdU1wT0pXbXhwTDJlL2NBOXI0VjRSU3g5Q1BU?= =?utf-8?B?Ti91dCtGeDZmbzRJUkZSY0hCQ0FZdkZkcHR3d1hUSi9JN0RtaWFHd1BrRVkv?= =?utf-8?B?ZmFJa0lPZWdKVHpXbGp0TjUzM1FKNEVYamVOZkZDMGtZM0dWd1lNbks4blNp?= =?utf-8?B?UVdGMVNET3NMOW9KZXhLZUIxalVabDR3RkV0cXloWGRtZVV3YXYxWldZYUNl?= =?utf-8?B?Z01DaDRtMFl0czVhMERwZDJKaElDeDFqMjF3emZPZEhGMUdYdTRxNmZXTnpT?= =?utf-8?B?VVlCZkhOYVgzb2lmYTYzSHBycXE3YW9MVGlYNUJmMWNZaVN2T1AzelF0bUVD?= =?utf-8?B?cHVMZk9HMWxaeERsNkFoMDNWYVFBS0MyQ1R5cTM2cEM1N0RPSnhkcTQvcSt1?= =?utf-8?B?bFN3L29xYnZWTDFKYVV2MnRwd3pManVOWnVYSUJWT21qL1puZ2R1VUpuK2Ux?= =?utf-8?B?aWRsRGllUG02OUJLM0V5M3hPaHBSOXFzSEI3SmNva1lERUpBeDBqTEROdGhs?= =?utf-8?B?TUhKSU1NWm56THRyaWJ5eUhOSWs1S1lWQlVFQjlNMGJ1WHpjOVovMmpBUStt?= =?utf-8?B?U1AyNVB2MzRwd0c4cmV1VytaenJYVEtsS0gxNVdXUXp5K1FaMTh1YmVsYWYv?= =?utf-8?B?Z2NXU3hlcThPeUxrK0FLUytYc0hMVEpoNGkyYkhJTzFEVExCUXpyVnh3c0pp?= =?utf-8?B?T2VjRDhOdnpJTzVaYWUxcndHcklUQ2grcU9SVUhhaFUzRGR1Z0VONkFGUE5T?= =?utf-8?B?QURPZ0FZVmpOUHRZU2I2Zm80UUhKZGY0NjMrZlkxaEo0NXczaWpuVmltM2hM?= =?utf-8?B?a3ZiWE41SEg4U1lPc21JdVhESUVFaVpZTFEvZTkvQ0NJblVSSWI4dz09?= X-OriginatorOrg: silabs.com X-MS-Exchange-CrossTenant-Network-Message-Id: 628c3b90-ef4f-4244-591e-08de544ef4a2 X-MS-Exchange-CrossTenant-AuthSource: DS0PR11MB8205.namprd11.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 15 Jan 2026 15:58:42.3502 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 54dbd822-5231-4b20-944d-6f4abcd541fb X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: 9WGADgeyrpKhPw1rcnTk3YKw7Bh7u3LtB4N1USmoA0l6PaKegHFH387sYf4c9oBYI3x64tPzjeouSL4jVc9sdw== X-MS-Exchange-Transport-CrossTenantHeadersStamped: SA2PR11MB5097 X-Proofpoint-GUID: HyLPZ0z9jvgJGZQEhwqievnbFdzXh1v_ X-Authority-Analysis: v=2.4 cv=M6BA6iws c=1 sm=1 tr=0 ts=69690eb6 cx=c_pps a=vcV0SyA3r3yo/t37AMr7eA==:117 a=6eWqkTHjU83fiwn7nKZWdM+Sl24=:19 a=z/mQ4Ysz8XfWz/Q5cLBRGdckG28=:19 a=lCpzRmAYbLLaTzLvsPZ7Mbvzbb8=:19 a=xqWC_Br6kY4A:10 a=IkcTkHD0fZMA:10 a=vUbySO9Y5rIA:10 a=M51BFTxLslgA:10 a=i1IsUcr2s-wA:10 a=VkNPw1HP01LnGYTKEx00:22 a=2AEO0YjSAAAA:8 a=ijG-J2Scc44MUVjsrbIA:9 a=3ZKOabzyN94A:10 a=QEXdDO2ut3YA:10 X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwMTE1MDEyMSBTYWx0ZWRfX+GyTZb/q2Xkn ektiUbFxKt5Xya8cS2CUwlXFK4s3KdeHyriVDABaIQZA413FAQm9Rzra+TE6wQNpVZ1T8hnklVC pmIfg7E6gwBdj7XGHOgXr8sOAIJYDBaNDkHc6GnuU0O9EpQwBGR5qhK0zMkQlevkE0DSpqZkOsN eeMEr7wt7Cc5nn35muYvhpGgvSsScnJsSnkt1KF89IqUnuItizS6TlNWUycvKrCc6sI8cCtq4XO NY+zTBUCqJtlCG42mU/3LJLxn5ZGl+1rU2LuKi8raGYy+W77xyh0MJdoSqQ61vmW0CJCZsC6IaN ww0LnyHjjTeZrFHWw/3PyNR5+nLL+DOqdepZbTQ5kF2hiVOfrbYBMMROIH5XWyjvVxB7Jf/XdrD VrurKYPM+J7MM3s76nS7ngi9AKnCwRytkqK1fPnpHqiISZyRNtaaqG4j2Pd5u1iNeKPG80EHctn RrtzuTLIoLVMWZw/REw== X-Proofpoint-ORIG-GUID: HyLPZ0z9jvgJGZQEhwqievnbFdzXh1v_ X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1121,Hydra:6.1.9,FMLib:17.12.100.49 definitions=2026-01-15_05,2026-01-15_01,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 impostorscore=0 suspectscore=0 bulkscore=0 spamscore=0 adultscore=0 priorityscore=1501 clxscore=1015 lowpriorityscore=0 phishscore=0 malwarescore=0 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2512120000 definitions=main-2601150121 From: Gabriel Beaulieu This introduces a new module gb-cpc-sdio, in order to communicate with a Greybus CPC device over SDIO. Most of the complexity stems from aggregation: packets are aggregated to minimize the number of CMD53s. In the first block, the first le32 is the number of packets in this transfer. Immediately after that are all the packet headers (CPC + Greybus). This lets the device process all the headers in a single interrupt, and prepare the ADMA descriptors for all the payloads in one go. Payloads start at the beginning of the second block and are concatained. Their lengths must be 32-bit aligned, so the driver takes care of adding and removing padding if necessary. Signed-off-by: Gabriel Beaulieu Signed-off-by: Damien Ri=C3=A9gel --- Changes in v2: - change formatting from %lu to %zu when printing size_t's - remove "/**" kernel-doc marker for static functions not actually using the kernel-doc format - reduce header inclusion list - use reverse christmas tree variable declarations consistently - update aggregation functions to try to be more legible - use define instead of constant value 0x0C for the address where to read the number of bytes the device wants to send - remove padding between headers and payloads when aggregating packets drivers/greybus/cpc/Kconfig | 12 + drivers/greybus/cpc/Makefile | 3 + drivers/greybus/cpc/sdio.c | 533 +++++++++++++++++++++++++++++++++++ 3 files changed, 548 insertions(+) create mode 100644 drivers/greybus/cpc/sdio.c diff --git a/drivers/greybus/cpc/Kconfig b/drivers/greybus/cpc/Kconfig index ab96fedd0de..8223f56795f 100644 --- a/drivers/greybus/cpc/Kconfig +++ b/drivers/greybus/cpc/Kconfig @@ -8,3 +8,15 @@ config GREYBUS_CPC =20 To compile this code as a module, chose M here: the module will be called gb-cpc.ko + +config GREYBUS_CPC_SDIO + tristate "Greybus CPC over SDIO" + depends on GREYBUS_CPC && MMC + help + This driver provides Greybus CPC host support for devices + connected via SDIO interface. + + To compile this driver as a module, choose M here: the module + will be called gb-cpc-sdio. + + If unsure, say N. diff --git a/drivers/greybus/cpc/Makefile b/drivers/greybus/cpc/Makefile index c4b530d27a3..3296536e86d 100644 --- a/drivers/greybus/cpc/Makefile +++ b/drivers/greybus/cpc/Makefile @@ -4,3 +4,6 @@ gb-cpc-y :=3D cport.o header.o host.o protocol.o =20 # CPC core obj-$(CONFIG_GREYBUS_CPC) +=3D gb-cpc.o + +gb-cpc-sdio-y :=3D sdio.o +obj-$(CONFIG_GREYBUS_CPC_SDIO) +=3D gb-cpc-sdio.o diff --git a/drivers/greybus/cpc/sdio.c b/drivers/greybus/cpc/sdio.c new file mode 100644 index 00000000000..aeeb8378dea --- /dev/null +++ b/drivers/greybus/cpc/sdio.c @@ -0,0 +1,533 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2025, Silicon Laboratories, Inc. + */ + +#include +#include +#include +#include +#include + +#include "cpc.h" +#include "header.h" +#include "host.h" + +#define GB_CPC_SDIO_MSG_SIZE_MAX 4096 +#define GB_CPC_SDIO_BLOCK_SIZE 256U +#define GB_CPC_SDIO_FIFO_ADDR 0 +#define GB_CPC_SDIO_RX_BYTES_CNT_ADDR 0x0C +#define GB_CPC_SDIO_ALIGNMENT 4 +#define GB_CPC_SDIO_DEFAULT_AGGREGATION 1 +#define CPC_FRAME_HEADER_SIZE (CPC_HEADER_SIZE + GREYBUS_HEADER_SIZE) +#define GB_CPC_SDIO_MAX_AGGREGATION ((GB_CPC_SDIO_BLOCK_SIZE - sizeof(u32)= ) / CPC_FRAME_HEADER_SIZE) + +enum cpc_sdio_flags { + CPC_SDIO_FLAG_IRQ_RUNNING, + CPC_SDIO_FLAG_TX_WORK_DELAYED, + CPC_SDIO_FLAG_SHUTDOWN, +}; + +struct cpc_sdio { + struct cpc_host_device *cpc_hd; + struct device *dev; + struct sdio_func *func; + + struct work_struct tx_work; + unsigned long flags; + + wait_queue_head_t event_queue; + u8 max_aggregation; +}; + +struct frame_header { + struct cpc_header cpc; + struct gb_operation_msg_hdr gb; +} __packed; + +static inline struct cpc_sdio *cpc_hd_to_cpc_sdio(struct cpc_host_device *= cpc_hd) +{ + return (struct cpc_sdio *)cpc_hd->priv; +} + +static int gb_cpc_sdio_wake_tx(struct cpc_host_device *cpc_hd) +{ + struct cpc_sdio *ctx =3D cpc_hd_to_cpc_sdio(cpc_hd); + + if (test_bit(CPC_SDIO_FLAG_SHUTDOWN, &ctx->flags)) + return 0; + + /* Use system workqueue for TX processing */ + schedule_work(&ctx->tx_work); + + return 0; +} + +/* + * Return the memory requirement in bytes for the aggregated frame aligned= to the block size + */ +static size_t cpc_sdio_get_aligned_size(struct cpc_sdio *ctx, struct sk_bu= ff_head *frame_list) +{ + struct sk_buff *frame; + size_t size =3D 0; + + /* Calculate total payload size */ + skb_queue_walk(frame_list, frame) { + /* payload is aligned and padded to 4 bytes */ + size +=3D ALIGN(frame->len, GB_CPC_SDIO_ALIGNMENT); + } + + /* Make sure the total payload size is a round number of blocks */ + size =3D ALIGN(size, GB_CPC_SDIO_BLOCK_SIZE); + + return size; +} + +static size_t cpc_sdio_build_aggregated_frame(struct cpc_sdio *ctx, + struct sk_buff_head *frame_list, + unsigned char **buffer) +{ + unsigned char *tx_buff; + struct sk_buff *frame; + __le32 *frame_count; + size_t xfer_size; + unsigned int i =3D 0; + + xfer_size =3D cpc_sdio_get_aligned_size(ctx, frame_list); + + /* Allocate aggregated frame */ + tx_buff =3D kmalloc(xfer_size, GFP_KERNEL); + if (!tx_buff) + return 0; + + frame_count =3D (__le32 *)tx_buff; + *frame_count =3D cpu_to_le32(skb_queue_len(frame_list)); + i +=3D sizeof(*frame_count); + + /* Copy frame headers to aggregate buffer */ + skb_queue_walk(frame_list, frame) { + struct frame_header *fh =3D (struct frame_header *)&tx_buff[i]; + + memcpy(fh, frame->data, sizeof(*fh)); + i +=3D sizeof(*fh); + } + + /* Build payload blocks if required */ + if (xfer_size > i) { + skb_queue_walk(frame_list, frame) { + size_t payload_len, padding_len; + + if (frame->len <=3D CPC_FRAME_HEADER_SIZE) + continue; + + payload_len =3D frame->len - CPC_FRAME_HEADER_SIZE; + memcpy(&tx_buff[i], &frame->data[CPC_FRAME_HEADER_SIZE], payload_len); + i +=3D payload_len; + + padding_len =3D ALIGN(payload_len, GB_CPC_SDIO_ALIGNMENT) - payload_len; + if (padding_len) { + memset(&tx_buff[i], 0, padding_len); + i +=3D padding_len; + } + } + } + + *buffer =3D tx_buff; + + return xfer_size; +} + +static bool cpc_sdio_get_payload_size(struct cpc_sdio *ctx, const struct f= rame_header *header, + size_t *payload_size) +{ + size_t gb_size; + + gb_size =3D le16_to_cpu(header->gb.size); + + /* Validate that the size is at least as large as the Greybus header */ + if (gb_size < GREYBUS_HEADER_SIZE) { + dev_dbg(ctx->dev, "Invalid Greybus header size: %zu\n", gb_size); + return false; + } + + /* Validate maximum size */ + if (gb_size > (GB_CPC_SDIO_MSG_SIZE_MAX + GREYBUS_HEADER_SIZE)) { + dev_dbg(ctx->dev, "Payload size exceeds maximum: %zu\n", gb_size); + return false; + } + + /* Size includes the Greybus header, so subtract it to get payload size */ + *payload_size =3D gb_size - GREYBUS_HEADER_SIZE; + + return true; +} + +/* + * Process aggregated frame + * Reconstructed frame layout: + * +-----+-----+-----+------+------+------+------+-------+---------+ + * | CPC Header (4B) | Size | OpID | Type | Stat | CPort | Payload | + * +-----+-----+-----+------+------+------+------+-------+---------+ + */ +static void cpc_sdio_process_aggregated_frame(struct cpc_sdio *ctx, unsign= ed char *aggregated_frame, + unsigned int frame_len) +{ + const unsigned char *payload_start; + const struct frame_header *header; + unsigned int payload_offset; + size_t aligned_payload_size; + struct sk_buff *rx_skb; + __le32 frame_count_le; + size_t payload_size; + size_t frame_size; + u32 frame_count; + + /* Get frame count from aggregated frame (4-byte u32) */ + frame_count_le =3D *((__le32 *)aggregated_frame); + frame_count =3D le32_to_cpu(frame_count_le); + + /* Ensure frame count doesn't exceed our negotiated maximum */ + if (frame_count > ctx->max_aggregation) { + dev_warn(ctx->dev, + "Process aggregated frame: frame count %u exceeds negotiated maximum %= u\n", + frame_count, ctx->max_aggregation); + return; + } + + /* Header starts at block 0 after frame count */ + header =3D (struct frame_header *)&aggregated_frame[sizeof(frame_count_le= )]; + + /* Payloads start at block 1 (after complete block 0) */ + payload_offset =3D (frame_count * CPC_FRAME_HEADER_SIZE) + sizeof(frame_c= ount_le); + + for (unsigned int i =3D 0; i < frame_count; i++) { + payload_start =3D &aggregated_frame[payload_offset]; + + /* Get payload size for this frame */ + if (!cpc_sdio_get_payload_size(ctx, header, &payload_size)) { + dev_err(ctx->dev, + "Process aggregated frame: failed to get payload size, aborting.\n"); + return; + } + + aligned_payload_size =3D ALIGN(payload_size, GB_CPC_SDIO_ALIGNMENT); + + /* Validate the payload is within the buffer boundary */ + if (payload_offset + aligned_payload_size > frame_len) { + dev_err(ctx->dev, + "Process aggregated frame: payload is out of buffer boundary, aborting= at frame %u\n", + i); + return; + } + + /* Calculate total frame size: CPC header + Greybus header + payload */ + frame_size =3D CPC_FRAME_HEADER_SIZE + payload_size; + + /* Allocate sk_buff for reconstructed frame */ + rx_skb =3D alloc_skb(frame_size, GFP_KERNEL); + if (!rx_skb) + return; + + /* Copy header */ + memcpy(skb_put(rx_skb, CPC_FRAME_HEADER_SIZE), header, CPC_FRAME_HEADER_= SIZE); + + /* Copy payload */ + if (payload_size > 0) + memcpy(skb_put(rx_skb, payload_size), payload_start, payload_size); + + /* Send reconstructed frame to CPC core */ + cpc_hd_rcvd(ctx->cpc_hd, rx_skb); + + /* Move to next header and payload start address */ + header++; + payload_offset +=3D aligned_payload_size; + } +} + +static u32 cpc_sdio_get_rx_num_bytes(struct sdio_func *func, int *err) +{ + unsigned int rx_num_block_addr =3D GB_CPC_SDIO_RX_BYTES_CNT_ADDR; + + return sdio_readl(func, rx_num_block_addr, err); +} + +static void gb_cpc_sdio_rx(struct cpc_sdio *ctx) +{ + unsigned char *rx_buff; + size_t data_len; + int err; + + sdio_claim_host(ctx->func); + data_len =3D cpc_sdio_get_rx_num_bytes(ctx->func, &err); + + if (err) { + dev_err(ctx->dev, "failed to obtain byte count (%d)\n", err); + goto release_host; + } + + /* Validate minimum RX data length */ + if (data_len < sizeof(u32) + CPC_FRAME_HEADER_SIZE) { + dev_err(ctx->dev, "failed to obtain enough bytes for a header (%zu)\n", = data_len); + goto release_host; + } + + /* Allocate sk_buff for RX data */ + rx_buff =3D kmalloc(data_len, GFP_KERNEL); + if (!rx_buff) + goto release_host; + + err =3D sdio_readsb(ctx->func, rx_buff, GB_CPC_SDIO_FIFO_ADDR, data_len); + sdio_release_host(ctx->func); + + if (err) { + dev_err(ctx->dev, "failed to sdio_readsb (%d)\n", err); + goto free_rx_skb; + } + + if (data_len < GB_CPC_SDIO_BLOCK_SIZE) { + dev_err(ctx->dev, "received %zd bytes, expected at least %u bytes\n", da= ta_len, + GB_CPC_SDIO_BLOCK_SIZE); + goto free_rx_skb; + } + + /* de-aggregate incoming skb into individual frames and send to CPC core = */ + cpc_sdio_process_aggregated_frame(ctx, rx_buff, data_len); + +free_rx_skb: + kfree(rx_buff); + + return; + +release_host: + sdio_release_host(ctx->func); +} + +static void gb_cpc_sdio_tx(struct cpc_sdio *ctx) +{ + struct sk_buff_head frame_list; + unsigned char *tx_buff; + size_t tx_len; + int err; + + skb_queue_head_init(&frame_list); + + /* Dequeue the negotiated maximum aggregated frames from the host device = */ + cpc_hd_dequeue_many(ctx->cpc_hd, &frame_list, ctx->max_aggregation); + + /* Check if any frames were dequeued */ + if (skb_queue_empty(&frame_list)) + return; + + tx_len =3D cpc_sdio_build_aggregated_frame(ctx, &frame_list, &tx_buff); + if (!tx_len) { + dev_err(ctx->dev, "failed to build aggregated frame\n"); + goto cleanup_frames; + } + + sdio_claim_host(ctx->func); + err =3D sdio_writesb(ctx->func, GB_CPC_SDIO_FIFO_ADDR, tx_buff, tx_len); + sdio_release_host(ctx->func); + + if (err) + dev_err(ctx->dev, "failed to sdio_writesb (%d)\n", err); + + kfree(tx_buff); + +cleanup_frames: + skb_queue_purge(&frame_list); +} + +static void gb_cpc_sdio_rx_tx(struct cpc_sdio *ctx) +{ + gb_cpc_sdio_rx(ctx); + + set_bit(CPC_SDIO_FLAG_IRQ_RUNNING, &ctx->flags); + gb_cpc_sdio_tx(ctx); + clear_bit(CPC_SDIO_FLAG_IRQ_RUNNING, &ctx->flags); +} + +static void gb_cpc_sdio_tx_work(struct work_struct *work) +{ + struct cpc_sdio *ctx =3D container_of(work, struct cpc_sdio, tx_work); + + /* Do not execute concurrently to the interrupt */ + if (test_bit(CPC_SDIO_FLAG_IRQ_RUNNING, &ctx->flags)) { + set_bit(CPC_SDIO_FLAG_TX_WORK_DELAYED, &ctx->flags); + return; + } + + gb_cpc_sdio_tx(ctx); +} + +static struct cpc_hd_driver cpc_sdio_driver =3D { + .wake_tx =3D gb_cpc_sdio_wake_tx, +}; + +static int cpc_sdio_init(struct sdio_func *func) +{ + unsigned char rx_data_ready_irq_en_bit =3D BIT(0); + unsigned int irq_enable_addr =3D 0x09; + int err; + + /* Enable the read data ready interrupt. */ + sdio_writeb(func, rx_data_ready_irq_en_bit, irq_enable_addr, &err); + if (err) + dev_err(&func->dev, "failed to set data ready interrupt (%d)\n", err); + + return err; +} + +static void cpc_sdio_irq_handler(struct sdio_func *func) +{ + unsigned int rx_data_pending_irq_bit =3D 0; + unsigned int irq_status_addr =3D 0x08; + unsigned long int_status; + struct cpc_sdio *ctx; + struct device *dev; + int err; + + ctx =3D sdio_get_drvdata(func); + dev =3D &func->dev; + + int_status =3D sdio_readb(func, irq_status_addr, &err); + if (err) { + dev_err(dev, "failed to read interrupt status registers (%d)\n", err); + return; + } + + if (__test_and_clear_bit(rx_data_pending_irq_bit, &int_status)) { + /* Clear the IRQ on the device side. */ + sdio_writeb(func, BIT(rx_data_pending_irq_bit), irq_status_addr, &err); + if (err) { + dev_err(dev, "failed to clear read interrupt (%d), interrupt will repea= t\n", + err); + return; + } + + cancel_work_sync(&ctx->tx_work); + gb_cpc_sdio_rx_tx(ctx); + + if (test_and_clear_bit(CPC_SDIO_FLAG_TX_WORK_DELAYED, &ctx->flags)) + schedule_work(&ctx->tx_work); + } + + if (int_status) + dev_err_once(dev, "unhandled interrupt from the device (%ld)\n", int_sta= tus); +} + +static int cpc_sdio_probe(struct sdio_func *func, const struct sdio_device= _id *id) +{ + struct cpc_host_device *cpc_hd; + struct cpc_sdio *ctx; + int err; + + /* Allocate our private context */ + ctx =3D kzalloc(sizeof(*ctx), GFP_KERNEL); + if (!ctx) + return -ENOMEM; + + /* Create CPC host device with our context as private data */ + cpc_hd =3D cpc_hd_create(&cpc_sdio_driver, &func->dev, ctx); + if (IS_ERR(cpc_hd)) { + kfree(ctx); + return PTR_ERR(cpc_hd); + } + + /* Initialize context */ + ctx->cpc_hd =3D cpc_hd; + ctx->dev =3D cpc_hd_dev(cpc_hd); + ctx->func =3D func; + ctx->max_aggregation =3D GB_CPC_SDIO_DEFAULT_AGGREGATION; + + INIT_WORK(&ctx->tx_work, gb_cpc_sdio_tx_work); + + /* Make ctx available to IRQ handler before enabling/claiming IRQ */ + sdio_set_drvdata(func, ctx); + + sdio_claim_host(func); + + err =3D sdio_enable_func(func); + if (err) + goto release_host; + + err =3D sdio_set_block_size(func, GB_CPC_SDIO_BLOCK_SIZE); + if (err) + goto disable_func; + + err =3D cpc_sdio_init(func); + if (err) + goto disable_func; + + err =3D sdio_claim_irq(func, cpc_sdio_irq_handler); + if (err) + goto disable_func; + + err =3D cpc_hd_add(cpc_hd); + if (err) + goto release_irq; + + sdio_release_host(func); + + return 0; + +release_irq: + sdio_release_irq(func); + +disable_func: + sdio_disable_func(func); + +release_host: + sdio_release_host(func); + cpc_hd_put(cpc_hd); + kfree(ctx); + + return err; +} + +static void cpc_sdio_remove(struct sdio_func *func) +{ + struct cpc_sdio *ctx =3D sdio_get_drvdata(func); + struct cpc_host_device *cpc_hd =3D ctx->cpc_hd; + + /* Prevent new TX wakeups and wake the thread */ + set_bit(CPC_SDIO_FLAG_SHUTDOWN, &ctx->flags); + + /* Cancel and flush any pending TX work */ + cancel_work_sync(&ctx->tx_work); + + sdio_claim_host(func); + sdio_release_irq(func); + sdio_disable_func(func); + sdio_release_host(func); + + cpc_hd_del(cpc_hd); + cpc_hd_put(cpc_hd); + + kfree(ctx); +} + +/* NOTE: Development/RFC purposes only. */ +static const struct sdio_device_id sdio_ids[] =3D { + { + SDIO_DEVICE(0x0296, 0x5347), + }, + {}, +}; +MODULE_DEVICE_TABLE(sdio, sdio_ids); + +static struct sdio_driver gb_cpc_sdio_driver =3D { + .name =3D KBUILD_MODNAME, + .id_table =3D sdio_ids, + .probe =3D cpc_sdio_probe, + .remove =3D cpc_sdio_remove, + .drv =3D { + .owner =3D THIS_MODULE, + .name =3D KBUILD_MODNAME, + }, +}; + +module_sdio_driver(gb_cpc_sdio_driver); + +MODULE_DESCRIPTION("Greybus Host Driver for Silicon Labs devices using SDI= O"); +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("Damien Ri=C3=A9gel "); --=20 2.52.0