linux/drivers/net/phy/spi_ks8995.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * SPI driver for Micrel/Kendin KS8995M and KSZ8864RMN ethernet switches
   4 *
   5 * Copyright (C) 2008 Gabor Juhos <juhosg at openwrt.org>
   6 *
   7 * This file was based on: drivers/spi/at25.c
   8 *     Copyright (C) 2006 David Brownell
   9 */
  10
  11#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  12
  13#include <linux/types.h>
  14#include <linux/kernel.h>
  15#include <linux/module.h>
  16#include <linux/delay.h>
  17#include <linux/device.h>
  18#include <linux/gpio/consumer.h>
  19#include <linux/of.h>
  20#include <linux/of_gpio.h>
  21
  22#include <linux/spi/spi.h>
  23
  24#define DRV_VERSION             "0.1.1"
  25#define DRV_DESC                "Micrel KS8995 Ethernet switch SPI driver"
  26
  27/* ------------------------------------------------------------------------ */
  28
  29#define KS8995_REG_ID0          0x00    /* Chip ID0 */
  30#define KS8995_REG_ID1          0x01    /* Chip ID1 */
  31
  32#define KS8995_REG_GC0          0x02    /* Global Control 0 */
  33#define KS8995_REG_GC1          0x03    /* Global Control 1 */
  34#define KS8995_REG_GC2          0x04    /* Global Control 2 */
  35#define KS8995_REG_GC3          0x05    /* Global Control 3 */
  36#define KS8995_REG_GC4          0x06    /* Global Control 4 */
  37#define KS8995_REG_GC5          0x07    /* Global Control 5 */
  38#define KS8995_REG_GC6          0x08    /* Global Control 6 */
  39#define KS8995_REG_GC7          0x09    /* Global Control 7 */
  40#define KS8995_REG_GC8          0x0a    /* Global Control 8 */
  41#define KS8995_REG_GC9          0x0b    /* Global Control 9 */
  42
  43#define KS8995_REG_PC(p, r)     ((0x10 * p) + r)         /* Port Control */
  44#define KS8995_REG_PS(p, r)     ((0x10 * p) + r + 0xe)  /* Port Status */
  45
  46#define KS8995_REG_TPC0         0x60    /* TOS Priority Control 0 */
  47#define KS8995_REG_TPC1         0x61    /* TOS Priority Control 1 */
  48#define KS8995_REG_TPC2         0x62    /* TOS Priority Control 2 */
  49#define KS8995_REG_TPC3         0x63    /* TOS Priority Control 3 */
  50#define KS8995_REG_TPC4         0x64    /* TOS Priority Control 4 */
  51#define KS8995_REG_TPC5         0x65    /* TOS Priority Control 5 */
  52#define KS8995_REG_TPC6         0x66    /* TOS Priority Control 6 */
  53#define KS8995_REG_TPC7         0x67    /* TOS Priority Control 7 */
  54
  55#define KS8995_REG_MAC0         0x68    /* MAC address 0 */
  56#define KS8995_REG_MAC1         0x69    /* MAC address 1 */
  57#define KS8995_REG_MAC2         0x6a    /* MAC address 2 */
  58#define KS8995_REG_MAC3         0x6b    /* MAC address 3 */
  59#define KS8995_REG_MAC4         0x6c    /* MAC address 4 */
  60#define KS8995_REG_MAC5         0x6d    /* MAC address 5 */
  61
  62#define KS8995_REG_IAC0         0x6e    /* Indirect Access Control 0 */
  63#define KS8995_REG_IAC1         0x6f    /* Indirect Access Control 0 */
  64#define KS8995_REG_IAD7         0x70    /* Indirect Access Data 7 */
  65#define KS8995_REG_IAD6         0x71    /* Indirect Access Data 6 */
  66#define KS8995_REG_IAD5         0x72    /* Indirect Access Data 5 */
  67#define KS8995_REG_IAD4         0x73    /* Indirect Access Data 4 */
  68#define KS8995_REG_IAD3         0x74    /* Indirect Access Data 3 */
  69#define KS8995_REG_IAD2         0x75    /* Indirect Access Data 2 */
  70#define KS8995_REG_IAD1         0x76    /* Indirect Access Data 1 */
  71#define KS8995_REG_IAD0         0x77    /* Indirect Access Data 0 */
  72
  73#define KSZ8864_REG_ID1         0xfe    /* Chip ID in bit 7 */
  74
  75#define KS8995_REGS_SIZE        0x80
  76#define KSZ8864_REGS_SIZE       0x100
  77#define KSZ8795_REGS_SIZE       0x100
  78
  79#define ID1_CHIPID_M            0xf
  80#define ID1_CHIPID_S            4
  81#define ID1_REVISION_M          0x7
  82#define ID1_REVISION_S          1
  83#define ID1_START_SW            1       /* start the switch */
  84
  85#define FAMILY_KS8995           0x95
  86#define FAMILY_KSZ8795          0x87
  87#define CHIPID_M                0
  88#define KS8995_CHIP_ID          0x00
  89#define KSZ8864_CHIP_ID         0x01
  90#define KSZ8795_CHIP_ID         0x09
  91
  92#define KS8995_CMD_WRITE        0x02U
  93#define KS8995_CMD_READ         0x03U
  94
  95#define KS8995_RESET_DELAY      10 /* usec */
  96
  97enum ks8995_chip_variant {
  98        ks8995,
  99        ksz8864,
 100        ksz8795,
 101        max_variant
 102};
 103
 104struct ks8995_chip_params {
 105        char *name;
 106        int family_id;
 107        int chip_id;
 108        int regs_size;
 109        int addr_width;
 110        int addr_shift;
 111};
 112
 113static const struct ks8995_chip_params ks8995_chip[] = {
 114        [ks8995] = {
 115                .name = "KS8995MA",
 116                .family_id = FAMILY_KS8995,
 117                .chip_id = KS8995_CHIP_ID,
 118                .regs_size = KS8995_REGS_SIZE,
 119                .addr_width = 8,
 120                .addr_shift = 0,
 121        },
 122        [ksz8864] = {
 123                .name = "KSZ8864RMN",
 124                .family_id = FAMILY_KS8995,
 125                .chip_id = KSZ8864_CHIP_ID,
 126                .regs_size = KSZ8864_REGS_SIZE,
 127                .addr_width = 8,
 128                .addr_shift = 0,
 129        },
 130        [ksz8795] = {
 131                .name = "KSZ8795CLX",
 132                .family_id = FAMILY_KSZ8795,
 133                .chip_id = KSZ8795_CHIP_ID,
 134                .regs_size = KSZ8795_REGS_SIZE,
 135                .addr_width = 12,
 136                .addr_shift = 1,
 137        },
 138};
 139
 140struct ks8995_pdata {
 141        int reset_gpio;
 142        enum of_gpio_flags reset_gpio_flags;
 143};
 144
 145struct ks8995_switch {
 146        struct spi_device       *spi;
 147        struct mutex            lock;
 148        struct ks8995_pdata     *pdata;
 149        struct bin_attribute    regs_attr;
 150        const struct ks8995_chip_params *chip;
 151        int                     revision_id;
 152};
 153
 154static const struct spi_device_id ks8995_id[] = {
 155        {"ks8995", ks8995},
 156        {"ksz8864", ksz8864},
 157        {"ksz8795", ksz8795},
 158        { }
 159};
 160MODULE_DEVICE_TABLE(spi, ks8995_id);
 161
 162static const struct of_device_id ks8895_spi_of_match[] = {
 163        { .compatible = "micrel,ks8995" },
 164        { .compatible = "micrel,ksz8864" },
 165        { .compatible = "micrel,ksz8795" },
 166        { },
 167 };
 168MODULE_DEVICE_TABLE(of, ks8895_spi_of_match);
 169
 170static inline u8 get_chip_id(u8 val)
 171{
 172        return (val >> ID1_CHIPID_S) & ID1_CHIPID_M;
 173}
 174
 175static inline u8 get_chip_rev(u8 val)
 176{
 177        return (val >> ID1_REVISION_S) & ID1_REVISION_M;
 178}
 179
 180/* create_spi_cmd - create a chip specific SPI command header
 181 * @ks: pointer to switch instance
 182 * @cmd: SPI command for switch
 183 * @address: register address for command
 184 *
 185 * Different chip families use different bit pattern to address the switches
 186 * registers:
 187 *
 188 * KS8995: 8bit command + 8bit address
 189 * KSZ8795: 3bit command + 12bit address + 1bit TR (?)
 190 */
 191static inline __be16 create_spi_cmd(struct ks8995_switch *ks, int cmd,
 192                                    unsigned address)
 193{
 194        u16 result = cmd;
 195
 196        /* make room for address (incl. address shift) */
 197        result <<= ks->chip->addr_width + ks->chip->addr_shift;
 198        /* add address */
 199        result |= address << ks->chip->addr_shift;
 200        /* SPI protocol needs big endian */
 201        return cpu_to_be16(result);
 202}
 203/* ------------------------------------------------------------------------ */
 204static int ks8995_read(struct ks8995_switch *ks, char *buf,
 205                 unsigned offset, size_t count)
 206{
 207        __be16 cmd;
 208        struct spi_transfer t[2];
 209        struct spi_message m;
 210        int err;
 211
 212        cmd = create_spi_cmd(ks, KS8995_CMD_READ, offset);
 213        spi_message_init(&m);
 214
 215        memset(&t, 0, sizeof(t));
 216
 217        t[0].tx_buf = &cmd;
 218        t[0].len = sizeof(cmd);
 219        spi_message_add_tail(&t[0], &m);
 220
 221        t[1].rx_buf = buf;
 222        t[1].len = count;
 223        spi_message_add_tail(&t[1], &m);
 224
 225        mutex_lock(&ks->lock);
 226        err = spi_sync(ks->spi, &m);
 227        mutex_unlock(&ks->lock);
 228
 229        return err ? err : count;
 230}
 231
 232static int ks8995_write(struct ks8995_switch *ks, char *buf,
 233                 unsigned offset, size_t count)
 234{
 235        __be16 cmd;
 236        struct spi_transfer t[2];
 237        struct spi_message m;
 238        int err;
 239
 240        cmd = create_spi_cmd(ks, KS8995_CMD_WRITE, offset);
 241        spi_message_init(&m);
 242
 243        memset(&t, 0, sizeof(t));
 244
 245        t[0].tx_buf = &cmd;
 246        t[0].len = sizeof(cmd);
 247        spi_message_add_tail(&t[0], &m);
 248
 249        t[1].tx_buf = buf;
 250        t[1].len = count;
 251        spi_message_add_tail(&t[1], &m);
 252
 253        mutex_lock(&ks->lock);
 254        err = spi_sync(ks->spi, &m);
 255        mutex_unlock(&ks->lock);
 256
 257        return err ? err : count;
 258}
 259
 260static inline int ks8995_read_reg(struct ks8995_switch *ks, u8 addr, u8 *buf)
 261{
 262        return ks8995_read(ks, buf, addr, 1) != 1;
 263}
 264
 265static inline int ks8995_write_reg(struct ks8995_switch *ks, u8 addr, u8 val)
 266{
 267        char buf = val;
 268
 269        return ks8995_write(ks, &buf, addr, 1) != 1;
 270}
 271
 272/* ------------------------------------------------------------------------ */
 273
 274static int ks8995_stop(struct ks8995_switch *ks)
 275{
 276        return ks8995_write_reg(ks, KS8995_REG_ID1, 0);
 277}
 278
 279static int ks8995_start(struct ks8995_switch *ks)
 280{
 281        return ks8995_write_reg(ks, KS8995_REG_ID1, 1);
 282}
 283
 284static int ks8995_reset(struct ks8995_switch *ks)
 285{
 286        int err;
 287
 288        err = ks8995_stop(ks);
 289        if (err)
 290                return err;
 291
 292        udelay(KS8995_RESET_DELAY);
 293
 294        return ks8995_start(ks);
 295}
 296
 297static ssize_t ks8995_registers_read(struct file *filp, struct kobject *kobj,
 298        struct bin_attribute *bin_attr, char *buf, loff_t off, size_t count)
 299{
 300        struct device *dev;
 301        struct ks8995_switch *ks8995;
 302
 303        dev = container_of(kobj, struct device, kobj);
 304        ks8995 = dev_get_drvdata(dev);
 305
 306        return ks8995_read(ks8995, buf, off, count);
 307}
 308
 309static ssize_t ks8995_registers_write(struct file *filp, struct kobject *kobj,
 310        struct bin_attribute *bin_attr, char *buf, loff_t off, size_t count)
 311{
 312        struct device *dev;
 313        struct ks8995_switch *ks8995;
 314
 315        dev = container_of(kobj, struct device, kobj);
 316        ks8995 = dev_get_drvdata(dev);
 317
 318        return ks8995_write(ks8995, buf, off, count);
 319}
 320
 321/* ks8995_get_revision - get chip revision
 322 * @ks: pointer to switch instance
 323 *
 324 * Verify chip family and id and get chip revision.
 325 */
 326static int ks8995_get_revision(struct ks8995_switch *ks)
 327{
 328        int err;
 329        u8 id0, id1, ksz8864_id;
 330
 331        /* read family id */
 332        err = ks8995_read_reg(ks, KS8995_REG_ID0, &id0);
 333        if (err) {
 334                err = -EIO;
 335                goto err_out;
 336        }
 337
 338        /* verify family id */
 339        if (id0 != ks->chip->family_id) {
 340                dev_err(&ks->spi->dev, "chip family id mismatch: expected 0x%02x but 0x%02x read\n",
 341                        ks->chip->family_id, id0);
 342                err = -ENODEV;
 343                goto err_out;
 344        }
 345
 346        switch (ks->chip->family_id) {
 347        case FAMILY_KS8995:
 348                /* try reading chip id at CHIP ID1 */
 349                err = ks8995_read_reg(ks, KS8995_REG_ID1, &id1);
 350                if (err) {
 351                        err = -EIO;
 352                        goto err_out;
 353                }
 354
 355                /* verify chip id */
 356                if ((get_chip_id(id1) == CHIPID_M) &&
 357                    (get_chip_id(id1) == ks->chip->chip_id)) {
 358                        /* KS8995MA */
 359                        ks->revision_id = get_chip_rev(id1);
 360                } else if (get_chip_id(id1) != CHIPID_M) {
 361                        /* KSZ8864RMN */
 362                        err = ks8995_read_reg(ks, KS8995_REG_ID1, &ksz8864_id);
 363                        if (err) {
 364                                err = -EIO;
 365                                goto err_out;
 366                        }
 367
 368                        if ((ksz8864_id & 0x80) &&
 369                            (ks->chip->chip_id == KSZ8864_CHIP_ID)) {
 370                                ks->revision_id = get_chip_rev(id1);
 371                        }
 372
 373                } else {
 374                        dev_err(&ks->spi->dev, "unsupported chip id for KS8995 family: 0x%02x\n",
 375                                id1);
 376                        err = -ENODEV;
 377                }
 378                break;
 379        case FAMILY_KSZ8795:
 380                /* try reading chip id at CHIP ID1 */
 381                err = ks8995_read_reg(ks, KS8995_REG_ID1, &id1);
 382                if (err) {
 383                        err = -EIO;
 384                        goto err_out;
 385                }
 386
 387                if (get_chip_id(id1) == ks->chip->chip_id) {
 388                        ks->revision_id = get_chip_rev(id1);
 389                } else {
 390                        dev_err(&ks->spi->dev, "unsupported chip id for KSZ8795 family: 0x%02x\n",
 391                                id1);
 392                        err = -ENODEV;
 393                }
 394                break;
 395        default:
 396                dev_err(&ks->spi->dev, "unsupported family id: 0x%02x\n", id0);
 397                err = -ENODEV;
 398                break;
 399        }
 400err_out:
 401        return err;
 402}
 403
 404/* ks8995_parse_dt - setup platform data from devicetree
 405 * @ks: pointer to switch instance
 406 *
 407 * Parses supported DT properties and sets up platform data
 408 * accordingly.
 409 */
 410static void ks8995_parse_dt(struct ks8995_switch *ks)
 411{
 412        struct device_node *np = ks->spi->dev.of_node;
 413        struct ks8995_pdata *pdata = ks->pdata;
 414
 415        if (!np)
 416                return;
 417
 418        pdata->reset_gpio = of_get_named_gpio_flags(np, "reset-gpios", 0,
 419                &pdata->reset_gpio_flags);
 420}
 421
 422static const struct bin_attribute ks8995_registers_attr = {
 423        .attr = {
 424                .name   = "registers",
 425                .mode   = 0600,
 426        },
 427        .size   = KS8995_REGS_SIZE,
 428        .read   = ks8995_registers_read,
 429        .write  = ks8995_registers_write,
 430};
 431
 432/* ------------------------------------------------------------------------ */
 433static int ks8995_probe(struct spi_device *spi)
 434{
 435        struct ks8995_switch *ks;
 436        int err;
 437        int variant = spi_get_device_id(spi)->driver_data;
 438
 439        if (variant >= max_variant) {
 440                dev_err(&spi->dev, "bad chip variant %d\n", variant);
 441                return -ENODEV;
 442        }
 443
 444        ks = devm_kzalloc(&spi->dev, sizeof(*ks), GFP_KERNEL);
 445        if (!ks)
 446                return -ENOMEM;
 447
 448        mutex_init(&ks->lock);
 449        ks->spi = spi;
 450        ks->chip = &ks8995_chip[variant];
 451
 452        if (ks->spi->dev.of_node) {
 453                ks->pdata = devm_kzalloc(&spi->dev, sizeof(*ks->pdata),
 454                                         GFP_KERNEL);
 455                if (!ks->pdata)
 456                        return -ENOMEM;
 457
 458                ks->pdata->reset_gpio = -1;
 459
 460                ks8995_parse_dt(ks);
 461        }
 462
 463        if (!ks->pdata)
 464                ks->pdata = spi->dev.platform_data;
 465
 466        /* de-assert switch reset */
 467        if (ks->pdata && gpio_is_valid(ks->pdata->reset_gpio)) {
 468                unsigned long flags;
 469
 470                flags = (ks->pdata->reset_gpio_flags == OF_GPIO_ACTIVE_LOW ?
 471                         GPIOF_ACTIVE_LOW : 0);
 472
 473                err = devm_gpio_request_one(&spi->dev,
 474                                            ks->pdata->reset_gpio,
 475                                            flags, "switch-reset");
 476                if (err) {
 477                        dev_err(&spi->dev,
 478                                "failed to get reset-gpios: %d\n", err);
 479                        return -EIO;
 480                }
 481
 482                gpiod_set_value(gpio_to_desc(ks->pdata->reset_gpio), 0);
 483        }
 484
 485        spi_set_drvdata(spi, ks);
 486
 487        spi->mode = SPI_MODE_0;
 488        spi->bits_per_word = 8;
 489        err = spi_setup(spi);
 490        if (err) {
 491                dev_err(&spi->dev, "spi_setup failed, err=%d\n", err);
 492                return err;
 493        }
 494
 495        err = ks8995_get_revision(ks);
 496        if (err)
 497                return err;
 498
 499        memcpy(&ks->regs_attr, &ks8995_registers_attr, sizeof(ks->regs_attr));
 500        ks->regs_attr.size = ks->chip->regs_size;
 501
 502        err = ks8995_reset(ks);
 503        if (err)
 504                return err;
 505
 506        sysfs_attr_init(&ks->regs_attr.attr);
 507        err = sysfs_create_bin_file(&spi->dev.kobj, &ks->regs_attr);
 508        if (err) {
 509                dev_err(&spi->dev, "unable to create sysfs file, err=%d\n",
 510                                    err);
 511                return err;
 512        }
 513
 514        dev_info(&spi->dev, "%s device found, Chip ID:%x, Revision:%x\n",
 515                 ks->chip->name, ks->chip->chip_id, ks->revision_id);
 516
 517        return 0;
 518}
 519
 520static int ks8995_remove(struct spi_device *spi)
 521{
 522        struct ks8995_switch *ks = spi_get_drvdata(spi);
 523
 524        sysfs_remove_bin_file(&spi->dev.kobj, &ks->regs_attr);
 525
 526        /* assert reset */
 527        if (ks->pdata && gpio_is_valid(ks->pdata->reset_gpio))
 528                gpiod_set_value(gpio_to_desc(ks->pdata->reset_gpio), 1);
 529
 530        return 0;
 531}
 532
 533/* ------------------------------------------------------------------------ */
 534static struct spi_driver ks8995_driver = {
 535        .driver = {
 536                .name       = "spi-ks8995",
 537                .of_match_table = of_match_ptr(ks8895_spi_of_match),
 538        },
 539        .probe    = ks8995_probe,
 540        .remove   = ks8995_remove,
 541        .id_table = ks8995_id,
 542};
 543
 544module_spi_driver(ks8995_driver);
 545
 546MODULE_DESCRIPTION(DRV_DESC);
 547MODULE_VERSION(DRV_VERSION);
 548MODULE_AUTHOR("Gabor Juhos <juhosg at openwrt.org>");
 549MODULE_LICENSE("GPL v2");
 550