?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
staging: vt6655: MACvSaveContext use memcpy_fromio to read context.
[linux/fpc-iii.git] / drivers / video / fbdev / ssd1307fb.c
blobfa3480815cdb61dadec19f15772523c6eaf35cbd
1 /*
2 * Driver for the Solomon SSD1307 OLED controller
3 *
4 * Copyright 2012 Free Electrons
5 *
6 * Licensed under the GPLv2 or later.
7 */
8
9 #include <linux/backlight.h>
10 #include <linux/delay.h>
11 #include <linux/fb.h>
12 #include <linux/i2c.h>
13 #include <linux/kernel.h>
14 #include <linux/module.h>
15 #include <linux/of_device.h>
16 #include <linux/of_gpio.h>
17 #include <linux/pwm.h>
18 #include <linux/uaccess.h>
19
20 #define SSD1307FB_DATA 0x40
21 #define SSD1307FB_COMMAND 0x80
22
23 #define SSD1307FB_SET_ADDRESS_MODE 0x20
24 #define SSD1307FB_SET_ADDRESS_MODE_HORIZONTAL (0x00)
25 #define SSD1307FB_SET_ADDRESS_MODE_VERTICAL (0x01)
26 #define SSD1307FB_SET_ADDRESS_MODE_PAGE (0x02)
27 #define SSD1307FB_SET_COL_RANGE 0x21
28 #define SSD1307FB_SET_PAGE_RANGE 0x22
29 #define SSD1307FB_CONTRAST 0x81
30 #define SSD1307FB_CHARGE_PUMP 0x8d
31 #define SSD1307FB_SEG_REMAP_ON 0xa1
32 #define SSD1307FB_DISPLAY_OFF 0xae
33 #define SSD1307FB_SET_MULTIPLEX_RATIO 0xa8
34 #define SSD1307FB_DISPLAY_ON 0xaf
35 #define SSD1307FB_START_PAGE_ADDRESS 0xb0
36 #define SSD1307FB_SET_DISPLAY_OFFSET 0xd3
37 #define SSD1307FB_SET_CLOCK_FREQ 0xd5
38 #define SSD1307FB_SET_PRECHARGE_PERIOD 0xd9
39 #define SSD1307FB_SET_COM_PINS_CONFIG 0xda
40 #define SSD1307FB_SET_VCOMH 0xdb
41
42 #define MAX_CONTRAST 255
43
44 #define REFRESHRATE 1
45
46 static u_int refreshrate = REFRESHRATE;
47 module_param(refreshrate, uint, 0);
48
49 struct ssd1307fb_par;
50
51 struct ssd1307fb_deviceinfo {
52 u32 default_vcomh;
53 u32 default_dclk_div;
54 u32 default_dclk_frq;
55 int need_pwm;
56 int need_chargepump;
57 };
58
59 struct ssd1307fb_par {
60 u32 com_invdir;
61 u32 com_lrremap;
62 u32 com_offset;
63 u32 com_seq;
64 u32 contrast;
65 u32 dclk_div;
66 u32 dclk_frq;
67 struct ssd1307fb_deviceinfo *device_info;
68 struct i2c_client *client;
69 u32 height;
70 struct fb_info *info;
71 u32 page_offset;
72 u32 prechargep1;
73 u32 prechargep2;
74 struct pwm_device *pwm;
75 u32 pwm_period;
76 int reset;
77 u32 seg_remap;
78 u32 vcomh;
79 u32 width;
80 };
81
82 struct ssd1307fb_array {
83 u8 type;
84 u8 data[0];
85 };
86
87 static struct fb_fix_screeninfo ssd1307fb_fix = {
88 .id = "Solomon SSD1307",
89 .type = FB_TYPE_PACKED_PIXELS,
90 .visual = FB_VISUAL_MONO10,
91 .xpanstep = 0,
92 .ypanstep = 0,
93 .ywrapstep = 0,
94 .accel = FB_ACCEL_NONE,
95 };
96
97 static struct fb_var_screeninfo ssd1307fb_var = {
98 .bits_per_pixel = 1,
99 };
100
101 static struct ssd1307fb_array *ssd1307fb_alloc_array(u32 len, u8 type)
102 {
103 struct ssd1307fb_array *array;
104
105 array = kzalloc(sizeof(struct ssd1307fb_array) + len, GFP_KERNEL);
106 if (!array)
107 return NULL;
108
109 array->type = type;
110
111 return array;
112 }
113
114 static int ssd1307fb_write_array(struct i2c_client *client,
115 struct ssd1307fb_array *array, u32 len)
116 {
117 int ret;
118
119 len += sizeof(struct ssd1307fb_array);
120
121 ret = i2c_master_send(client, (u8 *)array, len);
122 if (ret != len) {
123 dev_err(&client->dev, "Couldn't send I2C command.\n");
124 return ret;
125 }
126
127 return 0;
128 }
129
130 static inline int ssd1307fb_write_cmd(struct i2c_client *client, u8 cmd)
131 {
132 struct ssd1307fb_array *array;
133 int ret;
134
135 array = ssd1307fb_alloc_array(1, SSD1307FB_COMMAND);
136 if (!array)
137 return -ENOMEM;
138
139 array->data[0] = cmd;
140
141 ret = ssd1307fb_write_array(client, array, 1);
142 kfree(array);
143
144 return ret;
145 }
146
147 static void ssd1307fb_update_display(struct ssd1307fb_par *par)
148 {
149 struct ssd1307fb_array *array;
150 u8 *vmem = par->info->screen_base;
151 int i, j, k;
152
153 array = ssd1307fb_alloc_array(par->width * par->height / 8,
154 SSD1307FB_DATA);
155 if (!array)
156 return;
157
158 /*
159 * The screen is divided in pages, each having a height of 8
160 * pixels, and the width of the screen. When sending a byte of
161 * data to the controller, it gives the 8 bits for the current
162 * column. I.e, the first byte are the 8 bits of the first
163 * column, then the 8 bits for the second column, etc.
164 *
165 *
166 * Representation of the screen, assuming it is 5 bits
167 * wide. Each letter-number combination is a bit that controls
168 * one pixel.
169 *
170 * A0 A1 A2 A3 A4
171 * B0 B1 B2 B3 B4
172 * C0 C1 C2 C3 C4
173 * D0 D1 D2 D3 D4
174 * E0 E1 E2 E3 E4
175 * F0 F1 F2 F3 F4
176 * G0 G1 G2 G3 G4
177 * H0 H1 H2 H3 H4
178 *
179 * If you want to update this screen, you need to send 5 bytes:
180 * (1) A0 B0 C0 D0 E0 F0 G0 H0
181 * (2) A1 B1 C1 D1 E1 F1 G1 H1
182 * (3) A2 B2 C2 D2 E2 F2 G2 H2
183 * (4) A3 B3 C3 D3 E3 F3 G3 H3
184 * (5) A4 B4 C4 D4 E4 F4 G4 H4
185 */
186
187 for (i = 0; i < (par->height / 8); i++) {
188 for (j = 0; j < par->width; j++) {
189 u32 array_idx = i * par->width + j;
190 array->data[array_idx] = 0;
191 for (k = 0; k < 8; k++) {
192 u32 page_length = par->width * i;
193 u32 index = page_length + (par->width * k + j) / 8;
194 u8 byte = *(vmem + index);
195 u8 bit = byte & (1 << (j % 8));
196 bit = bit >> (j % 8);
197 array->data[array_idx] |= bit << k;
198 }
199 }
200 }
201
202 ssd1307fb_write_array(par->client, array, par->width * par->height / 8);
203 kfree(array);
204 }
205
206
207 static ssize_t ssd1307fb_write(struct fb_info *info, const char __user *buf,
208 size_t count, loff_t *ppos)
209 {
210 struct ssd1307fb_par *par = info->par;
211 unsigned long total_size;
212 unsigned long p = *ppos;
213 u8 __iomem *dst;
214
215 total_size = info->fix.smem_len;
216
217 if (p > total_size)
218 return -EINVAL;
219
220 if (count + p > total_size)
221 count = total_size - p;
222
223 if (!count)
224 return -EINVAL;
225
226 dst = (void __force *) (info->screen_base + p);
227
228 if (copy_from_user(dst, buf, count))
229 return -EFAULT;
230
231 ssd1307fb_update_display(par);
232
233 *ppos += count;
234
235 return count;
236 }
237
238 static int ssd1307fb_blank(int blank_mode, struct fb_info *info)
239 {
240 struct ssd1307fb_par *par = info->par;
241
242 if (blank_mode != FB_BLANK_UNBLANK)
243 return ssd1307fb_write_cmd(par->client, SSD1307FB_DISPLAY_OFF);
244 else
245 return ssd1307fb_write_cmd(par->client, SSD1307FB_DISPLAY_ON);
246 }
247
248 static void ssd1307fb_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
249 {
250 struct ssd1307fb_par *par = info->par;
251 sys_fillrect(info, rect);
252 ssd1307fb_update_display(par);
253 }
254
255 static void ssd1307fb_copyarea(struct fb_info *info, const struct fb_copyarea *area)
256 {
257 struct ssd1307fb_par *par = info->par;
258 sys_copyarea(info, area);
259 ssd1307fb_update_display(par);
260 }
261
262 static void ssd1307fb_imageblit(struct fb_info *info, const struct fb_image *image)
263 {
264 struct ssd1307fb_par *par = info->par;
265 sys_imageblit(info, image);
266 ssd1307fb_update_display(par);
267 }
268
269 static struct fb_ops ssd1307fb_ops = {
270 .owner = THIS_MODULE,
271 .fb_read = fb_sys_read,
272 .fb_write = ssd1307fb_write,
273 .fb_blank = ssd1307fb_blank,
274 .fb_fillrect = ssd1307fb_fillrect,
275 .fb_copyarea = ssd1307fb_copyarea,
276 .fb_imageblit = ssd1307fb_imageblit,
277 };
278
279 static void ssd1307fb_deferred_io(struct fb_info *info,
280 struct list_head *pagelist)
281 {
282 ssd1307fb_update_display(info->par);
283 }
284
285 static int ssd1307fb_init(struct ssd1307fb_par *par)
286 {
287 int ret;
288 u32 precharge, dclk, com_invdir, compins;
289
290 if (par->device_info->need_pwm) {
291 par->pwm = pwm_get(&par->client->dev, NULL);
292 if (IS_ERR(par->pwm)) {
293 dev_err(&par->client->dev, "Could not get PWM from device tree!\n");
294 return PTR_ERR(par->pwm);
295 }
296
297 par->pwm_period = pwm_get_period(par->pwm);
298 /* Enable the PWM */
299 pwm_config(par->pwm, par->pwm_period / 2, par->pwm_period);
300 pwm_enable(par->pwm);
301
302 dev_dbg(&par->client->dev, "Using PWM%d with a %dns period.\n",
303 par->pwm->pwm, par->pwm_period);
304 };
305
306 /* Set initial contrast */
307 ret = ssd1307fb_write_cmd(par->client, SSD1307FB_CONTRAST);
308 if (ret < 0)
309 return ret;
310
311 ret = ssd1307fb_write_cmd(par->client, par->contrast);
312 if (ret < 0)
313 return ret;
314
315 /* Set segment re-map */
316 if (par->seg_remap) {
317 ret = ssd1307fb_write_cmd(par->client, SSD1307FB_SEG_REMAP_ON);
318 if (ret < 0)
319 return ret;
320 };
321
322 /* Set COM direction */
323 com_invdir = 0xc0 | (par->com_invdir & 0x1) << 3;
324 ret = ssd1307fb_write_cmd(par->client, com_invdir);
325 if (ret < 0)
326 return ret;
327
328 /* Set multiplex ratio value */
329 ret = ssd1307fb_write_cmd(par->client, SSD1307FB_SET_MULTIPLEX_RATIO);
330 if (ret < 0)
331 return ret;
332
333 ret = ssd1307fb_write_cmd(par->client, par->height - 1);
334 if (ret < 0)
335 return ret;
336
337 /* set display offset value */
338 ret = ssd1307fb_write_cmd(par->client, SSD1307FB_SET_DISPLAY_OFFSET);
339 if (ret < 0)
340 return ret;
341
342 ret = ssd1307fb_write_cmd(par->client, par->com_offset);
343 if (ret < 0)
344 return ret;
345
346 /* Set clock frequency */
347 ret = ssd1307fb_write_cmd(par->client, SSD1307FB_SET_CLOCK_FREQ);
348 if (ret < 0)
349 return ret;
350
351 dclk = ((par->dclk_div - 1) & 0xf) | (par->dclk_frq & 0xf) << 4;
352 ret = ssd1307fb_write_cmd(par->client, dclk);
353 if (ret < 0)
354 return ret;
355
356 /* Set precharge period in number of ticks from the internal clock */
357 ret = ssd1307fb_write_cmd(par->client, SSD1307FB_SET_PRECHARGE_PERIOD);
358 if (ret < 0)
359 return ret;
360
361 precharge = (par->prechargep1 & 0xf) | (par->prechargep2 & 0xf) << 4;
362 ret = ssd1307fb_write_cmd(par->client, precharge);
363 if (ret < 0)
364 return ret;
365
366 /* Set COM pins configuration */
367 ret = ssd1307fb_write_cmd(par->client, SSD1307FB_SET_COM_PINS_CONFIG);
368 if (ret < 0)
369 return ret;
370
371 compins = 0x02 | !(par->com_seq & 0x1) << 4
372 | (par->com_lrremap & 0x1) << 5;
373 ret = ssd1307fb_write_cmd(par->client, compins);
374 if (ret < 0)
375 return ret;
376
377 /* Set VCOMH */
378 ret = ssd1307fb_write_cmd(par->client, SSD1307FB_SET_VCOMH);
379 if (ret < 0)
380 return ret;
381
382 ret = ssd1307fb_write_cmd(par->client, par->vcomh);
383 if (ret < 0)
384 return ret;
385
386 /* Turn on the DC-DC Charge Pump */
387 ret = ssd1307fb_write_cmd(par->client, SSD1307FB_CHARGE_PUMP);
388 if (ret < 0)
389 return ret;
390
391 ret = ssd1307fb_write_cmd(par->client,
392 (par->device_info->need_chargepump & 0x1 << 2) & 0x14);
393 if (ret < 0)
394 return ret;
395
396 /* Switch to horizontal addressing mode */
397 ret = ssd1307fb_write_cmd(par->client, SSD1307FB_SET_ADDRESS_MODE);
398 if (ret < 0)
399 return ret;
400
401 ret = ssd1307fb_write_cmd(par->client,
402 SSD1307FB_SET_ADDRESS_MODE_HORIZONTAL);
403 if (ret < 0)
404 return ret;
405
406 /* Set column range */
407 ret = ssd1307fb_write_cmd(par->client, SSD1307FB_SET_COL_RANGE);
408 if (ret < 0)
409 return ret;
410
411 ret = ssd1307fb_write_cmd(par->client, 0x0);
412 if (ret < 0)
413 return ret;
414
415 ret = ssd1307fb_write_cmd(par->client, par->width - 1);
416 if (ret < 0)
417 return ret;
418
419 /* Set page range */
420 ret = ssd1307fb_write_cmd(par->client, SSD1307FB_SET_PAGE_RANGE);
421 if (ret < 0)
422 return ret;
423
424 ret = ssd1307fb_write_cmd(par->client, 0x0);
425 if (ret < 0)
426 return ret;
427
428 ret = ssd1307fb_write_cmd(par->client,
429 par->page_offset + (par->height / 8) - 1);
430 if (ret < 0)
431 return ret;
432
433 /* Turn on the display */
434 ret = ssd1307fb_write_cmd(par->client, SSD1307FB_DISPLAY_ON);
435 if (ret < 0)
436 return ret;
437
438 return 0;
439 }
440
441 static int ssd1307fb_update_bl(struct backlight_device *bdev)
442 {
443 struct ssd1307fb_par *par = bl_get_data(bdev);
444 int ret;
445 int brightness = bdev->props.brightness;
446
447 par->contrast = brightness;
448
449 ret = ssd1307fb_write_cmd(par->client, SSD1307FB_CONTRAST);
450 if (ret < 0)
451 return ret;
452 ret = ssd1307fb_write_cmd(par->client, par->contrast);
453 if (ret < 0)
454 return ret;
455 return 0;
456 }
457
458 static int ssd1307fb_get_brightness(struct backlight_device *bdev)
459 {
460 struct ssd1307fb_par *par = bl_get_data(bdev);
461
462 return par->contrast;
463 }
464
465 static int ssd1307fb_check_fb(struct backlight_device *bdev,
466 struct fb_info *info)
467 {
468 return (info->bl_dev == bdev);
469 }
470
471 static const struct backlight_ops ssd1307fb_bl_ops = {
472 .options = BL_CORE_SUSPENDRESUME,
473 .update_status = ssd1307fb_update_bl,
474 .get_brightness = ssd1307fb_get_brightness,
475 .check_fb = ssd1307fb_check_fb,
476 };
477
478 static struct ssd1307fb_deviceinfo ssd1307fb_ssd1305_deviceinfo = {
479 .default_vcomh = 0x34,
480 .default_dclk_div = 1,
481 .default_dclk_frq = 7,
482 };
483
484 static struct ssd1307fb_deviceinfo ssd1307fb_ssd1306_deviceinfo = {
485 .default_vcomh = 0x20,
486 .default_dclk_div = 1,
487 .default_dclk_frq = 8,
488 .need_chargepump = 1,
489 };
490
491 static struct ssd1307fb_deviceinfo ssd1307fb_ssd1307_deviceinfo = {
492 .default_vcomh = 0x20,
493 .default_dclk_div = 2,
494 .default_dclk_frq = 12,
495 .need_pwm = 1,
496 };
497
498 static struct ssd1307fb_deviceinfo ssd1307fb_ssd1309_deviceinfo = {
499 .default_vcomh = 0x34,
500 .default_dclk_div = 1,
501 .default_dclk_frq = 10,
502 };
503
504 static const struct of_device_id ssd1307fb_of_match[] = {
505 {
506 .compatible = "solomon,ssd1305fb-i2c",
507 .data = (void *)&ssd1307fb_ssd1305_deviceinfo,
508 },
509 {
510 .compatible = "solomon,ssd1306fb-i2c",
511 .data = (void *)&ssd1307fb_ssd1306_deviceinfo,
512 },
513 {
514 .compatible = "solomon,ssd1307fb-i2c",
515 .data = (void *)&ssd1307fb_ssd1307_deviceinfo,
516 },
517 {
518 .compatible = "solomon,ssd1309fb-i2c",
519 .data = (void *)&ssd1307fb_ssd1309_deviceinfo,
520 },
521 {},
522 };
523 MODULE_DEVICE_TABLE(of, ssd1307fb_of_match);
524
525 static int ssd1307fb_probe(struct i2c_client *client,
526 const struct i2c_device_id *id)
527 {
528 struct backlight_device *bl;
529 char bl_name[12];
530 struct fb_info *info;
531 struct device_node *node = client->dev.of_node;
532 struct fb_deferred_io *ssd1307fb_defio;
533 u32 vmem_size;
534 struct ssd1307fb_par *par;
535 u8 *vmem;
536 int ret;
537
538 if (!node) {
539 dev_err(&client->dev, "No device tree data found!\n");
540 return -EINVAL;
541 }
542
543 info = framebuffer_alloc(sizeof(struct ssd1307fb_par), &client->dev);
544 if (!info) {
545 dev_err(&client->dev, "Couldn't allocate framebuffer.\n");
546 return -ENOMEM;
547 }
548
549 par = info->par;
550 par->info = info;
551 par->client = client;
552
553 par->device_info = (struct ssd1307fb_deviceinfo *)of_match_device(
554 ssd1307fb_of_match, &client->dev)->data;
555
556 par->reset = of_get_named_gpio(client->dev.of_node,
557 "reset-gpios", 0);
558 if (!gpio_is_valid(par->reset)) {
559 ret = -EINVAL;
560 goto fb_alloc_error;
561 }
562
563 if (of_property_read_u32(node, "solomon,width", &par->width))
564 par->width = 96;
565
566 if (of_property_read_u32(node, "solomon,height", &par->height))
567 par->height = 16;
568
569 if (of_property_read_u32(node, "solomon,page-offset", &par->page_offset))
570 par->page_offset = 1;
571
572 if (of_property_read_u32(node, "solomon,com-offset", &par->com_offset))
573 par->com_offset = 0;
574
575 if (of_property_read_u32(node, "solomon,prechargep1", &par->prechargep1))
576 par->prechargep1 = 2;
577
578 if (of_property_read_u32(node, "solomon,prechargep2", &par->prechargep2))
579 par->prechargep2 = 2;
580
581 par->seg_remap = !of_property_read_bool(node, "solomon,segment-no-remap");
582 par->com_seq = of_property_read_bool(node, "solomon,com-seq");
583 par->com_lrremap = of_property_read_bool(node, "solomon,com-lrremap");
584 par->com_invdir = of_property_read_bool(node, "solomon,com-invdir");
585
586 par->contrast = 127;
587 par->vcomh = par->device_info->default_vcomh;
588
589 /* Setup display timing */
590 par->dclk_div = par->device_info->default_dclk_div;
591 par->dclk_frq = par->device_info->default_dclk_frq;
592
593 vmem_size = par->width * par->height / 8;
594
595 vmem = (void *)__get_free_pages(GFP_KERNEL | __GFP_ZERO,
596 get_order(vmem_size));
597 if (!vmem) {
598 dev_err(&client->dev, "Couldn't allocate graphical memory.\n");
599 ret = -ENOMEM;
600 goto fb_alloc_error;
601 }
602
603 ssd1307fb_defio = devm_kzalloc(&client->dev, sizeof(struct fb_deferred_io), GFP_KERNEL);
604 if (!ssd1307fb_defio) {
605 dev_err(&client->dev, "Couldn't allocate deferred io.\n");
606 ret = -ENOMEM;
607 goto fb_alloc_error;
608 }
609
610 ssd1307fb_defio->delay = HZ / refreshrate;
611 ssd1307fb_defio->deferred_io = ssd1307fb_deferred_io;
612
613 info->fbops = &ssd1307fb_ops;
614 info->fix = ssd1307fb_fix;
615 info->fix.line_length = par->width / 8;
616 info->fbdefio = ssd1307fb_defio;
617
618 info->var = ssd1307fb_var;
619 info->var.xres = par->width;
620 info->var.xres_virtual = par->width;
621 info->var.yres = par->height;
622 info->var.yres_virtual = par->height;
623
624 info->var.red.length = 1;
625 info->var.red.offset = 0;
626 info->var.green.length = 1;
627 info->var.green.offset = 0;
628 info->var.blue.length = 1;
629 info->var.blue.offset = 0;
630
631 info->screen_base = (u8 __force __iomem *)vmem;
632 info->fix.smem_start = __pa(vmem);
633 info->fix.smem_len = vmem_size;
634
635 fb_deferred_io_init(info);
636
637 ret = devm_gpio_request_one(&client->dev, par->reset,
638 GPIOF_OUT_INIT_HIGH,
639 "oled-reset");
640 if (ret) {
641 dev_err(&client->dev,
642 "failed to request gpio %d: %d\n",
643 par->reset, ret);
644 goto reset_oled_error;
645 }
646
647 i2c_set_clientdata(client, info);
648
649 /* Reset the screen */
650 gpio_set_value(par->reset, 0);
651 udelay(4);
652 gpio_set_value(par->reset, 1);
653 udelay(4);
654
655 ret = ssd1307fb_init(par);
656 if (ret)
657 goto reset_oled_error;
658
659 ret = register_framebuffer(info);
660 if (ret) {
661 dev_err(&client->dev, "Couldn't register the framebuffer\n");
662 goto panel_init_error;
663 }
664
665 snprintf(bl_name, sizeof(bl_name), "ssd1307fb%d", info->node);
666 bl = backlight_device_register(bl_name, &client->dev, par,
667 &ssd1307fb_bl_ops, NULL);
668 if (IS_ERR(bl)) {
669 ret = PTR_ERR(bl);
670 dev_err(&client->dev, "unable to register backlight device: %d\n",
671 ret);
672 goto bl_init_error;
673 }
674
675 bl->props.brightness = par->contrast;
676 bl->props.max_brightness = MAX_CONTRAST;
677 info->bl_dev = bl;
678
679 dev_info(&client->dev, "fb%d: %s framebuffer device registered, using %d bytes of video memory\n", info->node, info->fix.id, vmem_size);
680
681 return 0;
682
683 bl_init_error:
684 unregister_framebuffer(info);
685 panel_init_error:
686 if (par->device_info->need_pwm) {
687 pwm_disable(par->pwm);
688 pwm_put(par->pwm);
689 };
690 reset_oled_error:
691 fb_deferred_io_cleanup(info);
692 fb_alloc_error:
693 framebuffer_release(info);
694 return ret;
695 }
696
697 static int ssd1307fb_remove(struct i2c_client *client)
698 {
699 struct fb_info *info = i2c_get_clientdata(client);
700 struct ssd1307fb_par *par = info->par;
701
702 ssd1307fb_write_cmd(par->client, SSD1307FB_DISPLAY_OFF);
703
704 backlight_device_unregister(info->bl_dev);
705
706 unregister_framebuffer(info);
707 if (par->device_info->need_pwm) {
708 pwm_disable(par->pwm);
709 pwm_put(par->pwm);
710 };
711 fb_deferred_io_cleanup(info);
712 __free_pages(__va(info->fix.smem_start), get_order(info->fix.smem_len));
713 framebuffer_release(info);
714
715 return 0;
716 }
717
718 static const struct i2c_device_id ssd1307fb_i2c_id[] = {
719 { "ssd1305fb", 0 },
720 { "ssd1306fb", 0 },
721 { "ssd1307fb", 0 },
722 { "ssd1309fb", 0 },
723 { }
724 };
725 MODULE_DEVICE_TABLE(i2c, ssd1307fb_i2c_id);
726
727 static struct i2c_driver ssd1307fb_driver = {
728 .probe = ssd1307fb_probe,
729 .remove = ssd1307fb_remove,
730 .id_table = ssd1307fb_i2c_id,
731 .driver = {
732 .name = "ssd1307fb",
733 .of_match_table = ssd1307fb_of_match,
734 },
735 };
736
737 module_i2c_driver(ssd1307fb_driver);
738
739 MODULE_DESCRIPTION("FB driver for the Solomon SSD1307 OLED controller");
740 MODULE_AUTHOR("Maxime Ripard <maxime.ripard@free-electrons.com>");
741 MODULE_LICENSE("GPL");
Linux with added FPC-III support