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