?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
sh_eth: fix EESIPR values for SH77{34|63}
[linux/fpc-iii.git] / drivers / video / fbdev / ssd1307fb.c
blob2925d5ce8d3e561c1d674cab95be1ce757ed8f39
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 const 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 const 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 const 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 struct pwm_args pargs;
290
291 if (par->device_info->need_pwm) {
292 par->pwm = pwm_get(&par->client->dev, NULL);
293 if (IS_ERR(par->pwm)) {
294 dev_err(&par->client->dev, "Could not get PWM from device tree!\n");
295 return PTR_ERR(par->pwm);
296 }
297
298 /*
299 * FIXME: pwm_apply_args() should be removed when switching to
300 * the atomic PWM API.
301 */
302 pwm_apply_args(par->pwm);
303
304 pwm_get_args(par->pwm, &pargs);
305
306 par->pwm_period = pargs.period;
307 /* Enable the PWM */
308 pwm_config(par->pwm, par->pwm_period / 2, par->pwm_period);
309 pwm_enable(par->pwm);
310
311 dev_dbg(&par->client->dev, "Using PWM%d with a %dns period.\n",
312 par->pwm->pwm, par->pwm_period);
313 };
314
315 /* Set initial contrast */
316 ret = ssd1307fb_write_cmd(par->client, SSD1307FB_CONTRAST);
317 if (ret < 0)
318 return ret;
319
320 ret = ssd1307fb_write_cmd(par->client, par->contrast);
321 if (ret < 0)
322 return ret;
323
324 /* Set segment re-map */
325 if (par->seg_remap) {
326 ret = ssd1307fb_write_cmd(par->client, SSD1307FB_SEG_REMAP_ON);
327 if (ret < 0)
328 return ret;
329 };
330
331 /* Set COM direction */
332 com_invdir = 0xc0 | (par->com_invdir & 0x1) << 3;
333 ret = ssd1307fb_write_cmd(par->client, com_invdir);
334 if (ret < 0)
335 return ret;
336
337 /* Set multiplex ratio value */
338 ret = ssd1307fb_write_cmd(par->client, SSD1307FB_SET_MULTIPLEX_RATIO);
339 if (ret < 0)
340 return ret;
341
342 ret = ssd1307fb_write_cmd(par->client, par->height - 1);
343 if (ret < 0)
344 return ret;
345
346 /* set display offset value */
347 ret = ssd1307fb_write_cmd(par->client, SSD1307FB_SET_DISPLAY_OFFSET);
348 if (ret < 0)
349 return ret;
350
351 ret = ssd1307fb_write_cmd(par->client, par->com_offset);
352 if (ret < 0)
353 return ret;
354
355 /* Set clock frequency */
356 ret = ssd1307fb_write_cmd(par->client, SSD1307FB_SET_CLOCK_FREQ);
357 if (ret < 0)
358 return ret;
359
360 dclk = ((par->dclk_div - 1) & 0xf) | (par->dclk_frq & 0xf) << 4;
361 ret = ssd1307fb_write_cmd(par->client, dclk);
362 if (ret < 0)
363 return ret;
364
365 /* Set precharge period in number of ticks from the internal clock */
366 ret = ssd1307fb_write_cmd(par->client, SSD1307FB_SET_PRECHARGE_PERIOD);
367 if (ret < 0)
368 return ret;
369
370 precharge = (par->prechargep1 & 0xf) | (par->prechargep2 & 0xf) << 4;
371 ret = ssd1307fb_write_cmd(par->client, precharge);
372 if (ret < 0)
373 return ret;
374
375 /* Set COM pins configuration */
376 ret = ssd1307fb_write_cmd(par->client, SSD1307FB_SET_COM_PINS_CONFIG);
377 if (ret < 0)
378 return ret;
379
380 compins = 0x02 | !(par->com_seq & 0x1) << 4
381 | (par->com_lrremap & 0x1) << 5;
382 ret = ssd1307fb_write_cmd(par->client, compins);
383 if (ret < 0)
384 return ret;
385
386 /* Set VCOMH */
387 ret = ssd1307fb_write_cmd(par->client, SSD1307FB_SET_VCOMH);
388 if (ret < 0)
389 return ret;
390
391 ret = ssd1307fb_write_cmd(par->client, par->vcomh);
392 if (ret < 0)
393 return ret;
394
395 /* Turn on the DC-DC Charge Pump */
396 ret = ssd1307fb_write_cmd(par->client, SSD1307FB_CHARGE_PUMP);
397 if (ret < 0)
398 return ret;
399
400 ret = ssd1307fb_write_cmd(par->client,
401 BIT(4) | (par->device_info->need_chargepump ? BIT(2) : 0));
402 if (ret < 0)
403 return ret;
404
405 /* Switch to horizontal addressing mode */
406 ret = ssd1307fb_write_cmd(par->client, SSD1307FB_SET_ADDRESS_MODE);
407 if (ret < 0)
408 return ret;
409
410 ret = ssd1307fb_write_cmd(par->client,
411 SSD1307FB_SET_ADDRESS_MODE_HORIZONTAL);
412 if (ret < 0)
413 return ret;
414
415 /* Set column range */
416 ret = ssd1307fb_write_cmd(par->client, SSD1307FB_SET_COL_RANGE);
417 if (ret < 0)
418 return ret;
419
420 ret = ssd1307fb_write_cmd(par->client, 0x0);
421 if (ret < 0)
422 return ret;
423
424 ret = ssd1307fb_write_cmd(par->client, par->width - 1);
425 if (ret < 0)
426 return ret;
427
428 /* Set page range */
429 ret = ssd1307fb_write_cmd(par->client, SSD1307FB_SET_PAGE_RANGE);
430 if (ret < 0)
431 return ret;
432
433 ret = ssd1307fb_write_cmd(par->client, 0x0);
434 if (ret < 0)
435 return ret;
436
437 ret = ssd1307fb_write_cmd(par->client,
438 par->page_offset + (par->height / 8) - 1);
439 if (ret < 0)
440 return ret;
441
442 /* Turn on the display */
443 ret = ssd1307fb_write_cmd(par->client, SSD1307FB_DISPLAY_ON);
444 if (ret < 0)
445 return ret;
446
447 return 0;
448 }
449
450 static int ssd1307fb_update_bl(struct backlight_device *bdev)
451 {
452 struct ssd1307fb_par *par = bl_get_data(bdev);
453 int ret;
454 int brightness = bdev->props.brightness;
455
456 par->contrast = brightness;
457
458 ret = ssd1307fb_write_cmd(par->client, SSD1307FB_CONTRAST);
459 if (ret < 0)
460 return ret;
461 ret = ssd1307fb_write_cmd(par->client, par->contrast);
462 if (ret < 0)
463 return ret;
464 return 0;
465 }
466
467 static int ssd1307fb_get_brightness(struct backlight_device *bdev)
468 {
469 struct ssd1307fb_par *par = bl_get_data(bdev);
470
471 return par->contrast;
472 }
473
474 static int ssd1307fb_check_fb(struct backlight_device *bdev,
475 struct fb_info *info)
476 {
477 return (info->bl_dev == bdev);
478 }
479
480 static const struct backlight_ops ssd1307fb_bl_ops = {
481 .options = BL_CORE_SUSPENDRESUME,
482 .update_status = ssd1307fb_update_bl,
483 .get_brightness = ssd1307fb_get_brightness,
484 .check_fb = ssd1307fb_check_fb,
485 };
486
487 static struct ssd1307fb_deviceinfo ssd1307fb_ssd1305_deviceinfo = {
488 .default_vcomh = 0x34,
489 .default_dclk_div = 1,
490 .default_dclk_frq = 7,
491 };
492
493 static struct ssd1307fb_deviceinfo ssd1307fb_ssd1306_deviceinfo = {
494 .default_vcomh = 0x20,
495 .default_dclk_div = 1,
496 .default_dclk_frq = 8,
497 .need_chargepump = 1,
498 };
499
500 static struct ssd1307fb_deviceinfo ssd1307fb_ssd1307_deviceinfo = {
501 .default_vcomh = 0x20,
502 .default_dclk_div = 2,
503 .default_dclk_frq = 12,
504 .need_pwm = 1,
505 };
506
507 static struct ssd1307fb_deviceinfo ssd1307fb_ssd1309_deviceinfo = {
508 .default_vcomh = 0x34,
509 .default_dclk_div = 1,
510 .default_dclk_frq = 10,
511 };
512
513 static const struct of_device_id ssd1307fb_of_match[] = {
514 {
515 .compatible = "solomon,ssd1305fb-i2c",
516 .data = (void *)&ssd1307fb_ssd1305_deviceinfo,
517 },
518 {
519 .compatible = "solomon,ssd1306fb-i2c",
520 .data = (void *)&ssd1307fb_ssd1306_deviceinfo,
521 },
522 {
523 .compatible = "solomon,ssd1307fb-i2c",
524 .data = (void *)&ssd1307fb_ssd1307_deviceinfo,
525 },
526 {
527 .compatible = "solomon,ssd1309fb-i2c",
528 .data = (void *)&ssd1307fb_ssd1309_deviceinfo,
529 },
530 {},
531 };
532 MODULE_DEVICE_TABLE(of, ssd1307fb_of_match);
533
534 static int ssd1307fb_probe(struct i2c_client *client,
535 const struct i2c_device_id *id)
536 {
537 struct backlight_device *bl;
538 char bl_name[12];
539 struct fb_info *info;
540 struct device_node *node = client->dev.of_node;
541 struct fb_deferred_io *ssd1307fb_defio;
542 u32 vmem_size;
543 struct ssd1307fb_par *par;
544 u8 *vmem;
545 int ret;
546
547 if (!node) {
548 dev_err(&client->dev, "No device tree data found!\n");
549 return -EINVAL;
550 }
551
552 info = framebuffer_alloc(sizeof(struct ssd1307fb_par), &client->dev);
553 if (!info) {
554 dev_err(&client->dev, "Couldn't allocate framebuffer.\n");
555 return -ENOMEM;
556 }
557
558 par = info->par;
559 par->info = info;
560 par->client = client;
561
562 par->device_info = of_device_get_match_data(&client->dev);
563
564 par->reset = of_get_named_gpio(client->dev.of_node,
565 "reset-gpios", 0);
566 if (!gpio_is_valid(par->reset)) {
567 ret = -EINVAL;
568 goto fb_alloc_error;
569 }
570
571 if (of_property_read_u32(node, "solomon,width", &par->width))
572 par->width = 96;
573
574 if (of_property_read_u32(node, "solomon,height", &par->height))
575 par->height = 16;
576
577 if (of_property_read_u32(node, "solomon,page-offset", &par->page_offset))
578 par->page_offset = 1;
579
580 if (of_property_read_u32(node, "solomon,com-offset", &par->com_offset))
581 par->com_offset = 0;
582
583 if (of_property_read_u32(node, "solomon,prechargep1", &par->prechargep1))
584 par->prechargep1 = 2;
585
586 if (of_property_read_u32(node, "solomon,prechargep2", &par->prechargep2))
587 par->prechargep2 = 2;
588
589 par->seg_remap = !of_property_read_bool(node, "solomon,segment-no-remap");
590 par->com_seq = of_property_read_bool(node, "solomon,com-seq");
591 par->com_lrremap = of_property_read_bool(node, "solomon,com-lrremap");
592 par->com_invdir = of_property_read_bool(node, "solomon,com-invdir");
593
594 par->contrast = 127;
595 par->vcomh = par->device_info->default_vcomh;
596
597 /* Setup display timing */
598 par->dclk_div = par->device_info->default_dclk_div;
599 par->dclk_frq = par->device_info->default_dclk_frq;
600
601 vmem_size = par->width * par->height / 8;
602
603 vmem = (void *)__get_free_pages(GFP_KERNEL | __GFP_ZERO,
604 get_order(vmem_size));
605 if (!vmem) {
606 dev_err(&client->dev, "Couldn't allocate graphical memory.\n");
607 ret = -ENOMEM;
608 goto fb_alloc_error;
609 }
610
611 ssd1307fb_defio = devm_kzalloc(&client->dev, sizeof(struct fb_deferred_io), GFP_KERNEL);
612 if (!ssd1307fb_defio) {
613 dev_err(&client->dev, "Couldn't allocate deferred io.\n");
614 ret = -ENOMEM;
615 goto fb_alloc_error;
616 }
617
618 ssd1307fb_defio->delay = HZ / refreshrate;
619 ssd1307fb_defio->deferred_io = ssd1307fb_deferred_io;
620
621 info->fbops = &ssd1307fb_ops;
622 info->fix = ssd1307fb_fix;
623 info->fix.line_length = par->width / 8;
624 info->fbdefio = ssd1307fb_defio;
625
626 info->var = ssd1307fb_var;
627 info->var.xres = par->width;
628 info->var.xres_virtual = par->width;
629 info->var.yres = par->height;
630 info->var.yres_virtual = par->height;
631
632 info->var.red.length = 1;
633 info->var.red.offset = 0;
634 info->var.green.length = 1;
635 info->var.green.offset = 0;
636 info->var.blue.length = 1;
637 info->var.blue.offset = 0;
638
639 info->screen_base = (u8 __force __iomem *)vmem;
640 info->fix.smem_start = __pa(vmem);
641 info->fix.smem_len = vmem_size;
642
643 fb_deferred_io_init(info);
644
645 ret = devm_gpio_request_one(&client->dev, par->reset,
646 GPIOF_OUT_INIT_HIGH,
647 "oled-reset");
648 if (ret) {
649 dev_err(&client->dev,
650 "failed to request gpio %d: %d\n",
651 par->reset, ret);
652 goto reset_oled_error;
653 }
654
655 i2c_set_clientdata(client, info);
656
657 /* Reset the screen */
658 gpio_set_value(par->reset, 0);
659 udelay(4);
660 gpio_set_value(par->reset, 1);
661 udelay(4);
662
663 ret = ssd1307fb_init(par);
664 if (ret)
665 goto reset_oled_error;
666
667 ret = register_framebuffer(info);
668 if (ret) {
669 dev_err(&client->dev, "Couldn't register the framebuffer\n");
670 goto panel_init_error;
671 }
672
673 snprintf(bl_name, sizeof(bl_name), "ssd1307fb%d", info->node);
674 bl = backlight_device_register(bl_name, &client->dev, par,
675 &ssd1307fb_bl_ops, NULL);
676 if (IS_ERR(bl)) {
677 ret = PTR_ERR(bl);
678 dev_err(&client->dev, "unable to register backlight device: %d\n",
679 ret);
680 goto bl_init_error;
681 }
682
683 bl->props.brightness = par->contrast;
684 bl->props.max_brightness = MAX_CONTRAST;
685 info->bl_dev = bl;
686
687 dev_info(&client->dev, "fb%d: %s framebuffer device registered, using %d bytes of video memory\n", info->node, info->fix.id, vmem_size);
688
689 return 0;
690
691 bl_init_error:
692 unregister_framebuffer(info);
693 panel_init_error:
694 if (par->device_info->need_pwm) {
695 pwm_disable(par->pwm);
696 pwm_put(par->pwm);
697 };
698 reset_oled_error:
699 fb_deferred_io_cleanup(info);
700 fb_alloc_error:
701 framebuffer_release(info);
702 return ret;
703 }
704
705 static int ssd1307fb_remove(struct i2c_client *client)
706 {
707 struct fb_info *info = i2c_get_clientdata(client);
708 struct ssd1307fb_par *par = info->par;
709
710 ssd1307fb_write_cmd(par->client, SSD1307FB_DISPLAY_OFF);
711
712 backlight_device_unregister(info->bl_dev);
713
714 unregister_framebuffer(info);
715 if (par->device_info->need_pwm) {
716 pwm_disable(par->pwm);
717 pwm_put(par->pwm);
718 };
719 fb_deferred_io_cleanup(info);
720 __free_pages(__va(info->fix.smem_start), get_order(info->fix.smem_len));
721 framebuffer_release(info);
722
723 return 0;
724 }
725
726 static const struct i2c_device_id ssd1307fb_i2c_id[] = {
727 { "ssd1305fb", 0 },
728 { "ssd1306fb", 0 },
729 { "ssd1307fb", 0 },
730 { "ssd1309fb", 0 },
731 { }
732 };
733 MODULE_DEVICE_TABLE(i2c, ssd1307fb_i2c_id);
734
735 static struct i2c_driver ssd1307fb_driver = {
736 .probe = ssd1307fb_probe,
737 .remove = ssd1307fb_remove,
738 .id_table = ssd1307fb_i2c_id,
739 .driver = {
740 .name = "ssd1307fb",
741 .of_match_table = ssd1307fb_of_match,
742 },
743 };
744
745 module_i2c_driver(ssd1307fb_driver);
746
747 MODULE_DESCRIPTION("FB driver for the Solomon SSD1307 OLED controller");
748 MODULE_AUTHOR("Maxime Ripard <maxime.ripard@free-electrons.com>");
749 MODULE_LICENSE("GPL");
Linux with added FPC-III support