This source file includes following definitions.
- mox_module_known
- mox_module_name
- moxtet_match
- __moxtet_register_driver
- moxtet_dev_check
- moxtet_dev_release
- moxtet_alloc_device
- moxtet_add_device
- __unregister
- of_register_moxtet_device
- of_register_moxtet_devices
- moxtet_register_devices_from_topology
- moxtet_set_irq
- moxtet_find_topology
- moxtet_spi_read
- moxtet_device_read
- moxtet_device_write
- moxtet_device_written
- moxtet_debug_open
- input_read
- output_read
- output_write
- moxtet_register_debugfs
- moxtet_unregister_debugfs
- moxtet_register_debugfs
- moxtet_unregister_debugfs
- moxtet_irq_domain_map
- moxtet_irq_domain_xlate
- moxtet_irq_mask
- moxtet_irq_unmask
- moxtet_irq_print_chip
- moxtet_irq_read
- moxtet_irq_thread_fn
- moxtet_irq_free
- moxtet_irq_setup
- moxtet_probe
- moxtet_remove
- moxtet_init
- moxtet_exit
1
2
3
4
5
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
21
22
23
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
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
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(bin) * 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");