/******************************************************************************
* am335x backlight
* 本文主要分析TI的am335x处理器，backlight注册过程。
*
* Tony Liu, 2016-4-21, Shenzhen
*******************************************************************************/
kernel/arcm/arm/omap2/board-am335xevm.c
static int __init backlight_init(void)
{
int index = 0;
#if defined(CONFIG_OK335XD)
index = 0;
am335x_backlight.dev.platform_data = &am335x_backlight_data0; ------+
#elif defined(CONFIG_OK335XS) |
index = 2; |
am335x_backlight.dev.platform_data = &am335x_backlight_data2; |
#endif |
|
am33xx_register_ecap(index, &pwm_pdata[index]); -------------------|----+
platform_device_register(&am335x_backlight); | |
| | |
return 0; | | |
} +---------------------------------|-+ |
late_initcall(backlight_init); | | |
| | |
| | |
static struct platform_pwm_backlight_data am335x_backlight_data0 = { <--+ | |
.pwm_id = "ecap.0", | |
.ch = -1, | |
.lth_brightness = 21, | |
.max_brightness = AM335X_BACKLIGHT_MAX_BRIGHTNESS, | |
.dft_brightness = AM335X_BACKLIGHT_DEFAULT_BRIGHTNESS, | |
.pwm_period_ns = AM335X_PWM_PERIOD_NANO_SECONDS, | |
}; | |
| |
#define AM335X_BACKLIGHT_MAX_BRIGHTNESS 100 | |
#define AM335X_BACKLIGHT_DEFAULT_BRIGHTNESS 60 | |
| |
#define AM335X_PWM_PERIOD_NANO_SECONDS (5000 * 10 * 100) | |
| |
static struct platform_device am335x_backlight = { <---------------+ |
.name = "pwm-backlight", |
.id = -1, |
}; |
|
#define PWM_STR_LEN 10 |
int __init am33xx_register_ecap(int id, struct pwmss_platform_data *pdata) <-+
{
struct platform_device *pdev;
struct omap_hwmod *oh;
char *oh_name = "ecap";
char dev_name[PWM_STR_LEN];
sprintf(dev_name, "ecap.%d", id);
//查找链表中是否有同名的设备的寄存器信息
oh = omap_hwmod_lookup(dev_name); -------------------+
if (!oh) { |
pr_err("Could not look up %s hwmod\n", dev_name); |
return -ENODEV; |
} |
//注册设备 |
pdev = omap_device_build(oh_name, id, oh, pdata, ----------|---+
sizeof(*pdata), NULL, 0, 0); | |
| |
if (IS_ERR(pdev)) { | |
WARN(1, "Can't build omap_device for %s:%s.\n", | |
dev_name, oh->name); | |
return PTR_ERR(pdev); | |
} | |
return 0; | |
} | |
//查找设备注册时的链表中是否有设备 | |
struct omap_hwmod *omap_hwmod_lookup(const char *name) <-------+ |
{ |
struct omap_hwmod *oh; |
|
if (!name) |
return NULL; |
|
oh = _lookup(name); ----+ |
| |
return oh; | |
} | |
V |
static struct omap_hwmod *_lookup(const char *name) |
{ |
struct omap_hwmod *oh, *temp_oh; |
|
oh = NULL; |
//查找 |
list_for_each_entry(temp_oh, &omap_hwmod_list, node) { |
if (!strcmp(name, temp_oh->name)) { |
oh = temp_oh; |
break; |
} |
} +-----------------------------------------+
|
return oh; |
} |
V
struct platform_device *omap_device_build(const char *pdev_name, int pdev_id,
struct omap_hwmod *oh, void *pdata,
int pdata_len,
struct omap_device_pm_latency *pm_lats,
int pm_lats_cnt, int is_early_device)
{
struct omap_hwmod *ohs[] = { oh };
if (!oh)
return ERR_PTR(-EINVAL);
return omap_device_build_ss(pdev_name, pdev_id, ohs, 1, pdata,
pdata_len, pm_lats, pm_lats_cnt,
is_early_device);
} |
V
struct platform_device *omap_device_build_ss(const char *pdev_name, int pdev_id,
struct omap_hwmod **ohs, int oh_cnt,
void *pdata, int pdata_len,
struct omap_device_pm_latency *pm_lats,
int pm_lats_cnt, int is_early_device)
{
int ret = -ENOMEM;
struct platform_device *pdev;
struct omap_device *od;
if (!ohs || oh_cnt == 0 || !pdev_name)
return ERR_PTR(-EINVAL);
if (!pdata && pdata_len > 0)
return ERR_PTR(-EINVAL);
pdev = platform_device_alloc(pdev_name, pdev_id);
if (!pdev) {
ret = -ENOMEM;
goto odbs_exit;
}
/* Set the dev_name early to allow dev_xxx in omap_device_alloc */
if (pdev->id != -1)
dev_set_name(&pdev->dev, "%s.%d", pdev->name, pdev->id);
else
dev_set_name(&pdev->dev, "%s", pdev->name);
od = omap_device_alloc(pdev, ohs, oh_cnt, pm_lats, pm_lats_cnt);
if (!od)
goto odbs_exit1;
ret = platform_device_add_data(pdev, pdata, pdata_len);
if (ret)
goto odbs_exit2;
if (is_early_device)
ret = omap_early_device_register(pdev);
else
ret = omap_device_register(pdev);
if (ret)
goto odbs_exit2;
return pdev;
odbs_exit2:
omap_device_delete(od);
odbs_exit1:
platform_device_put(pdev);
odbs_exit:
pr_err("omap_device: %s: build failed (%d)\n", pdev_name, ret);
return ERR_PTR(ret);
}
//驱动注册
kernel/driver/video/backlight/pwm_bl.c
static int __init pwm_backlight_init(void)
{
return platform_driver_register(&pwm_backlight_driver);
} |
V
static struct platform_driver pwm_backlight_driver = {
.driver = {
.name = "pwm-backlight",
.owner = THIS_MODULE,
},
.probe = pwm_backlight_probe, --------------+
.remove = pwm_backlight_remove, |
.suspend = pwm_backlight_suspend, |
.resume = pwm_backlight_resume, |
}; |
|
static int pwm_backlight_probe(struct platform_device *pdev) <---+
{
struct backlight_properties props;
struct platform_pwm_backlight_data *data = pdev->dev.platform_data;
struct backlight_device *bl;
struct pwm_bl_data *pb;
int ret;
if (!data) {
dev_err(&pdev->dev, "failed to find platform data\n");
return -EINVAL;
}
if (data->init) {
ret = data->init(&pdev->dev);
if (ret < 0)
return ret;
}
pb = kzalloc(sizeof(*pb), GFP_KERNEL);
if (!pb) {
dev_err(&pdev->dev, "no memory for state\n");
ret = -ENOMEM;
goto err_alloc;
}
pb->period = data->pwm_period_ns;
pb->notify = data->notify;
pb->notify_after = data->notify_after;
pb->check_fb = data->check_fb;
pb->lth_brightness = data->lth_brightness *
(data->pwm_period_ns / data->max_brightness);
pb->dev = &pdev->dev;
pb->pwm = pwm_request(data->pwm_id, data->ch, "backlight");
if (IS_ERR(pb->pwm)) {
dev_err(&pdev->dev, "unable to request PWM for backlight\n");
ret = PTR_ERR(pb->pwm);
goto err_pwm;
} else
dev_dbg(&pdev->dev, "got pwm for backlight\n");
memset(&props, 0, sizeof(struct backlight_properties));
props.type = BACKLIGHT_RAW;
props.max_brightness = data->max_brightness;
bl = backlight_device_register(dev_name(&pdev->dev), &pdev->dev, pb, ---+
&pwm_backlight_ops, &props); |
----------------------------------------------|--+
if (IS_ERR(bl)) { | |
dev_err(&pdev->dev, "failed to register backlight\n"); | |
ret = PTR_ERR(bl); | |
goto err_bl; | |
} | |
| |
bl->props.brightness = data->dft_brightness; | |
backlight_update_status(bl); | |
| |
platform_set_drvdata(pdev, bl); | |
return 0; | |
| |
err_bl: | |
pwm_release(pb->pwm); | |
err_pwm: | |
kfree(pb); | |
err_alloc: | |
if (data->exit) | |
data->exit(&pdev->dev); | |
return ret; | |
} | |
| |
struct backlight_device *backlight_device_register(const char *name, <-----+ |
struct device *parent, void *devdata, const struct backlight_ops *ops, |
const struct backlight_properties *props) |
{ |
struct backlight_device *new_bd; |
int rc; |
|
pr_debug("backlight_device_register: name=%s\n", name); |
|
new_bd = kzalloc(sizeof(struct backlight_device), GFP_KERNEL); |
if (!new_bd) |
return ERR_PTR(-ENOMEM); |
|
mutex_init(&new_bd->update_lock); |
mutex_init(&new_bd->ops_lock); |
|
new_bd->dev.class = backlight_class; |
new_bd->dev.parent = parent; |
new_bd->dev.release = bl_device_release; |
dev_set_name(&new_bd->dev, name); |
dev_set_drvdata(&new_bd->dev, devdata); |
|
/* Set default properties */ |
if (props) { |
memcpy(&new_bd->props, props, |
sizeof(struct backlight_properties)); |
if (props->type <= 0 || props->type >= BACKLIGHT_TYPE_MAX) { |
WARN(1, "%s: invalid backlight type", name); |
new_bd->props.type = BACKLIGHT_RAW; |
} |
} else { |
new_bd->props.type = BACKLIGHT_RAW; |
} |
|
rc = device_register(&new_bd->dev); |
if (rc) { |
kfree(new_bd); |
return ERR_PTR(rc); |
} |
|
rc = backlight_register_fb(new_bd); |
if (rc) { |
device_unregister(&new_bd->dev); |
return ERR_PTR(rc); |
} |
|
new_bd->ops = ops; |
|
#ifdef CONFIG_PMAC_BACKLIGHT |
mutex_lock(&pmac_backlight_mutex); |
if (!pmac_backlight) |
pmac_backlight = new_bd; |
mutex_unlock(&pmac_backlight_mutex); |
#endif |
|
return new_bd; |
} |
|
static const struct backlight_ops pwm_backlight_ops = { <---------------+
.update_status = pwm_backlight_update_status, -----------+
.get_brightness = pwm_backlight_get_brightness, |
.check_fb = pwm_backlight_check_fb, |
}; |
//每次设置pwm都会调用下面的函数 |
static int pwm_backlight_update_status(struct backlight_device *bl) <-----+
{
struct pwm_bl_data *pb = dev_get_drvdata(&bl->dev);
int brightness = bl->props.brightness;
int max = bl->props.max_brightness;
if (bl->props.power != FB_BLANK_UNBLANK)
brightness = 0;
if (bl->props.fb_blank != FB_BLANK_UNBLANK)
brightness = 0;
if (pb->notify)
brightness = pb->notify(pb->dev, brightness);
if (brightness == 0) {
pwm_set_duty_ns(pb->pwm, 0);
pwm_stop(pb->pwm);
} else {
brightness = pb->lth_brightness +
(brightness * (pb->period - pb->lth_brightness) / max);
pwm_set_period_ns(pb->pwm, pb->period);
pwm_set_duty_ns(pb->pwm, brightness);
pwm_start(pb->pwm);
}
if (pb->notify_after)
pb->notify_after(pb->dev, brightness);
return 0;
}
