projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
driver: tty: serial: remove cast for kzalloc return value
[deliverable/linux.git] / drivers / tty / vt / consolemap.c
CommitLineData
1da177e4
LT		 1/*
2 * consolemap.c
3 *
4 * Mapping from internal code (such as Latin-1 or Unicode or IBM PC code)
5 * to font positions.
6 *
7 * aeb, 950210
8 *
9 * Support for multiple unimaps by Jakub Jelinek <jj@ultra.linux.cz>, July 1998
10 *
11 * Fix bug in inverse translation. Stanislav Voronyi <stas@cnti.uanet.kharkov.ua>, Dec 1998
12 */
13
1da177e4
LT		 14#include <linux/module.h>
15#include <linux/kd.h>
16#include <linux/errno.h>
17#include <linux/mm.h>
18#include <linux/slab.h>
19#include <linux/init.h>
20#include <linux/tty.h>
21#include <asm/uaccess.h>
5d1a33fa 22#include <linux/console.h>
1da177e4
LT		 23#include <linux/consolemap.h>
24#include <linux/vt_kern.h>
25
26static unsigned short translations[][256] = {
27 /* 8-bit Latin-1 mapped to Unicode -- trivial mapping */
28 {
29 0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
30 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f,
31 0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
32 0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f,
33 0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
34 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
35 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
36 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
37 0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
38 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
39 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
40 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
41 0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
42 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
43 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
44 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f,
45 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
46 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
47 0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
48 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
49 0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7,
50 0x00a8, 0x00a9, 0x00aa, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
51 0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7,
52 0x00b8, 0x00b9, 0x00ba, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00bf,
53 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7,
54 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf,
55 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
56 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
57 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7,
58 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
59 0x00f0, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7,
60 0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x00ff
61 },
62 /* VT100 graphics mapped to Unicode */
63 {
64 0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
65 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f,
66 0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
67 0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f,
68 0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
69 0x0028, 0x0029, 0x002a, 0x2192, 0x2190, 0x2191, 0x2193, 0x002f,
70 0x2588, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
71 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
72 0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
73 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
74 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
75 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x00a0,
76 0x25c6, 0x2592, 0x2409, 0x240c, 0x240d, 0x240a, 0x00b0, 0x00b1,
77 0x2591, 0x240b, 0x2518, 0x2510, 0x250c, 0x2514, 0x253c, 0x23ba,
78 0x23bb, 0x2500, 0x23bc, 0x23bd, 0x251c, 0x2524, 0x2534, 0x252c,
79 0x2502, 0x2264, 0x2265, 0x03c0, 0x2260, 0x00a3, 0x00b7, 0x007f,
80 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
81 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
82 0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
83 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
84 0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7,
85 0x00a8, 0x00a9, 0x00aa, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
86 0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7,
87 0x00b8, 0x00b9, 0x00ba, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00bf,
88 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7,
89 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf,
90 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
91 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
92 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7,
93 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
94 0x00f0, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7,
95 0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x00ff
96 },
97 /* IBM Codepage 437 mapped to Unicode */
98 {
99 0x0000, 0x263a, 0x263b, 0x2665, 0x2666, 0x2663, 0x2660, 0x2022,
100 0x25d8, 0x25cb, 0x25d9, 0x2642, 0x2640, 0x266a, 0x266b, 0x263c,
101 0x25b6, 0x25c0, 0x2195, 0x203c, 0x00b6, 0x00a7, 0x25ac, 0x21a8,
102 0x2191, 0x2193, 0x2192, 0x2190, 0x221f, 0x2194, 0x25b2, 0x25bc,
103 0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
104 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
105 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
106 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
107 0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
108 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
109 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
110 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
111 0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
112 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
113 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
114 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x2302,
115 0x00c7, 0x00fc, 0x00e9, 0x00e2, 0x00e4, 0x00e0, 0x00e5, 0x00e7,
116 0x00ea, 0x00eb, 0x00e8, 0x00ef, 0x00ee, 0x00ec, 0x00c4, 0x00c5,
117 0x00c9, 0x00e6, 0x00c6, 0x00f4, 0x00f6, 0x00f2, 0x00fb, 0x00f9,
118 0x00ff, 0x00d6, 0x00dc, 0x00a2, 0x00a3, 0x00a5, 0x20a7, 0x0192,
119 0x00e1, 0x00ed, 0x00f3, 0x00fa, 0x00f1, 0x00d1, 0x00aa, 0x00ba,
120 0x00bf, 0x2310, 0x00ac, 0x00bd, 0x00bc, 0x00a1, 0x00ab, 0x00bb,
121 0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
122 0x2555, 0x2563, 0x2551, 0x2557, 0x255d, 0x255c, 0x255b, 0x2510,
123 0x2514, 0x2534, 0x252c, 0x251c, 0x2500, 0x253c, 0x255e, 0x255f,
124 0x255a, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256c, 0x2567,
125 0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256b,
126 0x256a, 0x2518, 0x250c, 0x2588, 0x2584, 0x258c, 0x2590, 0x2580,
127 0x03b1, 0x00df, 0x0393, 0x03c0, 0x03a3, 0x03c3, 0x00b5, 0x03c4,
128 0x03a6, 0x0398, 0x03a9, 0x03b4, 0x221e, 0x03c6, 0x03b5, 0x2229,
129 0x2261, 0x00b1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00f7, 0x2248,
130 0x00b0, 0x2219, 0x00b7, 0x221a, 0x207f, 0x00b2, 0x25a0, 0x00a0
131 },
132 /* User mapping -- default to codes for direct font mapping */
133 {
134 0xf000, 0xf001, 0xf002, 0xf003, 0xf004, 0xf005, 0xf006, 0xf007,
135 0xf008, 0xf009, 0xf00a, 0xf00b, 0xf00c, 0xf00d, 0xf00e, 0xf00f,
136 0xf010, 0xf011, 0xf012, 0xf013, 0xf014, 0xf015, 0xf016, 0xf017,
137 0xf018, 0xf019, 0xf01a, 0xf01b, 0xf01c, 0xf01d, 0xf01e, 0xf01f,
138 0xf020, 0xf021, 0xf022, 0xf023, 0xf024, 0xf025, 0xf026, 0xf027,
139 0xf028, 0xf029, 0xf02a, 0xf02b, 0xf02c, 0xf02d, 0xf02e, 0xf02f,
140 0xf030, 0xf031, 0xf032, 0xf033, 0xf034, 0xf035, 0xf036, 0xf037,
141 0xf038, 0xf039, 0xf03a, 0xf03b, 0xf03c, 0xf03d, 0xf03e, 0xf03f,
142 0xf040, 0xf041, 0xf042, 0xf043, 0xf044, 0xf045, 0xf046, 0xf047,
143 0xf048, 0xf049, 0xf04a, 0xf04b, 0xf04c, 0xf04d, 0xf04e, 0xf04f,
144 0xf050, 0xf051, 0xf052, 0xf053, 0xf054, 0xf055, 0xf056, 0xf057,
145 0xf058, 0xf059, 0xf05a, 0xf05b, 0xf05c, 0xf05d, 0xf05e, 0xf05f,
146 0xf060, 0xf061, 0xf062, 0xf063, 0xf064, 0xf065, 0xf066, 0xf067,
147 0xf068, 0xf069, 0xf06a, 0xf06b, 0xf06c, 0xf06d, 0xf06e, 0xf06f,
148 0xf070, 0xf071, 0xf072, 0xf073, 0xf074, 0xf075, 0xf076, 0xf077,
149 0xf078, 0xf079, 0xf07a, 0xf07b, 0xf07c, 0xf07d, 0xf07e, 0xf07f,
150 0xf080, 0xf081, 0xf082, 0xf083, 0xf084, 0xf085, 0xf086, 0xf087,
151 0xf088, 0xf089, 0xf08a, 0xf08b, 0xf08c, 0xf08d, 0xf08e, 0xf08f,
152 0xf090, 0xf091, 0xf092, 0xf093, 0xf094, 0xf095, 0xf096, 0xf097,
153 0xf098, 0xf099, 0xf09a, 0xf09b, 0xf09c, 0xf09d, 0xf09e, 0xf09f,
154 0xf0a0, 0xf0a1, 0xf0a2, 0xf0a3, 0xf0a4, 0xf0a5, 0xf0a6, 0xf0a7,
155 0xf0a8, 0xf0a9, 0xf0aa, 0xf0ab, 0xf0ac, 0xf0ad, 0xf0ae, 0xf0af,
156 0xf0b0, 0xf0b1, 0xf0b2, 0xf0b3, 0xf0b4, 0xf0b5, 0xf0b6, 0xf0b7,
157 0xf0b8, 0xf0b9, 0xf0ba, 0xf0bb, 0xf0bc, 0xf0bd, 0xf0be, 0xf0bf,
158 0xf0c0, 0xf0c1, 0xf0c2, 0xf0c3, 0xf0c4, 0xf0c5, 0xf0c6, 0xf0c7,
159 0xf0c8, 0xf0c9, 0xf0ca, 0xf0cb, 0xf0cc, 0xf0cd, 0xf0ce, 0xf0cf,
160 0xf0d0, 0xf0d1, 0xf0d2, 0xf0d3, 0xf0d4, 0xf0d5, 0xf0d6, 0xf0d7,
161 0xf0d8, 0xf0d9, 0xf0da, 0xf0db, 0xf0dc, 0xf0dd, 0xf0de, 0xf0df,
162 0xf0e0, 0xf0e1, 0xf0e2, 0xf0e3, 0xf0e4, 0xf0e5, 0xf0e6, 0xf0e7,
163 0xf0e8, 0xf0e9, 0xf0ea, 0xf0eb, 0xf0ec, 0xf0ed, 0xf0ee, 0xf0ef,
164 0xf0f0, 0xf0f1, 0xf0f2, 0xf0f3, 0xf0f4, 0xf0f5, 0xf0f6, 0xf0f7,
165 0xf0f8, 0xf0f9, 0xf0fa, 0xf0fb, 0xf0fc, 0xf0fd, 0xf0fe, 0xf0ff
166 }
167};
168
169/* The standard kernel character-to-font mappings are not invertible
170 -- this is just a best effort. */
171
172#define MAX_GLYPH 512 /* Max possible glyph value */
173
174static int inv_translate[MAX_NR_CONSOLES];
175
176struct uni_pagedir {
177 u16 **uni_pgdir[32];
178 unsigned long refcount;
179 unsigned long sum;
180 unsigned char *inverse_translations[4];
759448f4 181 u16 *inverse_trans_unicode;
1da177e4
LT		 182 int readonly;
183};
184
185static struct uni_pagedir *dflt;
186
187static void set_inverse_transl(struct vc_data *conp, struct uni_pagedir *p, int i)
188{
189 int j, glyph;
190 unsigned short *t = translations[i];
191 unsigned char *q;
192
193 if (!p) return;
194 q = p->inverse_translations[i];
195
196 if (!q) {
197 q = p->inverse_translations[i] = (unsigned char *)
198 kmalloc(MAX_GLYPH, GFP_KERNEL);
199 if (!q) return;
200 }
201 memset(q, 0, MAX_GLYPH);
202
203 for (j = 0; j < E_TABSZ; j++) {
204 glyph = conv_uni_to_pc(conp, t[j]);
205 if (glyph >= 0 && glyph < MAX_GLYPH && q[glyph] < 32) {
206 /* prefer '-' above SHY etc. */
207 q[glyph] = j;
208 }
209 }
210}
211
759448f4
JE		 212static void set_inverse_trans_unicode(struct vc_data *conp,
213 struct uni_pagedir *p)
214{
215 int i, j, k, glyph;
216 u16 **p1, *p2;
217 u16 *q;
218
219 if (!p) return;
220 q = p->inverse_trans_unicode;
221 if (!q) {
222 q = p->inverse_trans_unicode =
223 kmalloc(MAX_GLYPH * sizeof(u16), GFP_KERNEL);
224 if (!q)
225 return;
226 }
227 memset(q, 0, MAX_GLYPH * sizeof(u16));
228
229 for (i = 0; i < 32; i++) {
230 p1 = p->uni_pgdir[i];
231 if (!p1)
232 continue;
233 for (j = 0; j < 32; j++) {
234 p2 = p1[j];
235 if (!p2)
236 continue;
237 for (k = 0; k < 64; k++) {
238 glyph = p2[k];
239 if (glyph >= 0 && glyph < MAX_GLYPH
240 && q[glyph] < 32)
241 q[glyph] = (i << 11) + (j << 6) + k;
242 }
243 }
244 }
245}
246
1da177e4
LT		 247unsigned short *set_translate(int m, struct vc_data *vc)
248{
249 inv_translate[vc->vc_num] = m;
250 return translations[m];
251}
252
253/*
254 * Inverse translation is impossible for several reasons:
255 * 1. The font<->character maps are not 1-1.
256 * 2. The text may have been written while a different translation map
759448f4 257 * was active.
1da177e4
LT		 258 * Still, it is now possible to a certain extent to cut and paste non-ASCII.
259 */
759448f4 260u16 inverse_translate(struct vc_data *conp, int glyph, int use_unicode)
1da177e4
LT		 261{
262 struct uni_pagedir *p;
759448f4 263 int m;
1da177e4
LT		 264 if (glyph < 0 || glyph >= MAX_GLYPH)
265 return 0;
759448f4 266 else if (!(p = (struct uni_pagedir *)*conp->vc_uni_pagedir_loc))
1da177e4 267 return glyph;
759448f4
JE		 268 else if (use_unicode) {
269 if (!p->inverse_trans_unicode)
270 return glyph;
271 else
272 return p->inverse_trans_unicode[glyph];
273 } else {
274 m = inv_translate[conp->vc_num];
275 if (!p->inverse_translations[m])
276 return glyph;
277 else
278 return p->inverse_translations[m][glyph];
279 }
1da177e4 280}
f7511d5f 281EXPORT_SYMBOL_GPL(inverse_translate);
1da177e4
LT		 282
283static void update_user_maps(void)
284{
285 int i;
286 struct uni_pagedir *p, *q = NULL;
287
288 for (i = 0; i < MAX_NR_CONSOLES; i++) {
289 if (!vc_cons_allocated(i))
290 continue;
291 p = (struct uni_pagedir *)*vc_cons[i].d->vc_uni_pagedir_loc;
292 if (p && p != q) {
293 set_inverse_transl(vc_cons[i].d, p, USER_MAP);
759448f4 294 set_inverse_trans_unicode(vc_cons[i].d, p);
1da177e4
LT		 295 q = p;
296 }
297 }
298}
299
300/*
301 * Load customizable translation table
302 * arg points to a 256 byte translation table.
303 *
304 * The "old" variants are for translation directly to font (using the
305 * 0xf000-0xf0ff "transparent" Unicodes) whereas the "new" variants set
306 * Unicodes explicitly.
307 */
308int con_set_trans_old(unsigned char __user * arg)
309{
310 int i;
311 unsigned short *p = translations[USER_MAP];
312
313 if (!access_ok(VERIFY_READ, arg, E_TABSZ))
314 return -EFAULT;
315
5d1a33fa 316 console_lock();
1da177e4
LT		 317 for (i=0; i<E_TABSZ ; i++) {
318 unsigned char uc;
319 __get_user(uc, arg+i);
320 p[i] = UNI_DIRECT_BASE | uc;
321 }
322
323 update_user_maps();
5d1a33fa 324 console_unlock();
1da177e4
LT		 325 return 0;
326}
327
328int con_get_trans_old(unsigned char __user * arg)
329{
330 int i, ch;
331 unsigned short *p = translations[USER_MAP];
332
333 if (!access_ok(VERIFY_WRITE, arg, E_TABSZ))
334 return -EFAULT;
335
5d1a33fa 336 console_lock();
1da177e4 337 for (i=0; i<E_TABSZ ; i++)
5d1a33fa
AC		 338 {
339 ch = conv_uni_to_pc(vc_cons[fg_console].d, p[i]);
340 __put_user((ch & ~0xff) ? 0 : ch, arg+i);
341 }
342 console_unlock();
1da177e4
LT		 343 return 0;
344}
345
346int con_set_trans_new(ushort __user * arg)
347{
348 int i;
349 unsigned short *p = translations[USER_MAP];
350
351 if (!access_ok(VERIFY_READ, arg, E_TABSZ*sizeof(unsigned short)))
352 return -EFAULT;
353
5d1a33fa 354 console_lock();
1da177e4
LT		 355 for (i=0; i<E_TABSZ ; i++) {
356 unsigned short us;
357 __get_user(us, arg+i);
358 p[i] = us;
359 }
360
361 update_user_maps();
5d1a33fa 362 console_unlock();
1da177e4
LT		 363 return 0;
364}
365
366int con_get_trans_new(ushort __user * arg)
367{
368 int i;
369 unsigned short *p = translations[USER_MAP];
370
371 if (!access_ok(VERIFY_WRITE, arg, E_TABSZ*sizeof(unsigned short)))
372 return -EFAULT;
373
5d1a33fa 374 console_lock();
1da177e4
LT		 375 for (i=0; i<E_TABSZ ; i++)
376 __put_user(p[i], arg+i);
5d1a33fa 377 console_unlock();
1da177e4
LT		 378
379 return 0;
380}
381
382/*
383 * Unicode -> current font conversion
384 *
385 * A font has at most 512 chars, usually 256.
386 * But one font position may represent several Unicode chars.
387 * A hashtable is somewhat of a pain to deal with, so use a
388 * "paged table" instead. Simulation has shown the memory cost of
389 * this 3-level paged table scheme to be comparable to a hash table.
390 */
391
392extern u8 dfont_unicount[]; /* Defined in console_defmap.c */
393extern u16 dfont_unitable[];
394
395static void con_release_unimap(struct uni_pagedir *p)
396{
397 u16 **p1;
398 int i, j;
399
400 if (p == dflt) dflt = NULL;
401 for (i = 0; i < 32; i++) {
402 if ((p1 = p->uni_pgdir[i]) != NULL) {
403 for (j = 0; j < 32; j++)
735d5661 404 kfree(p1[j]);
1da177e4
LT		 405 kfree(p1);
406 }
407 p->uni_pgdir[i] = NULL;
408 }
735d5661
JJ		 409 for (i = 0; i < 4; i++) {
410 kfree(p->inverse_translations[i]);
411 p->inverse_translations[i] = NULL;
412 }
daa74a25
SK		 413 kfree(p->inverse_trans_unicode);
414 p->inverse_trans_unicode = NULL;
1da177e4
LT		 415}
416
5d1a33fa 417/* Caller must hold the console lock */
1da177e4
LT		 418void con_free_unimap(struct vc_data *vc)
419{
420 struct uni_pagedir *p;
421
422 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
423 if (!p)
424 return;
425 *vc->vc_uni_pagedir_loc = 0;
426 if (--p->refcount)
427 return;
428 con_release_unimap(p);
429 kfree(p);
430}
431
432static int con_unify_unimap(struct vc_data *conp, struct uni_pagedir *p)
433{
434 int i, j, k;
435 struct uni_pagedir *q;
436
437 for (i = 0; i < MAX_NR_CONSOLES; i++) {
438 if (!vc_cons_allocated(i))
439 continue;
440 q = (struct uni_pagedir *)*vc_cons[i].d->vc_uni_pagedir_loc;
441 if (!q || q == p || q->sum != p->sum)
442 continue;
443 for (j = 0; j < 32; j++) {
444 u16 **p1, **q1;
445 p1 = p->uni_pgdir[j]; q1 = q->uni_pgdir[j];
446 if (!p1 && !q1)
447 continue;
448 if (!p1 || !q1)
449 break;
450 for (k = 0; k < 32; k++) {
451 if (!p1[k] && !q1[k])
452 continue;
453 if (!p1[k] || !q1[k])
454 break;
455 if (memcmp(p1[k], q1[k], 64*sizeof(u16)))
456 break;
457 }
458 if (k < 32)
459 break;
460 }
461 if (j == 32) {
462 q->refcount++;
463 *conp->vc_uni_pagedir_loc = (unsigned long)q;
464 con_release_unimap(p);
465 kfree(p);
466 return 1;
467 }
468 }
469 return 0;
470}
471
472static int
473con_insert_unipair(struct uni_pagedir *p, u_short unicode, u_short fontpos)
474{
475 int i, n;
476 u16 **p1, *p2;
477
478 if (!(p1 = p->uni_pgdir[n = unicode >> 11])) {
479 p1 = p->uni_pgdir[n] = kmalloc(32*sizeof(u16 *), GFP_KERNEL);
480 if (!p1) return -ENOMEM;
481 for (i = 0; i < 32; i++)
482 p1[i] = NULL;
483 }
484
485 if (!(p2 = p1[n = (unicode >> 6) & 0x1f])) {
486 p2 = p1[n] = kmalloc(64*sizeof(u16), GFP_KERNEL);
487 if (!p2) return -ENOMEM;
488 memset(p2, 0xff, 64*sizeof(u16)); /* No glyphs for the characters (yet) */
489 }
490
491 p2[unicode & 0x3f] = fontpos;
492
493 p->sum += (fontpos << 20) + unicode;
494
495 return 0;
496}
497
5d1a33fa
AC		 498/* ui is a leftover from using a hashtable, but might be used again
499 Caller must hold the lock */
500static int con_do_clear_unimap(struct vc_data *vc, struct unimapinit *ui)
1da177e4
LT		 501{
502 struct uni_pagedir *p, *q;
5d1a33fa 503
1da177e4 504 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
5d1a33fa
AC		 505 if (p && p->readonly)
506 return -EIO;
507
1da177e4 508 if (!p || --p->refcount) {
392b7bc1 509 q = kzalloc(sizeof(*p), GFP_KERNEL);
1da177e4 510 if (!q) {
5d1a33fa
AC		 511 if (p)
512 p->refcount++;
1da177e4
LT		 513 return -ENOMEM;
514 }
1da177e4
LT		 515 q->refcount=1;
516 *vc->vc_uni_pagedir_loc = (unsigned long)q;
517 } else {
518 if (p == dflt) dflt = NULL;
519 p->refcount++;
520 p->sum = 0;
521 con_release_unimap(p);
522 }
523 return 0;
524}
525
5d1a33fa
AC		 526int con_clear_unimap(struct vc_data *vc, struct unimapinit *ui)
527{
528 int ret;
529 console_lock();
530 ret = con_do_clear_unimap(vc, ui);
531 console_unlock();
532 return ret;
533}
534
1da177e4
LT		 535int con_set_unimap(struct vc_data *vc, ushort ct, struct unipair __user *list)
536{
537 int err = 0, err1, i;
538 struct uni_pagedir *p, *q;
539
5d1a33fa
AC		 540 console_lock();
541
4a4c61b7 542 /* Save original vc_unipagdir_loc in case we allocate a new one */
1da177e4 543 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
5d1a33fa
AC		 544 if (p->readonly) {
545 console_unlock();
546 return -EIO;
547 }
1da177e4 548
5d1a33fa
AC		 549 if (!ct) {
550 console_unlock();
551 return 0;
552 }
1da177e4
LT		 553
554 if (p->refcount > 1) {
555 int j, k;
556 u16 **p1, *p2, l;
557
5d1a33fa
AC		 558 err1 = con_do_clear_unimap(vc, NULL);
559 if (err1) {
560 console_unlock();
561 return err1;
562 }
1da177e4 563
4a4c61b7
LC		 564 /*
565 * Since refcount was > 1, con_clear_unimap() allocated a
566 * a new uni_pagedir for this vc. Re: p != q
567 */
1da177e4 568 q = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
4a4c61b7
LC		 569
570 /*
571 * uni_pgdir is a 32*32*64 table with rows allocated
572 * when its first entry is added. The unicode value must
573 * still be incremented for empty rows. We are copying
574 * entries from "p" (old) to "q" (new).
575 */
576 l = 0; /* unicode value */
577 for (i = 0; i < 32; i++)
1da177e4
LT		 578 if ((p1 = p->uni_pgdir[i]))
579 for (j = 0; j < 32; j++)
4a4c61b7 580 if ((p2 = p1[j])) {
1da177e4
LT		 581 for (k = 0; k < 64; k++, l++)
582 if (p2[k] != 0xffff) {
4a4c61b7
LC		 583 /*
584 * Found one, copy entry for unicode
585 * l with fontpos value p2[k].
586 */
1da177e4
LT		 587 err1 = con_insert_unipair(q, l, p2[k]);
588 if (err1) {
589 p->refcount++;
590 *vc->vc_uni_pagedir_loc = (unsigned long)p;
591 con_release_unimap(q);
592 kfree(q);
5d1a33fa
AC		 593 console_unlock();
594 return err1;
1da177e4 595 }
4a4c61b7
LC		 596 }
597 } else {
598 /* Account for row of 64 empty entries */
599 l += 64;
600 }
601 else
602 /* Account for empty table */
603 l += 32 * 64;
604
605 /*
606 * Finished copying font table, set vc_uni_pagedir to new table
607 */
608 p = q;
609 } else if (p == dflt) {
1da177e4 610 dflt = NULL;
4a4c61b7
LC		 611 }
612
613 /*
614 * Insert user specified unicode pairs into new table.
615 */
1da177e4
LT		 616 while (ct--) {
617 unsigned short unicode, fontpos;
618 __get_user(unicode, &list->unicode);
619 __get_user(fontpos, &list->fontpos);
620 if ((err1 = con_insert_unipair(p, unicode,fontpos)) != 0)
621 err = err1;
71183c94 622 list++;
1da177e4
LT		 623 }
624
4a4c61b7
LC		 625 /*
626 * Merge with fontmaps of any other virtual consoles.
627 */
5d1a33fa
AC		 628 if (con_unify_unimap(vc, p)) {
629 console_unlock();
1da177e4 630 return err;
5d1a33fa 631 }
1da177e4
LT		 632
633 for (i = 0; i <= 3; i++)
4a4c61b7 634 set_inverse_transl(vc, p, i); /* Update inverse translations */
759448f4 635 set_inverse_trans_unicode(vc, p);
5d1a33fa
AC		 636
637 console_unlock();
1da177e4
LT		 638 return err;
639}
640
5d1a33fa
AC		 641/**
642 * con_set_default_unimap - set default unicode map
643 * @vc: the console we are updating
644 *
645 * Loads the unimap for the hardware font, as defined in uni_hash.tbl.
646 * The representation used was the most compact I could come up
647 * with. This routine is executed at video setup, and when the
648 * PIO_FONTRESET ioctl is called.
649 *
650 * The caller must hold the console lock
651 */
1da177e4
LT		 652int con_set_default_unimap(struct vc_data *vc)
653{
654 int i, j, err = 0, err1;
655 u16 *q;
656 struct uni_pagedir *p;
657
658 if (dflt) {
659 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
660 if (p == dflt)
661 return 0;
5d1a33fa 662
1da177e4
LT		 663 dflt->refcount++;
664 *vc->vc_uni_pagedir_loc = (unsigned long)dflt;
106b5fa7 665 if (p && !--p->refcount) {
1da177e4
LT		 666 con_release_unimap(p);
667 kfree(p);
668 }
669 return 0;
670 }
671
672 /* The default font is always 256 characters */
673
5d1a33fa
AC		 674 err = con_do_clear_unimap(vc, NULL);
675 if (err)
676 return err;
1da177e4
LT		 677
678 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
679 q = dfont_unitable;
680
681 for (i = 0; i < 256; i++)
682 for (j = dfont_unicount[i]; j; j--) {
683 err1 = con_insert_unipair(p, *(q++), i);
684 if (err1)
685 err = err1;
686 }
687
688 if (con_unify_unimap(vc, p)) {
689 dflt = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
690 return err;
691 }
692
693 for (i = 0; i <= 3; i++)
694 set_inverse_transl(vc, p, i); /* Update all inverse translations */
759448f4 695 set_inverse_trans_unicode(vc, p);
1da177e4
LT		 696 dflt = p;
697 return err;
698}
699EXPORT_SYMBOL(con_set_default_unimap);
700
5d1a33fa
AC		 701/**
702 * con_copy_unimap - copy unimap between two vts
703 * @dst_vc: target
704 * @src_vt: source
705 *
706 * The caller must hold the console lock when invoking this method
707 */
1da177e4
LT		 708int con_copy_unimap(struct vc_data *dst_vc, struct vc_data *src_vc)
709{
710 struct uni_pagedir *q;
711
712 if (!*src_vc->vc_uni_pagedir_loc)
713 return -EINVAL;
714 if (*dst_vc->vc_uni_pagedir_loc == *src_vc->vc_uni_pagedir_loc)
715 return 0;
716 con_free_unimap(dst_vc);
717 q = (struct uni_pagedir *)*src_vc->vc_uni_pagedir_loc;
718 q->refcount++;
719 *dst_vc->vc_uni_pagedir_loc = (long)q;
720 return 0;
721}
5d1a33fa 722EXPORT_SYMBOL(con_copy_unimap);
1da177e4 723
5d1a33fa
AC		 724/**
725 * con_get_unimap - get the unicode map
726 * @vc: the console to read from
727 *
728 * Read the console unicode data for this console. Called from the ioctl
729 * handlers.
730 */
1da177e4
LT		 731int con_get_unimap(struct vc_data *vc, ushort ct, ushort __user *uct, struct unipair __user *list)
732{
733 int i, j, k, ect;
734 u16 **p1, *p2;
735 struct uni_pagedir *p;
736
5d1a33fa
AC		 737 console_lock();
738
1da177e4
LT		 739 ect = 0;
740 if (*vc->vc_uni_pagedir_loc) {
741 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
742 for (i = 0; i < 32; i++)
743 if ((p1 = p->uni_pgdir[i]))
744 for (j = 0; j < 32; j++)
745 if ((p2 = *(p1++)))
746 for (k = 0; k < 64; k++) {
747 if (*p2 < MAX_GLYPH && ect++ < ct) {
748 __put_user((u_short)((i<<11)+(j<<6)+k),
749 &list->unicode);
750 __put_user((u_short) *p2,
751 &list->fontpos);
752 list++;
753 }
754 p2++;
755 }
756 }
757 __put_user(ect, uct);
5d1a33fa 758 console_unlock();
1da177e4
LT		 759 return ((ect <= ct) ? 0 : -ENOMEM);
760}
761
04c71976
ST		 762/*
763 * Always use USER_MAP. These functions are used by the keyboard,
764 * which shouldn't be affected by G0/G1 switching, etc.
765 * If the user map still contains default values, i.e. the
766 * direct-to-font mapping, then assume user is using Latin1.
5d1a33fa
AC		 767 *
768 * FIXME: at some point we need to decide if we want to lock the table
769 * update element itself via the keyboard_event_lock for consistency with the
770 * keyboard driver as well as the consoles
04c71976 771 */
759448f4
JE		 772/* may be called during an interrupt */
773u32 conv_8bit_to_uni(unsigned char c)
774{
759448f4
JE		 775 unsigned short uni = translations[USER_MAP][c];
776 return uni == (0xf000 | c) ? c : uni;
777}
778
04c71976
ST		 779int conv_uni_to_8bit(u32 uni)
780{
781 int c;
782 for (c = 0; c < 0x100; c++)
783 if (translations[USER_MAP][c] == uni ||
784 (translations[USER_MAP][c] == (c | 0xf000) && uni == c))
785 return c;
786 return -1;
787}
788
1da177e4
LT		 789int
790conv_uni_to_pc(struct vc_data *conp, long ucs)
791{
792 int h;
793 u16 **p1, *p2;
794 struct uni_pagedir *p;
795
796 /* Only 16-bit codes supported at this time */
797 if (ucs > 0xffff)
2f1a2ccb
EK		 798 return -4; /* Not found */
799 else if (ucs < 0x20)
1da177e4 800 return -1; /* Not a printable character */
2f1a2ccb 801 else if (ucs == 0xfeff || (ucs >= 0x200b && ucs <= 0x200f))
1da177e4
LT		 802 return -2; /* Zero-width space */
803 /*
804 * UNI_DIRECT_BASE indicates the start of the region in the User Zone
805 * which always has a 1:1 mapping to the currently loaded font. The
806 * UNI_DIRECT_MASK indicates the bit span of the region.
807 */
808 else if ((ucs & ~UNI_DIRECT_MASK) == UNI_DIRECT_BASE)
809 return ucs & UNI_DIRECT_MASK;
810
811 if (!*conp->vc_uni_pagedir_loc)
812 return -3;
813
814 p = (struct uni_pagedir *)*conp->vc_uni_pagedir_loc;
815 if ((p1 = p->uni_pgdir[ucs >> 11]) &&
816 (p2 = p1[(ucs >> 6) & 0x1f]) &&
817 (h = p2[ucs & 0x3f]) < MAX_GLYPH)
818 return h;
819
820 return -4; /* not found */
821}
822
823/*
824 * This is called at sys_setup time, after memory and the console are
825 * initialized. It must be possible to call kmalloc(..., GFP_KERNEL)
826 * from this function, hence the call from sys_setup.
827 */
828void __init
829console_map_init(void)
830{
831 int i;
832
833 for (i = 0; i < MAX_NR_CONSOLES; i++)
834 if (vc_cons_allocated(i) && !*vc_cons[i].d->vc_uni_pagedir_loc)
835 con_set_default_unimap(vc_cons[i].d);
836}
837
Linux kernel - Deliverables
This page took 0.664179 seconds and 5 git commands to generate.