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