blob: 591f6b22aa947190a9e728b650caa40090cc9595 [file] [log] [blame]
Bruno Prémontfabdbf22012-07-30 21:38:28 +02001/***************************************************************************
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>
Stephen Rothwelld1c60a02012-08-16 15:20:10 +100021#include <linux/vmalloc.h>
Bruno Prémontfabdbf22012-07-30 21:38:28 +020022
23#include <linux/fb.h>
24#include <linux/module.h>
25
26#include "hid-picolcd.h"
27
28/* Framebuffer
29 *
30 * The PicoLCD use a Topway LCD module of 256x64 pixel
31 * This display area is tiled over 4 controllers with 8 tiles
32 * each. Each tile has 8x64 pixel, each data byte representing
33 * a 1-bit wide vertical line of the tile.
34 *
35 * The display can be updated at a tile granularity.
36 *
37 * Chip 1 Chip 2 Chip 3 Chip 4
38 * +----------------+----------------+----------------+----------------+
39 * | Tile 1 | Tile 1 | Tile 1 | Tile 1 |
40 * +----------------+----------------+----------------+----------------+
41 * | Tile 2 | Tile 2 | Tile 2 | Tile 2 |
42 * +----------------+----------------+----------------+----------------+
43 * ...
44 * +----------------+----------------+----------------+----------------+
45 * | Tile 8 | Tile 8 | Tile 8 | Tile 8 |
46 * +----------------+----------------+----------------+----------------+
47 */
48#define PICOLCDFB_NAME "picolcdfb"
49#define PICOLCDFB_WIDTH (256)
50#define PICOLCDFB_HEIGHT (64)
51#define PICOLCDFB_SIZE (PICOLCDFB_WIDTH * PICOLCDFB_HEIGHT / 8)
52
53#define PICOLCDFB_UPDATE_RATE_LIMIT 10
54#define PICOLCDFB_UPDATE_RATE_DEFAULT 2
55
56/* Framebuffer visual structures */
57static const struct fb_fix_screeninfo picolcdfb_fix = {
58 .id = PICOLCDFB_NAME,
59 .type = FB_TYPE_PACKED_PIXELS,
60 .visual = FB_VISUAL_MONO01,
61 .xpanstep = 0,
62 .ypanstep = 0,
63 .ywrapstep = 0,
64 .line_length = PICOLCDFB_WIDTH / 8,
65 .accel = FB_ACCEL_NONE,
66};
67
68static const struct fb_var_screeninfo picolcdfb_var = {
69 .xres = PICOLCDFB_WIDTH,
70 .yres = PICOLCDFB_HEIGHT,
71 .xres_virtual = PICOLCDFB_WIDTH,
72 .yres_virtual = PICOLCDFB_HEIGHT,
73 .width = 103,
74 .height = 26,
75 .bits_per_pixel = 1,
76 .grayscale = 1,
77 .red = {
78 .offset = 0,
79 .length = 1,
80 .msb_right = 0,
81 },
82 .green = {
83 .offset = 0,
84 .length = 1,
85 .msb_right = 0,
86 },
87 .blue = {
88 .offset = 0,
89 .length = 1,
90 .msb_right = 0,
91 },
92 .transp = {
93 .offset = 0,
94 .length = 0,
95 .msb_right = 0,
96 },
97};
98
99/* Send a given tile to PicoLCD */
Bruno Prémont16048702012-08-19 19:32:04 +0200100static int picolcd_fb_send_tile(struct picolcd_data *data, u8 *vbitmap,
101 int chip, int tile)
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200102{
Bruno Prémont16048702012-08-19 19:32:04 +0200103 struct hid_report *report1, *report2;
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200104 unsigned long flags;
105 u8 *tdata;
106 int i;
107
Bruno Prémont16048702012-08-19 19:32:04 +0200108 report1 = picolcd_out_report(REPORT_LCD_CMD_DATA, data->hdev);
109 if (!report1 || report1->maxfield != 1)
110 return -ENODEV;
111 report2 = picolcd_out_report(REPORT_LCD_DATA, data->hdev);
112 if (!report2 || report2->maxfield != 1)
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200113 return -ENODEV;
114
115 spin_lock_irqsave(&data->lock, flags);
Bruno Prémont16048702012-08-19 19:32:04 +0200116 if ((data->status & PICOLCD_FAILED)) {
117 spin_unlock_irqrestore(&data->lock, flags);
118 return -ENODEV;
119 }
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200120 hid_set_field(report1->field[0], 0, chip << 2);
121 hid_set_field(report1->field[0], 1, 0x02);
122 hid_set_field(report1->field[0], 2, 0x00);
123 hid_set_field(report1->field[0], 3, 0x00);
124 hid_set_field(report1->field[0], 4, 0xb8 | tile);
125 hid_set_field(report1->field[0], 5, 0x00);
126 hid_set_field(report1->field[0], 6, 0x00);
127 hid_set_field(report1->field[0], 7, 0x40);
128 hid_set_field(report1->field[0], 8, 0x00);
129 hid_set_field(report1->field[0], 9, 0x00);
130 hid_set_field(report1->field[0], 10, 32);
131
132 hid_set_field(report2->field[0], 0, (chip << 2) | 0x01);
133 hid_set_field(report2->field[0], 1, 0x00);
134 hid_set_field(report2->field[0], 2, 0x00);
135 hid_set_field(report2->field[0], 3, 32);
136
Bruno Prémont16048702012-08-19 19:32:04 +0200137 tdata = vbitmap + (tile * 4 + chip) * 64;
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200138 for (i = 0; i < 64; i++)
139 if (i < 32)
140 hid_set_field(report1->field[0], 11 + i, tdata[i]);
141 else
142 hid_set_field(report2->field[0], 4 + i - 32, tdata[i]);
143
Benjamin Tissoiresd88142722013-02-25 11:31:46 +0100144 hid_hw_request(data->hdev, report1, HID_REQ_SET_REPORT);
145 hid_hw_request(data->hdev, report2, HID_REQ_SET_REPORT);
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200146 spin_unlock_irqrestore(&data->lock, flags);
147 return 0;
148}
149
150/* Translate a single tile*/
151static int picolcd_fb_update_tile(u8 *vbitmap, const u8 *bitmap, int bpp,
152 int chip, int tile)
153{
154 int i, b, changed = 0;
155 u8 tdata[64];
156 u8 *vdata = vbitmap + (tile * 4 + chip) * 64;
157
158 if (bpp == 1) {
159 for (b = 7; b >= 0; b--) {
160 const u8 *bdata = bitmap + tile * 256 + chip * 8 + b * 32;
161 for (i = 0; i < 64; i++) {
162 tdata[i] <<= 1;
163 tdata[i] |= (bdata[i/8] >> (i % 8)) & 0x01;
164 }
165 }
166 } else if (bpp == 8) {
167 for (b = 7; b >= 0; b--) {
168 const u8 *bdata = bitmap + (tile * 256 + chip * 8 + b * 32) * 8;
169 for (i = 0; i < 64; i++) {
170 tdata[i] <<= 1;
171 tdata[i] |= (bdata[i] & 0x80) ? 0x01 : 0x00;
172 }
173 }
174 } else {
175 /* Oops, we should never get here! */
176 WARN_ON(1);
177 return 0;
178 }
179
180 for (i = 0; i < 64; i++)
181 if (tdata[i] != vdata[i]) {
182 changed = 1;
183 vdata[i] = tdata[i];
184 }
185 return changed;
186}
187
188void picolcd_fb_refresh(struct picolcd_data *data)
189{
190 if (data->fb_info)
191 schedule_delayed_work(&data->fb_info->deferred_work, 0);
192}
193
194/* Reconfigure LCD display */
195int picolcd_fb_reset(struct picolcd_data *data, int clear)
196{
197 struct hid_report *report = picolcd_out_report(REPORT_LCD_CMD, data->hdev);
Bruno Prémont16048702012-08-19 19:32:04 +0200198 struct picolcd_fb_data *fbdata = data->fb_info->par;
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200199 int i, j;
200 unsigned long flags;
201 static const u8 mapcmd[8] = { 0x00, 0x02, 0x00, 0x64, 0x3f, 0x00, 0x64, 0xc0 };
202
203 if (!report || report->maxfield != 1)
204 return -ENODEV;
205
206 spin_lock_irqsave(&data->lock, flags);
207 for (i = 0; i < 4; i++) {
208 for (j = 0; j < report->field[0]->maxusage; j++)
209 if (j == 0)
210 hid_set_field(report->field[0], j, i << 2);
211 else if (j < sizeof(mapcmd))
212 hid_set_field(report->field[0], j, mapcmd[j]);
213 else
214 hid_set_field(report->field[0], j, 0);
Benjamin Tissoiresd88142722013-02-25 11:31:46 +0100215 hid_hw_request(data->hdev, report, HID_REQ_SET_REPORT);
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200216 }
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200217 spin_unlock_irqrestore(&data->lock, flags);
218
Bruno Prémont16048702012-08-19 19:32:04 +0200219 if (clear) {
220 memset(fbdata->vbitmap, 0, PICOLCDFB_SIZE);
221 memset(fbdata->bitmap, 0, PICOLCDFB_SIZE*fbdata->bpp);
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200222 }
Bruno Prémont16048702012-08-19 19:32:04 +0200223 fbdata->force = 1;
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200224
225 /* schedule first output of framebuffer */
Bruno Prémont16048702012-08-19 19:32:04 +0200226 if (fbdata->ready)
227 schedule_delayed_work(&data->fb_info->deferred_work, 0);
228 else
229 fbdata->ready = 1;
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200230
231 return 0;
232}
233
234/* Update fb_vbitmap from the screen_base and send changed tiles to device */
Bruno Prémonta93ab842012-07-30 21:38:57 +0200235static void picolcd_fb_update(struct fb_info *info)
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200236{
237 int chip, tile, n;
238 unsigned long flags;
Bruno Prémont16048702012-08-19 19:32:04 +0200239 struct picolcd_fb_data *fbdata = info->par;
Bruno Prémonta93ab842012-07-30 21:38:57 +0200240 struct picolcd_data *data;
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200241
Bruno Prémonta93ab842012-07-30 21:38:57 +0200242 mutex_lock(&info->lock);
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200243
Bruno Prémont16048702012-08-19 19:32:04 +0200244 spin_lock_irqsave(&fbdata->lock, flags);
245 if (!fbdata->ready && fbdata->picolcd)
246 picolcd_fb_reset(fbdata->picolcd, 0);
247 spin_unlock_irqrestore(&fbdata->lock, flags);
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200248
249 /*
250 * Translate the framebuffer into the format needed by the PicoLCD.
251 * See display layout above.
252 * Do this one tile after the other and push those tiles that changed.
253 *
254 * Wait for our IO to complete as otherwise we might flood the queue!
255 */
256 n = 0;
257 for (chip = 0; chip < 4; chip++)
Bruno Prémont16048702012-08-19 19:32:04 +0200258 for (tile = 0; tile < 8; tile++) {
259 if (!fbdata->force && !picolcd_fb_update_tile(
260 fbdata->vbitmap, fbdata->bitmap,
261 fbdata->bpp, chip, tile))
262 continue;
263 n += 2;
264 if (n >= HID_OUTPUT_FIFO_SIZE / 2) {
265 spin_lock_irqsave(&fbdata->lock, flags);
266 data = fbdata->picolcd;
267 spin_unlock_irqrestore(&fbdata->lock, flags);
268 mutex_unlock(&info->lock);
269 if (!data)
270 return;
Benjamin Tissoiresb7966a42013-02-25 11:31:47 +0100271 hid_hw_wait(data->hdev);
Bruno Prémont16048702012-08-19 19:32:04 +0200272 mutex_lock(&info->lock);
273 n = 0;
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200274 }
Bruno Prémont16048702012-08-19 19:32:04 +0200275 spin_lock_irqsave(&fbdata->lock, flags);
276 data = fbdata->picolcd;
277 spin_unlock_irqrestore(&fbdata->lock, flags);
278 if (!data || picolcd_fb_send_tile(data,
279 fbdata->vbitmap, chip, tile))
280 goto out;
281 }
282 fbdata->force = false;
Bruno Prémonta93ab842012-07-30 21:38:57 +0200283 if (n) {
Bruno Prémont16048702012-08-19 19:32:04 +0200284 spin_lock_irqsave(&fbdata->lock, flags);
285 data = fbdata->picolcd;
286 spin_unlock_irqrestore(&fbdata->lock, flags);
Bruno Prémonta93ab842012-07-30 21:38:57 +0200287 mutex_unlock(&info->lock);
Bruno Prémont16048702012-08-19 19:32:04 +0200288 if (data)
Benjamin Tissoiresb7966a42013-02-25 11:31:47 +0100289 hid_hw_wait(data->hdev);
Bruno Prémonta93ab842012-07-30 21:38:57 +0200290 return;
291 }
292out:
293 mutex_unlock(&info->lock);
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200294}
295
296/* Stub to call the system default and update the image on the picoLCD */
297static void picolcd_fb_fillrect(struct fb_info *info,
298 const struct fb_fillrect *rect)
299{
300 if (!info->par)
301 return;
302 sys_fillrect(info, rect);
303
304 schedule_delayed_work(&info->deferred_work, 0);
305}
306
307/* Stub to call the system default and update the image on the picoLCD */
308static void picolcd_fb_copyarea(struct fb_info *info,
309 const struct fb_copyarea *area)
310{
311 if (!info->par)
312 return;
313 sys_copyarea(info, area);
314
315 schedule_delayed_work(&info->deferred_work, 0);
316}
317
318/* Stub to call the system default and update the image on the picoLCD */
319static void picolcd_fb_imageblit(struct fb_info *info, const struct fb_image *image)
320{
321 if (!info->par)
322 return;
323 sys_imageblit(info, image);
324
325 schedule_delayed_work(&info->deferred_work, 0);
326}
327
328/*
329 * this is the slow path from userspace. they can seek and write to
330 * the fb. it's inefficient to do anything less than a full screen draw
331 */
332static ssize_t picolcd_fb_write(struct fb_info *info, const char __user *buf,
333 size_t count, loff_t *ppos)
334{
335 ssize_t ret;
336 if (!info->par)
337 return -ENODEV;
338 ret = fb_sys_write(info, buf, count, ppos);
339 if (ret >= 0)
340 schedule_delayed_work(&info->deferred_work, 0);
341 return ret;
342}
343
344static int picolcd_fb_blank(int blank, struct fb_info *info)
345{
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200346 /* We let fb notification do this for us via lcd/backlight device */
347 return 0;
348}
349
350static void picolcd_fb_destroy(struct fb_info *info)
351{
Bruno Prémont16048702012-08-19 19:32:04 +0200352 struct picolcd_fb_data *fbdata = info->par;
353
Bruno Prémont9966c372012-07-30 21:38:46 +0200354 /* make sure no work is deferred */
Bruno Prémonta93ab842012-07-30 21:38:57 +0200355 fb_deferred_io_cleanup(info);
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200356
Bruno Prémont16048702012-08-19 19:32:04 +0200357 /* No thridparty should ever unregister our framebuffer! */
358 WARN_ON(fbdata->picolcd != NULL);
359
Bruno Prémont9966c372012-07-30 21:38:46 +0200360 vfree((u8 *)info->fix.smem_start);
361 framebuffer_release(info);
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200362}
363
364static int picolcd_fb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
365{
366 __u32 bpp = var->bits_per_pixel;
367 __u32 activate = var->activate;
368
369 /* only allow 1/8 bit depth (8-bit is grayscale) */
370 *var = picolcdfb_var;
371 var->activate = activate;
372 if (bpp >= 8) {
373 var->bits_per_pixel = 8;
374 var->red.length = 8;
375 var->green.length = 8;
376 var->blue.length = 8;
377 } else {
378 var->bits_per_pixel = 1;
379 var->red.length = 1;
380 var->green.length = 1;
381 var->blue.length = 1;
382 }
383 return 0;
384}
385
386static int picolcd_set_par(struct fb_info *info)
387{
Bruno Prémont16048702012-08-19 19:32:04 +0200388 struct picolcd_fb_data *fbdata = info->par;
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200389 u8 *tmp_fb, *o_fb;
Bruno Prémont16048702012-08-19 19:32:04 +0200390 if (info->var.bits_per_pixel == fbdata->bpp)
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200391 return 0;
392 /* switch between 1/8 bit depths */
393 if (info->var.bits_per_pixel != 1 && info->var.bits_per_pixel != 8)
394 return -EINVAL;
395
Bruno Prémont16048702012-08-19 19:32:04 +0200396 o_fb = fbdata->bitmap;
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200397 tmp_fb = kmalloc(PICOLCDFB_SIZE*info->var.bits_per_pixel, GFP_KERNEL);
398 if (!tmp_fb)
399 return -ENOMEM;
400
401 /* translate FB content to new bits-per-pixel */
402 if (info->var.bits_per_pixel == 1) {
403 int i, b;
404 for (i = 0; i < PICOLCDFB_SIZE; i++) {
405 u8 p = 0;
406 for (b = 0; b < 8; b++) {
407 p <<= 1;
408 p |= o_fb[i*8+b] ? 0x01 : 0x00;
409 }
410 tmp_fb[i] = p;
411 }
412 memcpy(o_fb, tmp_fb, PICOLCDFB_SIZE);
413 info->fix.visual = FB_VISUAL_MONO01;
414 info->fix.line_length = PICOLCDFB_WIDTH / 8;
415 } else {
416 int i;
417 memcpy(tmp_fb, o_fb, PICOLCDFB_SIZE);
418 for (i = 0; i < PICOLCDFB_SIZE * 8; i++)
419 o_fb[i] = tmp_fb[i/8] & (0x01 << (7 - i % 8)) ? 0xff : 0x00;
420 info->fix.visual = FB_VISUAL_DIRECTCOLOR;
421 info->fix.line_length = PICOLCDFB_WIDTH;
422 }
423
424 kfree(tmp_fb);
Bruno Prémont16048702012-08-19 19:32:04 +0200425 fbdata->bpp = info->var.bits_per_pixel;
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200426 return 0;
427}
428
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200429/* Note this can't be const because of struct fb_info definition */
430static struct fb_ops picolcdfb_ops = {
431 .owner = THIS_MODULE,
432 .fb_destroy = picolcd_fb_destroy,
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200433 .fb_read = fb_sys_read,
434 .fb_write = picolcd_fb_write,
435 .fb_blank = picolcd_fb_blank,
436 .fb_fillrect = picolcd_fb_fillrect,
437 .fb_copyarea = picolcd_fb_copyarea,
438 .fb_imageblit = picolcd_fb_imageblit,
439 .fb_check_var = picolcd_fb_check_var,
440 .fb_set_par = picolcd_set_par,
441};
442
443
444/* Callback from deferred IO workqueue */
445static void picolcd_fb_deferred_io(struct fb_info *info, struct list_head *pagelist)
446{
Bruno Prémonta93ab842012-07-30 21:38:57 +0200447 picolcd_fb_update(info);
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200448}
449
450static const struct fb_deferred_io picolcd_fb_defio = {
451 .delay = HZ / PICOLCDFB_UPDATE_RATE_DEFAULT,
452 .deferred_io = picolcd_fb_deferred_io,
453};
454
455
456/*
457 * The "fb_update_rate" sysfs attribute
458 */
459static ssize_t picolcd_fb_update_rate_show(struct device *dev,
460 struct device_attribute *attr, char *buf)
461{
462 struct picolcd_data *data = dev_get_drvdata(dev);
Bruno Prémont16048702012-08-19 19:32:04 +0200463 struct picolcd_fb_data *fbdata = data->fb_info->par;
464 unsigned i, fb_update_rate = fbdata->update_rate;
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200465 size_t ret = 0;
466
467 for (i = 1; i <= PICOLCDFB_UPDATE_RATE_LIMIT; i++)
468 if (ret >= PAGE_SIZE)
469 break;
470 else if (i == fb_update_rate)
471 ret += snprintf(buf+ret, PAGE_SIZE-ret, "[%u] ", i);
472 else
473 ret += snprintf(buf+ret, PAGE_SIZE-ret, "%u ", i);
474 if (ret > 0)
475 buf[min(ret, (size_t)PAGE_SIZE)-1] = '\n';
476 return ret;
477}
478
479static ssize_t picolcd_fb_update_rate_store(struct device *dev,
480 struct device_attribute *attr, const char *buf, size_t count)
481{
482 struct picolcd_data *data = dev_get_drvdata(dev);
Bruno Prémont16048702012-08-19 19:32:04 +0200483 struct picolcd_fb_data *fbdata = data->fb_info->par;
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200484 int i;
485 unsigned u;
486
487 if (count < 1 || count > 10)
488 return -EINVAL;
489
490 i = sscanf(buf, "%u", &u);
491 if (i != 1)
492 return -EINVAL;
493
494 if (u > PICOLCDFB_UPDATE_RATE_LIMIT)
495 return -ERANGE;
496 else if (u == 0)
497 u = PICOLCDFB_UPDATE_RATE_DEFAULT;
498
Bruno Prémont16048702012-08-19 19:32:04 +0200499 fbdata->update_rate = u;
500 data->fb_info->fbdefio->delay = HZ / fbdata->update_rate;
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200501 return count;
502}
503
504static DEVICE_ATTR(fb_update_rate, 0666, picolcd_fb_update_rate_show,
505 picolcd_fb_update_rate_store);
506
507/* initialize Framebuffer device */
508int picolcd_init_framebuffer(struct picolcd_data *data)
509{
510 struct device *dev = &data->hdev->dev;
511 struct fb_info *info = NULL;
Bruno Prémont16048702012-08-19 19:32:04 +0200512 struct picolcd_fb_data *fbdata = NULL;
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200513 int i, error = -ENOMEM;
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200514 u32 *palette;
515
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200516 /* The extra memory is:
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200517 * - 256*u32 for pseudo_palette
Bruno Prémont9966c372012-07-30 21:38:46 +0200518 * - struct fb_deferred_io
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200519 */
Bruno Prémont9966c372012-07-30 21:38:46 +0200520 info = framebuffer_alloc(256 * sizeof(u32) +
Bruno Prémont16048702012-08-19 19:32:04 +0200521 sizeof(struct fb_deferred_io) +
522 sizeof(struct picolcd_fb_data) +
523 PICOLCDFB_SIZE, dev);
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200524 if (info == NULL) {
525 dev_err(dev, "failed to allocate a framebuffer\n");
526 goto err_nomem;
527 }
528
Bruno Prémont9966c372012-07-30 21:38:46 +0200529 info->fbdefio = info->par;
530 *info->fbdefio = picolcd_fb_defio;
Bruno Prémont16048702012-08-19 19:32:04 +0200531 info->par += sizeof(struct fb_deferred_io);
532 palette = info->par;
533 info->par += 256 * sizeof(u32);
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200534 for (i = 0; i < 256; i++)
535 palette[i] = i > 0 && i < 16 ? 0xff : 0;
536 info->pseudo_palette = palette;
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200537 info->fbops = &picolcdfb_ops;
538 info->var = picolcdfb_var;
539 info->fix = picolcdfb_fix;
540 info->fix.smem_len = PICOLCDFB_SIZE*8;
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200541 info->flags = FBINFO_FLAG_DEFAULT;
542
Bruno Prémont16048702012-08-19 19:32:04 +0200543 fbdata = info->par;
544 spin_lock_init(&fbdata->lock);
545 fbdata->picolcd = data;
546 fbdata->update_rate = PICOLCDFB_UPDATE_RATE_DEFAULT;
547 fbdata->bpp = picolcdfb_var.bits_per_pixel;
548 fbdata->force = 1;
549 fbdata->vbitmap = info->par + sizeof(struct picolcd_fb_data);
550 fbdata->bitmap = vmalloc(PICOLCDFB_SIZE*8);
551 if (fbdata->bitmap == NULL) {
552 dev_err(dev, "can't get a free page for framebuffer\n");
553 goto err_nomem;
554 }
555 info->screen_base = (char __force __iomem *)fbdata->bitmap;
556 info->fix.smem_start = (unsigned long)fbdata->bitmap;
557 memset(fbdata->vbitmap, 0xff, PICOLCDFB_SIZE);
558 data->fb_info = info;
559
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200560 error = picolcd_fb_reset(data, 1);
561 if (error) {
562 dev_err(dev, "failed to configure display\n");
563 goto err_cleanup;
564 }
Bruno Prémont16048702012-08-19 19:32:04 +0200565
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200566 error = device_create_file(dev, &dev_attr_fb_update_rate);
567 if (error) {
568 dev_err(dev, "failed to create sysfs attributes\n");
569 goto err_cleanup;
570 }
Bruno Prémont16048702012-08-19 19:32:04 +0200571
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200572 fb_deferred_io_init(info);
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200573 error = register_framebuffer(info);
574 if (error) {
575 dev_err(dev, "failed to register framebuffer\n");
576 goto err_sysfs;
577 }
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200578 return 0;
579
580err_sysfs:
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200581 device_remove_file(dev, &dev_attr_fb_update_rate);
Bruno Prémont16048702012-08-19 19:32:04 +0200582 fb_deferred_io_cleanup(info);
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200583err_cleanup:
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200584 data->fb_info = NULL;
585
586err_nomem:
Bruno Prémont16048702012-08-19 19:32:04 +0200587 if (fbdata)
588 vfree(fbdata->bitmap);
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200589 framebuffer_release(info);
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200590 return error;
591}
592
593void picolcd_exit_framebuffer(struct picolcd_data *data)
594{
595 struct fb_info *info = data->fb_info;
Bruno Prémont16048702012-08-19 19:32:04 +0200596 struct picolcd_fb_data *fbdata = info->par;
597 unsigned long flags;
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200598
599 device_remove_file(&data->hdev->dev, &dev_attr_fb_update_rate);
Bruno Prémont16048702012-08-19 19:32:04 +0200600
601 /* disconnect framebuffer from HID dev */
602 spin_lock_irqsave(&fbdata->lock, flags);
603 fbdata->picolcd = NULL;
604 spin_unlock_irqrestore(&fbdata->lock, flags);
605
606 /* make sure there is no running update - thus that fbdata->picolcd
607 * once obtained under lock is guaranteed not to get free() under
608 * the feet of the deferred work */
Linus Torvalds033d9952012-10-02 09:54:49 -0700609 flush_delayed_work(&info->deferred_work);
Bruno Prémont16048702012-08-19 19:32:04 +0200610
611 data->fb_info = NULL;
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200612 unregister_framebuffer(info);
Bruno Prémontfabdbf22012-07-30 21:38:28 +0200613}