Root/
1 | /*************************************************************************** |
2 | * Copyright (C) 2010-2012 by Bruno Prémont <bonbons@linux-vserver.org> * |
3 | * * |
4 | * Based on Logitech G13 driver (v0.4) * |
5 | * Copyright (C) 2009 by Rick L. Vinyard, Jr. <rvinyard@cs.nmsu.edu> * |
6 | * * |
7 | * This program is free software: you can redistribute it and/or modify * |
8 | * it under the terms of the GNU General Public License as published by * |
9 | * the Free Software Foundation, version 2 of the License. * |
10 | * * |
11 | * This driver is distributed in the hope that it will be useful, but * |
12 | * WITHOUT ANY WARRANTY; without even the implied warranty of * |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * |
14 | * General Public License for more details. * |
15 | * * |
16 | * You should have received a copy of the GNU General Public License * |
17 | * along with this software. If not see <http://www.gnu.org/licenses/>. * |
18 | ***************************************************************************/ |
19 | |
20 | #include <linux/hid.h> |
21 | #include <linux/vmalloc.h> |
22 | #include "usbhid/usbhid.h" |
23 | #include <linux/usb.h> |
24 | |
25 | #include <linux/fb.h> |
26 | #include <linux/module.h> |
27 | |
28 | #include "hid-picolcd.h" |
29 | |
30 | /* Framebuffer |
31 | * |
32 | * The PicoLCD use a Topway LCD module of 256x64 pixel |
33 | * This display area is tiled over 4 controllers with 8 tiles |
34 | * each. Each tile has 8x64 pixel, each data byte representing |
35 | * a 1-bit wide vertical line of the tile. |
36 | * |
37 | * The display can be updated at a tile granularity. |
38 | * |
39 | * Chip 1 Chip 2 Chip 3 Chip 4 |
40 | * +----------------+----------------+----------------+----------------+ |
41 | * | Tile 1 | Tile 1 | Tile 1 | Tile 1 | |
42 | * +----------------+----------------+----------------+----------------+ |
43 | * | Tile 2 | Tile 2 | Tile 2 | Tile 2 | |
44 | * +----------------+----------------+----------------+----------------+ |
45 | * ... |
46 | * +----------------+----------------+----------------+----------------+ |
47 | * | Tile 8 | Tile 8 | Tile 8 | Tile 8 | |
48 | * +----------------+----------------+----------------+----------------+ |
49 | */ |
50 | #define PICOLCDFB_NAME "picolcdfb" |
51 | #define PICOLCDFB_WIDTH (256) |
52 | #define PICOLCDFB_HEIGHT (64) |
53 | #define PICOLCDFB_SIZE (PICOLCDFB_WIDTH * PICOLCDFB_HEIGHT / 8) |
54 | |
55 | #define PICOLCDFB_UPDATE_RATE_LIMIT 10 |
56 | #define PICOLCDFB_UPDATE_RATE_DEFAULT 2 |
57 | |
58 | /* Framebuffer visual structures */ |
59 | static const struct fb_fix_screeninfo picolcdfb_fix = { |
60 | .id = PICOLCDFB_NAME, |
61 | .type = FB_TYPE_PACKED_PIXELS, |
62 | .visual = FB_VISUAL_MONO01, |
63 | .xpanstep = 0, |
64 | .ypanstep = 0, |
65 | .ywrapstep = 0, |
66 | .line_length = PICOLCDFB_WIDTH / 8, |
67 | .accel = FB_ACCEL_NONE, |
68 | }; |
69 | |
70 | static const struct fb_var_screeninfo picolcdfb_var = { |
71 | .xres = PICOLCDFB_WIDTH, |
72 | .yres = PICOLCDFB_HEIGHT, |
73 | .xres_virtual = PICOLCDFB_WIDTH, |
74 | .yres_virtual = PICOLCDFB_HEIGHT, |
75 | .width = 103, |
76 | .height = 26, |
77 | .bits_per_pixel = 1, |
78 | .grayscale = 1, |
79 | .red = { |
80 | .offset = 0, |
81 | .length = 1, |
82 | .msb_right = 0, |
83 | }, |
84 | .green = { |
85 | .offset = 0, |
86 | .length = 1, |
87 | .msb_right = 0, |
88 | }, |
89 | .blue = { |
90 | .offset = 0, |
91 | .length = 1, |
92 | .msb_right = 0, |
93 | }, |
94 | .transp = { |
95 | .offset = 0, |
96 | .length = 0, |
97 | .msb_right = 0, |
98 | }, |
99 | }; |
100 | |
101 | /* Send a given tile to PicoLCD */ |
102 | static int picolcd_fb_send_tile(struct picolcd_data *data, u8 *vbitmap, |
103 | int chip, int tile) |
104 | { |
105 | struct hid_report *report1, *report2; |
106 | unsigned long flags; |
107 | u8 *tdata; |
108 | int i; |
109 | |
110 | report1 = picolcd_out_report(REPORT_LCD_CMD_DATA, data->hdev); |
111 | if (!report1 || report1->maxfield != 1) |
112 | return -ENODEV; |
113 | report2 = picolcd_out_report(REPORT_LCD_DATA, data->hdev); |
114 | if (!report2 || report2->maxfield != 1) |
115 | return -ENODEV; |
116 | |
117 | spin_lock_irqsave(&data->lock, flags); |
118 | if ((data->status & PICOLCD_FAILED)) { |
119 | spin_unlock_irqrestore(&data->lock, flags); |
120 | return -ENODEV; |
121 | } |
122 | hid_set_field(report1->field[0], 0, chip << 2); |
123 | hid_set_field(report1->field[0], 1, 0x02); |
124 | hid_set_field(report1->field[0], 2, 0x00); |
125 | hid_set_field(report1->field[0], 3, 0x00); |
126 | hid_set_field(report1->field[0], 4, 0xb8 | tile); |
127 | hid_set_field(report1->field[0], 5, 0x00); |
128 | hid_set_field(report1->field[0], 6, 0x00); |
129 | hid_set_field(report1->field[0], 7, 0x40); |
130 | hid_set_field(report1->field[0], 8, 0x00); |
131 | hid_set_field(report1->field[0], 9, 0x00); |
132 | hid_set_field(report1->field[0], 10, 32); |
133 | |
134 | hid_set_field(report2->field[0], 0, (chip << 2) | 0x01); |
135 | hid_set_field(report2->field[0], 1, 0x00); |
136 | hid_set_field(report2->field[0], 2, 0x00); |
137 | hid_set_field(report2->field[0], 3, 32); |
138 | |
139 | tdata = vbitmap + (tile * 4 + chip) * 64; |
140 | for (i = 0; i < 64; i++) |
141 | if (i < 32) |
142 | hid_set_field(report1->field[0], 11 + i, tdata[i]); |
143 | else |
144 | hid_set_field(report2->field[0], 4 + i - 32, tdata[i]); |
145 | |
146 | usbhid_submit_report(data->hdev, report1, USB_DIR_OUT); |
147 | usbhid_submit_report(data->hdev, report2, USB_DIR_OUT); |
148 | spin_unlock_irqrestore(&data->lock, flags); |
149 | return 0; |
150 | } |
151 | |
152 | /* Translate a single tile*/ |
153 | static int picolcd_fb_update_tile(u8 *vbitmap, const u8 *bitmap, int bpp, |
154 | int chip, int tile) |
155 | { |
156 | int i, b, changed = 0; |
157 | u8 tdata[64]; |
158 | u8 *vdata = vbitmap + (tile * 4 + chip) * 64; |
159 | |
160 | if (bpp == 1) { |
161 | for (b = 7; b >= 0; b--) { |
162 | const u8 *bdata = bitmap + tile * 256 + chip * 8 + b * 32; |
163 | for (i = 0; i < 64; i++) { |
164 | tdata[i] <<= 1; |
165 | tdata[i] |= (bdata[i/8] >> (i % 8)) & 0x01; |
166 | } |
167 | } |
168 | } else if (bpp == 8) { |
169 | for (b = 7; b >= 0; b--) { |
170 | const u8 *bdata = bitmap + (tile * 256 + chip * 8 + b * 32) * 8; |
171 | for (i = 0; i < 64; i++) { |
172 | tdata[i] <<= 1; |
173 | tdata[i] |= (bdata[i] & 0x80) ? 0x01 : 0x00; |
174 | } |
175 | } |
176 | } else { |
177 | /* Oops, we should never get here! */ |
178 | WARN_ON(1); |
179 | return 0; |
180 | } |
181 | |
182 | for (i = 0; i < 64; i++) |
183 | if (tdata[i] != vdata[i]) { |
184 | changed = 1; |
185 | vdata[i] = tdata[i]; |
186 | } |
187 | return changed; |
188 | } |
189 | |
190 | void picolcd_fb_refresh(struct picolcd_data *data) |
191 | { |
192 | if (data->fb_info) |
193 | schedule_delayed_work(&data->fb_info->deferred_work, 0); |
194 | } |
195 | |
196 | /* Reconfigure LCD display */ |
197 | int picolcd_fb_reset(struct picolcd_data *data, int clear) |
198 | { |
199 | struct hid_report *report = picolcd_out_report(REPORT_LCD_CMD, data->hdev); |
200 | struct picolcd_fb_data *fbdata = data->fb_info->par; |
201 | int i, j; |
202 | unsigned long flags; |
203 | static const u8 mapcmd[8] = { 0x00, 0x02, 0x00, 0x64, 0x3f, 0x00, 0x64, 0xc0 }; |
204 | |
205 | if (!report || report->maxfield != 1) |
206 | return -ENODEV; |
207 | |
208 | spin_lock_irqsave(&data->lock, flags); |
209 | for (i = 0; i < 4; i++) { |
210 | for (j = 0; j < report->field[0]->maxusage; j++) |
211 | if (j == 0) |
212 | hid_set_field(report->field[0], j, i << 2); |
213 | else if (j < sizeof(mapcmd)) |
214 | hid_set_field(report->field[0], j, mapcmd[j]); |
215 | else |
216 | hid_set_field(report->field[0], j, 0); |
217 | usbhid_submit_report(data->hdev, report, USB_DIR_OUT); |
218 | } |
219 | spin_unlock_irqrestore(&data->lock, flags); |
220 | |
221 | if (clear) { |
222 | memset(fbdata->vbitmap, 0, PICOLCDFB_SIZE); |
223 | memset(fbdata->bitmap, 0, PICOLCDFB_SIZE*fbdata->bpp); |
224 | } |
225 | fbdata->force = 1; |
226 | |
227 | /* schedule first output of framebuffer */ |
228 | if (fbdata->ready) |
229 | schedule_delayed_work(&data->fb_info->deferred_work, 0); |
230 | else |
231 | fbdata->ready = 1; |
232 | |
233 | return 0; |
234 | } |
235 | |
236 | /* Update fb_vbitmap from the screen_base and send changed tiles to device */ |
237 | static void picolcd_fb_update(struct fb_info *info) |
238 | { |
239 | int chip, tile, n; |
240 | unsigned long flags; |
241 | struct picolcd_fb_data *fbdata = info->par; |
242 | struct picolcd_data *data; |
243 | |
244 | mutex_lock(&info->lock); |
245 | |
246 | spin_lock_irqsave(&fbdata->lock, flags); |
247 | if (!fbdata->ready && fbdata->picolcd) |
248 | picolcd_fb_reset(fbdata->picolcd, 0); |
249 | spin_unlock_irqrestore(&fbdata->lock, flags); |
250 | |
251 | /* |
252 | * Translate the framebuffer into the format needed by the PicoLCD. |
253 | * See display layout above. |
254 | * Do this one tile after the other and push those tiles that changed. |
255 | * |
256 | * Wait for our IO to complete as otherwise we might flood the queue! |
257 | */ |
258 | n = 0; |
259 | for (chip = 0; chip < 4; chip++) |
260 | for (tile = 0; tile < 8; tile++) { |
261 | if (!fbdata->force && !picolcd_fb_update_tile( |
262 | fbdata->vbitmap, fbdata->bitmap, |
263 | fbdata->bpp, chip, tile)) |
264 | continue; |
265 | n += 2; |
266 | if (n >= HID_OUTPUT_FIFO_SIZE / 2) { |
267 | spin_lock_irqsave(&fbdata->lock, flags); |
268 | data = fbdata->picolcd; |
269 | spin_unlock_irqrestore(&fbdata->lock, flags); |
270 | mutex_unlock(&info->lock); |
271 | if (!data) |
272 | return; |
273 | usbhid_wait_io(data->hdev); |
274 | mutex_lock(&info->lock); |
275 | n = 0; |
276 | } |
277 | spin_lock_irqsave(&fbdata->lock, flags); |
278 | data = fbdata->picolcd; |
279 | spin_unlock_irqrestore(&fbdata->lock, flags); |
280 | if (!data || picolcd_fb_send_tile(data, |
281 | fbdata->vbitmap, chip, tile)) |
282 | goto out; |
283 | } |
284 | fbdata->force = false; |
285 | if (n) { |
286 | spin_lock_irqsave(&fbdata->lock, flags); |
287 | data = fbdata->picolcd; |
288 | spin_unlock_irqrestore(&fbdata->lock, flags); |
289 | mutex_unlock(&info->lock); |
290 | if (data) |
291 | usbhid_wait_io(data->hdev); |
292 | return; |
293 | } |
294 | out: |
295 | mutex_unlock(&info->lock); |
296 | } |
297 | |
298 | /* Stub to call the system default and update the image on the picoLCD */ |
299 | static void picolcd_fb_fillrect(struct fb_info *info, |
300 | const struct fb_fillrect *rect) |
301 | { |
302 | if (!info->par) |
303 | return; |
304 | sys_fillrect(info, rect); |
305 | |
306 | schedule_delayed_work(&info->deferred_work, 0); |
307 | } |
308 | |
309 | /* Stub to call the system default and update the image on the picoLCD */ |
310 | static void picolcd_fb_copyarea(struct fb_info *info, |
311 | const struct fb_copyarea *area) |
312 | { |
313 | if (!info->par) |
314 | return; |
315 | sys_copyarea(info, area); |
316 | |
317 | schedule_delayed_work(&info->deferred_work, 0); |
318 | } |
319 | |
320 | /* Stub to call the system default and update the image on the picoLCD */ |
321 | static void picolcd_fb_imageblit(struct fb_info *info, const struct fb_image *image) |
322 | { |
323 | if (!info->par) |
324 | return; |
325 | sys_imageblit(info, image); |
326 | |
327 | schedule_delayed_work(&info->deferred_work, 0); |
328 | } |
329 | |
330 | /* |
331 | * this is the slow path from userspace. they can seek and write to |
332 | * the fb. it's inefficient to do anything less than a full screen draw |
333 | */ |
334 | static ssize_t picolcd_fb_write(struct fb_info *info, const char __user *buf, |
335 | size_t count, loff_t *ppos) |
336 | { |
337 | ssize_t ret; |
338 | if (!info->par) |
339 | return -ENODEV; |
340 | ret = fb_sys_write(info, buf, count, ppos); |
341 | if (ret >= 0) |
342 | schedule_delayed_work(&info->deferred_work, 0); |
343 | return ret; |
344 | } |
345 | |
346 | static int picolcd_fb_blank(int blank, struct fb_info *info) |
347 | { |
348 | /* We let fb notification do this for us via lcd/backlight device */ |
349 | return 0; |
350 | } |
351 | |
352 | static void picolcd_fb_destroy(struct fb_info *info) |
353 | { |
354 | struct picolcd_fb_data *fbdata = info->par; |
355 | |
356 | /* make sure no work is deferred */ |
357 | fb_deferred_io_cleanup(info); |
358 | |
359 | /* No thridparty should ever unregister our framebuffer! */ |
360 | WARN_ON(fbdata->picolcd != NULL); |
361 | |
362 | vfree((u8 *)info->fix.smem_start); |
363 | framebuffer_release(info); |
364 | } |
365 | |
366 | static int picolcd_fb_check_var(struct fb_var_screeninfo *var, struct fb_info *info) |
367 | { |
368 | __u32 bpp = var->bits_per_pixel; |
369 | __u32 activate = var->activate; |
370 | |
371 | /* only allow 1/8 bit depth (8-bit is grayscale) */ |
372 | *var = picolcdfb_var; |
373 | var->activate = activate; |
374 | if (bpp >= 8) { |
375 | var->bits_per_pixel = 8; |
376 | var->red.length = 8; |
377 | var->green.length = 8; |
378 | var->blue.length = 8; |
379 | } else { |
380 | var->bits_per_pixel = 1; |
381 | var->red.length = 1; |
382 | var->green.length = 1; |
383 | var->blue.length = 1; |
384 | } |
385 | return 0; |
386 | } |
387 | |
388 | static int picolcd_set_par(struct fb_info *info) |
389 | { |
390 | struct picolcd_fb_data *fbdata = info->par; |
391 | u8 *tmp_fb, *o_fb; |
392 | if (info->var.bits_per_pixel == fbdata->bpp) |
393 | return 0; |
394 | /* switch between 1/8 bit depths */ |
395 | if (info->var.bits_per_pixel != 1 && info->var.bits_per_pixel != 8) |
396 | return -EINVAL; |
397 | |
398 | o_fb = fbdata->bitmap; |
399 | tmp_fb = kmalloc(PICOLCDFB_SIZE*info->var.bits_per_pixel, GFP_KERNEL); |
400 | if (!tmp_fb) |
401 | return -ENOMEM; |
402 | |
403 | /* translate FB content to new bits-per-pixel */ |
404 | if (info->var.bits_per_pixel == 1) { |
405 | int i, b; |
406 | for (i = 0; i < PICOLCDFB_SIZE; i++) { |
407 | u8 p = 0; |
408 | for (b = 0; b < 8; b++) { |
409 | p <<= 1; |
410 | p |= o_fb[i*8+b] ? 0x01 : 0x00; |
411 | } |
412 | tmp_fb[i] = p; |
413 | } |
414 | memcpy(o_fb, tmp_fb, PICOLCDFB_SIZE); |
415 | info->fix.visual = FB_VISUAL_MONO01; |
416 | info->fix.line_length = PICOLCDFB_WIDTH / 8; |
417 | } else { |
418 | int i; |
419 | memcpy(tmp_fb, o_fb, PICOLCDFB_SIZE); |
420 | for (i = 0; i < PICOLCDFB_SIZE * 8; i++) |
421 | o_fb[i] = tmp_fb[i/8] & (0x01 << (7 - i % 8)) ? 0xff : 0x00; |
422 | info->fix.visual = FB_VISUAL_DIRECTCOLOR; |
423 | info->fix.line_length = PICOLCDFB_WIDTH; |
424 | } |
425 | |
426 | kfree(tmp_fb); |
427 | fbdata->bpp = info->var.bits_per_pixel; |
428 | return 0; |
429 | } |
430 | |
431 | /* Note this can't be const because of struct fb_info definition */ |
432 | static struct fb_ops picolcdfb_ops = { |
433 | .owner = THIS_MODULE, |
434 | .fb_destroy = picolcd_fb_destroy, |
435 | .fb_read = fb_sys_read, |
436 | .fb_write = picolcd_fb_write, |
437 | .fb_blank = picolcd_fb_blank, |
438 | .fb_fillrect = picolcd_fb_fillrect, |
439 | .fb_copyarea = picolcd_fb_copyarea, |
440 | .fb_imageblit = picolcd_fb_imageblit, |
441 | .fb_check_var = picolcd_fb_check_var, |
442 | .fb_set_par = picolcd_set_par, |
443 | }; |
444 | |
445 | |
446 | /* Callback from deferred IO workqueue */ |
447 | static void picolcd_fb_deferred_io(struct fb_info *info, struct list_head *pagelist) |
448 | { |
449 | picolcd_fb_update(info); |
450 | } |
451 | |
452 | static const struct fb_deferred_io picolcd_fb_defio = { |
453 | .delay = HZ / PICOLCDFB_UPDATE_RATE_DEFAULT, |
454 | .deferred_io = picolcd_fb_deferred_io, |
455 | }; |
456 | |
457 | |
458 | /* |
459 | * The "fb_update_rate" sysfs attribute |
460 | */ |
461 | static ssize_t picolcd_fb_update_rate_show(struct device *dev, |
462 | struct device_attribute *attr, char *buf) |
463 | { |
464 | struct picolcd_data *data = dev_get_drvdata(dev); |
465 | struct picolcd_fb_data *fbdata = data->fb_info->par; |
466 | unsigned i, fb_update_rate = fbdata->update_rate; |
467 | size_t ret = 0; |
468 | |
469 | for (i = 1; i <= PICOLCDFB_UPDATE_RATE_LIMIT; i++) |
470 | if (ret >= PAGE_SIZE) |
471 | break; |
472 | else if (i == fb_update_rate) |
473 | ret += snprintf(buf+ret, PAGE_SIZE-ret, "[%u] ", i); |
474 | else |
475 | ret += snprintf(buf+ret, PAGE_SIZE-ret, "%u ", i); |
476 | if (ret > 0) |
477 | buf[min(ret, (size_t)PAGE_SIZE)-1] = '\n'; |
478 | return ret; |
479 | } |
480 | |
481 | static ssize_t picolcd_fb_update_rate_store(struct device *dev, |
482 | struct device_attribute *attr, const char *buf, size_t count) |
483 | { |
484 | struct picolcd_data *data = dev_get_drvdata(dev); |
485 | struct picolcd_fb_data *fbdata = data->fb_info->par; |
486 | int i; |
487 | unsigned u; |
488 | |
489 | if (count < 1 || count > 10) |
490 | return -EINVAL; |
491 | |
492 | i = sscanf(buf, "%u", &u); |
493 | if (i != 1) |
494 | return -EINVAL; |
495 | |
496 | if (u > PICOLCDFB_UPDATE_RATE_LIMIT) |
497 | return -ERANGE; |
498 | else if (u == 0) |
499 | u = PICOLCDFB_UPDATE_RATE_DEFAULT; |
500 | |
501 | fbdata->update_rate = u; |
502 | data->fb_info->fbdefio->delay = HZ / fbdata->update_rate; |
503 | return count; |
504 | } |
505 | |
506 | static DEVICE_ATTR(fb_update_rate, 0666, picolcd_fb_update_rate_show, |
507 | picolcd_fb_update_rate_store); |
508 | |
509 | /* initialize Framebuffer device */ |
510 | int picolcd_init_framebuffer(struct picolcd_data *data) |
511 | { |
512 | struct device *dev = &data->hdev->dev; |
513 | struct fb_info *info = NULL; |
514 | struct picolcd_fb_data *fbdata = NULL; |
515 | int i, error = -ENOMEM; |
516 | u32 *palette; |
517 | |
518 | /* The extra memory is: |
519 | * - 256*u32 for pseudo_palette |
520 | * - struct fb_deferred_io |
521 | */ |
522 | info = framebuffer_alloc(256 * sizeof(u32) + |
523 | sizeof(struct fb_deferred_io) + |
524 | sizeof(struct picolcd_fb_data) + |
525 | PICOLCDFB_SIZE, dev); |
526 | if (info == NULL) { |
527 | dev_err(dev, "failed to allocate a framebuffer\n"); |
528 | goto err_nomem; |
529 | } |
530 | |
531 | info->fbdefio = info->par; |
532 | *info->fbdefio = picolcd_fb_defio; |
533 | info->par += sizeof(struct fb_deferred_io); |
534 | palette = info->par; |
535 | info->par += 256 * sizeof(u32); |
536 | for (i = 0; i < 256; i++) |
537 | palette[i] = i > 0 && i < 16 ? 0xff : 0; |
538 | info->pseudo_palette = palette; |
539 | info->fbops = &picolcdfb_ops; |
540 | info->var = picolcdfb_var; |
541 | info->fix = picolcdfb_fix; |
542 | info->fix.smem_len = PICOLCDFB_SIZE*8; |
543 | info->flags = FBINFO_FLAG_DEFAULT; |
544 | |
545 | fbdata = info->par; |
546 | spin_lock_init(&fbdata->lock); |
547 | fbdata->picolcd = data; |
548 | fbdata->update_rate = PICOLCDFB_UPDATE_RATE_DEFAULT; |
549 | fbdata->bpp = picolcdfb_var.bits_per_pixel; |
550 | fbdata->force = 1; |
551 | fbdata->vbitmap = info->par + sizeof(struct picolcd_fb_data); |
552 | fbdata->bitmap = vmalloc(PICOLCDFB_SIZE*8); |
553 | if (fbdata->bitmap == NULL) { |
554 | dev_err(dev, "can't get a free page for framebuffer\n"); |
555 | goto err_nomem; |
556 | } |
557 | info->screen_base = (char __force __iomem *)fbdata->bitmap; |
558 | info->fix.smem_start = (unsigned long)fbdata->bitmap; |
559 | memset(fbdata->vbitmap, 0xff, PICOLCDFB_SIZE); |
560 | data->fb_info = info; |
561 | |
562 | error = picolcd_fb_reset(data, 1); |
563 | if (error) { |
564 | dev_err(dev, "failed to configure display\n"); |
565 | goto err_cleanup; |
566 | } |
567 | |
568 | error = device_create_file(dev, &dev_attr_fb_update_rate); |
569 | if (error) { |
570 | dev_err(dev, "failed to create sysfs attributes\n"); |
571 | goto err_cleanup; |
572 | } |
573 | |
574 | fb_deferred_io_init(info); |
575 | error = register_framebuffer(info); |
576 | if (error) { |
577 | dev_err(dev, "failed to register framebuffer\n"); |
578 | goto err_sysfs; |
579 | } |
580 | return 0; |
581 | |
582 | err_sysfs: |
583 | device_remove_file(dev, &dev_attr_fb_update_rate); |
584 | fb_deferred_io_cleanup(info); |
585 | err_cleanup: |
586 | data->fb_info = NULL; |
587 | |
588 | err_nomem: |
589 | if (fbdata) |
590 | vfree(fbdata->bitmap); |
591 | framebuffer_release(info); |
592 | return error; |
593 | } |
594 | |
595 | void picolcd_exit_framebuffer(struct picolcd_data *data) |
596 | { |
597 | struct fb_info *info = data->fb_info; |
598 | struct picolcd_fb_data *fbdata = info->par; |
599 | unsigned long flags; |
600 | |
601 | device_remove_file(&data->hdev->dev, &dev_attr_fb_update_rate); |
602 | |
603 | /* disconnect framebuffer from HID dev */ |
604 | spin_lock_irqsave(&fbdata->lock, flags); |
605 | fbdata->picolcd = NULL; |
606 | spin_unlock_irqrestore(&fbdata->lock, flags); |
607 | |
608 | /* make sure there is no running update - thus that fbdata->picolcd |
609 | * once obtained under lock is guaranteed not to get free() under |
610 | * the feet of the deferred work */ |
611 | flush_delayed_work(&info->deferred_work); |
612 | |
613 | data->fb_info = NULL; |
614 | unregister_framebuffer(info); |
615 | } |
616 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9