blob: c32a2a50bfa2a0870bd69f5c86bbf68a8c81e64d [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/drivers/video/fbcmap.c -- Colormap handling for frame buffer devices
3 *
4 * Created 15 Jun 1997 by Geert Uytterhoeven
5 *
6 * 2001 - Documented with DocBook
7 * - Brad Douglas <brad@neruo.com>
8 *
9 * This file is subject to the terms and conditions of the GNU General Public
10 * License. See the file COPYING in the main directory of this archive for
11 * more details.
12 */
13
14#include <linux/string.h>
15#include <linux/module.h>
16#include <linux/tty.h>
17#include <linux/fb.h>
18#include <linux/slab.h>
19
20#include <asm/uaccess.h>
21
22static u16 red2[] = {
23 0x0000, 0xaaaa
24};
25static u16 green2[] = {
26 0x0000, 0xaaaa
27};
28static u16 blue2[] = {
29 0x0000, 0xaaaa
30};
31
32static u16 red4[] = {
33 0x0000, 0xaaaa, 0x5555, 0xffff
34};
35static u16 green4[] = {
36 0x0000, 0xaaaa, 0x5555, 0xffff
37};
38static u16 blue4[] = {
39 0x0000, 0xaaaa, 0x5555, 0xffff
40};
41
42static u16 red8[] = {
43 0x0000, 0x0000, 0x0000, 0x0000, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa
44};
45static u16 green8[] = {
46 0x0000, 0x0000, 0xaaaa, 0xaaaa, 0x0000, 0x0000, 0x5555, 0xaaaa
47};
48static u16 blue8[] = {
49 0x0000, 0xaaaa, 0x0000, 0xaaaa, 0x0000, 0xaaaa, 0x0000, 0xaaaa
50};
51
52static u16 red16[] = {
53 0x0000, 0x0000, 0x0000, 0x0000, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa,
54 0x5555, 0x5555, 0x5555, 0x5555, 0xffff, 0xffff, 0xffff, 0xffff
55};
56static u16 green16[] = {
57 0x0000, 0x0000, 0xaaaa, 0xaaaa, 0x0000, 0x0000, 0x5555, 0xaaaa,
58 0x5555, 0x5555, 0xffff, 0xffff, 0x5555, 0x5555, 0xffff, 0xffff
59};
60static u16 blue16[] = {
61 0x0000, 0xaaaa, 0x0000, 0xaaaa, 0x0000, 0xaaaa, 0x0000, 0xaaaa,
62 0x5555, 0xffff, 0x5555, 0xffff, 0x5555, 0xffff, 0x5555, 0xffff
63};
64
65static struct fb_cmap default_2_colors = {
66 0, 2, red2, green2, blue2, NULL
67};
68static struct fb_cmap default_8_colors = {
69 0, 8, red8, green8, blue8, NULL
70};
71static struct fb_cmap default_4_colors = {
72 0, 4, red4, green4, blue4, NULL
73};
74static struct fb_cmap default_16_colors = {
75 0, 16, red16, green16, blue16, NULL
76};
77
78
79/**
80 * fb_alloc_cmap - allocate a colormap
81 * @cmap: frame buffer colormap structure
82 * @len: length of @cmap
83 * @transp: boolean, 1 if there is transparency, 0 otherwise
84 *
85 * Allocates memory for a colormap @cmap. @len is the
86 * number of entries in the palette.
87 *
88 * Returns -1 errno on error, or zero on success.
89 *
90 */
91
92int fb_alloc_cmap(struct fb_cmap *cmap, int len, int transp)
93{
94 int size = len*sizeof(u16);
95
96 if (cmap->len != len) {
97 fb_dealloc_cmap(cmap);
98 if (!len)
99 return 0;
100 if (!(cmap->red = kmalloc(size, GFP_ATOMIC)))
101 goto fail;
102 if (!(cmap->green = kmalloc(size, GFP_ATOMIC)))
103 goto fail;
104 if (!(cmap->blue = kmalloc(size, GFP_ATOMIC)))
105 goto fail;
106 if (transp) {
107 if (!(cmap->transp = kmalloc(size, GFP_ATOMIC)))
108 goto fail;
109 } else
110 cmap->transp = NULL;
111 }
112 cmap->start = 0;
113 cmap->len = len;
114 fb_copy_cmap(fb_default_cmap(len), cmap);
115 return 0;
116
117fail:
118 fb_dealloc_cmap(cmap);
119 return -1;
120}
121
122/**
123 * fb_dealloc_cmap - deallocate a colormap
124 * @cmap: frame buffer colormap structure
125 *
126 * Deallocates a colormap that was previously allocated with
127 * fb_alloc_cmap().
128 *
129 */
130
131void fb_dealloc_cmap(struct fb_cmap *cmap)
132{
133 kfree(cmap->red);
134 kfree(cmap->green);
135 kfree(cmap->blue);
136 kfree(cmap->transp);
137
138 cmap->red = cmap->green = cmap->blue = cmap->transp = NULL;
139 cmap->len = 0;
140}
141
142/**
143 * fb_copy_cmap - copy a colormap
144 * @from: frame buffer colormap structure
145 * @to: frame buffer colormap structure
146 *
147 * Copy contents of colormap from @from to @to.
148 */
149
150int fb_copy_cmap(struct fb_cmap *from, struct fb_cmap *to)
151{
152 int tooff = 0, fromoff = 0;
153 int size;
154
155 if (to->start > from->start)
156 fromoff = to->start - from->start;
157 else
158 tooff = from->start - to->start;
159 size = to->len - tooff;
160 if (size > (int) (from->len - fromoff))
161 size = from->len - fromoff;
162 if (size <= 0)
163 return -EINVAL;
164 size *= sizeof(u16);
165
166 memcpy(to->red+tooff, from->red+fromoff, size);
167 memcpy(to->green+tooff, from->green+fromoff, size);
168 memcpy(to->blue+tooff, from->blue+fromoff, size);
169 if (from->transp && to->transp)
170 memcpy(to->transp+tooff, from->transp+fromoff, size);
171 return 0;
172}
173
174int fb_cmap_to_user(struct fb_cmap *from, struct fb_cmap_user *to)
175{
176 int tooff = 0, fromoff = 0;
177 int size;
178
179 if (to->start > from->start)
180 fromoff = to->start - from->start;
181 else
182 tooff = from->start - to->start;
183 size = to->len - tooff;
184 if (size > (int) (from->len - fromoff))
185 size = from->len - fromoff;
186 if (size <= 0)
187 return -EINVAL;
188 size *= sizeof(u16);
189
190 if (copy_to_user(to->red+tooff, from->red+fromoff, size))
191 return -EFAULT;
192 if (copy_to_user(to->green+tooff, from->green+fromoff, size))
193 return -EFAULT;
194 if (copy_to_user(to->blue+tooff, from->blue+fromoff, size))
195 return -EFAULT;
196 if (from->transp && to->transp)
197 if (copy_to_user(to->transp+tooff, from->transp+fromoff, size))
198 return -EFAULT;
199 return 0;
200}
201
202/**
203 * fb_set_cmap - set the colormap
204 * @cmap: frame buffer colormap structure
205 * @info: frame buffer info structure
206 *
207 * Sets the colormap @cmap for a screen of device @info.
208 *
209 * Returns negative errno on error, or zero on success.
210 *
211 */
212
213int fb_set_cmap(struct fb_cmap *cmap, struct fb_info *info)
214{
Michal Januszewski03e259a2005-07-27 11:46:08 -0700215 int i, start, rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 u16 *red, *green, *blue, *transp;
217 u_int hred, hgreen, hblue, htransp = 0xffff;
218
219 red = cmap->red;
220 green = cmap->green;
221 blue = cmap->blue;
222 transp = cmap->transp;
223 start = cmap->start;
224
Benjamin Herrenschmidt71494372005-05-01 08:59:22 -0700225 if (start < 0 || (!info->fbops->fb_setcolreg &&
226 !info->fbops->fb_setcmap))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 return -EINVAL;
Michal Januszewski03e259a2005-07-27 11:46:08 -0700228 if (info->fbops->fb_setcmap) {
229 rc = info->fbops->fb_setcmap(cmap, info);
230 } else {
231 for (i = 0; i < cmap->len; i++) {
232 hred = *red++;
233 hgreen = *green++;
234 hblue = *blue++;
235 if (transp)
236 htransp = *transp++;
237 if (info->fbops->fb_setcolreg(start++,
238 hred, hgreen, hblue,
239 htransp, info))
240 break;
241 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 }
Michal Januszewski03e259a2005-07-27 11:46:08 -0700243 if (rc == 0)
244 fb_copy_cmap(cmap, &info->cmap);
245
246 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247}
248
249int fb_set_user_cmap(struct fb_cmap_user *cmap, struct fb_info *info)
250{
Michal Januszewski03e259a2005-07-27 11:46:08 -0700251 int rc, size = cmap->len * sizeof(u16);
252 struct fb_cmap umap;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253
Michal Januszewski03e259a2005-07-27 11:46:08 -0700254 if (cmap->start < 0 || (!info->fbops->fb_setcolreg &&
255 !info->fbops->fb_setcmap))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 return -EINVAL;
Benjamin Herrenschmidt71494372005-05-01 08:59:22 -0700257
Michal Januszewski03e259a2005-07-27 11:46:08 -0700258 memset(&umap, 0, sizeof(struct fb_cmap));
259 rc = fb_alloc_cmap(&umap, cmap->len, cmap->transp != NULL);
260 if (rc)
Benjamin Herrenschmidt71494372005-05-01 08:59:22 -0700261 return rc;
Michal Januszewski03e259a2005-07-27 11:46:08 -0700262 if (copy_from_user(umap.red, cmap->red, size) ||
263 copy_from_user(umap.green, cmap->green, size) ||
264 copy_from_user(umap.blue, cmap->blue, size) ||
265 (cmap->transp && copy_from_user(umap.transp, cmap->transp, size))) {
266 fb_dealloc_cmap(&umap);
267 return -EFAULT;
Benjamin Herrenschmidt71494372005-05-01 08:59:22 -0700268 }
Michal Januszewski03e259a2005-07-27 11:46:08 -0700269 umap.start = cmap->start;
270 rc = fb_set_cmap(&umap, info);
271 fb_dealloc_cmap(&umap);
272 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273}
274
275/**
276 * fb_default_cmap - get default colormap
277 * @len: size of palette for a depth
278 *
279 * Gets the default colormap for a specific screen depth. @len
280 * is the size of the palette for a particular screen depth.
281 *
282 * Returns pointer to a frame buffer colormap structure.
283 *
284 */
285
286struct fb_cmap *fb_default_cmap(int len)
287{
288 if (len <= 2)
289 return &default_2_colors;
290 if (len <= 4)
291 return &default_4_colors;
292 if (len <= 8)
293 return &default_8_colors;
294 return &default_16_colors;
295}
296
297
298/**
299 * fb_invert_cmaps - invert all defaults colormaps
300 *
301 * Invert all default colormaps.
302 *
303 */
304
305void fb_invert_cmaps(void)
306{
307 u_int i;
308
309 for (i = 0; i < 2; i++) {
310 red2[i] = ~red2[i];
311 green2[i] = ~green2[i];
312 blue2[i] = ~blue2[i];
313 }
314 for (i = 0; i < 4; i++) {
315 red4[i] = ~red4[i];
316 green4[i] = ~green4[i];
317 blue4[i] = ~blue4[i];
318 }
319 for (i = 0; i < 8; i++) {
320 red8[i] = ~red8[i];
321 green8[i] = ~green8[i];
322 blue8[i] = ~blue8[i];
323 }
324 for (i = 0; i < 16; i++) {
325 red16[i] = ~red16[i];
326 green16[i] = ~green16[i];
327 blue16[i] = ~blue16[i];
328 }
329}
330
331
332 /*
333 * Visible symbols for modules
334 */
335
336EXPORT_SYMBOL(fb_alloc_cmap);
337EXPORT_SYMBOL(fb_dealloc_cmap);
338EXPORT_SYMBOL(fb_copy_cmap);
339EXPORT_SYMBOL(fb_set_cmap);
340EXPORT_SYMBOL(fb_default_cmap);
341EXPORT_SYMBOL(fb_invert_cmaps);