diff options
author | Linus Torvalds <torvalds@woody.linux-foundation.org> | 2007-02-20 13:17:32 -0500 |
---|---|---|
committer | Linus Torvalds <torvalds@woody.linux-foundation.org> | 2007-02-20 13:17:32 -0500 |
commit | a5527c6a586537c1af7ae6db30bb444ee4abdfe8 (patch) | |
tree | f0682de5c461c270f5f58b7304fd5ea5b5d6fb38 /drivers/video/backlight/lcd.c | |
parent | 4afffe5eabc4005674a1ef4f4c96f1ae9f4a979b (diff) | |
parent | 8f27489d1105c2386e6ed71c35e74e0e69603cbc (diff) |
Merge branch 'for-linus' of git://git.o-hand.com/linux-rpurdie-backlight
* 'for-linus' of git://git.o-hand.com/linux-rpurdie-backlight:
backlight: Remove bogus SYSFS dependency
backlight: simplify corgi_bl locking
backlight: Separate backlight properties from backlight ops pointers
backlight: Clean up pmac_backlight handling
backlight: Improve backlight selection for fbdev drivers
backlight: Rework backlight/fb interaction simplifying, lots
backlight: Remove unneeded backlight update_status calls
backlight: Remove uneeded update_status call from chipsfb.c
backlight/fbcon: Add FB_EVENT_CONBLANK
backlight: Fix Kconfig entries
backlight: Remove uneeded nvidia set_power calls
backlight: Convert semaphore -> mutex
backlight: Fix external uses of backlight internal semaphore
backlight: Minor code cleanups for hp680_bl.c
backlight: Minor code cleanups for corgi_bl.c
backlight: Remove excessive (un)likelys
backlight: Remove unneeded owner field
backlight: Fix error handling
backlight: Add Frontpath ProGear HX1050+ driver
backlight: Add maintainer entry
Diffstat (limited to 'drivers/video/backlight/lcd.c')
-rw-r--r-- | drivers/video/backlight/lcd.c | 83 |
1 files changed, 39 insertions, 44 deletions
diff --git a/drivers/video/backlight/lcd.c b/drivers/video/backlight/lcd.c index f6e041627edb..6ef8f0a7a137 100644 --- a/drivers/video/backlight/lcd.c +++ b/drivers/video/backlight/lcd.c | |||
@@ -31,11 +31,11 @@ static int fb_notifier_callback(struct notifier_block *self, | |||
31 | return 0; | 31 | return 0; |
32 | 32 | ||
33 | ld = container_of(self, struct lcd_device, fb_notif); | 33 | ld = container_of(self, struct lcd_device, fb_notif); |
34 | down(&ld->sem); | 34 | mutex_lock(&ld->ops_lock); |
35 | if (ld->props) | 35 | if (ld->ops) |
36 | if (!ld->props->check_fb || ld->props->check_fb(evdata->info)) | 36 | if (!ld->ops->check_fb || ld->ops->check_fb(evdata->info)) |
37 | ld->props->set_power(ld, *(int *)evdata->data); | 37 | ld->ops->set_power(ld, *(int *)evdata->data); |
38 | up(&ld->sem); | 38 | mutex_unlock(&ld->ops_lock); |
39 | return 0; | 39 | return 0; |
40 | } | 40 | } |
41 | 41 | ||
@@ -66,12 +66,12 @@ static ssize_t lcd_show_power(struct class_device *cdev, char *buf) | |||
66 | int rc; | 66 | int rc; |
67 | struct lcd_device *ld = to_lcd_device(cdev); | 67 | struct lcd_device *ld = to_lcd_device(cdev); |
68 | 68 | ||
69 | down(&ld->sem); | 69 | mutex_lock(&ld->ops_lock); |
70 | if (likely(ld->props && ld->props->get_power)) | 70 | if (ld->ops && ld->ops->get_power) |
71 | rc = sprintf(buf, "%d\n", ld->props->get_power(ld)); | 71 | rc = sprintf(buf, "%d\n", ld->ops->get_power(ld)); |
72 | else | 72 | else |
73 | rc = -ENXIO; | 73 | rc = -ENXIO; |
74 | up(&ld->sem); | 74 | mutex_unlock(&ld->ops_lock); |
75 | 75 | ||
76 | return rc; | 76 | return rc; |
77 | } | 77 | } |
@@ -89,13 +89,13 @@ static ssize_t lcd_store_power(struct class_device *cdev, const char *buf, size_ | |||
89 | if (size != count) | 89 | if (size != count) |
90 | return -EINVAL; | 90 | return -EINVAL; |
91 | 91 | ||
92 | down(&ld->sem); | 92 | mutex_lock(&ld->ops_lock); |
93 | if (likely(ld->props && ld->props->set_power)) { | 93 | if (ld->ops && ld->ops->set_power) { |
94 | pr_debug("lcd: set power to %d\n", power); | 94 | pr_debug("lcd: set power to %d\n", power); |
95 | ld->props->set_power(ld, power); | 95 | ld->ops->set_power(ld, power); |
96 | rc = count; | 96 | rc = count; |
97 | } | 97 | } |
98 | up(&ld->sem); | 98 | mutex_unlock(&ld->ops_lock); |
99 | 99 | ||
100 | return rc; | 100 | return rc; |
101 | } | 101 | } |
@@ -105,10 +105,10 @@ static ssize_t lcd_show_contrast(struct class_device *cdev, char *buf) | |||
105 | int rc = -ENXIO; | 105 | int rc = -ENXIO; |
106 | struct lcd_device *ld = to_lcd_device(cdev); | 106 | struct lcd_device *ld = to_lcd_device(cdev); |
107 | 107 | ||
108 | down(&ld->sem); | 108 | mutex_lock(&ld->ops_lock); |
109 | if (likely(ld->props && ld->props->get_contrast)) | 109 | if (ld->ops && ld->ops->get_contrast) |
110 | rc = sprintf(buf, "%d\n", ld->props->get_contrast(ld)); | 110 | rc = sprintf(buf, "%d\n", ld->ops->get_contrast(ld)); |
111 | up(&ld->sem); | 111 | mutex_unlock(&ld->ops_lock); |
112 | 112 | ||
113 | return rc; | 113 | return rc; |
114 | } | 114 | } |
@@ -126,28 +126,22 @@ static ssize_t lcd_store_contrast(struct class_device *cdev, const char *buf, si | |||
126 | if (size != count) | 126 | if (size != count) |
127 | return -EINVAL; | 127 | return -EINVAL; |
128 | 128 | ||
129 | down(&ld->sem); | 129 | mutex_lock(&ld->ops_lock); |
130 | if (likely(ld->props && ld->props->set_contrast)) { | 130 | if (ld->ops && ld->ops->set_contrast) { |
131 | pr_debug("lcd: set contrast to %d\n", contrast); | 131 | pr_debug("lcd: set contrast to %d\n", contrast); |
132 | ld->props->set_contrast(ld, contrast); | 132 | ld->ops->set_contrast(ld, contrast); |
133 | rc = count; | 133 | rc = count; |
134 | } | 134 | } |
135 | up(&ld->sem); | 135 | mutex_unlock(&ld->ops_lock); |
136 | 136 | ||
137 | return rc; | 137 | return rc; |
138 | } | 138 | } |
139 | 139 | ||
140 | static ssize_t lcd_show_max_contrast(struct class_device *cdev, char *buf) | 140 | static ssize_t lcd_show_max_contrast(struct class_device *cdev, char *buf) |
141 | { | 141 | { |
142 | int rc = -ENXIO; | ||
143 | struct lcd_device *ld = to_lcd_device(cdev); | 142 | struct lcd_device *ld = to_lcd_device(cdev); |
144 | 143 | ||
145 | down(&ld->sem); | 144 | return sprintf(buf, "%d\n", ld->props.max_contrast); |
146 | if (likely(ld->props)) | ||
147 | rc = sprintf(buf, "%d\n", ld->props->max_contrast); | ||
148 | up(&ld->sem); | ||
149 | |||
150 | return rc; | ||
151 | } | 145 | } |
152 | 146 | ||
153 | static void lcd_class_release(struct class_device *dev) | 147 | static void lcd_class_release(struct class_device *dev) |
@@ -180,45 +174,46 @@ static const struct class_device_attribute lcd_class_device_attributes[] = { | |||
180 | * respective framebuffer device). | 174 | * respective framebuffer device). |
181 | * @devdata: an optional pointer to be stored in the class_device. The | 175 | * @devdata: an optional pointer to be stored in the class_device. The |
182 | * methods may retrieve it by using class_get_devdata(ld->class_dev). | 176 | * methods may retrieve it by using class_get_devdata(ld->class_dev). |
183 | * @lp: the lcd properties structure. | 177 | * @ops: the lcd operations structure. |
184 | * | 178 | * |
185 | * Creates and registers a new lcd class_device. Returns either an ERR_PTR() | 179 | * Creates and registers a new lcd class_device. Returns either an ERR_PTR() |
186 | * or a pointer to the newly allocated device. | 180 | * or a pointer to the newly allocated device. |
187 | */ | 181 | */ |
188 | struct lcd_device *lcd_device_register(const char *name, void *devdata, | 182 | struct lcd_device *lcd_device_register(const char *name, void *devdata, |
189 | struct lcd_properties *lp) | 183 | struct lcd_ops *ops) |
190 | { | 184 | { |
191 | int i, rc; | 185 | int i, rc; |
192 | struct lcd_device *new_ld; | 186 | struct lcd_device *new_ld; |
193 | 187 | ||
194 | pr_debug("lcd_device_register: name=%s\n", name); | 188 | pr_debug("lcd_device_register: name=%s\n", name); |
195 | 189 | ||
196 | new_ld = kmalloc(sizeof(struct lcd_device), GFP_KERNEL); | 190 | new_ld = kzalloc(sizeof(struct lcd_device), GFP_KERNEL); |
197 | if (unlikely(!new_ld)) | 191 | if (!new_ld) |
198 | return ERR_PTR(-ENOMEM); | 192 | return ERR_PTR(-ENOMEM); |
199 | 193 | ||
200 | init_MUTEX(&new_ld->sem); | 194 | mutex_init(&new_ld->ops_lock); |
201 | new_ld->props = lp; | 195 | mutex_init(&new_ld->update_lock); |
202 | memset(&new_ld->class_dev, 0, sizeof(new_ld->class_dev)); | 196 | new_ld->ops = ops; |
203 | new_ld->class_dev.class = &lcd_class; | 197 | new_ld->class_dev.class = &lcd_class; |
204 | strlcpy(new_ld->class_dev.class_id, name, KOBJ_NAME_LEN); | 198 | strlcpy(new_ld->class_dev.class_id, name, KOBJ_NAME_LEN); |
205 | class_set_devdata(&new_ld->class_dev, devdata); | 199 | class_set_devdata(&new_ld->class_dev, devdata); |
206 | 200 | ||
207 | rc = class_device_register(&new_ld->class_dev); | 201 | rc = class_device_register(&new_ld->class_dev); |
208 | if (unlikely(rc)) { | 202 | if (rc) { |
209 | error: kfree(new_ld); | 203 | kfree(new_ld); |
210 | return ERR_PTR(rc); | 204 | return ERR_PTR(rc); |
211 | } | 205 | } |
212 | 206 | ||
213 | rc = lcd_register_fb(new_ld); | 207 | rc = lcd_register_fb(new_ld); |
214 | 208 | if (rc) { | |
215 | if (unlikely(rc)) | 209 | class_device_unregister(&new_ld->class_dev); |
216 | goto error; | 210 | return ERR_PTR(rc); |
211 | } | ||
217 | 212 | ||
218 | for (i = 0; i < ARRAY_SIZE(lcd_class_device_attributes); i++) { | 213 | for (i = 0; i < ARRAY_SIZE(lcd_class_device_attributes); i++) { |
219 | rc = class_device_create_file(&new_ld->class_dev, | 214 | rc = class_device_create_file(&new_ld->class_dev, |
220 | &lcd_class_device_attributes[i]); | 215 | &lcd_class_device_attributes[i]); |
221 | if (unlikely(rc)) { | 216 | if (rc) { |
222 | while (--i >= 0) | 217 | while (--i >= 0) |
223 | class_device_remove_file(&new_ld->class_dev, | 218 | class_device_remove_file(&new_ld->class_dev, |
224 | &lcd_class_device_attributes[i]); | 219 | &lcd_class_device_attributes[i]); |
@@ -251,9 +246,9 @@ void lcd_device_unregister(struct lcd_device *ld) | |||
251 | class_device_remove_file(&ld->class_dev, | 246 | class_device_remove_file(&ld->class_dev, |
252 | &lcd_class_device_attributes[i]); | 247 | &lcd_class_device_attributes[i]); |
253 | 248 | ||
254 | down(&ld->sem); | 249 | mutex_lock(&ld->ops_lock); |
255 | ld->props = NULL; | 250 | ld->ops = NULL; |
256 | up(&ld->sem); | 251 | mutex_unlock(&ld->ops_lock); |
257 | lcd_unregister_fb(ld); | 252 | lcd_unregister_fb(ld); |
258 | class_device_unregister(&ld->class_dev); | 253 | class_device_unregister(&ld->class_dev); |
259 | } | 254 | } |