xref: /openbmc/linux/drivers/tty/vt/consolemap.c (revision d2999e1b)
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 
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>
22 #include <linux/console.h>
23 #include <linux/consolemap.h>
24 #include <linux/vt_kern.h>
25 
26 static 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 
174 static int inv_translate[MAX_NR_CONSOLES];
175 
176 struct uni_pagedir {
177 	u16 		**uni_pgdir[32];
178 	unsigned long	refcount;
179 	unsigned long	sum;
180 	unsigned char	*inverse_translations[4];
181 	u16		*inverse_trans_unicode;
182 };
183 
184 static struct uni_pagedir *dflt;
185 
186 static void set_inverse_transl(struct vc_data *conp, struct uni_pagedir *p, int i)
187 {
188 	int j, glyph;
189 	unsigned short *t = translations[i];
190 	unsigned char *q;
191 
192 	if (!p) return;
193 	q = p->inverse_translations[i];
194 
195 	if (!q) {
196 		q = p->inverse_translations[i] = kmalloc(MAX_GLYPH, GFP_KERNEL);
197 		if (!q) return;
198 	}
199 	memset(q, 0, MAX_GLYPH);
200 
201 	for (j = 0; j < E_TABSZ; j++) {
202 		glyph = conv_uni_to_pc(conp, t[j]);
203 		if (glyph >= 0 && glyph < MAX_GLYPH && q[glyph] < 32) {
204 			/* prefer '-' above SHY etc. */
205 		  	q[glyph] = j;
206 		}
207 	}
208 }
209 
210 static void set_inverse_trans_unicode(struct vc_data *conp,
211 				      struct uni_pagedir *p)
212 {
213 	int i, j, k, glyph;
214 	u16 **p1, *p2;
215 	u16 *q;
216 
217 	if (!p) return;
218 	q = p->inverse_trans_unicode;
219 	if (!q) {
220 		q = p->inverse_trans_unicode =
221 			kmalloc(MAX_GLYPH * sizeof(u16), GFP_KERNEL);
222 		if (!q)
223 			return;
224 	}
225 	memset(q, 0, MAX_GLYPH * sizeof(u16));
226 
227 	for (i = 0; i < 32; i++) {
228 		p1 = p->uni_pgdir[i];
229 		if (!p1)
230 			continue;
231 		for (j = 0; j < 32; j++) {
232 			p2 = p1[j];
233 			if (!p2)
234 				continue;
235 			for (k = 0; k < 64; k++) {
236 				glyph = p2[k];
237 				if (glyph >= 0 && glyph < MAX_GLYPH
238 					       && q[glyph] < 32)
239 		  			q[glyph] = (i << 11) + (j << 6) + k;
240 			}
241 		}
242 	}
243 }
244 
245 unsigned short *set_translate(int m, struct vc_data *vc)
246 {
247 	inv_translate[vc->vc_num] = m;
248 	return translations[m];
249 }
250 
251 /*
252  * Inverse translation is impossible for several reasons:
253  * 1. The font<->character maps are not 1-1.
254  * 2. The text may have been written while a different translation map
255  *    was active.
256  * Still, it is now possible to a certain extent to cut and paste non-ASCII.
257  */
258 u16 inverse_translate(struct vc_data *conp, int glyph, int use_unicode)
259 {
260 	struct uni_pagedir *p;
261 	int m;
262 	if (glyph < 0 || glyph >= MAX_GLYPH)
263 		return 0;
264 	else if (!(p = *conp->vc_uni_pagedir_loc))
265 		return glyph;
266 	else if (use_unicode) {
267 		if (!p->inverse_trans_unicode)
268 			return glyph;
269 		else
270 			return p->inverse_trans_unicode[glyph];
271 	} else {
272 		m = inv_translate[conp->vc_num];
273 		if (!p->inverse_translations[m])
274 			return glyph;
275 		else
276 			return p->inverse_translations[m][glyph];
277 	}
278 }
279 EXPORT_SYMBOL_GPL(inverse_translate);
280 
281 static void update_user_maps(void)
282 {
283 	int i;
284 	struct uni_pagedir *p, *q = NULL;
285 
286 	for (i = 0; i < MAX_NR_CONSOLES; i++) {
287 		if (!vc_cons_allocated(i))
288 			continue;
289 		p = *vc_cons[i].d->vc_uni_pagedir_loc;
290 		if (p && p != q) {
291 			set_inverse_transl(vc_cons[i].d, p, USER_MAP);
292 			set_inverse_trans_unicode(vc_cons[i].d, p);
293 			q = p;
294 		}
295 	}
296 }
297 
298 /*
299  * Load customizable translation table
300  * arg points to a 256 byte translation table.
301  *
302  * The "old" variants are for translation directly to font (using the
303  * 0xf000-0xf0ff "transparent" Unicodes) whereas the "new" variants set
304  * Unicodes explicitly.
305  */
306 int con_set_trans_old(unsigned char __user * arg)
307 {
308 	int i;
309 	unsigned short *p = translations[USER_MAP];
310 
311 	if (!access_ok(VERIFY_READ, arg, E_TABSZ))
312 		return -EFAULT;
313 
314 	console_lock();
315 	for (i=0; i<E_TABSZ ; i++) {
316 		unsigned char uc;
317 		__get_user(uc, arg+i);
318 		p[i] = UNI_DIRECT_BASE | uc;
319 	}
320 
321 	update_user_maps();
322 	console_unlock();
323 	return 0;
324 }
325 
326 int con_get_trans_old(unsigned char __user * arg)
327 {
328 	int i, ch;
329 	unsigned short *p = translations[USER_MAP];
330 
331 	if (!access_ok(VERIFY_WRITE, arg, E_TABSZ))
332 		return -EFAULT;
333 
334 	console_lock();
335 	for (i=0; i<E_TABSZ ; i++)
336 	{
337 		ch = conv_uni_to_pc(vc_cons[fg_console].d, p[i]);
338 		__put_user((ch & ~0xff) ? 0 : ch, arg+i);
339 	}
340 	console_unlock();
341 	return 0;
342 }
343 
344 int con_set_trans_new(ushort __user * arg)
345 {
346 	int i;
347 	unsigned short *p = translations[USER_MAP];
348 
349 	if (!access_ok(VERIFY_READ, arg, E_TABSZ*sizeof(unsigned short)))
350 		return -EFAULT;
351 
352 	console_lock();
353 	for (i=0; i<E_TABSZ ; i++) {
354 		unsigned short us;
355 		__get_user(us, arg+i);
356 		p[i] = us;
357 	}
358 
359 	update_user_maps();
360 	console_unlock();
361 	return 0;
362 }
363 
364 int con_get_trans_new(ushort __user * arg)
365 {
366 	int i;
367 	unsigned short *p = translations[USER_MAP];
368 
369 	if (!access_ok(VERIFY_WRITE, arg, E_TABSZ*sizeof(unsigned short)))
370 		return -EFAULT;
371 
372 	console_lock();
373 	for (i=0; i<E_TABSZ ; i++)
374 	  __put_user(p[i], arg+i);
375 	console_unlock();
376 
377 	return 0;
378 }
379 
380 /*
381  * Unicode -> current font conversion
382  *
383  * A font has at most 512 chars, usually 256.
384  * But one font position may represent several Unicode chars.
385  * A hashtable is somewhat of a pain to deal with, so use a
386  * "paged table" instead.  Simulation has shown the memory cost of
387  * this 3-level paged table scheme to be comparable to a hash table.
388  */
389 
390 extern u8 dfont_unicount[];	/* Defined in console_defmap.c */
391 extern u16 dfont_unitable[];
392 
393 static void con_release_unimap(struct uni_pagedir *p)
394 {
395 	u16 **p1;
396 	int i, j;
397 
398 	if (p == dflt) dflt = NULL;
399 	for (i = 0; i < 32; i++) {
400 		if ((p1 = p->uni_pgdir[i]) != NULL) {
401 			for (j = 0; j < 32; j++)
402 				kfree(p1[j]);
403 			kfree(p1);
404 		}
405 		p->uni_pgdir[i] = NULL;
406 	}
407 	for (i = 0; i < 4; i++) {
408 		kfree(p->inverse_translations[i]);
409 		p->inverse_translations[i] = NULL;
410 	}
411 	kfree(p->inverse_trans_unicode);
412 	p->inverse_trans_unicode = NULL;
413 }
414 
415 /* Caller must hold the console lock */
416 void con_free_unimap(struct vc_data *vc)
417 {
418 	struct uni_pagedir *p;
419 
420 	p = *vc->vc_uni_pagedir_loc;
421 	if (!p)
422 		return;
423 	*vc->vc_uni_pagedir_loc = NULL;
424 	if (--p->refcount)
425 		return;
426 	con_release_unimap(p);
427 	kfree(p);
428 }
429 
430 static int con_unify_unimap(struct vc_data *conp, struct uni_pagedir *p)
431 {
432 	int i, j, k;
433 	struct uni_pagedir *q;
434 
435 	for (i = 0; i < MAX_NR_CONSOLES; i++) {
436 		if (!vc_cons_allocated(i))
437 			continue;
438 		q = *vc_cons[i].d->vc_uni_pagedir_loc;
439 		if (!q || q == p || q->sum != p->sum)
440 			continue;
441 		for (j = 0; j < 32; j++) {
442 			u16 **p1, **q1;
443 			p1 = p->uni_pgdir[j]; q1 = q->uni_pgdir[j];
444 			if (!p1 && !q1)
445 				continue;
446 			if (!p1 || !q1)
447 				break;
448 			for (k = 0; k < 32; k++) {
449 				if (!p1[k] && !q1[k])
450 					continue;
451 				if (!p1[k] || !q1[k])
452 					break;
453 				if (memcmp(p1[k], q1[k], 64*sizeof(u16)))
454 					break;
455 			}
456 			if (k < 32)
457 				break;
458 		}
459 		if (j == 32) {
460 			q->refcount++;
461 			*conp->vc_uni_pagedir_loc = q;
462 			con_release_unimap(p);
463 			kfree(p);
464 			return 1;
465 		}
466 	}
467 	return 0;
468 }
469 
470 static int
471 con_insert_unipair(struct uni_pagedir *p, u_short unicode, u_short fontpos)
472 {
473 	int i, n;
474 	u16 **p1, *p2;
475 
476 	if (!(p1 = p->uni_pgdir[n = unicode >> 11])) {
477 		p1 = p->uni_pgdir[n] = kmalloc(32*sizeof(u16 *), GFP_KERNEL);
478 		if (!p1) return -ENOMEM;
479 		for (i = 0; i < 32; i++)
480 			p1[i] = NULL;
481 	}
482 
483 	if (!(p2 = p1[n = (unicode >> 6) & 0x1f])) {
484 		p2 = p1[n] = kmalloc(64*sizeof(u16), GFP_KERNEL);
485 		if (!p2) return -ENOMEM;
486 		memset(p2, 0xff, 64*sizeof(u16)); /* No glyphs for the characters (yet) */
487 	}
488 
489 	p2[unicode & 0x3f] = fontpos;
490 
491 	p->sum += (fontpos << 20) + unicode;
492 
493 	return 0;
494 }
495 
496 /* ui is a leftover from using a hashtable, but might be used again
497    Caller must hold the lock */
498 static int con_do_clear_unimap(struct vc_data *vc, struct unimapinit *ui)
499 {
500 	struct uni_pagedir *p, *q;
501 
502 	p = *vc->vc_uni_pagedir_loc;
503 	if (!p || --p->refcount) {
504 		q = kzalloc(sizeof(*p), GFP_KERNEL);
505 		if (!q) {
506 			if (p)
507 				p->refcount++;
508 			return -ENOMEM;
509 		}
510 		q->refcount=1;
511 		*vc->vc_uni_pagedir_loc = q;
512 	} else {
513 		if (p == dflt) dflt = NULL;
514 		p->refcount++;
515 		p->sum = 0;
516 		con_release_unimap(p);
517 	}
518 	return 0;
519 }
520 
521 int con_clear_unimap(struct vc_data *vc, struct unimapinit *ui)
522 {
523 	int ret;
524 	console_lock();
525 	ret = con_do_clear_unimap(vc, ui);
526 	console_unlock();
527 	return ret;
528 }
529 
530 int con_set_unimap(struct vc_data *vc, ushort ct, struct unipair __user *list)
531 {
532 	int err = 0, err1, i;
533 	struct uni_pagedir *p, *q;
534 
535 	if (!ct)
536 		return 0;
537 
538 	console_lock();
539 
540 	/* Save original vc_unipagdir_loc in case we allocate a new one */
541 	p = *vc->vc_uni_pagedir_loc;
542 
543 	if (p->refcount > 1) {
544 		int j, k;
545 		u16 **p1, *p2, l;
546 
547 		err1 = con_do_clear_unimap(vc, NULL);
548 		if (err1) {
549 			console_unlock();
550 			return err1;
551 		}
552 
553 		/*
554 		 * Since refcount was > 1, con_clear_unimap() allocated a
555 		 * a new uni_pagedir for this vc.  Re: p != q
556 		 */
557 		q = *vc->vc_uni_pagedir_loc;
558 
559 		/*
560 		 * uni_pgdir is a 32*32*64 table with rows allocated
561 		 * when its first entry is added.  The unicode value must
562 		 * still be incremented for empty rows.  We are copying
563 		 * entries from "p" (old) to "q" (new).
564 		 */
565 		l = 0;		/* unicode value */
566 		for (i = 0; i < 32; i++)
567 		if ((p1 = p->uni_pgdir[i]))
568 			for (j = 0; j < 32; j++)
569 			if ((p2 = p1[j])) {
570 				for (k = 0; k < 64; k++, l++)
571 				if (p2[k] != 0xffff) {
572 					/*
573 					 * Found one, copy entry for unicode
574 					 * l with fontpos value p2[k].
575 					 */
576 					err1 = con_insert_unipair(q, l, p2[k]);
577 					if (err1) {
578 						p->refcount++;
579 						*vc->vc_uni_pagedir_loc = p;
580 						con_release_unimap(q);
581 						kfree(q);
582 						console_unlock();
583 						return err1;
584 					}
585 				}
586 			} else {
587 				/* Account for row of 64 empty entries */
588 				l += 64;
589 			}
590 		else
591 			/* Account for empty table */
592 			l += 32 * 64;
593 
594 		/*
595 		 * Finished copying font table, set vc_uni_pagedir to new table
596 		 */
597 		p = q;
598 	} else if (p == dflt) {
599 		dflt = NULL;
600 	}
601 
602 	/*
603 	 * Insert user specified unicode pairs into new table.
604 	 */
605 	while (ct--) {
606 		unsigned short unicode, fontpos;
607 		__get_user(unicode, &list->unicode);
608 		__get_user(fontpos, &list->fontpos);
609 		if ((err1 = con_insert_unipair(p, unicode,fontpos)) != 0)
610 			err = err1;
611 		list++;
612 	}
613 
614 	/*
615 	 * Merge with fontmaps of any other virtual consoles.
616 	 */
617 	if (con_unify_unimap(vc, p)) {
618 		console_unlock();
619 		return err;
620 	}
621 
622 	for (i = 0; i <= 3; i++)
623 		set_inverse_transl(vc, p, i); /* Update inverse translations */
624 	set_inverse_trans_unicode(vc, p);
625 
626 	console_unlock();
627 	return err;
628 }
629 
630 /**
631  *	con_set_default_unimap	-	set default unicode map
632  *	@vc: the console we are updating
633  *
634  *	Loads the unimap for the hardware font, as defined in uni_hash.tbl.
635  *	The representation used was the most compact I could come up
636  *	with.  This routine is executed at video setup, and when the
637  *	PIO_FONTRESET ioctl is called.
638  *
639  *	The caller must hold the console lock
640  */
641 int con_set_default_unimap(struct vc_data *vc)
642 {
643 	int i, j, err = 0, err1;
644 	u16 *q;
645 	struct uni_pagedir *p;
646 
647 	if (dflt) {
648 		p = *vc->vc_uni_pagedir_loc;
649 		if (p == dflt)
650 			return 0;
651 
652 		dflt->refcount++;
653 		*vc->vc_uni_pagedir_loc = dflt;
654 		if (p && !--p->refcount) {
655 			con_release_unimap(p);
656 			kfree(p);
657 		}
658 		return 0;
659 	}
660 
661 	/* The default font is always 256 characters */
662 
663 	err = con_do_clear_unimap(vc, NULL);
664 	if (err)
665 		return err;
666 
667 	p = *vc->vc_uni_pagedir_loc;
668 	q = dfont_unitable;
669 
670 	for (i = 0; i < 256; i++)
671 		for (j = dfont_unicount[i]; j; j--) {
672 			err1 = con_insert_unipair(p, *(q++), i);
673 			if (err1)
674 				err = err1;
675 		}
676 
677 	if (con_unify_unimap(vc, p)) {
678 		dflt = *vc->vc_uni_pagedir_loc;
679 		return err;
680 	}
681 
682 	for (i = 0; i <= 3; i++)
683 		set_inverse_transl(vc, p, i);	/* Update all inverse translations */
684 	set_inverse_trans_unicode(vc, p);
685 	dflt = p;
686 	return err;
687 }
688 EXPORT_SYMBOL(con_set_default_unimap);
689 
690 /**
691  *	con_copy_unimap		-	copy unimap between two vts
692  *	@dst_vc: target
693  *	@src_vt: source
694  *
695  *	The caller must hold the console lock when invoking this method
696  */
697 int con_copy_unimap(struct vc_data *dst_vc, struct vc_data *src_vc)
698 {
699 	struct uni_pagedir *q;
700 
701 	if (!*src_vc->vc_uni_pagedir_loc)
702 		return -EINVAL;
703 	if (*dst_vc->vc_uni_pagedir_loc == *src_vc->vc_uni_pagedir_loc)
704 		return 0;
705 	con_free_unimap(dst_vc);
706 	q = *src_vc->vc_uni_pagedir_loc;
707 	q->refcount++;
708 	*dst_vc->vc_uni_pagedir_loc = q;
709 	return 0;
710 }
711 EXPORT_SYMBOL(con_copy_unimap);
712 
713 /**
714  *	con_get_unimap		-	get the unicode map
715  *	@vc: the console to read from
716  *
717  *	Read the console unicode data for this console. Called from the ioctl
718  *	handlers.
719  */
720 int con_get_unimap(struct vc_data *vc, ushort ct, ushort __user *uct, struct unipair __user *list)
721 {
722 	int i, j, k, ect;
723 	u16 **p1, *p2;
724 	struct uni_pagedir *p;
725 
726 	console_lock();
727 
728 	ect = 0;
729 	if (*vc->vc_uni_pagedir_loc) {
730 		p = *vc->vc_uni_pagedir_loc;
731 		for (i = 0; i < 32; i++)
732 		if ((p1 = p->uni_pgdir[i]))
733 			for (j = 0; j < 32; j++)
734 			if ((p2 = *(p1++)))
735 				for (k = 0; k < 64; k++) {
736 					if (*p2 < MAX_GLYPH && ect++ < ct) {
737 						__put_user((u_short)((i<<11)+(j<<6)+k),
738 							   &list->unicode);
739 						__put_user((u_short) *p2,
740 							   &list->fontpos);
741 						list++;
742 					}
743 					p2++;
744 				}
745 	}
746 	__put_user(ect, uct);
747 	console_unlock();
748 	return ((ect <= ct) ? 0 : -ENOMEM);
749 }
750 
751 /*
752  * Always use USER_MAP. These functions are used by the keyboard,
753  * which shouldn't be affected by G0/G1 switching, etc.
754  * If the user map still contains default values, i.e. the
755  * direct-to-font mapping, then assume user is using Latin1.
756  *
757  * FIXME: at some point we need to decide if we want to lock the table
758  * update element itself via the keyboard_event_lock for consistency with the
759  * keyboard driver as well as the consoles
760  */
761 /* may be called during an interrupt */
762 u32 conv_8bit_to_uni(unsigned char c)
763 {
764 	unsigned short uni = translations[USER_MAP][c];
765 	return uni == (0xf000 | c) ? c : uni;
766 }
767 
768 int conv_uni_to_8bit(u32 uni)
769 {
770 	int c;
771 	for (c = 0; c < 0x100; c++)
772 		if (translations[USER_MAP][c] == uni ||
773 		   (translations[USER_MAP][c] == (c | 0xf000) && uni == c))
774 			return c;
775 	return -1;
776 }
777 
778 int
779 conv_uni_to_pc(struct vc_data *conp, long ucs)
780 {
781 	int h;
782 	u16 **p1, *p2;
783 	struct uni_pagedir *p;
784 
785 	/* Only 16-bit codes supported at this time */
786 	if (ucs > 0xffff)
787 		return -4;		/* Not found */
788 	else if (ucs < 0x20)
789 		return -1;		/* Not a printable character */
790 	else if (ucs == 0xfeff || (ucs >= 0x200b && ucs <= 0x200f))
791 		return -2;			/* Zero-width space */
792 	/*
793 	 * UNI_DIRECT_BASE indicates the start of the region in the User Zone
794 	 * which always has a 1:1 mapping to the currently loaded font.  The
795 	 * UNI_DIRECT_MASK indicates the bit span of the region.
796 	 */
797 	else if ((ucs & ~UNI_DIRECT_MASK) == UNI_DIRECT_BASE)
798 		return ucs & UNI_DIRECT_MASK;
799 
800 	if (!*conp->vc_uni_pagedir_loc)
801 		return -3;
802 
803 	p = *conp->vc_uni_pagedir_loc;
804 	if ((p1 = p->uni_pgdir[ucs >> 11]) &&
805 	    (p2 = p1[(ucs >> 6) & 0x1f]) &&
806 	    (h = p2[ucs & 0x3f]) < MAX_GLYPH)
807 		return h;
808 
809 	return -4;		/* not found */
810 }
811 
812 /*
813  * This is called at sys_setup time, after memory and the console are
814  * initialized.  It must be possible to call kmalloc(..., GFP_KERNEL)
815  * from this function, hence the call from sys_setup.
816  */
817 void __init
818 console_map_init(void)
819 {
820 	int i;
821 
822 	for (i = 0; i < MAX_NR_CONSOLES; i++)
823 		if (vc_cons_allocated(i) && !*vc_cons[i].d->vc_uni_pagedir_loc)
824 			con_set_default_unimap(vc_cons[i].d);
825 }
826 
827