一：GPIO
//dtsi
device {
rst-gpio = <&tlmm 67 0x00>；
};
// sample code
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/of.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
void device_probe(struct platform_device *pdev)
{
struct device *dev;
struct device_node *np;
int rst_gpio;
int rc;
probe:
dev = &pdev->dev;
np = &pdev->dev.of_node;
//dev = &client->dev;
//np = client->dev.of_node; // i2c
rst_gpio = of_get_named_gpio(np, "rst-gpio", 0);
//rst_gpio = of_get_named_gpio_flags(np, "rst-gpio", 0, &flags);
init:
if (gpio_is_valid(rst_gpio)) {
rc = devm_gpio_request_one(dev, pdata->enable_gpio,
GPIOF_OUT_INIT_LOW, "xxx_reset");
if (rc < 0) {
pr_err("rst gpio request failed\n");
}
}
use:
if (gpio_is_valid(rst_gpio)) {
gpio_set_value(rst_gpio, 0);
usleep_range(1000, 2000); /* Keep enable down at least 1ms */
gpio_set_value(rst_gpio, 1);
usleep_range(500, 1000); /* #include <linux/delay.h> */
}
deinit:
if (gpio_is_valid(rst_gpio)) {
gpio_set_value(rst_gpio, 0);
}
}
//API
int devm_gpio_request(struct device *dev, unsigned gpio, const char *label);
int devm_gpio_request_one(struct device *dev, unsigned gpio, unsigned long flags, const char *label);
int gpio_get_value(unsigned int gpio);
void gpio_set_value(unsigned int gpio, int value);
int gpio_direction_input(unsigned gpio);
int gpio_direction_output(unsigned gpio, int value);
int gpio_get_value_cansleep(unsigned gpio);
void gpio_set_value_cansleep(unsigned gpio, int value);
bool gpio_is_valid(int number);
int gpio_to_irq(unsigned int gpio);
# 使用需要显示free资源
int gpio_request(unsigned gpio, const char *label);
int gpio_request_one(unsigned gpio, unsigned long flags, const char *label);
int gpio_free(unsigned gpio);
int gpio_request_array(const struct gpio *array, size_t num);
void gpio_free_array(const struct gpio *array, size_t num);
二：IRQ
//dtsi
device {
qcom,platform-te-gpio = <&tlmm 23 0>;
}
// sample code
#include <linux/interrupt.h>
static irqreturn_t dsi_display_panel_te_irq_handler(int irq, void *data)
{
struct dsi_display *display = (struct dsi_display *)data;
...
...
return IRQ_HANDLED;
}
void device_irq_init(struct platform_device *pdev)
{
struct device *dev;
struct device_node *np;
int disp_te_gpio;
unsigned int te_irq;
int flags;
int rc;
dev = &pdev->dev;
np = = pdev->dev.of_node;
disp_te_gpio = of_get_named_gpio(np,
"qcom,platform-te-gpio", 0);
//disp_te_gpio = of_get_named_gpio_flags(np, "rst-gpio", 0, &flags);
if (!gpio_is_valid(disp_te_gpio)) {
rc = -EINVAL;
goto error;
}
rc = devm_gpio_request_one(dev, pdata->enable_gpio, GPIOF_IN, "xxx_irq");
if (rc < 0) {
pr_err("rst gpio request failed\n");
}
te_irq = gpio_to_irq(disp_te_gpio);
rc = devm_request_irq(dev, te_irq, dsi_display_panel_te_irq_handler,
IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
"TE_GPIO", display);
error:
return;
}
//API
disable_irq(te_irq);
enable_irq(te_irq);
# handler:上半部处理函数，thread_fn:下半部处理函数
int devm_request_threaded_irq(struct device *dev, unsigned int irq,
irq_handler_t handler, irq_handler_t thread_fn,
unsigned long irqflags, const char *devname,
void *dev_id);
三：regulator
// dtsi
device {
vdd-supply = <&pm8350_l6>;
}
// sample code
#include <linux/regulator/consumer.h>
void device_regulator_sample(struct platform_device *pdev)
{
struct device *dev;
struct regulator *vdd_reg;
int ret;
dev = &pdev->dev;
vdd_reg = devm_regulator_get(dev, "vdd");
if (IS_ERR(vdd_reg)) {
ret = PTR_ERR(vdd_reg);
pr_err("Failed to get vdd regulator: %d\n", ret);
//return ret;
}
// enable
if (vdd_reg && !regulator_is_enabled(vdd_reg)) {
ret = regulator_enable(axera_sdio->dvdd3_3);
if (ret < 0) {
pr_err("Couldn't enable vdd_reg regulator ret=%d\n",ret);
}
}
// disbale
if (vdd_reg && regulator_is_enabled(vdd_reg)) {
ret = regulator_disable(vdd_reg);
if (ret < 0) {
pr_err("Couldn't disable vdd_reg regulator ret=%d\n",ret);
}
}
}
//API
int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV);
四：CLK
//dtsi
device {
clock-names = "bb_clk3";
clocks = <&clock_rpmh RPMH_LN_BB_CLK3>;
}
//sample code
#include <linux/clk.h>
void device_clk_init(struct platform_device *pdev)
{
struct device *dev;
struct clk *bb_clk;
int ret;
dev = &pdev->dev;
bb_clk = devm_clk_get(dev, "bb_clk3");
if (IS_ERR(bb_clk)) {
if (PTR_ERR(bb_clk) != -EPROBE_DEFER)
pr_err("Unable to get bb_clk3 clock\n");
return;
}
ret = clk_prepare_enable(bb_clk);
if (ret)
pr_err("enable bb_clk failed\n");
ret = clk_disable_unprepare(bb_clk);
if (ret)
pr_err("disable bb_clk failed\n");
}
//API
int clk_set_rate(struct clk *clk, unsigned long rate);
unsigned long clk_get_rate(struct clk *clk);
五：debugfs
// sample code
#include <linux/debugfs.h>
static int cam_ife_set_csid_debug(void *data, u64 val)
{
g_ife_hw_mgr.debug_cfg.csid_debug = val;
CAM_DBG(CAM_ISP, "Set CSID Debug value :%lld", val);
return 0;
}
static int cam_ife_get_csid_debug(void *data, u64 *val)
{
*val = g_ife_hw_mgr.debug_cfg.csid_debug;
CAM_DBG(CAM_ISP, "Get CSID Debug value :%lld",
g_ife_hw_mgr.debug_cfg.csid_debug);
return 0;
}
DEFINE_SIMPLE_ATTRIBUTE(cam_ife_csid_debug,
cam_ife_get_csid_debug,
cam_ife_set_csid_debug, "%llu\n");
static int cam_ife_hw_mgr_debug_register(void)
{
int rc = 0;
struct dentry *dbgfileptr = NULL;
dbgfileptr = debugfs_create_dir("camera_ife", NULL);
if (!dbgfileptr) {
CAM_ERR(CAM_ISP,"DebugFS could not create directory!");
rc = -ENOENT;
goto end;
}
/* Store parent inode for cleanup in caller */
g_ife_hw_mgr.debug_cfg.dentry = dbgfileptr;
dbgfileptr = debugfs_create_file("ife_csid_debug", 0644,
g_ife_hw_mgr.debug_cfg.dentry, NULL, &cam_ife_csid_debug);
dbgfileptr = debugfs_create_u32("enable_recovery", 0644,
g_ife_hw_mgr.debug_cfg.dentry,
&g_ife_hw_mgr.debug_cfg.enable_recovery);
dbgfileptr = debugfs_create_bool("enable_req_dump", 0644,
g_ife_hw_mgr.debug_cfg.dentry,
&g_ife_hw_mgr.debug_cfg.enable_req_dump);
if (IS_ERR(dbgfileptr)) {
if (PTR_ERR(dbgfileptr) == -ENODEV)
CAM_WARN(CAM_ISP, "DebugFS not enabled in kernel!");
else
rc = PTR_ERR(dbgfileptr);
}
end:
g_ife_hw_mgr.debug_cfg.enable_recovery = 0;
return rc;
}
static int cam_ife_hw_mgr_debug_deinit(void)
{
debugfs_remove_recursive(g_ife_hw_mgr.debug_cfg.dentry);
g_ife_hw_mgr.debug_cfg.dentry = NULL;
}
六：DEVICE_ATTR
/示例：
static ssize_t show_test(struct device *dev, struct device_attribute *attr,
char *buf)
{
return scnprintf(buf, PAGE_SIZE,
"#Write into test to start test sequence!#\n");
}
static ssize_t store_test(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
struct i2c_client *client;
int ret;
client = to_i2c_client(dev);
/*test */
ret = blinkm_test_run(client);
if (ret < 0)
return ret;
return count;
}
static DEVICE_ATTR(test, S_IRUGO | S_IWUSR, show_test, store_test);
static struct attribute *blinkm_attrs[] = {
//&dev_attr_red.attr,
//&dev_attr_green.attr,
//&dev_attr_blue.attr,
//&dev_attr_test.attr,
NULL,
};
probe:
/* Register sysfs hooks */
err = sysfs_create_group(&client->dev.kobj, &blinkm_group);
if (err < 0) {
dev_err(&client->dev, "couldn't register sysfs group\n");
goto exit;
}
remove:
sysfs_remove_group(&client->dev.kobj, &blinkm_group);
//sysfs.txt
结构体:
struct device_attribute {
struct attribute attr;
ssize_t (*show)(struct device *dev, struct device_attribute *attr,
char *buf);
ssize_t (*store)(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count);
};
声明:
DEVICE_ATTR(_name, _mode, _show, _store);
增/删属性:
int device_create_file(struct device *dev, const struct device_attribute *attr);
void device_remove_file(struct device *dev, const struct device_attribute * attr);
七：DRIVER_ATTR
// 示例1:
static ssize_t version_show(struct device_driver *driver, char *buf)
{
return snprintf(buf, PAGE_SIZE, "%s\n", ASD_DRIVER_VERSION);
}
static DRIVER_ATTR_RO(version);
static int sample_create_driver_attrs(struct device_driver *driver)
{
return driver_create_file(driver, &driver_attr_version);
}
static void sample_remove_driver_attrs(struct device_driver *driver)
{
driver_remove_file(driver, &driver_attr_version);
}
// 示例2:
static ssize_t debug_show(struct device_driver *dev, char *buf)
{
return snprintf(buf, PAGE_SIZE, "%s\n", debug_path);
}
static ssize_t debug_store(struct device_driver *dev, const char *buf,
size_t count)
{
strncpy(debug_path, buf, PATH_MAX);
return count;
}
static DRIVER_ATTR_RW(debug);
static int sample2_create_driver_attrs(struct device_driver *driver)
{
return driver_create_file(driver, &driver_attr_debug);
}
static void sample2_remove_driver_attrs(struct device_driver *driver)
{
driver_remove_file(driver, &driver_attr_debug);
}
//sysfs.txt
结构体:
struct driver_attribute {
struct attribute attr;
ssize_t (*show)(struct device_driver *, char * buf);
ssize_t (*store)(struct device_driver *, const char * buf,
size_t count);
};
声明:
DRIVER_ATTR(_name, _mode, _show, _store)
增/删属性：
int driver_create_file(struct device_driver *, const struct driver_attribute *);
void driver_remove_file(struct device_driver *, const struct driver_attribute *);
八：i2c driver
#include <linux/i2c.h>
#define SAMPLE_DRIVER_I2C "sample_devive_name"
/* Return negative errno else zero on success */
static int sample_write_byte(struct i2c_client *client, u8 addr, u8 val)
{
int rval;
rval = i2c_smbus_write_byte_data(client, addr, val);
if (rval < 0) {
LOG_ERROR("i2c write error, err %d\n", rval);
return rval;
}
LOG_DEBUG("write addr:0x%02x val:0x%02x ok\n", addr, val);
return 0;
}
/* Return negative errno else a data byte received from the device. */
static int sample_read_byte(struct i2c_client *client, u8 addr)
{
int rval;
rval = i2c_smbus_read_byte_data(client, addr);
if (rval < 0) {
LOG_ERROR("i2c read error, err %d\n", rval);
return rval;
}
LOG_DEBUG("read addr:0x%02x val:0x%02x ok\n", addr, rval);
return rval;
}
static int32_t sample_driver_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct customer_data *cust_data = NULL;
struct device *dev;
struct device_node *np;
int rc;
dev = &client->dev;
np = client->dev.of_node;
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
LOG_ERROR( "%s :: i2c_check_functionality failed",
client->name);
rc = -EFAULT;
return rc;
}
// alloc customer struct data
cust_data = kzalloc(sizeof(*customer_struct_data), GFP_KERNEL);
if (!cust_data)
return -ENOMEM;
i2c_set_clientdata(client, cust_data);
// TODO: parse dt
// TODO: init power, gpio, clk, irq
// TODO: register subsystem driver
return rc;
free_ctrl:
kfree(cust_data);
return rc;
}
static int32_t sample_driver_i2c_remove(struct i2c_client *client)
{
struct customer_data *cust_data =
i2c_get_clientdata(client);
if (!cust_data) {
LOG_ERROR("cust_data is NULL");
return -EINVAL;
}
// TODO : shutdown device
// TODO : unreister subsystem driver
// TODO : release resource
// TODO: Free Allocated Mem
kfree(cust_data);
return 0;
}
static const struct of_device_id sample_driver_dt_match[] = {
{.compatible = "vendor,device_name"},
{}
};
MODULE_DEVICE_TABLE(of, sample_driver_dt_match);
/* not use id_table match, use of_match_table */
//static const struct i2c_device_id i2c_id[] = {
// {SAMPLE_DRIVER_I2C, (kernel_ulong_t)NULL},
// { }
//};
static struct i2c_driver sample_driver_i2c = {
// .id_table = i2c_id,
.probe = sample_driver_i2c_probe,
.remove = sample_driver_i2c_remove,
.driver = {
.name = SAMPLE_DRIVER_I2C,
.of_match_table = sample_driver_dt_match,
},
};
module_i2c_driver(sample_driver_i2c);
MODULE_DESCRIPTION("sample_driver");
MODULE_LICENSE("GPL v2");
九：platform driver
#include <linux/platform_device.h>
static int32_t sample_driver_platform_probe(
struct platform_device *pdev)
{
struct customer_data *cust_data = NULL;
struct device *dev;
struct device_node *np;
int rc;
dev = &pdev->dev;
np = pdev->dev.of_node;
LOG_FUNC_ENTER();
// TODO: parse dt
// TODO: init power, gpio, clk, irq
// TODO: register subsystem driver
// TODO: create driver attr, debufs
return rc;
}
static int32_t sample_platform_remove(
struct platform_device *pdev)
{
LOG_FUNC_ENTER();
// TODO : shutdown device
// TODO : unreister subsystem driver
// TODO : release resource
// TODO: Free Allocated Mem
return 0;
}
static const struct of_device_id sample_driver_dt_match[] = {
{.compatible = "vendor,device_name"},
{}
};
MODULE_DEVICE_TABLE(of, sample_driver_dt_match);
struct platform_driver sample_platform_driver = {
.probe = sample_driver_platform_probe,
.driver = {
.name = "qcom,actuator",
.owner = THIS_MODULE,
.of_match_table = sample_driver_dt_match,
.suppress_bind_attrs = true,
},
.remove = sample_platform_remove,
};
static int __init sample_driver_init(void)
{
int32_t rc = 0;
rc = platform_driver_register(&sample_platform_driver);
if (rc < 0) {
LOG_ERROR(
"platform_driver_register failed rc = %d", rc);
return rc;
}
return rc;
}
module_init(sample_driver_init);
static void __exit sample_driver_exit(void)
{
platform_driver_unregister(&sample_platform_driver);
}
module_exit(sample_driver_exit);
MODULE_DESCRIPTION("sample_driver");
MODULE_LICENSE("GPL v2");
十：log
#define LOG_TAG "[sample_driver]"
#define LOG_DEBUG_EN (1)
#if LOG_DEBUG_EN
#define LOG_DEBUG(fmt, args...) do { \
printk(LOG_TAG "D %s line %d:"fmt"\n", __func__, __LINE__, ##args); \
} while (0)
#define LOG_FUNC_ENTER() do { \
printk(LOG_TAG "D %s line %d: Enter\n", __func__, __LINE__); \
} while (0)
#define LOG_FUNC_EXIT() do { \
printk(LOG_TAG "D %s line %d: Exit\n", __func__, __LINE__); \
} while (0)
#else /* #if LOG_DEBUG_EN*/
#define LOG_DEBUG(fmt, args...)
#define LOG_FUNC_ENTER()
#define LOG_FUNC_EXIT()
#endif
#define LOG_INFO(fmt, args...) do { \
printk(KERN_INFO LOG_TAG "I %s line %d:"fmt"\n", __func__, __LINE__, ##args); \
} while (0)
#define LOG_ERROR(fmt, args...) do { \
printk(KERN_ERR LOG_TAG "E %s line %d:"fmt"\n", __func__, __LINE__, ##args); \
} while (0)
十一：完成量
#include <linux/completion.h>
//struct completion preisp_wp_comp;
//init_completion(&preisp_wp_comp);
static DECLARE_COMPLETION(preisp_wp_comp);
wait_for_completion(&preisp_wp_comp);
//if (wait_for_completion_timeout(&preisp_wp_comp, msecs_to_jiffies(2000)) == 0)
// pr_err("%s: timeout! fail wake up preisp\n", __func__);
complete(&preisp_wp_comp);
