1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * FSI core driver 4 * 5 * Copyright (C) IBM Corporation 2016 6 * 7 * TODO: 8 * - Rework topology 9 * - s/chip_id/chip_loc 10 * - s/cfam/chip (cfam_id -> chip_id etc...) 11 */ 12 13 #include <linux/crc4.h> 14 #include <linux/device.h> 15 #include <linux/fsi.h> 16 #include <linux/idr.h> 17 #include <linux/module.h> 18 #include <linux/of.h> 19 #include <linux/slab.h> 20 #include <linux/bitops.h> 21 #include <linux/cdev.h> 22 #include <linux/fs.h> 23 #include <linux/uaccess.h> 24 25 #include "fsi-master.h" 26 27 #define FSI_SLAVE_CONF_NEXT_MASK GENMASK(31, 31) 28 #define FSI_SLAVE_CONF_SLOTS_MASK GENMASK(23, 16) 29 #define FSI_SLAVE_CONF_SLOTS_SHIFT 16 30 #define FSI_SLAVE_CONF_VERSION_MASK GENMASK(15, 12) 31 #define FSI_SLAVE_CONF_VERSION_SHIFT 12 32 #define FSI_SLAVE_CONF_TYPE_MASK GENMASK(11, 4) 33 #define FSI_SLAVE_CONF_TYPE_SHIFT 4 34 #define FSI_SLAVE_CONF_CRC_SHIFT 4 35 #define FSI_SLAVE_CONF_CRC_MASK GENMASK(3, 0) 36 #define FSI_SLAVE_CONF_DATA_BITS 28 37 38 #define FSI_PEEK_BASE 0x410 39 40 static const int engine_page_size = 0x400; 41 42 #define FSI_SLAVE_BASE 0x800 43 44 /* 45 * FSI slave engine control register offsets 46 */ 47 #define FSI_SMODE 0x0 /* R/W: Mode register */ 48 #define FSI_SISC 0x8 /* R/W: Interrupt condition */ 49 #define FSI_SSTAT 0x14 /* R : Slave status */ 50 #define FSI_SLBUS 0x30 /* W : LBUS Ownership */ 51 #define FSI_LLMODE 0x100 /* R/W: Link layer mode register */ 52 53 /* 54 * SMODE fields 55 */ 56 #define FSI_SMODE_WSC 0x80000000 /* Warm start done */ 57 #define FSI_SMODE_ECRC 0x20000000 /* Hw CRC check */ 58 #define FSI_SMODE_SID_SHIFT 24 /* ID shift */ 59 #define FSI_SMODE_SID_MASK 3 /* ID Mask */ 60 #define FSI_SMODE_ED_SHIFT 20 /* Echo delay shift */ 61 #define FSI_SMODE_ED_MASK 0xf /* Echo delay mask */ 62 #define FSI_SMODE_SD_SHIFT 16 /* Send delay shift */ 63 #define FSI_SMODE_SD_MASK 0xf /* Send delay mask */ 64 #define FSI_SMODE_LBCRR_SHIFT 8 /* Clk ratio shift */ 65 #define FSI_SMODE_LBCRR_MASK 0xf /* Clk ratio mask */ 66 67 /* 68 * SLBUS fields 69 */ 70 #define FSI_SLBUS_FORCE 0x80000000 /* Force LBUS ownership */ 71 72 /* 73 * LLMODE fields 74 */ 75 #define FSI_LLMODE_ASYNC 0x1 76 77 #define FSI_SLAVE_SIZE_23b 0x800000 78 79 static DEFINE_IDA(master_ida); 80 81 struct fsi_slave { 82 struct device dev; 83 struct fsi_master *master; 84 struct cdev cdev; 85 int cdev_idx; 86 int id; /* FSI address */ 87 int link; /* FSI link# */ 88 u32 cfam_id; 89 int chip_id; 90 uint32_t size; /* size of slave address space */ 91 u8 t_send_delay; 92 u8 t_echo_delay; 93 }; 94 95 #define CREATE_TRACE_POINTS 96 #include <trace/events/fsi.h> 97 98 #define to_fsi_master(d) container_of(d, struct fsi_master, dev) 99 #define to_fsi_slave(d) container_of(d, struct fsi_slave, dev) 100 101 static const int slave_retries = 2; 102 static int discard_errors; 103 104 static dev_t fsi_base_dev; 105 static DEFINE_IDA(fsi_minor_ida); 106 #define FSI_CHAR_MAX_DEVICES 0x1000 107 108 /* Legacy /dev numbering: 4 devices per chip, 16 chips */ 109 #define FSI_CHAR_LEGACY_TOP 64 110 111 static int fsi_master_read(struct fsi_master *master, int link, 112 uint8_t slave_id, uint32_t addr, void *val, size_t size); 113 static int fsi_master_write(struct fsi_master *master, int link, 114 uint8_t slave_id, uint32_t addr, const void *val, size_t size); 115 static int fsi_master_break(struct fsi_master *master, int link); 116 117 /* 118 * fsi_device_read() / fsi_device_write() / fsi_device_peek() 119 * 120 * FSI endpoint-device support 121 * 122 * Read / write / peek accessors for a client 123 * 124 * Parameters: 125 * dev: Structure passed to FSI client device drivers on probe(). 126 * addr: FSI address of given device. Client should pass in its base address 127 * plus desired offset to access its register space. 128 * val: For read/peek this is the value read at the specified address. For 129 * write this is value to write to the specified address. 130 * The data in val must be FSI bus endian (big endian). 131 * size: Size in bytes of the operation. Sizes supported are 1, 2 and 4 bytes. 132 * Addresses must be aligned on size boundaries or an error will result. 133 */ 134 int fsi_device_read(struct fsi_device *dev, uint32_t addr, void *val, 135 size_t size) 136 { 137 if (addr > dev->size || size > dev->size || addr > dev->size - size) 138 return -EINVAL; 139 140 return fsi_slave_read(dev->slave, dev->addr + addr, val, size); 141 } 142 EXPORT_SYMBOL_GPL(fsi_device_read); 143 144 int fsi_device_write(struct fsi_device *dev, uint32_t addr, const void *val, 145 size_t size) 146 { 147 if (addr > dev->size || size > dev->size || addr > dev->size - size) 148 return -EINVAL; 149 150 return fsi_slave_write(dev->slave, dev->addr + addr, val, size); 151 } 152 EXPORT_SYMBOL_GPL(fsi_device_write); 153 154 int fsi_device_peek(struct fsi_device *dev, void *val) 155 { 156 uint32_t addr = FSI_PEEK_BASE + ((dev->unit - 2) * sizeof(uint32_t)); 157 158 return fsi_slave_read(dev->slave, addr, val, sizeof(uint32_t)); 159 } 160 161 static void fsi_device_release(struct device *_device) 162 { 163 struct fsi_device *device = to_fsi_dev(_device); 164 165 of_node_put(device->dev.of_node); 166 kfree(device); 167 } 168 169 static struct fsi_device *fsi_create_device(struct fsi_slave *slave) 170 { 171 struct fsi_device *dev; 172 173 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 174 if (!dev) 175 return NULL; 176 177 dev->dev.parent = &slave->dev; 178 dev->dev.bus = &fsi_bus_type; 179 dev->dev.release = fsi_device_release; 180 181 return dev; 182 } 183 184 /* FSI slave support */ 185 static int fsi_slave_calc_addr(struct fsi_slave *slave, uint32_t *addrp, 186 uint8_t *idp) 187 { 188 uint32_t addr = *addrp; 189 uint8_t id = *idp; 190 191 if (addr > slave->size) 192 return -EINVAL; 193 194 /* For 23 bit addressing, we encode the extra two bits in the slave 195 * id (and the slave's actual ID needs to be 0). 196 */ 197 if (addr > 0x1fffff) { 198 if (slave->id != 0) 199 return -EINVAL; 200 id = (addr >> 21) & 0x3; 201 addr &= 0x1fffff; 202 } 203 204 *addrp = addr; 205 *idp = id; 206 return 0; 207 } 208 209 static int fsi_slave_report_and_clear_errors(struct fsi_slave *slave) 210 { 211 struct fsi_master *master = slave->master; 212 __be32 irq, stat; 213 int rc, link; 214 uint8_t id; 215 216 link = slave->link; 217 id = slave->id; 218 219 rc = fsi_master_read(master, link, id, FSI_SLAVE_BASE + FSI_SISC, 220 &irq, sizeof(irq)); 221 if (rc) 222 return rc; 223 224 rc = fsi_master_read(master, link, id, FSI_SLAVE_BASE + FSI_SSTAT, 225 &stat, sizeof(stat)); 226 if (rc) 227 return rc; 228 229 dev_dbg(&slave->dev, "status: 0x%08x, sisc: 0x%08x\n", 230 be32_to_cpu(stat), be32_to_cpu(irq)); 231 232 /* clear interrupts */ 233 return fsi_master_write(master, link, id, FSI_SLAVE_BASE + FSI_SISC, 234 &irq, sizeof(irq)); 235 } 236 237 /* Encode slave local bus echo delay */ 238 static inline uint32_t fsi_smode_echodly(int x) 239 { 240 return (x & FSI_SMODE_ED_MASK) << FSI_SMODE_ED_SHIFT; 241 } 242 243 /* Encode slave local bus send delay */ 244 static inline uint32_t fsi_smode_senddly(int x) 245 { 246 return (x & FSI_SMODE_SD_MASK) << FSI_SMODE_SD_SHIFT; 247 } 248 249 /* Encode slave local bus clock rate ratio */ 250 static inline uint32_t fsi_smode_lbcrr(int x) 251 { 252 return (x & FSI_SMODE_LBCRR_MASK) << FSI_SMODE_LBCRR_SHIFT; 253 } 254 255 /* Encode slave ID */ 256 static inline uint32_t fsi_smode_sid(int x) 257 { 258 return (x & FSI_SMODE_SID_MASK) << FSI_SMODE_SID_SHIFT; 259 } 260 261 static uint32_t fsi_slave_smode(int id, u8 t_senddly, u8 t_echodly) 262 { 263 return FSI_SMODE_WSC | FSI_SMODE_ECRC 264 | fsi_smode_sid(id) 265 | fsi_smode_echodly(t_echodly - 1) | fsi_smode_senddly(t_senddly - 1) 266 | fsi_smode_lbcrr(0x8); 267 } 268 269 static int fsi_slave_set_smode(struct fsi_slave *slave) 270 { 271 uint32_t smode; 272 __be32 data; 273 274 /* set our smode register with the slave ID field to 0; this enables 275 * extended slave addressing 276 */ 277 smode = fsi_slave_smode(slave->id, slave->t_send_delay, slave->t_echo_delay); 278 data = cpu_to_be32(smode); 279 280 return fsi_master_write(slave->master, slave->link, slave->id, 281 FSI_SLAVE_BASE + FSI_SMODE, 282 &data, sizeof(data)); 283 } 284 285 static int fsi_slave_handle_error(struct fsi_slave *slave, bool write, 286 uint32_t addr, size_t size) 287 { 288 struct fsi_master *master = slave->master; 289 int rc, link; 290 uint32_t reg; 291 uint8_t id, send_delay, echo_delay; 292 293 if (discard_errors) 294 return -1; 295 296 link = slave->link; 297 id = slave->id; 298 299 dev_dbg(&slave->dev, "handling error on %s to 0x%08x[%zd]", 300 write ? "write" : "read", addr, size); 301 302 /* try a simple clear of error conditions, which may fail if we've lost 303 * communication with the slave 304 */ 305 rc = fsi_slave_report_and_clear_errors(slave); 306 if (!rc) 307 return 0; 308 309 /* send a TERM and retry */ 310 if (master->term) { 311 rc = master->term(master, link, id); 312 if (!rc) { 313 rc = fsi_master_read(master, link, id, 0, 314 ®, sizeof(reg)); 315 if (!rc) 316 rc = fsi_slave_report_and_clear_errors(slave); 317 if (!rc) 318 return 0; 319 } 320 } 321 322 send_delay = slave->t_send_delay; 323 echo_delay = slave->t_echo_delay; 324 325 /* getting serious, reset the slave via BREAK */ 326 rc = fsi_master_break(master, link); 327 if (rc) 328 return rc; 329 330 slave->t_send_delay = send_delay; 331 slave->t_echo_delay = echo_delay; 332 333 rc = fsi_slave_set_smode(slave); 334 if (rc) 335 return rc; 336 337 if (master->link_config) 338 master->link_config(master, link, 339 slave->t_send_delay, 340 slave->t_echo_delay); 341 342 return fsi_slave_report_and_clear_errors(slave); 343 } 344 345 int fsi_slave_read(struct fsi_slave *slave, uint32_t addr, 346 void *val, size_t size) 347 { 348 uint8_t id = slave->id; 349 int rc, err_rc, i; 350 351 rc = fsi_slave_calc_addr(slave, &addr, &id); 352 if (rc) 353 return rc; 354 355 for (i = 0; i < slave_retries; i++) { 356 rc = fsi_master_read(slave->master, slave->link, 357 id, addr, val, size); 358 if (!rc) 359 break; 360 361 err_rc = fsi_slave_handle_error(slave, false, addr, size); 362 if (err_rc) 363 break; 364 } 365 366 return rc; 367 } 368 EXPORT_SYMBOL_GPL(fsi_slave_read); 369 370 int fsi_slave_write(struct fsi_slave *slave, uint32_t addr, 371 const void *val, size_t size) 372 { 373 uint8_t id = slave->id; 374 int rc, err_rc, i; 375 376 rc = fsi_slave_calc_addr(slave, &addr, &id); 377 if (rc) 378 return rc; 379 380 for (i = 0; i < slave_retries; i++) { 381 rc = fsi_master_write(slave->master, slave->link, 382 id, addr, val, size); 383 if (!rc) 384 break; 385 386 err_rc = fsi_slave_handle_error(slave, true, addr, size); 387 if (err_rc) 388 break; 389 } 390 391 return rc; 392 } 393 EXPORT_SYMBOL_GPL(fsi_slave_write); 394 395 extern int fsi_slave_claim_range(struct fsi_slave *slave, 396 uint32_t addr, uint32_t size) 397 { 398 if (addr + size < addr) 399 return -EINVAL; 400 401 if (addr + size > slave->size) 402 return -EINVAL; 403 404 /* todo: check for overlapping claims */ 405 return 0; 406 } 407 EXPORT_SYMBOL_GPL(fsi_slave_claim_range); 408 409 extern void fsi_slave_release_range(struct fsi_slave *slave, 410 uint32_t addr, uint32_t size) 411 { 412 } 413 EXPORT_SYMBOL_GPL(fsi_slave_release_range); 414 415 static bool fsi_device_node_matches(struct device *dev, struct device_node *np, 416 uint32_t addr, uint32_t size) 417 { 418 unsigned int len, na, ns; 419 const __be32 *prop; 420 uint32_t psize; 421 422 na = of_n_addr_cells(np); 423 ns = of_n_size_cells(np); 424 425 if (na != 1 || ns != 1) 426 return false; 427 428 prop = of_get_property(np, "reg", &len); 429 if (!prop || len != 8) 430 return false; 431 432 if (of_read_number(prop, 1) != addr) 433 return false; 434 435 psize = of_read_number(prop + 1, 1); 436 if (psize != size) { 437 dev_warn(dev, 438 "node %s matches probed address, but not size (got 0x%x, expected 0x%x)", 439 of_node_full_name(np), psize, size); 440 } 441 442 return true; 443 } 444 445 /* Find a matching node for the slave engine at @address, using @size bytes 446 * of space. Returns NULL if not found, or a matching node with refcount 447 * already incremented. 448 */ 449 static struct device_node *fsi_device_find_of_node(struct fsi_device *dev) 450 { 451 struct device_node *parent, *np; 452 453 parent = dev_of_node(&dev->slave->dev); 454 if (!parent) 455 return NULL; 456 457 for_each_child_of_node(parent, np) { 458 if (fsi_device_node_matches(&dev->dev, np, 459 dev->addr, dev->size)) 460 return np; 461 } 462 463 return NULL; 464 } 465 466 static int fsi_slave_scan(struct fsi_slave *slave) 467 { 468 uint32_t engine_addr; 469 int rc, i; 470 471 /* 472 * scan engines 473 * 474 * We keep the peek mode and slave engines for the core; so start 475 * at the third slot in the configuration table. We also need to 476 * skip the chip ID entry at the start of the address space. 477 */ 478 engine_addr = engine_page_size * 3; 479 for (i = 2; i < engine_page_size / sizeof(uint32_t); i++) { 480 uint8_t slots, version, type, crc; 481 struct fsi_device *dev; 482 uint32_t conf; 483 __be32 data; 484 485 rc = fsi_slave_read(slave, (i + 1) * sizeof(data), 486 &data, sizeof(data)); 487 if (rc) { 488 dev_warn(&slave->dev, 489 "error reading slave registers\n"); 490 return -1; 491 } 492 conf = be32_to_cpu(data); 493 494 crc = crc4(0, conf, 32); 495 if (crc) { 496 dev_warn(&slave->dev, 497 "crc error in slave register at 0x%04x\n", 498 i); 499 return -1; 500 } 501 502 slots = (conf & FSI_SLAVE_CONF_SLOTS_MASK) 503 >> FSI_SLAVE_CONF_SLOTS_SHIFT; 504 version = (conf & FSI_SLAVE_CONF_VERSION_MASK) 505 >> FSI_SLAVE_CONF_VERSION_SHIFT; 506 type = (conf & FSI_SLAVE_CONF_TYPE_MASK) 507 >> FSI_SLAVE_CONF_TYPE_SHIFT; 508 509 /* 510 * Unused address areas are marked by a zero type value; this 511 * skips the defined address areas 512 */ 513 if (type != 0 && slots != 0) { 514 515 /* create device */ 516 dev = fsi_create_device(slave); 517 if (!dev) 518 return -ENOMEM; 519 520 dev->slave = slave; 521 dev->engine_type = type; 522 dev->version = version; 523 dev->unit = i; 524 dev->addr = engine_addr; 525 dev->size = slots * engine_page_size; 526 527 trace_fsi_dev_init(dev); 528 529 dev_dbg(&slave->dev, 530 "engine[%i]: type %x, version %x, addr %x size %x\n", 531 dev->unit, dev->engine_type, version, 532 dev->addr, dev->size); 533 534 dev_set_name(&dev->dev, "%02x:%02x:%02x:%02x", 535 slave->master->idx, slave->link, 536 slave->id, i - 2); 537 dev->dev.of_node = fsi_device_find_of_node(dev); 538 539 rc = device_register(&dev->dev); 540 if (rc) { 541 dev_warn(&slave->dev, "add failed: %d\n", rc); 542 put_device(&dev->dev); 543 } 544 } 545 546 engine_addr += slots * engine_page_size; 547 548 if (!(conf & FSI_SLAVE_CONF_NEXT_MASK)) 549 break; 550 } 551 552 return 0; 553 } 554 555 static unsigned long aligned_access_size(size_t offset, size_t count) 556 { 557 unsigned long offset_unit, count_unit; 558 559 /* Criteria: 560 * 561 * 1. Access size must be less than or equal to the maximum access 562 * width or the highest power-of-two factor of offset 563 * 2. Access size must be less than or equal to the amount specified by 564 * count 565 * 566 * The access width is optimal if we can calculate 1 to be strictly 567 * equal while still satisfying 2. 568 */ 569 570 /* Find 1 by the bottom bit of offset (with a 4 byte access cap) */ 571 offset_unit = BIT(__builtin_ctzl(offset | 4)); 572 573 /* Find 2 by the top bit of count */ 574 count_unit = BIT(8 * sizeof(unsigned long) - 1 - __builtin_clzl(count)); 575 576 /* Constrain the maximum access width to the minimum of both criteria */ 577 return BIT(__builtin_ctzl(offset_unit | count_unit)); 578 } 579 580 static ssize_t fsi_slave_sysfs_raw_read(struct file *file, 581 struct kobject *kobj, struct bin_attribute *attr, char *buf, 582 loff_t off, size_t count) 583 { 584 struct fsi_slave *slave = to_fsi_slave(kobj_to_dev(kobj)); 585 size_t total_len, read_len; 586 int rc; 587 588 if (off < 0) 589 return -EINVAL; 590 591 if (off > 0xffffffff || count > 0xffffffff || off + count > 0xffffffff) 592 return -EINVAL; 593 594 for (total_len = 0; total_len < count; total_len += read_len) { 595 read_len = aligned_access_size(off, count - total_len); 596 597 rc = fsi_slave_read(slave, off, buf + total_len, read_len); 598 if (rc) 599 return rc; 600 601 off += read_len; 602 } 603 604 return count; 605 } 606 607 static ssize_t fsi_slave_sysfs_raw_write(struct file *file, 608 struct kobject *kobj, struct bin_attribute *attr, 609 char *buf, loff_t off, size_t count) 610 { 611 struct fsi_slave *slave = to_fsi_slave(kobj_to_dev(kobj)); 612 size_t total_len, write_len; 613 int rc; 614 615 if (off < 0) 616 return -EINVAL; 617 618 if (off > 0xffffffff || count > 0xffffffff || off + count > 0xffffffff) 619 return -EINVAL; 620 621 for (total_len = 0; total_len < count; total_len += write_len) { 622 write_len = aligned_access_size(off, count - total_len); 623 624 rc = fsi_slave_write(slave, off, buf + total_len, write_len); 625 if (rc) 626 return rc; 627 628 off += write_len; 629 } 630 631 return count; 632 } 633 634 static const struct bin_attribute fsi_slave_raw_attr = { 635 .attr = { 636 .name = "raw", 637 .mode = 0600, 638 }, 639 .size = 0, 640 .read = fsi_slave_sysfs_raw_read, 641 .write = fsi_slave_sysfs_raw_write, 642 }; 643 644 static void fsi_slave_release(struct device *dev) 645 { 646 struct fsi_slave *slave = to_fsi_slave(dev); 647 648 fsi_free_minor(slave->dev.devt); 649 of_node_put(dev->of_node); 650 kfree(slave); 651 } 652 653 static bool fsi_slave_node_matches(struct device_node *np, 654 int link, uint8_t id) 655 { 656 unsigned int len, na, ns; 657 const __be32 *prop; 658 659 na = of_n_addr_cells(np); 660 ns = of_n_size_cells(np); 661 662 /* Ensure we have the correct format for addresses and sizes in 663 * reg properties 664 */ 665 if (na != 2 || ns != 0) 666 return false; 667 668 prop = of_get_property(np, "reg", &len); 669 if (!prop || len != 8) 670 return false; 671 672 return (of_read_number(prop, 1) == link) && 673 (of_read_number(prop + 1, 1) == id); 674 } 675 676 /* Find a matching node for the slave at (link, id). Returns NULL if none 677 * found, or a matching node with refcount already incremented. 678 */ 679 static struct device_node *fsi_slave_find_of_node(struct fsi_master *master, 680 int link, uint8_t id) 681 { 682 struct device_node *parent, *np; 683 684 parent = dev_of_node(&master->dev); 685 if (!parent) 686 return NULL; 687 688 for_each_child_of_node(parent, np) { 689 if (fsi_slave_node_matches(np, link, id)) 690 return np; 691 } 692 693 return NULL; 694 } 695 696 static ssize_t cfam_read(struct file *filep, char __user *buf, size_t count, 697 loff_t *offset) 698 { 699 struct fsi_slave *slave = filep->private_data; 700 size_t total_len, read_len; 701 loff_t off = *offset; 702 ssize_t rc; 703 704 if (off < 0) 705 return -EINVAL; 706 707 if (off > 0xffffffff || count > 0xffffffff || off + count > 0xffffffff) 708 return -EINVAL; 709 710 for (total_len = 0; total_len < count; total_len += read_len) { 711 __be32 data; 712 713 read_len = min_t(size_t, count, 4); 714 read_len -= off & 0x3; 715 716 rc = fsi_slave_read(slave, off, &data, read_len); 717 if (rc) 718 goto fail; 719 rc = copy_to_user(buf + total_len, &data, read_len); 720 if (rc) { 721 rc = -EFAULT; 722 goto fail; 723 } 724 off += read_len; 725 } 726 rc = count; 727 fail: 728 *offset = off; 729 return rc; 730 } 731 732 static ssize_t cfam_write(struct file *filep, const char __user *buf, 733 size_t count, loff_t *offset) 734 { 735 struct fsi_slave *slave = filep->private_data; 736 size_t total_len, write_len; 737 loff_t off = *offset; 738 ssize_t rc; 739 740 741 if (off < 0) 742 return -EINVAL; 743 744 if (off > 0xffffffff || count > 0xffffffff || off + count > 0xffffffff) 745 return -EINVAL; 746 747 for (total_len = 0; total_len < count; total_len += write_len) { 748 __be32 data; 749 750 write_len = min_t(size_t, count, 4); 751 write_len -= off & 0x3; 752 753 rc = copy_from_user(&data, buf + total_len, write_len); 754 if (rc) { 755 rc = -EFAULT; 756 goto fail; 757 } 758 rc = fsi_slave_write(slave, off, &data, write_len); 759 if (rc) 760 goto fail; 761 off += write_len; 762 } 763 rc = count; 764 fail: 765 *offset = off; 766 return rc; 767 } 768 769 static loff_t cfam_llseek(struct file *file, loff_t offset, int whence) 770 { 771 switch (whence) { 772 case SEEK_CUR: 773 break; 774 case SEEK_SET: 775 file->f_pos = offset; 776 break; 777 default: 778 return -EINVAL; 779 } 780 781 return offset; 782 } 783 784 static int cfam_open(struct inode *inode, struct file *file) 785 { 786 struct fsi_slave *slave = container_of(inode->i_cdev, struct fsi_slave, cdev); 787 788 file->private_data = slave; 789 790 return 0; 791 } 792 793 static const struct file_operations cfam_fops = { 794 .owner = THIS_MODULE, 795 .open = cfam_open, 796 .llseek = cfam_llseek, 797 .read = cfam_read, 798 .write = cfam_write, 799 }; 800 801 static ssize_t send_term_store(struct device *dev, 802 struct device_attribute *attr, 803 const char *buf, size_t count) 804 { 805 struct fsi_slave *slave = to_fsi_slave(dev); 806 struct fsi_master *master = slave->master; 807 808 if (!master->term) 809 return -ENODEV; 810 811 master->term(master, slave->link, slave->id); 812 return count; 813 } 814 815 static DEVICE_ATTR_WO(send_term); 816 817 static ssize_t slave_send_echo_show(struct device *dev, 818 struct device_attribute *attr, 819 char *buf) 820 { 821 struct fsi_slave *slave = to_fsi_slave(dev); 822 823 return sprintf(buf, "%u\n", slave->t_send_delay); 824 } 825 826 static ssize_t slave_send_echo_store(struct device *dev, 827 struct device_attribute *attr, const char *buf, size_t count) 828 { 829 struct fsi_slave *slave = to_fsi_slave(dev); 830 struct fsi_master *master = slave->master; 831 unsigned long val; 832 int rc; 833 834 if (kstrtoul(buf, 0, &val) < 0) 835 return -EINVAL; 836 837 if (val < 1 || val > 16) 838 return -EINVAL; 839 840 if (!master->link_config) 841 return -ENXIO; 842 843 /* Current HW mandates that send and echo delay are identical */ 844 slave->t_send_delay = val; 845 slave->t_echo_delay = val; 846 847 rc = fsi_slave_set_smode(slave); 848 if (rc < 0) 849 return rc; 850 if (master->link_config) 851 master->link_config(master, slave->link, 852 slave->t_send_delay, 853 slave->t_echo_delay); 854 855 return count; 856 } 857 858 static DEVICE_ATTR(send_echo_delays, 0600, 859 slave_send_echo_show, slave_send_echo_store); 860 861 static ssize_t chip_id_show(struct device *dev, 862 struct device_attribute *attr, 863 char *buf) 864 { 865 struct fsi_slave *slave = to_fsi_slave(dev); 866 867 return sprintf(buf, "%d\n", slave->chip_id); 868 } 869 870 static DEVICE_ATTR_RO(chip_id); 871 872 static ssize_t cfam_id_show(struct device *dev, 873 struct device_attribute *attr, 874 char *buf) 875 { 876 struct fsi_slave *slave = to_fsi_slave(dev); 877 878 return sprintf(buf, "0x%x\n", slave->cfam_id); 879 } 880 881 static DEVICE_ATTR_RO(cfam_id); 882 883 static struct attribute *cfam_attr[] = { 884 &dev_attr_send_echo_delays.attr, 885 &dev_attr_chip_id.attr, 886 &dev_attr_cfam_id.attr, 887 &dev_attr_send_term.attr, 888 NULL, 889 }; 890 891 static const struct attribute_group cfam_attr_group = { 892 .attrs = cfam_attr, 893 }; 894 895 static const struct attribute_group *cfam_attr_groups[] = { 896 &cfam_attr_group, 897 NULL, 898 }; 899 900 static char *cfam_devnode(struct device *dev, umode_t *mode, 901 kuid_t *uid, kgid_t *gid) 902 { 903 struct fsi_slave *slave = to_fsi_slave(dev); 904 905 #ifdef CONFIG_FSI_NEW_DEV_NODE 906 return kasprintf(GFP_KERNEL, "fsi/cfam%d", slave->cdev_idx); 907 #else 908 return kasprintf(GFP_KERNEL, "cfam%d", slave->cdev_idx); 909 #endif 910 } 911 912 static const struct device_type cfam_type = { 913 .name = "cfam", 914 .devnode = cfam_devnode, 915 .groups = cfam_attr_groups 916 }; 917 918 static char *fsi_cdev_devnode(struct device *dev, umode_t *mode, 919 kuid_t *uid, kgid_t *gid) 920 { 921 #ifdef CONFIG_FSI_NEW_DEV_NODE 922 return kasprintf(GFP_KERNEL, "fsi/%s", dev_name(dev)); 923 #else 924 return kasprintf(GFP_KERNEL, "%s", dev_name(dev)); 925 #endif 926 } 927 928 const struct device_type fsi_cdev_type = { 929 .name = "fsi-cdev", 930 .devnode = fsi_cdev_devnode, 931 }; 932 EXPORT_SYMBOL_GPL(fsi_cdev_type); 933 934 /* Backward compatible /dev/ numbering in "old style" mode */ 935 static int fsi_adjust_index(int index) 936 { 937 #ifdef CONFIG_FSI_NEW_DEV_NODE 938 return index; 939 #else 940 return index + 1; 941 #endif 942 } 943 944 static int __fsi_get_new_minor(struct fsi_slave *slave, enum fsi_dev_type type, 945 dev_t *out_dev, int *out_index) 946 { 947 int cid = slave->chip_id; 948 int id; 949 950 /* Check if we qualify for legacy numbering */ 951 if (cid >= 0 && cid < 16 && type < 4) { 952 /* Try reserving the legacy number */ 953 id = (cid << 4) | type; 954 id = ida_simple_get(&fsi_minor_ida, id, id + 1, GFP_KERNEL); 955 if (id >= 0) { 956 *out_index = fsi_adjust_index(cid); 957 *out_dev = fsi_base_dev + id; 958 return 0; 959 } 960 /* Other failure */ 961 if (id != -ENOSPC) 962 return id; 963 /* Fallback to non-legacy allocation */ 964 } 965 id = ida_simple_get(&fsi_minor_ida, FSI_CHAR_LEGACY_TOP, 966 FSI_CHAR_MAX_DEVICES, GFP_KERNEL); 967 if (id < 0) 968 return id; 969 *out_index = fsi_adjust_index(id); 970 *out_dev = fsi_base_dev + id; 971 return 0; 972 } 973 974 int fsi_get_new_minor(struct fsi_device *fdev, enum fsi_dev_type type, 975 dev_t *out_dev, int *out_index) 976 { 977 return __fsi_get_new_minor(fdev->slave, type, out_dev, out_index); 978 } 979 EXPORT_SYMBOL_GPL(fsi_get_new_minor); 980 981 void fsi_free_minor(dev_t dev) 982 { 983 ida_simple_remove(&fsi_minor_ida, MINOR(dev)); 984 } 985 EXPORT_SYMBOL_GPL(fsi_free_minor); 986 987 static int fsi_slave_init(struct fsi_master *master, int link, uint8_t id) 988 { 989 uint32_t cfam_id; 990 struct fsi_slave *slave; 991 uint8_t crc; 992 __be32 data, llmode, slbus; 993 int rc; 994 995 /* Currently, we only support single slaves on a link, and use the 996 * full 23-bit address range 997 */ 998 if (id != 0) 999 return -EINVAL; 1000 1001 rc = fsi_master_read(master, link, id, 0, &data, sizeof(data)); 1002 if (rc) { 1003 dev_dbg(&master->dev, "can't read slave %02x:%02x %d\n", 1004 link, id, rc); 1005 return -ENODEV; 1006 } 1007 cfam_id = be32_to_cpu(data); 1008 1009 crc = crc4(0, cfam_id, 32); 1010 if (crc) { 1011 trace_fsi_slave_invalid_cfam(master, link, cfam_id); 1012 dev_warn(&master->dev, "slave %02x:%02x invalid cfam id CRC!\n", 1013 link, id); 1014 return -EIO; 1015 } 1016 1017 dev_dbg(&master->dev, "fsi: found chip %08x at %02x:%02x:%02x\n", 1018 cfam_id, master->idx, link, id); 1019 1020 /* If we're behind a master that doesn't provide a self-running bus 1021 * clock, put the slave into async mode 1022 */ 1023 if (master->flags & FSI_MASTER_FLAG_SWCLOCK) { 1024 llmode = cpu_to_be32(FSI_LLMODE_ASYNC); 1025 rc = fsi_master_write(master, link, id, 1026 FSI_SLAVE_BASE + FSI_LLMODE, 1027 &llmode, sizeof(llmode)); 1028 if (rc) 1029 dev_warn(&master->dev, 1030 "can't set llmode on slave:%02x:%02x %d\n", 1031 link, id, rc); 1032 } 1033 1034 /* We can communicate with a slave; create the slave device and 1035 * register. 1036 */ 1037 slave = kzalloc(sizeof(*slave), GFP_KERNEL); 1038 if (!slave) 1039 return -ENOMEM; 1040 1041 dev_set_name(&slave->dev, "slave@%02x:%02x", link, id); 1042 slave->dev.type = &cfam_type; 1043 slave->dev.parent = &master->dev; 1044 slave->dev.of_node = fsi_slave_find_of_node(master, link, id); 1045 slave->dev.release = fsi_slave_release; 1046 device_initialize(&slave->dev); 1047 slave->cfam_id = cfam_id; 1048 slave->master = master; 1049 slave->link = link; 1050 slave->id = id; 1051 slave->size = FSI_SLAVE_SIZE_23b; 1052 slave->t_send_delay = 16; 1053 slave->t_echo_delay = 16; 1054 1055 /* Get chip ID if any */ 1056 slave->chip_id = -1; 1057 if (slave->dev.of_node) { 1058 uint32_t prop; 1059 if (!of_property_read_u32(slave->dev.of_node, "chip-id", &prop)) 1060 slave->chip_id = prop; 1061 1062 } 1063 1064 slbus = cpu_to_be32(FSI_SLBUS_FORCE); 1065 rc = fsi_master_write(master, link, id, FSI_SLAVE_BASE + FSI_SLBUS, 1066 &slbus, sizeof(slbus)); 1067 if (rc) 1068 dev_warn(&master->dev, 1069 "can't set slbus on slave:%02x:%02x %d\n", link, id, 1070 rc); 1071 1072 rc = fsi_slave_set_smode(slave); 1073 if (rc) { 1074 dev_warn(&master->dev, 1075 "can't set smode on slave:%02x:%02x %d\n", 1076 link, id, rc); 1077 goto err_free; 1078 } 1079 1080 /* Allocate a minor in the FSI space */ 1081 rc = __fsi_get_new_minor(slave, fsi_dev_cfam, &slave->dev.devt, 1082 &slave->cdev_idx); 1083 if (rc) 1084 goto err_free; 1085 1086 trace_fsi_slave_init(slave); 1087 1088 /* Create chardev for userspace access */ 1089 cdev_init(&slave->cdev, &cfam_fops); 1090 rc = cdev_device_add(&slave->cdev, &slave->dev); 1091 if (rc) { 1092 dev_err(&slave->dev, "Error %d creating slave device\n", rc); 1093 goto err_free_ida; 1094 } 1095 1096 /* Now that we have the cdev registered with the core, any fatal 1097 * failures beyond this point will need to clean up through 1098 * cdev_device_del(). Fortunately though, nothing past here is fatal. 1099 */ 1100 1101 if (master->link_config) 1102 master->link_config(master, link, 1103 slave->t_send_delay, 1104 slave->t_echo_delay); 1105 1106 /* Legacy raw file -> to be removed */ 1107 rc = device_create_bin_file(&slave->dev, &fsi_slave_raw_attr); 1108 if (rc) 1109 dev_warn(&slave->dev, "failed to create raw attr: %d\n", rc); 1110 1111 1112 rc = fsi_slave_scan(slave); 1113 if (rc) 1114 dev_dbg(&master->dev, "failed during slave scan with: %d\n", 1115 rc); 1116 1117 return 0; 1118 1119 err_free_ida: 1120 fsi_free_minor(slave->dev.devt); 1121 err_free: 1122 of_node_put(slave->dev.of_node); 1123 kfree(slave); 1124 return rc; 1125 } 1126 1127 /* FSI master support */ 1128 static int fsi_check_access(uint32_t addr, size_t size) 1129 { 1130 if (size == 4) { 1131 if (addr & 0x3) 1132 return -EINVAL; 1133 } else if (size == 2) { 1134 if (addr & 0x1) 1135 return -EINVAL; 1136 } else if (size != 1) 1137 return -EINVAL; 1138 1139 return 0; 1140 } 1141 1142 static int fsi_master_read(struct fsi_master *master, int link, 1143 uint8_t slave_id, uint32_t addr, void *val, size_t size) 1144 { 1145 int rc; 1146 1147 trace_fsi_master_read(master, link, slave_id, addr, size); 1148 1149 rc = fsi_check_access(addr, size); 1150 if (!rc) 1151 rc = master->read(master, link, slave_id, addr, val, size); 1152 1153 trace_fsi_master_rw_result(master, link, slave_id, addr, size, 1154 false, val, rc); 1155 1156 return rc; 1157 } 1158 1159 static int fsi_master_write(struct fsi_master *master, int link, 1160 uint8_t slave_id, uint32_t addr, const void *val, size_t size) 1161 { 1162 int rc; 1163 1164 trace_fsi_master_write(master, link, slave_id, addr, size, val); 1165 1166 rc = fsi_check_access(addr, size); 1167 if (!rc) 1168 rc = master->write(master, link, slave_id, addr, val, size); 1169 1170 trace_fsi_master_rw_result(master, link, slave_id, addr, size, 1171 true, val, rc); 1172 1173 return rc; 1174 } 1175 1176 static int fsi_master_link_disable(struct fsi_master *master, int link) 1177 { 1178 if (master->link_enable) 1179 return master->link_enable(master, link, false); 1180 1181 return 0; 1182 } 1183 1184 static int fsi_master_link_enable(struct fsi_master *master, int link) 1185 { 1186 if (master->link_enable) 1187 return master->link_enable(master, link, true); 1188 1189 return 0; 1190 } 1191 1192 /* 1193 * Issue a break command on this link 1194 */ 1195 static int fsi_master_break(struct fsi_master *master, int link) 1196 { 1197 int rc = 0; 1198 1199 trace_fsi_master_break(master, link); 1200 1201 if (master->send_break) 1202 rc = master->send_break(master, link); 1203 if (master->link_config) 1204 master->link_config(master, link, 16, 16); 1205 1206 return rc; 1207 } 1208 1209 static int fsi_master_scan(struct fsi_master *master) 1210 { 1211 int link, rc; 1212 1213 for (link = 0; link < master->n_links; link++) { 1214 rc = fsi_master_link_enable(master, link); 1215 if (rc) { 1216 dev_dbg(&master->dev, 1217 "enable link %d failed: %d\n", link, rc); 1218 continue; 1219 } 1220 rc = fsi_master_break(master, link); 1221 if (rc) { 1222 fsi_master_link_disable(master, link); 1223 dev_dbg(&master->dev, 1224 "break to link %d failed: %d\n", link, rc); 1225 continue; 1226 } 1227 1228 rc = fsi_slave_init(master, link, 0); 1229 if (rc) 1230 fsi_master_link_disable(master, link); 1231 } 1232 1233 return 0; 1234 } 1235 1236 static int fsi_slave_remove_device(struct device *dev, void *arg) 1237 { 1238 device_unregister(dev); 1239 return 0; 1240 } 1241 1242 static int fsi_master_remove_slave(struct device *dev, void *arg) 1243 { 1244 struct fsi_slave *slave = to_fsi_slave(dev); 1245 1246 device_for_each_child(dev, NULL, fsi_slave_remove_device); 1247 cdev_device_del(&slave->cdev, &slave->dev); 1248 put_device(dev); 1249 return 0; 1250 } 1251 1252 static void fsi_master_unscan(struct fsi_master *master) 1253 { 1254 device_for_each_child(&master->dev, NULL, fsi_master_remove_slave); 1255 } 1256 1257 int fsi_master_rescan(struct fsi_master *master) 1258 { 1259 int rc; 1260 1261 mutex_lock(&master->scan_lock); 1262 fsi_master_unscan(master); 1263 rc = fsi_master_scan(master); 1264 mutex_unlock(&master->scan_lock); 1265 1266 return rc; 1267 } 1268 EXPORT_SYMBOL_GPL(fsi_master_rescan); 1269 1270 static ssize_t master_rescan_store(struct device *dev, 1271 struct device_attribute *attr, const char *buf, size_t count) 1272 { 1273 struct fsi_master *master = to_fsi_master(dev); 1274 int rc; 1275 1276 rc = fsi_master_rescan(master); 1277 if (rc < 0) 1278 return rc; 1279 1280 return count; 1281 } 1282 1283 static DEVICE_ATTR(rescan, 0200, NULL, master_rescan_store); 1284 1285 static ssize_t master_break_store(struct device *dev, 1286 struct device_attribute *attr, const char *buf, size_t count) 1287 { 1288 struct fsi_master *master = to_fsi_master(dev); 1289 1290 fsi_master_break(master, 0); 1291 1292 return count; 1293 } 1294 1295 static DEVICE_ATTR(break, 0200, NULL, master_break_store); 1296 1297 static struct attribute *master_attrs[] = { 1298 &dev_attr_break.attr, 1299 &dev_attr_rescan.attr, 1300 NULL 1301 }; 1302 1303 ATTRIBUTE_GROUPS(master); 1304 1305 static struct class fsi_master_class = { 1306 .name = "fsi-master", 1307 .dev_groups = master_groups, 1308 }; 1309 1310 int fsi_master_register(struct fsi_master *master) 1311 { 1312 int rc; 1313 struct device_node *np; 1314 1315 mutex_init(&master->scan_lock); 1316 master->idx = ida_simple_get(&master_ida, 0, INT_MAX, GFP_KERNEL); 1317 dev_set_name(&master->dev, "fsi%d", master->idx); 1318 master->dev.class = &fsi_master_class; 1319 1320 rc = device_register(&master->dev); 1321 if (rc) { 1322 ida_simple_remove(&master_ida, master->idx); 1323 return rc; 1324 } 1325 1326 np = dev_of_node(&master->dev); 1327 if (!of_property_read_bool(np, "no-scan-on-init")) { 1328 mutex_lock(&master->scan_lock); 1329 fsi_master_scan(master); 1330 mutex_unlock(&master->scan_lock); 1331 } 1332 1333 return 0; 1334 } 1335 EXPORT_SYMBOL_GPL(fsi_master_register); 1336 1337 void fsi_master_unregister(struct fsi_master *master) 1338 { 1339 if (master->idx >= 0) { 1340 ida_simple_remove(&master_ida, master->idx); 1341 master->idx = -1; 1342 } 1343 1344 mutex_lock(&master->scan_lock); 1345 fsi_master_unscan(master); 1346 mutex_unlock(&master->scan_lock); 1347 device_unregister(&master->dev); 1348 } 1349 EXPORT_SYMBOL_GPL(fsi_master_unregister); 1350 1351 /* FSI core & Linux bus type definitions */ 1352 1353 static int fsi_bus_match(struct device *dev, struct device_driver *drv) 1354 { 1355 struct fsi_device *fsi_dev = to_fsi_dev(dev); 1356 struct fsi_driver *fsi_drv = to_fsi_drv(drv); 1357 const struct fsi_device_id *id; 1358 1359 if (!fsi_drv->id_table) 1360 return 0; 1361 1362 for (id = fsi_drv->id_table; id->engine_type; id++) { 1363 if (id->engine_type != fsi_dev->engine_type) 1364 continue; 1365 if (id->version == FSI_VERSION_ANY || 1366 id->version == fsi_dev->version) 1367 return 1; 1368 } 1369 1370 return 0; 1371 } 1372 1373 int fsi_driver_register(struct fsi_driver *fsi_drv) 1374 { 1375 if (!fsi_drv) 1376 return -EINVAL; 1377 if (!fsi_drv->id_table) 1378 return -EINVAL; 1379 1380 return driver_register(&fsi_drv->drv); 1381 } 1382 EXPORT_SYMBOL_GPL(fsi_driver_register); 1383 1384 void fsi_driver_unregister(struct fsi_driver *fsi_drv) 1385 { 1386 driver_unregister(&fsi_drv->drv); 1387 } 1388 EXPORT_SYMBOL_GPL(fsi_driver_unregister); 1389 1390 struct bus_type fsi_bus_type = { 1391 .name = "fsi", 1392 .match = fsi_bus_match, 1393 }; 1394 EXPORT_SYMBOL_GPL(fsi_bus_type); 1395 1396 static int __init fsi_init(void) 1397 { 1398 int rc; 1399 1400 rc = alloc_chrdev_region(&fsi_base_dev, 0, FSI_CHAR_MAX_DEVICES, "fsi"); 1401 if (rc) 1402 return rc; 1403 rc = bus_register(&fsi_bus_type); 1404 if (rc) 1405 goto fail_bus; 1406 1407 rc = class_register(&fsi_master_class); 1408 if (rc) 1409 goto fail_class; 1410 1411 return 0; 1412 1413 fail_class: 1414 bus_unregister(&fsi_bus_type); 1415 fail_bus: 1416 unregister_chrdev_region(fsi_base_dev, FSI_CHAR_MAX_DEVICES); 1417 return rc; 1418 } 1419 postcore_initcall(fsi_init); 1420 1421 static void fsi_exit(void) 1422 { 1423 class_unregister(&fsi_master_class); 1424 bus_unregister(&fsi_bus_type); 1425 unregister_chrdev_region(fsi_base_dev, FSI_CHAR_MAX_DEVICES); 1426 ida_destroy(&fsi_minor_ida); 1427 } 1428 module_exit(fsi_exit); 1429 module_param(discard_errors, int, 0664); 1430 MODULE_LICENSE("GPL"); 1431 MODULE_PARM_DESC(discard_errors, "Don't invoke error handling on bus accesses"); 1432