Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'fbdev-for-6.5-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/deller/linux-fbdev
Pull fbdev fixes and cleanups from Helge Deller:
"Just the usual bunch of code cleanups in various drivers, this time
mostly in vgacon and imxfb:
- Code cleanup in vgacon (Jiri Slaby)
- Explicitly include correct DT includes (Rob Herring)
- imxfb code cleanup (Yangtao Li, Martin Kaiser)
- kyrofb: make arrays const and smaller (Colin Ian King)
- ep93xx-fb: return value check fix (Yuanjun Gong)
- au1200fb: add missing IRQ check (Zhang Shurong)"
* tag 'fbdev-for-6.5-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/deller/linux-fbdev:
fbdev: Explicitly include correct DT includes
fbdev: ep93xx-fb: fix return value check in ep93xxfb_probe
fbdev: au1200fb: Fix missing IRQ check in au1200fb_drv_probe
fbdev: kyro: make some const read-only arrays static and reduce type size
fbcon: remove unused display (p) from fbcon_redraw()
sticon: make sticon_set_def_font() void and remove op parameter
vgacon: cache vc_cell_height in vgacon_cursor()
vgacon: let vgacon_doresize() return void
vgacon: remove unused xpos from vgacon_set_cursor_size()
vgacon: remove unneeded forward declarations
vgacon: switch vgacon_scrolldelta() and vgacon_restore_screen()
fbdev: imxfb: remove unneeded labels
fbdev: imxfb: Convert to devm_platform_ioremap_resource()
fbdev: imxfb: Convert to devm_kmalloc_array()
fbdev: imxfb: Removed unneeded release_mem_region
fbdev: imxfb: switch to DEFINE_SIMPLE_DEV_PM_OPS
fbdev: imxfb: warn about invalid left/right margin
+97
-118
+6
-6
drivers/video/console/sticon.c
+6
-6
drivers/video/console/sticon.c
···
156
156
return false;
157
157
}
158
158
159
-
static int sticon_set_def_font(int unit, struct console_font *op)
159
+
static void sticon_set_def_font(int unit)
160
160
{
161
161
if (font_data[unit] != STI_DEF_FONT) {
162
162
if (--FNTREFCOUNT(font_data[unit]) == 0) {
···
165
165
}
166
166
font_data[unit] = STI_DEF_FONT;
167
167
}
168
-
169
-
return 0;
170
168
}
171
169
172
170
static int sticon_set_font(struct vc_data *vc, struct console_font *op,
···
244
246
vc->vc_video_erase_char, font_data[vc->vc_num]);
245
247
246
248
/* delete old font in case it is a user font */
247
-
sticon_set_def_font(unit, NULL);
249
+
sticon_set_def_font(unit);
248
250
249
251
FNTREFCOUNT(cooked_font)++;
250
252
font_data[unit] = cooked_font;
···
262
264
263
265
static int sticon_font_default(struct vc_data *vc, struct console_font *op, char *name)
264
266
{
265
-
return sticon_set_def_font(vc->vc_num, op);
267
+
sticon_set_def_font(vc->vc_num);
268
+
269
+
return 0;
266
270
}
267
271
268
272
static int sticon_font_set(struct vc_data *vc, struct console_font *font,
···
297
297
298
298
/* free memory used by user font */
299
299
for (i = 0; i < MAX_NR_CONSOLES; i++)
300
-
sticon_set_def_font(i, NULL);
300
+
sticon_set_def_font(i);
301
301
}
302
302
303
303
static void sticon_clear(struct vc_data *conp, int sy, int sx, int height,
+28
-46
drivers/video/console/vgacon.c
+28
-46
drivers/video/console/vgacon.c
···
65
65
* Interface used by the world
66
66
*/
67
67
68
-
static const char *vgacon_startup(void);
69
-
static void vgacon_init(struct vc_data *c, int init);
70
-
static void vgacon_deinit(struct vc_data *c);
71
-
static void vgacon_cursor(struct vc_data *c, int mode);
72
-
static int vgacon_switch(struct vc_data *c);
73
-
static int vgacon_blank(struct vc_data *c, int blank, int mode_switch);
74
-
static void vgacon_scrolldelta(struct vc_data *c, int lines);
75
68
static int vgacon_set_origin(struct vc_data *c);
76
-
static void vgacon_save_screen(struct vc_data *c);
77
-
static void vgacon_invert_region(struct vc_data *c, u16 * p, int count);
69
+
78
70
static struct uni_pagedict *vgacon_uni_pagedir;
79
71
static int vgacon_refcount;
80
72
···
134
142
write_vga(12, (c->vc_visible_origin - vga_vram_base) / 2);
135
143
}
136
144
137
-
static void vgacon_restore_screen(struct vc_data *c)
138
-
{
139
-
if (c->vc_origin != c->vc_visible_origin)
140
-
vgacon_scrolldelta(c, 0);
141
-
}
142
-
143
145
static void vgacon_scrolldelta(struct vc_data *c, int lines)
144
146
{
145
147
vc_scrolldelta_helper(c, lines, vga_rolled_over, (void *)vga_vram_base,
146
148
vga_vram_size);
147
149
vga_set_mem_top(c);
150
+
}
151
+
152
+
static void vgacon_restore_screen(struct vc_data *c)
153
+
{
154
+
if (c->vc_origin != c->vc_visible_origin)
155
+
vgacon_scrolldelta(c, 0);
148
156
}
149
157
150
158
static const char *vgacon_startup(void)
···
437
445
}
438
446
}
439
447
440
-
static void vgacon_set_cursor_size(int xpos, int from, int to)
448
+
static void vgacon_set_cursor_size(int from, int to)
441
449
{
442
450
unsigned long flags;
443
451
int curs, cure;
···
470
478
471
479
static void vgacon_cursor(struct vc_data *c, int mode)
472
480
{
481
+
unsigned int c_height;
482
+
473
483
if (c->vc_mode != KD_TEXT)
474
484
return;
475
485
476
486
vgacon_restore_screen(c);
477
487
488
+
c_height = c->vc_cell_height;
489
+
478
490
switch (mode) {
479
491
case CM_ERASE:
480
492
write_vga(14, (c->vc_pos - vga_vram_base) / 2);
481
493
if (vga_video_type >= VIDEO_TYPE_VGAC)
482
-
vgacon_set_cursor_size(c->state.x, 31, 30);
494
+
vgacon_set_cursor_size(31, 30);
483
495
else
484
-
vgacon_set_cursor_size(c->state.x, 31, 31);
496
+
vgacon_set_cursor_size(31, 31);
485
497
break;
486
498
487
499
case CM_MOVE:
···
493
497
write_vga(14, (c->vc_pos - vga_vram_base) / 2);
494
498
switch (CUR_SIZE(c->vc_cursor_type)) {
495
499
case CUR_UNDERLINE:
496
-
vgacon_set_cursor_size(c->state.x,
497
-
c->vc_cell_height -
498
-
(c->vc_cell_height <
499
-
10 ? 2 : 3),
500
-
c->vc_cell_height -
501
-
(c->vc_cell_height <
502
-
10 ? 1 : 2));
500
+
vgacon_set_cursor_size(c_height -
501
+
(c_height < 10 ? 2 : 3),
502
+
c_height -
503
+
(c_height < 10 ? 1 : 2));
503
504
break;
504
505
case CUR_TWO_THIRDS:
505
-
vgacon_set_cursor_size(c->state.x,
506
-
c->vc_cell_height / 3,
507
-
c->vc_cell_height -
508
-
(c->vc_cell_height <
509
-
10 ? 1 : 2));
506
+
vgacon_set_cursor_size(c_height / 3, c_height -
507
+
(c_height < 10 ? 1 : 2));
510
508
break;
511
509
case CUR_LOWER_THIRD:
512
-
vgacon_set_cursor_size(c->state.x,
513
-
(c->vc_cell_height * 2) / 3,
514
-
c->vc_cell_height -
515
-
(c->vc_cell_height <
516
-
10 ? 1 : 2));
510
+
vgacon_set_cursor_size(c_height * 2 / 3, c_height -
511
+
(c_height < 10 ? 1 : 2));
517
512
break;
518
513
case CUR_LOWER_HALF:
519
-
vgacon_set_cursor_size(c->state.x,
520
-
c->vc_cell_height / 2,
521
-
c->vc_cell_height -
522
-
(c->vc_cell_height <
523
-
10 ? 1 : 2));
514
+
vgacon_set_cursor_size(c_height / 2, c_height -
515
+
(c_height < 10 ? 1 : 2));
524
516
break;
525
517
case CUR_NONE:
526
518
if (vga_video_type >= VIDEO_TYPE_VGAC)
527
-
vgacon_set_cursor_size(c->state.x, 31, 30);
519
+
vgacon_set_cursor_size(31, 30);
528
520
else
529
-
vgacon_set_cursor_size(c->state.x, 31, 31);
521
+
vgacon_set_cursor_size(31, 31);
530
522
break;
531
523
default:
532
-
vgacon_set_cursor_size(c->state.x, 1,
533
-
c->vc_cell_height);
524
+
vgacon_set_cursor_size(1, c_height);
534
525
break;
535
526
}
536
527
break;
537
528
}
538
529
}
539
530
540
-
static int vgacon_doresize(struct vc_data *c,
531
+
static void vgacon_doresize(struct vc_data *c,
541
532
unsigned int width, unsigned int height)
542
533
{
543
534
unsigned long flags;
···
583
600
}
584
601
585
602
raw_spin_unlock_irqrestore(&vga_lock, flags);
586
-
return 0;
587
603
}
588
604
589
605
static int vgacon_switch(struct vc_data *c)
+3
drivers/video/fbdev/au1200fb.c
+3
drivers/video/fbdev/au1200fb.c
+2
-1
drivers/video/fbdev/bw2.c
+2
-1
drivers/video/fbdev/bw2.c
+2
-1
drivers/video/fbdev/cg14.c
+2
-1
drivers/video/fbdev/cg14.c
+2
-1
drivers/video/fbdev/cg3.c
+2
-1
drivers/video/fbdev/cg3.c
+2
-1
drivers/video/fbdev/cg6.c
+2
-1
drivers/video/fbdev/cg6.c
+3
-4
drivers/video/fbdev/core/fbcon.c
+3
-4
drivers/video/fbdev/core/fbcon.c
···
1612
1612
}
1613
1613
}
1614
1614
1615
-
static void fbcon_redraw(struct vc_data *vc, struct fbcon_display *p,
1616
-
int line, int count, int offset)
1615
+
static void fbcon_redraw(struct vc_data *vc, int line, int count, int offset)
1617
1616
{
1618
1617
unsigned short *d = (unsigned short *)
1619
1618
(vc->vc_origin + vc->vc_size_row * line);
···
1826
1827
1827
1828
case SCROLL_REDRAW:
1828
1829
redraw_up:
1829
-
fbcon_redraw(vc, p, t, b - t - count,
1830
+
fbcon_redraw(vc, t, b - t - count,
1830
1831
count * vc->vc_cols);
1831
1832
fbcon_clear(vc, b - count, 0, count, vc->vc_cols);
1832
1833
scr_memsetw((unsigned short *) (vc->vc_origin +
···
1912
1913
1913
1914
case SCROLL_REDRAW:
1914
1915
redraw_down:
1915
-
fbcon_redraw(vc, p, b - 1, b - t - count,
1916
+
fbcon_redraw(vc, b - 1, b - t - count,
1916
1917
-count * vc->vc_cols);
1917
1918
fbcon_clear(vc, t, 0, count, vc->vc_cols);
1918
1919
scr_memsetw((unsigned short *) (vc->vc_origin +
+3
-1
drivers/video/fbdev/ep93xx-fb.c
+3
-1
drivers/video/fbdev/ep93xx-fb.c
+2
-1
drivers/video/fbdev/ffb.c
+2
-1
drivers/video/fbdev/ffb.c
+1
-2
drivers/video/fbdev/grvga.c
+1
-2
drivers/video/fbdev/grvga.c
+18
-30
drivers/video/fbdev/imxfb.c
+18
-30
drivers/video/fbdev/imxfb.c
···
613
613
if (var->hsync_len < 1 || var->hsync_len > 64)
614
614
printk(KERN_ERR "%s: invalid hsync_len %d\n",
615
615
info->fix.id, var->hsync_len);
616
-
if (var->left_margin > 255)
616
+
if (var->left_margin < 3 || var->left_margin > 255)
617
617
printk(KERN_ERR "%s: invalid left_margin %d\n",
618
618
info->fix.id, var->left_margin);
619
-
if (var->right_margin > 255)
619
+
if (var->right_margin < 1 || var->right_margin > 255)
620
620
printk(KERN_ERR "%s: invalid right_margin %d\n",
621
621
info->fix.id, var->right_margin);
622
622
if (var->yres < 1 || var->yres > ymax_mask)
···
673
673
674
674
pr_debug("%s\n",__func__);
675
675
676
-
info->pseudo_palette = kmalloc_array(16, sizeof(u32), GFP_KERNEL);
676
+
info->pseudo_palette = devm_kmalloc_array(&pdev->dev, 16,
677
+
sizeof(u32), GFP_KERNEL);
677
678
if (!info->pseudo_palette)
678
679
return -ENOMEM;
679
680
···
869
868
struct imxfb_info *fbi;
870
869
struct lcd_device *lcd;
871
870
struct fb_info *info;
872
-
struct resource *res;
873
871
struct imx_fb_videomode *m;
874
872
const struct of_device_id *of_id;
875
873
struct device_node *display_np;
···
884
884
of_id = of_match_device(imxfb_of_dev_id, &pdev->dev);
885
885
if (of_id)
886
886
pdev->id_entry = of_id->data;
887
-
888
-
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
889
-
if (!res)
890
-
return -ENODEV;
891
887
892
888
info = framebuffer_alloc(sizeof(struct imxfb_info), &pdev->dev);
893
889
if (!info)
···
903
907
if (!display_np) {
904
908
dev_err(&pdev->dev, "No display defined in devicetree\n");
905
909
ret = -EINVAL;
906
-
goto failed_of_parse;
910
+
goto failed_init;
907
911
}
908
912
909
913
/*
···
917
921
if (!fbi->mode) {
918
922
ret = -ENOMEM;
919
923
of_node_put(display_np);
920
-
goto failed_of_parse;
924
+
goto failed_init;
921
925
}
922
926
923
927
ret = imxfb_of_read_mode(&pdev->dev, display_np, fbi->mode);
924
928
of_node_put(display_np);
925
929
if (ret)
926
-
goto failed_of_parse;
930
+
goto failed_init;
927
931
928
932
/* Calculate maximum bytes used per pixel. In most cases this should
929
933
* be the same as m->bpp/8 */
···
936
940
fbi->clk_ipg = devm_clk_get(&pdev->dev, "ipg");
937
941
if (IS_ERR(fbi->clk_ipg)) {
938
942
ret = PTR_ERR(fbi->clk_ipg);
939
-
goto failed_getclock;
943
+
goto failed_init;
940
944
}
941
945
942
946
/*
···
951
955
*/
952
956
ret = clk_prepare_enable(fbi->clk_ipg);
953
957
if (ret)
954
-
goto failed_getclock;
958
+
goto failed_init;
955
959
clk_disable_unprepare(fbi->clk_ipg);
956
960
957
961
fbi->clk_ahb = devm_clk_get(&pdev->dev, "ahb");
958
962
if (IS_ERR(fbi->clk_ahb)) {
959
963
ret = PTR_ERR(fbi->clk_ahb);
960
-
goto failed_getclock;
964
+
goto failed_init;
961
965
}
962
966
963
967
fbi->clk_per = devm_clk_get(&pdev->dev, "per");
964
968
if (IS_ERR(fbi->clk_per)) {
965
969
ret = PTR_ERR(fbi->clk_per);
966
-
goto failed_getclock;
970
+
goto failed_init;
967
971
}
968
972
969
-
fbi->regs = devm_ioremap_resource(&pdev->dev, res);
973
+
fbi->regs = devm_platform_ioremap_resource(pdev, 0);
970
974
if (IS_ERR(fbi->regs)) {
971
975
ret = PTR_ERR(fbi->regs);
972
-
goto failed_ioremap;
976
+
goto failed_init;
973
977
}
974
978
975
979
fbi->map_size = PAGE_ALIGN(info->fix.smem_len);
···
978
982
if (!info->screen_buffer) {
979
983
dev_err(&pdev->dev, "Failed to allocate video RAM\n");
980
984
ret = -ENOMEM;
981
-
goto failed_map;
985
+
goto failed_init;
982
986
}
983
987
984
988
info->fix.smem_start = fbi->map_dma;
···
1030
1034
1031
1035
failed_lcd:
1032
1036
unregister_framebuffer(info);
1033
-
1034
1037
failed_register:
1035
1038
fb_dealloc_cmap(&info->cmap);
1036
1039
failed_cmap:
1037
1040
dma_free_wc(&pdev->dev, fbi->map_size, info->screen_buffer,
1038
1041
fbi->map_dma);
1039
-
failed_map:
1040
-
failed_ioremap:
1041
-
failed_getclock:
1042
-
release_mem_region(res->start, resource_size(res));
1043
-
failed_of_parse:
1044
-
kfree(info->pseudo_palette);
1045
1042
failed_init:
1046
1043
framebuffer_release(info);
1047
1044
return ret;
···
1051
1062
fb_dealloc_cmap(&info->cmap);
1052
1063
dma_free_wc(&pdev->dev, fbi->map_size, info->screen_buffer,
1053
1064
fbi->map_dma);
1054
-
kfree(info->pseudo_palette);
1055
1065
framebuffer_release(info);
1056
1066
}
1057
1067
1058
-
static int __maybe_unused imxfb_suspend(struct device *dev)
1068
+
static int imxfb_suspend(struct device *dev)
1059
1069
{
1060
1070
struct fb_info *info = dev_get_drvdata(dev);
1061
1071
struct imxfb_info *fbi = info->par;
···
1064
1076
return 0;
1065
1077
}
1066
1078
1067
-
static int __maybe_unused imxfb_resume(struct device *dev)
1079
+
static int imxfb_resume(struct device *dev)
1068
1080
{
1069
1081
struct fb_info *info = dev_get_drvdata(dev);
1070
1082
struct imxfb_info *fbi = info->par;
···
1074
1086
return 0;
1075
1087
}
1076
1088
1077
-
static SIMPLE_DEV_PM_OPS(imxfb_pm_ops, imxfb_suspend, imxfb_resume);
1089
+
static DEFINE_SIMPLE_DEV_PM_OPS(imxfb_pm_ops, imxfb_suspend, imxfb_resume);
1078
1090
1079
1091
static struct platform_driver imxfb_driver = {
1080
1092
.driver = {
1081
1093
.name = DRIVER_NAME,
1082
1094
.of_match_table = imxfb_of_dev_id,
1083
-
.pm = &imxfb_pm_ops,
1095
+
.pm = pm_sleep_ptr(&imxfb_pm_ops),
1084
1096
},
1085
1097
.probe = imxfb_probe,
1086
1098
.remove_new = imxfb_remove,
+5
-5
drivers/video/fbdev/kyro/STG4000InitDevice.c
+5
-5
drivers/video/fbdev/kyro/STG4000InitDevice.c
···
83
83
static u32 InitSDRAMRegisters(volatile STG4000REG __iomem *pSTGReg,
84
84
u32 dwSubSysID, u32 dwRevID)
85
85
{
86
-
u32 adwSDRAMArgCfg0[] = { 0xa0, 0x80, 0xa0, 0xa0, 0xa0 };
87
-
u32 adwSDRAMCfg1[] = { 0x8732, 0x8732, 0xa732, 0xa732, 0x8732 };
88
-
u32 adwSDRAMCfg2[] = { 0x87d2, 0x87d2, 0xa7d2, 0x87d2, 0xa7d2 };
89
-
u32 adwSDRAMRsh[] = { 36, 39, 40 };
90
-
u32 adwChipSpeed[] = { 110, 120, 125 };
86
+
static const u8 adwSDRAMArgCfg0[] = { 0xa0, 0x80, 0xa0, 0xa0, 0xa0 };
87
+
static const u16 adwSDRAMCfg1[] = { 0x8732, 0x8732, 0xa732, 0xa732, 0x8732 };
88
+
static const u16 adwSDRAMCfg2[] = { 0x87d2, 0x87d2, 0xa7d2, 0x87d2, 0xa7d2 };
89
+
static const u8 adwSDRAMRsh[] = { 36, 39, 40 };
90
+
static const u8 adwChipSpeed[] = { 110, 120, 125 };
91
91
u32 dwMemTypeIdx;
92
92
u32 dwChipSpeedIdx;
93
93
+2
-1
drivers/video/fbdev/leo.c
+2
-1
drivers/video/fbdev/leo.c
+1
-3
drivers/video/fbdev/mb862xx/mb862xxfb_accel.c
+1
-3
drivers/video/fbdev/mb862xx/mb862xxfb_accel.c
+3
-3
drivers/video/fbdev/mb862xx/mb862xxfbdrv.c
+3
-3
drivers/video/fbdev/mb862xx/mb862xxfbdrv.c
···
18
18
#include <linux/init.h>
19
19
#include <linux/interrupt.h>
20
20
#include <linux/pci.h>
21
-
#if defined(CONFIG_OF)
21
+
#include <linux/of.h>
22
22
#include <linux/of_address.h>
23
23
#include <linux/of_irq.h>
24
-
#include <linux/of_platform.h>
25
-
#endif
24
+
#include <linux/platform_device.h>
25
+
26
26
#include "mb862xxfb.h"
27
27
#include "mb862xx_reg.h"
28
28
+1
-1
drivers/video/fbdev/omap2/omapfb/displays/panel-dsi-cm.c
+1
-1
drivers/video/fbdev/omap2/omapfb/displays/panel-dsi-cm.c
···
15
15
#include <linux/gpio/consumer.h>
16
16
#include <linux/interrupt.h>
17
17
#include <linux/jiffies.h>
18
+
#include <linux/mod_devicetable.h>
18
19
#include <linux/module.h>
19
20
#include <linux/platform_device.h>
20
21
#include <linux/sched/signal.h>
21
22
#include <linux/slab.h>
22
23
#include <linux/workqueue.h>
23
-
#include <linux/of_device.h>
24
24
25
25
#include <video/omapfb_dss.h>
26
26
#include <video/mipi_display.h>
+2
-1
drivers/video/fbdev/p9100.c
+2
-1
drivers/video/fbdev/p9100.c
+2
-2
drivers/video/fbdev/platinumfb.c
+2
-2
drivers/video/fbdev/platinumfb.c
···
30
30
#include <linux/fb.h>
31
31
#include <linux/init.h>
32
32
#include <linux/nvram.h>
33
+
#include <linux/of.h>
33
34
#include <linux/of_address.h>
34
-
#include <linux/of_device.h>
35
-
#include <linux/of_platform.h>
35
+
#include <linux/platform_device.h>
36
36
37
37
#include "macmodes.h"
38
38
#include "platinumfb.h"
+1
-1
drivers/video/fbdev/sbuslib.c
+1
-1
drivers/video/fbdev/sbuslib.c
+2
-1
drivers/video/fbdev/sunxvr1000.c
+2
-1
drivers/video/fbdev/sunxvr1000.c
+1
-1
drivers/video/fbdev/sunxvr2500.c
+1
-1
drivers/video/fbdev/sunxvr2500.c
+1
-1
drivers/video/fbdev/sunxvr500.c
+1
-1
drivers/video/fbdev/sunxvr500.c
+2
-1
drivers/video/fbdev/tcx.c
+2
-1
drivers/video/fbdev/tcx.c
+2
-3
drivers/video/fbdev/xilinxfb.c
+2
-3
drivers/video/fbdev/xilinxfb.c
···
24
24
#include <linux/module.h>
25
25
#include <linux/kernel.h>
26
26
#include <linux/errno.h>
27
+
#include <linux/platform_device.h>
27
28
#include <linux/string.h>
28
29
#include <linux/mm.h>
29
30
#include <linux/fb.h>
30
31
#include <linux/init.h>
31
32
#include <linux/dma-mapping.h>
32
-
#include <linux/of_device.h>
33
-
#include <linux/of_platform.h>
34
-
#include <linux/of_address.h>
33
+
#include <linux/of.h>
35
34
#include <linux/io.h>
36
35
#include <linux/slab.h>
37
36