projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] IPMI oops fix
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / char / consolemap.c
CommitLineData
1da177e4
LT		 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/config.h>
15#include <linux/module.h>
16#include <linux/kd.h>
17#include <linux/errno.h>
18#include <linux/mm.h>
19#include <linux/slab.h>
20#include <linux/init.h>
21#include <linux/tty.h>
22#include <asm/uaccess.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 int readonly;
182};
183
184static struct uni_pagedir *dflt;
185
186static void set_inverse_transl(struct vc_data *conp, struct uni_pagedir *p, int i)
187{
188 int j, glyph;
189 unsigned short *t = translations[i];
190 unsigned char *q;
191
192 if (!p) return;
193 q = p->inverse_translations[i];
194
195 if (!q) {
196 q = p->inverse_translations[i] = (unsigned char *)
197 kmalloc(MAX_GLYPH, GFP_KERNEL);
198 if (!q) return;
199 }
200 memset(q, 0, MAX_GLYPH);
201
202 for (j = 0; j < E_TABSZ; j++) {
203 glyph = conv_uni_to_pc(conp, t[j]);
204 if (glyph >= 0 && glyph < MAX_GLYPH && q[glyph] < 32) {
205 /* prefer '-' above SHY etc. */
206 q[glyph] = j;
207 }
208 }
209}
210
211unsigned short *set_translate(int m, struct vc_data *vc)
212{
213 inv_translate[vc->vc_num] = m;
214 return translations[m];
215}
216
217/*
218 * Inverse translation is impossible for several reasons:
219 * 1. The font<->character maps are not 1-1.
220 * 2. The text may have been written while a different translation map
221 * was active, or using Unicode.
222 * Still, it is now possible to a certain extent to cut and paste non-ASCII.
223 */
224unsigned char inverse_translate(struct vc_data *conp, int glyph)
225{
226 struct uni_pagedir *p;
227 if (glyph < 0 || glyph >= MAX_GLYPH)
228 return 0;
229 else if (!(p = (struct uni_pagedir *)*conp->vc_uni_pagedir_loc) ||
230 !p->inverse_translations[inv_translate[conp->vc_num]])
231 return glyph;
232 else
233 return p->inverse_translations[inv_translate[conp->vc_num]][glyph];
234}
235
236static void update_user_maps(void)
237{
238 int i;
239 struct uni_pagedir *p, *q = NULL;
240
241 for (i = 0; i < MAX_NR_CONSOLES; i++) {
242 if (!vc_cons_allocated(i))
243 continue;
244 p = (struct uni_pagedir *)*vc_cons[i].d->vc_uni_pagedir_loc;
245 if (p && p != q) {
246 set_inverse_transl(vc_cons[i].d, p, USER_MAP);
247 q = p;
248 }
249 }
250}
251
252/*
253 * Load customizable translation table
254 * arg points to a 256 byte translation table.
255 *
256 * The "old" variants are for translation directly to font (using the
257 * 0xf000-0xf0ff "transparent" Unicodes) whereas the "new" variants set
258 * Unicodes explicitly.
259 */
260int con_set_trans_old(unsigned char __user * arg)
261{
262 int i;
263 unsigned short *p = translations[USER_MAP];
264
265 if (!access_ok(VERIFY_READ, arg, E_TABSZ))
266 return -EFAULT;
267
268 for (i=0; i<E_TABSZ ; i++) {
269 unsigned char uc;
270 __get_user(uc, arg+i);
271 p[i] = UNI_DIRECT_BASE | uc;
272 }
273
274 update_user_maps();
275 return 0;
276}
277
278int con_get_trans_old(unsigned char __user * arg)
279{
280 int i, ch;
281 unsigned short *p = translations[USER_MAP];
282
283 if (!access_ok(VERIFY_WRITE, arg, E_TABSZ))
284 return -EFAULT;
285
286 for (i=0; i<E_TABSZ ; i++)
287 {
288 ch = conv_uni_to_pc(vc_cons[fg_console].d, p[i]);
289 __put_user((ch & ~0xff) ? 0 : ch, arg+i);
290 }
291 return 0;
292}
293
294int con_set_trans_new(ushort __user * arg)
295{
296 int i;
297 unsigned short *p = translations[USER_MAP];
298
299 if (!access_ok(VERIFY_READ, arg, E_TABSZ*sizeof(unsigned short)))
300 return -EFAULT;
301
302 for (i=0; i<E_TABSZ ; i++) {
303 unsigned short us;
304 __get_user(us, arg+i);
305 p[i] = us;
306 }
307
308 update_user_maps();
309 return 0;
310}
311
312int con_get_trans_new(ushort __user * arg)
313{
314 int i;
315 unsigned short *p = translations[USER_MAP];
316
317 if (!access_ok(VERIFY_WRITE, arg, E_TABSZ*sizeof(unsigned short)))
318 return -EFAULT;
319
320 for (i=0; i<E_TABSZ ; i++)
321 __put_user(p[i], arg+i);
322
323 return 0;
324}
325
326/*
327 * Unicode -> current font conversion
328 *
329 * A font has at most 512 chars, usually 256.
330 * But one font position may represent several Unicode chars.
331 * A hashtable is somewhat of a pain to deal with, so use a
332 * "paged table" instead. Simulation has shown the memory cost of
333 * this 3-level paged table scheme to be comparable to a hash table.
334 */
335
336extern u8 dfont_unicount[]; /* Defined in console_defmap.c */
337extern u16 dfont_unitable[];
338
339static void con_release_unimap(struct uni_pagedir *p)
340{
341 u16 **p1;
342 int i, j;
343
344 if (p == dflt) dflt = NULL;
345 for (i = 0; i < 32; i++) {
346 if ((p1 = p->uni_pgdir[i]) != NULL) {
347 for (j = 0; j < 32; j++)
735d5661 348 kfree(p1[j]);
1da177e4
LT		 349 kfree(p1);
350 }
351 p->uni_pgdir[i] = NULL;
352 }
735d5661
JJ		 353 for (i = 0; i < 4; i++) {
354 kfree(p->inverse_translations[i]);
355 p->inverse_translations[i] = NULL;
356 }
1da177e4
LT		 357}
358
359void con_free_unimap(struct vc_data *vc)
360{
361 struct uni_pagedir *p;
362
363 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
364 if (!p)
365 return;
366 *vc->vc_uni_pagedir_loc = 0;
367 if (--p->refcount)
368 return;
369 con_release_unimap(p);
370 kfree(p);
371}
372
373static int con_unify_unimap(struct vc_data *conp, struct uni_pagedir *p)
374{
375 int i, j, k;
376 struct uni_pagedir *q;
377
378 for (i = 0; i < MAX_NR_CONSOLES; i++) {
379 if (!vc_cons_allocated(i))
380 continue;
381 q = (struct uni_pagedir *)*vc_cons[i].d->vc_uni_pagedir_loc;
382 if (!q || q == p || q->sum != p->sum)
383 continue;
384 for (j = 0; j < 32; j++) {
385 u16 **p1, **q1;
386 p1 = p->uni_pgdir[j]; q1 = q->uni_pgdir[j];
387 if (!p1 && !q1)
388 continue;
389 if (!p1 || !q1)
390 break;
391 for (k = 0; k < 32; k++) {
392 if (!p1[k] && !q1[k])
393 continue;
394 if (!p1[k] || !q1[k])
395 break;
396 if (memcmp(p1[k], q1[k], 64*sizeof(u16)))
397 break;
398 }
399 if (k < 32)
400 break;
401 }
402 if (j == 32) {
403 q->refcount++;
404 *conp->vc_uni_pagedir_loc = (unsigned long)q;
405 con_release_unimap(p);
406 kfree(p);
407 return 1;
408 }
409 }
410 return 0;
411}
412
413static int
414con_insert_unipair(struct uni_pagedir *p, u_short unicode, u_short fontpos)
415{
416 int i, n;
417 u16 **p1, *p2;
418
419 if (!(p1 = p->uni_pgdir[n = unicode >> 11])) {
420 p1 = p->uni_pgdir[n] = kmalloc(32*sizeof(u16 *), GFP_KERNEL);
421 if (!p1) return -ENOMEM;
422 for (i = 0; i < 32; i++)
423 p1[i] = NULL;
424 }
425
426 if (!(p2 = p1[n = (unicode >> 6) & 0x1f])) {
427 p2 = p1[n] = kmalloc(64*sizeof(u16), GFP_KERNEL);
428 if (!p2) return -ENOMEM;
429 memset(p2, 0xff, 64*sizeof(u16)); /* No glyphs for the characters (yet) */
430 }
431
432 p2[unicode & 0x3f] = fontpos;
433
434 p->sum += (fontpos << 20) + unicode;
435
436 return 0;
437}
438
439/* ui is a leftover from using a hashtable, but might be used again */
440int con_clear_unimap(struct vc_data *vc, struct unimapinit *ui)
441{
442 struct uni_pagedir *p, *q;
443
444 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
445 if (p && p->readonly) return -EIO;
446 if (!p || --p->refcount) {
447 q = (struct uni_pagedir *)kmalloc(sizeof(*p), GFP_KERNEL);
448 if (!q) {
449 if (p) p->refcount++;
450 return -ENOMEM;
451 }
452 memset(q, 0, sizeof(*q));
453 q->refcount=1;
454 *vc->vc_uni_pagedir_loc = (unsigned long)q;
455 } else {
456 if (p == dflt) dflt = NULL;
457 p->refcount++;
458 p->sum = 0;
459 con_release_unimap(p);
460 }
461 return 0;
462}
463
464int con_set_unimap(struct vc_data *vc, ushort ct, struct unipair __user *list)
465{
466 int err = 0, err1, i;
467 struct uni_pagedir *p, *q;
468
469 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
470 if (p->readonly) return -EIO;
471
472 if (!ct) return 0;
473
474 if (p->refcount > 1) {
475 int j, k;
476 u16 **p1, *p2, l;
477
478 err1 = con_clear_unimap(vc, NULL);
479 if (err1) return err1;
480
481 q = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
482 for (i = 0, l = 0; i < 32; i++)
483 if ((p1 = p->uni_pgdir[i]))
484 for (j = 0; j < 32; j++)
485 if ((p2 = p1[j]))
486 for (k = 0; k < 64; k++, l++)
487 if (p2[k] != 0xffff) {
488 err1 = con_insert_unipair(q, l, p2[k]);
489 if (err1) {
490 p->refcount++;
491 *vc->vc_uni_pagedir_loc = (unsigned long)p;
492 con_release_unimap(q);
493 kfree(q);
494 return err1;
495 }
496 }
497 p = q;
498 } else if (p == dflt)
499 dflt = NULL;
500
501 while (ct--) {
502 unsigned short unicode, fontpos;
503 __get_user(unicode, &list->unicode);
504 __get_user(fontpos, &list->fontpos);
505 if ((err1 = con_insert_unipair(p, unicode,fontpos)) != 0)
506 err = err1;
507 list++;
508 }
509
510 if (con_unify_unimap(vc, p))
511 return err;
512
513 for (i = 0; i <= 3; i++)
514 set_inverse_transl(vc, p, i); /* Update all inverse translations */
515
516 return err;
517}
518
519/* Loads the unimap for the hardware font, as defined in uni_hash.tbl.
520 The representation used was the most compact I could come up
521 with. This routine is executed at sys_setup time, and when the
522 PIO_FONTRESET ioctl is called. */
523
524int con_set_default_unimap(struct vc_data *vc)
525{
526 int i, j, err = 0, err1;
527 u16 *q;
528 struct uni_pagedir *p;
529
530 if (dflt) {
531 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
532 if (p == dflt)
533 return 0;
534 dflt->refcount++;
535 *vc->vc_uni_pagedir_loc = (unsigned long)dflt;
536 if (p && --p->refcount) {
537 con_release_unimap(p);
538 kfree(p);
539 }
540 return 0;
541 }
542
543 /* The default font is always 256 characters */
544
545 err = con_clear_unimap(vc, NULL);
546 if (err) return err;
547
548 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
549 q = dfont_unitable;
550
551 for (i = 0; i < 256; i++)
552 for (j = dfont_unicount[i]; j; j--) {
553 err1 = con_insert_unipair(p, *(q++), i);
554 if (err1)
555 err = err1;
556 }
557
558 if (con_unify_unimap(vc, p)) {
559 dflt = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
560 return err;
561 }
562
563 for (i = 0; i <= 3; i++)
564 set_inverse_transl(vc, p, i); /* Update all inverse translations */
565 dflt = p;
566 return err;
567}
568EXPORT_SYMBOL(con_set_default_unimap);
569
570int con_copy_unimap(struct vc_data *dst_vc, struct vc_data *src_vc)
571{
572 struct uni_pagedir *q;
573
574 if (!*src_vc->vc_uni_pagedir_loc)
575 return -EINVAL;
576 if (*dst_vc->vc_uni_pagedir_loc == *src_vc->vc_uni_pagedir_loc)
577 return 0;
578 con_free_unimap(dst_vc);
579 q = (struct uni_pagedir *)*src_vc->vc_uni_pagedir_loc;
580 q->refcount++;
581 *dst_vc->vc_uni_pagedir_loc = (long)q;
582 return 0;
583}
584
585int con_get_unimap(struct vc_data *vc, ushort ct, ushort __user *uct, struct unipair __user *list)
586{
587 int i, j, k, ect;
588 u16 **p1, *p2;
589 struct uni_pagedir *p;
590
591 ect = 0;
592 if (*vc->vc_uni_pagedir_loc) {
593 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
594 for (i = 0; i < 32; i++)
595 if ((p1 = p->uni_pgdir[i]))
596 for (j = 0; j < 32; j++)
597 if ((p2 = *(p1++)))
598 for (k = 0; k < 64; k++) {
599 if (*p2 < MAX_GLYPH && ect++ < ct) {
600 __put_user((u_short)((i<<11)+(j<<6)+k),
601 &list->unicode);
602 __put_user((u_short) *p2,
603 &list->fontpos);
604 list++;
605 }
606 p2++;
607 }
608 }
609 __put_user(ect, uct);
610 return ((ect <= ct) ? 0 : -ENOMEM);
611}
612
613void con_protect_unimap(struct vc_data *vc, int rdonly)
614{
615 struct uni_pagedir *p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
616
617 if (p)
618 p->readonly = rdonly;
619}
620
621int
622conv_uni_to_pc(struct vc_data *conp, long ucs)
623{
624 int h;
625 u16 **p1, *p2;
626 struct uni_pagedir *p;
627
628 /* Only 16-bit codes supported at this time */
629 if (ucs > 0xffff)
630 ucs = 0xfffd; /* U+FFFD: REPLACEMENT CHARACTER */
631 else if (ucs < 0x20 || ucs >= 0xfffe)
632 return -1; /* Not a printable character */
633 else if (ucs == 0xfeff || (ucs >= 0x200a && ucs <= 0x200f))
634 return -2; /* Zero-width space */
635 /*
636 * UNI_DIRECT_BASE indicates the start of the region in the User Zone
637 * which always has a 1:1 mapping to the currently loaded font. The
638 * UNI_DIRECT_MASK indicates the bit span of the region.
639 */
640 else if ((ucs & ~UNI_DIRECT_MASK) == UNI_DIRECT_BASE)
641 return ucs & UNI_DIRECT_MASK;
642
643 if (!*conp->vc_uni_pagedir_loc)
644 return -3;
645
646 p = (struct uni_pagedir *)*conp->vc_uni_pagedir_loc;
647 if ((p1 = p->uni_pgdir[ucs >> 11]) &&
648 (p2 = p1[(ucs >> 6) & 0x1f]) &&
649 (h = p2[ucs & 0x3f]) < MAX_GLYPH)
650 return h;
651
652 return -4; /* not found */
653}
654
655/*
656 * This is called at sys_setup time, after memory and the console are
657 * initialized. It must be possible to call kmalloc(..., GFP_KERNEL)
658 * from this function, hence the call from sys_setup.
659 */
660void __init
661console_map_init(void)
662{
663 int i;
664
665 for (i = 0; i < MAX_NR_CONSOLES; i++)
666 if (vc_cons_allocated(i) && !*vc_cons[i].d->vc_uni_pagedir_loc)
667 con_set_default_unimap(vc_cons[i].d);
668}
669
670EXPORT_SYMBOL(con_copy_unimap);
kernel source for telekom puls (alcatel/mediatek)