| // SPDX-License-Identifier: GPL-2.0-or-later |
| /* |
| * Semtech SX1301 LoRa concentrator |
| * |
| * Copyright (c) 2018 Andreas Färber |
| * |
| * Based on SX1301 HAL code: |
| * Copyright (c) 2013 Semtech-Cycleo |
| */ |
| |
| #include <linux/bitops.h> |
| #include <linux/delay.h> |
| #include <linux/lora.h> |
| #include <linux/module.h> |
| #include <linux/netdevice.h> |
| #include <linux/of.h> |
| #include <linux/of_device.h> |
| #include <linux/of_gpio.h> |
| #include <linux/lora/dev.h> |
| #include <linux/spi/spi.h> |
| |
| #define REG_PAGE_RESET 0 |
| #define REG_VERSION 1 |
| #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_PAGE_RESET_SOFT_RESET BIT(7) |
| |
| #define REG_16_GLOBAL_EN BIT(3) |
| |
| #define REG_17_CLK32M_EN BIT(0) |
| |
| #define REG_2_43_RADIO_A_EN BIT(0) |
| #define REG_2_43_RADIO_B_EN BIT(1) |
| #define REG_2_43_RADIO_RST BIT(2) |
| |
| struct spi_sx1301 { |
| struct spi_device *parent; |
| u8 page; |
| u8 regs; |
| }; |
| |
| struct sx1301_priv { |
| 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(struct spi_device *spi, u8 reg, u8 *val) |
| { |
| u8 addr = reg & 0x7f; |
| return spi_write_then_read(spi, &addr, 1, val, 1); |
| } |
| |
| static int sx1301_write(struct spi_device *spi, u8 reg, u8 val) |
| { |
| u8 buf[2]; |
| |
| buf[0] = reg | BIT(7); |
| buf[1] = val; |
| return spi_write(spi, buf, 2); |
| } |
| |
| static int sx1301_page_switch(struct spi_device *spi, 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); |
| if (ret) { |
| dev_err(&spi->dev, "switching to page %u failed\n", (unsigned)page); |
| return ret; |
| } |
| |
| priv->cur_page = page; |
| |
| return 0; |
| } |
| |
| static int sx1301_soft_reset(struct spi_device *spi) |
| { |
| return sx1301_write(spi, REG_PAGE_RESET, REG_PAGE_RESET_SOFT_RESET); |
| } |
| |
| #define REG_RADIO_X_DATA 0 |
| #define REG_RADIO_X_DATA_READBACK 1 |
| #define REG_RADIO_X_ADDR 2 |
| #define REG_RADIO_X_CS 4 |
| |
| static int sx1301_radio_set_cs(struct spi_controller *ctrl, bool enable) |
| { |
| struct spi_sx1301 *ssx = spi_controller_get_devdata(ctrl); |
| u8 cs; |
| int ret; |
| |
| dev_dbg(&ctrl->dev, "setting CS to %s\n", enable ? "1" : "0"); |
| |
| ret = sx1301_page_switch(ssx->parent, ssx->page); |
| if (ret) { |
| dev_warn(&ctrl->dev, "failed to switch page for CS (%d)\n", ret); |
| return ret; |
| } |
| |
| ret = sx1301_read(ssx->parent, ssx->regs + REG_RADIO_X_CS, &cs); |
| if (ret) { |
| dev_warn(&ctrl->dev, "failed to read CS (%d)\n", ret); |
| cs = 0; |
| } |
| |
| if (enable) |
| cs |= BIT(0); |
| else |
| cs &= ~BIT(0); |
| |
| ret = sx1301_write(ssx->parent, ssx->regs + REG_RADIO_X_CS, cs); |
| if (ret) |
| dev_warn(&ctrl->dev, "failed to write CS (%d)\n", ret); |
| |
| return 0; |
| } |
| |
| static void sx1301_radio_spi_set_cs(struct spi_device *spi, bool enable) |
| { |
| int ret; |
| |
| dev_dbg(&spi->dev, "setting SPI CS to %s\n", enable ? "1" : "0"); |
| |
| if (enable) |
| return; |
| |
| ret = sx1301_radio_set_cs(spi->controller, enable); |
| if (ret) |
| dev_warn(&spi->dev, "failed to write CS (%d)\n", ret); |
| } |
| |
| 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); |
| const u8 *tx_buf = xfr->tx_buf; |
| u8 *rx_buf = xfr->rx_buf; |
| int ret; |
| |
| if (xfr->len == 0 || xfr->len > 3) |
| return -EINVAL; |
| |
| dev_dbg(&spi->dev, "transferring one (%u)\n", xfr->len); |
| |
| ret = sx1301_page_switch(ssx->parent, ssx->page); |
| if (ret) { |
| dev_err(&spi->dev, "failed to switch page for transfer (%d)\n", ret); |
| return ret; |
| } |
| |
| if (tx_buf) { |
| ret = sx1301_write(ssx->parent, 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_write(ssx->parent, 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; |
| } |
| |
| ret = sx1301_radio_set_cs(ctrl, true); |
| if (ret) { |
| dev_err(&spi->dev, "SPI radio CS set failed\n"); |
| return ret; |
| } |
| |
| ret = sx1301_radio_set_cs(ctrl, false); |
| if (ret) { |
| dev_err(&spi->dev, "SPI radio CS unset failed\n"); |
| return ret; |
| } |
| } |
| |
| if (rx_buf) { |
| ret = sx1301_read(ssx->parent, 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; |
| } |
| } |
| |
| return 0; |
| } |
| |
| static void sx1301_radio_setup(struct spi_controller *ctrl) |
| { |
| ctrl->mode_bits = SPI_CS_HIGH | SPI_NO_CS; |
| ctrl->bits_per_word_mask = SPI_BPW_MASK(8); |
| ctrl->num_chipselect = 1; |
| ctrl->set_cs = sx1301_radio_spi_set_cs; |
| ctrl->transfer_one = sx1301_radio_spi_transfer_one; |
| } |
| |
| static int sx1301_probe(struct spi_device *spi) |
| { |
| struct net_device *netdev; |
| struct sx1301_priv *priv; |
| struct spi_sx1301 *radio; |
| struct gpio_desc *rst; |
| int ret; |
| u8 val; |
| |
| rst = devm_gpiod_get_optional(&spi->dev, "reset", GPIOD_OUT_LOW); |
| if (IS_ERR(rst)) |
| return PTR_ERR(rst); |
| |
| gpiod_set_value_cansleep(rst, 1); |
| msleep(100); |
| gpiod_set_value_cansleep(rst, 0); |
| msleep(100); |
| |
| 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"); |
| goto err_version; |
| } |
| |
| if (val != 103) { |
| dev_err(&spi->dev, "unexpected version: %u\n", val); |
| ret = -ENXIO; |
| goto err_version; |
| } |
| |
| netdev = alloc_loradev(sizeof(*priv)); |
| if (!netdev) { |
| ret = -ENOMEM; |
| goto err_alloc_loradev; |
| } |
| |
| priv = netdev_priv(netdev); |
| priv->rst_gpio = rst; |
| priv->cur_page = 0xff; |
| |
| spi_set_drvdata(spi, netdev); |
| SET_NETDEV_DEV(netdev, &spi->dev); |
| |
| ret = sx1301_write(spi, REG_PAGE_RESET, 0); |
| if (ret) { |
| dev_err(&spi->dev, "page/reset write failed\n"); |
| return ret; |
| } |
| |
| ret = sx1301_soft_reset(spi); |
| if (ret) { |
| dev_err(&spi->dev, "soft reset failed\n"); |
| return ret; |
| } |
| |
| ret = sx1301_read(spi, 16, &val); |
| if (ret) { |
| dev_err(&spi->dev, "16 read failed\n"); |
| return ret; |
| } |
| |
| val &= ~REG_16_GLOBAL_EN; |
| |
| ret = sx1301_write(spi, 16, val); |
| if (ret) { |
| dev_err(&spi->dev, "16 write failed\n"); |
| return ret; |
| } |
| |
| ret = sx1301_read(spi, 17, &val); |
| if (ret) { |
| dev_err(&spi->dev, "17 read failed\n"); |
| return ret; |
| } |
| |
| val &= ~REG_17_CLK32M_EN; |
| |
| ret = sx1301_write(spi, 17, val); |
| if (ret) { |
| dev_err(&spi->dev, "17 write failed\n"); |
| return ret; |
| } |
| |
| ret = sx1301_page_switch(spi, 2); |
| if (ret) { |
| dev_err(&spi->dev, "page 2 switch failed\n"); |
| return ret; |
| } |
| |
| ret = sx1301_read(spi, 43, &val); |
| if (ret) { |
| dev_err(&spi->dev, "2|43 read failed\n"); |
| return ret; |
| } |
| |
| val |= REG_2_43_RADIO_B_EN | REG_2_43_RADIO_A_EN; |
| |
| ret = sx1301_write(spi, 43, val); |
| if (ret) { |
| dev_err(&spi->dev, "2|43 write failed\n"); |
| return ret; |
| } |
| |
| msleep(500); |
| |
| ret = sx1301_read(spi, 43, &val); |
| if (ret) { |
| dev_err(&spi->dev, "2|43 read failed\n"); |
| return ret; |
| } |
| |
| val |= REG_2_43_RADIO_RST; |
| |
| ret = sx1301_write(spi, 43, val); |
| if (ret) { |
| dev_err(&spi->dev, "2|43 write failed\n"); |
| return ret; |
| } |
| |
| msleep(5); |
| |
| ret = sx1301_read(spi, 43, &val); |
| if (ret) { |
| dev_err(&spi->dev, "2|43 read failed\n"); |
| return ret; |
| } |
| |
| val &= ~REG_2_43_RADIO_RST; |
| |
| ret = sx1301_write(spi, 43, val); |
| if (ret) { |
| dev_err(&spi->dev, "2|43 write failed\n"); |
| return ret; |
| } |
| |
| /* radio A */ |
| |
| priv->radio_a_ctrl = spi_alloc_master(&spi->dev, sizeof(*radio)); |
| if (!priv->radio_a_ctrl) { |
| ret = -ENOMEM; |
| goto err_radio_a_alloc; |
| } |
| |
| sx1301_radio_setup(priv->radio_a_ctrl); |
| 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->parent = spi; |
| |
| dev_info(&spi->dev, "registering radio A SPI\n"); |
| |
| ret = devm_spi_register_controller(&spi->dev, priv->radio_a_ctrl); |
| if (ret) { |
| dev_err(&spi->dev, "radio A SPI register failed\n"); |
| goto err_radio_a_register; |
| } |
| |
| /* 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; |
| } |
| |
| sx1301_radio_setup(priv->radio_b_ctrl); |
| 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->parent = spi; |
| |
| dev_info(&spi->dev, "registering radio B SPI\n"); |
| |
| ret = devm_spi_register_controller(&spi->dev, priv->radio_b_ctrl); |
| if (ret) { |
| dev_err(&spi->dev, "radio B SPI register failed\n"); |
| goto err_radio_b_register; |
| } |
| |
| dev_info(&spi->dev, "SX1301 module probed\n"); |
| |
| return 0; |
| err_radio_b_register: |
| spi_controller_put(priv->radio_b_ctrl); |
| err_radio_b_alloc: |
| err_radio_a_register: |
| spi_controller_put(priv->radio_a_ctrl); |
| err_radio_a_alloc: |
| 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; |
| } |
| |
| #ifdef CONFIG_OF |
| static const struct of_device_id sx1301_dt_ids[] = { |
| { .compatible = "semtech,sx1301" }, |
| {} |
| }; |
| MODULE_DEVICE_TABLE(of, sx1301_dt_ids); |
| #endif |
| |
| static struct spi_driver sx1301_spi_driver = { |
| .driver = { |
| .name = "sx1301", |
| .of_match_table = of_match_ptr(sx1301_dt_ids), |
| }, |
| .probe = sx1301_probe, |
| .remove = sx1301_remove, |
| }; |
| |
| module_spi_driver(sx1301_spi_driver); |
| |
| MODULE_DESCRIPTION("SX1301 SPI driver"); |
| MODULE_AUTHOR("Andreas Färber <afaerber@suse.de>"); |
| MODULE_LICENSE("GPL"); |