读取设备硬件寄存器

Question

I am attempting to create a device driver, albeit a naïvely simple one, which simply reads the status of a hardware register representing a dip switch. Very new at this and I am rather unsure of where to find adequate resources on the topic. Would be desirable to expose the data in sysfs.

DTS:

switches@c1000000 {
      compatible = "test, test-switches";
      label = "security_switch";
      reg = c1000000;
      mask = 0x1000;
      status = "okay";
    };

Driver:

#include <linux/module.h>
#include <linux/init.h>
#include <linux/mod_devicetable.h>
#include <linux/property.h>
#include <linux/platform_device.h>
#include <linux/of_device.h>
#include <linux/regmap.h>

/* Declare the probe and remove functions */
static int dt_probe(struct platform_device *pdev);
static int dt_remove(struct platform_device *pdev);
/* Declare the read switch function */
int read_switch(struct platform_device *pdev);


int read_switch(struct platform_device *pdev)
{
    static void *reg_data;
    int ret;
    unsigned int adr_reg, bit_mask;
    struct device *dev = &pdev->dev;

    ret = device_property_read_u32(dev, "reg", &adr_reg);
    if(ret) {
        printk("Error! Could not read 'reg'\n");
        return -1;
    }
    printk("Reg read as - %d\n", adr_reg);
    ret = device_property_read_u32(dev, "mask", &bit_mask);
    if(ret) {
        printk("Error! Could not read 'mask'\n");
        return -1;
    }
    printk("Mask read as - %d\n", bit_mask);
    reg_data = ioremap(adr_reg, bit_mask);
    printk("Value @%d", adr_reg);
    printk("-%d ", bit_mask);
    printk(": %d\n", ioread32(reg_data));
    iounmap(reg_data);
    return 0;
}

/**
 * @brief This structure is used to match the DTS entry
 */

static const struct of_device_id switch_driver_ids[] = {
    {
        .compatible = "test,test-switches",
    }, {}
};
MODULE_DEVICE_TABLE(of, switch_driver_ids);

/**
 * @brief Platform Driver definition including functions used for adding, removing and probing 
 * the device
 */
static struct platform_driver switch_driver = {
    .probe = dt_probe,
    .remove = dt_remove,
    .driver = {
        .name = "switch_device_driver",
        .of_match_table = switch_driver_ids,
    },
};

/**
 * @brief This function is called loading the driver 
 */
static int dt_probe(struct platform_device *pdev) {
    struct device *dev = &pdev->dev;
    int ret;
    const char *label;
    const char *status;
    unsigned int reg;

    printk("dt_probe - Probing function!\n");

    /* Check for device properties */
    if(!device_property_present(dev, "label")) {
        printk("dt_probe - Error! Device property 'label' not found!\n");
        return -1;
    }
    printk("dt_probe - Error! Device property 'label' found!\n");

    if(!device_property_present(dev, "status")) {
        printk("dt_probe - Error! Device property 'status' not found!\n");
        return -1;
    }
    printk("dt_probe - Error! Device property 'status' found!\n");

    
    if(!device_property_present(dev, "reg")) {
        printk("dt_probe - Error! Device property 'reg' not found!\n");
        return -1;
    }
    printk("dt_probe - Error! Device property 'reg' found!\n");


    /* Read device properties */
    ret = device_property_read_string(dev, "label", &label);
    if(ret) {
        printk("dt_probe - Error! Could not read 'label'\n");
        return -1;
    }
    printk("dt_probe - label: %s\n", label);
    ret = device_property_read_string(dev, "status", &status);
    if(ret) {
        printk("dt_probe - Error! Could not read 'status'\n");
        return -1;
    }
    printk("dt_probe - status: %s\n", status);
    ret = device_property_read_u32(dev, "reg", &reg);
    if(ret) {
        printk("dt_probe - Error! Could not read 'reg'\n");
        return -1;
    }
    printk("dt_probe - reg: %d\n", reg);

    read_switch(pdev);

    return 0;
}

/**
 * @brief This function is called unloading the driver 
 */
static int dt_remove(struct platform_device *pdev) {
    printk("dt_probe - Removing driver\n");
    return 0;
}

/**
 * @brief This function is called when the module is loaded into the kernel
 */
static int __init init_drv(void) {
    printk("dt_probe - Loading the driver...\n");
    if(platform_driver_register(&switch_driver)) {
        printk("dt_probe - Error! Could not load driver\n");
        return -1;
    }
    return 0;
}

/**
 * @brief This function is called when the module is removed from the kernel
 */
static void __exit exit_drv(void) {
    printk("dt_probe - Unload driver");
    platform_driver_unregister(&switch_driver);
}

module_init(init_drv);
module_exit(exit_drv);

Answer 1

There's basic documentation on sysfs here:
https://docs.kernel.org/filesystems/sysfs.html

With more info in include/linux/sysfs.h and include/linux/device.h.

Generally speaking though: best way to learn this stuff is read kernel docs (Documentation folder under kernel source tree), Kernel source itself, mailing lists & other well-established/written mainline drivers.

This used to be a decent primer on device drivers, it's very dated at this point, but some concepts may still apply: https://lwn.net/Kernel/LDD3/

Not sure I follow how a DIP switch get's "mapped" to a particular register. If this is GPIO pins on your SOC, then the -easy- way to get sysfs access is to use GPIO via sysfs, though it can be tricky sorting out pin numbers depending on your platform.

That said, if this really does need it's own driver--then usually you'll want to use DEVICE_ATTR family of macros to define your attribute and then either sysfs_create_group / sysfs_remove_group or sysfs_add_file / sysfs_remove_file to register/unregister in your probe / remove .