drivers/net/dsa/microchip/ksz9477_spi.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Microchip KSZ9477 series register access through SPI
   4  *
   5  * Copyright (C) 2017-2019 Microchip Technology Inc.
   6  */
   7
   8 #include <asm/unaligned.h>
   9
  10 #include <linux/delay.h>
  11 #include <linux/kernel.h>
  12 #include <linux/module.h>
  13 #include <linux/spi/spi.h>
  14
  15 #include "ksz_priv.h"
  16 #include "ksz_spi.h"
  17
  18 /* SPI frame opcodes */
  19 #define KS_SPIOP_RD                     3
  20 #define KS_SPIOP_WR                     2
  21
  22 #define SPI_ADDR_SHIFT                  24
  23 #define SPI_ADDR_MASK                   (BIT(SPI_ADDR_SHIFT) - 1)
  24 #define SPI_TURNAROUND_SHIFT            5
  25
  26 /* Enough to read all switch port registers. */
  27 #define SPI_TX_BUF_LEN                  0x100
  28
  29 static int ksz9477_spi_read_reg(struct spi_device *spi, u32 reg, u8 *val,
  30                                 unsigned int len)
  31 {
  32         u32 txbuf;
  33         int ret;
  34
  35         txbuf = reg & SPI_ADDR_MASK;
  36         txbuf |= KS_SPIOP_RD << SPI_ADDR_SHIFT;
  37         txbuf <<= SPI_TURNAROUND_SHIFT;
  38         txbuf = cpu_to_be32(txbuf);
  39
  40         ret = spi_write_then_read(spi, &txbuf, 4, val, len);
  41         return ret;
  42 }
  43
  44 static int ksz9477_spi_write_reg(struct spi_device *spi, u32 reg, u8 *val,
  45                                  unsigned int len)
  46 {
  47         u32 *txbuf = (u32 *)val;
  48
  49         *txbuf = reg & SPI_ADDR_MASK;
  50         *txbuf |= (KS_SPIOP_WR << SPI_ADDR_SHIFT);
  51         *txbuf <<= SPI_TURNAROUND_SHIFT;
  52         *txbuf = cpu_to_be32(*txbuf);
  53
  54         return spi_write(spi, txbuf, 4 + len);
  55 }
  56
  57 static int ksz_spi_read(struct ksz_device *dev, u32 reg, u8 *data,
  58                         unsigned int len)
  59 {
  60         struct spi_device *spi = dev->priv;
  61
  62         return ksz9477_spi_read_reg(spi, reg, data, len);
  63 }
  64
  65 static int ksz_spi_write(struct ksz_device *dev, u32 reg, void *data,
  66                          unsigned int len)
  67 {
  68         struct spi_device *spi = dev->priv;
  69
  70         if (len > SPI_TX_BUF_LEN)
  71                 len = SPI_TX_BUF_LEN;
  72         memcpy(&dev->txbuf[4], data, len);
  73         return ksz9477_spi_write_reg(spi, reg, dev->txbuf, len);
  74 }
  75
  76 static int ksz_spi_read24(struct ksz_device *dev, u32 reg, u32 *val)
  77 {
  78         int ret;
  79
  80         *val = 0;
  81         ret = ksz_spi_read(dev, reg, (u8 *)val, 3);
  82         if (!ret) {
  83                 *val = be32_to_cpu(*val);
  84                 /* convert to 24bit */
  85                 *val >>= 8;
  86         }
  87
  88         return ret;
  89 }
  90
  91 static int ksz_spi_write24(struct ksz_device *dev, u32 reg, u32 value)
  92 {
  93         /* make it to big endian 24bit from MSB */
  94         value <<= 8;
  95         value = cpu_to_be32(value);
  96         return ksz_spi_write(dev, reg, &value, 3);
  97 }
  98
  99 static const struct ksz_io_ops ksz9477_spi_ops = {
 100         .read8 = ksz_spi_read8,
 101         .read16 = ksz_spi_read16,
 102         .read24 = ksz_spi_read24,
 103         .read32 = ksz_spi_read32,
 104         .write8 = ksz_spi_write8,
 105         .write16 = ksz_spi_write16,
 106         .write24 = ksz_spi_write24,
 107         .write32 = ksz_spi_write32,
 108         .get = ksz_spi_get,
 109         .set = ksz_spi_set,
 110 };
 111
 112 static int ksz9477_spi_probe(struct spi_device *spi)
 113 {
 114         struct ksz_device *dev;
 115         int ret;
 116
 117         dev = ksz_switch_alloc(&spi->dev, &ksz9477_spi_ops, spi);
 118         if (!dev)
 119                 return -ENOMEM;
 120
 121         if (spi->dev.platform_data)
 122                 dev->pdata = spi->dev.platform_data;
 123
 124         dev->txbuf = devm_kzalloc(dev->dev, 4 + SPI_TX_BUF_LEN, GFP_KERNEL);
 125
 126         ret = ksz9477_switch_register(dev);
 127
 128         /* Main DSA driver may not be started yet. */
 129         if (ret)
 130                 return ret;
 131
 132         spi_set_drvdata(spi, dev);
 133
 134         return 0;
 135 }
 136
 137 static int ksz9477_spi_remove(struct spi_device *spi)
 138 {
 139         struct ksz_device *dev = spi_get_drvdata(spi);
 140
 141         if (dev)
 142                 ksz_switch_remove(dev);
 143
 144         return 0;
 145 }
 146
 147 static void ksz9477_spi_shutdown(struct spi_device *spi)
 148 {
 149         struct ksz_device *dev = spi_get_drvdata(spi);
 150
 151         if (dev && dev->dev_ops->shutdown)
 152                 dev->dev_ops->shutdown(dev);
 153 }
 154
 155 static const struct of_device_id ksz9477_dt_ids[] = {
 156         { .compatible = "microchip,ksz9477" },
 157         { .compatible = "microchip,ksz9897" },
 158         { .compatible = "microchip,ksz9893" },
 159         { .compatible = "microchip,ksz9563" },
 160         {},
 161 };
 162 MODULE_DEVICE_TABLE(of, ksz9477_dt_ids);
 163
 164 static struct spi_driver ksz9477_spi_driver = {
 165         .driver = {
 166                 .name   = "ksz9477-switch",
 167                 .owner  = THIS_MODULE,
 168                 .of_match_table = of_match_ptr(ksz9477_dt_ids),
 169         },
 170         .probe  = ksz9477_spi_probe,
 171         .remove = ksz9477_spi_remove,
 172         .shutdown = ksz9477_spi_shutdown,
 173 };
 174
 175 module_spi_driver(ksz9477_spi_driver);
 176
 177 MODULE_AUTHOR("Woojung Huh <Woojung.Huh@microchip.com>");
 178 MODULE_DESCRIPTION("Microchip KSZ9477 Series Switch SPI access Driver");
 179 MODULE_LICENSE("GPL");