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"); 886