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