drivers/bus/moxtet.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Turris Mox module configuration bus driver
   4  *
   5  * Copyright (C) 2019 Marek Behun <marek.behun@nic.cz>
   6  */
   7
   8 #include <dt-bindings/bus/moxtet.h>
   9 #include <linux/bitops.h>
  10 #include <linux/debugfs.h>
  11 #include <linux/interrupt.h>
  12 #include <linux/module.h>
  13 #include <linux/moxtet.h>
  14 #include <linux/mutex.h>
  15 #include <linux/of_device.h>
  16 #include <linux/of_irq.h>
  17 #include <linux/spi/spi.h>
  18
  19 /*
  20  * @name:       module name for sysfs
  21  * @hwirq_base: base index for IRQ for this module (-1 if no IRQs)
  22  * @nirqs:      how many interrupts does the shift register provide
  23  * @desc:       module description for kernel log
  24  */
  25 static const struct {
  26         const char *name;
  27         int hwirq_base;
  28         int nirqs;
  29         const char *desc;
  30 } mox_module_table[] = {
  31         /* do not change order of this array! */
  32         { NULL,          0,                     0, NULL },
  33         { "sfp",        -1,                     0, "MOX D (SFP cage)" },
  34         { "pci",        MOXTET_IRQ_PCI,         1, "MOX B (Mini-PCIe)" },
  35         { "topaz",      MOXTET_IRQ_TOPAZ,       1, "MOX C (4 port switch)" },
  36         { "peridot",    MOXTET_IRQ_PERIDOT(0),  1, "MOX E (8 port switch)" },
  37         { "usb3",       MOXTET_IRQ_USB3,        2, "MOX F (USB 3.0)" },
  38         { "pci-bridge", -1,                     0, "MOX G (Mini-PCIe bridge)" },
  39 };
  40
  41 static inline bool mox_module_known(unsigned int id)
  42 {
  43         return id >= TURRIS_MOX_MODULE_FIRST && id <= TURRIS_MOX_MODULE_LAST;
  44 }
  45
  46 static inline const char *mox_module_name(unsigned int id)
  47 {
  48         if (mox_module_known(id))
  49                 return mox_module_table[id].name;
  50         else
  51                 return "unknown";
  52 }
  53
  54 #define DEF_MODULE_ATTR(name, fmt, ...)                                 \
  55 static ssize_t                                                          \
  56 module_##name##_show(struct device *dev, struct device_attribute *a,    \
  57                      char *buf)                                         \
  58 {                                                                       \
  59         struct moxtet_device *mdev = to_moxtet_device(dev);             \
  60         return sprintf(buf, (fmt), __VA_ARGS__);                        \
  61 }                                                                       \
  62 static DEVICE_ATTR_RO(module_##name)
  63
  64 DEF_MODULE_ATTR(id, "0x%x\n", mdev->id);
  65 DEF_MODULE_ATTR(name, "%s\n", mox_module_name(mdev->id));
  66 DEF_MODULE_ATTR(description, "%s\n",
  67                 mox_module_known(mdev->id) ? mox_module_table[mdev->id].desc
  68                                            : "");
  69
  70 static struct attribute *moxtet_dev_attrs[] = {
  71         &dev_attr_module_id.attr,
  72         &dev_attr_module_name.attr,
  73         &dev_attr_module_description.attr,
  74         NULL,
  75 };
  76
  77 static const struct attribute_group moxtet_dev_group = {
  78         .attrs = moxtet_dev_attrs,
  79 };
  80
  81 static const struct attribute_group *moxtet_dev_groups[] = {
  82         &moxtet_dev_group,
  83         NULL,
  84 };
  85
  86 static int moxtet_match(struct device *dev, struct device_driver *drv)
  87 {
  88         struct moxtet_device *mdev = to_moxtet_device(dev);
  89         struct moxtet_driver *tdrv = to_moxtet_driver(drv);
  90         const enum turris_mox_module_id *t;
  91
  92         if (of_driver_match_device(dev, drv))
  93                 return 1;
  94
  95         if (!tdrv->id_table)
  96                 return 0;
  97
  98         for (t = tdrv->id_table; *t; ++t)
  99                 if (*t == mdev->id)
 100                         return 1;
 101
 102         return 0;
 103 }
 104
 105 struct bus_type moxtet_bus_type = {
 106         .name           = "moxtet",
 107         .dev_groups     = moxtet_dev_groups,
 108         .match          = moxtet_match,
 109 };
 110 EXPORT_SYMBOL_GPL(moxtet_bus_type);
 111
 112 int __moxtet_register_driver(struct module *owner,
 113                              struct moxtet_driver *mdrv)
 114 {
 115         mdrv->driver.owner = owner;
 116         mdrv->driver.bus = &moxtet_bus_type;
 117         return driver_register(&mdrv->driver);
 118 }
 119 EXPORT_SYMBOL_GPL(__moxtet_register_driver);
 120
 121 static int moxtet_dev_check(struct device *dev, void *data)
 122 {
 123         struct moxtet_device *mdev = to_moxtet_device(dev);
 124         struct moxtet_device *new_dev = data;
 125
 126         if (mdev->moxtet == new_dev->moxtet && mdev->id == new_dev->id &&
 127             mdev->idx == new_dev->idx)
 128                 return -EBUSY;
 129         return 0;
 130 }
 131
 132 static void moxtet_dev_release(struct device *dev)
 133 {
 134         struct moxtet_device *mdev = to_moxtet_device(dev);
 135
 136         put_device(mdev->moxtet->dev);
 137         kfree(mdev);
 138 }
 139
 140 static struct moxtet_device *
 141 moxtet_alloc_device(struct moxtet *moxtet)
 142 {
 143         struct moxtet_device *dev;
 144
 145         if (!get_device(moxtet->dev))
 146                 return NULL;
 147
 148         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
 149         if (!dev) {
 150                 put_device(moxtet->dev);
 151                 return NULL;
 152         }
 153
 154         dev->moxtet = moxtet;
 155         dev->dev.parent = moxtet->dev;
 156         dev->dev.bus = &moxtet_bus_type;
 157         dev->dev.release = moxtet_dev_release;
 158
 159         device_initialize(&dev->dev);
 160
 161         return dev;
 162 }
 163
 164 static int moxtet_add_device(struct moxtet_device *dev)
 165 {
 166         static DEFINE_MUTEX(add_mutex);
 167         int ret;
 168
 169         if (dev->idx >= TURRIS_MOX_MAX_MODULES || dev->id > 0xf)
 170                 return -EINVAL;
 171
 172         dev_set_name(&dev->dev, "moxtet-%s.%u", mox_module_name(dev->id),
 173                      dev->idx);
 174
 175         mutex_lock(&add_mutex);
 176
 177         ret = bus_for_each_dev(&moxtet_bus_type, NULL, dev,
 178                                moxtet_dev_check);
 179         if (ret)
 180                 goto done;
 181
 182         ret = device_add(&dev->dev);
 183         if (ret < 0)
 184                 dev_err(dev->moxtet->dev, "can't add %s, status %d\n",
 185                         dev_name(dev->moxtet->dev), ret);
 186
 187 done:
 188         mutex_unlock(&add_mutex);
 189         return ret;
 190 }
 191
 192 static int __unregister(struct device *dev, void *null)
 193 {
 194         if (dev->of_node) {
 195                 of_node_clear_flag(dev->of_node, OF_POPULATED);
 196                 of_node_put(dev->of_node);
 197         }
 198
 199         device_unregister(dev);
 200
 201         return 0;
 202 }
 203
 204 static struct moxtet_device *
 205 of_register_moxtet_device(struct moxtet *moxtet, struct device_node *nc)
 206 {
 207         struct moxtet_device *dev;
 208         u32 val;
 209         int ret;
 210
 211         dev = moxtet_alloc_device(moxtet);
 212         if (!dev) {
 213                 dev_err(moxtet->dev,
 214                         "Moxtet device alloc error for %pOF\n", nc);
 215                 return ERR_PTR(-ENOMEM);
 216         }
 217
 218         ret = of_property_read_u32(nc, "reg", &val);
 219         if (ret) {
 220                 dev_err(moxtet->dev, "%pOF has no valid 'reg' property (%d)\n",
 221                         nc, ret);
 222                 goto err_put;
 223         }
 224
 225         dev->idx = val;
 226
 227         if (dev->idx >= TURRIS_MOX_MAX_MODULES) {
 228                 dev_err(moxtet->dev, "%pOF Moxtet address 0x%x out of range\n",
 229                         nc, dev->idx);
 230                 ret = -EINVAL;
 231                 goto err_put;
 232         }
 233
 234         dev->id = moxtet->modules[dev->idx];
 235
 236         if (!dev->id) {
 237                 dev_err(moxtet->dev, "%pOF Moxtet address 0x%x is empty\n", nc,
 238                         dev->idx);
 239                 ret = -ENODEV;
 240                 goto err_put;
 241         }
 242
 243         of_node_get(nc);
 244         dev->dev.of_node = nc;
 245
 246         ret = moxtet_add_device(dev);
 247         if (ret) {
 248                 dev_err(moxtet->dev,
 249                         "Moxtet device register error for %pOF\n", nc);
 250                 of_node_put(nc);
 251                 goto err_put;
 252         }
 253
 254         return dev;
 255
 256 err_put:
 257         put_device(&dev->dev);
 258         return ERR_PTR(ret);
 259 }
 260
 261 static void of_register_moxtet_devices(struct moxtet *moxtet)
 262 {
 263         struct moxtet_device *dev;
 264         struct device_node *nc;
 265
 266         if (!moxtet->dev->of_node)
 267                 return;
 268
 269         for_each_available_child_of_node(moxtet->dev->of_node, nc) {
 270                 if (of_node_test_and_set_flag(nc, OF_POPULATED))
 271                         continue;
 272                 dev = of_register_moxtet_device(moxtet, nc);
 273                 if (IS_ERR(dev)) {
 274                         dev_warn(moxtet->dev,
 275                                  "Failed to create Moxtet device for %pOF\n",
 276                                  nc);
 277                         of_node_clear_flag(nc, OF_POPULATED);
 278                 }
 279         }
 280 }
 281
 282 static void
 283 moxtet_register_devices_from_topology(struct moxtet *moxtet)
 284 {
 285         struct moxtet_device *dev;
 286         int i, ret;
 287
 288         for (i = 0; i < moxtet->count; ++i) {
 289                 dev = moxtet_alloc_device(moxtet);
 290                 if (!dev) {
 291                         dev_err(moxtet->dev, "Moxtet device %u alloc error\n",
 292                                 i);
 293                         continue;
 294                 }
 295
 296                 dev->idx = i;
 297                 dev->id = moxtet->modules[i];
 298
 299                 ret = moxtet_add_device(dev);
 300                 if (ret && ret != -EBUSY) {
 301                         put_device(&dev->dev);
 302                         dev_err(moxtet->dev,
 303                                 "Moxtet device %u register error: %i\n", i,
 304                                 ret);
 305                 }
 306         }
 307 }
 308
 309 /*
 310  * @nsame:      how many modules with same id are already in moxtet->modules
 311  */
 312 static int moxtet_set_irq(struct moxtet *moxtet, int idx, int id, int nsame)
 313 {
 314         int i, first;
 315         struct moxtet_irqpos *pos;
 316
 317         first = mox_module_table[id].hwirq_base +
 318                 nsame * mox_module_table[id].nirqs;
 319
 320         if (first + mox_module_table[id].nirqs > MOXTET_NIRQS)
 321                 return -EINVAL;
 322
 323         for (i = 0; i < mox_module_table[id].nirqs; ++i) {
 324                 pos = &moxtet->irq.position[first + i];
 325                 pos->idx = idx;
 326                 pos->bit = i;
 327                 moxtet->irq.exists |= BIT(first + i);
 328         }
 329
 330         return 0;
 331 }
 332
 333 static int moxtet_find_topology(struct moxtet *moxtet)
 334 {
 335         u8 buf[TURRIS_MOX_MAX_MODULES];
 336         int cnts[TURRIS_MOX_MODULE_LAST];
 337         int i, ret;
 338
 339         memset(cnts, 0, sizeof(cnts));
 340
 341         ret = spi_read(to_spi_device(moxtet->dev), buf, TURRIS_MOX_MAX_MODULES);
 342         if (ret < 0)
 343                 return ret;
 344
 345         if (buf[0] == TURRIS_MOX_CPU_ID_EMMC) {
 346                 dev_info(moxtet->dev, "Found MOX A (eMMC CPU) module\n");
 347         } else if (buf[0] == TURRIS_MOX_CPU_ID_SD) {
 348                 dev_info(moxtet->dev, "Found MOX A (CPU) module\n");
 349         } else {
 350                 dev_err(moxtet->dev, "Invalid Turris MOX A CPU module 0x%02x\n",
 351                         buf[0]);
 352                 return -ENODEV;
 353         }
 354
 355         moxtet->count = 0;
 356
 357         for (i = 1; i < TURRIS_MOX_MAX_MODULES; ++i) {
 358                 int id;
 359
 360                 if (buf[i] == 0xff)
 361                         break;
 362
 363                 id = buf[i] & 0xf;
 364
 365                 moxtet->modules[i-1] = id;
 366                 ++moxtet->count;
 367
 368                 if (mox_module_known(id)) {
 369                         dev_info(moxtet->dev, "Found %s module\n",
 370                                  mox_module_table[id].desc);
 371
 372                         if (moxtet_set_irq(moxtet, i-1, id, cnts[id]++) < 0)
 373                                 dev_err(moxtet->dev,
 374                                         "  Cannot set IRQ for module %s\n",
 375                                         mox_module_table[id].desc);
 376                 } else {
 377                         dev_warn(moxtet->dev,
 378                                  "Unknown Moxtet module found (ID 0x%02x)\n",
 379                                  id);
 380                 }
 381         }
 382
 383         return 0;
 384 }
 385
 386 static int moxtet_spi_read(struct moxtet *moxtet, u8 *buf)
 387 {
 388         struct spi_transfer xfer = {
 389                 .rx_buf = buf,
 390                 .tx_buf = moxtet->tx,
 391                 .len = moxtet->count + 1
 392         };
 393         int ret;
 394
 395         mutex_lock(&moxtet->lock);
 396
 397         ret = spi_sync_transfer(to_spi_device(moxtet->dev), &xfer, 1);
 398
 399         mutex_unlock(&moxtet->lock);
 400
 401         return ret;
 402 }
 403
 404 int moxtet_device_read(struct device *dev)
 405 {
 406         struct moxtet_device *mdev = to_moxtet_device(dev);
 407         struct moxtet *moxtet = mdev->moxtet;
 408         u8 buf[TURRIS_MOX_MAX_MODULES];
 409         int ret;
 410
 411         if (mdev->idx >= moxtet->count)
 412                 return -EINVAL;
 413
 414         ret = moxtet_spi_read(moxtet, buf);
 415         if (ret < 0)
 416                 return ret;
 417
 418         return buf[mdev->idx + 1] >> 4;
 419 }
 420 EXPORT_SYMBOL_GPL(moxtet_device_read);
 421
 422 int moxtet_device_write(struct device *dev, u8 val)
 423 {
 424         struct moxtet_device *mdev = to_moxtet_device(dev);
 425         struct moxtet *moxtet = mdev->moxtet;
 426         int ret;
 427
 428         if (mdev->idx >= moxtet->count)
 429                 return -EINVAL;
 430
 431         mutex_lock(&moxtet->lock);
 432
 433         moxtet->tx[moxtet->count - mdev->idx] = val;
 434
 435         ret = spi_write(to_spi_device(moxtet->dev), moxtet->tx,
 436                         moxtet->count + 1);
 437
 438         mutex_unlock(&moxtet->lock);
 439
 440         return ret;
 441 }
 442 EXPORT_SYMBOL_GPL(moxtet_device_write);
 443
 444 int moxtet_device_written(struct device *dev)
 445 {
 446         struct moxtet_device *mdev = to_moxtet_device(dev);
 447         struct moxtet *moxtet = mdev->moxtet;
 448
 449         if (mdev->idx >= moxtet->count)
 450                 return -EINVAL;
 451
 452         return moxtet->tx[moxtet->count - mdev->idx];
 453 }
 454 EXPORT_SYMBOL_GPL(moxtet_device_written);
 455
 456 #ifdef CONFIG_DEBUG_FS
 457 static int moxtet_debug_open(struct inode *inode, struct file *file)
 458 {
 459         file->private_data = inode->i_private;
 460
 461         return nonseekable_open(inode, file);
 462 }
 463
 464 static ssize_t input_read(struct file *file, char __user *buf, size_t len,
 465                           loff_t *ppos)
 466 {
 467         struct moxtet *moxtet = file->private_data;
 468         u8 bin[TURRIS_MOX_MAX_MODULES];
 469         u8 hex[sizeof(buf) * 2 + 1];
 470         int ret, n;
 471
 472         ret = moxtet_spi_read(moxtet, bin);
 473         if (ret < 0)
 474                 return ret;
 475
 476         n = moxtet->count + 1;
 477         bin2hex(hex, bin, n);
 478
 479         hex[2*n] = '\n';
 480
 481         return simple_read_from_buffer(buf, len, ppos, hex, 2*n + 1);
 482 }
 483
 484 static const struct file_operations input_fops = {
 485         .owner  = THIS_MODULE,
 486         .open   = moxtet_debug_open,
 487         .read   = input_read,
 488         .llseek = no_llseek,
 489 };
 490
 491 static ssize_t output_read(struct file *file, char __user *buf, size_t len,
 492                            loff_t *ppos)
 493 {
 494         struct moxtet *moxtet = file->private_data;
 495         u8 hex[TURRIS_MOX_MAX_MODULES * 2 + 1];
 496         u8 *p = hex;
 497         int i;
 498
 499         mutex_lock(&moxtet->lock);
 500
 501         for (i = 0; i < moxtet->count; ++i)
 502                 p = hex_byte_pack(p, moxtet->tx[moxtet->count - i]);
 503
 504         mutex_unlock(&moxtet->lock);
 505
 506         *p++ = '\n';
 507
 508         return simple_read_from_buffer(buf, len, ppos, hex, p - hex);
 509 }
 510
 511 static ssize_t output_write(struct file *file, const char __user *buf,
 512                             size_t len, loff_t *ppos)
 513 {
 514         struct moxtet *moxtet = file->private_data;
 515         u8 bin[TURRIS_MOX_MAX_MODULES];
 516         u8 hex[sizeof(bin) * 2 + 1];
 517         ssize_t res;
 518         loff_t dummy = 0;
 519         int err, i;
 520
 521         if (len > 2 * moxtet->count + 1 || len < 2 * moxtet->count)
 522                 return -EINVAL;
 523
 524         res = simple_write_to_buffer(hex, sizeof(hex), &dummy, buf, len);
 525         if (res < 0)
 526                 return res;
 527
 528         if (len % 2 == 1 && hex[len - 1] != '\n')
 529                 return -EINVAL;
 530
 531         err = hex2bin(bin, hex, moxtet->count);
 532         if (err < 0)
 533                 return -EINVAL;
 534
 535         mutex_lock(&moxtet->lock);
 536
 537         for (i = 0; i < moxtet->count; ++i)
 538                 moxtet->tx[moxtet->count - i] = bin[i];
 539
 540         err = spi_write(to_spi_device(moxtet->dev), moxtet->tx,
 541                         moxtet->count + 1);
 542
 543         mutex_unlock(&moxtet->lock);
 544
 545         return err < 0 ? err : len;
 546 }
 547
 548 static const struct file_operations output_fops = {
 549         .owner  = THIS_MODULE,
 550         .open   = moxtet_debug_open,
 551         .read   = output_read,
 552         .write  = output_write,
 553         .llseek = no_llseek,
 554 };
 555
 556 static int moxtet_register_debugfs(struct moxtet *moxtet)
 557 {
 558         struct dentry *root, *entry;
 559
 560         root = debugfs_create_dir("moxtet", NULL);
 561
 562         if (IS_ERR(root))
 563                 return PTR_ERR(root);
 564
 565         entry = debugfs_create_file_unsafe("input", 0444, root, moxtet,
 566                                            &input_fops);
 567         if (IS_ERR(entry))
 568                 goto err_remove;
 569
 570         entry = debugfs_create_file_unsafe("output", 0644, root, moxtet,
 571                                            &output_fops);
 572         if (IS_ERR(entry))
 573                 goto err_remove;
 574
 575         moxtet->debugfs_root = root;
 576
 577         return 0;
 578 err_remove:
 579         debugfs_remove_recursive(root);
 580         return PTR_ERR(entry);
 581 }
 582
 583 static void moxtet_unregister_debugfs(struct moxtet *moxtet)
 584 {
 585         debugfs_remove_recursive(moxtet->debugfs_root);
 586 }
 587 #else
 588 static inline int moxtet_register_debugfs(struct moxtet *moxtet)
 589 {
 590         return 0;
 591 }
 592
 593 static inline void moxtet_unregister_debugfs(struct moxtet *moxtet)
 594 {
 595 }
 596 #endif
 597
 598 static int moxtet_irq_domain_map(struct irq_domain *d, unsigned int irq,
 599                                  irq_hw_number_t hw)
 600 {
 601         struct moxtet *moxtet = d->host_data;
 602
 603         if (hw >= MOXTET_NIRQS || !(moxtet->irq.exists & BIT(hw))) {
 604                 dev_err(moxtet->dev, "Invalid hw irq number\n");
 605                 return -EINVAL;
 606         }
 607
 608         irq_set_chip_data(irq, d->host_data);
 609         irq_set_chip_and_handler(irq, &moxtet->irq.chip, handle_level_irq);
 610
 611         return 0;
 612 }
 613
 614 static int moxtet_irq_domain_xlate(struct irq_domain *d,
 615                                    struct device_node *ctrlr,
 616                                    const u32 *intspec, unsigned int intsize,
 617                                    unsigned long *out_hwirq,
 618                                    unsigned int *out_type)
 619 {
 620         struct moxtet *moxtet = d->host_data;
 621         int irq;
 622
 623         if (WARN_ON(intsize < 1))
 624                 return -EINVAL;
 625
 626         irq = intspec[0];
 627
 628         if (irq >= MOXTET_NIRQS || !(moxtet->irq.exists & BIT(irq)))
 629                 return -EINVAL;
 630
 631         *out_hwirq = irq;
 632         *out_type = IRQ_TYPE_NONE;
 633         return 0;
 634 }
 635
 636 static const struct irq_domain_ops moxtet_irq_domain = {
 637         .map = moxtet_irq_domain_map,
 638         .xlate = moxtet_irq_domain_xlate,
 639 };
 640
 641 static void moxtet_irq_mask(struct irq_data *d)
 642 {
 643         struct moxtet *moxtet = irq_data_get_irq_chip_data(d);
 644
 645         moxtet->irq.masked |= BIT(d->hwirq);
 646 }
 647
 648 static void moxtet_irq_unmask(struct irq_data *d)
 649 {
 650         struct moxtet *moxtet = irq_data_get_irq_chip_data(d);
 651
 652         moxtet->irq.masked &= ~BIT(d->hwirq);
 653 }
 654
 655 static void moxtet_irq_print_chip(struct irq_data *d, struct seq_file *p)
 656 {
 657         struct moxtet *moxtet = irq_data_get_irq_chip_data(d);
 658         struct moxtet_irqpos *pos = &moxtet->irq.position[d->hwirq];
 659         int id;
 660
 661         id = moxtet->modules[pos->idx];
 662
 663         seq_printf(p, " moxtet-%s.%i#%i", mox_module_name(id), pos->idx,
 664                    pos->bit);
 665 }
 666
 667 static const struct irq_chip moxtet_irq_chip = {
 668         .name                   = "moxtet",
 669         .irq_mask               = moxtet_irq_mask,
 670         .irq_unmask             = moxtet_irq_unmask,
 671         .irq_print_chip         = moxtet_irq_print_chip,
 672 };
 673
 674 static int moxtet_irq_read(struct moxtet *moxtet, unsigned long *map)
 675 {
 676         struct moxtet_irqpos *pos = moxtet->irq.position;
 677         u8 buf[TURRIS_MOX_MAX_MODULES];
 678         int i, ret;
 679
 680         ret = moxtet_spi_read(moxtet, buf);
 681         if (ret < 0)
 682                 return ret;
 683
 684         *map = 0;
 685
 686         for_each_set_bit(i, &moxtet->irq.exists, MOXTET_NIRQS) {
 687                 if (!(buf[pos[i].idx + 1] & BIT(4 + pos[i].bit)))
 688                         set_bit(i, map);
 689         }
 690
 691         return 0;
 692 }
 693
 694 static irqreturn_t moxtet_irq_thread_fn(int irq, void *data)
 695 {
 696         struct moxtet *moxtet = data;
 697         unsigned long set;
 698         int nhandled = 0, i, sub_irq, ret;
 699
 700         ret = moxtet_irq_read(moxtet, &set);
 701         if (ret < 0)
 702                 goto out;
 703
 704         set &= ~moxtet->irq.masked;
 705
 706         do {
 707                 for_each_set_bit(i, &set, MOXTET_NIRQS) {
 708                         sub_irq = irq_find_mapping(moxtet->irq.domain, i);
 709                         handle_nested_irq(sub_irq);
 710                         dev_dbg(moxtet->dev, "%i irq\n", i);
 711                         ++nhandled;
 712                 }
 713
 714                 ret = moxtet_irq_read(moxtet, &set);
 715                 if (ret < 0)
 716                         goto out;
 717
 718                 set &= ~moxtet->irq.masked;
 719         } while (set);
 720
 721 out:
 722         return (nhandled > 0 ? IRQ_HANDLED : IRQ_NONE);
 723 }
 724
 725 static void moxtet_irq_free(struct moxtet *moxtet)
 726 {
 727         int i, irq;
 728
 729         for (i = 0; i < MOXTET_NIRQS; ++i) {
 730                 if (moxtet->irq.exists & BIT(i)) {
 731                         irq = irq_find_mapping(moxtet->irq.domain, i);
 732                         irq_dispose_mapping(irq);
 733                 }
 734         }
 735
 736         irq_domain_remove(moxtet->irq.domain);
 737 }
 738
 739 static int moxtet_irq_setup(struct moxtet *moxtet)
 740 {
 741         int i, ret;
 742
 743         moxtet->irq.domain = irq_domain_add_simple(moxtet->dev->of_node,
 744                                                    MOXTET_NIRQS, 0,
 745                                                    &moxtet_irq_domain, moxtet);
 746         if (moxtet->irq.domain == NULL) {
 747                 dev_err(moxtet->dev, "Could not add IRQ domain\n");
 748                 return -ENOMEM;
 749         }
 750
 751         for (i = 0; i < MOXTET_NIRQS; ++i)
 752                 if (moxtet->irq.exists & BIT(i))
 753                         irq_create_mapping(moxtet->irq.domain, i);
 754
 755         moxtet->irq.chip = moxtet_irq_chip;
 756         moxtet->irq.masked = ~0;
 757
 758         ret = request_threaded_irq(moxtet->dev_irq, NULL, moxtet_irq_thread_fn,
 759                                    IRQF_ONESHOT, "moxtet", moxtet);
 760         if (ret < 0)
 761                 goto err_free;
 762
 763         return 0;
 764
 765 err_free:
 766         moxtet_irq_free(moxtet);
 767         return ret;
 768 }
 769
 770 static int moxtet_probe(struct spi_device *spi)
 771 {
 772         struct moxtet *moxtet;
 773         int ret;
 774
 775         ret = spi_setup(spi);
 776         if (ret < 0)
 777                 return ret;
 778
 779         moxtet = devm_kzalloc(&spi->dev, sizeof(struct moxtet),
 780                               GFP_KERNEL);
 781         if (!moxtet)
 782                 return -ENOMEM;
 783
 784         moxtet->dev = &spi->dev;
 785         spi_set_drvdata(spi, moxtet);
 786
 787         mutex_init(&moxtet->lock);
 788
 789         moxtet->dev_irq = of_irq_get(moxtet->dev->of_node, 0);
 790         if (moxtet->dev_irq == -EPROBE_DEFER)
 791                 return -EPROBE_DEFER;
 792
 793         if (moxtet->dev_irq <= 0) {
 794                 dev_err(moxtet->dev, "No IRQ resource found\n");
 795                 return -ENXIO;
 796         }
 797
 798         ret = moxtet_find_topology(moxtet);
 799         if (ret < 0)
 800                 return ret;
 801
 802         if (moxtet->irq.exists) {
 803                 ret = moxtet_irq_setup(moxtet);
 804                 if (ret < 0)
 805                         return ret;
 806         }
 807
 808         of_register_moxtet_devices(moxtet);
 809         moxtet_register_devices_from_topology(moxtet);
 810
 811         ret = moxtet_register_debugfs(moxtet);
 812         if (ret < 0)
 813                 dev_warn(moxtet->dev, "Failed creating debugfs entries: %i\n",
 814                          ret);
 815
 816         return 0;
 817 }
 818
 819 static int moxtet_remove(struct spi_device *spi)
 820 {
 821         struct moxtet *moxtet = spi_get_drvdata(spi);
 822
 823         free_irq(moxtet->dev_irq, moxtet);
 824
 825         moxtet_irq_free(moxtet);
 826
 827         moxtet_unregister_debugfs(moxtet);
 828
 829         device_for_each_child(moxtet->dev, NULL, __unregister);
 830
 831         mutex_destroy(&moxtet->lock);
 832
 833         return 0;
 834 }
 835
 836 static const struct of_device_id moxtet_dt_ids[] = {
 837         { .compatible = "cznic,moxtet" },
 838         {},
 839 };
 840 MODULE_DEVICE_TABLE(of, moxtet_dt_ids);
 841
 842 static struct spi_driver moxtet_spi_driver = {
 843         .driver = {
 844                 .name           = "moxtet",
 845                 .of_match_table = moxtet_dt_ids,
 846         },
 847         .probe          = moxtet_probe,
 848         .remove         = moxtet_remove,
 849 };
 850
 851 static int __init moxtet_init(void)
 852 {
 853         int ret;
 854
 855         ret = bus_register(&moxtet_bus_type);
 856         if (ret < 0) {
 857                 pr_err("moxtet bus registration failed: %d\n", ret);
 858                 goto error;
 859         }
 860
 861         ret = spi_register_driver(&moxtet_spi_driver);
 862         if (ret < 0) {
 863                 pr_err("moxtet spi driver registration failed: %d\n", ret);
 864                 goto error_bus;
 865         }
 866
 867         return 0;
 868
 869 error_bus:
 870         bus_unregister(&moxtet_bus_type);
 871 error:
 872         return ret;
 873 }
 874 postcore_initcall_sync(moxtet_init);
 875
 876 static void __exit moxtet_exit(void)
 877 {
 878         spi_unregister_driver(&moxtet_spi_driver);
 879         bus_unregister(&moxtet_bus_type);
 880 }
 881 module_exit(moxtet_exit);
 882
 883 MODULE_AUTHOR("Marek Behun <marek.behun@nic.cz>");
 884 MODULE_DESCRIPTION("CZ.NIC's Turris Mox module configuration bus");
 885 MODULE_LICENSE("GPL v2");