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;