From patchwork Thu Aug 9 12:33:31 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ben Whitten X-Patchwork-Id: 955524 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=fail (p=none dis=none) header.from=gmail.com Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.b="bwJu5qKv"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 41mSPR49fBz9ryt for ; Thu, 9 Aug 2018 22:34:35 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1730699AbeHIO7O (ORCPT ); Thu, 9 Aug 2018 10:59:14 -0400 Received: from mail-wm0-f66.google.com ([74.125.82.66]:52734 "EHLO mail-wm0-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727786AbeHIO7O (ORCPT ); Thu, 9 Aug 2018 10:59:14 -0400 Received: by mail-wm0-f66.google.com with SMTP id o11-v6so35447wmh.2 for ; Thu, 09 Aug 2018 05:34:32 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=sender:from:to:cc:subject:date:message-id; bh=d4trg1VikcampBqiUG7Zk05+B293YV9xzEpclqVwya0=; b=bwJu5qKv7yz062ltCbcF7jGaD0yAc3ZSuCZKlgxQTzCe7VrOlG6j+iNqim4V3Hwv1b UgJ9bBcdcXNTYgxpd1Rfj1q7DYZJPDw8ZcvPHeGNc37g6UP9RliklnZ1bIXCNPU55f2C q0CIcHKS++ZKx8zc6vXwZvBgWMW4B9niGb4FKFd7MQvafivc69rFhOVnAfi4JQF8ku0n YuSGN6dUYrTwy9Mp8NDPo8iQbQAoDyrGPINTWX/ymbn4eh+H1d7Ycwc4QMQNAnEPrfCd bZMiT+bSDhmkbjnokGafAhpqFqYOAjEkJxInlu8pBpTd9bOxgzMvYIO85aU2DhaTLBqO M0IQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:from:to:cc:subject:date:message-id; bh=d4trg1VikcampBqiUG7Zk05+B293YV9xzEpclqVwya0=; b=MpqS0SSFYtrjQAUCApei+72SAIXG4bGJjAhhPoadjYNm1227AKjJ9gnZGfKvzCqdbw OKDwqoRRbPv8hc+X7kuFLiGw7Lnr/K3ezxml4b988IioiedcnqFV353m13wBdykFreYV s0ZTF6o594cDOA+ARpBloPtNNcVMQeLaUUokms44SvnKEA42781lzMWgeI49LnB2Vr3G 8y73+l6VLU1ZMPepbnvozRTZfxlLLgyegItLl25g3wdXOPlfg8pdAprBp1SVZwnVuzDt iTTppRuXXXsEiOpnWIr21mbK01AOXbwsXa2ysPqB3xr1Reu32/vCiN/CxKSysYnKfC3P 6b2Q== X-Gm-Message-State: AOUpUlEFCpmrHJW9d6eEi7zC+LhlTOLYuR1s5DSyeC9bJnyQx7pq8aJ7 GI33LuoI9F6ohp8sdX6O3+c= X-Google-Smtp-Source: AA+uWPyhYCfAWRWm4Bcx9fqhZRezy1ElZZXfHfFIK3CBjp99RCcVjsEZgOZPfvDAV4JIOhT4PXEKLQ== X-Received: by 2002:a1c:8b0d:: with SMTP id n13-v6mr1407557wmd.46.1533818071315; Thu, 09 Aug 2018 05:34:31 -0700 (PDT) Received: from Sarah.corp.lairdtech.com ([109.174.151.67]) by smtp.gmail.com with ESMTPSA id g125-v6sm8596848wmf.16.2018.08.09.05.34.29 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Thu, 09 Aug 2018 05:34:30 -0700 (PDT) From: Ben Whitten X-Google-Original-From: Ben Whitten To: afaerber@suse.de Cc: starnight@g.ncu.edu.tw, hasnain.virk@arm.com, netdev@vger.kernel.org, liuxuenetmail@gmail.com, shess@hessware.de, Ben Whitten Subject: [PATCH lora-next v2 1/8] net: lora: add methods for devm registration Date: Thu, 9 Aug 2018 13:33:31 +0100 Message-Id: <1533818018-29005-1-git-send-email-ben.whitten@lairdtech.com> X-Mailer: git-send-email 2.7.4 Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Follow the devm model so that we can avoid lengthy unwind code. Signed-off-by: Ben Whitten --- drivers/net/lora/dev.c | 28 ++++++++++++++++++++++++++++ include/linux/lora/dev.h | 1 + 2 files changed, 29 insertions(+) diff --git a/drivers/net/lora/dev.c b/drivers/net/lora/dev.c index 8c01106..e32a870 100644 --- a/drivers/net/lora/dev.c +++ b/drivers/net/lora/dev.c @@ -84,6 +84,34 @@ void free_loradev(struct net_device *dev) } EXPORT_SYMBOL_GPL(free_loradev); +static void devm_free_loradev(struct device *dev, void *res) +{ + struct net_device *net = (*(struct net_device **)res); + free_loradev(net); +} + +struct net_device *devm_alloc_loradev(struct device *dev, size_t priv) +{ + struct net_device **ptr; + struct net_device *net; + + net = alloc_loradev(priv); + if (!net) + return NULL; + + ptr = devres_alloc(devm_free_loradev, sizeof(*ptr), GFP_KERNEL); + if (!ptr) { + free_loradev(net); + return NULL; + } + + *ptr = net; + devres_add(dev, ptr); + + return net; +} +EXPORT_SYMBOL_GPL(devm_alloc_loradev); + static struct rtnl_link_ops lora_link_ops __read_mostly = { .kind = "lora", .setup = lora_setup, diff --git a/include/linux/lora/dev.h b/include/linux/lora/dev.h index 153f9b2..0f600c9 100644 --- a/include/linux/lora/dev.h +++ b/include/linux/lora/dev.h @@ -31,6 +31,7 @@ static inline int lora_strtoeui(const char *str, lora_eui *val) } struct net_device *alloc_loradev(int sizeof_priv); +struct net_device *devm_alloc_loradev(struct device *dev, size_t priv); void free_loradev(struct net_device *dev); int register_loradev(struct net_device *dev); void unregister_loradev(struct net_device *dev); From patchwork Thu Aug 9 12:33:32 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Ben Whitten X-Patchwork-Id: 955525 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=fail (p=none dis=none) header.from=gmail.com Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.b="JbsvEUuy"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 41mSPS743jz9s1x for ; Thu, 9 Aug 2018 22:34:36 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1731041AbeHIO7Q (ORCPT ); Thu, 9 Aug 2018 10:59:16 -0400 Received: from mail-wr1-f68.google.com ([209.85.221.68]:35265 "EHLO mail-wr1-f68.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727786AbeHIO7Q (ORCPT ); Thu, 9 Aug 2018 10:59:16 -0400 Received: by mail-wr1-f68.google.com with SMTP id g1-v6so5022200wru.2 for ; Thu, 09 Aug 2018 05:34:33 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=sender:from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=L8qmrLLhBmovNagxfE4M6tIf6Kbw+/5IQVtHXBIaQso=; b=JbsvEUuyVlzwkziuUz3+Eo0y9DJk+7rcwfrepGUEPmU1NLdc5Stkz84kPygwEpNEU4 mnq2GH8qcpgkOHipG547LRLNUvyWISjpfp8HcpuEk47EMDrFDUhoDwL0S8DiFg+qi8rE ewDdP3aHoIlV8JsxGQiysS5XECFlTNqtVrbJ7OcnTAVPrUmlIE8Y0vw5CGJ0rWm5n/fz 6hCdsa/bQzkbYgkm44jzXqd3nhEFMky4+Dg1dDVvuXm1+X73DzCLzV+9IO0n75YcGmYg B7z7ti3o/UQ5huDIf974O+FwycJ3OZNstvu1gxtU0IX/mNAxcThzKVu0RAkDhHNT7k2e L/gg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:from:to:cc:subject:date:message-id :in-reply-to:references:mime-version:content-transfer-encoding; bh=L8qmrLLhBmovNagxfE4M6tIf6Kbw+/5IQVtHXBIaQso=; b=ecEI56VE6FMcuTsSh2ztamHle+mcql1/95Z2Vn+cfBLIh5dCgIugL/569chO1p9uvG wX2YxJPYtGd5tF6ub45qFN0f//6uPzXsR0vewz7YZmX2j1FQRzI90MqLjCaxw5BRzdq1 VJdMt07fQUOY+TqldHDhaNiJBzK4xp8zlHa3rHhc0h5aVu0WSTaTHy6Qvl+8kbXGzXLb wkm7eZRlclW6a/bkx9I2A2nkLhZ4EySS5qEuJR0aMqOEs9DTn1Y3zbH/ph99WBPK7VVp hFVbbT3TQrx+WqQEnAGV84x6pO7smveHK0RZzFf93eJPmBXzmTWg355kRMtvNsetT5rc +8kg== X-Gm-Message-State: AOUpUlFqt5zJPn2FYfTQKWVdyyPBq0X+UWfuWgr7axCV+FR1RT4HQleq 8XcWnFd5YnZdhGsORMgOWlA= X-Google-Smtp-Source: AA+uWPw7/1Bfbn184ReS2TAr+iXQ59qoaRqypDo66QPdyS7p2NCNJoY2k7MjosrhyROV5BxyhBt6WA== X-Received: by 2002:a5d:6250:: with SMTP id m16-v6mr1400218wrv.179.1533818072903; Thu, 09 Aug 2018 05:34:32 -0700 (PDT) Received: from Sarah.corp.lairdtech.com ([109.174.151.67]) by smtp.gmail.com with ESMTPSA id g125-v6sm8596848wmf.16.2018.08.09.05.34.31 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Thu, 09 Aug 2018 05:34:31 -0700 (PDT) From: Ben Whitten X-Google-Original-From: Ben Whitten To: afaerber@suse.de Cc: starnight@g.ncu.edu.tw, hasnain.virk@arm.com, netdev@vger.kernel.org, liuxuenetmail@gmail.com, shess@hessware.de, Ben Whitten Subject: [PATCH lora-next v2 2/8] net: lora: sx1301: convert to devm registration of netdev Date: Thu, 9 Aug 2018 13:33:32 +0100 Message-Id: <1533818018-29005-2-git-send-email-ben.whitten@lairdtech.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1533818018-29005-1-git-send-email-ben.whitten@lairdtech.com> References: <1533818018-29005-1-git-send-email-ben.whitten@lairdtech.com> MIME-Version: 1.0 Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org We allow the devres framework handle the clean removal of resources on teardown of the device, in this case the SPI device, saving lengthy unwind code and improving clarity. Signed-off-by: Ben Whitten --- drivers/net/lora/sx1301.c | 87 +++++++++++++++-------------------------------- 1 file changed, 27 insertions(+), 60 deletions(-) diff --git a/drivers/net/lora/sx1301.c b/drivers/net/lora/sx1301.c index 5342b61..3c09f5a 100644 --- a/drivers/net/lora/sx1301.c +++ b/drivers/net/lora/sx1301.c @@ -3,6 +3,7 @@ * Semtech SX1301 LoRa concentrator * * Copyright (c) 2018 Andreas Färber + * Copyright (c) 2018 Ben Whitten * * Based on SX1301 HAL code: * Copyright (c) 2013 Semtech-Cycleo @@ -637,20 +638,17 @@ static int sx1301_probe(struct spi_device *spi) ret = sx1301_read(spi, REG_VERSION, &val); if (ret) { dev_err(&spi->dev, "version read failed\n"); - goto err_version; + return ret; } if (val != 103) { dev_err(&spi->dev, "unexpected version: %u\n", val); - ret = -ENXIO; - goto err_version; + return -ENXIO; } - netdev = alloc_loradev(sizeof(*priv)); - if (!netdev) { - ret = -ENOMEM; - goto err_alloc_loradev; - } + netdev = devm_alloc_loradev(&spi->dev, sizeof(*priv)); + if (!netdev) + return -ENOMEM; priv = netdev_priv(netdev); priv->rst_gpio = rst; @@ -662,19 +660,19 @@ static int sx1301_probe(struct spi_device *spi) ret = sx1301_write(spi, REG_PAGE_RESET, 0); if (ret) { dev_err(&spi->dev, "page/reset write failed\n"); - goto err_init_page; + return ret; } ret = sx1301_soft_reset(spi); if (ret) { dev_err(&spi->dev, "soft reset failed\n"); - goto err_soft_reset; + return ret; } ret = sx1301_read(spi, 16, &val); if (ret) { dev_err(&spi->dev, "16 read failed\n"); - goto err_read_global_en_0; + return ret; } val &= ~REG_16_GLOBAL_EN; @@ -682,13 +680,13 @@ static int sx1301_probe(struct spi_device *spi) ret = sx1301_write(spi, 16, val); if (ret) { dev_err(&spi->dev, "16 write failed\n"); - goto err_write_global_en_0; + return ret; } ret = sx1301_read(spi, 17, &val); if (ret) { dev_err(&spi->dev, "17 read failed\n"); - goto err_read_clk32m_0; + return ret; } val &= ~REG_17_CLK32M_EN; @@ -696,7 +694,7 @@ static int sx1301_probe(struct spi_device *spi) ret = sx1301_write(spi, 17, val); if (ret) { dev_err(&spi->dev, "17 write failed\n"); - goto err_write_clk32m_0; + return ret; } ret = sx1301_page_read(spi, 2, 43, &val); @@ -749,8 +747,7 @@ static int sx1301_probe(struct spi_device *spi) priv->radio_a_ctrl = spi_alloc_master(&spi->dev, sizeof(*radio)); if (!priv->radio_a_ctrl) { - ret = -ENOMEM; - goto err_radio_a_alloc; + return -ENOMEM; } sx1301_radio_setup(priv->radio_a_ctrl); @@ -765,15 +762,14 @@ static int sx1301_probe(struct spi_device *spi) if (ret) { dev_err(&spi->dev, "radio A SPI register failed\n"); spi_controller_put(priv->radio_a_ctrl); - goto err_radio_a_register; + return ret; } /* radio B */ priv->radio_b_ctrl = spi_alloc_master(&spi->dev, sizeof(*radio)); if (!priv->radio_b_ctrl) { - ret = -ENOMEM; - goto err_radio_b_alloc; + return -ENOMEM; } sx1301_radio_setup(priv->radio_b_ctrl); @@ -788,7 +784,7 @@ static int sx1301_probe(struct spi_device *spi) if (ret) { dev_err(&spi->dev, "radio B SPI register failed\n"); spi_controller_put(priv->radio_b_ctrl); - goto err_radio_b_register; + return ret; } /* GPIO */ @@ -796,7 +792,7 @@ static int sx1301_probe(struct spi_device *spi) ret = sx1301_read(spi, REG_GPIO_MODE, &val); if (ret) { dev_err(&spi->dev, "GPIO mode read failed\n"); - goto err_read_gpio_mode; + return ret; } val |= GENMASK(4, 0); @@ -804,13 +800,13 @@ static int sx1301_probe(struct spi_device *spi) ret = sx1301_write(spi, REG_GPIO_MODE, val); if (ret) { dev_err(&spi->dev, "GPIO mode write failed\n"); - goto err_write_gpio_mode; + return ret; } ret = sx1301_read(spi, REG_GPIO_SELECT_OUTPUT, &val); if (ret) { dev_err(&spi->dev, "GPIO select output read failed\n"); - goto err_read_gpio_select_output; + return ret; } val &= ~GENMASK(3, 0); @@ -819,7 +815,7 @@ static int sx1301_probe(struct spi_device *spi) ret = sx1301_write(spi, REG_GPIO_SELECT_OUTPUT, val); if (ret) { dev_err(&spi->dev, "GPIO select output write failed\n"); - goto err_write_gpio_select_output; + return ret; } /* TODO LBT */ @@ -827,7 +823,7 @@ static int sx1301_probe(struct spi_device *spi) ret = sx1301_read(spi, 16, &val); if (ret) { dev_err(&spi->dev, "16 read (1) failed\n"); - goto err_read_global_en_1; + return ret; } val |= REG_16_GLOBAL_EN; @@ -835,13 +831,13 @@ static int sx1301_probe(struct spi_device *spi) ret = sx1301_write(spi, 16, val); if (ret) { dev_err(&spi->dev, "16 write (1) failed\n"); - goto err_write_global_en_1; + return ret; } ret = sx1301_read(spi, 17, &val); if (ret) { dev_err(&spi->dev, "17 read (1) failed\n"); - goto err_read_clk32m_1; + return ret; } val |= REG_17_CLK32M_EN; @@ -849,58 +845,28 @@ static int sx1301_probe(struct spi_device *spi) ret = sx1301_write(spi, 17, val); if (ret) { dev_err(&spi->dev, "17 write (1) failed\n"); - goto err_write_clk32m_1; + return ret; } /* calibration */ ret = sx1301_agc_calibrate(spi); if (ret) - goto err_agc_calibrate; + return ret; /* TODO */ ret = sx1301_load_all_firmware(spi); if (ret) - goto err_load_firmware; + return ret; dev_info(&spi->dev, "SX1301 module probed\n"); return 0; - -err_load_firmware: -err_agc_calibrate: -err_write_clk32m_1: -err_read_clk32m_1: -err_write_global_en_1: -err_read_global_en_1: -err_write_gpio_select_output: -err_read_gpio_select_output: -err_write_gpio_mode: -err_read_gpio_mode: -err_radio_b_register: -err_radio_b_alloc: -err_radio_a_register: -err_radio_a_alloc: -err_write_clk32m_0: -err_read_clk32m_0: -err_write_global_en_0: -err_read_global_en_0: -err_soft_reset: -err_init_page: - free_loradev(netdev); -err_alloc_loradev: -err_version: - return ret; } static int sx1301_remove(struct spi_device *spi) { - struct net_device *netdev = spi_get_drvdata(spi); - - //unregister_loradev(netdev); - free_loradev(netdev); - dev_info(&spi->dev, "SX1301 module removed\n"); return 0; @@ -927,4 +893,5 @@ module_spi_driver(sx1301_spi_driver); MODULE_DESCRIPTION("SX1301 SPI driver"); MODULE_AUTHOR("Andreas Färber "); +MODULE_AUTHOR("Ben Whitten "); MODULE_LICENSE("GPL"); From patchwork Thu Aug 9 12:33:33 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ben Whitten X-Patchwork-Id: 955531 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=fail (p=none dis=none) header.from=gmail.com Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.b="HHB+eG49"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 41mSPj4ZJ4z9ryt for ; Thu, 9 Aug 2018 22:34:49 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1731184AbeHIO7T (ORCPT ); Thu, 9 Aug 2018 10:59:19 -0400 Received: from mail-wr1-f49.google.com ([209.85.221.49]:46401 "EHLO mail-wr1-f49.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1730803AbeHIO7S (ORCPT ); Thu, 9 Aug 2018 10:59:18 -0400 Received: by mail-wr1-f49.google.com with SMTP id h14-v6so4978893wrw.13 for ; Thu, 09 Aug 2018 05:34:35 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=sender:from:to:cc:subject:date:message-id:in-reply-to:references; bh=LJIsGh5RqM4lIVY5P1r8AotygIBKkmK8YzvJBYt3AOs=; b=HHB+eG49Z6HOIGlRAhrWqZCL3MwBFFKbODFiPU01FkUc11Lncm6P/ymJbhfy2cjcs+ RklnltxdTXDNB24vu7cuKbXK4XWTckEwpHe6T9YV8NaBu1bLjbEqbsSxlJAj2fws4H1K quOF45knBBEwts84BXr3dhq0MhDU0qLHgdWTZMeRe7IwX506akvQQ51CDtIQCbNUUco7 ONFcmh6Dz25Qtrd4Zg96JfH0ZamAfU3YDP3+7hFv/d66ztIV0Pp/zlmwAd3HsoJ0N8dD aPK1tpM84499FfVq+7tpckMTKxaRqTB+4xLIsZDi+JSy5OpAETiKBG5EZlCxSKVrVdPi 5+Fw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:from:to:cc:subject:date:message-id :in-reply-to:references; bh=LJIsGh5RqM4lIVY5P1r8AotygIBKkmK8YzvJBYt3AOs=; b=FcuchDhlDGfWJwrk0NzoZOBayzruiE1oLPfBVKd1sB3mYn//ZP6Z5Nt9YZqd7aZtwB 2A4NyB2bxzo4wuK7GEHTUEQfDVsi8pPsFybIYRmbqRmjUPalBKmZixkcTD8DUk0WpxzP kshFPAvKJmOUeh7ApQ9Jc4WjdA8JNmttWeKpHcroUIH+PvTX8U523AU4WDS1x2ZP2Zr/ VDQoOSgr0WMVRL06k+e3hgNNjYmVcB3DlzDK5vv5rIs+r2sxWcjTO18fWzCjP/awZf9m nopvpS791gqW/plwqaxJf4T9XAEPvPIjqgcjmthaxmbeli/RRPKsEGwDFUhzU5bA+71P wlcg== X-Gm-Message-State: AOUpUlFmVrZfT3Yrs6av/fOK36e0iseBfAKfivRHmtj8i5LJO3KMN6Pn cRh4NKA3SQpJ9AFXwsiee7A= X-Google-Smtp-Source: AA+uWPxQ0gMx19I7u0QYGfXAwmlxuHWy7Pb0VcegFNjz+rhXqndlMo0L1vok3cYPtZdWYhAH5TuIJQ== X-Received: by 2002:a5d:4d8d:: with SMTP id b13-v6mr1283393wru.80.1533818074433; Thu, 09 Aug 2018 05:34:34 -0700 (PDT) Received: from Sarah.corp.lairdtech.com ([109.174.151.67]) by smtp.gmail.com with ESMTPSA id g125-v6sm8596848wmf.16.2018.08.09.05.34.32 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Thu, 09 Aug 2018 05:34:33 -0700 (PDT) From: Ben Whitten X-Google-Original-From: Ben Whitten To: afaerber@suse.de Cc: starnight@g.ncu.edu.tw, hasnain.virk@arm.com, netdev@vger.kernel.org, liuxuenetmail@gmail.com, shess@hessware.de, Ben Whitten Subject: [PATCH lora-next v2 3/8] net: lora: sx1301: convert to passing priv data throughout Date: Thu, 9 Aug 2018 13:33:33 +0100 Message-Id: <1533818018-29005-3-git-send-email-ben.whitten@lairdtech.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1533818018-29005-1-git-send-email-ben.whitten@lairdtech.com> References: <1533818018-29005-1-git-send-email-ben.whitten@lairdtech.com> Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Instead of passing around the spi device we instead pass around our driver data directly. Signed-off-by: Ben Whitten --- drivers/net/lora/sx1301.c | 305 +++++++++++++++++++++++----------------------- 1 file changed, 155 insertions(+), 150 deletions(-) diff --git a/drivers/net/lora/sx1301.c b/drivers/net/lora/sx1301.c index 3c09f5a..7324001 100644 --- a/drivers/net/lora/sx1301.c +++ b/drivers/net/lora/sx1301.c @@ -73,24 +73,26 @@ struct spi_sx1301 { }; struct sx1301_priv { + struct device *dev; + struct spi_device *spi; struct lora_priv lora; struct gpio_desc *rst_gpio; u8 cur_page; struct spi_controller *radio_a_ctrl, *radio_b_ctrl; }; -static int sx1301_read_burst(struct spi_device *spi, u8 reg, u8 *val, size_t len) +static int sx1301_read_burst(struct sx1301_priv *priv, u8 reg, u8 *val, size_t len) { u8 addr = reg & 0x7f; - return spi_write_then_read(spi, &addr, 1, val, len); + return spi_write_then_read(priv->spi, &addr, 1, val, len); } -static int sx1301_read(struct spi_device *spi, u8 reg, u8 *val) +static int sx1301_read(struct sx1301_priv *priv, u8 reg, u8 *val) { - return sx1301_read_burst(spi, reg, val, 1); + return sx1301_read_burst(priv, reg, val, 1); } -static int sx1301_write_burst(struct spi_device *spi, u8 reg, const u8 *val, size_t len) +static int sx1301_write_burst(struct sx1301_priv *priv, u8 reg, const u8 *val, size_t len) { u8 addr = reg | BIT(7); struct spi_transfer xfr[2] = { @@ -98,26 +100,25 @@ static int sx1301_write_burst(struct spi_device *spi, u8 reg, const u8 *val, siz { .tx_buf = val, .len = len }, }; - return spi_sync_transfer(spi, xfr, 2); + return spi_sync_transfer(priv->spi, xfr, 2); } -static int sx1301_write(struct spi_device *spi, u8 reg, u8 val) +static int sx1301_write(struct sx1301_priv *priv, u8 reg, u8 val) { - return sx1301_write_burst(spi, reg, &val, 1); + return sx1301_write_burst(priv, reg, &val, 1); } -static int sx1301_page_switch(struct spi_device *spi, u8 page) +static int sx1301_page_switch(struct sx1301_priv *priv, u8 page) { - struct sx1301_priv *priv = spi_get_drvdata(spi); int ret; if (priv->cur_page == page) return 0; - dev_dbg(&spi->dev, "switching to page %u\n", (unsigned)page); - ret = sx1301_write(spi, REG_PAGE_RESET, page & 0x3); + dev_dbg(priv->dev, "switching to page %u\n", (unsigned)page); + ret = sx1301_write(priv, REG_PAGE_RESET, page & 0x3); if (ret) { - dev_err(&spi->dev, "switching to page %u failed\n", (unsigned)page); + dev_err(priv->dev, "switching to page %u failed\n", (unsigned)page); return ret; } @@ -126,31 +127,31 @@ static int sx1301_page_switch(struct spi_device *spi, u8 page) return 0; } -static int sx1301_page_read(struct spi_device *spi, u8 page, u8 reg, u8 *val) +static int sx1301_page_read(struct sx1301_priv *priv, u8 page, u8 reg, u8 *val) { int ret; - ret = sx1301_page_switch(spi, page); + ret = sx1301_page_switch(priv, page); if (ret) return ret; - return sx1301_read(spi, reg, val); + return sx1301_read(priv, reg, val); } -static int sx1301_page_write(struct spi_device *spi, u8 page, u8 reg, u8 val) +static int sx1301_page_write(struct sx1301_priv *priv, u8 page, u8 reg, u8 val) { int ret; - ret = sx1301_page_switch(spi, page); + ret = sx1301_page_switch(priv, page); if (ret) return ret; - return sx1301_write(spi, reg, val); + return sx1301_write(priv, reg, val); } -static int sx1301_soft_reset(struct spi_device *spi) +static int sx1301_soft_reset(struct sx1301_priv *priv) { - return sx1301_write(spi, REG_PAGE_RESET, REG_PAGE_RESET_SOFT_RESET); + return sx1301_write(priv, REG_PAGE_RESET, REG_PAGE_RESET_SOFT_RESET); } #define REG_RADIO_X_DATA 0 @@ -161,12 +162,13 @@ static int sx1301_soft_reset(struct spi_device *spi) static int sx1301_radio_set_cs(struct spi_controller *ctrl, bool enable) { struct spi_sx1301 *ssx = spi_controller_get_devdata(ctrl); + struct sx1301_priv *priv = spi_get_drvdata(ssx->parent); u8 cs; int ret; dev_dbg(&ctrl->dev, "setting CS to %s\n", enable ? "1" : "0"); - ret = sx1301_page_read(ssx->parent, ssx->page, ssx->regs + REG_RADIO_X_CS, &cs); + ret = sx1301_page_read(priv, ssx->page, ssx->regs + REG_RADIO_X_CS, &cs); if (ret) { dev_warn(&ctrl->dev, "failed to read CS (%d)\n", ret); cs = 0; @@ -177,7 +179,7 @@ static int sx1301_radio_set_cs(struct spi_controller *ctrl, bool enable) else cs &= ~BIT(0); - ret = sx1301_page_write(ssx->parent, ssx->page, ssx->regs + REG_RADIO_X_CS, cs); + ret = sx1301_page_write(priv, ssx->page, ssx->regs + REG_RADIO_X_CS, cs); if (ret) { dev_err(&ctrl->dev, "failed to write CS (%d)\n", ret); return ret; @@ -200,6 +202,7 @@ static int sx1301_radio_spi_transfer_one(struct spi_controller *ctrl, struct spi_device *spi, struct spi_transfer *xfr) { struct spi_sx1301 *ssx = spi_controller_get_devdata(ctrl); + struct sx1301_priv *priv = spi_get_drvdata(ssx->parent); const u8 *tx_buf = xfr->tx_buf; u8 *rx_buf = xfr->rx_buf; int ret; @@ -210,13 +213,13 @@ static int sx1301_radio_spi_transfer_one(struct spi_controller *ctrl, dev_dbg(&spi->dev, "transferring one (%u)\n", xfr->len); if (tx_buf) { - ret = sx1301_page_write(ssx->parent, ssx->page, ssx->regs + REG_RADIO_X_ADDR, tx_buf ? tx_buf[0] : 0); + ret = sx1301_page_write(priv, ssx->page, ssx->regs + REG_RADIO_X_ADDR, tx_buf ? tx_buf[0] : 0); if (ret) { dev_err(&spi->dev, "SPI radio address write failed\n"); return ret; } - ret = sx1301_page_write(ssx->parent, ssx->page, ssx->regs + REG_RADIO_X_DATA, (tx_buf && xfr->len >= 2) ? tx_buf[1] : 0); + ret = sx1301_page_write(priv, ssx->page, ssx->regs + REG_RADIO_X_DATA, (tx_buf && xfr->len >= 2) ? tx_buf[1] : 0); if (ret) { dev_err(&spi->dev, "SPI radio data write failed\n"); return ret; @@ -236,7 +239,7 @@ static int sx1301_radio_spi_transfer_one(struct spi_controller *ctrl, } if (rx_buf) { - ret = sx1301_page_read(ssx->parent, ssx->page, ssx->regs + REG_RADIO_X_DATA_READBACK, &rx_buf[xfr->len - 1]); + ret = sx1301_page_read(priv, ssx->page, ssx->regs + REG_RADIO_X_DATA_READBACK, &rx_buf[xfr->len - 1]); if (ret) { dev_err(&spi->dev, "SPI radio data read failed\n"); return ret; @@ -246,45 +249,45 @@ static int sx1301_radio_spi_transfer_one(struct spi_controller *ctrl, return 0; } -static int sx1301_agc_ram_read(struct spi_device *spi, u8 addr, u8 *val) +static int sx1301_agc_ram_read(struct sx1301_priv *priv, u8 addr, u8 *val) { int ret; - ret = sx1301_page_write(spi, 2, REG_2_DBG_AGC_MCU_RAM_ADDR, addr); + ret = sx1301_page_write(priv, 2, REG_2_DBG_AGC_MCU_RAM_ADDR, addr); if (ret) { - dev_err(&spi->dev, "AGC RAM addr write failed\n"); + dev_err(priv->dev, "AGC RAM addr write failed\n"); return ret; } - ret = sx1301_page_read(spi, 2, REG_2_DBG_AGC_MCU_RAM_DATA, val); + ret = sx1301_page_read(priv, 2, REG_2_DBG_AGC_MCU_RAM_DATA, val); if (ret) { - dev_err(&spi->dev, "AGC RAM data read failed\n"); + dev_err(priv->dev, "AGC RAM data read failed\n"); return ret; } return 0; } -static int sx1301_arb_ram_read(struct spi_device *spi, u8 addr, u8 *val) +static int sx1301_arb_ram_read(struct sx1301_priv *priv, u8 addr, u8 *val) { int ret; - ret = sx1301_page_write(spi, 2, REG_2_DBG_ARB_MCU_RAM_ADDR, addr); + ret = sx1301_page_write(priv, 2, REG_2_DBG_ARB_MCU_RAM_ADDR, addr); if (ret) { - dev_err(&spi->dev, "ARB RAM addr write failed\n"); + dev_err(priv->dev, "ARB RAM addr write failed\n"); return ret; } - ret = sx1301_page_read(spi, 2, REG_2_DBG_ARB_MCU_RAM_DATA, val); + ret = sx1301_page_read(priv, 2, REG_2_DBG_ARB_MCU_RAM_DATA, val); if (ret) { - dev_err(&spi->dev, "ARB RAM data read failed\n"); + dev_err(priv->dev, "ARB RAM data read failed\n"); return ret; } return 0; } -static int sx1301_load_firmware(struct spi_device *spi, int mcu, const u8 *data, size_t len) +static int sx1301_load_firmware(struct sx1301_priv *priv, int mcu, const u8 *data, size_t len) { u8 *buf; u8 val, rst, select_mux; @@ -306,36 +309,36 @@ static int sx1301_load_firmware(struct spi_device *spi, int mcu, const u8 *data, return -EINVAL; } - ret = sx1301_page_read(spi, 0, REG_0_MCU, &val); + ret = sx1301_page_read(priv, 0, REG_0_MCU, &val); if (ret) { - dev_err(&spi->dev, "MCU read failed\n"); + dev_err(priv->dev, "MCU read failed\n"); return ret; } val |= rst; val &= ~select_mux; - ret = sx1301_page_write(spi, 0, REG_0_MCU, val); + ret = sx1301_page_write(priv, 0, REG_0_MCU, val); if (ret) { - dev_err(&spi->dev, "MCU reset / select mux write failed\n"); + dev_err(priv->dev, "MCU reset / select mux write failed\n"); return ret; } - ret = sx1301_write(spi, REG_MCU_PROM_ADDR, 0); + ret = sx1301_write(priv, REG_MCU_PROM_ADDR, 0); if (ret) { - dev_err(&spi->dev, "MCU prom addr write failed\n"); + dev_err(priv->dev, "MCU prom addr write failed\n"); return ret; } - ret = sx1301_write_burst(spi, REG_MCU_PROM_DATA, data, len); + ret = sx1301_write_burst(priv, REG_MCU_PROM_DATA, data, len); if (ret) { - dev_err(&spi->dev, "MCU prom data write failed\n"); + dev_err(priv->dev, "MCU prom data write failed\n"); return ret; } - ret = sx1301_read(spi, REG_MCU_PROM_DATA, &val); + ret = sx1301_read(priv, REG_MCU_PROM_DATA, &val); if (ret) { - dev_err(&spi->dev, "MCU prom data dummy read failed\n"); + dev_err(priv->dev, "MCU prom data dummy read failed\n"); return ret; } @@ -343,73 +346,73 @@ static int sx1301_load_firmware(struct spi_device *spi, int mcu, const u8 *data, if (!buf) return -ENOMEM; - ret = sx1301_read_burst(spi, REG_MCU_PROM_DATA, buf, len); + ret = sx1301_read_burst(priv, REG_MCU_PROM_DATA, buf, len); if (ret) { - dev_err(&spi->dev, "MCU prom data read failed\n"); + dev_err(priv->dev, "MCU prom data read failed\n"); kfree(buf); return ret; } if (memcmp(data, buf, len)) { - dev_err(&spi->dev, "MCU prom data read does not match data written\n"); + dev_err(priv->dev, "MCU prom data read does not match data written\n"); kfree(buf); return -ENXIO; } kfree(buf); - ret = sx1301_page_read(spi, 0, REG_0_MCU, &val); + ret = sx1301_page_read(priv, 0, REG_0_MCU, &val); if (ret) { - dev_err(&spi->dev, "MCU read (1) failed\n"); + dev_err(priv->dev, "MCU read (1) failed\n"); return ret; } val |= select_mux; - ret = sx1301_page_write(spi, 0, REG_0_MCU, val); + ret = sx1301_page_write(priv, 0, REG_0_MCU, val); if (ret) { - dev_err(&spi->dev, "MCU reset / select mux write (1) failed\n"); + dev_err(priv->dev, "MCU reset / select mux write (1) failed\n"); return ret; } return 0; } -static int sx1301_agc_calibrate(struct spi_device *spi) +static int sx1301_agc_calibrate(struct sx1301_priv *priv) { const struct firmware *fw; u8 val; int ret; - ret = request_firmware(&fw, "sx1301_agc_calibration.bin", &spi->dev); + ret = request_firmware(&fw, "sx1301_agc_calibration.bin", priv->dev); if (ret) { - dev_err(&spi->dev, "agc cal firmware file load failed\n"); + dev_err(priv->dev, "agc cal firmware file load failed\n"); return ret; } if (fw->size != 8192) { - dev_err(&spi->dev, "unexpected agc cal firmware size\n"); + dev_err(priv->dev, "unexpected agc cal firmware size\n"); return -EINVAL; } - ret = sx1301_load_firmware(spi, 1, fw->data, fw->size); + ret = sx1301_load_firmware(priv, 1, fw->data, fw->size); release_firmware(fw); if (ret) { - dev_err(&spi->dev, "agc cal firmware load failed\n"); + dev_err(priv->dev, "agc cal firmware load failed\n"); return ret; } - ret = sx1301_page_read(spi, 0, 105, &val); + ret = sx1301_page_read(priv, 0, 105, &val); if (ret) { - dev_err(&spi->dev, "0|105 read failed\n"); + dev_err(priv->dev, "0|105 read failed\n"); return ret; } val &= ~REG_0_105_FORCE_HOST_RADIO_CTRL; - ret = sx1301_page_write(spi, 0, 105, val); + ret = sx1301_page_write(priv, 0, 105, val); if (ret) { - dev_err(&spi->dev, "0|105 write failed\n"); + dev_err(priv->dev, "0|105 write failed\n"); return ret; } @@ -417,188 +420,188 @@ static int sx1301_agc_calibrate(struct spi_device *spi) if (false) val |= BIT(5); /* SX1255 */ - ret = sx1301_page_write(spi, 0, REG_0_RADIO_SELECT, val); + ret = sx1301_page_write(priv, 0, REG_0_RADIO_SELECT, val); if (ret) { - dev_err(&spi->dev, "radio select write failed\n"); + dev_err(priv->dev, "radio select write failed\n"); return ret; } - ret = sx1301_page_read(spi, 0, REG_0_MCU, &val); + ret = sx1301_page_read(priv, 0, REG_0_MCU, &val); if (ret) { - dev_err(&spi->dev, "MCU read (0) failed\n"); + dev_err(priv->dev, "MCU read (0) failed\n"); return ret; } val &= ~REG_0_MCU_RST_1; - ret = sx1301_page_write(spi, 0, REG_0_MCU, val); + ret = sx1301_page_write(priv, 0, REG_0_MCU, val); if (ret) { - dev_err(&spi->dev, "MCU write (0) failed\n"); + dev_err(priv->dev, "MCU write (0) failed\n"); return ret; } - ret = sx1301_agc_ram_read(spi, 0x20, &val); + ret = sx1301_agc_ram_read(priv, 0x20, &val); if (ret) { - dev_err(&spi->dev, "AGC RAM data read failed\n"); + dev_err(priv->dev, "AGC RAM data read failed\n"); return ret; } - dev_info(&spi->dev, "AGC calibration firmware version %u\n", (unsigned)val); + dev_info(priv->dev, "AGC calibration firmware version %u\n", (unsigned)val); if (val != 2) { - dev_err(&spi->dev, "unexpected firmware version, expecting %u\n", 2); + dev_err(priv->dev, "unexpected firmware version, expecting %u\n", 2); return -ENXIO; } - ret = sx1301_page_switch(spi, 3); + ret = sx1301_page_switch(priv, 3); if (ret) { - dev_err(&spi->dev, "page switch 3 failed\n"); + dev_err(priv->dev, "page switch 3 failed\n"); return ret; } - ret = sx1301_read(spi, REG_EMERGENCY_FORCE, &val); + ret = sx1301_read(priv, REG_EMERGENCY_FORCE, &val); if (ret) { - dev_err(&spi->dev, "emergency force read failed\n"); + dev_err(priv->dev, "emergency force read failed\n"); return ret; } val &= ~REG_EMERGENCY_FORCE_HOST_CTRL; - ret = sx1301_write(spi, REG_EMERGENCY_FORCE, val); + ret = sx1301_write(priv, REG_EMERGENCY_FORCE, val); if (ret) { - dev_err(&spi->dev, "emergency force write failed\n"); + dev_err(priv->dev, "emergency force write failed\n"); return ret; } - dev_err(&spi->dev, "starting calibration...\n"); + dev_err(priv->dev, "starting calibration...\n"); msleep(2300); - ret = sx1301_read(spi, REG_EMERGENCY_FORCE, &val); + ret = sx1301_read(priv, REG_EMERGENCY_FORCE, &val); if (ret) { - dev_err(&spi->dev, "emergency force read (1) failed\n"); + dev_err(priv->dev, "emergency force read (1) failed\n"); return ret; } val |= REG_EMERGENCY_FORCE_HOST_CTRL; - ret = sx1301_write(spi, REG_EMERGENCY_FORCE, val); + ret = sx1301_write(priv, REG_EMERGENCY_FORCE, val); if (ret) { - dev_err(&spi->dev, "emergency force write (1) failed\n"); + dev_err(priv->dev, "emergency force write (1) failed\n"); return ret; } - ret = sx1301_read(spi, REG_MCU_AGC_STATUS, &val); + ret = sx1301_read(priv, REG_MCU_AGC_STATUS, &val); if (ret) { - dev_err(&spi->dev, "AGC status read failed\n"); + dev_err(priv->dev, "AGC status read failed\n"); return ret; } - dev_info(&spi->dev, "AGC status: %02x\n", (unsigned)val); + dev_info(priv->dev, "AGC status: %02x\n", (unsigned)val); if ((val & (BIT(7) | BIT(0))) != (BIT(7) | BIT(0))) { - dev_err(&spi->dev, "AGC calibration failed\n"); + dev_err(priv->dev, "AGC calibration failed\n"); return -ENXIO; } return 0; } -static int sx1301_load_all_firmware(struct spi_device *spi) +static int sx1301_load_all_firmware(struct sx1301_priv *priv) { const struct firmware *fw; u8 val; int ret; - ret = request_firmware(&fw, "sx1301_arb.bin", &spi->dev); + ret = request_firmware(&fw, "sx1301_arb.bin", priv->dev); if (ret) { - dev_err(&spi->dev, "arb firmware file load failed\n"); + dev_err(priv->dev, "arb firmware file load failed\n"); return ret; } if (fw->size != 8192) { - dev_err(&spi->dev, "unexpected arb firmware size\n"); + dev_err(priv->dev, "unexpected arb firmware size\n"); release_firmware(fw); return -EINVAL; } - ret = sx1301_load_firmware(spi, 0, fw->data, fw->size); + ret = sx1301_load_firmware(priv, 0, fw->data, fw->size); release_firmware(fw); if (ret) return ret; - ret = request_firmware(&fw, "sx1301_agc.bin", &spi->dev); + ret = request_firmware(&fw, "sx1301_agc.bin", priv->dev); if (ret) { - dev_err(&spi->dev, "agc firmware file load failed\n"); + dev_err(priv->dev, "agc firmware file load failed\n"); return ret; } if (fw->size != 8192) { - dev_err(&spi->dev, "unexpected agc firmware size\n"); + dev_err(priv->dev, "unexpected agc firmware size\n"); release_firmware(fw); return -EINVAL; } - ret = sx1301_load_firmware(spi, 1, fw->data, fw->size); + ret = sx1301_load_firmware(priv, 1, fw->data, fw->size); release_firmware(fw); if (ret) return ret; - ret = sx1301_page_read(spi, 0, 105, &val); + ret = sx1301_page_read(priv, 0, 105, &val); if (ret) { - dev_err(&spi->dev, "0|105 read failed\n"); + dev_err(priv->dev, "0|105 read failed\n"); return ret; } val &= ~(REG_0_105_FORCE_HOST_RADIO_CTRL | REG_0_105_FORCE_HOST_FE_CTRL | REG_0_105_FORCE_DEC_FILTER_GAIN); - ret = sx1301_page_write(spi, 0, 105, val); + ret = sx1301_page_write(priv, 0, 105, val); if (ret) { - dev_err(&spi->dev, "0|105 write failed\n"); + dev_err(priv->dev, "0|105 write failed\n"); return ret; } - ret = sx1301_page_write(spi, 0, REG_0_RADIO_SELECT, 0); + ret = sx1301_page_write(priv, 0, REG_0_RADIO_SELECT, 0); if (ret) { - dev_err(&spi->dev, "radio select write failed\n"); + dev_err(priv->dev, "radio select write failed\n"); return ret; } - ret = sx1301_page_read(spi, 0, REG_0_MCU, &val); + ret = sx1301_page_read(priv, 0, REG_0_MCU, &val); if (ret) { - dev_err(&spi->dev, "MCU read (0) failed\n"); + dev_err(priv->dev, "MCU read (0) failed\n"); return ret; } val &= ~(REG_0_MCU_RST_1 | REG_0_MCU_RST_0); - ret = sx1301_page_write(spi, 0, REG_0_MCU, val); + ret = sx1301_page_write(priv, 0, REG_0_MCU, val); if (ret) { - dev_err(&spi->dev, "MCU write (0) failed\n"); + dev_err(priv->dev, "MCU write (0) failed\n"); return ret; } - ret = sx1301_agc_ram_read(spi, 0x20, &val); + ret = sx1301_agc_ram_read(priv, 0x20, &val); if (ret) { - dev_err(&spi->dev, "AGC RAM data read failed\n"); + dev_err(priv->dev, "AGC RAM data read failed\n"); return ret; } - dev_info(&spi->dev, "AGC firmware version %u\n", (unsigned)val); + dev_info(priv->dev, "AGC firmware version %u\n", (unsigned)val); if (val != 4) { - dev_err(&spi->dev, "unexpected firmware version, expecting %u\n", 4); + dev_err(priv->dev, "unexpected firmware version, expecting %u\n", 4); return -ENXIO; } - ret = sx1301_arb_ram_read(spi, 0x20, &val); + ret = sx1301_arb_ram_read(priv, 0x20, &val); if (ret) { - dev_err(&spi->dev, "ARB RAM data read failed\n"); + dev_err(priv->dev, "ARB RAM data read failed\n"); return ret; } - dev_info(&spi->dev, "ARB firmware version %u\n", (unsigned)val); + dev_info(priv->dev, "ARB firmware version %u\n", (unsigned)val); if (val != 1) { - dev_err(&spi->dev, "unexpected firmware version, expecting %u\n", 1); + dev_err(priv->dev, "unexpected firmware version, expecting %u\n", 1); return -ENXIO; } @@ -635,17 +638,6 @@ static int sx1301_probe(struct spi_device *spi) spi->bits_per_word = 8; spi_setup(spi); - ret = sx1301_read(spi, REG_VERSION, &val); - if (ret) { - dev_err(&spi->dev, "version read failed\n"); - return ret; - } - - if (val != 103) { - dev_err(&spi->dev, "unexpected version: %u\n", val); - return -ENXIO; - } - netdev = devm_alloc_loradev(&spi->dev, sizeof(*priv)); if (!netdev) return -ENOMEM; @@ -654,22 +646,35 @@ static int sx1301_probe(struct spi_device *spi) priv->rst_gpio = rst; priv->cur_page = 0xff; - spi_set_drvdata(spi, netdev); + spi_set_drvdata(spi, priv); + priv->dev = &spi->dev; + priv->spi = spi; SET_NETDEV_DEV(netdev, &spi->dev); - ret = sx1301_write(spi, REG_PAGE_RESET, 0); + ret = sx1301_read(priv, REG_VERSION, &val); + if (ret) { + dev_err(&spi->dev, "version read failed\n"); + return ret; + } + + if (val != 103) { + dev_err(&spi->dev, "unexpected version: %u\n", val); + return -ENXIO; + } + + ret = sx1301_write(priv, REG_PAGE_RESET, 0); if (ret) { dev_err(&spi->dev, "page/reset write failed\n"); return ret; } - ret = sx1301_soft_reset(spi); + ret = sx1301_soft_reset(priv); if (ret) { dev_err(&spi->dev, "soft reset failed\n"); return ret; } - ret = sx1301_read(spi, 16, &val); + ret = sx1301_read(priv, 16, &val); if (ret) { dev_err(&spi->dev, "16 read failed\n"); return ret; @@ -677,13 +682,13 @@ static int sx1301_probe(struct spi_device *spi) val &= ~REG_16_GLOBAL_EN; - ret = sx1301_write(spi, 16, val); + ret = sx1301_write(priv, 16, val); if (ret) { dev_err(&spi->dev, "16 write failed\n"); return ret; } - ret = sx1301_read(spi, 17, &val); + ret = sx1301_read(priv, 17, &val); if (ret) { dev_err(&spi->dev, "17 read failed\n"); return ret; @@ -691,13 +696,13 @@ static int sx1301_probe(struct spi_device *spi) val &= ~REG_17_CLK32M_EN; - ret = sx1301_write(spi, 17, val); + ret = sx1301_write(priv, 17, val); if (ret) { dev_err(&spi->dev, "17 write failed\n"); return ret; } - ret = sx1301_page_read(spi, 2, 43, &val); + ret = sx1301_page_read(priv, 2, 43, &val); if (ret) { dev_err(&spi->dev, "2|43 read failed\n"); return ret; @@ -705,7 +710,7 @@ static int sx1301_probe(struct spi_device *spi) val |= REG_2_43_RADIO_B_EN | REG_2_43_RADIO_A_EN; - ret = sx1301_page_write(spi, 2, 43, val); + ret = sx1301_page_write(priv, 2, 43, val); if (ret) { dev_err(&spi->dev, "2|43 write failed\n"); return ret; @@ -713,7 +718,7 @@ static int sx1301_probe(struct spi_device *spi) msleep(500); - ret = sx1301_page_read(spi, 2, 43, &val); + ret = sx1301_page_read(priv, 2, 43, &val); if (ret) { dev_err(&spi->dev, "2|43 read failed\n"); return ret; @@ -721,7 +726,7 @@ static int sx1301_probe(struct spi_device *spi) val |= REG_2_43_RADIO_RST; - ret = sx1301_page_write(spi, 2, 43, val); + ret = sx1301_page_write(priv, 2, 43, val); if (ret) { dev_err(&spi->dev, "2|43 write failed\n"); return ret; @@ -729,7 +734,7 @@ static int sx1301_probe(struct spi_device *spi) msleep(5); - ret = sx1301_page_read(spi, 2, 43, &val); + ret = sx1301_page_read(priv, 2, 43, &val); if (ret) { dev_err(&spi->dev, "2|43 read failed\n"); return ret; @@ -737,7 +742,7 @@ static int sx1301_probe(struct spi_device *spi) val &= ~REG_2_43_RADIO_RST; - ret = sx1301_page_write(spi, 2, 43, val); + ret = sx1301_page_write(priv, 2, 43, val); if (ret) { dev_err(&spi->dev, "2|43 write failed\n"); return ret; @@ -789,7 +794,7 @@ static int sx1301_probe(struct spi_device *spi) /* GPIO */ - ret = sx1301_read(spi, REG_GPIO_MODE, &val); + ret = sx1301_read(priv, REG_GPIO_MODE, &val); if (ret) { dev_err(&spi->dev, "GPIO mode read failed\n"); return ret; @@ -797,13 +802,13 @@ static int sx1301_probe(struct spi_device *spi) val |= GENMASK(4, 0); - ret = sx1301_write(spi, REG_GPIO_MODE, val); + ret = sx1301_write(priv, REG_GPIO_MODE, val); if (ret) { dev_err(&spi->dev, "GPIO mode write failed\n"); return ret; } - ret = sx1301_read(spi, REG_GPIO_SELECT_OUTPUT, &val); + ret = sx1301_read(priv, REG_GPIO_SELECT_OUTPUT, &val); if (ret) { dev_err(&spi->dev, "GPIO select output read failed\n"); return ret; @@ -812,7 +817,7 @@ static int sx1301_probe(struct spi_device *spi) val &= ~GENMASK(3, 0); val |= 2; - ret = sx1301_write(spi, REG_GPIO_SELECT_OUTPUT, val); + ret = sx1301_write(priv, REG_GPIO_SELECT_OUTPUT, val); if (ret) { dev_err(&spi->dev, "GPIO select output write failed\n"); return ret; @@ -820,7 +825,7 @@ static int sx1301_probe(struct spi_device *spi) /* TODO LBT */ - ret = sx1301_read(spi, 16, &val); + ret = sx1301_read(priv, 16, &val); if (ret) { dev_err(&spi->dev, "16 read (1) failed\n"); return ret; @@ -828,13 +833,13 @@ static int sx1301_probe(struct spi_device *spi) val |= REG_16_GLOBAL_EN; - ret = sx1301_write(spi, 16, val); + ret = sx1301_write(priv, 16, val); if (ret) { dev_err(&spi->dev, "16 write (1) failed\n"); return ret; } - ret = sx1301_read(spi, 17, &val); + ret = sx1301_read(priv, 17, &val); if (ret) { dev_err(&spi->dev, "17 read (1) failed\n"); return ret; @@ -842,7 +847,7 @@ static int sx1301_probe(struct spi_device *spi) val |= REG_17_CLK32M_EN; - ret = sx1301_write(spi, 17, val); + ret = sx1301_write(priv, 17, val); if (ret) { dev_err(&spi->dev, "17 write (1) failed\n"); return ret; @@ -850,13 +855,13 @@ static int sx1301_probe(struct spi_device *spi) /* calibration */ - ret = sx1301_agc_calibrate(spi); + ret = sx1301_agc_calibrate(priv); if (ret) return ret; /* TODO */ - ret = sx1301_load_all_firmware(spi); + ret = sx1301_load_all_firmware(priv); if (ret) return ret; From patchwork Thu Aug 9 12:33:34 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ben Whitten X-Patchwork-Id: 955526 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=fail (p=none dis=none) header.from=gmail.com Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.b="ORdZWrW+"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 41mSPW6lS0z9ryt for ; Thu, 9 Aug 2018 22:34:39 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1731218AbeHIO7T (ORCPT ); Thu, 9 Aug 2018 10:59:19 -0400 Received: from mail-wr1-f68.google.com ([209.85.221.68]:34067 "EHLO mail-wr1-f68.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727786AbeHIO7S (ORCPT ); Thu, 9 Aug 2018 10:59:18 -0400 Received: by mail-wr1-f68.google.com with SMTP id c13-v6so5034437wrt.1 for ; Thu, 09 Aug 2018 05:34:36 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=sender:from:to:cc:subject:date:message-id:in-reply-to:references; bh=h2lgkQ++UiCJLB3HqDM3Zel4Yy0OPkjc76rMhKD8An4=; b=ORdZWrW+87dE3/3IJkDLsbdfDjewxb7b2SARazxZ+ETbQ8XPjht4C0HXvSLFZIiJ8T /5JZcNrLXtdH5zp+ETl559T16RMpxPEBDVvdZUH7XTffVfTk1E532sHerCmrY7S1wdup 6NclhTWHMVaNa5chHSDKelNig9thxLHpDdsYsldaMDF24FGdO+ykEvxti2kNmYpIk1CE /Gb7OnVLv5LYTkZtts2dngkS6dEMMScqnojiHcOOgud54auScZbE/G3D2Iluo7u7l9ZT M7fBDXl5LQAoW1U2hcnRcdDNfG1LolgyzQgtMcxIFKZRkXbilCQIm9FTs360eoAyyAKG HaFA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:from:to:cc:subject:date:message-id :in-reply-to:references; bh=h2lgkQ++UiCJLB3HqDM3Zel4Yy0OPkjc76rMhKD8An4=; b=O4dkr3Z9izgCdB06bG15FtZm61Znn/OPucD2bClJcptLWBjzBA4VRsSsdnhLmUM2Rc 4T+qr1bQCBV0LhMziLXt1KRf5MxjJDj/1uok+XvEdr+Udko/pub58Jv1IMC+hliCIKEO IW73cnv8Q2uWnOi2gHMF0ig9Fm2AOkJvKbe+7CECYDFyod6w+2Z8+3QPQg070lwJMrbi N6ial2hgFtA6w45e4c8dPtZBCHVDTfE4q7/TFj5T4voFDASOsjjNcXZWvu+Dqp/bu9B0 PJ4qkO5QAA11yT2vIFbNBXGTy/nKgSTQZ45VWTAHGWvPuO0sW585VVf0aAJij9LjfLfY A04g== X-Gm-Message-State: AOUpUlFmzOgaisG7X/A02XtMouCUru4M2CpMqpkTwzOI6F1AQQuGEZMn +T06R1u+KDo92MDhKih1COY= X-Google-Smtp-Source: AA+uWPwZm0C6jeCjVbcL0B6TCOOBz1kJEP2Bdshbc0+7oEdsWI1bVvKHp1MqWbHse6GaqLvHxBSqFw== X-Received: by 2002:a5d:6a03:: with SMTP id m3-v6mr1300100wru.192.1533818075803; Thu, 09 Aug 2018 05:34:35 -0700 (PDT) Received: from Sarah.corp.lairdtech.com ([109.174.151.67]) by smtp.gmail.com with ESMTPSA id g125-v6sm8596848wmf.16.2018.08.09.05.34.34 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Thu, 09 Aug 2018 05:34:34 -0700 (PDT) From: Ben Whitten X-Google-Original-From: Ben Whitten To: afaerber@suse.de Cc: starnight@g.ncu.edu.tw, hasnain.virk@arm.com, netdev@vger.kernel.org, liuxuenetmail@gmail.com, shess@hessware.de, Ben Whitten Subject: [PATCH lora-next v2 4/8] net: lora: sx1301: convert load_firmware to take firmware directly Date: Thu, 9 Aug 2018 13:33:34 +0100 Message-Id: <1533818018-29005-4-git-send-email-ben.whitten@lairdtech.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1533818018-29005-1-git-send-email-ben.whitten@lairdtech.com> References: <1533818018-29005-1-git-send-email-ben.whitten@lairdtech.com> Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org We just pass the pointer to firmware down to the function that loads it. Signed-off-by: Ben Whitten --- drivers/net/lora/sx1301.c | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/drivers/net/lora/sx1301.c b/drivers/net/lora/sx1301.c index 7324001..3f2a532 100644 --- a/drivers/net/lora/sx1301.c +++ b/drivers/net/lora/sx1301.c @@ -287,13 +287,13 @@ static int sx1301_arb_ram_read(struct sx1301_priv *priv, u8 addr, u8 *val) return 0; } -static int sx1301_load_firmware(struct sx1301_priv *priv, int mcu, const u8 *data, size_t len) +static int sx1301_load_firmware(struct sx1301_priv *priv, int mcu, const struct firmware *fw) { u8 *buf; u8 val, rst, select_mux; int ret; - if (len > 8192) + if (fw->size > 8192) return -EINVAL; switch (mcu) { @@ -330,7 +330,7 @@ static int sx1301_load_firmware(struct sx1301_priv *priv, int mcu, const u8 *dat return ret; } - ret = sx1301_write_burst(priv, REG_MCU_PROM_DATA, data, len); + ret = sx1301_write_burst(priv, REG_MCU_PROM_DATA, fw->data, fw->size); if (ret) { dev_err(priv->dev, "MCU prom data write failed\n"); return ret; @@ -342,18 +342,18 @@ static int sx1301_load_firmware(struct sx1301_priv *priv, int mcu, const u8 *dat return ret; } - buf = kzalloc(len, GFP_KERNEL); + buf = kzalloc(fw->size, GFP_KERNEL); if (!buf) return -ENOMEM; - ret = sx1301_read_burst(priv, REG_MCU_PROM_DATA, buf, len); + ret = sx1301_read_burst(priv, REG_MCU_PROM_DATA, buf, fw->size); if (ret) { dev_err(priv->dev, "MCU prom data read failed\n"); kfree(buf); return ret; } - if (memcmp(data, buf, len)) { + if (memcmp(fw->data, buf, fw->size)) { dev_err(priv->dev, "MCU prom data read does not match data written\n"); kfree(buf); return -ENXIO; @@ -395,7 +395,7 @@ static int sx1301_agc_calibrate(struct sx1301_priv *priv) return -EINVAL; } - ret = sx1301_load_firmware(priv, 1, fw->data, fw->size); + ret = sx1301_load_firmware(priv, 1, fw); release_firmware(fw); if (ret) { dev_err(priv->dev, "agc cal firmware load failed\n"); @@ -523,7 +523,7 @@ static int sx1301_load_all_firmware(struct sx1301_priv *priv) return -EINVAL; } - ret = sx1301_load_firmware(priv, 0, fw->data, fw->size); + ret = sx1301_load_firmware(priv, 0, fw); release_firmware(fw); if (ret) return ret; @@ -540,7 +540,7 @@ static int sx1301_load_all_firmware(struct sx1301_priv *priv) return -EINVAL; } - ret = sx1301_load_firmware(priv, 1, fw->data, fw->size); + ret = sx1301_load_firmware(priv, 1, fw); release_firmware(fw); if (ret) return ret; From patchwork Thu Aug 9 12:33:35 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ben Whitten X-Patchwork-Id: 955527 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=fail (p=none dis=none) header.from=gmail.com Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.b="eXzh9wEM"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 41mSPX5XF6z9s1c for ; Thu, 9 Aug 2018 22:34:40 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1732301AbeHIO7U (ORCPT ); Thu, 9 Aug 2018 10:59:20 -0400 Received: from mail-wr1-f65.google.com ([209.85.221.65]:37188 "EHLO mail-wr1-f65.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1731095AbeHIO7U (ORCPT ); Thu, 9 Aug 2018 10:59:20 -0400 Received: by mail-wr1-f65.google.com with SMTP id u12-v6so5009623wrr.4 for ; Thu, 09 Aug 2018 05:34:37 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=sender:from:to:cc:subject:date:message-id:in-reply-to:references; bh=vUUZepHoEcyAPpt8ounDRiroB+wMRwa4vna1D0Pfyns=; b=eXzh9wEMS4kDDZhc6XrzQ26I6zssse2e6MhW8Zf0AetrhRJp9dWv3wKoj80UehNSA3 fFc7BxafxASX44w6ZV38qGUh7AvGsFLt2RLcCqX5g/y3alO1guzvG86klWwHqe0ggjhN zpBvdMO9QwKbJaKA7mX/Pw8fUQcM3YhITwVIqsqzs0zThmZGwZfR7K7bfS6sfnVwxbh2 uD5d0LF/7dXThWXuDZqoUIAlazd8t5FleUMUsHFFiH1bnY+ykBKq3Pms2i6mEo3tbAH9 X4XHG2RbTYSh/+RakudIGZESEonYOoW6E29X4kBhfbKNlOFiGyHKeCv434CBvsqVWdvS F2cw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:from:to:cc:subject:date:message-id :in-reply-to:references; bh=vUUZepHoEcyAPpt8ounDRiroB+wMRwa4vna1D0Pfyns=; b=Oq3fdaaC7Q/OsSufaxAjGW4IGxEpUV8Who1vD0WHnQ0jjPIQy7aqn7nRdX0DTeNk38 qL1dqo3iyG6MoXREM3mhvE/FCH37wm+neXBpWEL94WC7qN+2aqkRRiZFhAZAdhfVNtJu /3+R6oGksrGy/4E2uWXDYXLpj0LCc7m748IE2RPxExqDLOIqzZtXj1ceP56pQ5r7aA4V fuP/n9kqpNdB5QPrIjewXesY/G06vj32LTtPeLZKbqv9vB7/RrjGOGwzb+/fLdtTJkPh +jSox0ZpxPMb1WE8NK3KsNTk96O9u1xbcEobcIALRx3V2OH3CwirY1eMVsDRRoS+yB1d Tm/Q== X-Gm-Message-State: AOUpUlE61ti1rK7F7rKES8/6r3T7S0fK61T/VWUf1bSmTEOvo8RtKHWA f750ZEsTZKkZp0+s85d5vWM= X-Google-Smtp-Source: AA+uWPyYvf0jle8duW9MWStCOx+eXO1XxsGv54TfJ5kmQ6OMuxIitKNUkiXuMNnVSbIIcXgpvtVSOA== X-Received: by 2002:adf:ba12:: with SMTP id o18-v6mr1425256wrg.249.1533818077254; Thu, 09 Aug 2018 05:34:37 -0700 (PDT) Received: from Sarah.corp.lairdtech.com ([109.174.151.67]) by smtp.gmail.com with ESMTPSA id g125-v6sm8596848wmf.16.2018.08.09.05.34.35 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Thu, 09 Aug 2018 05:34:36 -0700 (PDT) From: Ben Whitten X-Google-Original-From: Ben Whitten To: afaerber@suse.de Cc: starnight@g.ncu.edu.tw, hasnain.virk@arm.com, netdev@vger.kernel.org, liuxuenetmail@gmail.com, shess@hessware.de, Ben Whitten Subject: [PATCH lora-next v2 5/8] net: lora: sx1301: remove duplicate firmware size checks Date: Thu, 9 Aug 2018 13:33:35 +0100 Message-Id: <1533818018-29005-5-git-send-email-ben.whitten@lairdtech.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1533818018-29005-1-git-send-email-ben.whitten@lairdtech.com> References: <1533818018-29005-1-git-send-email-ben.whitten@lairdtech.com> Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org No need to check the size of the firmware multiple times, just do it once in the function responsible for loading as the firmwares are the same size. Signed-off-by: Ben Whitten --- drivers/net/lora/sx1301.c | 21 +++------------------ 1 file changed, 3 insertions(+), 18 deletions(-) diff --git a/drivers/net/lora/sx1301.c b/drivers/net/lora/sx1301.c index 3f2a532..916ee40 100644 --- a/drivers/net/lora/sx1301.c +++ b/drivers/net/lora/sx1301.c @@ -293,8 +293,10 @@ static int sx1301_load_firmware(struct sx1301_priv *priv, int mcu, const struct u8 val, rst, select_mux; int ret; - if (fw->size > 8192) + if (fw->size != 8192) { + dev_err(priv->dev, "Unexpected firmware size\n"); return -EINVAL; + } switch (mcu) { case 0: @@ -390,11 +392,6 @@ static int sx1301_agc_calibrate(struct sx1301_priv *priv) return ret; } - if (fw->size != 8192) { - dev_err(priv->dev, "unexpected agc cal firmware size\n"); - return -EINVAL; - } - ret = sx1301_load_firmware(priv, 1, fw); release_firmware(fw); if (ret) { @@ -517,12 +514,6 @@ static int sx1301_load_all_firmware(struct sx1301_priv *priv) return ret; } - if (fw->size != 8192) { - dev_err(priv->dev, "unexpected arb firmware size\n"); - release_firmware(fw); - return -EINVAL; - } - ret = sx1301_load_firmware(priv, 0, fw); release_firmware(fw); if (ret) @@ -534,12 +525,6 @@ static int sx1301_load_all_firmware(struct sx1301_priv *priv) return ret; } - if (fw->size != 8192) { - dev_err(priv->dev, "unexpected agc firmware size\n"); - release_firmware(fw); - return -EINVAL; - } - ret = sx1301_load_firmware(priv, 1, fw); release_firmware(fw); if (ret) From patchwork Thu Aug 9 12:33:36 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ben Whitten X-Patchwork-Id: 955528 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=fail (p=none dis=none) header.from=gmail.com Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.b="a7OmjoGh"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 41mSPZ11XMz9s1x for ; Thu, 9 Aug 2018 22:34:42 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1732354AbeHIO7V (ORCPT ); Thu, 9 Aug 2018 10:59:21 -0400 Received: from mail-wm0-f65.google.com ([74.125.82.65]:39969 "EHLO mail-wm0-f65.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727786AbeHIO7V (ORCPT ); Thu, 9 Aug 2018 10:59:21 -0400 Received: by mail-wm0-f65.google.com with SMTP id y9-v6so108169wma.5 for ; Thu, 09 Aug 2018 05:34:39 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=sender:from:to:cc:subject:date:message-id:in-reply-to:references; bh=UEM/QaaFtKxoVa6SF6Al6ziDRq0SavRLHvC+hjR9jdc=; b=a7OmjoGhnSRb9Qcaa1wFQo3SVGQX4xsbMBu04GjYfVfJR1kVdAasQP6O+6SCeInL5d VARuyfyErF8eUULDlr3RLTAUSKpxykXQykjwE64jpToIQN7E37MIhRCFSOUZXG5uEtea Wx6luM5muSGeey3oU/7HF0Yq7PzczEAmuQnN+Fv65Iv/S638yNDVRuX5XpBvNOZhl8BS vtH9dc2JX1Ziwh3hVxaMmli7zs1AI9qRQKHGczUwEbaqUwojizao76ez+jlDkJfLEbBY EjcVWGOjTSpFpqS7T+ciey5e2XX9BCoa74DoV0eF9a4h9UpgP1VC3QDmUnbrF5lzXq6D QKvw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:from:to:cc:subject:date:message-id :in-reply-to:references; bh=UEM/QaaFtKxoVa6SF6Al6ziDRq0SavRLHvC+hjR9jdc=; b=LKP45OdU/iGFnVsGUC07tiI9HiIkIBsr9JplDXu8sC9ESOzDM4e2HQVrJ2o8JG86zI 7z2v8S4RR0ZQuJD+UjDWJRtyAsLgx0UAlXX33qpfzwFv6l46OpKlK55N5i7P80mAGHGS l+FdWAqqNjpVIO6ug3no7DstgvDP1v3ptoxtFwh6Lqn1TkAQpDVGG5lcCjonATTHoevB Q81oKQP/7wE6MNkoye2CBgV7mX+0aLX8c5uDqUKqEvxGqelj5NBT/AqXFIbrxI1p2LCv 0bSJKts53pI9tI+PeFlfSrqpYN1mTi4oYo2KeK+u2xVjAfBa/3BkZpQbYZCA4+z/sUKb 5+Pw== X-Gm-Message-State: AOUpUlFqizqn/UZyz1ui+M6BWShXCX7p/WPuKCejEoVgAASpuD4A3qzf 5LQO1HKk5Sv4CLyl8P5jEzs= X-Google-Smtp-Source: AA+uWPwVRVAQpduMQEpkTPPcvv9RzfymPEz7D3B2zBJcQqEvVYsP5dLeeW7qV5Ldg8+yveuQhmMTPA== X-Received: by 2002:a1c:cb87:: with SMTP id b129-v6mr1640707wmg.64.1533818078718; Thu, 09 Aug 2018 05:34:38 -0700 (PDT) Received: from Sarah.corp.lairdtech.com ([109.174.151.67]) by smtp.gmail.com with ESMTPSA id g125-v6sm8596848wmf.16.2018.08.09.05.34.37 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Thu, 09 Aug 2018 05:34:37 -0700 (PDT) From: Ben Whitten X-Google-Original-From: Ben Whitten To: afaerber@suse.de Cc: starnight@g.ncu.edu.tw, hasnain.virk@arm.com, netdev@vger.kernel.org, liuxuenetmail@gmail.com, shess@hessware.de, Ben Whitten Subject: [PATCH lora-next v2 6/8] net: lora: sx1301: replace version and size magic numbers with defines Date: Thu, 9 Aug 2018 13:33:36 +0100 Message-Id: <1533818018-29005-6-git-send-email-ben.whitten@lairdtech.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1533818018-29005-1-git-send-email-ben.whitten@lairdtech.com> References: <1533818018-29005-1-git-send-email-ben.whitten@lairdtech.com> Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org We replace the hard coded numbers for size and version with meaningful names. Signed-off-by: Ben Whitten --- drivers/net/lora/sx1301.c | 21 +++++++++++++-------- drivers/net/lora/sx1301.h | 18 ++++++++++++++++++ 2 files changed, 31 insertions(+), 8 deletions(-) create mode 100644 drivers/net/lora/sx1301.h diff --git a/drivers/net/lora/sx1301.c b/drivers/net/lora/sx1301.c index 916ee40..8e81179 100644 --- a/drivers/net/lora/sx1301.c +++ b/drivers/net/lora/sx1301.c @@ -21,6 +21,8 @@ #include #include +#include "sx1301.h" + #define REG_PAGE_RESET 0 #define REG_VERSION 1 #define REG_MCU_PROM_ADDR 9 @@ -293,7 +295,7 @@ static int sx1301_load_firmware(struct sx1301_priv *priv, int mcu, const struct u8 val, rst, select_mux; int ret; - if (fw->size != 8192) { + if (fw->size != SX1301_MCU_FW_BYTE) { dev_err(priv->dev, "Unexpected firmware size\n"); return -EINVAL; } @@ -445,8 +447,9 @@ static int sx1301_agc_calibrate(struct sx1301_priv *priv) dev_info(priv->dev, "AGC calibration firmware version %u\n", (unsigned)val); - if (val != 2) { - dev_err(priv->dev, "unexpected firmware version, expecting %u\n", 2); + if (val != SX1301_MCU_AGC_CAL_FW_VERSION) { + dev_err(priv->dev, "unexpected firmware version, expecting %u\n", + SX1301_MCU_AGC_CAL_FW_VERSION); return -ENXIO; } @@ -572,8 +575,9 @@ static int sx1301_load_all_firmware(struct sx1301_priv *priv) dev_info(priv->dev, "AGC firmware version %u\n", (unsigned)val); - if (val != 4) { - dev_err(priv->dev, "unexpected firmware version, expecting %u\n", 4); + if (val != SX1301_MCU_AGC_FW_VERSION) { + dev_err(priv->dev, "unexpected firmware version, expecting %u\n", + SX1301_MCU_AGC_FW_VERSION); return -ENXIO; } @@ -585,8 +589,9 @@ static int sx1301_load_all_firmware(struct sx1301_priv *priv) dev_info(priv->dev, "ARB firmware version %u\n", (unsigned)val); - if (val != 1) { - dev_err(priv->dev, "unexpected firmware version, expecting %u\n", 1); + if (val != SX1301_MCU_ARB_FW_VERSION) { + dev_err(priv->dev, "unexpected firmware version, expecting %u\n", + SX1301_MCU_ARB_FW_VERSION); return -ENXIO; } @@ -642,7 +647,7 @@ static int sx1301_probe(struct spi_device *spi) return ret; } - if (val != 103) { + if (val != SX1301_CHIP_VERSION) { dev_err(&spi->dev, "unexpected version: %u\n", val); return -ENXIO; } diff --git a/drivers/net/lora/sx1301.h b/drivers/net/lora/sx1301.h new file mode 100644 index 0000000..b37ac56 --- /dev/null +++ b/drivers/net/lora/sx1301.h @@ -0,0 +1,18 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * Semtech SX1301 lora concentrator + * + * Copyright (c) 2018 Ben Whitten + */ + +#ifndef _SX1301_ +#define _SX1301_ + +#define SX1301_CHIP_VERSION 103 + +#define SX1301_MCU_FW_BYTE 8192 +#define SX1301_MCU_ARB_FW_VERSION 1 +#define SX1301_MCU_AGC_FW_VERSION 4 +#define SX1301_MCU_AGC_CAL_FW_VERSION 2 + +#endif From patchwork Thu Aug 9 12:33:37 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ben Whitten X-Patchwork-Id: 955529 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=fail (p=none dis=none) header.from=gmail.com Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.b="nR6zPU9t"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 41mSPc1MMSz9ryt for ; Thu, 9 Aug 2018 22:34:44 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1732356AbeHIO7Y (ORCPT ); Thu, 9 Aug 2018 10:59:24 -0400 Received: from mail-wm0-f68.google.com ([74.125.82.68]:53787 "EHLO mail-wm0-f68.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727786AbeHIO7X (ORCPT ); Thu, 9 Aug 2018 10:59:23 -0400 Received: by mail-wm0-f68.google.com with SMTP id s9-v6so25983wmh.3 for ; Thu, 09 Aug 2018 05:34:40 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=sender:from:to:cc:subject:date:message-id:in-reply-to:references; bh=RnmZdXiKhaWEbhQwWhDK3SGMoDlBi6BmXDAZXutHTMo=; b=nR6zPU9tdDMkdf4qjAPDVSU/x+TFs34oZRNWrh0YKWWkgkBkIoVs29G/YMcAXkKr+M 9uMS/GLh+tFN7K0dfqZwgp2txaPhbXKwzPpiy7N1UjGE7Pl4fEIrME5ASYPkTtUhaiOb 9tSNCZ5i8e1H9pKYo706jjRC6JZiPb2280m2j8qjOX07fHYDmUzcFOVATVHJ6ZaUwNPw /fFKQIHsGyrXY2lMidkwRQSTZzv6R8Z6JaS4CqDsO4Hx5HHnqcrPRSk82jm76e65MV3Q pPKILDynbb2ruJAvciONZ7wRCXDWS0baIMVHkW/qusutPDDW6gjRxqbYmATiRTGD9CAF NNaQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:from:to:cc:subject:date:message-id :in-reply-to:references; bh=RnmZdXiKhaWEbhQwWhDK3SGMoDlBi6BmXDAZXutHTMo=; b=WE3HX3Y1ARLHWRwYnk6/sXy9uDBO8wbubcrVa1I51WHp3cV7r0SX+yw6s4bhjDsBm7 1sUMBRfupJrCtJeDHx+PC750gzQtb+xp55bN7i1qUBkCELw2YNQn3bShHfMQwTIghvHJ GqboXPmdKnQAeclJ9ry7+tdyRPsNHgLlWPYc3X+9qj+3smtzwhviIxdkcY6cP61ZvTq3 QqL7TPfPGYi8tr5kCp+nIUy4nlNnzMSFKF7x0Y4SmgMOrP1NLbuTafeWyoDE2NAenIDq JtCFnHhoCU3j8G2rx8eNI6bwpQQQC6+0BKfFc1rUcFXcEtHuEYWLKBb2IkCHeWDi7oHS k54Q== X-Gm-Message-State: AOUpUlGfKmhK0F9zvhY7GmZc1IRshoLlxgQ/LXQEGIkGUm8jzVcoAskz KMmbhfJcVkff18lMYJzi57Y= X-Google-Smtp-Source: AA+uWPynWj5hu3AJbMIGY6sCHZSkL8knKSJUkUFWv5a48hkewDLoI0XvqsEyxOTLEHIbyu5xJB+n9w== X-Received: by 2002:a1c:64d5:: with SMTP id y204-v6mr1502519wmb.14.1533818080148; Thu, 09 Aug 2018 05:34:40 -0700 (PDT) Received: from Sarah.corp.lairdtech.com ([109.174.151.67]) by smtp.gmail.com with ESMTPSA id g125-v6sm8596848wmf.16.2018.08.09.05.34.38 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Thu, 09 Aug 2018 05:34:39 -0700 (PDT) From: Ben Whitten X-Google-Original-From: Ben Whitten To: afaerber@suse.de Cc: starnight@g.ncu.edu.tw, hasnain.virk@arm.com, netdev@vger.kernel.org, liuxuenetmail@gmail.com, shess@hessware.de, Ben Whitten Subject: [PATCH lora-next v2 7/8] net: lora: sx1301: add initial registration for regmap Date: Thu, 9 Aug 2018 13:33:37 +0100 Message-Id: <1533818018-29005-7-git-send-email-ben.whitten@lairdtech.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1533818018-29005-1-git-send-email-ben.whitten@lairdtech.com> References: <1533818018-29005-1-git-send-email-ben.whitten@lairdtech.com> Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org The register and bit-field definitions are taken from the SX1301 datasheet version 2.01 dated June 2014 with the revision information 'First released version'. The reset state and RW capability of each field is not reflected in this patch however from the datasheet: "Bits and registers that are not documented are reserved. They may include calibration values. It is important not to modify these bits and registers. If specific bits must be changed in a register with reserved bits, the register must be read first, specific bits modified while masking reserved bits and then the register can be written." Then goes on to state: "Reserved bits should be written with their reset state, they may be read different states." Caching is currently disabled. The version is read back using regmap_read to verify regmap operation, in doing so needs to be moved after priv and regmap allocation. Further registers or fields are added as they are required in conversion. Signed-off-by: Ben Whitten --- drivers/net/lora/Kconfig | 1 + drivers/net/lora/sx1301.c | 46 ++++++++++++++++++++++++++++++++++++++++++---- drivers/net/lora/sx1301.h | 10 ++++++++++ 3 files changed, 53 insertions(+), 4 deletions(-) diff --git a/drivers/net/lora/Kconfig b/drivers/net/lora/Kconfig index bb57a01..79d23f2 100644 --- a/drivers/net/lora/Kconfig +++ b/drivers/net/lora/Kconfig @@ -49,6 +49,7 @@ config LORA_SX1301 tristate "Semtech SX1301 SPI driver" default y depends on SPI + select REGMAP_SPI help Semtech SX1301 diff --git a/drivers/net/lora/sx1301.c b/drivers/net/lora/sx1301.c index 8e81179..766df06 100644 --- a/drivers/net/lora/sx1301.c +++ b/drivers/net/lora/sx1301.c @@ -20,11 +20,11 @@ #include #include #include +#include #include "sx1301.h" #define REG_PAGE_RESET 0 -#define REG_VERSION 1 #define REG_MCU_PROM_ADDR 9 #define REG_MCU_PROM_DATA 10 #define REG_GPIO_SELECT_INPUT 27 @@ -68,6 +68,35 @@ #define REG_EMERGENCY_FORCE_HOST_CTRL BIT(0) +static const struct regmap_range_cfg sx1301_ranges[] = { + { + .name = "Pages", + + .range_min = SX1301_VIRT_BASE, + .range_max = SX1301_MAX_REGISTER, + + .selector_reg = SX1301_PAGE, + .selector_mask = 0x3, + + .window_start = 0, + .window_len = SX1301_PAGE_LEN, + }, +}; + +static struct regmap_config sx1301_regmap_config = { + .reg_bits = 8, + .val_bits = 8, + + .cache_type = REGCACHE_NONE, + + .read_flag_mask = 0, + .write_flag_mask = BIT(7), + + .ranges = sx1301_ranges, + .num_ranges = ARRAY_SIZE(sx1301_ranges), + .max_register = SX1301_MAX_REGISTER, +}; + struct spi_sx1301 { struct spi_device *parent; u8 page; @@ -81,6 +110,7 @@ struct sx1301_priv { struct gpio_desc *rst_gpio; u8 cur_page; struct spi_controller *radio_a_ctrl, *radio_b_ctrl; + struct regmap *regmap; }; static int sx1301_read_burst(struct sx1301_priv *priv, u8 reg, u8 *val, size_t len) @@ -614,6 +644,7 @@ static int sx1301_probe(struct spi_device *spi) struct spi_sx1301 *radio; struct gpio_desc *rst; int ret; + unsigned int ver; u8 val; rst = devm_gpiod_get_optional(&spi->dev, "reset", GPIOD_OUT_LOW); @@ -641,14 +672,21 @@ static int sx1301_probe(struct spi_device *spi) priv->spi = spi; SET_NETDEV_DEV(netdev, &spi->dev); - ret = sx1301_read(priv, REG_VERSION, &val); + priv->regmap = devm_regmap_init_spi(spi, &sx1301_regmap_config); + if (IS_ERR(priv->regmap)) { + ret = PTR_ERR(priv->regmap); + dev_err(&spi->dev, "Regmap allocation failed: %d\n", ret); + return ret; + } + + ret = regmap_read(priv->regmap, SX1301_VER, &ver); if (ret) { dev_err(&spi->dev, "version read failed\n"); return ret; } - if (val != SX1301_CHIP_VERSION) { - dev_err(&spi->dev, "unexpected version: %u\n", val); + if (ver != SX1301_CHIP_VERSION) { + dev_err(&spi->dev, "unexpected version: %u\n", ver); return -ENXIO; } diff --git a/drivers/net/lora/sx1301.h b/drivers/net/lora/sx1301.h index b37ac56..2fc283f 100644 --- a/drivers/net/lora/sx1301.h +++ b/drivers/net/lora/sx1301.h @@ -15,4 +15,14 @@ #define SX1301_MCU_AGC_FW_VERSION 4 #define SX1301_MCU_AGC_CAL_FW_VERSION 2 +/* Page independent */ +#define SX1301_PAGE 0x00 +#define SX1301_VER 0x01 + +#define SX1301_VIRT_BASE 0x100 +#define SX1301_PAGE_LEN 0x80 +#define SX1301_PAGE_BASE(n) (SX1301_VIRT_BASE + (SX1301_PAGE_LEN * n)) + +#define SX1301_MAX_REGISTER (SX1301_PAGE_BASE(3) + 0x7F) + #endif From patchwork Thu Aug 9 12:33:38 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ben Whitten X-Patchwork-Id: 955530 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=fail (p=none dis=none) header.from=gmail.com Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.b="TKDuqBMm"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 41mSPf5hDWz9ryt for ; Thu, 9 Aug 2018 22:34:46 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1732358AbeHIO70 (ORCPT ); Thu, 9 Aug 2018 10:59:26 -0400 Received: from mail-wr1-f51.google.com ([209.85.221.51]:38114 "EHLO mail-wr1-f51.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1731399AbeHIO70 (ORCPT ); Thu, 9 Aug 2018 10:59:26 -0400 Received: by mail-wr1-f51.google.com with SMTP id v14-v6so5009020wro.5 for ; Thu, 09 Aug 2018 05:34:42 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=sender:from:to:cc:subject:date:message-id:in-reply-to:references; bh=to3BPOu1ua+24qM6pCePpAtPh+fGU8qdvG4Kq0eNvJM=; b=TKDuqBMmqQzZWb1q/mswbwDpez2gtA6c37uGr4GGuOZLAGpZDZ8zKCCQVjlXxaeuw7 o4E7i6I12mbLeF6Ej+wc8BYDiuV6kh30pkIsXRXPlM5R1QiU4k0xn1s+2bEr5T0A1pOc LQdi74Th2Fp8ME7zU3IzS85lUD1+YkxKZcjbssiRscB7KSxpCgBJ/OfWaYZj7o0L+Zwc p7a9YS2wl3dl+8fbHOBEfhfk3C8c7Uqv5ukpgnRPSGRGC/N4nl1mhTJ6qY0cF3m1EM2C MLtOPNvT0rIzJ9+YAtAhRUwMTmpHXxutjIsSDhnBK/uxlMrVFr9NZpAQqtDMMzqEFjzo et4A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:from:to:cc:subject:date:message-id :in-reply-to:references; bh=to3BPOu1ua+24qM6pCePpAtPh+fGU8qdvG4Kq0eNvJM=; b=kGYkHWuduylKQOCAyQX0MLVXFwK7BQPyznGukGiEpoHQUiyblR9V+RPckNpUVZVmZ4 vcoLEZdTzQ5cn+zqW3v6guHulGzsz+zzOy6mvjvJx4WQ8FD4Cq0Awx1sJT5g/fwZLXZU isJDbGFqXb1bZ825udHQRJVN7bqoxBUxkgd7lhIaBbAOxlCMu1PBIZqz4awXABFLiwUd /nC9M20Uwz99nBKmsQYDnbqQ7jLqROt0/vDhMVDkSVHv7zAd9eWn+Hg2lF1zG/7NRXk/ bb1Bbacr6vMgQZc75mYxUqDmBoP0YtVmiTyLiLCjjwMbT+e4J0a/AC7F/caPwxPzTSA3 wyYg== X-Gm-Message-State: AOUpUlFJVSy04txA5ZLbRReP9vUjuNfU1yY5c/ZR46fDbKfLr937HF+0 a9xnAvCOYwCz/1PR2HUoqEU= X-Google-Smtp-Source: AA+uWPw/bBH3Cj3BXhPScNan7/wTXy1eZ7oFM4VUKEGvJVUL1MQrG961i/8A1M1/RM72HOspxYCxFg== X-Received: by 2002:a5d:4d8d:: with SMTP id b13-v6mr1283634wru.80.1533818081711; Thu, 09 Aug 2018 05:34:41 -0700 (PDT) Received: from Sarah.corp.lairdtech.com ([109.174.151.67]) by smtp.gmail.com with ESMTPSA id g125-v6sm8596848wmf.16.2018.08.09.05.34.40 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Thu, 09 Aug 2018 05:34:40 -0700 (PDT) From: Ben Whitten X-Google-Original-From: Ben Whitten To: afaerber@suse.de Cc: starnight@g.ncu.edu.tw, hasnain.virk@arm.com, netdev@vger.kernel.org, liuxuenetmail@gmail.com, shess@hessware.de, Ben Whitten Subject: [PATCH lora-next v2 8/8] net: lora: sx1301: convert driver over to regmap reads and writes Date: Thu, 9 Aug 2018 13:33:38 +0100 Message-Id: <1533818018-29005-8-git-send-email-ben.whitten@lairdtech.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1533818018-29005-1-git-send-email-ben.whitten@lairdtech.com> References: <1533818018-29005-1-git-send-email-ben.whitten@lairdtech.com> Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org The reads and writes are replaced with regmap versions and unneeded functions, variable, and defines removed. Signed-off-by: Ben Whitten --- drivers/net/lora/sx1301.c | 204 +++++++++++++++------------------------------- drivers/net/lora/sx1301.h | 30 +++++++ 2 files changed, 95 insertions(+), 139 deletions(-) diff --git a/drivers/net/lora/sx1301.c b/drivers/net/lora/sx1301.c index 766df06..4db5a43 100644 --- a/drivers/net/lora/sx1301.c +++ b/drivers/net/lora/sx1301.c @@ -24,29 +24,6 @@ #include "sx1301.h" -#define REG_PAGE_RESET 0 -#define REG_MCU_PROM_ADDR 9 -#define REG_MCU_PROM_DATA 10 -#define REG_GPIO_SELECT_INPUT 27 -#define REG_GPIO_SELECT_OUTPUT 28 -#define REG_GPIO_MODE 29 -#define REG_MCU_AGC_STATUS 32 -#define REG_0_RADIO_SELECT 35 -#define REG_0_MCU 106 -#define REG_2_SPI_RADIO_A_DATA 33 -#define REG_2_SPI_RADIO_A_DATA_READBACK 34 -#define REG_2_SPI_RADIO_A_ADDR 35 -#define REG_2_SPI_RADIO_A_CS 37 -#define REG_2_SPI_RADIO_B_DATA 38 -#define REG_2_SPI_RADIO_B_DATA_READBACK 39 -#define REG_2_SPI_RADIO_B_ADDR 40 -#define REG_2_SPI_RADIO_B_CS 42 -#define REG_2_DBG_ARB_MCU_RAM_DATA 64 -#define REG_2_DBG_AGC_MCU_RAM_DATA 65 -#define REG_2_DBG_ARB_MCU_RAM_ADDR 80 -#define REG_2_DBG_AGC_MCU_RAM_ADDR 81 -#define REG_EMERGENCY_FORCE 127 - #define REG_PAGE_RESET_SOFT_RESET BIT(7) #define REG_16_GLOBAL_EN BIT(3) @@ -99,8 +76,7 @@ static struct regmap_config sx1301_regmap_config = { struct spi_sx1301 { struct spi_device *parent; - u8 page; - u8 regs; + unsigned int regs; }; struct sx1301_priv { @@ -108,7 +84,6 @@ struct sx1301_priv { struct spi_device *spi; struct lora_priv lora; struct gpio_desc *rst_gpio; - u8 cur_page; struct spi_controller *radio_a_ctrl, *radio_b_ctrl; struct regmap *regmap; }; @@ -140,50 +115,9 @@ static int sx1301_write(struct sx1301_priv *priv, u8 reg, u8 val) return sx1301_write_burst(priv, reg, &val, 1); } -static int sx1301_page_switch(struct sx1301_priv *priv, u8 page) -{ - int ret; - - if (priv->cur_page == page) - return 0; - - dev_dbg(priv->dev, "switching to page %u\n", (unsigned)page); - ret = sx1301_write(priv, REG_PAGE_RESET, page & 0x3); - if (ret) { - dev_err(priv->dev, "switching to page %u failed\n", (unsigned)page); - return ret; - } - - priv->cur_page = page; - - return 0; -} - -static int sx1301_page_read(struct sx1301_priv *priv, u8 page, u8 reg, u8 *val) -{ - int ret; - - ret = sx1301_page_switch(priv, page); - if (ret) - return ret; - - return sx1301_read(priv, reg, val); -} - -static int sx1301_page_write(struct sx1301_priv *priv, u8 page, u8 reg, u8 val) -{ - int ret; - - ret = sx1301_page_switch(priv, page); - if (ret) - return ret; - - return sx1301_write(priv, reg, val); -} - static int sx1301_soft_reset(struct sx1301_priv *priv) { - return sx1301_write(priv, REG_PAGE_RESET, REG_PAGE_RESET_SOFT_RESET); + return regmap_write(priv->regmap, SX1301_PAGE, REG_PAGE_RESET_SOFT_RESET); } #define REG_RADIO_X_DATA 0 @@ -195,12 +129,12 @@ static int sx1301_radio_set_cs(struct spi_controller *ctrl, bool enable) { struct spi_sx1301 *ssx = spi_controller_get_devdata(ctrl); struct sx1301_priv *priv = spi_get_drvdata(ssx->parent); - u8 cs; + unsigned int cs; int ret; dev_dbg(&ctrl->dev, "setting CS to %s\n", enable ? "1" : "0"); - ret = sx1301_page_read(priv, ssx->page, ssx->regs + REG_RADIO_X_CS, &cs); + ret = regmap_read(priv->regmap, ssx->regs + REG_RADIO_X_CS, &cs); if (ret) { dev_warn(&ctrl->dev, "failed to read CS (%d)\n", ret); cs = 0; @@ -211,7 +145,7 @@ static int sx1301_radio_set_cs(struct spi_controller *ctrl, bool enable) else cs &= ~BIT(0); - ret = sx1301_page_write(priv, ssx->page, ssx->regs + REG_RADIO_X_CS, cs); + ret = regmap_write(priv->regmap, ssx->regs + REG_RADIO_X_CS, cs); if (ret) { dev_err(&ctrl->dev, "failed to write CS (%d)\n", ret); return ret; @@ -235,8 +169,8 @@ static int sx1301_radio_spi_transfer_one(struct spi_controller *ctrl, { struct spi_sx1301 *ssx = spi_controller_get_devdata(ctrl); struct sx1301_priv *priv = spi_get_drvdata(ssx->parent); - const u8 *tx_buf = xfr->tx_buf; - u8 *rx_buf = xfr->rx_buf; + const unsigned int *tx_buf = xfr->tx_buf; + unsigned int *rx_buf = xfr->rx_buf; int ret; if (xfr->len == 0 || xfr->len > 3) @@ -245,13 +179,13 @@ static int sx1301_radio_spi_transfer_one(struct spi_controller *ctrl, dev_dbg(&spi->dev, "transferring one (%u)\n", xfr->len); if (tx_buf) { - ret = sx1301_page_write(priv, ssx->page, ssx->regs + REG_RADIO_X_ADDR, tx_buf ? tx_buf[0] : 0); + ret = regmap_write(priv->regmap, ssx->regs + REG_RADIO_X_ADDR, tx_buf ? tx_buf[0] : 0); if (ret) { dev_err(&spi->dev, "SPI radio address write failed\n"); return ret; } - ret = sx1301_page_write(priv, ssx->page, ssx->regs + REG_RADIO_X_DATA, (tx_buf && xfr->len >= 2) ? tx_buf[1] : 0); + ret = regmap_write(priv->regmap, ssx->regs + REG_RADIO_X_DATA, (tx_buf && xfr->len >= 2) ? tx_buf[1] : 0); if (ret) { dev_err(&spi->dev, "SPI radio data write failed\n"); return ret; @@ -271,7 +205,7 @@ static int sx1301_radio_spi_transfer_one(struct spi_controller *ctrl, } if (rx_buf) { - ret = sx1301_page_read(priv, ssx->page, ssx->regs + REG_RADIO_X_DATA_READBACK, &rx_buf[xfr->len - 1]); + ret = regmap_read(priv->regmap, ssx->regs + REG_RADIO_X_DATA_READBACK, &rx_buf[xfr->len - 1]); if (ret) { dev_err(&spi->dev, "SPI radio data read failed\n"); return ret; @@ -281,17 +215,17 @@ static int sx1301_radio_spi_transfer_one(struct spi_controller *ctrl, return 0; } -static int sx1301_agc_ram_read(struct sx1301_priv *priv, u8 addr, u8 *val) +static int sx1301_agc_ram_read(struct sx1301_priv *priv, u8 addr, unsigned int *val) { int ret; - ret = sx1301_page_write(priv, 2, REG_2_DBG_AGC_MCU_RAM_ADDR, addr); + ret = regmap_write(priv->regmap, SX1301_DBG_AGC_MCU_RAM_ADDR, addr); if (ret) { dev_err(priv->dev, "AGC RAM addr write failed\n"); return ret; } - ret = sx1301_page_read(priv, 2, REG_2_DBG_AGC_MCU_RAM_DATA, val); + ret = regmap_read(priv->regmap, SX1301_DBG_AGC_MCU_RAM_DATA, val); if (ret) { dev_err(priv->dev, "AGC RAM data read failed\n"); return ret; @@ -300,17 +234,17 @@ static int sx1301_agc_ram_read(struct sx1301_priv *priv, u8 addr, u8 *val) return 0; } -static int sx1301_arb_ram_read(struct sx1301_priv *priv, u8 addr, u8 *val) +static int sx1301_arb_ram_read(struct sx1301_priv *priv, u8 addr, unsigned int *val) { int ret; - ret = sx1301_page_write(priv, 2, REG_2_DBG_ARB_MCU_RAM_ADDR, addr); + ret = regmap_write(priv->regmap, SX1301_DBG_ARB_MCU_RAM_ADDR, addr); if (ret) { dev_err(priv->dev, "ARB RAM addr write failed\n"); return ret; } - ret = sx1301_page_read(priv, 2, REG_2_DBG_ARB_MCU_RAM_DATA, val); + ret = regmap_read(priv->regmap, SX1301_DBG_ARB_MCU_RAM_DATA, val); if (ret) { dev_err(priv->dev, "ARB RAM data read failed\n"); return ret; @@ -322,7 +256,8 @@ static int sx1301_arb_ram_read(struct sx1301_priv *priv, u8 addr, u8 *val) static int sx1301_load_firmware(struct sx1301_priv *priv, int mcu, const struct firmware *fw) { u8 *buf; - u8 val, rst, select_mux; + u8 rst, select_mux; + unsigned int val; int ret; if (fw->size != SX1301_MCU_FW_BYTE) { @@ -343,7 +278,7 @@ static int sx1301_load_firmware(struct sx1301_priv *priv, int mcu, const struct return -EINVAL; } - ret = sx1301_page_read(priv, 0, REG_0_MCU, &val); + ret = regmap_read(priv->regmap, SX1301_MCU_CTRL, &val); if (ret) { dev_err(priv->dev, "MCU read failed\n"); return ret; @@ -352,25 +287,25 @@ static int sx1301_load_firmware(struct sx1301_priv *priv, int mcu, const struct val |= rst; val &= ~select_mux; - ret = sx1301_page_write(priv, 0, REG_0_MCU, val); + ret = regmap_write(priv->regmap, SX1301_MCU_CTRL, val); if (ret) { dev_err(priv->dev, "MCU reset / select mux write failed\n"); return ret; } - ret = sx1301_write(priv, REG_MCU_PROM_ADDR, 0); + ret = regmap_write(priv->regmap, SX1301_MPA, 0); if (ret) { dev_err(priv->dev, "MCU prom addr write failed\n"); return ret; } - ret = sx1301_write_burst(priv, REG_MCU_PROM_DATA, fw->data, fw->size); + ret = sx1301_write_burst(priv, SX1301_MPD, fw->data, fw->size); if (ret) { dev_err(priv->dev, "MCU prom data write failed\n"); return ret; } - ret = sx1301_read(priv, REG_MCU_PROM_DATA, &val); + ret = regmap_read(priv->regmap, SX1301_MPD, &val); if (ret) { dev_err(priv->dev, "MCU prom data dummy read failed\n"); return ret; @@ -380,7 +315,7 @@ static int sx1301_load_firmware(struct sx1301_priv *priv, int mcu, const struct if (!buf) return -ENOMEM; - ret = sx1301_read_burst(priv, REG_MCU_PROM_DATA, buf, fw->size); + ret = sx1301_read_burst(priv, SX1301_MPD, buf, fw->size); if (ret) { dev_err(priv->dev, "MCU prom data read failed\n"); kfree(buf); @@ -395,7 +330,7 @@ static int sx1301_load_firmware(struct sx1301_priv *priv, int mcu, const struct kfree(buf); - ret = sx1301_page_read(priv, 0, REG_0_MCU, &val); + ret = regmap_read(priv->regmap, SX1301_MCU_CTRL, &val); if (ret) { dev_err(priv->dev, "MCU read (1) failed\n"); return ret; @@ -403,7 +338,7 @@ static int sx1301_load_firmware(struct sx1301_priv *priv, int mcu, const struct val |= select_mux; - ret = sx1301_page_write(priv, 0, REG_0_MCU, val); + ret = regmap_write(priv->regmap, SX1301_MCU_CTRL, val); if (ret) { dev_err(priv->dev, "MCU reset / select mux write (1) failed\n"); return ret; @@ -415,7 +350,7 @@ static int sx1301_load_firmware(struct sx1301_priv *priv, int mcu, const struct static int sx1301_agc_calibrate(struct sx1301_priv *priv) { const struct firmware *fw; - u8 val; + unsigned int val; int ret; ret = request_firmware(&fw, "sx1301_agc_calibration.bin", priv->dev); @@ -431,7 +366,7 @@ static int sx1301_agc_calibrate(struct sx1301_priv *priv) return ret; } - ret = sx1301_page_read(priv, 0, 105, &val); + ret = regmap_read(priv->regmap, SX1301_FORCE_CTRL, &val); if (ret) { dev_err(priv->dev, "0|105 read failed\n"); return ret; @@ -439,7 +374,7 @@ static int sx1301_agc_calibrate(struct sx1301_priv *priv) val &= ~REG_0_105_FORCE_HOST_RADIO_CTRL; - ret = sx1301_page_write(priv, 0, 105, val); + ret = regmap_write(priv->regmap, SX1301_FORCE_CTRL, val); if (ret) { dev_err(priv->dev, "0|105 write failed\n"); return ret; @@ -449,13 +384,13 @@ static int sx1301_agc_calibrate(struct sx1301_priv *priv) if (false) val |= BIT(5); /* SX1255 */ - ret = sx1301_page_write(priv, 0, REG_0_RADIO_SELECT, val); + ret = regmap_write(priv->regmap, SX1301_CHRS, val); if (ret) { dev_err(priv->dev, "radio select write failed\n"); return ret; } - ret = sx1301_page_read(priv, 0, REG_0_MCU, &val); + ret = regmap_read(priv->regmap, SX1301_MCU_CTRL, &val); if (ret) { dev_err(priv->dev, "MCU read (0) failed\n"); return ret; @@ -463,7 +398,7 @@ static int sx1301_agc_calibrate(struct sx1301_priv *priv) val &= ~REG_0_MCU_RST_1; - ret = sx1301_page_write(priv, 0, REG_0_MCU, val); + ret = regmap_write(priv->regmap, SX1301_MCU_CTRL, val); if (ret) { dev_err(priv->dev, "MCU write (0) failed\n"); return ret; @@ -483,13 +418,7 @@ static int sx1301_agc_calibrate(struct sx1301_priv *priv) return -ENXIO; } - ret = sx1301_page_switch(priv, 3); - if (ret) { - dev_err(priv->dev, "page switch 3 failed\n"); - return ret; - } - - ret = sx1301_read(priv, REG_EMERGENCY_FORCE, &val); + ret = regmap_read(priv->regmap, SX1301_EMERGENCY_FORCE_HOST_CTRL, &val); if (ret) { dev_err(priv->dev, "emergency force read failed\n"); return ret; @@ -497,7 +426,7 @@ static int sx1301_agc_calibrate(struct sx1301_priv *priv) val &= ~REG_EMERGENCY_FORCE_HOST_CTRL; - ret = sx1301_write(priv, REG_EMERGENCY_FORCE, val); + ret = regmap_write(priv->regmap, SX1301_EMERGENCY_FORCE_HOST_CTRL, val); if (ret) { dev_err(priv->dev, "emergency force write failed\n"); return ret; @@ -506,7 +435,7 @@ static int sx1301_agc_calibrate(struct sx1301_priv *priv) dev_err(priv->dev, "starting calibration...\n"); msleep(2300); - ret = sx1301_read(priv, REG_EMERGENCY_FORCE, &val); + ret = regmap_read(priv->regmap, SX1301_EMERGENCY_FORCE_HOST_CTRL, &val); if (ret) { dev_err(priv->dev, "emergency force read (1) failed\n"); return ret; @@ -514,13 +443,13 @@ static int sx1301_agc_calibrate(struct sx1301_priv *priv) val |= REG_EMERGENCY_FORCE_HOST_CTRL; - ret = sx1301_write(priv, REG_EMERGENCY_FORCE, val); + ret = regmap_write(priv->regmap, SX1301_EMERGENCY_FORCE_HOST_CTRL, val); if (ret) { dev_err(priv->dev, "emergency force write (1) failed\n"); return ret; } - ret = sx1301_read(priv, REG_MCU_AGC_STATUS, &val); + ret = regmap_read(priv->regmap, SX1301_AGCSTS, &val); if (ret) { dev_err(priv->dev, "AGC status read failed\n"); return ret; @@ -538,7 +467,7 @@ static int sx1301_agc_calibrate(struct sx1301_priv *priv) static int sx1301_load_all_firmware(struct sx1301_priv *priv) { const struct firmware *fw; - u8 val; + unsigned int val; int ret; ret = request_firmware(&fw, "sx1301_arb.bin", priv->dev); @@ -563,7 +492,7 @@ static int sx1301_load_all_firmware(struct sx1301_priv *priv) if (ret) return ret; - ret = sx1301_page_read(priv, 0, 105, &val); + ret = regmap_read(priv->regmap, SX1301_FORCE_CTRL, &val); if (ret) { dev_err(priv->dev, "0|105 read failed\n"); return ret; @@ -571,19 +500,19 @@ static int sx1301_load_all_firmware(struct sx1301_priv *priv) val &= ~(REG_0_105_FORCE_HOST_RADIO_CTRL | REG_0_105_FORCE_HOST_FE_CTRL | REG_0_105_FORCE_DEC_FILTER_GAIN); - ret = sx1301_page_write(priv, 0, 105, val); + ret = regmap_write(priv->regmap, SX1301_FORCE_CTRL, val); if (ret) { dev_err(priv->dev, "0|105 write failed\n"); return ret; } - ret = sx1301_page_write(priv, 0, REG_0_RADIO_SELECT, 0); + ret = regmap_write(priv->regmap, SX1301_CHRS, 0); if (ret) { dev_err(priv->dev, "radio select write failed\n"); return ret; } - ret = sx1301_page_read(priv, 0, REG_0_MCU, &val); + ret = regmap_read(priv->regmap, SX1301_MCU_CTRL, &val); if (ret) { dev_err(priv->dev, "MCU read (0) failed\n"); return ret; @@ -591,7 +520,7 @@ static int sx1301_load_all_firmware(struct sx1301_priv *priv) val &= ~(REG_0_MCU_RST_1 | REG_0_MCU_RST_0); - ret = sx1301_page_write(priv, 0, REG_0_MCU, val); + ret = regmap_write(priv->regmap, SX1301_MCU_CTRL, val); if (ret) { dev_err(priv->dev, "MCU write (0) failed\n"); return ret; @@ -645,7 +574,7 @@ static int sx1301_probe(struct spi_device *spi) struct gpio_desc *rst; int ret; unsigned int ver; - u8 val; + unsigned int val; rst = devm_gpiod_get_optional(&spi->dev, "reset", GPIOD_OUT_LOW); if (IS_ERR(rst)) @@ -665,7 +594,6 @@ static int sx1301_probe(struct spi_device *spi) priv = netdev_priv(netdev); priv->rst_gpio = rst; - priv->cur_page = 0xff; spi_set_drvdata(spi, priv); priv->dev = &spi->dev; @@ -690,7 +618,7 @@ static int sx1301_probe(struct spi_device *spi) return -ENXIO; } - ret = sx1301_write(priv, REG_PAGE_RESET, 0); + ret = regmap_write(priv->regmap, SX1301_PAGE, 0); if (ret) { dev_err(&spi->dev, "page/reset write failed\n"); return ret; @@ -702,7 +630,7 @@ static int sx1301_probe(struct spi_device *spi) return ret; } - ret = sx1301_read(priv, 16, &val); + ret = regmap_read(priv->regmap, SX1301_GEN, &val); if (ret) { dev_err(&spi->dev, "16 read failed\n"); return ret; @@ -710,13 +638,13 @@ static int sx1301_probe(struct spi_device *spi) val &= ~REG_16_GLOBAL_EN; - ret = sx1301_write(priv, 16, val); + ret = regmap_write(priv->regmap, SX1301_GEN, val); if (ret) { dev_err(&spi->dev, "16 write failed\n"); return ret; } - ret = sx1301_read(priv, 17, &val); + ret = regmap_read(priv->regmap, SX1301_CKEN, &val); if (ret) { dev_err(&spi->dev, "17 read failed\n"); return ret; @@ -724,13 +652,13 @@ static int sx1301_probe(struct spi_device *spi) val &= ~REG_17_CLK32M_EN; - ret = sx1301_write(priv, 17, val); + ret = regmap_write(priv->regmap, SX1301_CKEN, val); if (ret) { dev_err(&spi->dev, "17 write failed\n"); return ret; } - ret = sx1301_page_read(priv, 2, 43, &val); + ret = regmap_read(priv->regmap, SX1301_RADIO_CFG, &val); if (ret) { dev_err(&spi->dev, "2|43 read failed\n"); return ret; @@ -738,7 +666,7 @@ static int sx1301_probe(struct spi_device *spi) val |= REG_2_43_RADIO_B_EN | REG_2_43_RADIO_A_EN; - ret = sx1301_page_write(priv, 2, 43, val); + ret = regmap_write(priv->regmap, SX1301_RADIO_CFG, val); if (ret) { dev_err(&spi->dev, "2|43 write failed\n"); return ret; @@ -746,7 +674,7 @@ static int sx1301_probe(struct spi_device *spi) msleep(500); - ret = sx1301_page_read(priv, 2, 43, &val); + ret = regmap_read(priv->regmap, SX1301_RADIO_CFG, &val); if (ret) { dev_err(&spi->dev, "2|43 read failed\n"); return ret; @@ -754,7 +682,7 @@ static int sx1301_probe(struct spi_device *spi) val |= REG_2_43_RADIO_RST; - ret = sx1301_page_write(priv, 2, 43, val); + ret = regmap_write(priv->regmap, SX1301_RADIO_CFG, val); if (ret) { dev_err(&spi->dev, "2|43 write failed\n"); return ret; @@ -762,7 +690,7 @@ static int sx1301_probe(struct spi_device *spi) msleep(5); - ret = sx1301_page_read(priv, 2, 43, &val); + ret = regmap_read(priv->regmap, SX1301_RADIO_CFG, &val); if (ret) { dev_err(&spi->dev, "2|43 read failed\n"); return ret; @@ -770,7 +698,7 @@ static int sx1301_probe(struct spi_device *spi) val &= ~REG_2_43_RADIO_RST; - ret = sx1301_page_write(priv, 2, 43, val); + ret = regmap_write(priv->regmap, SX1301_RADIO_CFG, val); if (ret) { dev_err(&spi->dev, "2|43 write failed\n"); return ret; @@ -787,8 +715,7 @@ static int sx1301_probe(struct spi_device *spi) priv->radio_a_ctrl->dev.of_node = of_get_child_by_name(spi->dev.of_node, "radio-a"); radio = spi_controller_get_devdata(priv->radio_a_ctrl); - radio->page = 2; - radio->regs = REG_2_SPI_RADIO_A_DATA; + radio->regs = SX1301_RADIO_A_SPI_DATA; radio->parent = spi; ret = devm_spi_register_controller(&spi->dev, priv->radio_a_ctrl); @@ -809,8 +736,7 @@ static int sx1301_probe(struct spi_device *spi) priv->radio_b_ctrl->dev.of_node = of_get_child_by_name(spi->dev.of_node, "radio-b"); radio = spi_controller_get_devdata(priv->radio_b_ctrl); - radio->page = 2; - radio->regs = REG_2_SPI_RADIO_B_DATA; + radio->regs = SX1301_RADIO_B_SPI_DATA; radio->parent = spi; ret = devm_spi_register_controller(&spi->dev, priv->radio_b_ctrl); @@ -822,7 +748,7 @@ static int sx1301_probe(struct spi_device *spi) /* GPIO */ - ret = sx1301_read(priv, REG_GPIO_MODE, &val); + ret = regmap_read(priv->regmap, SX1301_GPMODE, &val); if (ret) { dev_err(&spi->dev, "GPIO mode read failed\n"); return ret; @@ -830,13 +756,13 @@ static int sx1301_probe(struct spi_device *spi) val |= GENMASK(4, 0); - ret = sx1301_write(priv, REG_GPIO_MODE, val); + ret = regmap_write(priv->regmap, SX1301_GPMODE, val); if (ret) { dev_err(&spi->dev, "GPIO mode write failed\n"); return ret; } - ret = sx1301_read(priv, REG_GPIO_SELECT_OUTPUT, &val); + ret = regmap_read(priv->regmap, SX1301_GPSO, &val); if (ret) { dev_err(&spi->dev, "GPIO select output read failed\n"); return ret; @@ -845,7 +771,7 @@ static int sx1301_probe(struct spi_device *spi) val &= ~GENMASK(3, 0); val |= 2; - ret = sx1301_write(priv, REG_GPIO_SELECT_OUTPUT, val); + ret = regmap_write(priv->regmap, SX1301_GPSO, val); if (ret) { dev_err(&spi->dev, "GPIO select output write failed\n"); return ret; @@ -853,7 +779,7 @@ static int sx1301_probe(struct spi_device *spi) /* TODO LBT */ - ret = sx1301_read(priv, 16, &val); + ret = regmap_read(priv->regmap, SX1301_GEN, &val); if (ret) { dev_err(&spi->dev, "16 read (1) failed\n"); return ret; @@ -861,13 +787,13 @@ static int sx1301_probe(struct spi_device *spi) val |= REG_16_GLOBAL_EN; - ret = sx1301_write(priv, 16, val); + ret = regmap_write(priv->regmap, SX1301_GEN, val); if (ret) { dev_err(&spi->dev, "16 write (1) failed\n"); return ret; } - ret = sx1301_read(priv, 17, &val); + ret = regmap_read(priv->regmap, SX1301_CKEN, &val); if (ret) { dev_err(&spi->dev, "17 read (1) failed\n"); return ret; @@ -875,7 +801,7 @@ static int sx1301_probe(struct spi_device *spi) val |= REG_17_CLK32M_EN; - ret = sx1301_write(priv, 17, val); + ret = regmap_write(priv->regmap, SX1301_CKEN, val); if (ret) { dev_err(&spi->dev, "17 write (1) failed\n"); return ret; diff --git a/drivers/net/lora/sx1301.h b/drivers/net/lora/sx1301.h index 2fc283f..b21e5c6 100644 --- a/drivers/net/lora/sx1301.h +++ b/drivers/net/lora/sx1301.h @@ -18,11 +18,41 @@ /* Page independent */ #define SX1301_PAGE 0x00 #define SX1301_VER 0x01 +#define SX1301_MPA 0x09 +#define SX1301_MPD 0x0A +#define SX1301_GEN 0x10 +#define SX1301_CKEN 0x11 +#define SX1301_GPSO 0x1C +#define SX1301_GPMODE 0x1D +#define SX1301_AGCSTS 0x20 #define SX1301_VIRT_BASE 0x100 #define SX1301_PAGE_LEN 0x80 #define SX1301_PAGE_BASE(n) (SX1301_VIRT_BASE + (SX1301_PAGE_LEN * n)) +/* Page 0 */ +#define SX1301_CHRS (SX1301_PAGE_BASE(0) + 0x23) +#define SX1301_FORCE_CTRL (SX1301_PAGE_BASE(0) + 0x69) +#define SX1301_MCU_CTRL (SX1301_PAGE_BASE(0) + 0x6A) + +/* Page 2 */ +#define SX1301_RADIO_A_SPI_DATA (SX1301_PAGE_BASE(2) + 0x21) +#define SX1301_RADIO_A_SPI_DATA_RB (SX1301_PAGE_BASE(2) + 0x22) +#define SX1301_RADIO_A_SPI_ADDR (SX1301_PAGE_BASE(2) + 0x23) +#define SX1301_RADIO_A_SPI_CS (SX1301_PAGE_BASE(2) + 0x25) +#define SX1301_RADIO_B_SPI_DATA (SX1301_PAGE_BASE(2) + 0x26) +#define SX1301_RADIO_B_SPI_DATA_RB (SX1301_PAGE_BASE(2) + 0x27) +#define SX1301_RADIO_B_SPI_ADDR (SX1301_PAGE_BASE(2) + 0x28) +#define SX1301_RADIO_B_SPI_CS (SX1301_PAGE_BASE(2) + 0x2A) +#define SX1301_RADIO_CFG (SX1301_PAGE_BASE(2) + 0x2B) +#define SX1301_DBG_ARB_MCU_RAM_DATA (SX1301_PAGE_BASE(2) + 0x40) +#define SX1301_DBG_AGC_MCU_RAM_DATA (SX1301_PAGE_BASE(2) + 0x41) +#define SX1301_DBG_ARB_MCU_RAM_ADDR (SX1301_PAGE_BASE(2) + 0x50) +#define SX1301_DBG_AGC_MCU_RAM_ADDR (SX1301_PAGE_BASE(2) + 0x51) + +/* Page 3 */ +#define SX1301_EMERGENCY_FORCE_HOST_CTRL (SX1301_PAGE_BASE(3) + 0x7F) + #define SX1301_MAX_REGISTER (SX1301_PAGE_BASE(3) + 0x7F) #endif