Linuxの自作ドライバでinit関数が呼ばれません

Question

#現在の状況
以前の質問に関連しているのですが、まだドライバが認識されず困っています。

デバイスツリーとドライバの関連付けについてはわかってきたのですが、関連づいているのにも関わらずドライバのinit関数やprobe関数が呼ばれません。エラーらしきものも出ていません。
（必ず通るところでdmesgに出力するようにしていますが、出力されません）
デバッグ出力レベルは調整済みです。

ちなみにmodprobeを使うと、正しく認識されているようです（lsmodで見ただけですが）。

以下、ソースコードです。

#include <linux/delay.h>
#include <linux/device.h>
#include <linux/gpio/consumer.h>
#include <linux/kernel.h>	/*<-include printk.h		*/
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/of_gpio.h>
#include <linux/slab.h>
#include <linux/platform_device.h>
#include <linux/spi/spi.h>
#include <linux/uaccess.h>
#include <linux/eeprom_93xx56.h>

/*
 * This supports access to SPI devices using normal userspace I/O calls.
 * Note that while traditional UNIX/POSIX I/O semantics are half duplex,
 * and often mask message boundaries, full SPI support requires full duplex
 * transfers.  There are several kinds of internal message boundaries to
 * handle chipselect management and other protocol options.
 *
 * SPI has a character major number assigned.  We allocate minor numbers
 * dynamically using a bitmask.  You must use hotplug tools, such as udev
 * (or mdev with busybox) to create and destroy the /dev/spidevB.C device
 * nodes, since there is no fixed association of minor numbers with any
 * particular SPI bus or device.
 */
#define SPIDEV_MAJOR			153	/* assigned */
#define N_SPI_MINORS			32	/* ... up to 256 */

#define OP_START	0x4
#define OP_WRITE	(OP_START | 0x1)
#define OP_READ		(OP_START | 0x2)
#define ADDR_EWDS	0x00
#define ADDR_ERAL	0x80
#define ADDR_EWEN	0xC0

#define ADDR_LEN_x8	(9)

static struct class *eeprom_93xx56_class;

struct eeprom_93xx56_dev {
	dev_t			devt;
	spinlock_t		spi_lock;
	struct spi_device 	*spi;
	struct eeprom_93xx56_platform_data *pdata;
	struct list_head	device_entry;
	struct mutex 		lock;
	struct mutex		buf_lock;
	int 			addrlen;
	int 			size;
	unsigned		users;
	u8			*tx_buffer;
	u8			*rx_buffer;
	u32			speed_hz;
};

static LIST_HEAD(device_list);
static DEFINE_MUTEX(device_list_lock);
static unsigned bufsiz = 256;
module_param(bufsiz, uint, S_IRUGO);
MODULE_PARM_DESC(bufsiz, "data bytes in biggest supported SPI message");

/*----------------------------- Module Define ------------------------------------------ */
static const struct of_device_id eeprom_93xx56_of_table[] = {
	{ .compatible = "microchip,eeprom-93xx56" },
	{},
};
MODULE_DEVICE_TABLE(of, eeprom_93xx56_of_table);

static const struct spi_device_id eeprom_93xx56_id[] = {
	{ "93xx56-0", 0 },
    {},
};
MODULE_DEVICE_TABLE(spi, eeprom_93xx56_id);
/* ------------------------------------------------------------------------------------- */
....中略....
static int eeprom_93xx56_probe_dt(struct spi_device *spi)
{
	struct device_node *np = spi->dev.of_node;
	struct eeprom_93xx56_platform_data *pd;
	u32 tmp;
	int gpio;
	enum of_gpio_flags of_flags;
	int ret;

	pd = devm_kzalloc(&spi->dev, sizeof(*pd), GFP_KERNEL);
	if (!pd)
		return -ENOMEM;

	ret = of_property_read_u32(np, "data-size", &tmp);
	if (ret < 0) {
		dev_err(&spi->dev, "data-size property not found\n");
		return ret;
	}

	if (tmp == 8) {
		pd->flags |= EE_ADDR8;
	} else if (tmp == 16) {
		pd->flags |= EE_ADDR16;
	} else {
		dev_err(&spi->dev, "invalid data-size (%d)\n", tmp);
		return -EINVAL;
	}

	if (of_property_read_bool(np, "read-only"))
		pd->flags |= EE_READONLY;

	gpio = of_get_named_gpio_flags(np, "select-gpios", 0, &of_flags);
	if (gpio_is_valid(gpio)) {
		unsigned long flags =
			of_flags == OF_GPIO_ACTIVE_LOW ? GPIOF_ACTIVE_LOW : 0;

		ret = devm_gpio_request_one(&spi->dev, gpio, flags,
					    "eeprom_93xx56_select");
		if (ret)
			return ret;

		pd->select = gpio_to_desc(gpio);
		pd->prepare = select_assert;
		pd->finish = select_deassert;

		gpiod_direction_output(pd->select, 0);
	}

	spi->dev.platform_data = pd;

	return 0;
}

