Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
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
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];
181 u16 *inverse_trans_unicode;
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
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
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
257 * was active.
258 * Still, it is now possible to a certain extent to cut and paste non-ASCII.
259 */
260u16 inverse_translate(struct vc_data *conp, int glyph, int use_unicode)
261{
262 struct uni_pagedir *p;
263 int m;
264 if (glyph < 0 || glyph >= MAX_GLYPH)
265 return 0;
266 else if (!(p = (struct uni_pagedir *)*conp->vc_uni_pagedir_loc))
267 return glyph;
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 }
280}
281EXPORT_SYMBOL_GPL(inverse_translate);
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);
294 set_inverse_trans_unicode(vc_cons[i].d, p);
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
316 console_lock();
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();
324 console_unlock();
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
336 console_lock();
337 for (i=0; i<E_TABSZ ; i++)
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();
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
354 console_lock();
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();
362 console_unlock();
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
374 console_lock();
375 for (i=0; i<E_TABSZ ; i++)
376 __put_user(p[i], arg+i);
377 console_unlock();
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++)
404 kfree(p1[j]);
405 kfree(p1);
406 }
407 p->uni_pgdir[i] = NULL;
408 }
409 for (i = 0; i < 4; i++) {
410 kfree(p->inverse_translations[i]);
411 p->inverse_translations[i] = NULL;
412 }
413 kfree(p->inverse_trans_unicode);
414 p->inverse_trans_unicode = NULL;
415}
416
417/* Caller must hold the console lock */
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
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)
501{
502 struct uni_pagedir *p, *q;
503
504 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
505 if (p && p->readonly)
506 return -EIO;
507
508 if (!p || --p->refcount) {
509 q = kzalloc(sizeof(*p), GFP_KERNEL);
510 if (!q) {
511 if (p)
512 p->refcount++;
513 return -ENOMEM;
514 }
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
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
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
540 console_lock();
541
542 /* Save original vc_unipagdir_loc in case we allocate a new one */
543 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
544 if (p->readonly) {
545 console_unlock();
546 return -EIO;
547 }
548
549 if (!ct) {
550 console_unlock();
551 return 0;
552 }
553
554 if (p->refcount > 1) {
555 int j, k;
556 u16 **p1, *p2, l;
557
558 err1 = con_do_clear_unimap(vc, NULL);
559 if (err1) {
560 console_unlock();
561 return err1;
562 }
563
564 /*
565 * Since refcount was > 1, con_clear_unimap() allocated a
566 * a new uni_pagedir for this vc. Re: p != q
567 */
568 q = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
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++)
578 if ((p1 = p->uni_pgdir[i]))
579 for (j = 0; j < 32; j++)
580 if ((p2 = p1[j])) {
581 for (k = 0; k < 64; k++, l++)
582 if (p2[k] != 0xffff) {
583 /*
584 * Found one, copy entry for unicode
585 * l with fontpos value p2[k].
586 */
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);
593 console_unlock();
594 return err1;
595 }
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) {
610 dflt = NULL;
611 }
612
613 /*
614 * Insert user specified unicode pairs into new table.
615 */
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;
622 list++;
623 }
624
625 /*
626 * Merge with fontmaps of any other virtual consoles.
627 */
628 if (con_unify_unimap(vc, p)) {
629 console_unlock();
630 return err;
631 }
632
633 for (i = 0; i <= 3; i++)
634 set_inverse_transl(vc, p, i); /* Update inverse translations */
635 set_inverse_trans_unicode(vc, p);
636
637 console_unlock();
638 return err;
639}
640
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 */
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;
662
663 dflt->refcount++;
664 *vc->vc_uni_pagedir_loc = (unsigned long)dflt;
665 if (p && !--p->refcount) {
666 con_release_unimap(p);
667 kfree(p);
668 }
669 return 0;
670 }
671
672 /* The default font is always 256 characters */
673
674 err = con_do_clear_unimap(vc, NULL);
675 if (err)
676 return err;
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 */
695 set_inverse_trans_unicode(vc, p);
696 dflt = p;
697 return err;
698}
699EXPORT_SYMBOL(con_set_default_unimap);
700
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 */
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}
722EXPORT_SYMBOL(con_copy_unimap);
723
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 */
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
737 console_lock();
738
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);
758 console_unlock();
759 return ((ect <= ct) ? 0 : -ENOMEM);
760}
761
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.
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
771 */
772/* may be called during an interrupt */
773u32 conv_8bit_to_uni(unsigned char c)
774{
775 unsigned short uni = translations[USER_MAP][c];
776 return uni == (0xf000 | c) ? c : uni;
777}
778
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
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)
798 return -4; /* Not found */
799 else if (ucs < 0x20)
800 return -1; /* Not a printable character */
801 else if (ucs == 0xfeff || (ucs >= 0x200b && ucs <= 0x200f))
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