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 CREATE_TRACE_POINTS 28 #include <trace/events/fsi.h> 29 30 #define FSI_SLAVE_CONF_NEXT_MASK GENMASK(31, 31) 31 #define FSI_SLAVE_CONF_SLOTS_MASK GENMASK(23, 16) 32 #define FSI_SLAVE_CONF_SLOTS_SHIFT 16 33 #define FSI_SLAVE_CONF_VERSION_MASK GENMASK(15, 12) 34 #define FSI_SLAVE_CONF_VERSION_SHIFT 12 35 #define FSI_SLAVE_CONF_TYPE_MASK GENMASK(11, 4) 36 #define FSI_SLAVE_CONF_TYPE_SHIFT 4 37 #define FSI_SLAVE_CONF_CRC_SHIFT 4 38 #define FSI_SLAVE_CONF_CRC_MASK GENMASK(3, 0) 39 #define FSI_SLAVE_CONF_DATA_BITS 28 40 41 #define FSI_PEEK_BASE 0x410 42 43 static const int engine_page_size = 0x400; 44 45 #define FSI_SLAVE_BASE 0x800 46 47 /* 48 * FSI slave engine control register offsets 49 */ 50 #define FSI_SMODE 0x0 /* R/W: Mode register */ 51 #define FSI_SISC 0x8 /* R/W: Interrupt condition */ 52 #define FSI_SSTAT 0x14 /* R : Slave status */ 53 #define FSI_SLBUS 0x30 /* W : LBUS Ownership */ 54 #define FSI_LLMODE 0x100 /* R/W: Link layer mode register */ 55 56 /* 57 * SMODE fields 58 */ 59 #define FSI_SMODE_WSC 0x80000000 /* Warm start done */ 60 #define FSI_SMODE_ECRC 0x20000000 /* Hw CRC check */ 61 #define FSI_SMODE_SID_SHIFT 24 /* ID shift */ 62 #define FSI_SMODE_SID_MASK 3 /* ID Mask */ 63 #define FSI_SMODE_ED_SHIFT 20 /* Echo delay shift */ 64 #define FSI_SMODE_ED_MASK 0xf /* Echo delay mask */ 65 #define FSI_SMODE_SD_SHIFT 16 /* Send delay shift */ 66 #define FSI_SMODE_SD_MASK 0xf /* Send delay mask */ 67 #define FSI_SMODE_LBCRR_SHIFT 8 /* Clk ratio shift */ 68 #define FSI_SMODE_LBCRR_MASK 0xf /* Clk ratio mask */ 69 70 /* 71 * SLBUS fields 72 */ 73 #define FSI_SLBUS_FORCE 0x80000000 /* Force LBUS ownership */ 74 75 /* 76 * LLMODE fields 77 */ 78 #define FSI_LLMODE_ASYNC 0x1 79 80 #define FSI_SLAVE_SIZE_23b 0x800000 81 82 static DEFINE_IDA(master_ida); 83 84 struct fsi_slave { 85 struct device dev; 86 struct fsi_master *master; 87 struct cdev cdev; 88 int cdev_idx; 89 int id; /* FSI address */ 90 int link; /* FSI link# */ 91 u32 cfam_id; 92 int chip_id; 93 uint32_t size; /* size of slave address space */ 94 u8 t_send_delay; 95 u8 t_echo_delay; 96 }; 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 dev_dbg(&slave->dev, 528 "engine[%i]: type %x, version %x, addr %x size %x\n", 529 dev->unit, dev->engine_type, version, 530 dev->addr, dev->size); 531 532 dev_set_name(&dev->dev, "%02x:%02x:%02x:%02x", 533 slave->master->idx, slave->link, 534 slave->id, i - 2); 535 dev->dev.of_node = fsi_device_find_of_node(dev); 536 537 rc = device_register(&dev->dev); 538 if (rc) { 539 dev_warn(&slave->dev, "add failed: %d\n", rc); 540 put_device(&dev->dev); 541 } 542 } 543 544 engine_addr += slots * engine_page_size; 545 546 if (!(conf & FSI_SLAVE_CONF_NEXT_MASK)) 547 break; 548 } 549 550 return 0; 551 } 552 553 static unsigned long aligned_access_size(size_t offset, size_t count) 554 { 555 unsigned long offset_unit, count_unit; 556 557 /* Criteria: 558 * 559 * 1. Access size must be less than or equal to the maximum access 560 * width or the highest power-of-two factor of offset 561 * 2. Access size must be less than or equal to the amount specified by 562 * count 563 * 564 * The access width is optimal if we can calculate 1 to be strictly 565 * equal while still satisfying 2. 566 */ 567 568 /* Find 1 by the bottom bit of offset (with a 4 byte access cap) */ 569 offset_unit = BIT(__builtin_ctzl(offset | 4)); 570 571 /* Find 2 by the top bit of count */ 572 count_unit = BIT(8 * sizeof(unsigned long) - 1 - __builtin_clzl(count)); 573 574 /* Constrain the maximum access width to the minimum of both criteria */ 575 return BIT(__builtin_ctzl(offset_unit | count_unit)); 576 } 577 578 static ssize_t fsi_slave_sysfs_raw_read(struct file *file, 579 struct kobject *kobj, struct bin_attribute *attr, char *buf, 580 loff_t off, size_t count) 581 { 582 struct fsi_slave *slave = to_fsi_slave(kobj_to_dev(kobj)); 583 size_t total_len, read_len; 584 int rc; 585 586 if (off < 0) 587 return -EINVAL; 588 589 if (off > 0xffffffff || count > 0xffffffff || off + count > 0xffffffff) 590 return -EINVAL; 591 592 for (total_len = 0; total_len < count; total_len += read_len) { 593 read_len = aligned_access_size(off, count - total_len); 594 595 rc = fsi_slave_read(slave, off, buf + total_len, read_len); 596 if (rc) 597 return rc; 598 599 off += read_len; 600 } 601 602 return count; 603 } 604 605 static ssize_t fsi_slave_sysfs_raw_write(struct file *file, 606 struct kobject *kobj, struct bin_attribute *attr, 607 char *buf, loff_t off, size_t count) 608 { 609 struct fsi_slave *slave = to_fsi_slave(kobj_to_dev(kobj)); 610 size_t total_len, write_len; 611 int rc; 612 613 if (off < 0) 614 return -EINVAL; 615 616 if (off > 0xffffffff || count > 0xffffffff || off + count > 0xffffffff) 617 return -EINVAL; 618 619 for (total_len = 0; total_len < count; total_len += write_len) { 620 write_len = aligned_access_size(off, count - total_len); 621 622 rc = fsi_slave_write(slave, off, buf + total_len, write_len); 623 if (rc) 624 return rc; 625 626 off += write_len; 627 } 628 629 return count; 630 } 631 632 static const struct bin_attribute fsi_slave_raw_attr = { 633 .attr = { 634 .name = "raw", 635 .mode = 0600, 636 }, 637 .size = 0, 638 .read = fsi_slave_sysfs_raw_read, 639 .write = fsi_slave_sysfs_raw_write, 640 }; 641 642 static void fsi_slave_release(struct device *dev) 643 { 644 struct fsi_slave *slave = to_fsi_slave(dev); 645 646 fsi_free_minor(slave->dev.devt); 647 of_node_put(dev->of_node); 648 kfree(slave); 649 } 650 651 static bool fsi_slave_node_matches(struct device_node *np, 652 int link, uint8_t id) 653 { 654 unsigned int len, na, ns; 655 const __be32 *prop; 656 657 na = of_n_addr_cells(np); 658 ns = of_n_size_cells(np); 659 660 /* Ensure we have the correct format for addresses and sizes in 661 * reg properties 662 */ 663 if (na != 2 || ns != 0) 664 return false; 665 666 prop = of_get_property(np, "reg", &len); 667 if (!prop || len != 8) 668 return false; 669 670 return (of_read_number(prop, 1) == link) && 671 (of_read_number(prop + 1, 1) == id); 672 } 673 674 /* Find a matching node for the slave at (link, id). Returns NULL if none 675 * found, or a matching node with refcount already incremented. 676 */ 677 static struct device_node *fsi_slave_find_of_node(struct fsi_master *master, 678 int link, uint8_t id) 679 { 680 struct device_node *parent, *np; 681 682 parent = dev_of_node(&master->dev); 683 if (!parent) 684 return NULL; 685 686 for_each_child_of_node(parent, np) { 687 if (fsi_slave_node_matches(np, link, id)) 688 return np; 689 } 690 691 return NULL; 692 } 693 694 static ssize_t cfam_read(struct file *filep, char __user *buf, size_t count, 695 loff_t *offset) 696 { 697 struct fsi_slave *slave = filep->private_data; 698 size_t total_len, read_len; 699 loff_t off = *offset; 700 ssize_t rc; 701 702 if (off < 0) 703 return -EINVAL; 704 705 if (off > 0xffffffff || count > 0xffffffff || off + count > 0xffffffff) 706 return -EINVAL; 707 708 for (total_len = 0; total_len < count; total_len += read_len) { 709 __be32 data; 710 711 read_len = min_t(size_t, count, 4); 712 read_len -= off & 0x3; 713 714 rc = fsi_slave_read(slave, off, &data, read_len); 715 if (rc) 716 goto fail; 717 rc = copy_to_user(buf + total_len, &data, read_len); 718 if (rc) { 719 rc = -EFAULT; 720 goto fail; 721 } 722 off += read_len; 723 } 724 rc = count; 725 fail: 726 *offset = off; 727 return rc; 728 } 729 730 static ssize_t cfam_write(struct file *filep, const char __user *buf, 731 size_t count, loff_t *offset) 732 { 733 struct fsi_slave *slave = filep->private_data; 734 size_t total_len, write_len; 735 loff_t off = *offset; 736 ssize_t rc; 737 738 739 if (off < 0) 740 return -EINVAL; 741 742 if (off > 0xffffffff || count > 0xffffffff || off + count > 0xffffffff) 743 return -EINVAL; 744 745 for (total_len = 0; total_len < count; total_len += write_len) { 746 __be32 data; 747 748 write_len = min_t(size_t, count, 4); 749 write_len -= off & 0x3; 750 751 rc = copy_from_user(&data, buf + total_len, write_len); 752 if (rc) { 753 rc = -EFAULT; 754 goto fail; 755 } 756 rc = fsi_slave_write(slave, off, &data, write_len); 757 if (rc) 758 goto fail; 759 off += write_len; 760 } 761 rc = count; 762 fail: 763 *offset = off; 764 return rc; 765 } 766 767 static loff_t cfam_llseek(struct file *file, loff_t offset, int whence) 768 { 769 switch (whence) { 770 case SEEK_CUR: 771 break; 772 case SEEK_SET: 773 file->f_pos = offset; 774 break; 775 default: 776 return -EINVAL; 777 } 778 779 return offset; 780 } 781 782 static int cfam_open(struct inode *inode, struct file *file) 783 { 784 struct fsi_slave *slave = container_of(inode->i_cdev, struct fsi_slave, cdev); 785 786 file->private_data = slave; 787 788 return 0; 789 } 790 791 static const struct file_operations cfam_fops = { 792 .owner = THIS_MODULE, 793 .open = cfam_open, 794 .llseek = cfam_llseek, 795 .read = cfam_read, 796 .write = cfam_write, 797 }; 798 799 static ssize_t send_term_store(struct device *dev, 800 struct device_attribute *attr, 801 const char *buf, size_t count) 802 { 803 struct fsi_slave *slave = to_fsi_slave(dev); 804 struct fsi_master *master = slave->master; 805 806 if (!master->term) 807 return -ENODEV; 808 809 master->term(master, slave->link, slave->id); 810 return count; 811 } 812 813 static DEVICE_ATTR_WO(send_term); 814 815 static ssize_t slave_send_echo_show(struct device *dev, 816 struct device_attribute *attr, 817 char *buf) 818 { 819 struct fsi_slave *slave = to_fsi_slave(dev); 820 821 return sprintf(buf, "%u\n", slave->t_send_delay); 822 } 823 824 static ssize_t slave_send_echo_store(struct device *dev, 825 struct device_attribute *attr, const char *buf, size_t count) 826 { 827 struct fsi_slave *slave = to_fsi_slave(dev); 828 struct fsi_master *master = slave->master; 829 unsigned long val; 830 int rc; 831 832 if (kstrtoul(buf, 0, &val) < 0) 833 return -EINVAL; 834 835 if (val < 1 || val > 16) 836 return -EINVAL; 837 838 if (!master->link_config) 839 return -ENXIO; 840 841 /* Current HW mandates that send and echo delay are identical */ 842 slave->t_send_delay = val; 843 slave->t_echo_delay = val; 844 845 rc = fsi_slave_set_smode(slave); 846 if (rc < 0) 847 return rc; 848 if (master->link_config) 849 master->link_config(master, slave->link, 850 slave->t_send_delay, 851 slave->t_echo_delay); 852 853 return count; 854 } 855 856 static DEVICE_ATTR(send_echo_delays, 0600, 857 slave_send_echo_show, slave_send_echo_store); 858 859 static ssize_t chip_id_show(struct device *dev, 860 struct device_attribute *attr, 861 char *buf) 862 { 863 struct fsi_slave *slave = to_fsi_slave(dev); 864 865 return sprintf(buf, "%d\n", slave->chip_id); 866 } 867 868 static DEVICE_ATTR_RO(chip_id); 869 870 static ssize_t cfam_id_show(struct device *dev, 871 struct device_attribute *attr, 872 char *buf) 873 { 874 struct fsi_slave *slave = to_fsi_slave(dev); 875 876 return sprintf(buf, "0x%x\n", slave->cfam_id); 877 } 878 879 static DEVICE_ATTR_RO(cfam_id); 880 881 static struct attribute *cfam_attr[] = { 882 &dev_attr_send_echo_delays.attr, 883 &dev_attr_chip_id.attr, 884 &dev_attr_cfam_id.attr, 885 &dev_attr_send_term.attr, 886 NULL, 887 }; 888 889 static const struct attribute_group cfam_attr_group = { 890 .attrs = cfam_attr, 891 }; 892 893 static const struct attribute_group *cfam_attr_groups[] = { 894 &cfam_attr_group, 895 NULL, 896 }; 897 898 static char *cfam_devnode(struct device *dev, umode_t *mode, 899 kuid_t *uid, kgid_t *gid) 900 { 901 struct fsi_slave *slave = to_fsi_slave(dev); 902 903 #ifdef CONFIG_FSI_NEW_DEV_NODE 904 return kasprintf(GFP_KERNEL, "fsi/cfam%d", slave->cdev_idx); 905 #else 906 return kasprintf(GFP_KERNEL, "cfam%d", slave->cdev_idx); 907 #endif 908 } 909 910 static const struct device_type cfam_type = { 911 .name = "cfam", 912 .devnode = cfam_devnode, 913 .groups = cfam_attr_groups 914 }; 915 916 static char *fsi_cdev_devnode(struct device *dev, umode_t *mode, 917 kuid_t *uid, kgid_t *gid) 918 { 919 #ifdef CONFIG_FSI_NEW_DEV_NODE 920 return kasprintf(GFP_KERNEL, "fsi/%s", dev_name(dev)); 921 #else 922 return kasprintf(GFP_KERNEL, "%s", dev_name(dev)); 923 #endif 924 } 925 926 const struct device_type fsi_cdev_type = { 927 .name = "fsi-cdev", 928 .devnode = fsi_cdev_devnode, 929 }; 930 EXPORT_SYMBOL_GPL(fsi_cdev_type); 931 932 /* Backward compatible /dev/ numbering in "old style" mode */ 933 static int fsi_adjust_index(int index) 934 { 935 #ifdef CONFIG_FSI_NEW_DEV_NODE 936 return index; 937 #else 938 return index + 1; 939 #endif 940 } 941 942 static int __fsi_get_new_minor(struct fsi_slave *slave, enum fsi_dev_type type, 943 dev_t *out_dev, int *out_index) 944 { 945 int cid = slave->chip_id; 946 int id; 947 948 /* Check if we qualify for legacy numbering */ 949 if (cid >= 0 && cid < 16 && type < 4) { 950 /* Try reserving the legacy number */ 951 id = (cid << 4) | type; 952 id = ida_simple_get(&fsi_minor_ida, id, id + 1, GFP_KERNEL); 953 if (id >= 0) { 954 *out_index = fsi_adjust_index(cid); 955 *out_dev = fsi_base_dev + id; 956 return 0; 957 } 958 /* Other failure */ 959 if (id != -ENOSPC) 960 return id; 961 /* Fallback to non-legacy allocation */ 962 } 963 id = ida_simple_get(&fsi_minor_ida, FSI_CHAR_LEGACY_TOP, 964 FSI_CHAR_MAX_DEVICES, GFP_KERNEL); 965 if (id < 0) 966 return id; 967 *out_index = fsi_adjust_index(id); 968 *out_dev = fsi_base_dev + id; 969 return 0; 970 } 971 972 int fsi_get_new_minor(struct fsi_device *fdev, enum fsi_dev_type type, 973 dev_t *out_dev, int *out_index) 974 { 975 return __fsi_get_new_minor(fdev->slave, type, out_dev, out_index); 976 } 977 EXPORT_SYMBOL_GPL(fsi_get_new_minor); 978 979 void fsi_free_minor(dev_t dev) 980 { 981 ida_simple_remove(&fsi_minor_ida, MINOR(dev)); 982 } 983 EXPORT_SYMBOL_GPL(fsi_free_minor); 984 985 static int fsi_slave_init(struct fsi_master *master, int link, uint8_t id) 986 { 987 uint32_t cfam_id; 988 struct fsi_slave *slave; 989 uint8_t crc; 990 __be32 data, llmode, slbus; 991 int rc; 992 993 /* Currently, we only support single slaves on a link, and use the 994 * full 23-bit address range 995 */ 996 if (id != 0) 997 return -EINVAL; 998 999 rc = fsi_master_read(master, link, id, 0, &data, sizeof(data)); 1000 if (rc) { 1001 dev_dbg(&master->dev, "can't read slave %02x:%02x %d\n", 1002 link, id, rc); 1003 return -ENODEV; 1004 } 1005 cfam_id = be32_to_cpu(data); 1006 1007 crc = crc4(0, cfam_id, 32); 1008 if (crc) { 1009 dev_warn(&master->dev, "slave %02x:%02x invalid cfam id CRC!\n", 1010 link, id); 1011 return -EIO; 1012 } 1013 1014 dev_dbg(&master->dev, "fsi: found chip %08x at %02x:%02x:%02x\n", 1015 cfam_id, master->idx, link, id); 1016 1017 /* If we're behind a master that doesn't provide a self-running bus 1018 * clock, put the slave into async mode 1019 */ 1020 if (master->flags & FSI_MASTER_FLAG_SWCLOCK) { 1021 llmode = cpu_to_be32(FSI_LLMODE_ASYNC); 1022 rc = fsi_master_write(master, link, id, 1023 FSI_SLAVE_BASE + FSI_LLMODE, 1024 &llmode, sizeof(llmode)); 1025 if (rc) 1026 dev_warn(&master->dev, 1027 "can't set llmode on slave:%02x:%02x %d\n", 1028 link, id, rc); 1029 } 1030 1031 /* We can communicate with a slave; create the slave device and 1032 * register. 1033 */ 1034 slave = kzalloc(sizeof(*slave), GFP_KERNEL); 1035 if (!slave) 1036 return -ENOMEM; 1037 1038 dev_set_name(&slave->dev, "slave@%02x:%02x", link, id); 1039 slave->dev.type = &cfam_type; 1040 slave->dev.parent = &master->dev; 1041 slave->dev.of_node = fsi_slave_find_of_node(master, link, id); 1042 slave->dev.release = fsi_slave_release; 1043 device_initialize(&slave->dev); 1044 slave->cfam_id = cfam_id; 1045 slave->master = master; 1046 slave->link = link; 1047 slave->id = id; 1048 slave->size = FSI_SLAVE_SIZE_23b; 1049 slave->t_send_delay = 16; 1050 slave->t_echo_delay = 16; 1051 1052 /* Get chip ID if any */ 1053 slave->chip_id = -1; 1054 if (slave->dev.of_node) { 1055 uint32_t prop; 1056 if (!of_property_read_u32(slave->dev.of_node, "chip-id", &prop)) 1057 slave->chip_id = prop; 1058 1059 } 1060 1061 slbus = cpu_to_be32(FSI_SLBUS_FORCE); 1062 rc = fsi_master_write(master, link, id, FSI_SLAVE_BASE + FSI_SLBUS, 1063 &slbus, sizeof(slbus)); 1064 if (rc) 1065 dev_warn(&master->dev, 1066 "can't set slbus on slave:%02x:%02x %d\n", link, id, 1067 rc); 1068 1069 rc = fsi_slave_set_smode(slave); 1070 if (rc) { 1071 dev_warn(&master->dev, 1072 "can't set smode on slave:%02x:%02x %d\n", 1073 link, id, rc); 1074 goto err_free; 1075 } 1076 1077 /* Allocate a minor in the FSI space */ 1078 rc = __fsi_get_new_minor(slave, fsi_dev_cfam, &slave->dev.devt, 1079 &slave->cdev_idx); 1080 if (rc) 1081 goto err_free; 1082 1083 /* Create chardev for userspace access */ 1084 cdev_init(&slave->cdev, &cfam_fops); 1085 rc = cdev_device_add(&slave->cdev, &slave->dev); 1086 if (rc) { 1087 dev_err(&slave->dev, "Error %d creating slave device\n", rc); 1088 goto err_free_ida; 1089 } 1090 1091 /* Now that we have the cdev registered with the core, any fatal 1092 * failures beyond this point will need to clean up through 1093 * cdev_device_del(). Fortunately though, nothing past here is fatal. 1094 */ 1095 1096 if (master->link_config) 1097 master->link_config(master, link, 1098 slave->t_send_delay, 1099 slave->t_echo_delay); 1100 1101 /* Legacy raw file -> to be removed */ 1102 rc = device_create_bin_file(&slave->dev, &fsi_slave_raw_attr); 1103 if (rc) 1104 dev_warn(&slave->dev, "failed to create raw attr: %d\n", rc); 1105 1106 1107 rc = fsi_slave_scan(slave); 1108 if (rc) 1109 dev_dbg(&master->dev, "failed during slave scan with: %d\n", 1110 rc); 1111 1112 return 0; 1113 1114 err_free_ida: 1115 fsi_free_minor(slave->dev.devt); 1116 err_free: 1117 of_node_put(slave->dev.of_node); 1118 kfree(slave); 1119 return rc; 1120 } 1121 1122 /* FSI master support */ 1123 static int fsi_check_access(uint32_t addr, size_t size) 1124 { 1125 if (size == 4) { 1126 if (addr & 0x3) 1127 return -EINVAL; 1128 } else if (size == 2) { 1129 if (addr & 0x1) 1130 return -EINVAL; 1131 } else if (size != 1) 1132 return -EINVAL; 1133 1134 return 0; 1135 } 1136 1137 static int fsi_master_read(struct fsi_master *master, int link, 1138 uint8_t slave_id, uint32_t addr, void *val, size_t size) 1139 { 1140 int rc; 1141 1142 trace_fsi_master_read(master, link, slave_id, addr, size); 1143 1144 rc = fsi_check_access(addr, size); 1145 if (!rc) 1146 rc = master->read(master, link, slave_id, addr, val, size); 1147 1148 trace_fsi_master_rw_result(master, link, slave_id, addr, size, 1149 false, val, rc); 1150 1151 return rc; 1152 } 1153 1154 static int fsi_master_write(struct fsi_master *master, int link, 1155 uint8_t slave_id, uint32_t addr, const void *val, size_t size) 1156 { 1157 int rc; 1158 1159 trace_fsi_master_write(master, link, slave_id, addr, size, val); 1160 1161 rc = fsi_check_access(addr, size); 1162 if (!rc) 1163 rc = master->write(master, link, slave_id, addr, val, size); 1164 1165 trace_fsi_master_rw_result(master, link, slave_id, addr, size, 1166 true, val, rc); 1167 1168 return rc; 1169 } 1170 1171 static int fsi_master_link_disable(struct fsi_master *master, int link) 1172 { 1173 if (master->link_enable) 1174 return master->link_enable(master, link, false); 1175 1176 return 0; 1177 } 1178 1179 static int fsi_master_link_enable(struct fsi_master *master, int link) 1180 { 1181 if (master->link_enable) 1182 return master->link_enable(master, link, true); 1183 1184 return 0; 1185 } 1186 1187 /* 1188 * Issue a break command on this link 1189 */ 1190 static int fsi_master_break(struct fsi_master *master, int link) 1191 { 1192 int rc = 0; 1193 1194 trace_fsi_master_break(master, link); 1195 1196 if (master->send_break) 1197 rc = master->send_break(master, link); 1198 if (master->link_config) 1199 master->link_config(master, link, 16, 16); 1200 1201 return rc; 1202 } 1203 1204 static int fsi_master_scan(struct fsi_master *master) 1205 { 1206 int link, rc; 1207 1208 for (link = 0; link < master->n_links; link++) { 1209 rc = fsi_master_link_enable(master, link); 1210 if (rc) { 1211 dev_dbg(&master->dev, 1212 "enable link %d failed: %d\n", link, rc); 1213 continue; 1214 } 1215 rc = fsi_master_break(master, link); 1216 if (rc) { 1217 fsi_master_link_disable(master, link); 1218 dev_dbg(&master->dev, 1219 "break to link %d failed: %d\n", link, rc); 1220 continue; 1221 } 1222 1223 rc = fsi_slave_init(master, link, 0); 1224 if (rc) 1225 fsi_master_link_disable(master, link); 1226 } 1227 1228 return 0; 1229 } 1230 1231 static int fsi_slave_remove_device(struct device *dev, void *arg) 1232 { 1233 device_unregister(dev); 1234 return 0; 1235 } 1236 1237 static int fsi_master_remove_slave(struct device *dev, void *arg) 1238 { 1239 struct fsi_slave *slave = to_fsi_slave(dev); 1240 1241 device_for_each_child(dev, NULL, fsi_slave_remove_device); 1242 cdev_device_del(&slave->cdev, &slave->dev); 1243 put_device(dev); 1244 return 0; 1245 } 1246 1247 static void fsi_master_unscan(struct fsi_master *master) 1248 { 1249 device_for_each_child(&master->dev, NULL, fsi_master_remove_slave); 1250 } 1251 1252 int fsi_master_rescan(struct fsi_master *master) 1253 { 1254 int rc; 1255 1256 mutex_lock(&master->scan_lock); 1257 fsi_master_unscan(master); 1258 rc = fsi_master_scan(master); 1259 mutex_unlock(&master->scan_lock); 1260 1261 return rc; 1262 } 1263 EXPORT_SYMBOL_GPL(fsi_master_rescan); 1264 1265 static ssize_t master_rescan_store(struct device *dev, 1266 struct device_attribute *attr, const char *buf, size_t count) 1267 { 1268 struct fsi_master *master = to_fsi_master(dev); 1269 int rc; 1270 1271 rc = fsi_master_rescan(master); 1272 if (rc < 0) 1273 return rc; 1274 1275 return count; 1276 } 1277 1278 static DEVICE_ATTR(rescan, 0200, NULL, master_rescan_store); 1279 1280 static ssize_t master_break_store(struct device *dev, 1281 struct device_attribute *attr, const char *buf, size_t count) 1282 { 1283 struct fsi_master *master = to_fsi_master(dev); 1284 1285 fsi_master_break(master, 0); 1286 1287 return count; 1288 } 1289 1290 static DEVICE_ATTR(break, 0200, NULL, master_break_store); 1291 1292 static struct attribute *master_attrs[] = { 1293 &dev_attr_break.attr, 1294 &dev_attr_rescan.attr, 1295 NULL 1296 }; 1297 1298 ATTRIBUTE_GROUPS(master); 1299 1300 static struct class fsi_master_class = { 1301 .name = "fsi-master", 1302 .dev_groups = master_groups, 1303 }; 1304 1305 int fsi_master_register(struct fsi_master *master) 1306 { 1307 int rc; 1308 struct device_node *np; 1309 1310 mutex_init(&master->scan_lock); 1311 master->idx = ida_simple_get(&master_ida, 0, INT_MAX, GFP_KERNEL); 1312 dev_set_name(&master->dev, "fsi%d", master->idx); 1313 master->dev.class = &fsi_master_class; 1314 1315 rc = device_register(&master->dev); 1316 if (rc) { 1317 ida_simple_remove(&master_ida, master->idx); 1318 return rc; 1319 } 1320 1321 np = dev_of_node(&master->dev); 1322 if (!of_property_read_bool(np, "no-scan-on-init")) { 1323 mutex_lock(&master->scan_lock); 1324 fsi_master_scan(master); 1325 mutex_unlock(&master->scan_lock); 1326 } 1327 1328 return 0; 1329 } 1330 EXPORT_SYMBOL_GPL(fsi_master_register); 1331 1332 void fsi_master_unregister(struct fsi_master *master) 1333 { 1334 if (master->idx >= 0) { 1335 ida_simple_remove(&master_ida, master->idx); 1336 master->idx = -1; 1337 } 1338 1339 mutex_lock(&master->scan_lock); 1340 fsi_master_unscan(master); 1341 mutex_unlock(&master->scan_lock); 1342 device_unregister(&master->dev); 1343 } 1344 EXPORT_SYMBOL_GPL(fsi_master_unregister); 1345 1346 /* FSI core & Linux bus type definitions */ 1347 1348 static int fsi_bus_match(struct device *dev, struct device_driver *drv) 1349 { 1350 struct fsi_device *fsi_dev = to_fsi_dev(dev); 1351 struct fsi_driver *fsi_drv = to_fsi_drv(drv); 1352 const struct fsi_device_id *id; 1353 1354 if (!fsi_drv->id_table) 1355 return 0; 1356 1357 for (id = fsi_drv->id_table; id->engine_type; id++) { 1358 if (id->engine_type != fsi_dev->engine_type) 1359 continue; 1360 if (id->version == FSI_VERSION_ANY || 1361 id->version == fsi_dev->version) 1362 return 1; 1363 } 1364 1365 return 0; 1366 } 1367 1368 int fsi_driver_register(struct fsi_driver *fsi_drv) 1369 { 1370 if (!fsi_drv) 1371 return -EINVAL; 1372 if (!fsi_drv->id_table) 1373 return -EINVAL; 1374 1375 return driver_register(&fsi_drv->drv); 1376 } 1377 EXPORT_SYMBOL_GPL(fsi_driver_register); 1378 1379 void fsi_driver_unregister(struct fsi_driver *fsi_drv) 1380 { 1381 driver_unregister(&fsi_drv->drv); 1382 } 1383 EXPORT_SYMBOL_GPL(fsi_driver_unregister); 1384 1385 struct bus_type fsi_bus_type = { 1386 .name = "fsi", 1387 .match = fsi_bus_match, 1388 }; 1389 EXPORT_SYMBOL_GPL(fsi_bus_type); 1390 1391 static int __init fsi_init(void) 1392 { 1393 int rc; 1394 1395 rc = alloc_chrdev_region(&fsi_base_dev, 0, FSI_CHAR_MAX_DEVICES, "fsi"); 1396 if (rc) 1397 return rc; 1398 rc = bus_register(&fsi_bus_type); 1399 if (rc) 1400 goto fail_bus; 1401 1402 rc = class_register(&fsi_master_class); 1403 if (rc) 1404 goto fail_class; 1405 1406 return 0; 1407 1408 fail_class: 1409 bus_unregister(&fsi_bus_type); 1410 fail_bus: 1411 unregister_chrdev_region(fsi_base_dev, FSI_CHAR_MAX_DEVICES); 1412 return rc; 1413 } 1414 postcore_initcall(fsi_init); 1415 1416 static void fsi_exit(void) 1417 { 1418 class_unregister(&fsi_master_class); 1419 bus_unregister(&fsi_bus_type); 1420 unregister_chrdev_region(fsi_base_dev, FSI_CHAR_MAX_DEVICES); 1421 ida_destroy(&fsi_minor_ida); 1422 } 1423 module_exit(fsi_exit); 1424 module_param(discard_errors, int, 0664); 1425 MODULE_LICENSE("GPL"); 1426 MODULE_PARM_DESC(discard_errors, "Don't invoke error handling on bus accesses"); 1427