drivers/fsi/fsi-core.c

   1 /*
   2  * FSI core driver
   3  *
   4  * Copyright (C) IBM Corporation 2016
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * TODO:
  16  *  - Rework topology
  17  *  - s/chip_id/chip_loc
  18  *  - s/cfam/chip (cfam_id -> chip_id etc...)
  19  */
  20
  21 #include <linux/crc4.h>
  22 #include <linux/device.h>
  23 #include <linux/fsi.h>
  24 #include <linux/idr.h>
  25 #include <linux/module.h>
  26 #include <linux/of.h>
  27 #include <linux/slab.h>
  28 #include <linux/bitops.h>
  29 #include <linux/cdev.h>
  30 #include <linux/fs.h>
  31 #include <linux/uaccess.h>
  32
  33 #include "fsi-master.h"
  34
  35 #define CREATE_TRACE_POINTS
  36 #include <trace/events/fsi.h>
  37
  38 #define FSI_SLAVE_CONF_NEXT_MASK        GENMASK(31, 31)
  39 #define FSI_SLAVE_CONF_SLOTS_MASK       GENMASK(23, 16)
  40 #define FSI_SLAVE_CONF_SLOTS_SHIFT      16
  41 #define FSI_SLAVE_CONF_VERSION_MASK     GENMASK(15, 12)
  42 #define FSI_SLAVE_CONF_VERSION_SHIFT    12
  43 #define FSI_SLAVE_CONF_TYPE_MASK        GENMASK(11, 4)
  44 #define FSI_SLAVE_CONF_TYPE_SHIFT       4
  45 #define FSI_SLAVE_CONF_CRC_SHIFT        4
  46 #define FSI_SLAVE_CONF_CRC_MASK         GENMASK(3, 0)
  47 #define FSI_SLAVE_CONF_DATA_BITS        28
  48
  49 #define FSI_PEEK_BASE                   0x410
  50
  51 static const int engine_page_size = 0x400;
  52
  53 #define FSI_SLAVE_BASE                  0x800
  54
  55 /*
  56  * FSI slave engine control register offsets
  57  */
  58 #define FSI_SMODE               0x0     /* R/W: Mode register */
  59 #define FSI_SISC                0x8     /* R/W: Interrupt condition */
  60 #define FSI_SSTAT               0x14    /* R  : Slave status */
  61 #define FSI_LLMODE              0x100   /* R/W: Link layer mode register */
  62
  63 /*
  64  * SMODE fields
  65  */
  66 #define FSI_SMODE_WSC           0x80000000      /* Warm start done */
  67 #define FSI_SMODE_ECRC          0x20000000      /* Hw CRC check */
  68 #define FSI_SMODE_SID_SHIFT     24              /* ID shift */
  69 #define FSI_SMODE_SID_MASK      3               /* ID Mask */
  70 #define FSI_SMODE_ED_SHIFT      20              /* Echo delay shift */
  71 #define FSI_SMODE_ED_MASK       0xf             /* Echo delay mask */
  72 #define FSI_SMODE_SD_SHIFT      16              /* Send delay shift */
  73 #define FSI_SMODE_SD_MASK       0xf             /* Send delay mask */
  74 #define FSI_SMODE_LBCRR_SHIFT   8               /* Clk ratio shift */
  75 #define FSI_SMODE_LBCRR_MASK    0xf             /* Clk ratio mask */
  76
  77 /*
  78  * LLMODE fields
  79  */
  80 #define FSI_LLMODE_ASYNC        0x1
  81
  82 #define FSI_SLAVE_SIZE_23b              0x800000
  83
  84 static DEFINE_IDA(master_ida);
  85
  86 struct fsi_slave {
  87         struct device           dev;
  88         struct fsi_master       *master;
  89         struct cdev             cdev;
  90         int                     cdev_idx;
  91         int                     id;     /* FSI address */
  92         int                     link;   /* FSI link# */
  93         u32                     cfam_id;
  94         int                     chip_id;
  95         uint32_t                size;   /* size of slave address space */
  96         u8                      t_send_delay;
  97         u8                      t_echo_delay;
  98 };
  99
 100 #define to_fsi_master(d) container_of(d, struct fsi_master, dev)
 101 #define to_fsi_slave(d) container_of(d, struct fsi_slave, dev)
 102
 103 static const int slave_retries = 2;
 104 static int discard_errors;
 105
 106 static dev_t fsi_base_dev;
 107 static DEFINE_IDA(fsi_minor_ida);
 108 #define FSI_CHAR_MAX_DEVICES    0x1000
 109
 110 /* Legacy /dev numbering: 4 devices per chip, 16 chips */
 111 #define FSI_CHAR_LEGACY_TOP     64
 112
 113 static int fsi_master_read(struct fsi_master *master, int link,
 114                 uint8_t slave_id, uint32_t addr, void *val, size_t size);
 115 static int fsi_master_write(struct fsi_master *master, int link,
 116                 uint8_t slave_id, uint32_t addr, const void *val, size_t size);
 117 static int fsi_master_break(struct fsi_master *master, int link);
 118
 119 /*
 120  * fsi_device_read() / fsi_device_write() / fsi_device_peek()
 121  *
 122  * FSI endpoint-device support
 123  *
 124  * Read / write / peek accessors for a client
 125  *
 126  * Parameters:
 127  * dev:  Structure passed to FSI client device drivers on probe().
 128  * addr: FSI address of given device.  Client should pass in its base address
 129  *       plus desired offset to access its register space.
 130  * val:  For read/peek this is the value read at the specified address. For
 131  *       write this is value to write to the specified address.
 132  *       The data in val must be FSI bus endian (big endian).
 133  * size: Size in bytes of the operation.  Sizes supported are 1, 2 and 4 bytes.
 134  *       Addresses must be aligned on size boundaries or an error will result.
 135  */
 136 int fsi_device_read(struct fsi_device *dev, uint32_t addr, void *val,
 137                 size_t size)
 138 {
 139         if (addr > dev->size || size > dev->size || addr > dev->size - size)
 140                 return -EINVAL;
 141
 142         return fsi_slave_read(dev->slave, dev->addr + addr, val, size);
 143 }
 144 EXPORT_SYMBOL_GPL(fsi_device_read);
 145
 146 int fsi_device_write(struct fsi_device *dev, uint32_t addr, const void *val,
 147                 size_t size)
 148 {
 149         if (addr > dev->size || size > dev->size || addr > dev->size - size)
 150                 return -EINVAL;
 151
 152         return fsi_slave_write(dev->slave, dev->addr + addr, val, size);
 153 }
 154 EXPORT_SYMBOL_GPL(fsi_device_write);
 155
 156 int fsi_device_peek(struct fsi_device *dev, void *val)
 157 {
 158         uint32_t addr = FSI_PEEK_BASE + ((dev->unit - 2) * sizeof(uint32_t));
 159
 160         return fsi_slave_read(dev->slave, addr, val, sizeof(uint32_t));
 161 }
 162
 163 static void fsi_device_release(struct device *_device)
 164 {
 165         struct fsi_device *device = to_fsi_dev(_device);
 166
 167         of_node_put(device->dev.of_node);
 168         kfree(device);
 169 }
 170
 171 static struct fsi_device *fsi_create_device(struct fsi_slave *slave)
 172 {
 173         struct fsi_device *dev;
 174
 175         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
 176         if (!dev)
 177                 return NULL;
 178
 179         dev->dev.parent = &slave->dev;
 180         dev->dev.bus = &fsi_bus_type;
 181         dev->dev.release = fsi_device_release;
 182
 183         return dev;
 184 }
 185
 186 /* FSI slave support */
 187 static int fsi_slave_calc_addr(struct fsi_slave *slave, uint32_t *addrp,
 188                 uint8_t *idp)
 189 {
 190         uint32_t addr = *addrp;
 191         uint8_t id = *idp;
 192
 193         if (addr > slave->size)
 194                 return -EINVAL;
 195
 196         /* For 23 bit addressing, we encode the extra two bits in the slave
 197          * id (and the slave's actual ID needs to be 0).
 198          */
 199         if (addr > 0x1fffff) {
 200                 if (slave->id != 0)
 201                         return -EINVAL;
 202                 id = (addr >> 21) & 0x3;
 203                 addr &= 0x1fffff;
 204         }
 205
 206         *addrp = addr;
 207         *idp = id;
 208         return 0;
 209 }
 210
 211 static int fsi_slave_report_and_clear_errors(struct fsi_slave *slave)
 212 {
 213         struct fsi_master *master = slave->master;
 214         __be32 irq, stat;
 215         int rc, link;
 216         uint8_t id;
 217
 218         link = slave->link;
 219         id = slave->id;
 220
 221         rc = fsi_master_read(master, link, id, FSI_SLAVE_BASE + FSI_SISC,
 222                         &irq, sizeof(irq));
 223         if (rc)
 224                 return rc;
 225
 226         rc =  fsi_master_read(master, link, id, FSI_SLAVE_BASE + FSI_SSTAT,
 227                         &stat, sizeof(stat));
 228         if (rc)
 229                 return rc;
 230
 231         dev_dbg(&slave->dev, "status: 0x%08x, sisc: 0x%08x\n",
 232                         be32_to_cpu(stat), be32_to_cpu(irq));
 233
 234         /* clear interrupts */
 235         return fsi_master_write(master, link, id, FSI_SLAVE_BASE + FSI_SISC,
 236                         &irq, sizeof(irq));
 237 }
 238
 239 /* Encode slave local bus echo delay */
 240 static inline uint32_t fsi_smode_echodly(int x)
 241 {
 242         return (x & FSI_SMODE_ED_MASK) << FSI_SMODE_ED_SHIFT;
 243 }
 244
 245 /* Encode slave local bus send delay */
 246 static inline uint32_t fsi_smode_senddly(int x)
 247 {
 248         return (x & FSI_SMODE_SD_MASK) << FSI_SMODE_SD_SHIFT;
 249 }
 250
 251 /* Encode slave local bus clock rate ratio */
 252 static inline uint32_t fsi_smode_lbcrr(int x)
 253 {
 254         return (x & FSI_SMODE_LBCRR_MASK) << FSI_SMODE_LBCRR_SHIFT;
 255 }
 256
 257 /* Encode slave ID */
 258 static inline uint32_t fsi_smode_sid(int x)
 259 {
 260         return (x & FSI_SMODE_SID_MASK) << FSI_SMODE_SID_SHIFT;
 261 }
 262
 263 static uint32_t fsi_slave_smode(int id, u8 t_senddly, u8 t_echodly)
 264 {
 265         return FSI_SMODE_WSC | FSI_SMODE_ECRC
 266                 | fsi_smode_sid(id)
 267                 | fsi_smode_echodly(t_echodly - 1) | fsi_smode_senddly(t_senddly - 1)
 268                 | fsi_smode_lbcrr(0x8);
 269 }
 270
 271 static int fsi_slave_set_smode(struct fsi_slave *slave)
 272 {
 273         uint32_t smode;
 274         __be32 data;
 275
 276         /* set our smode register with the slave ID field to 0; this enables
 277          * extended slave addressing
 278          */
 279         smode = fsi_slave_smode(slave->id, slave->t_send_delay, slave->t_echo_delay);
 280         data = cpu_to_be32(smode);
 281
 282         return fsi_master_write(slave->master, slave->link, slave->id,
 283                                 FSI_SLAVE_BASE + FSI_SMODE,
 284                                 &data, sizeof(data));
 285 }
 286
 287 static int fsi_slave_handle_error(struct fsi_slave *slave, bool write,
 288                                   uint32_t addr, size_t size)
 289 {
 290         struct fsi_master *master = slave->master;
 291         int rc, link;
 292         uint32_t reg;
 293         uint8_t id, send_delay, echo_delay;
 294
 295         if (discard_errors)
 296                 return -1;
 297
 298         link = slave->link;
 299         id = slave->id;
 300
 301         dev_dbg(&slave->dev, "handling error on %s to 0x%08x[%zd]",
 302                         write ? "write" : "read", addr, size);
 303
 304         /* try a simple clear of error conditions, which may fail if we've lost
 305          * communication with the slave
 306          */
 307         rc = fsi_slave_report_and_clear_errors(slave);
 308         if (!rc)
 309                 return 0;
 310
 311         /* send a TERM and retry */
 312         if (master->term) {
 313                 rc = master->term(master, link, id);
 314                 if (!rc) {
 315                         rc = fsi_master_read(master, link, id, 0,
 316                                         &reg, sizeof(reg));
 317                         if (!rc)
 318                                 rc = fsi_slave_report_and_clear_errors(slave);
 319                         if (!rc)
 320                                 return 0;
 321                 }
 322         }
 323
 324         send_delay = slave->t_send_delay;
 325         echo_delay = slave->t_echo_delay;
 326
 327         /* getting serious, reset the slave via BREAK */
 328         rc = fsi_master_break(master, link);
 329         if (rc)
 330                 return rc;
 331
 332         slave->t_send_delay = send_delay;
 333         slave->t_echo_delay = echo_delay;
 334
 335         rc = fsi_slave_set_smode(slave);
 336         if (rc)
 337                 return rc;
 338
 339         if (master->link_config)
 340                 master->link_config(master, link,
 341                                     slave->t_send_delay,
 342                                     slave->t_echo_delay);
 343
 344         return fsi_slave_report_and_clear_errors(slave);
 345 }
 346
 347 int fsi_slave_read(struct fsi_slave *slave, uint32_t addr,
 348                         void *val, size_t size)
 349 {
 350         uint8_t id = slave->id;
 351         int rc, err_rc, i;
 352
 353         rc = fsi_slave_calc_addr(slave, &addr, &id);
 354         if (rc)
 355                 return rc;
 356
 357         for (i = 0; i < slave_retries; i++) {
 358                 rc = fsi_master_read(slave->master, slave->link,
 359                                 id, addr, val, size);
 360                 if (!rc)
 361                         break;
 362
 363                 err_rc = fsi_slave_handle_error(slave, false, addr, size);
 364                 if (err_rc)
 365                         break;
 366         }
 367
 368         return rc;
 369 }
 370 EXPORT_SYMBOL_GPL(fsi_slave_read);
 371
 372 int fsi_slave_write(struct fsi_slave *slave, uint32_t addr,
 373                         const void *val, size_t size)
 374 {
 375         uint8_t id = slave->id;
 376         int rc, err_rc, i;
 377
 378         rc = fsi_slave_calc_addr(slave, &addr, &id);
 379         if (rc)
 380                 return rc;
 381
 382         for (i = 0; i < slave_retries; i++) {
 383                 rc = fsi_master_write(slave->master, slave->link,
 384                                 id, addr, val, size);
 385                 if (!rc)
 386                         break;
 387
 388                 err_rc = fsi_slave_handle_error(slave, true, addr, size);
 389                 if (err_rc)
 390                         break;
 391         }
 392
 393         return rc;
 394 }
 395 EXPORT_SYMBOL_GPL(fsi_slave_write);
 396
 397 extern int fsi_slave_claim_range(struct fsi_slave *slave,
 398                 uint32_t addr, uint32_t size)
 399 {
 400         if (addr + size < addr)
 401                 return -EINVAL;
 402
 403         if (addr + size > slave->size)
 404                 return -EINVAL;
 405
 406         /* todo: check for overlapping claims */
 407         return 0;
 408 }
 409 EXPORT_SYMBOL_GPL(fsi_slave_claim_range);
 410
 411 extern void fsi_slave_release_range(struct fsi_slave *slave,
 412                 uint32_t addr, uint32_t size)
 413 {
 414 }
 415 EXPORT_SYMBOL_GPL(fsi_slave_release_range);
 416
 417 static bool fsi_device_node_matches(struct device *dev, struct device_node *np,
 418                 uint32_t addr, uint32_t size)
 419 {
 420         unsigned int len, na, ns;
 421         const __be32 *prop;
 422         uint32_t psize;
 423
 424         na = of_n_addr_cells(np);
 425         ns = of_n_size_cells(np);
 426
 427         if (na != 1 || ns != 1)
 428                 return false;
 429
 430         prop = of_get_property(np, "reg", &len);
 431         if (!prop || len != 8)
 432                 return false;
 433
 434         if (of_read_number(prop, 1) != addr)
 435                 return false;
 436
 437         psize = of_read_number(prop + 1, 1);
 438         if (psize != size) {
 439                 dev_warn(dev,
 440                         "node %s matches probed address, but not size (got 0x%x, expected 0x%x)",
 441                         of_node_full_name(np), psize, size);
 442         }
 443
 444         return true;
 445 }
 446
 447 /* Find a matching node for the slave engine at @address, using @size bytes
 448  * of space. Returns NULL if not found, or a matching node with refcount
 449  * already incremented.
 450  */
 451 static struct device_node *fsi_device_find_of_node(struct fsi_device *dev)
 452 {
 453         struct device_node *parent, *np;
 454
 455         parent = dev_of_node(&dev->slave->dev);
 456         if (!parent)
 457                 return NULL;
 458
 459         for_each_child_of_node(parent, np) {
 460                 if (fsi_device_node_matches(&dev->dev, np,
 461                                         dev->addr, dev->size))
 462                         return np;
 463         }
 464
 465         return NULL;
 466 }
 467
 468 static int fsi_slave_scan(struct fsi_slave *slave)
 469 {
 470         uint32_t engine_addr;
 471         int rc, i;
 472
 473         /*
 474          * scan engines
 475          *
 476          * We keep the peek mode and slave engines for the core; so start
 477          * at the third slot in the configuration table. We also need to
 478          * skip the chip ID entry at the start of the address space.
 479          */
 480         engine_addr = engine_page_size * 3;
 481         for (i = 2; i < engine_page_size / sizeof(uint32_t); i++) {
 482                 uint8_t slots, version, type, crc;
 483                 struct fsi_device *dev;
 484                 uint32_t conf;
 485                 __be32 data;
 486
 487                 rc = fsi_slave_read(slave, (i + 1) * sizeof(data),
 488                                 &data, sizeof(data));
 489                 if (rc) {
 490                         dev_warn(&slave->dev,
 491                                 "error reading slave registers\n");
 492                         return -1;
 493                 }
 494                 conf = be32_to_cpu(data);
 495
 496                 crc = crc4(0, conf, 32);
 497                 if (crc) {
 498                         dev_warn(&slave->dev,
 499                                 "crc error in slave register at 0x%04x\n",
 500                                 i);
 501                         return -1;
 502                 }
 503
 504                 slots = (conf & FSI_SLAVE_CONF_SLOTS_MASK)
 505                         >> FSI_SLAVE_CONF_SLOTS_SHIFT;
 506                 version = (conf & FSI_SLAVE_CONF_VERSION_MASK)
 507                         >> FSI_SLAVE_CONF_VERSION_SHIFT;
 508                 type = (conf & FSI_SLAVE_CONF_TYPE_MASK)
 509                         >> FSI_SLAVE_CONF_TYPE_SHIFT;
 510
 511                 /*
 512                  * Unused address areas are marked by a zero type value; this
 513                  * skips the defined address areas
 514                  */
 515                 if (type != 0 && slots != 0) {
 516
 517                         /* create device */
 518                         dev = fsi_create_device(slave);
 519                         if (!dev)
 520                                 return -ENOMEM;
 521
 522                         dev->slave = slave;
 523                         dev->engine_type = type;
 524                         dev->version = version;
 525                         dev->unit = i;
 526                         dev->addr = engine_addr;
 527                         dev->size = slots * engine_page_size;
 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;
 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                 dev_warn(&master->dev, "slave %02x:%02x invalid cfam id CRC!\n",
1012                                 link, id);
1013                 return -EIO;
1014         }
1015
1016         dev_dbg(&master->dev, "fsi: found chip %08x at %02x:%02x:%02x\n",
1017                         cfam_id, master->idx, link, id);
1018
1019         /* If we're behind a master that doesn't provide a self-running bus
1020          * clock, put the slave into async mode
1021          */
1022         if (master->flags & FSI_MASTER_FLAG_SWCLOCK) {
1023                 llmode = cpu_to_be32(FSI_LLMODE_ASYNC);
1024                 rc = fsi_master_write(master, link, id,
1025                                 FSI_SLAVE_BASE + FSI_LLMODE,
1026                                 &llmode, sizeof(llmode));
1027                 if (rc)
1028                         dev_warn(&master->dev,
1029                                 "can't set llmode on slave:%02x:%02x %d\n",
1030                                 link, id, rc);
1031         }
1032
1033         /* We can communicate with a slave; create the slave device and
1034          * register.
1035          */
1036         slave = kzalloc(sizeof(*slave), GFP_KERNEL);
1037         if (!slave)
1038                 return -ENOMEM;
1039
1040         dev_set_name(&slave->dev, "slave@%02x:%02x", link, id);
1041         slave->dev.type = &cfam_type;
1042         slave->dev.parent = &master->dev;
1043         slave->dev.of_node = fsi_slave_find_of_node(master, link, id);
1044         slave->dev.release = fsi_slave_release;
1045         device_initialize(&slave->dev);
1046         slave->cfam_id = cfam_id;
1047         slave->master = master;
1048         slave->link = link;
1049         slave->id = id;
1050         slave->size = FSI_SLAVE_SIZE_23b;
1051         slave->t_send_delay = 16;
1052         slave->t_echo_delay = 16;
1053
1054         /* Get chip ID if any */
1055         slave->chip_id = -1;
1056         if (slave->dev.of_node) {
1057                 uint32_t prop;
1058                 if (!of_property_read_u32(slave->dev.of_node, "chip-id", &prop))
1059                         slave->chip_id = prop;
1060
1061         }
1062
1063         rc = fsi_slave_set_smode(slave);
1064         if (rc) {
1065                 dev_warn(&master->dev,
1066                                 "can't set smode on slave:%02x:%02x %d\n",
1067                                 link, id, rc);
1068                 goto err_free;
1069         }
1070
1071         /* Allocate a minor in the FSI space */
1072         rc = __fsi_get_new_minor(slave, fsi_dev_cfam, &slave->dev.devt,
1073                                  &slave->cdev_idx);
1074         if (rc)
1075                 goto err_free;
1076
1077         /* Create chardev for userspace access */
1078         cdev_init(&slave->cdev, &cfam_fops);
1079         rc = cdev_device_add(&slave->cdev, &slave->dev);
1080         if (rc) {
1081                 dev_err(&slave->dev, "Error %d creating slave device\n", rc);
1082                 goto err_free_ida;
1083         }
1084
1085         /* Now that we have the cdev registered with the core, any fatal
1086          * failures beyond this point will need to clean up through
1087          * cdev_device_del(). Fortunately though, nothing past here is fatal.
1088          */
1089
1090         if (master->link_config)
1091                 master->link_config(master, link,
1092                                     slave->t_send_delay,
1093                                     slave->t_echo_delay);
1094
1095         /* Legacy raw file -> to be removed */
1096         rc = device_create_bin_file(&slave->dev, &fsi_slave_raw_attr);
1097         if (rc)
1098                 dev_warn(&slave->dev, "failed to create raw attr: %d\n", rc);
1099
1100
1101         rc = fsi_slave_scan(slave);
1102         if (rc)
1103                 dev_dbg(&master->dev, "failed during slave scan with: %d\n",
1104                                 rc);
1105
1106         return 0;
1107
1108 err_free_ida:
1109         fsi_free_minor(slave->dev.devt);
1110 err_free:
1111         of_node_put(slave->dev.of_node);
1112         kfree(slave);
1113         return rc;
1114 }
1115
1116 /* FSI master support */
1117 static int fsi_check_access(uint32_t addr, size_t size)
1118 {
1119         if (size == 4) {
1120                 if (addr & 0x3)
1121                         return -EINVAL;
1122         } else if (size == 2) {
1123                 if (addr & 0x1)
1124                         return -EINVAL;
1125         } else if (size != 1)
1126                 return -EINVAL;
1127
1128         return 0;
1129 }
1130
1131 static int fsi_master_read(struct fsi_master *master, int link,
1132                 uint8_t slave_id, uint32_t addr, void *val, size_t size)
1133 {
1134         int rc;
1135
1136         trace_fsi_master_read(master, link, slave_id, addr, size);
1137
1138         rc = fsi_check_access(addr, size);
1139         if (!rc)
1140                 rc = master->read(master, link, slave_id, addr, val, size);
1141
1142         trace_fsi_master_rw_result(master, link, slave_id, addr, size,
1143                         false, val, rc);
1144
1145         return rc;
1146 }
1147
1148 static int fsi_master_write(struct fsi_master *master, int link,
1149                 uint8_t slave_id, uint32_t addr, const void *val, size_t size)
1150 {
1151         int rc;
1152
1153         trace_fsi_master_write(master, link, slave_id, addr, size, val);
1154
1155         rc = fsi_check_access(addr, size);
1156         if (!rc)
1157                 rc = master->write(master, link, slave_id, addr, val, size);
1158
1159         trace_fsi_master_rw_result(master, link, slave_id, addr, size,
1160                         true, val, rc);
1161
1162         return rc;
1163 }
1164
1165 static int fsi_master_link_enable(struct fsi_master *master, int link)
1166 {
1167         if (master->link_enable)
1168                 return master->link_enable(master, link);
1169
1170         return 0;
1171 }
1172
1173 /*
1174  * Issue a break command on this link
1175  */
1176 static int fsi_master_break(struct fsi_master *master, int link)
1177 {
1178         int rc = 0;
1179
1180         trace_fsi_master_break(master, link);
1181
1182         if (master->send_break)
1183                 rc = master->send_break(master, link);
1184         if (master->link_config)
1185                 master->link_config(master, link, 16, 16);
1186
1187         return rc;
1188 }
1189
1190 static int fsi_master_scan(struct fsi_master *master)
1191 {
1192         int link, rc;
1193
1194         for (link = 0; link < master->n_links; link++) {
1195                 rc = fsi_master_link_enable(master, link);
1196                 if (rc) {
1197                         dev_dbg(&master->dev,
1198                                 "enable link %d failed: %d\n", link, rc);
1199                         continue;
1200                 }
1201                 rc = fsi_master_break(master, link);
1202                 if (rc) {
1203                         dev_dbg(&master->dev,
1204                                 "break to link %d failed: %d\n", link, rc);
1205                         continue;
1206                 }
1207
1208                 fsi_slave_init(master, link, 0);
1209         }
1210
1211         return 0;
1212 }
1213
1214 static int fsi_slave_remove_device(struct device *dev, void *arg)
1215 {
1216         device_unregister(dev);
1217         return 0;
1218 }
1219
1220 static int fsi_master_remove_slave(struct device *dev, void *arg)
1221 {
1222         struct fsi_slave *slave = to_fsi_slave(dev);
1223
1224         device_for_each_child(dev, NULL, fsi_slave_remove_device);
1225         cdev_device_del(&slave->cdev, &slave->dev);
1226         put_device(dev);
1227         return 0;
1228 }
1229
1230 static void fsi_master_unscan(struct fsi_master *master)
1231 {
1232         device_for_each_child(&master->dev, NULL, fsi_master_remove_slave);
1233 }
1234
1235 int fsi_master_rescan(struct fsi_master *master)
1236 {
1237         int rc;
1238
1239         mutex_lock(&master->scan_lock);
1240         fsi_master_unscan(master);
1241         rc = fsi_master_scan(master);
1242         mutex_unlock(&master->scan_lock);
1243
1244         return rc;
1245 }
1246 EXPORT_SYMBOL_GPL(fsi_master_rescan);
1247
1248 static ssize_t master_rescan_store(struct device *dev,
1249                 struct device_attribute *attr, const char *buf, size_t count)
1250 {
1251         struct fsi_master *master = to_fsi_master(dev);
1252         int rc;
1253
1254         rc = fsi_master_rescan(master);
1255         if (rc < 0)
1256                 return rc;
1257
1258         return count;
1259 }
1260
1261 static DEVICE_ATTR(rescan, 0200, NULL, master_rescan_store);
1262
1263 static ssize_t master_break_store(struct device *dev,
1264                 struct device_attribute *attr, const char *buf, size_t count)
1265 {
1266         struct fsi_master *master = to_fsi_master(dev);
1267
1268         fsi_master_break(master, 0);
1269
1270         return count;
1271 }
1272
1273 static DEVICE_ATTR(break, 0200, NULL, master_break_store);
1274
1275 int fsi_master_register(struct fsi_master *master)
1276 {
1277         int rc;
1278         struct device_node *np;
1279
1280         mutex_init(&master->scan_lock);
1281         master->idx = ida_simple_get(&master_ida, 0, INT_MAX, GFP_KERNEL);
1282         if (master->idx < 0)
1283                 return master->idx;
1284
1285         dev_set_name(&master->dev, "fsi%d", master->idx);
1286
1287         rc = device_register(&master->dev);
1288         if (rc) {
1289                 ida_simple_remove(&master_ida, master->idx);
1290                 return rc;
1291         }
1292
1293         rc = device_create_file(&master->dev, &dev_attr_rescan);
1294         if (rc) {
1295                 device_del(&master->dev);
1296                 ida_simple_remove(&master_ida, master->idx);
1297                 return rc;
1298         }
1299
1300         rc = device_create_file(&master->dev, &dev_attr_break);
1301         if (rc) {
1302                 device_del(&master->dev);
1303                 ida_simple_remove(&master_ida, master->idx);
1304                 return rc;
1305         }
1306
1307         np = dev_of_node(&master->dev);
1308         if (!of_property_read_bool(np, "no-scan-on-init")) {
1309                 mutex_lock(&master->scan_lock);
1310                 fsi_master_scan(master);
1311                 mutex_unlock(&master->scan_lock);
1312         }
1313
1314         return 0;
1315 }
1316 EXPORT_SYMBOL_GPL(fsi_master_register);
1317
1318 void fsi_master_unregister(struct fsi_master *master)
1319 {
1320         if (master->idx >= 0) {
1321                 ida_simple_remove(&master_ida, master->idx);
1322                 master->idx = -1;
1323         }
1324
1325         mutex_lock(&master->scan_lock);
1326         fsi_master_unscan(master);
1327         mutex_unlock(&master->scan_lock);
1328         device_unregister(&master->dev);
1329 }
1330 EXPORT_SYMBOL_GPL(fsi_master_unregister);
1331
1332 /* FSI core & Linux bus type definitions */
1333
1334 static int fsi_bus_match(struct device *dev, struct device_driver *drv)
1335 {
1336         struct fsi_device *fsi_dev = to_fsi_dev(dev);
1337         struct fsi_driver *fsi_drv = to_fsi_drv(drv);
1338         const struct fsi_device_id *id;
1339
1340         if (!fsi_drv->id_table)
1341                 return 0;
1342
1343         for (id = fsi_drv->id_table; id->engine_type; id++) {
1344                 if (id->engine_type != fsi_dev->engine_type)
1345                         continue;
1346                 if (id->version == FSI_VERSION_ANY ||
1347                                 id->version == fsi_dev->version)
1348                         return 1;
1349         }
1350
1351         return 0;
1352 }
1353
1354 int fsi_driver_register(struct fsi_driver *fsi_drv)
1355 {
1356         if (!fsi_drv)
1357                 return -EINVAL;
1358         if (!fsi_drv->id_table)
1359                 return -EINVAL;
1360
1361         return driver_register(&fsi_drv->drv);
1362 }
1363 EXPORT_SYMBOL_GPL(fsi_driver_register);
1364
1365 void fsi_driver_unregister(struct fsi_driver *fsi_drv)
1366 {
1367         driver_unregister(&fsi_drv->drv);
1368 }
1369 EXPORT_SYMBOL_GPL(fsi_driver_unregister);
1370
1371 struct bus_type fsi_bus_type = {
1372         .name           = "fsi",
1373         .match          = fsi_bus_match,
1374 };
1375 EXPORT_SYMBOL_GPL(fsi_bus_type);
1376
1377 static int __init fsi_init(void)
1378 {
1379         int rc;
1380
1381         rc = alloc_chrdev_region(&fsi_base_dev, 0, FSI_CHAR_MAX_DEVICES, "fsi");
1382         if (rc)
1383                 return rc;
1384         rc = bus_register(&fsi_bus_type);
1385         if (rc)
1386                 goto fail_bus;
1387         return 0;
1388
1389  fail_bus:
1390         unregister_chrdev_region(fsi_base_dev, FSI_CHAR_MAX_DEVICES);
1391         return rc;
1392 }
1393 postcore_initcall(fsi_init);
1394
1395 static void fsi_exit(void)
1396 {
1397         bus_unregister(&fsi_bus_type);
1398         unregister_chrdev_region(fsi_base_dev, FSI_CHAR_MAX_DEVICES);
1399         ida_destroy(&fsi_minor_ida);
1400 }
1401 module_exit(fsi_exit);
1402 module_param(discard_errors, int, 0664);
1403 MODULE_LICENSE("GPL");
1404 MODULE_PARM_DESC(discard_errors, "Don't invoke error handling on bus accesses");