drivers/net/dsa/b53/b53_spi.c

   1 /*
   2  * B53 register access through SPI
   3  *
   4  * Copyright (C) 2011-2013 Jonas Gorski <jogo@openwrt.org>
   5  *
   6  * Permission to use, copy, modify, and/or distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18
  19 #include <linux/unaligned.h>
  20
  21 #include <linux/delay.h>
  22 #include <linux/kernel.h>
  23 #include <linux/module.h>
  24 #include <linux/spi/spi.h>
  25 #include <linux/platform_data/b53.h>
  26
  27 #include "b53_priv.h"
  28
  29 #define B53_SPI_DATA            0xf0
  30
  31 #define B53_SPI_STATUS          0xfe
  32 #define B53_SPI_CMD_SPIF        BIT(7)
  33 #define B53_SPI_CMD_RACK        BIT(5)
  34
  35 #define B53_SPI_CMD_READ        0x00
  36 #define B53_SPI_CMD_WRITE       0x01
  37 #define B53_SPI_CMD_NORMAL      0x60
  38 #define B53_SPI_CMD_FAST        0x10
  39
  40 #define B53_SPI_PAGE_SELECT     0xff
  41
  42 static inline int b53_spi_read_reg(struct spi_device *spi, u8 reg, u8 *val,
  43                                    unsigned int len)
  44 {
  45         u8 txbuf[2];
  46
  47         txbuf[0] = B53_SPI_CMD_NORMAL | B53_SPI_CMD_READ;
  48         txbuf[1] = reg;
  49
  50         return spi_write_then_read(spi, txbuf, 2, val, len);
  51 }
  52
  53 static inline int b53_spi_clear_status(struct spi_device *spi)
  54 {
  55         unsigned int i;
  56         u8 rxbuf;
  57         int ret;
  58
  59         for (i = 0; i < 10; i++) {
  60                 ret = b53_spi_read_reg(spi, B53_SPI_STATUS, &rxbuf, 1);
  61                 if (ret)
  62                         return ret;
  63
  64                 if (!(rxbuf & B53_SPI_CMD_SPIF))
  65                         break;
  66
  67                 mdelay(1);
  68         }
  69
  70         if (i == 10)
  71                 return -EIO;
  72
  73         return 0;
  74 }
  75
  76 static inline int b53_spi_set_page(struct spi_device *spi, u8 page)
  77 {
  78         u8 txbuf[3];
  79
  80         txbuf[0] = B53_SPI_CMD_NORMAL | B53_SPI_CMD_WRITE;
  81         txbuf[1] = B53_SPI_PAGE_SELECT;
  82         txbuf[2] = page;
  83
  84         return spi_write(spi, txbuf, sizeof(txbuf));
  85 }
  86
  87 static inline int b53_prepare_reg_access(struct spi_device *spi, u8 page)
  88 {
  89         int ret = b53_spi_clear_status(spi);
  90
  91         if (ret)
  92                 return ret;
  93
  94         return b53_spi_set_page(spi, page);
  95 }
  96
  97 static int b53_spi_prepare_reg_read(struct spi_device *spi, u8 reg)
  98 {
  99         u8 rxbuf;
 100         int retry_count;
 101         int ret;
 102
 103         ret = b53_spi_read_reg(spi, reg, &rxbuf, 1);
 104         if (ret)
 105                 return ret;
 106
 107         for (retry_count = 0; retry_count < 10; retry_count++) {
 108                 ret = b53_spi_read_reg(spi, B53_SPI_STATUS, &rxbuf, 1);
 109                 if (ret)
 110                         return ret;
 111
 112                 if (rxbuf & B53_SPI_CMD_RACK)
 113                         break;
 114
 115                 mdelay(1);
 116         }
 117
 118         if (retry_count == 10)
 119                 return -EIO;
 120
 121         return 0;
 122 }
 123
 124 static int b53_spi_read(struct b53_device *dev, u8 page, u8 reg, u8 *data,
 125                         unsigned int len)
 126 {
 127         struct spi_device *spi = dev->priv;
 128         int ret;
 129
 130         ret = b53_prepare_reg_access(spi, page);
 131         if (ret)
 132                 return ret;
 133
 134         ret = b53_spi_prepare_reg_read(spi, reg);
 135         if (ret)
 136                 return ret;
 137
 138         return b53_spi_read_reg(spi, B53_SPI_DATA, data, len);
 139 }
 140
 141 static int b53_spi_read8(struct b53_device *dev, u8 page, u8 reg, u8 *val)
 142 {
 143         return b53_spi_read(dev, page, reg, val, 1);
 144 }
 145
 146 static int b53_spi_read16(struct b53_device *dev, u8 page, u8 reg, u16 *val)
 147 {
 148         __le16 value;
 149         int ret;
 150
 151         ret = b53_spi_read(dev, page, reg, (u8 *)&value, 2);
 152
 153         if (!ret)
 154                 *val = le16_to_cpu(value);
 155
 156         return ret;
 157 }
 158
 159 static int b53_spi_read32(struct b53_device *dev, u8 page, u8 reg, u32 *val)
 160 {
 161         __le32 value;
 162         int ret;
 163
 164         ret = b53_spi_read(dev, page, reg, (u8 *)&value, 4);
 165
 166         if (!ret)
 167                 *val = le32_to_cpu(value);
 168
 169         return ret;
 170 }
 171
 172 static int b53_spi_read48(struct b53_device *dev, u8 page, u8 reg, u64 *val)
 173 {
 174         __le64 value;
 175         int ret;
 176
 177         *val = 0;
 178         ret = b53_spi_read(dev, page, reg, (u8 *)&value, 6);
 179         if (!ret)
 180                 *val = le64_to_cpu(value);
 181
 182         return ret;
 183 }
 184
 185 static int b53_spi_read64(struct b53_device *dev, u8 page, u8 reg, u64 *val)
 186 {
 187         __le64 value;
 188         int ret;
 189
 190         ret = b53_spi_read(dev, page, reg, (u8 *)&value, 8);
 191
 192         if (!ret)
 193                 *val = le64_to_cpu(value);
 194
 195         return ret;
 196 }
 197
 198 static int b53_spi_write8(struct b53_device *dev, u8 page, u8 reg, u8 value)
 199 {
 200         struct spi_device *spi = dev->priv;
 201         int ret;
 202         u8 txbuf[3];
 203
 204         ret = b53_prepare_reg_access(spi, page);
 205         if (ret)
 206                 return ret;
 207
 208         txbuf[0] = B53_SPI_CMD_NORMAL | B53_SPI_CMD_WRITE;
 209         txbuf[1] = reg;
 210         txbuf[2] = value;
 211
 212         return spi_write(spi, txbuf, sizeof(txbuf));
 213 }
 214
 215 static int b53_spi_write16(struct b53_device *dev, u8 page, u8 reg, u16 value)
 216 {
 217         struct spi_device *spi = dev->priv;
 218         int ret;
 219         u8 txbuf[4];
 220
 221         ret = b53_prepare_reg_access(spi, page);
 222         if (ret)
 223                 return ret;
 224
 225         txbuf[0] = B53_SPI_CMD_NORMAL | B53_SPI_CMD_WRITE;
 226         txbuf[1] = reg;
 227         put_unaligned_le16(value, &txbuf[2]);
 228
 229         return spi_write(spi, txbuf, sizeof(txbuf));
 230 }
 231
 232 static int b53_spi_write32(struct b53_device *dev, u8 page, u8 reg, u32 value)
 233 {
 234         struct spi_device *spi = dev->priv;
 235         int ret;
 236         u8 txbuf[6];
 237
 238         ret = b53_prepare_reg_access(spi, page);
 239         if (ret)
 240                 return ret;
 241
 242         txbuf[0] = B53_SPI_CMD_NORMAL | B53_SPI_CMD_WRITE;
 243         txbuf[1] = reg;
 244         put_unaligned_le32(value, &txbuf[2]);
 245
 246         return spi_write(spi, txbuf, sizeof(txbuf));
 247 }
 248
 249 static int b53_spi_write48(struct b53_device *dev, u8 page, u8 reg, u64 value)
 250 {
 251         struct spi_device *spi = dev->priv;
 252         int ret;
 253         u8 txbuf[10];
 254
 255         ret = b53_prepare_reg_access(spi, page);
 256         if (ret)
 257                 return ret;
 258
 259         txbuf[0] = B53_SPI_CMD_NORMAL | B53_SPI_CMD_WRITE;
 260         txbuf[1] = reg;
 261         put_unaligned_le64(value, &txbuf[2]);
 262
 263         return spi_write(spi, txbuf, sizeof(txbuf) - 2);
 264 }
 265
 266 static int b53_spi_write64(struct b53_device *dev, u8 page, u8 reg, u64 value)
 267 {
 268         struct spi_device *spi = dev->priv;
 269         int ret;
 270         u8 txbuf[10];
 271
 272         ret = b53_prepare_reg_access(spi, page);
 273         if (ret)
 274                 return ret;
 275
 276         txbuf[0] = B53_SPI_CMD_NORMAL | B53_SPI_CMD_WRITE;
 277         txbuf[1] = reg;
 278         put_unaligned_le64(value, &txbuf[2]);
 279
 280         return spi_write(spi, txbuf, sizeof(txbuf));
 281 }
 282
 283 static const struct b53_io_ops b53_spi_ops = {
 284         .read8 = b53_spi_read8,
 285         .read16 = b53_spi_read16,
 286         .read32 = b53_spi_read32,
 287         .read48 = b53_spi_read48,
 288         .read64 = b53_spi_read64,
 289         .write8 = b53_spi_write8,
 290         .write16 = b53_spi_write16,
 291         .write32 = b53_spi_write32,
 292         .write48 = b53_spi_write48,
 293         .write64 = b53_spi_write64,
 294 };
 295
 296 static int b53_spi_probe(struct spi_device *spi)
 297 {
 298         struct b53_device *dev;
 299         int ret;
 300
 301         dev = b53_switch_alloc(&spi->dev, &b53_spi_ops, spi);
 302         if (!dev)
 303                 return -ENOMEM;
 304
 305         if (spi->dev.platform_data)
 306                 dev->pdata = spi->dev.platform_data;
 307
 308         ret = b53_switch_register(dev);
 309         if (ret)
 310                 return ret;
 311
 312         spi_set_drvdata(spi, dev);
 313
 314         return 0;
 315 }
 316
 317 static void b53_spi_remove(struct spi_device *spi)
 318 {
 319         struct b53_device *dev = spi_get_drvdata(spi);
 320
 321         if (dev)
 322                 b53_switch_remove(dev);
 323 }
 324
 325 static void b53_spi_shutdown(struct spi_device *spi)
 326 {
 327         struct b53_device *dev = spi_get_drvdata(spi);
 328
 329         if (dev)
 330                 b53_switch_shutdown(dev);
 331
 332         spi_set_drvdata(spi, NULL);
 333 }
 334
 335 static const struct of_device_id b53_spi_of_match[] = {
 336         { .compatible = "brcm,bcm5325" },
 337         { .compatible = "brcm,bcm5365" },
 338         { .compatible = "brcm,bcm5395" },
 339         { .compatible = "brcm,bcm5397" },
 340         { .compatible = "brcm,bcm5398" },
 341         { .compatible = "brcm,bcm53115" },
 342         { .compatible = "brcm,bcm53125" },
 343         { .compatible = "brcm,bcm53128" },
 344         { /* sentinel */ }
 345 };
 346 MODULE_DEVICE_TABLE(of, b53_spi_of_match);
 347
 348 static const struct spi_device_id b53_spi_ids[] = {
 349         { .name = "bcm5325" },
 350         { .name = "bcm5365" },
 351         { .name = "bcm5395" },
 352         { .name = "bcm5397" },
 353         { .name = "bcm5398" },
 354         { .name = "bcm53115" },
 355         { .name = "bcm53125" },
 356         { .name = "bcm53128" },
 357         { /* sentinel */ }
 358 };
 359 MODULE_DEVICE_TABLE(spi, b53_spi_ids);
 360
 361 static struct spi_driver b53_spi_driver = {
 362         .driver = {
 363                 .name   = "b53-switch",
 364                 .of_match_table = b53_spi_of_match,
 365         },
 366         .probe  = b53_spi_probe,
 367         .remove = b53_spi_remove,
 368         .shutdown = b53_spi_shutdown,
 369         .id_table = b53_spi_ids,
 370 };
 371
 372 module_spi_driver(b53_spi_driver);
 373
 374 MODULE_AUTHOR("Jonas Gorski <jogo@openwrt.org>");
 375 MODULE_DESCRIPTION("B53 SPI access driver");
 376 MODULE_LICENSE("Dual BSD/GPL");