net/phy/spi_ks8995.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * SPI driver for Micrel/Kendin KS8995M and KSZ8864RMN ethernet switches
0004  *
0005  * Copyright (C) 2008 Gabor Juhos <juhosg at openwrt.org>
0006  *
0007  * This file was based on: drivers/spi/at25.c
0008  *     Copyright (C) 2006 David Brownell
0009  */
0010
0011 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0012
0013 #include <linux/types.h>
0014 #include <linux/kernel.h>
0015 #include <linux/module.h>
0016 #include <linux/delay.h>
0017 #include <linux/device.h>
0018 #include <linux/gpio/consumer.h>
0019 #include <linux/of.h>
0020 #include <linux/of_gpio.h>
0021
0022 #include <linux/spi/spi.h>
0023
0024 #define DRV_VERSION     "0.1.1"
0025 #define DRV_DESC        "Micrel KS8995 Ethernet switch SPI driver"
0026
0027 /* ------------------------------------------------------------------------ */
0028
0029 #define KS8995_REG_ID0      0x00    /* Chip ID0 */
0030 #define KS8995_REG_ID1      0x01    /* Chip ID1 */
0031
0032 #define KS8995_REG_GC0      0x02    /* Global Control 0 */
0033 #define KS8995_REG_GC1      0x03    /* Global Control 1 */
0034 #define KS8995_REG_GC2      0x04    /* Global Control 2 */
0035 #define KS8995_REG_GC3      0x05    /* Global Control 3 */
0036 #define KS8995_REG_GC4      0x06    /* Global Control 4 */
0037 #define KS8995_REG_GC5      0x07    /* Global Control 5 */
0038 #define KS8995_REG_GC6      0x08    /* Global Control 6 */
0039 #define KS8995_REG_GC7      0x09    /* Global Control 7 */
0040 #define KS8995_REG_GC8      0x0a    /* Global Control 8 */
0041 #define KS8995_REG_GC9      0x0b    /* Global Control 9 */
0042
0043 #define KS8995_REG_PC(p, r) ((0x10 * p) + r)     /* Port Control */
0044 #define KS8995_REG_PS(p, r) ((0x10 * p) + r + 0xe)  /* Port Status */
0045
0046 #define KS8995_REG_TPC0     0x60    /* TOS Priority Control 0 */
0047 #define KS8995_REG_TPC1     0x61    /* TOS Priority Control 1 */
0048 #define KS8995_REG_TPC2     0x62    /* TOS Priority Control 2 */
0049 #define KS8995_REG_TPC3     0x63    /* TOS Priority Control 3 */
0050 #define KS8995_REG_TPC4     0x64    /* TOS Priority Control 4 */
0051 #define KS8995_REG_TPC5     0x65    /* TOS Priority Control 5 */
0052 #define KS8995_REG_TPC6     0x66    /* TOS Priority Control 6 */
0053 #define KS8995_REG_TPC7     0x67    /* TOS Priority Control 7 */
0054
0055 #define KS8995_REG_MAC0     0x68    /* MAC address 0 */
0056 #define KS8995_REG_MAC1     0x69    /* MAC address 1 */
0057 #define KS8995_REG_MAC2     0x6a    /* MAC address 2 */
0058 #define KS8995_REG_MAC3     0x6b    /* MAC address 3 */
0059 #define KS8995_REG_MAC4     0x6c    /* MAC address 4 */
0060 #define KS8995_REG_MAC5     0x6d    /* MAC address 5 */
0061
0062 #define KS8995_REG_IAC0     0x6e    /* Indirect Access Control 0 */
0063 #define KS8995_REG_IAC1     0x6f    /* Indirect Access Control 0 */
0064 #define KS8995_REG_IAD7     0x70    /* Indirect Access Data 7 */
0065 #define KS8995_REG_IAD6     0x71    /* Indirect Access Data 6 */
0066 #define KS8995_REG_IAD5     0x72    /* Indirect Access Data 5 */
0067 #define KS8995_REG_IAD4     0x73    /* Indirect Access Data 4 */
0068 #define KS8995_REG_IAD3     0x74    /* Indirect Access Data 3 */
0069 #define KS8995_REG_IAD2     0x75    /* Indirect Access Data 2 */
0070 #define KS8995_REG_IAD1     0x76    /* Indirect Access Data 1 */
0071 #define KS8995_REG_IAD0     0x77    /* Indirect Access Data 0 */
0072
0073 #define KSZ8864_REG_ID1     0xfe    /* Chip ID in bit 7 */
0074
0075 #define KS8995_REGS_SIZE    0x80
0076 #define KSZ8864_REGS_SIZE   0x100
0077 #define KSZ8795_REGS_SIZE   0x100
0078
0079 #define ID1_CHIPID_M        0xf
0080 #define ID1_CHIPID_S        4
0081 #define ID1_REVISION_M      0x7
0082 #define ID1_REVISION_S      1
0083 #define ID1_START_SW        1   /* start the switch */
0084
0085 #define FAMILY_KS8995       0x95
0086 #define FAMILY_KSZ8795      0x87
0087 #define CHIPID_M        0
0088 #define KS8995_CHIP_ID      0x00
0089 #define KSZ8864_CHIP_ID     0x01
0090 #define KSZ8795_CHIP_ID     0x09
0091
0092 #define KS8995_CMD_WRITE    0x02U
0093 #define KS8995_CMD_READ     0x03U
0094
0095 #define KS8995_RESET_DELAY  10 /* usec */
0096
0097 enum ks8995_chip_variant {
0098     ks8995,
0099     ksz8864,
0100     ksz8795,
0101     max_variant
0102 };
0103
0104 struct ks8995_chip_params {
0105     char *name;
0106     int family_id;
0107     int chip_id;
0108     int regs_size;
0109     int addr_width;
0110     int addr_shift;
0111 };
0112
0113 static const struct ks8995_chip_params ks8995_chip[] = {
0114     [ks8995] = {
0115         .name = "KS8995MA",
0116         .family_id = FAMILY_KS8995,
0117         .chip_id = KS8995_CHIP_ID,
0118         .regs_size = KS8995_REGS_SIZE,
0119         .addr_width = 8,
0120         .addr_shift = 0,
0121     },
0122     [ksz8864] = {
0123         .name = "KSZ8864RMN",
0124         .family_id = FAMILY_KS8995,
0125         .chip_id = KSZ8864_CHIP_ID,
0126         .regs_size = KSZ8864_REGS_SIZE,
0127         .addr_width = 8,
0128         .addr_shift = 0,
0129     },
0130     [ksz8795] = {
0131         .name = "KSZ8795CLX",
0132         .family_id = FAMILY_KSZ8795,
0133         .chip_id = KSZ8795_CHIP_ID,
0134         .regs_size = KSZ8795_REGS_SIZE,
0135         .addr_width = 12,
0136         .addr_shift = 1,
0137     },
0138 };
0139
0140 struct ks8995_pdata {
0141     int reset_gpio;
0142     enum of_gpio_flags reset_gpio_flags;
0143 };
0144
0145 struct ks8995_switch {
0146     struct spi_device   *spi;
0147     struct mutex        lock;
0148     struct ks8995_pdata *pdata;
0149     struct bin_attribute    regs_attr;
0150     const struct ks8995_chip_params *chip;
0151     int         revision_id;
0152 };
0153
0154 static const struct spi_device_id ks8995_id[] = {
0155     {"ks8995", ks8995},
0156     {"ksz8864", ksz8864},
0157     {"ksz8795", ksz8795},
0158     { }
0159 };
0160 MODULE_DEVICE_TABLE(spi, ks8995_id);
0161
0162 static const struct of_device_id ks8895_spi_of_match[] = {
0163     { .compatible = "micrel,ks8995" },
0164     { .compatible = "micrel,ksz8864" },
0165     { .compatible = "micrel,ksz8795" },
0166     { },
0167 };
0168 MODULE_DEVICE_TABLE(of, ks8895_spi_of_match);
0169
0170 static inline u8 get_chip_id(u8 val)
0171 {
0172     return (val >> ID1_CHIPID_S) & ID1_CHIPID_M;
0173 }
0174
0175 static inline u8 get_chip_rev(u8 val)
0176 {
0177     return (val >> ID1_REVISION_S) & ID1_REVISION_M;
0178 }
0179
0180 /* create_spi_cmd - create a chip specific SPI command header
0181  * @ks: pointer to switch instance
0182  * @cmd: SPI command for switch
0183  * @address: register address for command
0184  *
0185  * Different chip families use different bit pattern to address the switches
0186  * registers:
0187  *
0188  * KS8995: 8bit command + 8bit address
0189  * KSZ8795: 3bit command + 12bit address + 1bit TR (?)
0190  */
0191 static inline __be16 create_spi_cmd(struct ks8995_switch *ks, int cmd,
0192                     unsigned address)
0193 {
0194     u16 result = cmd;
0195
0196     /* make room for address (incl. address shift) */
0197     result <<= ks->chip->addr_width + ks->chip->addr_shift;
0198     /* add address */
0199     result |= address << ks->chip->addr_shift;
0200     /* SPI protocol needs big endian */
0201     return cpu_to_be16(result);
0202 }
0203 /* ------------------------------------------------------------------------ */
0204 static int ks8995_read(struct ks8995_switch *ks, char *buf,
0205          unsigned offset, size_t count)
0206 {
0207     __be16 cmd;
0208     struct spi_transfer t[2];
0209     struct spi_message m;
0210     int err;
0211
0212     cmd = create_spi_cmd(ks, KS8995_CMD_READ, offset);
0213     spi_message_init(&m);
0214
0215     memset(&t, 0, sizeof(t));
0216
0217     t[0].tx_buf = &cmd;
0218     t[0].len = sizeof(cmd);
0219     spi_message_add_tail(&t[0], &m);
0220
0221     t[1].rx_buf = buf;
0222     t[1].len = count;
0223     spi_message_add_tail(&t[1], &m);
0224
0225     mutex_lock(&ks->lock);
0226     err = spi_sync(ks->spi, &m);
0227     mutex_unlock(&ks->lock);
0228
0229     return err ? err : count;
0230 }
0231
0232 static int ks8995_write(struct ks8995_switch *ks, char *buf,
0233          unsigned offset, size_t count)
0234 {
0235     __be16 cmd;
0236     struct spi_transfer t[2];
0237     struct spi_message m;
0238     int err;
0239
0240     cmd = create_spi_cmd(ks, KS8995_CMD_WRITE, offset);
0241     spi_message_init(&m);
0242
0243     memset(&t, 0, sizeof(t));
0244
0245     t[0].tx_buf = &cmd;
0246     t[0].len = sizeof(cmd);
0247     spi_message_add_tail(&t[0], &m);
0248
0249     t[1].tx_buf = buf;
0250     t[1].len = count;
0251     spi_message_add_tail(&t[1], &m);
0252
0253     mutex_lock(&ks->lock);
0254     err = spi_sync(ks->spi, &m);
0255     mutex_unlock(&ks->lock);
0256
0257     return err ? err : count;
0258 }
0259
0260 static inline int ks8995_read_reg(struct ks8995_switch *ks, u8 addr, u8 *buf)
0261 {
0262     return ks8995_read(ks, buf, addr, 1) != 1;
0263 }
0264
0265 static inline int ks8995_write_reg(struct ks8995_switch *ks, u8 addr, u8 val)
0266 {
0267     char buf = val;
0268
0269     return ks8995_write(ks, &buf, addr, 1) != 1;
0270 }
0271
0272 /* ------------------------------------------------------------------------ */
0273
0274 static int ks8995_stop(struct ks8995_switch *ks)
0275 {
0276     return ks8995_write_reg(ks, KS8995_REG_ID1, 0);
0277 }
0278
0279 static int ks8995_start(struct ks8995_switch *ks)
0280 {
0281     return ks8995_write_reg(ks, KS8995_REG_ID1, 1);
0282 }
0283
0284 static int ks8995_reset(struct ks8995_switch *ks)
0285 {
0286     int err;
0287
0288     err = ks8995_stop(ks);
0289     if (err)
0290         return err;
0291
0292     udelay(KS8995_RESET_DELAY);
0293
0294     return ks8995_start(ks);
0295 }
0296
0297 static ssize_t ks8995_registers_read(struct file *filp, struct kobject *kobj,
0298     struct bin_attribute *bin_attr, char *buf, loff_t off, size_t count)
0299 {
0300     struct device *dev;
0301     struct ks8995_switch *ks8995;
0302
0303     dev = kobj_to_dev(kobj);
0304     ks8995 = dev_get_drvdata(dev);
0305
0306     return ks8995_read(ks8995, buf, off, count);
0307 }
0308
0309 static ssize_t ks8995_registers_write(struct file *filp, struct kobject *kobj,
0310     struct bin_attribute *bin_attr, char *buf, loff_t off, size_t count)
0311 {
0312     struct device *dev;
0313     struct ks8995_switch *ks8995;
0314
0315     dev = kobj_to_dev(kobj);
0316     ks8995 = dev_get_drvdata(dev);
0317
0318     return ks8995_write(ks8995, buf, off, count);
0319 }
0320
0321 /* ks8995_get_revision - get chip revision
0322  * @ks: pointer to switch instance
0323  *
0324  * Verify chip family and id and get chip revision.
0325  */
0326 static int ks8995_get_revision(struct ks8995_switch *ks)
0327 {
0328     int err;
0329     u8 id0, id1, ksz8864_id;
0330
0331     /* read family id */
0332     err = ks8995_read_reg(ks, KS8995_REG_ID0, &id0);
0333     if (err) {
0334         err = -EIO;
0335         goto err_out;
0336     }
0337
0338     /* verify family id */
0339     if (id0 != ks->chip->family_id) {
0340         dev_err(&ks->spi->dev, "chip family id mismatch: expected 0x%02x but 0x%02x read\n",
0341             ks->chip->family_id, id0);
0342         err = -ENODEV;
0343         goto err_out;
0344     }
0345
0346     switch (ks->chip->family_id) {
0347     case FAMILY_KS8995:
0348         /* try reading chip id at CHIP ID1 */
0349         err = ks8995_read_reg(ks, KS8995_REG_ID1, &id1);
0350         if (err) {
0351             err = -EIO;
0352             goto err_out;
0353         }
0354
0355         /* verify chip id */
0356         if ((get_chip_id(id1) == CHIPID_M) &&
0357             (get_chip_id(id1) == ks->chip->chip_id)) {
0358             /* KS8995MA */
0359             ks->revision_id = get_chip_rev(id1);
0360         } else if (get_chip_id(id1) != CHIPID_M) {
0361             /* KSZ8864RMN */
0362             err = ks8995_read_reg(ks, KS8995_REG_ID1, &ksz8864_id);
0363             if (err) {
0364                 err = -EIO;
0365                 goto err_out;
0366             }
0367
0368             if ((ksz8864_id & 0x80) &&
0369                 (ks->chip->chip_id == KSZ8864_CHIP_ID)) {
0370                 ks->revision_id = get_chip_rev(id1);
0371             }
0372
0373         } else {
0374             dev_err(&ks->spi->dev, "unsupported chip id for KS8995 family: 0x%02x\n",
0375                 id1);
0376             err = -ENODEV;
0377         }
0378         break;
0379     case FAMILY_KSZ8795:
0380         /* try reading chip id at CHIP ID1 */
0381         err = ks8995_read_reg(ks, KS8995_REG_ID1, &id1);
0382         if (err) {
0383             err = -EIO;
0384             goto err_out;
0385         }
0386
0387         if (get_chip_id(id1) == ks->chip->chip_id) {
0388             ks->revision_id = get_chip_rev(id1);
0389         } else {
0390             dev_err(&ks->spi->dev, "unsupported chip id for KSZ8795 family: 0x%02x\n",
0391                 id1);
0392             err = -ENODEV;
0393         }
0394         break;
0395     default:
0396         dev_err(&ks->spi->dev, "unsupported family id: 0x%02x\n", id0);
0397         err = -ENODEV;
0398         break;
0399     }
0400 err_out:
0401     return err;
0402 }
0403
0404 /* ks8995_parse_dt - setup platform data from devicetree
0405  * @ks: pointer to switch instance
0406  *
0407  * Parses supported DT properties and sets up platform data
0408  * accordingly.
0409  */
0410 static void ks8995_parse_dt(struct ks8995_switch *ks)
0411 {
0412     struct device_node *np = ks->spi->dev.of_node;
0413     struct ks8995_pdata *pdata = ks->pdata;
0414
0415     if (!np)
0416         return;
0417
0418     pdata->reset_gpio = of_get_named_gpio_flags(np, "reset-gpios", 0,
0419         &pdata->reset_gpio_flags);
0420 }
0421
0422 static const struct bin_attribute ks8995_registers_attr = {
0423     .attr = {
0424         .name   = "registers",
0425         .mode   = 0600,
0426     },
0427     .size   = KS8995_REGS_SIZE,
0428     .read   = ks8995_registers_read,
0429     .write  = ks8995_registers_write,
0430 };
0431
0432 /* ------------------------------------------------------------------------ */
0433 static int ks8995_probe(struct spi_device *spi)
0434 {
0435     struct ks8995_switch *ks;
0436     int err;
0437     int variant = spi_get_device_id(spi)->driver_data;
0438
0439     if (variant >= max_variant) {
0440         dev_err(&spi->dev, "bad chip variant %d\n", variant);
0441         return -ENODEV;
0442     }
0443
0444     ks = devm_kzalloc(&spi->dev, sizeof(*ks), GFP_KERNEL);
0445     if (!ks)
0446         return -ENOMEM;
0447
0448     mutex_init(&ks->lock);
0449     ks->spi = spi;
0450     ks->chip = &ks8995_chip[variant];
0451
0452     if (ks->spi->dev.of_node) {
0453         ks->pdata = devm_kzalloc(&spi->dev, sizeof(*ks->pdata),
0454                      GFP_KERNEL);
0455         if (!ks->pdata)
0456             return -ENOMEM;
0457
0458         ks->pdata->reset_gpio = -1;
0459
0460         ks8995_parse_dt(ks);
0461     }
0462
0463     if (!ks->pdata)
0464         ks->pdata = spi->dev.platform_data;
0465
0466     /* de-assert switch reset */
0467     if (ks->pdata && gpio_is_valid(ks->pdata->reset_gpio)) {
0468         unsigned long flags;
0469
0470         flags = (ks->pdata->reset_gpio_flags == OF_GPIO_ACTIVE_LOW ?
0471              GPIOF_ACTIVE_LOW : 0);
0472
0473         err = devm_gpio_request_one(&spi->dev,
0474                         ks->pdata->reset_gpio,
0475                         flags, "switch-reset");
0476         if (err) {
0477             dev_err(&spi->dev,
0478                 "failed to get reset-gpios: %d\n", err);
0479             return -EIO;
0480         }
0481
0482         gpiod_set_value(gpio_to_desc(ks->pdata->reset_gpio), 0);
0483     }
0484
0485     spi_set_drvdata(spi, ks);
0486
0487     spi->mode = SPI_MODE_0;
0488     spi->bits_per_word = 8;
0489     err = spi_setup(spi);
0490     if (err) {
0491         dev_err(&spi->dev, "spi_setup failed, err=%d\n", err);
0492         return err;
0493     }
0494
0495     err = ks8995_get_revision(ks);
0496     if (err)
0497         return err;
0498
0499     memcpy(&ks->regs_attr, &ks8995_registers_attr, sizeof(ks->regs_attr));
0500     ks->regs_attr.size = ks->chip->regs_size;
0501
0502     err = ks8995_reset(ks);
0503     if (err)
0504         return err;
0505
0506     sysfs_attr_init(&ks->regs_attr.attr);
0507     err = sysfs_create_bin_file(&spi->dev.kobj, &ks->regs_attr);
0508     if (err) {
0509         dev_err(&spi->dev, "unable to create sysfs file, err=%d\n",
0510                     err);
0511         return err;
0512     }
0513
0514     dev_info(&spi->dev, "%s device found, Chip ID:%x, Revision:%x\n",
0515          ks->chip->name, ks->chip->chip_id, ks->revision_id);
0516
0517     return 0;
0518 }
0519
0520 static void ks8995_remove(struct spi_device *spi)
0521 {
0522     struct ks8995_switch *ks = spi_get_drvdata(spi);
0523
0524     sysfs_remove_bin_file(&spi->dev.kobj, &ks->regs_attr);
0525
0526     /* assert reset */
0527     if (ks->pdata && gpio_is_valid(ks->pdata->reset_gpio))
0528         gpiod_set_value(gpio_to_desc(ks->pdata->reset_gpio), 1);
0529 }
0530
0531 /* ------------------------------------------------------------------------ */
0532 static struct spi_driver ks8995_driver = {
0533     .driver = {
0534         .name       = "spi-ks8995",
0535         .of_match_table = of_match_ptr(ks8895_spi_of_match),
0536     },
0537     .probe    = ks8995_probe,
0538     .remove   = ks8995_remove,
0539     .id_table = ks8995_id,
0540 };
0541
0542 module_spi_driver(ks8995_driver);
0543
0544 MODULE_DESCRIPTION(DRV_DESC);
0545 MODULE_VERSION(DRV_VERSION);
0546 MODULE_AUTHOR("Gabor Juhos <juhosg at openwrt.org>");
0547 MODULE_LICENSE("GPL v2");