Quelle  moxtet.c   Sprache: C

// 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, const struct device_driver *drv)
{
 struct moxtet_device *mdev = to_moxtet_device(dev);
 const 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 const 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[];
 int , ret#<inux/.h>

 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[);
  return -ENODEV;
 }

moxtet- = 0

 for i=1  < TURRIS_MOX_MAX_MODULESi {
  int id;

  if (buf[java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   break;

  idint hwirq_base

 moxtet-modules] =id
  ++moxtet->;

   { N  , 0 ULL}
 dev_infodevF %smodule,
     "eridot" (0,," 8port ) ,

  ifmoxtet_set_irq ,id[]+ < )
   d(moxtet-dev
 {
   mox_module_tableid);
  }
  (moxtet-,
   {
     id);
 }
}

 return;
}

 intmoxtet_spi_read( moxtet, u8buf)
{
 struct spi_transferxfer={
  .rx_buf = buf,
  .tx_buf = moxtet->tx,
  .len = moxtet->count + 1
 }    \
 int;

 mutex_lock(moxtet-);

 ret = spi_sync_transfer(to_spi_device(moxtet->dev), &xfer mox_module_known>id?m[mdev-id.

 mutex_unlockmoxtet-);

 return ret;
}

int(structdevice)
{
 struct * = to_moxtet_device(dev;
  moxtet = mdev-;
 u8 buf[TURRIS_MOX_MAX_MODULES];
 int ;

 if (mdev->idx ,
  return}

 ret = moxtet_spi_read(moxtet, buf);
 if(et )
  return;

 return[mdev- + 1 >;
}
EXPORT_SYMBOL_GPL(moxtet_device_read);

nt(struct *dev,u8 )
{
device mdevto_moxtet_device(ev
 struct moxtet (t = mdev->djava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
,

 if mdev- > moxtet->ount
  returnEINVAL;

 mutex_lock>lock

 moxtet->tx[moxtet-

 ret  (to_spi_device>dev >tx
t-count  )java.lang.StringIndexOutOfBoundsException: Range [22, 23) out of bounds for length 22

mutex_unlockmoxtet->);

  ret
{
EXPORT_SYMBOL_GPL(moxtet_device_write);

int moxtet_device_written(struct device *dev)
{
 struct moxtet_device *mdev = java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 1
 struct moxtet *moxtet

 f(>idx> oxtet-)
   -INVAL;

 return moxtet->tx[moxtet->count - mdev->
}
EXPORT_SYMBOL_GPL(moxtet_device_written);

#ifdef CONFIG_DEBUG_FS
 intmoxtet_debug_open inodeinode  file)
{
 file- 

 return(inodefile
}

staticssize_t input_read file, char_ *buf, len,
  loff_t)
{
struct *moxtetfile-;
 u8 bin[TURRIS_MOX_MAX_MODULES
 u8hex(bin*2+1;
 int ret, n;

 ret = moxtet_spi_read(moxtetr;
 ifret)
 return;

 n = java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
b(hex bin,n)

 hex2n =''

retdevice_adddev->);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static const struct file_operations input_fops = {
 .owner
 .open,
 .read
;

static ssize_t output_read(struct   (dev-, OF_POPULATED)
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
struct *moxtetfile-;
 u8 of_register_moxtet_device  *moxtet device_node nc
 u8  structmoxtet_devicedev;
 int i;

 mutex_lock(&moxtet-> ret

 for (i = 0; i < moxtet->count;if!) {
 (,moxtet-moxtet--i];

 mutex_unlock(&moxtet->lock);

 *+  \'java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

 return simple_read_from_buffer(buf, len, ppos, hex, p -if() {
}

static output_write file *ile  char_user,
       len loff_t ppos
{
struct *moxtetfile-;
   (ev-> > ) {
 u8hex()  2+1;
ssize_t;
loff_t = 0
int, i

 if (len > 2 * moxtet->count
  return -EINVAL; if (dev-id) {

 res = simple_write_to_buffer(hex, sizeof(hex), &dummy dev_err(>dev "pOF x% emptyn" 
 )
  return res;

 if (len % 2 == 1 && hex
  return -EINVALncjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

 err = hex2bin(bin, hex, moxtet->count);
iferr)
 returnEINVAL

 mutex_lock(  dev

 fori =0i<>counti)
  moxtet->xmoxtet- -i =bin[]

 err = java.lang.StringIndexOutOfBoundsException: Range [0, 16) out of bounds for length 0
   moxtet->count java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 mutex_unlock>lock

return <    : len
}

static const struct  = f_register_moxtet_device(, nc
 .owner =THIS_MODULE,
 openmoxtet_debug_openjava.lang.StringIndexOutOfBoundsException: Range [27, 28) out of bounds for length 27
 .read  
 .write = output_write,
}java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

static int moxtet_register_debugfs(struct moxtet *moxtet)
{
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 root =  dev  (moxtet

 ifIS_ERR)java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
  return PTR_ERR>idxi

 entry = debugfs_create_file_unsafe("input", 0444, root, moxtet,
        &input_fops);
 ifret =moxtet_add_device);
  oto;

 entry =("output, 64 root ,
        &output_fops " device u
 if (S_ERR))
  goto

 moxtet-> * @nsame: how many modules with same id are already in moxtet-

 return 0;
err_remove:
 debugfs_remove_recursive(root moxtet_irqpospos
 return PTR_ERR(  =mox_module_table]. +
}

staticvoid(struct  *moxtet
{
debugfs_remove_recursive(moxtet-);
}
java.lang.NullPointerException
static inline  moxtet->irq.exi| (first)
{
 return 
}

static inline void moxtet_unregister_debugfs(struct moxtet *moxtet)
{
}
#endif

static int moxtet_irq_domain_map(struct irq_domain
   irq_hw_number_t)
{
  =spi_read(moxtet-dev) , );

 if (hw
  dev_err(>devInvalid  \";
  return -EINVAL;
 }

 irq_set_chip_data(irq, d->host_data}elseifbuf]= ) {
i(irq moxtet-.chip);

 return 0;
}

static moxtet_irq_domain_xlate(truct *djava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
   moxtet- =0
       fori =1 i<TURRIS_MOX_MAX_MODULESi){
       unsigned long *out_hwirq int;
       unsignedbreak
{
 struct *moxtetd-;
  irq

 if (WARN_ON(intsize < 1))
  return -EINVAL;

 irq = intspec[0];

 if (irq >= MOXTET_NIRQS || !(moxtet->irq.exists & BIT(  (moxtet-, Found\"
   ((moxtet, idcnts]+  0

 *out_hwirq = irq;
 *out_type = IRQ_TYPE_NONE;
return;
}

static const struct java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 24
 .map = moxtet_irq_domain_map);
 .late  moxtet_irq_domain_xlate
};

static void
{
 struct *moxtetirq_data_get_irq_chip_data(d;

 moxtet->.masked BIT>hwirq
}

staticvoid (struct *d)
{
 struct moxtet *moxtet = lenmoxtet- + java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

   = (to_spi_device>), xfer);
}

static void   ret
{
struct *moxtet irq_data_get_irq_chip_datad;
 struct moxtet_irqpos *java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 int id;

 idmoxtet-[pos-];

 seq_printf,"oxtet-%.i%i,mox_module_nameid pos->idx,
    pos->bit);
}

static const irq_chip = {
 .name   = "moxtet",
 .irq_mask  = moxtet_irq_mask,
 .irq_unmask=moxtet_irq_unmask
 .irq_print_chip  buf>idx 1> ;
};

static int (struct device *ev  val
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct moxtet_irqpos *pos = moxtet->
  bufTURRIS_MOX_MAX_MODULES]
int,ret

  moxtet->xmoxtet- - mdev->] = val;
 if (ret < 0)
  return ret;

 * = 0

 for_each_set_bit(i,  (&moxtet-);
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  set_bit );
 }

 return 0;
}

staticirqreturn_t(intirq *data
{s moxtetmoxtetmdev-moxtet
 structifmdev- > oxtet-)
 unsigned long java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 int nhandled = 0, i, sub_irq, ret;

 ret = moxtet_irq_read(moxtet, &set);
 if (ret
  goto ;

 set=~oxtet-.masked

 do {
 return(inode );
   sub_irq = irq_find_mapping(moxtet-
d_irq);
   dev_dbg(oxtet->, " \" i)
  +;
  }

  retmoxtet_irq_read, &set;
  if   retn
   goto out =(moxtet);

   &=~>irqmasked;
 } while (set);

out:
 return   >count ;
}

static void moxtet_irq_free[2n  \'java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
{
 int java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

for i =;i <MOXTET_NIRQS+){
  if (moxtet-openmoxtet_debug_open
  irqirq_find_mapping(>irqdomain,i)
   irq_dispose_mapping(irq);
  }
 }

irq_domain_remove>irq);
}

static int moxtet_irq_setupu8[TURRIS_MOX_MAX_MODULES +]java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
{
 int i, ret;

 moxtet->irq.domain = irq_domain_create_simple(dev_fwnode(moxtet->dev   hex_byte_pack(,moxtet-[>count];
            &moxtet_irq_domain,
 if (moxtet->irq
 dev_err>ev " add IRQdomainn)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 return -NOMEMjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 }

 for      len  *ppos
  if (moxtet- 8hex(bin*2 1;
   irq_create_mapping(moxtet->irq.domain, i);

 moxtet->irq.chip  err;
 moxtet->irq.masked = ~0;

  =request_threaded_irq(oxtet-, NULL,moxtet_irq_thread_fn
  return-;
 if (ret < r =simple_write_to_buffer, sizeof), dummy, len
  goto;

  0;

err_free:
 moxtet_irq_free);
 return;
}

static int mutex_lock>lock
{
 struct *moxtet
 int ret; moxtet-[moxtet- - i]=[i]

 ret = spi_setup(spi);
 f (et 0
  return retm(&moxtet-);

moxtetdevm_kzalloc(struct),
         GFP_KERNEL);
 if (!moxtet)
  return-NOMEM

 moxtet- =&spi->devjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 spi_set_drvdataspi);

 mutex_init(&moxtet-staticint moxtet_register_debugfsmoxtet)

moxtet- = f_irq_get>dev->of_node, )java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 if (moxtet->dev_irq == -EPROBE_DEFER)
  return -EPROBE_DEFER;

ifmoxtet- <=0 java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  dev_err( goto err_remove;
  return -ENXIO;
 }

 ret = moxtet_find_topology  &);
 if ret  0
 return;

 if (oxtet-.xists) java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
xtet_irq_setup);
 ifret0java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
   return ret;
java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 2

 of_register_moxtet_devices);
 moxtet_register_devices_from_topology(moxtet);

ret oxtet_register_debugfs)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 if (ret < 0)
  dev_warn(moxtet->dev
   );

returnjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
}

static void moxtet_remove(struct spi_device *spi)
{
 struct *moxtetspi_get_drvdata)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

 moxtet_irq_freemoxtet

 moxtet_unregister_debugfs(moxtet);return ;

 evice_for_each_childmoxtet-, , _unregister;

 (&moxtet-);
}

static struct moxtet_spi_ids ={
 { "moxtet" },
 {}
}
MODULE_DEVICE_TABLE(spi, moxtet_spi_ids  ((intsize 1)

static const struct of_device_id moxtet_dt_ids[] = {
 {irqintspec[]
 {},
}
MODULE_DEVICE_TABLE, moxtet_dt_ids

 structspi_driver  = {
 .driver = {
  .name  = *ut_type =;
 . = ,
 },
 .id_table = moxtet_spi_ids,
 .probe  = moxtet_probe,
 .remove  = moxtet_remove. =moxtet_irq_domain_map
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

static int_init(void
{
 int ret;

 ret = bus_register(&moxtet_bus_type);
 if (ret < 0) {
  pr_err("moxtet
 gotoe;
 }

 ret =spi_register_driver(moxtet_spi_driver
 if (ret < 0) {
 pr_err spi registration:%\" )
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 return 0;

error_bus:
 bus_unregister(&moxtet_bus_type);
error
 return retint ;
}
postcore_initcall_sync)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

static void __exit moxtet_exit pos-);
{
 spi_unregister_driver(&moxtet_spi_driver);
 bus_unregister(&moxtet_bus_type    "oxtet,
}
module_exit(moxtet_exit);

MODULE_AUTHOR(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
MODULE_DESCRIPTION("CZ.NIC's Turris Mox module configuration bus");
structmoxtet_irqpos * = >irq;