drivers/spi/spi-lp8841-rtc.c

   1 /*
   2  * SPI master driver for ICP DAS LP-8841 RTC
   3  *
   4  * Copyright (C) 2016 Sergei Ianovich
   5  *
   6  * based on
   7  *
   8  * Dallas DS1302 RTC Support
   9  * Copyright (C) 2002 David McCullough
  10  * Copyright (C) 2003 - 2007 Paul Mundt
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  */
  22 #include <linux/delay.h>
  23 #include <linux/kernel.h>
  24 #include <linux/module.h>
  25 #include <linux/platform_device.h>
  26 #include <linux/of.h>
  27 #include <linux/of_device.h>
  28 #include <linux/spi/spi.h>
  29
  30 #define DRIVER_NAME     "spi_lp8841_rtc"
  31
  32 #define SPI_LP8841_RTC_CE       0x01
  33 #define SPI_LP8841_RTC_CLK      0x02
  34 #define SPI_LP8841_RTC_nWE      0x04
  35 #define SPI_LP8841_RTC_MOSI     0x08
  36 #define SPI_LP8841_RTC_MISO     0x01
  37
  38 /*
  39  * REVISIT If there is support for SPI_3WIRE and SPI_LSB_FIRST in SPI
  40  * GPIO driver, this SPI driver can be replaced by a simple GPIO driver
  41  * providing 3 GPIO pins.
  42  */
  43
  44 struct spi_lp8841_rtc {
  45         void            *iomem;
  46         unsigned long   state;
  47 };
  48
  49 static inline void
  50 setsck(struct spi_lp8841_rtc *data, int is_on)
  51 {
  52         if (is_on)
  53                 data->state |= SPI_LP8841_RTC_CLK;
  54         else
  55                 data->state &= ~SPI_LP8841_RTC_CLK;
  56         writeb(data->state, data->iomem);
  57 }
  58
  59 static inline void
  60 setmosi(struct spi_lp8841_rtc *data, int is_on)
  61 {
  62         if (is_on)
  63                 data->state |= SPI_LP8841_RTC_MOSI;
  64         else
  65                 data->state &= ~SPI_LP8841_RTC_MOSI;
  66         writeb(data->state, data->iomem);
  67 }
  68
  69 static inline int
  70 getmiso(struct spi_lp8841_rtc *data)
  71 {
  72         return ioread8(data->iomem) & SPI_LP8841_RTC_MISO;
  73 }
  74
  75 static inline u32
  76 bitbang_txrx_be_cpha0_lsb(struct spi_lp8841_rtc *data,
  77                 unsigned usecs, unsigned cpol, unsigned flags,
  78                 u32 word, u8 bits)
  79 {
  80         /* if (cpol == 0) this is SPI_MODE_0; else this is SPI_MODE_2 */
  81
  82         u32 shift = 32 - bits;
  83         /* clock starts at inactive polarity */
  84         for (; likely(bits); bits--) {
  85
  86                 /* setup LSB (to slave) on leading edge */
  87                 if ((flags & SPI_MASTER_NO_TX) == 0)
  88                         setmosi(data, (word & 1));
  89
  90                 usleep_range(usecs, usecs + 1); /* T(setup) */
  91
  92                 /* sample LSB (from slave) on trailing edge */
  93                 word >>= 1;
  94                 if ((flags & SPI_MASTER_NO_RX) == 0)
  95                         word |= (getmiso(data) << 31);
  96
  97                 setsck(data, !cpol);
  98                 usleep_range(usecs, usecs + 1);
  99
 100                 setsck(data, cpol);
 101         }
 102
 103         word >>= shift;
 104         return word;
 105 }
 106
 107 static int
 108 spi_lp8841_rtc_transfer_one(struct spi_master *master,
 109                             struct spi_device *spi,
 110                             struct spi_transfer *t)
 111 {
 112         struct spi_lp8841_rtc   *data = spi_master_get_devdata(master);
 113         unsigned                count = t->len;
 114         const u8                *tx = t->tx_buf;
 115         u8                      *rx = t->rx_buf;
 116         u8                      word = 0;
 117         int                     ret = 0;
 118
 119         if (tx) {
 120                 data->state &= ~SPI_LP8841_RTC_nWE;
 121                 writeb(data->state, data->iomem);
 122                 while (likely(count > 0)) {
 123                         word = *tx++;
 124                         bitbang_txrx_be_cpha0_lsb(data, 1, 0,
 125                                         SPI_MASTER_NO_RX, word, 8);
 126                         count--;
 127                 }
 128         } else if (rx) {
 129                 data->state |= SPI_LP8841_RTC_nWE;
 130                 writeb(data->state, data->iomem);
 131                 while (likely(count > 0)) {
 132                         word = bitbang_txrx_be_cpha0_lsb(data, 1, 0,
 133                                         SPI_MASTER_NO_TX, word, 8);
 134                         *rx++ = word;
 135                         count--;
 136                 }
 137         } else {
 138                 ret = -EINVAL;
 139         }
 140
 141         spi_finalize_current_transfer(master);
 142
 143         return ret;
 144 }
 145
 146 static void
 147 spi_lp8841_rtc_set_cs(struct spi_device *spi, bool enable)
 148 {
 149         struct spi_lp8841_rtc *data = spi_master_get_devdata(spi->master);
 150
 151         data->state = 0;
 152         writeb(data->state, data->iomem);
 153         if (enable) {
 154                 usleep_range(4, 5);
 155                 data->state |= SPI_LP8841_RTC_CE;
 156                 writeb(data->state, data->iomem);
 157                 usleep_range(4, 5);
 158         }
 159 }
 160
 161 static int
 162 spi_lp8841_rtc_setup(struct spi_device *spi)
 163 {
 164         if ((spi->mode & SPI_CS_HIGH) == 0) {
 165                 dev_err(&spi->dev, "unsupported active low chip select\n");
 166                 return -EINVAL;
 167         }
 168
 169         if ((spi->mode & SPI_LSB_FIRST) == 0) {
 170                 dev_err(&spi->dev, "unsupported MSB first mode\n");
 171                 return -EINVAL;
 172         }
 173
 174         if ((spi->mode & SPI_3WIRE) == 0) {
 175                 dev_err(&spi->dev, "unsupported wiring. 3 wires required\n");
 176                 return -EINVAL;
 177         }
 178
 179         return 0;
 180 }
 181
 182 #ifdef CONFIG_OF
 183 static const struct of_device_id spi_lp8841_rtc_dt_ids[] = {
 184         { .compatible = "icpdas,lp8841-spi-rtc" },
 185         { }
 186 };
 187
 188 MODULE_DEVICE_TABLE(of, spi_lp8841_rtc_dt_ids);
 189 #endif
 190
 191 static int
 192 spi_lp8841_rtc_probe(struct platform_device *pdev)
 193 {
 194         int                             ret;
 195         struct spi_master               *master;
 196         struct spi_lp8841_rtc           *data;
 197         void                            *iomem;
 198
 199         master = spi_alloc_master(&pdev->dev, sizeof(*data));
 200         if (!master)
 201                 return -ENOMEM;
 202         platform_set_drvdata(pdev, master);
 203
 204         master->flags = SPI_MASTER_HALF_DUPLEX;
 205         master->mode_bits = SPI_CS_HIGH | SPI_3WIRE | SPI_LSB_FIRST;
 206
 207         master->bus_num = pdev->id;
 208         master->num_chipselect = 1;
 209         master->setup = spi_lp8841_rtc_setup;
 210         master->set_cs = spi_lp8841_rtc_set_cs;
 211         master->transfer_one = spi_lp8841_rtc_transfer_one;
 212         master->bits_per_word_mask = SPI_BPW_MASK(8);
 213 #ifdef CONFIG_OF
 214         master->dev.of_node = pdev->dev.of_node;
 215 #endif
 216
 217         data = spi_master_get_devdata(master);
 218
 219         iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 220         data->iomem = devm_ioremap_resource(&pdev->dev, iomem);
 221         ret = PTR_ERR_OR_ZERO(data->iomem);
 222         if (ret) {
 223                 dev_err(&pdev->dev, "failed to get IO address\n");
 224                 goto err_put_master;
 225         }
 226
 227         /* register with the SPI framework */
 228         ret = devm_spi_register_master(&pdev->dev, master);
 229         if (ret) {
 230                 dev_err(&pdev->dev, "cannot register spi master\n");
 231                 goto err_put_master;
 232         }
 233
 234         return ret;
 235
 236
 237 err_put_master:
 238         spi_master_put(master);
 239
 240         return ret;
 241 }
 242
 243 MODULE_ALIAS("platform:" DRIVER_NAME);
 244
 245 static struct platform_driver spi_lp8841_rtc_driver = {
 246         .driver = {
 247                 .name   = DRIVER_NAME,
 248                 .of_match_table = of_match_ptr(spi_lp8841_rtc_dt_ids),
 249         },
 250         .probe          = spi_lp8841_rtc_probe,
 251 };
 252 module_platform_driver(spi_lp8841_rtc_driver);
 253
 254 MODULE_DESCRIPTION("SPI master driver for ICP DAS LP-8841 RTC");
 255 MODULE_AUTHOR("Sergei Ianovich");
 256 MODULE_LICENSE("GPL");