// SPDX-License-Identifier: GPL-2.0 /* * Turris Mox module configuration bus driver * * Copyright (C) 2019 Marek BehĂșn <kabel@kernel.org> */ #include <dt-bindings/bus/moxtet.h> #include <linux/bitops.h> #include <linux/debugfs.h> #include <linux/interrupt.h> #include <linux/module.h> #include <linux/moxtet.h> #include <linux/mutex.h> #include <linux/of_device.h> #include <linux/of_irq.h> #include <linux/spi/spi.h> /* * @name: module name for sysfs * @hwirq_base: base index for IRQ for this module (-1 if no IRQs) * @nirqs: how many interrupts does the shift register provide * @desc: module description for kernel log */ static const struct { const char *name; int hwirq_base; int nirqs; const char *desc; } mox_module_table[] = { /* do not change order of this array! */ { NULL, 0, 0, NULL }, { "sfp", -1, 0, "MOX D (SFP cage)" }, { "pci", MOXTET_IRQ_PCI, 1, "MOX B (Mini-PCIe)" }, { "topaz", MOXTET_IRQ_TOPAZ, 1, "MOX C (4 port switch)" }, { "peridot", MOXTET_IRQ_PERIDOT(0), 1, "MOX E (8 port switch)" }, { "usb3", MOXTET_IRQ_USB3, 2, "MOX F (USB 3.0)" }, { "pci-bridge", -1, 0, "MOX G (Mini-PCIe bridge)" }, }; static inline bool mox_module_known(unsigned int id) { return id >= TURRIS_MOX_MODULE_FIRST && id <= TURRIS_MOX_MODULE_LAST; } static inline const char *mox_module_name(unsigned int id) { if (mox_module_known(id)) return mox_module_table[id].name; else return "unknown"; } #define DEF_MODULE_ATTR(name, fmt, ...) \ static ssize_t \ module_##name##_show(struct device *dev, struct device_attribute *a, \ char *buf) \ { \ struct moxtet_device *mdev = to_moxtet_device(dev); \ return sprintf(buf, (fmt), __VA_ARGS__); \ } \ static DEVICE_ATTR_RO(module_##name) DEF_MODULE_ATTR(id, "0x%x\n", mdev->id); DEF_MODULE_ATTR(name, "%s\n", mox_module_name(mdev->id)); DEF_MODULE_ATTR(description, "%s\n", mox_module_known(mdev->id) ? mox_module_table[mdev->id].desc : ""); static struct attribute *moxtet_dev_attrs[] = { &dev_attr_module_id.attr, &dev_attr_module_name.attr, &dev_attr_module_description.attr, NULL, }; static const struct attribute_group moxtet_dev_group = { .attrs = moxtet_dev_attrs, }; static const struct attribute_group *moxtet_dev_groups[] = { &moxtet_dev_group, NULL, }; static int moxtet_match(struct device *dev, struct device_driver *drv) { struct moxtet_device *mdev = to_moxtet_device(dev); struct moxtet_driver *tdrv = to_moxtet_driver(drv); const enum turris_mox_module_id *t; if (of_driver_match_device(dev, drv)) return 1; if (!tdrv->id_table) return 0; for (t = tdrv->id_table; *t; ++t) if (*t == mdev->id) return 1; return 0; } static struct bus_type moxtet_bus_type = { .name = "moxtet", .dev_groups = moxtet_dev_groups, .match = moxtet_match, }; int __moxtet_register_driver(struct module *owner, struct moxtet_driver *mdrv) { mdrv->driver.owner = owner; mdrv->driver.bus = &moxtet_bus_type; return driver_register(&mdrv->driver); } EXPORT_SYMBOL_GPL(__moxtet_register_driver); static int moxtet_dev_check(struct device *dev, void *data) { struct moxtet_device *mdev = to_moxtet_device(dev); struct moxtet_device *new_dev = data; if (mdev->moxtet == new_dev->moxtet && mdev->id == new_dev->id && mdev->idx == new_dev->idx) return -EBUSY; return 0; } static void moxtet_dev_release(struct device *dev) { struct moxtet_device *mdev = to_moxtet_device(dev); put_device(mdev->moxtet->dev); kfree(mdev); } static struct moxtet_device * moxtet_alloc_device(struct moxtet *moxtet) { struct moxtet_device *dev; if (!get_device(moxtet->dev)) return NULL; dev = kzalloc(sizeof(*dev), GFP_KERNEL); if (!dev) { put_device(moxtet->dev); return NULL; } dev->moxtet = moxtet; dev->dev.parent = moxtet->dev; dev->dev.bus = &moxtet_bus_type; dev->dev.release = moxtet_dev_release; device_initialize(&dev->dev); return dev; } static int moxtet_add_device(struct moxtet_device *dev) { static DEFINE_MUTEX(add_mutex); int ret; if (dev->idx >= TURRIS_MOX_MAX_MODULES || dev->id > 0xf) return -EINVAL; dev_set_name(&dev->dev, "moxtet-%s.%u", mox_module_name(dev->id), dev->idx); mutex_lock(&add_mutex); ret = bus_for_each_dev(&moxtet_bus_type, NULL, dev, moxtet_dev_check); if (ret) goto done; ret = device_add(&dev->dev); if (ret < 0) dev_err(dev->moxtet->dev, "can't add %s, status %d\n", dev_name(dev->moxtet->dev), ret); done: mutex_unlock(&add_mutex); return ret; } static int __unregister(struct device *dev, void *null) { if (dev->of_node) { of_node_clear_flag(dev->of_node, OF_POPULATED); of_node_put(dev->of_node); } device_unregister(dev); return 0; } static struct moxtet_device * of_register_moxtet_device(struct moxtet *moxtet, struct device_node *nc) { struct moxtet_device *dev; u32 val; int ret; dev = moxtet_alloc_device(moxtet); if (!dev) { dev_err(moxtet->dev, "Moxtet device alloc error for %pOF\n", nc); return ERR_PTR(-ENOMEM); } ret = of_property_read_u32(nc, "reg", &val); if (ret) { dev_err(moxtet->dev, "%pOF has no valid 'reg' property (%d)\n", nc, ret); goto err_put; } dev->idx = val; if (dev->idx >= TURRIS_MOX_MAX_MODULES) { dev_err(moxtet->dev, "%pOF Moxtet address 0x%x out of range\n", nc, dev->idx); ret = -EINVAL; goto err_put; } dev->id = moxtet->modules[dev->idx]; if (!dev->id) { dev_err(moxtet->dev, "%pOF Moxtet address 0x%x is empty\n", nc, dev->idx); ret = -ENODEV; goto err_put; } of_node_get(nc); dev->dev.of_node = nc; ret = moxtet_add_device(dev); if (ret) { dev_err(moxtet->dev, "Moxtet device register error for %pOF\n", nc); of_node_put(nc); goto err_put; } return dev; err_put: put_device(&dev->dev); return ERR_PTR(ret); } static void of_register_moxtet_devices(struct moxtet *moxtet) { struct moxtet_device *dev; struct device_node *nc; if (!moxtet->dev->of_node) return; for_each_available_child_of_node(moxtet->dev->of_node, nc) { if (of_node_test_and_set_flag(nc, OF_POPULATED)) continue; dev = of_register_moxtet_device(moxtet, nc); if (IS_ERR(dev)) { dev_warn(moxtet->dev, "Failed to create Moxtet device for %pOF\n", nc); of_node_clear_flag(nc, OF_POPULATED); } } } static void moxtet_register_devices_from_topology(struct moxtet *moxtet) { struct moxtet_device *dev; int i, ret; for (i = 0; i < moxtet->count; ++i) { dev = moxtet_alloc_device(moxtet); if (!dev) { dev_err(moxtet->dev, "Moxtet device %u alloc error\n", i); continue; } dev->idx = i; dev->id = moxtet->modules[i]; ret = moxtet_add_device(dev); if (ret && ret != -EBUSY) { put_device(&dev->dev); dev_err(moxtet->dev, "Moxtet device %u register error: %i\n", i, ret); } } } /* * @nsame: how many modules with same id are already in moxtet->modules */ static int moxtet_set_irq(struct moxtet *moxtet, int idx, int id, int nsame) { int i, first; struct moxtet_irqpos *pos; first = mox_module_table[id].hwirq_base + nsame * mox_module_table[id].nirqs; if (first + mox_module_table[id].nirqs > MOXTET_NIRQS) return -EINVAL; for (i = 0; i < mox_module_table[id].nirqs; ++i) { pos = &moxtet->irq.position[first + i]; pos->idx = idx; pos->bit = i; moxtet->irq.exists |= BIT(first + i); } return 0; } static int moxtet_find_topology(struct moxtet *moxtet) { u8 buf[TURRIS_MOX_MAX_MODULES]; int cnts[TURRIS_MOX_MODULE_LAST]; int i, ret; memset(cnts, 0, sizeof(cnts)); ret = spi_read(to_spi_device(moxtet->dev), buf, TURRIS_MOX_MAX_MODULES); if (ret < 0) return ret; if (buf[0] == TURRIS_MOX_CPU_ID_EMMC) { dev_info(moxtet->dev, "Found MOX A (eMMC CPU) module\n"); } else if (buf[0] == TURRIS_MOX_CPU_ID_SD) { dev_info(moxtet->dev, "Found MOX A (CPU) module\n"); } else { dev_err(moxtet->dev, "Invalid Turris MOX A CPU module 0x%02x\n", buf[0]); return -ENODEV; } moxtet->count = 0; for (i = 1; i < TURRIS_MOX_MAX_MODULES; ++i) { int id; if (buf[i] == 0xff) break; id = buf[i] & 0xf; moxtet->modules[i-1] = id; ++moxtet->count; if (mox_module_known(id)) { dev_info(moxtet->dev, "Found %s module\n", mox_module_table[id].desc); if (moxtet_set_irq(moxtet, i-1, id, cnts[id]++) < 0) dev_err(moxtet->dev, " Cannot set IRQ for module %s\n", mox_module_table[id].desc); } else { dev_warn(moxtet->dev, "Unknown Moxtet module found (ID 0x%02x)\n", id); } } return 0; } static int moxtet_spi_read(struct moxtet *moxtet, u8 *buf) { struct spi_transfer xfer = { .rx_buf = buf, .tx_buf = moxtet->tx, .len = moxtet->count + 1 }; int ret; mutex_lock(&moxtet->lock); ret = spi_sync_transfer(to_spi_device(moxtet->dev), &xfer, 1); mutex_unlock(&moxtet->lock); return ret; } int moxtet_device_read(struct device *dev) { struct moxtet_device *mdev = to_moxtet_device(dev); struct moxtet *moxtet = mdev->moxtet; u8 buf[TURRIS_MOX_MAX_MODULES]; int ret; if (mdev->idx >= moxtet->count) return -EINVAL; ret = moxtet_spi_read(moxtet, buf); if (ret < 0) return ret; return buf[mdev->idx + 1] >> 4; } EXPORT_SYMBOL_GPL(moxtet_device_read); int moxtet_device_write(struct device *dev, u8 val) { struct moxtet_device *mdev = to_moxtet_device(dev); struct moxtet *moxtet = mdev->moxtet; int ret; if (mdev->idx >= moxtet->count) return -EINVAL; mutex_lock(&moxtet->lock); moxtet->tx[moxtet->count - mdev->idx] = val; ret = spi_write(to_spi_device(moxtet->dev), moxtet->tx, moxtet->count + 1); mutex_unlock(&moxtet->lock); return ret; } EXPORT_SYMBOL_GPL(moxtet_device_write); int moxtet_device_written(struct device *dev) { struct moxtet_device *mdev = to_moxtet_device(dev); struct moxtet *moxtet = mdev->moxtet; if (mdev->idx >= moxtet->count) return -EINVAL; return moxtet->tx[moxtet->count - mdev->idx]; } EXPORT_SYMBOL_GPL(moxtet_device_written); #ifdef CONFIG_DEBUG_FS static int moxtet_debug_open(struct inode *inode, struct file *file) { file->private_data = inode->i_private; return nonseekable_open(inode, file); } static ssize_t input_read(struct file *file, char __user *buf, size_t len, loff_t *ppos) { struct moxtet *moxtet = file->private_data; u8 bin[TURRIS_MOX_MAX_MODULES]; u8 hex[sizeof(bin) * 2 + 1]; int ret, n; ret = moxtet_spi_read(moxtet, bin); if (ret < 0) return ret; n = moxtet->count + 1; bin2hex(hex, bin, n); hex[2*n] = '\n'; return simple_read_from_buffer(buf, len, ppos, hex, 2*n + 1); } static const struct file_operations input_fops = { .owner = THIS_MODULE, .open = moxtet_debug_open, .read = input_read, .llseek = no_llseek, }; static ssize_t output_read(struct file *file, char __user *buf, size_t len, loff_t *ppos) { struct moxtet *moxtet = file->private_data; u8 hex[TURRIS_MOX_MAX_MODULES * 2 + 1]; u8 *p = hex; int i; mutex_lock(&moxtet->lock); for (i = 0; i < moxtet->count; ++i) p = hex_byte_pack(p, moxtet->tx[moxtet->count - i]); mutex_unlock(&moxtet->lock); *p++ = '\n'; return simple_read_from_buffer(buf, len, ppos, hex, p - hex); } static ssize_t output_write(struct file *file, const char __user *buf, size_t len, loff_t *ppos) { struct moxtet *moxtet = file->private_data; u8 bin[TURRIS_MOX_MAX_MODULES]; u8 hex[sizeof(bin) * 2 + 1]; ssize_t res; loff_t dummy = 0; int err, i; if (len > 2 * moxtet->count + 1 || len < 2 * moxtet->count) return -EINVAL; res = simple_write_to_buffer(hex, sizeof(hex), &dummy, buf, len); if (res < 0) return res; if (len % 2 == 1 && hex[len - 1] != '\n') return -EINVAL; err = hex2bin(bin, hex, moxtet->count); if (err < 0) return -EINVAL; mutex_lock(&moxtet->lock); for (i = 0; i < moxtet->count; ++i) moxtet->tx[moxtet->count - i] = bin[i]; err = spi_write(to_spi_device(moxtet->dev), moxtet->tx, moxtet->count + 1); mutex_unlock(&moxtet->lock); return err < 0 ? err : len; } static const struct file_operations output_fops = { .owner = THIS_MODULE, .open = moxtet_debug_open, .read = output_read, .write = output_write, .llseek = no_llseek, }; static int moxtet_register_debugfs(struct moxtet *moxtet) { struct dentry *root, *entry; root = debugfs_create_dir("moxtet", NULL); if (IS_ERR(root)) return PTR_ERR(root); entry = debugfs_create_file_unsafe("input", 0444, root, moxtet, &input_fops); if (IS_ERR(entry)) goto err_remove; entry = debugfs_create_file_unsafe("output", 0644, root, moxtet, &output_fops); if (IS_ERR(entry)) goto err_remove; moxtet->debugfs_root = root; return 0; err_remove: debugfs_remove_recursive(root); return PTR_ERR(entry); } static void moxtet_unregister_debugfs(struct moxtet *moxtet) { debugfs_remove_recursive(moxtet->debugfs_root); } #else static inline int moxtet_register_debugfs(struct moxtet *moxtet) { return 0; } static inline void moxtet_unregister_debugfs(struct moxtet *moxtet) { } #endif static int moxtet_irq_domain_map(struct irq_domain *d, unsigned int irq, irq_hw_number_t hw) { struct moxtet *moxtet = d->host_data; if (hw >= MOXTET_NIRQS || !(moxtet->irq.exists & BIT(hw))) { dev_err(moxtet->dev, "Invalid hw irq number\n"); return -EINVAL; } irq_set_chip_data(irq, d->host_data); irq_set_chip_and_handler(irq, &moxtet->irq.chip, handle_level_irq); return 0; } static int moxtet_irq_domain_xlate(struct irq_domain *d, struct device_node *ctrlr, const u32 *intspec, unsigned int intsize, unsigned long *out_hwirq, unsigned int *out_type) { struct moxtet *moxtet = d->host_data; int irq; if (WARN_ON(intsize < 1)) return -EINVAL; irq = intspec[0]; if (irq >= MOXTET_NIRQS || !(moxtet->irq.exists & BIT(irq))) return -EINVAL; *out_hwirq = irq; *out_type = IRQ_TYPE_NONE; return 0; } static const struct irq_domain_ops moxtet_irq_domain = { .map = moxtet_irq_domain_map, .xlate = moxtet_irq_domain_xlate, }; static void moxtet_irq_mask(struct irq_data *d) { struct moxtet *moxtet = irq_data_get_irq_chip_data(d); moxtet->irq.masked |= BIT(d->hwirq); } static void moxtet_irq_unmask(struct irq_data *d) { struct moxtet *moxtet = irq_data_get_irq_chip_data(d); moxtet->irq.masked &= ~BIT(d->hwirq); } static void moxtet_irq_print_chip(struct irq_data *d, struct seq_file *p) { struct moxtet *moxtet = irq_data_get_irq_chip_data(d); struct moxtet_irqpos *pos = &moxtet->irq.position[d->hwirq]; int id; id = moxtet->modules[pos->idx]; seq_printf(p, " moxtet-%s.%i#%i", mox_module_name(id), pos->idx, pos->bit); } static const struct irq_chip moxtet_irq_chip = { .name = "moxtet", .irq_mask = moxtet_irq_mask, .irq_unmask = moxtet_irq_unmask, .irq_print_chip = moxtet_irq_print_chip, }; static int moxtet_irq_read(struct moxtet *moxtet, unsigned long *map) { struct moxtet_irqpos *pos = moxtet->irq.position; u8 buf[TURRIS_MOX_MAX_MODULES]; int i, ret; ret = moxtet_spi_read(moxtet, buf); if (ret < 0) return ret; *map = 0; for_each_set_bit(i, &moxtet->irq.exists, MOXTET_NIRQS) { if (!(buf[pos[i].idx + 1] & BIT(4 + pos[i].bit))) set_bit(i, map); } return 0; } static irqreturn_t moxtet_irq_thread_fn(int irq, void *data) { struct moxtet *moxtet = data; unsigned long set; int nhandled = 0, i, sub_irq, ret; ret = moxtet_irq_read(moxtet, &set); if (ret < 0) goto out; set &= ~moxtet->irq.masked; do { for_each_set_bit(i, &set, MOXTET_NIRQS) { sub_irq = irq_find_mapping(moxtet->irq.domain, i); handle_nested_irq(sub_irq); dev_dbg(moxtet->dev, "%i irq\n", i); ++nhandled; } ret = moxtet_irq_read(moxtet, &set); if (ret < 0) goto out; set &= ~moxtet->irq.masked; } while (set); out: return (nhandled > 0 ? IRQ_HANDLED : IRQ_NONE); } static void moxtet_irq_free(struct moxtet *moxtet) { int i, irq; for (i = 0; i < MOXTET_NIRQS; ++i) { if (moxtet->irq.exists & BIT(i)) { irq = irq_find_mapping(moxtet->irq.domain, i); irq_dispose_mapping(irq); } } irq_domain_remove(moxtet->irq.domain); } static int moxtet_irq_setup(struct moxtet *moxtet) { int i, ret; moxtet->irq.domain = irq_domain_add_simple(moxtet->dev->of_node, MOXTET_NIRQS, 0, &moxtet_irq_domain, moxtet); if (moxtet->irq.domain == NULL) { dev_err(moxtet->dev, "Could not add IRQ domain\n"); return -ENOMEM; } for (i = 0; i < MOXTET_NIRQS; ++i) if (moxtet->irq.exists & BIT(i)) irq_create_mapping(moxtet->irq.domain, i); moxtet->irq.chip = moxtet_irq_chip; moxtet->irq.masked = ~0; ret = request_threaded_irq(moxtet->dev_irq, NULL, moxtet_irq_thread_fn, IRQF_ONESHOT, "moxtet", moxtet); if (ret < 0) goto err_free; return 0; err_free: moxtet_irq_free(moxtet); return ret; } static int moxtet_probe(struct spi_device *spi) { struct moxtet *moxtet; int ret; ret = spi_setup(spi); if (ret < 0) return ret; moxtet = devm_kzalloc(&spi->dev, sizeof(struct moxtet), GFP_KERNEL); if (!moxtet) return -ENOMEM; moxtet->dev = &spi->dev; spi_set_drvdata(spi, moxtet); mutex_init(&moxtet->lock); moxtet->dev_irq = of_irq_get(moxtet->dev->of_node, 0); if (moxtet->dev_irq == -EPROBE_DEFER) return -EPROBE_DEFER; if (moxtet->dev_irq <= 0) { dev_err(moxtet->dev, "No IRQ resource found\n"); return -ENXIO; } ret = moxtet_find_topology(moxtet); if (ret < 0) return ret; if (moxtet->irq.exists) { ret = moxtet_irq_setup(moxtet); if (ret < 0) return ret; } of_register_moxtet_devices(moxtet); moxtet_register_devices_from_topology(moxtet); ret = moxtet_register_debugfs(moxtet); if (ret < 0) dev_warn(moxtet->dev, "Failed creating debugfs entries: %i\n", ret); return 0; } static void moxtet_remove(struct spi_device *spi) { struct moxtet *moxtet = spi_get_drvdata(spi); free_irq(moxtet->dev_irq, moxtet); moxtet_irq_free(moxtet); moxtet_unregister_debugfs(moxtet); device_for_each_child(moxtet->dev, NULL, __unregister); mutex_destroy(&moxtet->lock); } static const struct of_device_id moxtet_dt_ids[] = { { .compatible = "cznic,moxtet" }, {}, }; MODULE_DEVICE_TABLE(of, moxtet_dt_ids); static struct spi_driver moxtet_spi_driver = { .driver = { .name = "moxtet", .of_match_table = moxtet_dt_ids, }, .probe = moxtet_probe, .remove = moxtet_remove, }; static int __init moxtet_init(void) { int ret; ret = bus_register(&moxtet_bus_type); if (ret < 0) { pr_err("moxtet bus registration failed: %d\n", ret); goto error; } ret = spi_register_driver(&moxtet_spi_driver); if (ret < 0) { pr_err("moxtet spi driver registration failed: %d\n", ret); goto error_bus; } return 0; error_bus: bus_unregister(&moxtet_bus_type); error: return ret; } postcore_initcall_sync(moxtet_init); static void __exit moxtet_exit(void) { spi_unregister_driver(&moxtet_spi_driver); bus_unregister(&moxtet_bus_type); } module_exit(moxtet_exit); MODULE_AUTHOR("Marek Behun <kabel@kernel.org>"); MODULE_DESCRIPTION("CZ.NIC's Turris Mox module configuration bus"); MODULE_LICENSE("GPL v2");