[PATCH] SBC8360: module_param() permission fixes
[linux-2.6] / drivers / char / 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/consolemap.h>
23 #include <linux/vt_kern.h>
24
25 static unsigned short translations[][256] = {
26   /* 8-bit Latin-1 mapped to Unicode -- trivial mapping */
27   {
28     0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
29     0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f,
30     0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
31     0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f,
32     0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
33     0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
34     0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
35     0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
36     0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
37     0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
38     0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
39     0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
40     0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
41     0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
42     0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
43     0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f,
44     0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
45     0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
46     0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
47     0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
48     0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7,
49     0x00a8, 0x00a9, 0x00aa, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
50     0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7,
51     0x00b8, 0x00b9, 0x00ba, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00bf,
52     0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7,
53     0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf,
54     0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
55     0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
56     0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7,
57     0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
58     0x00f0, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7,
59     0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x00ff
60   }, 
61   /* VT100 graphics mapped to Unicode */
62   {
63     0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
64     0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f,
65     0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
66     0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f,
67     0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
68     0x0028, 0x0029, 0x002a, 0x2192, 0x2190, 0x2191, 0x2193, 0x002f,
69     0x2588, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
70     0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
71     0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
72     0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
73     0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
74     0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x00a0,
75     0x25c6, 0x2592, 0x2409, 0x240c, 0x240d, 0x240a, 0x00b0, 0x00b1,
76     0x2591, 0x240b, 0x2518, 0x2510, 0x250c, 0x2514, 0x253c, 0x23ba,
77     0x23bb, 0x2500, 0x23bc, 0x23bd, 0x251c, 0x2524, 0x2534, 0x252c,
78     0x2502, 0x2264, 0x2265, 0x03c0, 0x2260, 0x00a3, 0x00b7, 0x007f,
79     0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
80     0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
81     0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
82     0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
83     0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7,
84     0x00a8, 0x00a9, 0x00aa, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
85     0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7,
86     0x00b8, 0x00b9, 0x00ba, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00bf,
87     0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7,
88     0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf,
89     0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
90     0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
91     0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7,
92     0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
93     0x00f0, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7,
94     0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x00ff
95   },
96   /* IBM Codepage 437 mapped to Unicode */
97   {
98     0x0000, 0x263a, 0x263b, 0x2665, 0x2666, 0x2663, 0x2660, 0x2022, 
99     0x25d8, 0x25cb, 0x25d9, 0x2642, 0x2640, 0x266a, 0x266b, 0x263c,
100     0x25b6, 0x25c0, 0x2195, 0x203c, 0x00b6, 0x00a7, 0x25ac, 0x21a8,
101     0x2191, 0x2193, 0x2192, 0x2190, 0x221f, 0x2194, 0x25b2, 0x25bc,
102     0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
103     0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
104     0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
105     0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
106     0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
107     0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
108     0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
109     0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
110     0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
111     0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
112     0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
113     0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x2302,
114     0x00c7, 0x00fc, 0x00e9, 0x00e2, 0x00e4, 0x00e0, 0x00e5, 0x00e7,
115     0x00ea, 0x00eb, 0x00e8, 0x00ef, 0x00ee, 0x00ec, 0x00c4, 0x00c5,
116     0x00c9, 0x00e6, 0x00c6, 0x00f4, 0x00f6, 0x00f2, 0x00fb, 0x00f9,
117     0x00ff, 0x00d6, 0x00dc, 0x00a2, 0x00a3, 0x00a5, 0x20a7, 0x0192,
118     0x00e1, 0x00ed, 0x00f3, 0x00fa, 0x00f1, 0x00d1, 0x00aa, 0x00ba,
119     0x00bf, 0x2310, 0x00ac, 0x00bd, 0x00bc, 0x00a1, 0x00ab, 0x00bb,
120     0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
121     0x2555, 0x2563, 0x2551, 0x2557, 0x255d, 0x255c, 0x255b, 0x2510,
122     0x2514, 0x2534, 0x252c, 0x251c, 0x2500, 0x253c, 0x255e, 0x255f,
123     0x255a, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256c, 0x2567,
124     0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256b,
125     0x256a, 0x2518, 0x250c, 0x2588, 0x2584, 0x258c, 0x2590, 0x2580,
126     0x03b1, 0x00df, 0x0393, 0x03c0, 0x03a3, 0x03c3, 0x00b5, 0x03c4,
127     0x03a6, 0x0398, 0x03a9, 0x03b4, 0x221e, 0x03c6, 0x03b5, 0x2229,
128     0x2261, 0x00b1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00f7, 0x2248,
129     0x00b0, 0x2219, 0x00b7, 0x221a, 0x207f, 0x00b2, 0x25a0, 0x00a0
130   }, 
131   /* User mapping -- default to codes for direct font mapping */
132   {
133     0xf000, 0xf001, 0xf002, 0xf003, 0xf004, 0xf005, 0xf006, 0xf007,
134     0xf008, 0xf009, 0xf00a, 0xf00b, 0xf00c, 0xf00d, 0xf00e, 0xf00f,
135     0xf010, 0xf011, 0xf012, 0xf013, 0xf014, 0xf015, 0xf016, 0xf017,
136     0xf018, 0xf019, 0xf01a, 0xf01b, 0xf01c, 0xf01d, 0xf01e, 0xf01f,
137     0xf020, 0xf021, 0xf022, 0xf023, 0xf024, 0xf025, 0xf026, 0xf027,
138     0xf028, 0xf029, 0xf02a, 0xf02b, 0xf02c, 0xf02d, 0xf02e, 0xf02f,
139     0xf030, 0xf031, 0xf032, 0xf033, 0xf034, 0xf035, 0xf036, 0xf037,
140     0xf038, 0xf039, 0xf03a, 0xf03b, 0xf03c, 0xf03d, 0xf03e, 0xf03f,
141     0xf040, 0xf041, 0xf042, 0xf043, 0xf044, 0xf045, 0xf046, 0xf047,
142     0xf048, 0xf049, 0xf04a, 0xf04b, 0xf04c, 0xf04d, 0xf04e, 0xf04f,
143     0xf050, 0xf051, 0xf052, 0xf053, 0xf054, 0xf055, 0xf056, 0xf057,
144     0xf058, 0xf059, 0xf05a, 0xf05b, 0xf05c, 0xf05d, 0xf05e, 0xf05f,
145     0xf060, 0xf061, 0xf062, 0xf063, 0xf064, 0xf065, 0xf066, 0xf067,
146     0xf068, 0xf069, 0xf06a, 0xf06b, 0xf06c, 0xf06d, 0xf06e, 0xf06f,
147     0xf070, 0xf071, 0xf072, 0xf073, 0xf074, 0xf075, 0xf076, 0xf077,
148     0xf078, 0xf079, 0xf07a, 0xf07b, 0xf07c, 0xf07d, 0xf07e, 0xf07f,
149     0xf080, 0xf081, 0xf082, 0xf083, 0xf084, 0xf085, 0xf086, 0xf087,
150     0xf088, 0xf089, 0xf08a, 0xf08b, 0xf08c, 0xf08d, 0xf08e, 0xf08f,
151     0xf090, 0xf091, 0xf092, 0xf093, 0xf094, 0xf095, 0xf096, 0xf097,
152     0xf098, 0xf099, 0xf09a, 0xf09b, 0xf09c, 0xf09d, 0xf09e, 0xf09f,
153     0xf0a0, 0xf0a1, 0xf0a2, 0xf0a3, 0xf0a4, 0xf0a5, 0xf0a6, 0xf0a7,
154     0xf0a8, 0xf0a9, 0xf0aa, 0xf0ab, 0xf0ac, 0xf0ad, 0xf0ae, 0xf0af,
155     0xf0b0, 0xf0b1, 0xf0b2, 0xf0b3, 0xf0b4, 0xf0b5, 0xf0b6, 0xf0b7,
156     0xf0b8, 0xf0b9, 0xf0ba, 0xf0bb, 0xf0bc, 0xf0bd, 0xf0be, 0xf0bf,
157     0xf0c0, 0xf0c1, 0xf0c2, 0xf0c3, 0xf0c4, 0xf0c5, 0xf0c6, 0xf0c7,
158     0xf0c8, 0xf0c9, 0xf0ca, 0xf0cb, 0xf0cc, 0xf0cd, 0xf0ce, 0xf0cf,
159     0xf0d0, 0xf0d1, 0xf0d2, 0xf0d3, 0xf0d4, 0xf0d5, 0xf0d6, 0xf0d7,
160     0xf0d8, 0xf0d9, 0xf0da, 0xf0db, 0xf0dc, 0xf0dd, 0xf0de, 0xf0df,
161     0xf0e0, 0xf0e1, 0xf0e2, 0xf0e3, 0xf0e4, 0xf0e5, 0xf0e6, 0xf0e7,
162     0xf0e8, 0xf0e9, 0xf0ea, 0xf0eb, 0xf0ec, 0xf0ed, 0xf0ee, 0xf0ef,
163     0xf0f0, 0xf0f1, 0xf0f2, 0xf0f3, 0xf0f4, 0xf0f5, 0xf0f6, 0xf0f7,
164     0xf0f8, 0xf0f9, 0xf0fa, 0xf0fb, 0xf0fc, 0xf0fd, 0xf0fe, 0xf0ff
165   }
166 };
167
168 /* The standard kernel character-to-font mappings are not invertible
169    -- this is just a best effort. */
170
171 #define MAX_GLYPH 512           /* Max possible glyph value */
172
173 static int inv_translate[MAX_NR_CONSOLES];
174
175 struct uni_pagedir {
176         u16             **uni_pgdir[32];
177         unsigned long   refcount;
178         unsigned long   sum;
179         unsigned char   *inverse_translations[4];
180         int             readonly;
181 };
182
183 static struct uni_pagedir *dflt;
184
185 static void set_inverse_transl(struct vc_data *conp, struct uni_pagedir *p, int i)
186 {
187         int j, glyph;
188         unsigned short *t = translations[i];
189         unsigned char *q;
190         
191         if (!p) return;
192         q = p->inverse_translations[i];
193
194         if (!q) {
195                 q = p->inverse_translations[i] = (unsigned char *) 
196                         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 unsigned short *set_translate(int m, struct vc_data *vc)
211 {
212         inv_translate[vc->vc_num] = m;
213         return translations[m];
214 }
215
216 /*
217  * Inverse translation is impossible for several reasons:
218  * 1. The font<->character maps are not 1-1.
219  * 2. The text may have been written while a different translation map
220  *    was active, or using Unicode.
221  * Still, it is now possible to a certain extent to cut and paste non-ASCII.
222  */
223 unsigned char inverse_translate(struct vc_data *conp, int glyph)
224 {
225         struct uni_pagedir *p;
226         if (glyph < 0 || glyph >= MAX_GLYPH)
227                 return 0;
228         else if (!(p = (struct uni_pagedir *)*conp->vc_uni_pagedir_loc) ||
229                  !p->inverse_translations[inv_translate[conp->vc_num]])
230                 return glyph;
231         else
232                 return p->inverse_translations[inv_translate[conp->vc_num]][glyph];
233 }
234
235 static void update_user_maps(void)
236 {
237         int i;
238         struct uni_pagedir *p, *q = NULL;
239         
240         for (i = 0; i < MAX_NR_CONSOLES; i++) {
241                 if (!vc_cons_allocated(i))
242                         continue;
243                 p = (struct uni_pagedir *)*vc_cons[i].d->vc_uni_pagedir_loc;
244                 if (p && p != q) {
245                         set_inverse_transl(vc_cons[i].d, p, USER_MAP);
246                         q = p;
247                 }
248         }
249 }
250
251 /*
252  * Load customizable translation table
253  * arg points to a 256 byte translation table.
254  *
255  * The "old" variants are for translation directly to font (using the
256  * 0xf000-0xf0ff "transparent" Unicodes) whereas the "new" variants set
257  * Unicodes explicitly.
258  */
259 int con_set_trans_old(unsigned char __user * arg)
260 {
261         int i;
262         unsigned short *p = translations[USER_MAP];
263
264         if (!access_ok(VERIFY_READ, arg, E_TABSZ))
265                 return -EFAULT;
266
267         for (i=0; i<E_TABSZ ; i++) {
268                 unsigned char uc;
269                 __get_user(uc, arg+i);
270                 p[i] = UNI_DIRECT_BASE | uc;
271         }
272
273         update_user_maps();
274         return 0;
275 }
276
277 int con_get_trans_old(unsigned char __user * arg)
278 {
279         int i, ch;
280         unsigned short *p = translations[USER_MAP];
281
282         if (!access_ok(VERIFY_WRITE, arg, E_TABSZ))
283                 return -EFAULT;
284
285         for (i=0; i<E_TABSZ ; i++)
286           {
287             ch = conv_uni_to_pc(vc_cons[fg_console].d, p[i]);
288             __put_user((ch & ~0xff) ? 0 : ch, arg+i);
289           }
290         return 0;
291 }
292
293 int con_set_trans_new(ushort __user * arg)
294 {
295         int i;
296         unsigned short *p = translations[USER_MAP];
297
298         if (!access_ok(VERIFY_READ, arg, E_TABSZ*sizeof(unsigned short)))
299                 return -EFAULT;
300
301         for (i=0; i<E_TABSZ ; i++) {
302                 unsigned short us;
303                 __get_user(us, arg+i);
304                 p[i] = us;
305         }
306
307         update_user_maps();
308         return 0;
309 }
310
311 int con_get_trans_new(ushort __user * arg)
312 {
313         int i;
314         unsigned short *p = translations[USER_MAP];
315
316         if (!access_ok(VERIFY_WRITE, arg, E_TABSZ*sizeof(unsigned short)))
317                 return -EFAULT;
318
319         for (i=0; i<E_TABSZ ; i++)
320           __put_user(p[i], arg+i);
321         
322         return 0;
323 }
324
325 /*
326  * Unicode -> current font conversion 
327  *
328  * A font has at most 512 chars, usually 256.
329  * But one font position may represent several Unicode chars.
330  * A hashtable is somewhat of a pain to deal with, so use a
331  * "paged table" instead.  Simulation has shown the memory cost of
332  * this 3-level paged table scheme to be comparable to a hash table.
333  */
334
335 extern u8 dfont_unicount[];     /* Defined in console_defmap.c */
336 extern u16 dfont_unitable[];
337
338 static void con_release_unimap(struct uni_pagedir *p)
339 {
340         u16 **p1;
341         int i, j;
342
343         if (p == dflt) dflt = NULL;  
344         for (i = 0; i < 32; i++) {
345                 if ((p1 = p->uni_pgdir[i]) != NULL) {
346                         for (j = 0; j < 32; j++)
347                                 kfree(p1[j]);
348                         kfree(p1);
349                 }
350                 p->uni_pgdir[i] = NULL;
351         }
352         for (i = 0; i < 4; i++) {
353                 kfree(p->inverse_translations[i]);
354                 p->inverse_translations[i] = NULL;
355         }
356 }
357
358 void con_free_unimap(struct vc_data *vc)
359 {
360         struct uni_pagedir *p;
361
362         p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
363         if (!p)
364                 return;
365         *vc->vc_uni_pagedir_loc = 0;
366         if (--p->refcount)
367                 return;
368         con_release_unimap(p);
369         kfree(p);
370 }
371   
372 static int con_unify_unimap(struct vc_data *conp, struct uni_pagedir *p)
373 {
374         int i, j, k;
375         struct uni_pagedir *q;
376         
377         for (i = 0; i < MAX_NR_CONSOLES; i++) {
378                 if (!vc_cons_allocated(i))
379                         continue;
380                 q = (struct uni_pagedir *)*vc_cons[i].d->vc_uni_pagedir_loc;
381                 if (!q || q == p || q->sum != p->sum)
382                         continue;
383                 for (j = 0; j < 32; j++) {
384                         u16 **p1, **q1;
385                         p1 = p->uni_pgdir[j]; q1 = q->uni_pgdir[j];
386                         if (!p1 && !q1)
387                                 continue;
388                         if (!p1 || !q1)
389                                 break;
390                         for (k = 0; k < 32; k++) {
391                                 if (!p1[k] && !q1[k])
392                                         continue;
393                                 if (!p1[k] || !q1[k])
394                                         break;
395                                 if (memcmp(p1[k], q1[k], 64*sizeof(u16)))
396                                         break;
397                         }
398                         if (k < 32)
399                                 break;
400                 }
401                 if (j == 32) {
402                         q->refcount++;
403                         *conp->vc_uni_pagedir_loc = (unsigned long)q;
404                         con_release_unimap(p);
405                         kfree(p);
406                         return 1;
407                 }
408         }
409         return 0;
410 }
411
412 static int
413 con_insert_unipair(struct uni_pagedir *p, u_short unicode, u_short fontpos)
414 {
415         int i, n;
416         u16 **p1, *p2;
417
418         if (!(p1 = p->uni_pgdir[n = unicode >> 11])) {
419                 p1 = p->uni_pgdir[n] = kmalloc(32*sizeof(u16 *), GFP_KERNEL);
420                 if (!p1) return -ENOMEM;
421                 for (i = 0; i < 32; i++)
422                         p1[i] = NULL;
423         }
424
425         if (!(p2 = p1[n = (unicode >> 6) & 0x1f])) {
426                 p2 = p1[n] = kmalloc(64*sizeof(u16), GFP_KERNEL);
427                 if (!p2) return -ENOMEM;
428                 memset(p2, 0xff, 64*sizeof(u16)); /* No glyphs for the characters (yet) */
429         }
430
431         p2[unicode & 0x3f] = fontpos;
432         
433         p->sum += (fontpos << 20) + unicode;
434
435         return 0;
436 }
437
438 /* ui is a leftover from using a hashtable, but might be used again */
439 int con_clear_unimap(struct vc_data *vc, struct unimapinit *ui)
440 {
441         struct uni_pagedir *p, *q;
442   
443         p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
444         if (p && p->readonly) return -EIO;
445         if (!p || --p->refcount) {
446                 q = (struct uni_pagedir *)kmalloc(sizeof(*p), GFP_KERNEL);
447                 if (!q) {
448                         if (p) p->refcount++;
449                         return -ENOMEM;
450                 }
451                 memset(q, 0, sizeof(*q));
452                 q->refcount=1;
453                 *vc->vc_uni_pagedir_loc = (unsigned long)q;
454         } else {
455                 if (p == dflt) dflt = NULL;
456                 p->refcount++;
457                 p->sum = 0;
458                 con_release_unimap(p);
459         }
460         return 0;
461 }
462
463 int con_set_unimap(struct vc_data *vc, ushort ct, struct unipair __user *list)
464 {
465         int err = 0, err1, i;
466         struct uni_pagedir *p, *q;
467
468         p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
469         if (p->readonly) return -EIO;
470         
471         if (!ct) return 0;
472         
473         if (p->refcount > 1) {
474                 int j, k;
475                 u16 **p1, *p2, l;
476                 
477                 err1 = con_clear_unimap(vc, NULL);
478                 if (err1) return err1;
479                 
480                 q = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
481                 for (i = 0, l = 0; i < 32; i++)
482                 if ((p1 = p->uni_pgdir[i]))
483                         for (j = 0; j < 32; j++)
484                         if ((p2 = p1[j]))
485                                 for (k = 0; k < 64; k++, l++)
486                                 if (p2[k] != 0xffff) {
487                                         err1 = con_insert_unipair(q, l, p2[k]);
488                                         if (err1) {
489                                                 p->refcount++;
490                                                 *vc->vc_uni_pagedir_loc = (unsigned long)p;
491                                                 con_release_unimap(q);
492                                                 kfree(q);
493                                                 return err1; 
494                                         }
495                                 }
496                 p = q;
497         } else if (p == dflt)
498                 dflt = NULL;
499         
500         while (ct--) {
501                 unsigned short unicode, fontpos;
502                 __get_user(unicode, &list->unicode);
503                 __get_user(fontpos, &list->fontpos);
504                 if ((err1 = con_insert_unipair(p, unicode,fontpos)) != 0)
505                         err = err1;
506                         list++;
507         }
508         
509         if (con_unify_unimap(vc, p))
510                 return err;
511
512         for (i = 0; i <= 3; i++)
513                 set_inverse_transl(vc, p, i); /* Update all inverse translations */
514   
515         return err;
516 }
517
518 /* Loads the unimap for the hardware font, as defined in uni_hash.tbl.
519    The representation used was the most compact I could come up
520    with.  This routine is executed at sys_setup time, and when the
521    PIO_FONTRESET ioctl is called. */
522
523 int con_set_default_unimap(struct vc_data *vc)
524 {
525         int i, j, err = 0, err1;
526         u16 *q;
527         struct uni_pagedir *p;
528
529         if (dflt) {
530                 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
531                 if (p == dflt)
532                         return 0;
533                 dflt->refcount++;
534                 *vc->vc_uni_pagedir_loc = (unsigned long)dflt;
535                 if (p && --p->refcount) {
536                         con_release_unimap(p);
537                         kfree(p);
538                 }
539                 return 0;
540         }
541         
542         /* The default font is always 256 characters */
543
544         err = con_clear_unimap(vc, NULL);
545         if (err) return err;
546     
547         p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
548         q = dfont_unitable;
549         
550         for (i = 0; i < 256; i++)
551                 for (j = dfont_unicount[i]; j; j--) {
552                         err1 = con_insert_unipair(p, *(q++), i);
553                         if (err1)
554                                 err = err1;
555                 }
556                         
557         if (con_unify_unimap(vc, p)) {
558                 dflt = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
559                 return err;
560         }
561
562         for (i = 0; i <= 3; i++)
563                 set_inverse_transl(vc, p, i);   /* Update all inverse translations */
564         dflt = p;
565         return err;
566 }
567 EXPORT_SYMBOL(con_set_default_unimap);
568
569 int con_copy_unimap(struct vc_data *dst_vc, struct vc_data *src_vc)
570 {
571         struct uni_pagedir *q;
572
573         if (!*src_vc->vc_uni_pagedir_loc)
574                 return -EINVAL;
575         if (*dst_vc->vc_uni_pagedir_loc == *src_vc->vc_uni_pagedir_loc)
576                 return 0;
577         con_free_unimap(dst_vc);
578         q = (struct uni_pagedir *)*src_vc->vc_uni_pagedir_loc;
579         q->refcount++;
580         *dst_vc->vc_uni_pagedir_loc = (long)q;
581         return 0;
582 }
583
584 int con_get_unimap(struct vc_data *vc, ushort ct, ushort __user *uct, struct unipair __user *list)
585 {
586         int i, j, k, ect;
587         u16 **p1, *p2;
588         struct uni_pagedir *p;
589
590         ect = 0;
591         if (*vc->vc_uni_pagedir_loc) {
592                 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
593                 for (i = 0; i < 32; i++)
594                 if ((p1 = p->uni_pgdir[i]))
595                         for (j = 0; j < 32; j++)
596                         if ((p2 = *(p1++)))
597                                 for (k = 0; k < 64; k++) {
598                                         if (*p2 < MAX_GLYPH && ect++ < ct) {
599                                                 __put_user((u_short)((i<<11)+(j<<6)+k),
600                                                            &list->unicode);
601                                                 __put_user((u_short) *p2, 
602                                                            &list->fontpos);
603                                                 list++;
604                                         }
605                                         p2++;
606                                 }
607         }
608         __put_user(ect, uct);
609         return ((ect <= ct) ? 0 : -ENOMEM);
610 }
611
612 void con_protect_unimap(struct vc_data *vc, int rdonly)
613 {
614         struct uni_pagedir *p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
615         
616         if (p)
617                 p->readonly = rdonly;
618 }
619
620 int
621 conv_uni_to_pc(struct vc_data *conp, long ucs) 
622 {
623         int h;
624         u16 **p1, *p2;
625         struct uni_pagedir *p;
626   
627         /* Only 16-bit codes supported at this time */
628         if (ucs > 0xffff)
629                 ucs = 0xfffd;           /* U+FFFD: REPLACEMENT CHARACTER */
630         else if (ucs < 0x20 || ucs >= 0xfffe)
631                 return -1;              /* Not a printable character */
632         else if (ucs == 0xfeff || (ucs >= 0x200a && ucs <= 0x200f))
633                 return -2;                      /* Zero-width space */
634         /*
635          * UNI_DIRECT_BASE indicates the start of the region in the User Zone
636          * which always has a 1:1 mapping to the currently loaded font.  The
637          * UNI_DIRECT_MASK indicates the bit span of the region.
638          */
639         else if ((ucs & ~UNI_DIRECT_MASK) == UNI_DIRECT_BASE)
640                 return ucs & UNI_DIRECT_MASK;
641   
642         if (!*conp->vc_uni_pagedir_loc)
643                 return -3;
644
645         p = (struct uni_pagedir *)*conp->vc_uni_pagedir_loc;  
646         if ((p1 = p->uni_pgdir[ucs >> 11]) &&
647             (p2 = p1[(ucs >> 6) & 0x1f]) &&
648             (h = p2[ucs & 0x3f]) < MAX_GLYPH)
649                 return h;
650
651         return -4;              /* not found */
652 }
653
654 /*
655  * This is called at sys_setup time, after memory and the console are
656  * initialized.  It must be possible to call kmalloc(..., GFP_KERNEL)
657  * from this function, hence the call from sys_setup.
658  */
659 void __init 
660 console_map_init(void)
661 {
662         int i;
663         
664         for (i = 0; i < MAX_NR_CONSOLES; i++)
665                 if (vc_cons_allocated(i) && !*vc_cons[i].d->vc_uni_pagedir_loc)
666                         con_set_default_unimap(vc_cons[i].d);
667 }
668
669 EXPORT_SYMBOL(con_copy_unimap);