drivers/fsi/fsi-core.c

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