Merge tag 'v3.8-rc3' into v4l_for_linus
[profile/ivi/kernel-adaptation-intel-automotive.git] / drivers / tty / vt / consolemap.c
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         int             readonly;
183 };
184
185 static struct uni_pagedir *dflt;
186
187 static 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
212 static 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
247 unsigned 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  */
260 u16 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 }
281 EXPORT_SYMBOL_GPL(inverse_translate);
282
283 static 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  */
308 int 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
328 int 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
346 int 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
366 int 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
392 extern u8 dfont_unicount[];     /* Defined in console_defmap.c */
393 extern u16 dfont_unitable[];
394
395 static 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 */
418 void 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   
432 static 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
472 static int
473 con_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 */
500 static 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
526 int 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         
535 int 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  */
652 int 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 }
699 EXPORT_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  */
708 int 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 }
722 EXPORT_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  */
731 int 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 */
773 u32 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
779 int 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
789 int
790 conv_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  */
828 void __init 
829 console_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