From patchwork Tue Jul 5 11:42:58 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jakub Kicinski X-Patchwork-Id: 9214129 X-Patchwork-Delegate: kvalo@adurom.com Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork.web.codeaurora.org (Postfix) with ESMTP id 0141160752 for ; Tue, 5 Jul 2016 11:43:31 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id E32E628A16 for ; Tue, 5 Jul 2016 11:43:30 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id D584228A18; Tue, 5 Jul 2016 11:43:30 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-6.8 required=2.0 tests=BAYES_00,DKIM_SIGNED, RCVD_IN_DNSWL_HI,T_DKIM_INVALID autolearn=ham version=3.3.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 2A61528A16 for ; Tue, 5 Jul 2016 11:43:30 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S932970AbcGELn2 (ORCPT ); Tue, 5 Jul 2016 07:43:28 -0400 Received: from mail-wm0-f45.google.com ([74.125.82.45]:38051 "EHLO mail-wm0-f45.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S932938AbcGELn1 (ORCPT ); Tue, 5 Jul 2016 07:43:27 -0400 Received: by mail-wm0-f45.google.com with SMTP id r201so148807162wme.1 for ; Tue, 05 Jul 2016 04:43:26 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=netronome-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=bCAaH8qdbsmRQEMvmImElrMp9mUYhJa007Z7SVQ6AK8=; b=If6jTHsJg44+p7IbIUe+Xjk6VH+9m6RJxMIlz3WZmw1xa8nNha5LmDkn9zQba5XrnA v5d3Ma+M41jER3y2ankraItmuQ/aTVLKXsOoaCwD1VrZTRLmuyfteCx+cXlPmwsvCiFx gc4vLD28NH6mD0DrftrnhkETIG9o2zvj2Fv7nc08qZijrdutQDAYjR/EOtfooggozFpS vnP1zhIlVgrdlrFVJoC56ADjfXq8pe0t7DyqqXohvxOiGGcQJUpHOQu8QBedorwNS5Rs XHfSqJErBR+ZfgLv0jNiZM9NMCYDb8FEK+BaycWX0iRpOJ1RcnbaAU8y1j8BDmJduzB2 Ps1w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=bCAaH8qdbsmRQEMvmImElrMp9mUYhJa007Z7SVQ6AK8=; b=iSDQ+PEXJ/sCKrWv8ggwa0t6P7GXTePwM8qheObEbsmUCGyW72aRhvjXuUJkT0UVl0 Ne6fUdd8dwhQif0fZcELp18GVpF7eMRDGVzB4cFArNfdL96lIMQf6QGXmPHMWIGgWL/E y/wHE+hEPXtROSTZesIov2RYPgR8Rx5Tmkpfcm7UApEfm4qPzQqjTsNPwFEUNCDE7suv 14OiFNVaa8kIICH6EG7J392TBeZG4tQA0OLQPTK9OhUMcgqAiBgo0r9kuoWUhpOLxe9n 63JD0dlMTUKieuzgmM3yaKvRVT6PWQgTj3YQYT8ixuLnu8J58U6MY88+6JjoZinV+sSt ojiQ== X-Gm-Message-State: ALyK8tLmt8B4rI9dgscN1YO4yeYhr92uZiNVih7ge18H8ohJxq48P7YDYJSWhFzna04tbX56 X-Received: by 10.28.86.214 with SMTP id k205mr14783365wmb.17.1467719004472; Tue, 05 Jul 2016 04:43:24 -0700 (PDT) Received: from jkicinski-Precision-T1700.netronome.com (host-79-78-33-110.static.as9105.net. [79.78.33.110]) by smtp.gmail.com with ESMTPSA id e69sm354446wma.2.2016.07.05.04.43.22 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Tue, 05 Jul 2016 04:43:23 -0700 (PDT) From: Jakub Kicinski To: kvalo@codeaurora.org, linux-wireless@vger.kernel.org Cc: netdev@vger.kernel.org, hannes@stressinduktion.org, nbd@nbd.name, linux-kernel@vger.kernel.org, Jakub Kicinski Subject: [PATCHv4 wl-drv-next 1/2] add basic register-field manipulation macros Date: Tue, 5 Jul 2016 12:42:58 +0100 Message-Id: <1467718979-20029-2-git-send-email-jakub.kicinski@netronome.com> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1467718979-20029-1-git-send-email-jakub.kicinski@netronome.com> References: <1467718979-20029-1-git-send-email-jakub.kicinski@netronome.com> Sender: linux-wireless-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-wireless@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP Common approach to accessing register fields is to define structures or sets of macros containing mask and shift pair. Operations on the register are then performed as follows: field = (reg >> shift) & mask; reg &= ~(mask << shift); reg |= (field & mask) << shift; Defining shift and mask separately is tedious. Ivo van Doorn came up with an idea of computing them at compilation time based on a single shifted mask (later refined by Felix) which can be used like this: #define REG_FIELD 0x000ff000 field = FIELD_GET(REG_FIELD, reg); reg &= ~REG_FIELD; reg |= FIELD_PUT(REG_FIELD, field); FIELD_{GET,PUT} macros take care of finding out what the appropriate shift is based on compilation time ffs operation. GENMASK can be used to define registers (which is usually less error-prone and easier to match with datasheets). This approach is the most convenient I've seen so to limit code multiplication let's move the macros to a global header file. Signed-off-by: Jakub Kicinski --- include/linux/bitfield.h | 109 +++++++++++++++++++++++++++++++++++++++++++++++ include/linux/bug.h | 3 ++ 2 files changed, 112 insertions(+) create mode 100644 include/linux/bitfield.h diff --git a/include/linux/bitfield.h b/include/linux/bitfield.h new file mode 100644 index 000000000000..ff9fd0af2ac7 --- /dev/null +++ b/include/linux/bitfield.h @@ -0,0 +1,109 @@ +/* + * Copyright (C) 2014 Felix Fietkau + * Copyright (C) 2004 - 2009 Ivo van Doorn + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 + * as published by the Free Software Foundation + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ + +#ifndef _LINUX_BITFIELD_H +#define _LINUX_BITFIELD_H + +#include +#include + +#define _bf_shf(x) (__builtin_ffsll(x) - 1) + +#define _BF_FIELD_CHECK(_mask, _val) \ + ({ \ + BUILD_BUG_ON(!(_mask)); \ + BUILD_BUG_ON(__builtin_constant_p(_val) ? \ + ~((_mask) >> _bf_shf(_mask)) & (_val) : \ + 0); \ + __BUILD_BUG_ON_NOT_POWER_OF_2((_mask) + \ + (1ULL << _bf_shf(_mask))); \ + }) + +/* + * Bitfield access macros + * + * This file contains macros which take as input shifted mask + * from which they extract the base mask and shift amount at + * compilation time. There are two separate sets of the macros + * one for 32bit registers and one for 64bit ones. + * + * Fields can be defined using GENMASK (which is usually + * less error-prone and easier to match with datasheets). + * + * FIELD_{GET,PUT} macros are designed to be used with masks which + * are compilation time constants. + * + * Example: + * + * #define REG_FIELD_A GENMASK(6, 0) + * #define REG_FIELD_B BIT(7) + * #define REG_FIELD_C GENMASK(15, 8) + * #define REG_FIELD_D GENMASK(31, 16) + * + * Get: + * a = FIELD_GET(REG_FIELD_A, reg); + * b = FIELD_GET(REG_FIELD_B, reg); + * + * Set: + * reg = FIELD_PUT(REG_FIELD_A, 1) | + * FIELD_PUT(REG_FIELD_B, 0) | + * FIELD_PUT(REG_FIELD_C, c) | + * FIELD_PUT(REG_FIELD_D, 0x40); + * + * Modify: + * reg &= ~REG_FIELD_C; + * reg |= FIELD_PUT(REG_FIELD_C, c); + */ + +/** + * FIELD_PUT() - construct a bitfield element + * @_mask: shifted mask defining the field's length and position + * @_val: value to put in the field + * + * FIELD_PUT() masks and shifts up the value. The result should + * be combined with other fields of the bitfield using logical OR. + */ +#define FIELD_PUT(_mask, _val) \ + ({ \ + _BF_FIELD_CHECK(_mask, _val); \ + ((u32)(_val) << _bf_shf(_mask)) & (_mask); \ + }) + +/** + * FIELD_GET() - extract a bitfield element + * @_mask: shifted mask defining the field's length and position + * @_val: 32bit value of entire bitfield + * + * FIELD_GET() extracts the field specified by @_mask from the + * bitfield passed in as @_val. + */ +#define FIELD_GET(_mask, _val) \ + ({ \ + _BF_FIELD_CHECK(_mask, 0); \ + (u32)(((_val) & (_mask)) >> _bf_shf(_mask)); \ + }) + +#define FIELD_PUT64(_mask, _val) \ + ({ \ + _BF_FIELD_CHECK(_mask, _val); \ + ((u64)(_val) << _bf_shf(_mask)) & (_mask); \ + }) + +#define FIELD_GET64(_mask, _val) \ + ({ \ + _BF_FIELD_CHECK(_mask, 0); \ + (u64)(((_val) & (_mask)) >> _bf_shf(_mask)); \ + }) + +#endif diff --git a/include/linux/bug.h b/include/linux/bug.h index e51b0709e78d..bba5bdae1681 100644 --- a/include/linux/bug.h +++ b/include/linux/bug.h @@ -13,6 +13,7 @@ enum bug_trap_type { struct pt_regs; #ifdef __CHECKER__ +#define __BUILD_BUG_ON_NOT_POWER_OF_2(n) (0) #define BUILD_BUG_ON_NOT_POWER_OF_2(n) (0) #define BUILD_BUG_ON_ZERO(e) (0) #define BUILD_BUG_ON_NULL(e) ((void*)0) @@ -24,6 +25,8 @@ struct pt_regs; #else /* __CHECKER__ */ /* Force a compilation error if a constant expression is not a power of 2 */ +#define __BUILD_BUG_ON_NOT_POWER_OF_2(n) \ + BUILD_BUG_ON(((n) & ((n) - 1)) != 0) #define BUILD_BUG_ON_NOT_POWER_OF_2(n) \ BUILD_BUG_ON((n) == 0 || (((n) & ((n) - 1)) != 0))