static int eeprom_93xx56_probe(struct spi_device *spi )
{
	struct eeprom_93xx56_platform_data *pd;
	struct eeprom_93xx56_dev *edev;
	int err;

	dev_err(&spi->dev,"spi:93xx56 probing....\n");
	if (spi->dev.of_node) {
		err = eeprom_93xx56_probe_dt(spi);
		if (err < 0)
			return err;
	}

	pd = spi->dev.platform_data;
	if (!pd) {
		dev_err(&spi->dev, "missing platform data\n");
		return -ENODEV;
	}

	dev_err(&spi->dev,"spi:93xx56 memory setting..\n");
	edev = kzalloc(sizeof(*edev), GFP_KERNEL);
	if (!edev)
		return -ENOMEM;

	if (pd->flags & EE_ADDR8)
		edev->addrlen = ADDR_LEN_x8;
	else if (pd->flags & EE_ADDR16)
		edev->addrlen = ADDR_LEN_x8 - 1;
	else {
		dev_err(&spi->dev, "unspecified address type\n");
		err = -EINVAL;
		goto fail;
	}

	mutex_init(&edev->lock);

	edev->spi = spi;
	edev->pdata = pd;

	edev->size = 256;

	dev_err(&spi->dev, "%d-bit eeprom %s\n",
		(pd->flags & EE_ADDR8) ? 8 : 16,
		(pd->flags & EE_READONLY) ? "(readonly)" : "");

	if (!(pd->flags & EE_READONLY)) {
		if (device_create_file(&spi->dev, &dev_attr_erase))
			dev_err(&spi->dev, "can't create erase interface\n");
	}

	spi_set_drvdata(spi, edev);
	return 0;
fail:
	kfree(edev);
	return err;
}

static int eeprom_93xx56_remove(struct spi_device *spi)
{
	struct eeprom_93xx56_dev *edev = spi_get_drvdata(spi);

	if (!(edev->pdata->flags & EE_READONLY))
		device_remove_file(&spi->dev, &dev_attr_erase);

	kfree(edev);
	return 0;
}
/* --------------------------- Driver Function Define -------------------------------- */
static const struct file_operations eeprom_93xx56_fops = {
	.owner =	THIS_MODULE,
	/* REVISIT switch to aio primitives, so that userspace
	 * gets more complete API coverage.  It'll simplify things
	 * too, except for the locking.
	 */
	.write =	eeprom_93xx56_if_write,
	.read =		eeprom_93xx56_if_read,
//	.unlocked_ioctl = spieep_ioctl,
//	.compat_ioctl = spieep_compat_ioctl,
	.open =		eeprom_93xx56_if_open,
	.release =	eeprom_93xx56_if_release,
//	.llseek =	no_llseek,
};

static struct spi_driver eeprom_93xx56_driver = {
	.driver = {
		.name =		"93xx56",
		.owner =	THIS_MODULE,
		.of_match_table = of_match_ptr(eeprom_93xx56_of_table),
	},
	.probe =	eeprom_93xx56_probe,
	.remove =	eeprom_93xx56_remove,
};

