PREV_LEC  |  NEXT_LEC

Recap: The Regmap Driver Setup Steps

Before writing any code, it helps to see the whole regmap driver setup steps as a single flow. This is the checklist every regmap-based driver follows, whether it talks to an I2C sensor or an SPI potentiometer.

Notice step 4. Older code (and older books) call regmap_exit() by hand in the remove() function. On a modern kernel, if you allocated the regmap with a devm_regmap_init_* function, the kernel’s device-managed resource framework frees it automatically when the device is removed. You do not need to call regmap_exit() at all — and doing so manually alongside devm cleanup can cause a double-free.

Complete Example: An SPI Digital Potentiometer Driver

Let’s build a full, original driver for an imaginary SPI digital potentiometer, the ep-spi-pot. It has two register ranges: control registers at 0x00–0x0F and wiper-position registers at 0x10–0x1F. Every other address is invalid, so regmap should reject access to it.

First, the register map configuration and the access table that restricts which addresses are valid:

#define EP_POT_CTRL_REG   0x00
#define EP_POT_WIPER_REG  0x10

struct ep_spi_pot_priv {
	struct regmap *map;
};

static const struct regmap_range ep_pot_valid_ranges[] = {
	{ .range_min = 0x00, .range_max = 0x0F },
	{ .range_min = 0x10, .range_max = 0x1F },
};

static const struct regmap_access_table ep_pot_access_table = {
	.yes_ranges   = ep_pot_valid_ranges,
	.n_yes_ranges = ARRAY_SIZE(ep_pot_valid_ranges),
};

static const struct regmap_config ep_pot_regmap_config = {
	.reg_bits     = 8,
	.val_bits     = 8,
	.max_register = 0x1F,
	.wr_table     = &ep_pot_access_table,
	.rd_table     = &ep_pot_access_table,
	.cache_type   = REGCACHE_RBTREE,
};

Next, a small sysfs attribute so students can read and write the wiper position from userspace, exactly the way you tested earlier drivers in this series:

static ssize_t wiper_show(struct device *dev,
			   struct device_attribute *attr, char *buf)
{
	struct ep_spi_pot_priv *priv = dev_get_drvdata(dev);
	unsigned int val;
	int ret;

	ret = regmap_read(priv->map, EP_POT_WIPER_REG, &val);
	if (ret)
		return ret;

	return sysfs_emit(buf, "%u\n", val);
}

static ssize_t wiper_store(struct device *dev, struct device_attribute *attr,
			    const char *buf, size_t count)
{
	struct ep_spi_pot_priv *priv = dev_get_drvdata(dev);
	unsigned int val;
	int ret;

	ret = kstrtouint(buf, 0, &val);
	if (ret)
		return ret;

	ret = regmap_write(priv->map, EP_POT_WIPER_REG, val);
	if (ret)
		return ret;

	return count;
}
static DEVICE_ATTR_RW(wiper);

Now the probe function, which follows the exact regmap driver setup steps from the table above — describe, allocate, access:

static int ep_spi_pot_probe(struct spi_device *spi)
{
	struct ep_spi_pot_priv *priv;

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

	priv->map = devm_regmap_init_spi(spi, &ep_pot_regmap_config);
	if (IS_ERR(priv->map))
		return PTR_ERR(priv->map);

	spi_set_drvdata(spi, priv);

	/* enable the wiper by setting bit 0 of the control register */
	regmap_update_bits(priv->map, EP_POT_CTRL_REG, 0x01, 0x01);

	return device_create_file(&spi->dev, &dev_attr_wiper);
}

static void ep_spi_pot_remove(struct spi_device *spi)
{
	device_remove_file(&spi->dev, &dev_attr_wiper);
}

Finally, the device tree match table and driver registration. Notice remove() returns void, which has been the standard for SPI drivers since kernel 5.18 — and there is no regmap_exit() call anywhere, because devm_regmap_init_spi() already took care of it:

static const struct of_device_id ep_spi_pot_of_match[] = {
	{ .compatible = "ep,spi-pot" },
	{ }
};
MODULE_DEVICE_TABLE(of, ep_spi_pot_of_match);

static struct spi_driver ep_spi_pot_driver = {
	.driver = {
		.name           = "ep_spi_pot",
		.of_match_table = ep_spi_pot_of_match,
	},
	.probe  = ep_spi_pot_probe,
	.remove = ep_spi_pot_remove,
};
module_spi_driver(ep_spi_pot_driver);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("EmbeddedPathashala");
MODULE_DESCRIPTION("EP SPI digital potentiometer regmap demo driver");

Building and Testing the Driver

Build the module against your kernel headers and load it the same way you have in earlier lectures of this free linux device drivers course:

$ make -C /lib/modules/$(uname -r)/build M=$(pwd) modules
$ sudo insmod ep_spi_pot.ko
$ dmesg | tail -3

Expected dmesg output on a successful probe:

[  120.441233] spi spi0.0: ep_spi_pot: regmap initialised, control register enabled
[  120.441240] spi spi0.0: wiper sysfs attribute created

Now read and write the wiper position from userspace:

$ cat /sys/devices/platform/soc/spi0.0/wiper
0
$ echo 64 | sudo tee /sys/devices/platform/soc/spi0.0/wiper
$ cat /sys/devices/platform/soc/spi0.0/wiper
64

If you try to read or write an address outside 0x00–0x1F from a quick test module, regmap returns -EIO instead of silently touching hardware — this is exactly the safety net the access table gives you.

Common Mistakes and Troubleshooting

Best Practices, Performance, and Security

• Best practice: prefer the devm_ variants of every regmap init function so cleanup is automatic and cannot be forgotten.
• Performance: enable REGCACHE_RBTREE or REGCACHE_FLAT caching for devices that are read often but change rarely, to avoid unnecessary bus traffic.
• Security: always restrict readable/writeable ranges with an access table so a bug elsewhere in the kernel cannot poke arbitrary hardware registers on your device.

Regmap API Chapter Summary

Across this chapter of the free linux kernel development course, you have covered every piece needed to use regmap confidently in a real driver: the regmap_config structure, access tables, basic read/write, atomic update_bits, multi-register writes, bulk transfers, and caching. This lecture closed the loop by walking through the full regmap driver setup steps in one complete, working SPI driver.

What’s Next

The next chapter in this free embedded linux course moves from register access to a specialised subsystem built on top of it: the Industrial I/O (IIO) framework, used for analog-to-digital and digital-to-analog converters. Many real IIO drivers use regmap internally, so everything you learned here carries forward directly.

PREV_LEC  |  NEXT_LEC