4 * Mapping from internal code (such as Latin-1 or Unicode or IBM PC code)
9 * Support for multiple unimaps by Jakub Jelinek <jj@ultra.linux.cz>, July 1998
11 * Fix bug in inverse translation. Stanislav Voronyi <stas@cnti.uanet.kharkov.ua>, Dec 1998
14 #include <linux/module.h>
16 #include <linux/errno.h>
18 #include <linux/slab.h>
19 #include <linux/init.h>
20 #include <linux/tty.h>
21 #include <asm/uaccess.h>
22 #include <linux/consolemap.h>
23 #include <linux/vt_kern.h>
24 #include <linux/delay.h>
26 static unsigned short translations[][256] = {
27 /* 8-bit Latin-1 mapped to Unicode -- trivial mapping */
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
62 /* VT100 graphics mapped to Unicode */
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
97 /* IBM Codepage 437 mapped to Unicode */
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
132 /* User mapping -- default to codes for direct font mapping */
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
169 /* The standard kernel character-to-font mappings are not invertible
170 -- this is just a best effort. */
172 #define MAX_GLYPH 512 /* Max possible glyph value */
174 static int inv_translate[MAX_NR_CONSOLES];
178 unsigned long refcount;
180 unsigned char *inverse_translations[4];
181 u16 *inverse_trans_unicode;
185 static struct uni_pagedir *dflt;
187 static void set_inverse_transl(struct vc_data *conp, struct uni_pagedir *p, int i)
190 unsigned short *t = translations[i];
194 q = p->inverse_translations[i];
197 q = p->inverse_translations[i] = (unsigned char *)
198 kmalloc(MAX_GLYPH, GFP_KERNEL);
201 memset(q, 0, MAX_GLYPH);
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. */
212 static void set_inverse_trans_unicode(struct vc_data *conp,
213 struct uni_pagedir *p)
220 q = p->inverse_trans_unicode;
222 q = p->inverse_trans_unicode =
223 kmalloc(MAX_GLYPH * sizeof(u16), GFP_KERNEL);
227 memset(q, 0, MAX_GLYPH * sizeof(u16));
229 for (i = 0; i < 32; i++) {
230 p1 = p->uni_pgdir[i];
233 for (j = 0; j < 32; j++) {
237 for (k = 0; k < 64; k++) {
239 if (glyph >= 0 && glyph < MAX_GLYPH
241 q[glyph] = (i << 11) + (j << 6) + k;
247 unsigned short *set_translate(int m, struct vc_data *vc)
249 inv_translate[vc->vc_num] = m;
250 return translations[m];
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
258 * Still, it is now possible to a certain extent to cut and paste non-ASCII.
260 u16 inverse_translate(struct vc_data *conp, int glyph, int use_unicode)
262 struct uni_pagedir *p;
264 if (glyph < 0 || glyph >= MAX_GLYPH)
266 else if (!(p = (struct uni_pagedir *)*conp->vc_uni_pagedir_loc))
268 else if (use_unicode) {
269 if (!p->inverse_trans_unicode)
272 return p->inverse_trans_unicode[glyph];
274 m = inv_translate[conp->vc_num];
275 if (!p->inverse_translations[m])
278 return p->inverse_translations[m][glyph];
281 EXPORT_SYMBOL_GPL(inverse_translate);
283 static void update_user_maps(void)
286 struct uni_pagedir *p, *q = NULL;
288 for (i = 0; i < MAX_NR_CONSOLES; i++) {
289 if (!vc_cons_allocated(i))
291 p = (struct uni_pagedir *)*vc_cons[i].d->vc_uni_pagedir_loc;
293 set_inverse_transl(vc_cons[i].d, p, USER_MAP);
294 set_inverse_trans_unicode(vc_cons[i].d, p);
301 * Load customizable translation table
302 * arg points to a 256 byte translation table.
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.
308 int con_set_trans_old(unsigned char __user * arg)
311 unsigned short *p = translations[USER_MAP];
313 if (!access_ok(VERIFY_READ, arg, E_TABSZ))
316 for (i=0; i<E_TABSZ ; i++) {
318 __get_user(uc, arg+i);
319 p[i] = UNI_DIRECT_BASE | uc;
326 int con_get_trans_old(unsigned char __user * arg)
329 unsigned short *p = translations[USER_MAP];
331 if (!access_ok(VERIFY_WRITE, arg, E_TABSZ))
334 for (i=0; i<E_TABSZ ; i++)
336 ch = conv_uni_to_pc(vc_cons[fg_console].d, p[i]);
337 __put_user((ch & ~0xff) ? 0 : ch, arg+i);
342 int con_set_trans_new(ushort __user * arg)
345 unsigned short *p = translations[USER_MAP];
347 if (!access_ok(VERIFY_READ, arg, E_TABSZ*sizeof(unsigned short)))
350 for (i=0; i<E_TABSZ ; i++) {
352 __get_user(us, arg+i);
360 int con_get_trans_new(ushort __user * arg)
363 unsigned short *p = translations[USER_MAP];
365 if (!access_ok(VERIFY_WRITE, arg, E_TABSZ*sizeof(unsigned short)))
368 for (i=0; i<E_TABSZ ; i++)
369 __put_user(p[i], arg+i);
375 * Unicode -> current font conversion
377 * A font has at most 512 chars, usually 256.
378 * But one font position may represent several Unicode chars.
379 * A hashtable is somewhat of a pain to deal with, so use a
380 * "paged table" instead. Simulation has shown the memory cost of
381 * this 3-level paged table scheme to be comparable to a hash table.
384 extern u8 dfont_unicount[]; /* Defined in console_defmap.c */
385 extern u16 dfont_unitable[];
387 static void con_release_unimap(struct uni_pagedir *p)
392 if (p == dflt) dflt = NULL;
393 for (i = 0; i < 32; i++) {
394 if ((p1 = p->uni_pgdir[i]) != NULL) {
395 for (j = 0; j < 32; j++)
399 p->uni_pgdir[i] = NULL;
401 for (i = 0; i < 4; i++) {
402 kfree(p->inverse_translations[i]);
403 p->inverse_translations[i] = NULL;
405 if (p->inverse_trans_unicode) {
406 kfree(p->inverse_trans_unicode);
407 p->inverse_trans_unicode = NULL;
411 void con_free_unimap(struct vc_data *vc)
413 struct uni_pagedir *p;
415 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
418 *vc->vc_uni_pagedir_loc = 0;
421 con_release_unimap(p);
425 static int con_unify_unimap(struct vc_data *conp, struct uni_pagedir *p)
428 struct uni_pagedir *q;
430 for (i = 0; i < MAX_NR_CONSOLES; i++) {
431 if (!vc_cons_allocated(i))
433 q = (struct uni_pagedir *)*vc_cons[i].d->vc_uni_pagedir_loc;
434 if (!q || q == p || q->sum != p->sum)
436 for (j = 0; j < 32; j++) {
438 p1 = p->uni_pgdir[j]; q1 = q->uni_pgdir[j];
443 for (k = 0; k < 32; k++) {
444 if (!p1[k] && !q1[k])
446 if (!p1[k] || !q1[k])
448 if (memcmp(p1[k], q1[k], 64*sizeof(u16)))
456 *conp->vc_uni_pagedir_loc = (unsigned long)q;
457 con_release_unimap(p);
466 con_insert_unipair(struct uni_pagedir *p, u_short unicode, u_short fontpos)
471 if (!(p1 = p->uni_pgdir[n = unicode >> 11])) {
472 p1 = p->uni_pgdir[n] = kmalloc(32*sizeof(u16 *), GFP_KERNEL);
473 if (!p1) return -ENOMEM;
474 for (i = 0; i < 32; i++)
478 if (!(p2 = p1[n = (unicode >> 6) & 0x1f])) {
479 p2 = p1[n] = kmalloc(64*sizeof(u16), GFP_KERNEL);
480 if (!p2) return -ENOMEM;
482 /* WORKAROUND: This delay time prevent NULL point error. */
485 memset(p2, 0xff, 64*sizeof(u16)); /* No glyphs for the characters (yet) */
488 p2[unicode & 0x3f] = fontpos;
490 p->sum += (fontpos << 20) + unicode;
495 /* ui is a leftover from using a hashtable, but might be used again */
496 int con_clear_unimap(struct vc_data *vc, struct unimapinit *ui)
498 struct uni_pagedir *p, *q;
500 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
501 if (p && p->readonly) return -EIO;
502 if (!p || --p->refcount) {
503 q = kzalloc(sizeof(*p), GFP_KERNEL);
505 if (p) p->refcount++;
509 *vc->vc_uni_pagedir_loc = (unsigned long)q;
511 if (p == dflt) dflt = NULL;
514 con_release_unimap(p);
519 int con_set_unimap(struct vc_data *vc, ushort ct, struct unipair __user *list)
521 int err = 0, err1, i;
522 struct uni_pagedir *p, *q;
524 /* Save original vc_unipagdir_loc in case we allocate a new one */
525 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
526 if (p->readonly) return -EIO;
530 if (p->refcount > 1) {
534 err1 = con_clear_unimap(vc, NULL);
535 if (err1) return err1;
538 * Since refcount was > 1, con_clear_unimap() allocated a
539 * a new uni_pagedir for this vc. Re: p != q
541 q = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
544 * uni_pgdir is a 32*32*64 table with rows allocated
545 * when its first entry is added. The unicode value must
546 * still be incremented for empty rows. We are copying
547 * entries from "p" (old) to "q" (new).
549 l = 0; /* unicode value */
550 for (i = 0; i < 32; i++)
551 if ((p1 = p->uni_pgdir[i]))
552 for (j = 0; j < 32; j++)
554 for (k = 0; k < 64; k++, l++)
555 if (p2[k] != 0xffff) {
557 * Found one, copy entry for unicode
558 * l with fontpos value p2[k].
560 err1 = con_insert_unipair(q, l, p2[k]);
563 *vc->vc_uni_pagedir_loc = (unsigned long)p;
564 con_release_unimap(q);
570 /* Account for row of 64 empty entries */
574 /* Account for empty table */
578 * Finished copying font table, set vc_uni_pagedir to new table
581 } else if (p == dflt) {
586 * Insert user specified unicode pairs into new table.
589 unsigned short unicode, fontpos;
590 __get_user(unicode, &list->unicode);
591 __get_user(fontpos, &list->fontpos);
592 if ((err1 = con_insert_unipair(p, unicode,fontpos)) != 0)
598 * Merge with fontmaps of any other virtual consoles.
600 if (con_unify_unimap(vc, p))
603 for (i = 0; i <= 3; i++)
604 set_inverse_transl(vc, p, i); /* Update inverse translations */
605 set_inverse_trans_unicode(vc, p);
610 /* Loads the unimap for the hardware font, as defined in uni_hash.tbl.
611 The representation used was the most compact I could come up
612 with. This routine is executed at sys_setup time, and when the
613 PIO_FONTRESET ioctl is called. */
615 int con_set_default_unimap(struct vc_data *vc)
617 int i, j, err = 0, err1;
619 struct uni_pagedir *p;
622 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
626 *vc->vc_uni_pagedir_loc = (unsigned long)dflt;
627 if (p && --p->refcount) {
628 con_release_unimap(p);
634 /* The default font is always 256 characters */
636 err = con_clear_unimap(vc, NULL);
639 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
642 for (i = 0; i < 256; i++)
643 for (j = dfont_unicount[i]; j; j--) {
644 err1 = con_insert_unipair(p, *(q++), i);
649 if (con_unify_unimap(vc, p)) {
650 dflt = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
654 for (i = 0; i <= 3; i++)
655 set_inverse_transl(vc, p, i); /* Update all inverse translations */
656 set_inverse_trans_unicode(vc, p);
660 EXPORT_SYMBOL(con_set_default_unimap);
662 int con_copy_unimap(struct vc_data *dst_vc, struct vc_data *src_vc)
664 struct uni_pagedir *q;
666 if (!*src_vc->vc_uni_pagedir_loc)
668 if (*dst_vc->vc_uni_pagedir_loc == *src_vc->vc_uni_pagedir_loc)
670 con_free_unimap(dst_vc);
671 q = (struct uni_pagedir *)*src_vc->vc_uni_pagedir_loc;
673 *dst_vc->vc_uni_pagedir_loc = (long)q;
677 int con_get_unimap(struct vc_data *vc, ushort ct, ushort __user *uct, struct unipair __user *list)
681 struct uni_pagedir *p;
684 if (*vc->vc_uni_pagedir_loc) {
685 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
686 for (i = 0; i < 32; i++)
687 if ((p1 = p->uni_pgdir[i]))
688 for (j = 0; j < 32; j++)
690 for (k = 0; k < 64; k++) {
691 if (*p2 < MAX_GLYPH && ect++ < ct) {
692 __put_user((u_short)((i<<11)+(j<<6)+k),
694 __put_user((u_short) *p2,
701 __put_user(ect, uct);
702 return ((ect <= ct) ? 0 : -ENOMEM);
705 void con_protect_unimap(struct vc_data *vc, int rdonly)
707 struct uni_pagedir *p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
710 p->readonly = rdonly;
714 * Always use USER_MAP. These functions are used by the keyboard,
715 * which shouldn't be affected by G0/G1 switching, etc.
716 * If the user map still contains default values, i.e. the
717 * direct-to-font mapping, then assume user is using Latin1.
719 /* may be called during an interrupt */
720 u32 conv_8bit_to_uni(unsigned char c)
722 unsigned short uni = translations[USER_MAP][c];
723 return uni == (0xf000 | c) ? c : uni;
726 int conv_uni_to_8bit(u32 uni)
729 for (c = 0; c < 0x100; c++)
730 if (translations[USER_MAP][c] == uni ||
731 (translations[USER_MAP][c] == (c | 0xf000) && uni == c))
737 conv_uni_to_pc(struct vc_data *conp, long ucs)
741 struct uni_pagedir *p;
743 /* Only 16-bit codes supported at this time */
745 return -4; /* Not found */
747 return -1; /* Not a printable character */
748 else if (ucs == 0xfeff || (ucs >= 0x200b && ucs <= 0x200f))
749 return -2; /* Zero-width space */
751 * UNI_DIRECT_BASE indicates the start of the region in the User Zone
752 * which always has a 1:1 mapping to the currently loaded font. The
753 * UNI_DIRECT_MASK indicates the bit span of the region.
755 else if ((ucs & ~UNI_DIRECT_MASK) == UNI_DIRECT_BASE)
756 return ucs & UNI_DIRECT_MASK;
758 if (!*conp->vc_uni_pagedir_loc)
761 p = (struct uni_pagedir *)*conp->vc_uni_pagedir_loc;
762 if ((p1 = p->uni_pgdir[ucs >> 11]) &&
763 (p2 = p1[(ucs >> 6) & 0x1f]) &&
764 (h = p2[ucs & 0x3f]) < MAX_GLYPH)
767 return -4; /* not found */
771 * This is called at sys_setup time, after memory and the console are
772 * initialized. It must be possible to call kmalloc(..., GFP_KERNEL)
773 * from this function, hence the call from sys_setup.
776 console_map_init(void)
780 for (i = 0; i < MAX_NR_CONSOLES; i++)
781 if (vc_cons_allocated(i) && !*vc_cons[i].d->vc_uni_pagedir_loc)
782 con_set_default_unimap(vc_cons[i].d);
785 EXPORT_SYMBOL(con_copy_unimap);