drivers/net/phy/spi_ks8995.c

   1 /*
   2  * SPI driver for Micrel/Kendin KS8995M ethernet switch
   3  *
   4  * Copyright (C) 2008 Gabor Juhos <juhosg at openwrt.org>
   5  *
   6  * This file was based on: drivers/spi/at25.c
   7  *     Copyright (C) 2006 David Brownell
   8  *
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU General Public License version 2 as published
  11  * by the Free Software Foundation.
  12  */
  13
  14 #include <linux/types.h>
  15 #include <linux/kernel.h>
  16 #include <linux/init.h>
  17 #include <linux/module.h>
  18 #include <linux/delay.h>
  19 #include <linux/device.h>
  20
  21 #include <linux/spi/spi.h>
  22
  23 #define DRV_VERSION             "0.1.1"
  24 #define DRV_DESC                "Micrel KS8995 Ethernet switch SPI driver"
  25
  26 /* ------------------------------------------------------------------------ */
  27
  28 #define KS8995_REG_ID0          0x00    /* Chip ID0 */
  29 #define KS8995_REG_ID1          0x01    /* Chip ID1 */
  30
  31 #define KS8995_REG_GC0          0x02    /* Global Control 0 */
  32 #define KS8995_REG_GC1          0x03    /* Global Control 1 */
  33 #define KS8995_REG_GC2          0x04    /* Global Control 2 */
  34 #define KS8995_REG_GC3          0x05    /* Global Control 3 */
  35 #define KS8995_REG_GC4          0x06    /* Global Control 4 */
  36 #define KS8995_REG_GC5          0x07    /* Global Control 5 */
  37 #define KS8995_REG_GC6          0x08    /* Global Control 6 */
  38 #define KS8995_REG_GC7          0x09    /* Global Control 7 */
  39 #define KS8995_REG_GC8          0x0a    /* Global Control 8 */
  40 #define KS8995_REG_GC9          0x0b    /* Global Control 9 */
  41
  42 #define KS8995_REG_PC(p, r)     ((0x10 * p) + r)         /* Port Control */
  43 #define KS8995_REG_PS(p, r)     ((0x10 * p) + r + 0xe)  /* Port Status */
  44
  45 #define KS8995_REG_TPC0         0x60    /* TOS Priority Control 0 */
  46 #define KS8995_REG_TPC1         0x61    /* TOS Priority Control 1 */
  47 #define KS8995_REG_TPC2         0x62    /* TOS Priority Control 2 */
  48 #define KS8995_REG_TPC3         0x63    /* TOS Priority Control 3 */
  49 #define KS8995_REG_TPC4         0x64    /* TOS Priority Control 4 */
  50 #define KS8995_REG_TPC5         0x65    /* TOS Priority Control 5 */
  51 #define KS8995_REG_TPC6         0x66    /* TOS Priority Control 6 */
  52 #define KS8995_REG_TPC7         0x67    /* TOS Priority Control 7 */
  53
  54 #define KS8995_REG_MAC0         0x68    /* MAC address 0 */
  55 #define KS8995_REG_MAC1         0x69    /* MAC address 1 */
  56 #define KS8995_REG_MAC2         0x6a    /* MAC address 2 */
  57 #define KS8995_REG_MAC3         0x6b    /* MAC address 3 */
  58 #define KS8995_REG_MAC4         0x6c    /* MAC address 4 */
  59 #define KS8995_REG_MAC5         0x6d    /* MAC address 5 */
  60
  61 #define KS8995_REG_IAC0         0x6e    /* Indirect Access Control 0 */
  62 #define KS8995_REG_IAC1         0x6f    /* Indirect Access Control 0 */
  63 #define KS8995_REG_IAD7         0x70    /* Indirect Access Data 7 */
  64 #define KS8995_REG_IAD6         0x71    /* Indirect Access Data 6 */
  65 #define KS8995_REG_IAD5         0x72    /* Indirect Access Data 5 */
  66 #define KS8995_REG_IAD4         0x73    /* Indirect Access Data 4 */
  67 #define KS8995_REG_IAD3         0x74    /* Indirect Access Data 3 */
  68 #define KS8995_REG_IAD2         0x75    /* Indirect Access Data 2 */
  69 #define KS8995_REG_IAD1         0x76    /* Indirect Access Data 1 */
  70 #define KS8995_REG_IAD0         0x77    /* Indirect Access Data 0 */
  71
  72 #define KS8995_REGS_SIZE        0x80
  73
  74 #define ID1_CHIPID_M            0xf
  75 #define ID1_CHIPID_S            4
  76 #define ID1_REVISION_M          0x7
  77 #define ID1_REVISION_S          1
  78 #define ID1_START_SW            1       /* start the switch */
  79
  80 #define FAMILY_KS8995           0x95
  81 #define CHIPID_M                0
  82
  83 #define KS8995_CMD_WRITE        0x02U
  84 #define KS8995_CMD_READ         0x03U
  85
  86 #define KS8995_RESET_DELAY      10 /* usec */
  87
  88 struct ks8995_pdata {
  89         /* not yet implemented */
  90 };
  91
  92 struct ks8995_switch {
  93         struct spi_device       *spi;
  94         struct mutex            lock;
  95         struct ks8995_pdata     *pdata;
  96 };
  97
  98 static inline u8 get_chip_id(u8 val)
  99 {
 100         return (val >> ID1_CHIPID_S) & ID1_CHIPID_M;
 101 }
 102
 103 static inline u8 get_chip_rev(u8 val)
 104 {
 105         return (val >> ID1_REVISION_S) & ID1_REVISION_M;
 106 }
 107
 108 /* ------------------------------------------------------------------------ */
 109 static int ks8995_read(struct ks8995_switch *ks, char *buf,
 110                  unsigned offset, size_t count)
 111 {
 112         u8 cmd[2];
 113         struct spi_transfer t[2];
 114         struct spi_message m;
 115         int err;
 116
 117         spi_message_init(&m);
 118
 119         memset(&t, 0, sizeof(t));
 120
 121         t[0].tx_buf = cmd;
 122         t[0].len = sizeof(cmd);
 123         spi_message_add_tail(&t[0], &m);
 124
 125         t[1].rx_buf = buf;
 126         t[1].len = count;
 127         spi_message_add_tail(&t[1], &m);
 128
 129         cmd[0] = KS8995_CMD_READ;
 130         cmd[1] = offset;
 131
 132         mutex_lock(&ks->lock);
 133         err = spi_sync(ks->spi, &m);
 134         mutex_unlock(&ks->lock);
 135
 136         return err ? err : count;
 137 }
 138
 139
 140 static int ks8995_write(struct ks8995_switch *ks, char *buf,
 141                  unsigned offset, size_t count)
 142 {
 143         u8 cmd[2];
 144         struct spi_transfer t[2];
 145         struct spi_message m;
 146         int err;
 147
 148         spi_message_init(&m);
 149
 150         memset(&t, 0, sizeof(t));
 151
 152         t[0].tx_buf = cmd;
 153         t[0].len = sizeof(cmd);
 154         spi_message_add_tail(&t[0], &m);
 155
 156         t[1].tx_buf = buf;
 157         t[1].len = count;
 158         spi_message_add_tail(&t[1], &m);
 159
 160         cmd[0] = KS8995_CMD_WRITE;
 161         cmd[1] = offset;
 162
 163         mutex_lock(&ks->lock);
 164         err = spi_sync(ks->spi, &m);
 165         mutex_unlock(&ks->lock);
 166
 167         return err ? err : count;
 168 }
 169
 170 static inline int ks8995_read_reg(struct ks8995_switch *ks, u8 addr, u8 *buf)
 171 {
 172         return (ks8995_read(ks, buf, addr, 1) != 1);
 173 }
 174
 175 static inline int ks8995_write_reg(struct ks8995_switch *ks, u8 addr, u8 val)
 176 {
 177         char buf = val;
 178
 179         return (ks8995_write(ks, &buf, addr, 1) != 1);
 180 }
 181
 182 /* ------------------------------------------------------------------------ */
 183
 184 static int ks8995_stop(struct ks8995_switch *ks)
 185 {
 186         return ks8995_write_reg(ks, KS8995_REG_ID1, 0);
 187 }
 188
 189 static int ks8995_start(struct ks8995_switch *ks)
 190 {
 191         return ks8995_write_reg(ks, KS8995_REG_ID1, 1);
 192 }
 193
 194 static int ks8995_reset(struct ks8995_switch *ks)
 195 {
 196         int err;
 197
 198         err = ks8995_stop(ks);
 199         if (err)
 200                 return err;
 201
 202         udelay(KS8995_RESET_DELAY);
 203
 204         return ks8995_start(ks);
 205 }
 206
 207 /* ------------------------------------------------------------------------ */
 208
 209 static ssize_t ks8995_registers_read(struct file *filp, struct kobject *kobj,
 210         struct bin_attribute *bin_attr, char *buf, loff_t off, size_t count)
 211 {
 212         struct device *dev;
 213         struct ks8995_switch *ks8995;
 214
 215         dev = container_of(kobj, struct device, kobj);
 216         ks8995 = dev_get_drvdata(dev);
 217
 218         if (unlikely(off > KS8995_REGS_SIZE))
 219                 return 0;
 220
 221         if ((off + count) > KS8995_REGS_SIZE)
 222                 count = KS8995_REGS_SIZE - off;
 223
 224         if (unlikely(!count))
 225                 return count;
 226
 227         return ks8995_read(ks8995, buf, off, count);
 228 }
 229
 230
 231 static ssize_t ks8995_registers_write(struct file *filp, struct kobject *kobj,
 232         struct bin_attribute *bin_attr, char *buf, loff_t off, size_t count)
 233 {
 234         struct device *dev;
 235         struct ks8995_switch *ks8995;
 236
 237         dev = container_of(kobj, struct device, kobj);
 238         ks8995 = dev_get_drvdata(dev);
 239
 240         if (unlikely(off >= KS8995_REGS_SIZE))
 241                 return -EFBIG;
 242
 243         if ((off + count) > KS8995_REGS_SIZE)
 244                 count = KS8995_REGS_SIZE - off;
 245
 246         if (unlikely(!count))
 247                 return count;
 248
 249         return ks8995_write(ks8995, buf, off, count);
 250 }
 251
 252
 253 static struct bin_attribute ks8995_registers_attr = {
 254         .attr = {
 255                 .name   = "registers",
 256                 .mode   = S_IRUSR | S_IWUSR,
 257         },
 258         .size   = KS8995_REGS_SIZE,
 259         .read   = ks8995_registers_read,
 260         .write  = ks8995_registers_write,
 261 };
 262
 263 /* ------------------------------------------------------------------------ */
 264
 265 static int __devinit ks8995_probe(struct spi_device *spi)
 266 {
 267         struct ks8995_switch    *ks;
 268         struct ks8995_pdata     *pdata;
 269         u8      ids[2];
 270         int     err;
 271
 272         /* Chip description */
 273         pdata = spi->dev.platform_data;
 274
 275         ks = kzalloc(sizeof(*ks), GFP_KERNEL);
 276         if (!ks) {
 277                 dev_err(&spi->dev, "no memory for private data\n");
 278                 return -ENOMEM;
 279         }
 280
 281         mutex_init(&ks->lock);
 282         ks->pdata = pdata;
 283         ks->spi = spi_dev_get(spi);
 284         dev_set_drvdata(&spi->dev, ks);
 285
 286         spi->mode = SPI_MODE_0;
 287         spi->bits_per_word = 8;
 288         err = spi_setup(spi);
 289         if (err) {
 290                 dev_err(&spi->dev, "spi_setup failed, err=%d\n", err);
 291                 goto err_drvdata;
 292         }
 293
 294         err = ks8995_read(ks, ids, KS8995_REG_ID0, sizeof(ids));
 295         if (err < 0) {
 296                 dev_err(&spi->dev, "unable to read id registers, err=%d\n",
 297                                 err);
 298                 goto err_drvdata;
 299         }
 300
 301         switch (ids[0]) {
 302         case FAMILY_KS8995:
 303                 break;
 304         default:
 305                 dev_err(&spi->dev, "unknown family id:%02x\n", ids[0]);
 306                 err = -ENODEV;
 307                 goto err_drvdata;
 308         }
 309
 310         err = ks8995_reset(ks);
 311         if (err)
 312                 goto err_drvdata;
 313
 314         err = sysfs_create_bin_file(&spi->dev.kobj, &ks8995_registers_attr);
 315         if (err) {
 316                 dev_err(&spi->dev, "unable to create sysfs file, err=%d\n",
 317                                     err);
 318                 goto err_drvdata;
 319         }
 320
 321         dev_info(&spi->dev, "KS89%02X device found, Chip ID:%01x, "
 322                         "Revision:%01x\n", ids[0],
 323                         get_chip_id(ids[1]), get_chip_rev(ids[1]));
 324
 325         return 0;
 326
 327 err_drvdata:
 328         dev_set_drvdata(&spi->dev, NULL);
 329         kfree(ks);
 330         return err;
 331 }
 332
 333 static int __devexit ks8995_remove(struct spi_device *spi)
 334 {
 335         struct ks8995_data      *ks8995;
 336
 337         ks8995 = dev_get_drvdata(&spi->dev);
 338         sysfs_remove_bin_file(&spi->dev.kobj, &ks8995_registers_attr);
 339
 340         dev_set_drvdata(&spi->dev, NULL);
 341         kfree(ks8995);
 342
 343         return 0;
 344 }
 345
 346 /* ------------------------------------------------------------------------ */
 347
 348 static struct spi_driver ks8995_driver = {
 349         .driver = {
 350                 .name       = "spi-ks8995",
 351                 .bus         = &spi_bus_type,
 352                 .owner     = THIS_MODULE,
 353         },
 354         .probe    = ks8995_probe,
 355         .remove   = __devexit_p(ks8995_remove),
 356 };
 357
 358 static int __init ks8995_init(void)
 359 {
 360         printk(KERN_INFO DRV_DESC " version " DRV_VERSION"\n");
 361
 362         return spi_register_driver(&ks8995_driver);
 363 }
 364 module_init(ks8995_init);
 365
 366 static void __exit ks8995_exit(void)
 367 {
 368         spi_unregister_driver(&ks8995_driver);
 369 }
 370 module_exit(ks8995_exit);
 371
 372 MODULE_DESCRIPTION(DRV_DESC);
 373 MODULE_VERSION(DRV_VERSION);
 374 MODULE_AUTHOR("Gabor Juhos <juhosg at openwrt.org>");
 375 MODULE_LICENSE("GPL v2");