/* ------------------------------------------------------------------------------------ */
static int __init eeprom_93xx56_init(void)
{
	int status;

	/* Claim our 256 reserved device numbers.  Then register a class
	 * that will key udev/mdev to add/remove /dev nodes.  Last, register
	 * the driver which manages those device numbers.
	 */
	printk(KERN_ALERT "eep93xx56:init...\n");
	BUILD_BUG_ON(N_SPI_MINORS > 256);
	status = register_chrdev(SPIDEV_MAJOR, "spi", &eeprom_93xx56_fops);
	if (status < 0)
		return status;

	eeprom_93xx56_class = class_create(THIS_MODULE, "93xx56");
	if (IS_ERR(eeprom_93xx56_class)) {
		printk(KERN_ALERT "class_create:93xx56 missed!!\n");
		unregister_chrdev(SPIDEV_MAJOR, eeprom_93xx56_driver.driver.name);
		return PTR_ERR(eeprom_93xx56_class);
	}

	status = spi_register_driver(&eeprom_93xx56_driver);
	if (status < 0) {
		class_destroy(eeprom_93xx56_class);
		unregister_chrdev(SPIDEV_MAJOR, eeprom_93xx56_driver.driver.name);
	}
	return status;
}
module_init(eeprom_93xx56_init);

static void __exit eeprom_93xx56_exit(void)
{
	spi_unregister_driver(&eeprom_93xx56_driver);
	class_destroy(eeprom_93xx56_class);
	unregister_chrdev(SPIDEV_MAJOR, eeprom_93xx56_driver.driver.name);
}
module_exit(eeprom_93xx56_exit);
/* ----------------------------------------------------------------------------------- */

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Driver for 93xx56 EEPROMs");
MODULE_AUTHOR("xxxx <[e-mail]>");
MODULE_ALIAS("spi:93xx56");

#わからないこと
デバイスツリーのcompatibleは同一になっています。
compatibleの中身だけを変更し、それに合った別の（元々あった）ドライバと関連付けると認識されるので、デバイスツリーは間違っていないと思っています。

このとき、init関数やprobe関数が呼ばれもしないのが何故なのかがわかりません。
カーネルがinit関数、probe関数を呼ばない要因など、ヒントになりそうなことがありましたらご教示いただけたらと思います。
よろしくお願いします。

Comments

[退会済みユーザー]

よろしければ状況の明確化のため教えてください。

> ちなみにmodprobeを使うと、正しく認識されているようです（lsmodで見ただけですが）。

modprobeコマンドを実行すると、意図した(自作の)ドライバをロードできており、
かつprintkの表示もdmesgで確認できた、ということでしょうか？

> compatibleの中身だけを変更し、それに合った別の（元々あった）ドライバと関連付けると認識されるので、デバイスツリーは間違っていないと思っています。

デバイスツリーのcompatibleを既存のドライバと関連づけると、OS起動時にドライバが自動でロードされ、dmesgでprintkの表示を確認できた。しかし、compatibleを自作のドライバに関連づけた場合は、OS起動時に自動でロードされない(lsmodでドライバが表示されず、printkが走った形跡が無いのでinit,probeが呼ばれていない)。ということでしょうか？

[hero1000]

>> ちなみにmodprobeを使うと、正しく認識されているようです（lsmodで見ただけですが）。
>modprobeコマンドを実行すると、意図した(自作の)ドライバをロードできており、
>かつprintkの表示もdmesgで確認できた、ということでしょうか？
はい、そうです。

>デバイスツリーのcompatibleを既存のドライバと関連づけると、OS起動時にドライバが自動でロードさ>れ、dmesgでprintkの表示を確認できた。しかし、compatibleを自作のドライバに関連づけた場合は、>OS起動時に自動でロードされない(lsmodでドライバが表示されず、printkが走った形跡が無いので>init,probeが呼ばれていない)。ということでしょうか？
はい、その通りです。

Answer 1

自己解決しました。

まずspi.cとspidev.cはどうやら必須らしく、デバイスツリーではspiにspi.c、その下に子としてspidev.cをぶら下げる必要があるようです。
私の自作ドライバはspidev.cのさらに子のノードにぶら下げることで認識されるようになりました。

ただ、spidev.cと私のドライバの動作は似たようなもの（もともと入れ替えるつもりだった）なので、メカニズムとしてははっきりしない感じ（一番嫌なやつですね）です。