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 if (p->inverse_trans_unicode) { 414 kfree(p->inverse_trans_unicode); 415 p->inverse_trans_unicode = NULL; 416 } 417 } 418 419 /* Caller must hold the console lock */ 420 void con_free_unimap(struct vc_data *vc) 421 { 422 struct uni_pagedir *p; 423 424 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc; 425 if (!p) 426 return; 427 *vc->vc_uni_pagedir_loc = 0; 428 if (--p->refcount) 429 return; 430 con_release_unimap(p); 431 kfree(p); 432 } 433 434 static int con_unify_unimap(struct vc_data *conp, struct uni_pagedir *p) 435 { 436 int i, j, k; 437 struct uni_pagedir *q; 438 439 for (i = 0; i < MAX_NR_CONSOLES; i++) { 440 if (!vc_cons_allocated(i)) 441 continue; 442 q = (struct uni_pagedir *)*vc_cons[i].d->vc_uni_pagedir_loc; 443 if (!q || q == p || q->sum != p->sum) 444 continue; 445 for (j = 0; j < 32; j++) { 446 u16 **p1, **q1; 447 p1 = p->uni_pgdir[j]; q1 = q->uni_pgdir[j]; 448 if (!p1 && !q1) 449 continue; 450 if (!p1 || !q1) 451 break; 452 for (k = 0; k < 32; k++) { 453 if (!p1[k] && !q1[k]) 454 continue; 455 if (!p1[k] || !q1[k]) 456 break; 457 if (memcmp(p1[k], q1[k], 64*sizeof(u16))) 458 break; 459 } 460 if (k < 32) 461 break; 462 } 463 if (j == 32) { 464 q->refcount++; 465 *conp->vc_uni_pagedir_loc = (unsigned long)q; 466 con_release_unimap(p); 467 kfree(p); 468 return 1; 469 } 470 } 471 return 0; 472 } 473 474 static int 475 con_insert_unipair(struct uni_pagedir *p, u_short unicode, u_short fontpos) 476 { 477 int i, n; 478 u16 **p1, *p2; 479 480 if (!(p1 = p->uni_pgdir[n = unicode >> 11])) { 481 p1 = p->uni_pgdir[n] = kmalloc(32*sizeof(u16 *), GFP_KERNEL); 482 if (!p1) return -ENOMEM; 483 for (i = 0; i < 32; i++) 484 p1[i] = NULL; 485 } 486 487 if (!(p2 = p1[n = (unicode >> 6) & 0x1f])) { 488 p2 = p1[n] = kmalloc(64*sizeof(u16), GFP_KERNEL); 489 if (!p2) return -ENOMEM; 490 memset(p2, 0xff, 64*sizeof(u16)); /* No glyphs for the characters (yet) */ 491 } 492 493 p2[unicode & 0x3f] = fontpos; 494 495 p->sum += (fontpos << 20) + unicode; 496 497 return 0; 498 } 499 500 /* ui is a leftover from using a hashtable, but might be used again 501 Caller must hold the lock */ 502 static int con_do_clear_unimap(struct vc_data *vc, struct unimapinit *ui) 503 { 504 struct uni_pagedir *p, *q; 505 506 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc; 507 if (p && p->readonly) 508 return -EIO; 509 510 if (!p || --p->refcount) { 511 q = kzalloc(sizeof(*p), GFP_KERNEL); 512 if (!q) { 513 if (p) 514 p->refcount++; 515 return -ENOMEM; 516 } 517 q->refcount=1; 518 *vc->vc_uni_pagedir_loc = (unsigned long)q; 519 } else { 520 if (p == dflt) dflt = NULL; 521 p->refcount++; 522 p->sum = 0; 523 con_release_unimap(p); 524 } 525 return 0; 526 } 527 528 int con_clear_unimap(struct vc_data *vc, struct unimapinit *ui) 529 { 530 int ret; 531 console_lock(); 532 ret = con_do_clear_unimap(vc, ui); 533 console_unlock(); 534 return ret; 535 } 536 537 int con_set_unimap(struct vc_data *vc, ushort ct, struct unipair __user *list) 538 { 539 int err = 0, err1, i; 540 struct uni_pagedir *p, *q; 541 542 console_lock(); 543 544 /* Save original vc_unipagdir_loc in case we allocate a new one */ 545 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc; 546 if (p->readonly) { 547 console_unlock(); 548 return -EIO; 549 } 550 551 if (!ct) { 552 console_unlock(); 553 return 0; 554 } 555 556 if (p->refcount > 1) { 557 int j, k; 558 u16 **p1, *p2, l; 559 560 err1 = con_do_clear_unimap(vc, NULL); 561 if (err1) { 562 console_unlock(); 563 return err1; 564 } 565 566 /* 567 * Since refcount was > 1, con_clear_unimap() allocated a 568 * a new uni_pagedir for this vc. Re: p != q 569 */ 570 q = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc; 571 572 /* 573 * uni_pgdir is a 32*32*64 table with rows allocated 574 * when its first entry is added. The unicode value must 575 * still be incremented for empty rows. We are copying 576 * entries from "p" (old) to "q" (new). 577 */ 578 l = 0; /* unicode value */ 579 for (i = 0; i < 32; i++) 580 if ((p1 = p->uni_pgdir[i])) 581 for (j = 0; j < 32; j++) 582 if ((p2 = p1[j])) { 583 for (k = 0; k < 64; k++, l++) 584 if (p2[k] != 0xffff) { 585 /* 586 * Found one, copy entry for unicode 587 * l with fontpos value p2[k]. 588 */ 589 err1 = con_insert_unipair(q, l, p2[k]); 590 if (err1) { 591 p->refcount++; 592 *vc->vc_uni_pagedir_loc = (unsigned long)p; 593 con_release_unimap(q); 594 kfree(q); 595 console_unlock(); 596 return err1; 597 } 598 } 599 } else { 600 /* Account for row of 64 empty entries */ 601 l += 64; 602 } 603 else 604 /* Account for empty table */ 605 l += 32 * 64; 606 607 /* 608 * Finished copying font table, set vc_uni_pagedir to new table 609 */ 610 p = q; 611 } else if (p == dflt) { 612 dflt = NULL; 613 } 614 615 /* 616 * Insert user specified unicode pairs into new table. 617 */ 618 while (ct--) { 619 unsigned short unicode, fontpos; 620 __get_user(unicode, &list->unicode); 621 __get_user(fontpos, &list->fontpos); 622 if ((err1 = con_insert_unipair(p, unicode,fontpos)) != 0) 623 err = err1; 624 list++; 625 } 626 627 /* 628 * Merge with fontmaps of any other virtual consoles. 629 */ 630 if (con_unify_unimap(vc, p)) { 631 console_unlock(); 632 return err; 633 } 634 635 for (i = 0; i <= 3; i++) 636 set_inverse_transl(vc, p, i); /* Update inverse translations */ 637 set_inverse_trans_unicode(vc, p); 638 639 console_unlock(); 640 return err; 641 } 642 643 /** 644 * con_set_default_unimap - set default unicode map 645 * @vc: the console we are updating 646 * 647 * Loads the unimap for the hardware font, as defined in uni_hash.tbl. 648 * The representation used was the most compact I could come up 649 * with. This routine is executed at video setup, and when the 650 * PIO_FONTRESET ioctl is called. 651 * 652 * The caller must hold the console lock 653 */ 654 int con_set_default_unimap(struct vc_data *vc) 655 { 656 int i, j, err = 0, err1; 657 u16 *q; 658 struct uni_pagedir *p; 659 660 if (dflt) { 661 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc; 662 if (p == dflt) 663 return 0; 664 665 dflt->refcount++; 666 *vc->vc_uni_pagedir_loc = (unsigned long)dflt; 667 if (p && !--p->refcount) { 668 con_release_unimap(p); 669 kfree(p); 670 } 671 return 0; 672 } 673 674 /* The default font is always 256 characters */ 675 676 err = con_do_clear_unimap(vc, NULL); 677 if (err) 678 return err; 679 680 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc; 681 q = dfont_unitable; 682 683 for (i = 0; i < 256; i++) 684 for (j = dfont_unicount[i]; j; j--) { 685 err1 = con_insert_unipair(p, *(q++), i); 686 if (err1) 687 err = err1; 688 } 689 690 if (con_unify_unimap(vc, p)) { 691 dflt = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc; 692 return err; 693 } 694 695 for (i = 0; i <= 3; i++) 696 set_inverse_transl(vc, p, i); /* Update all inverse translations */ 697 set_inverse_trans_unicode(vc, p); 698 dflt = p; 699 return err; 700 } 701 EXPORT_SYMBOL(con_set_default_unimap); 702 703 /** 704 * con_copy_unimap - copy unimap between two vts 705 * @dst_vc: target 706 * @src_vt: source 707 * 708 * The caller must hold the console lock when invoking this method 709 */ 710 int con_copy_unimap(struct vc_data *dst_vc, struct vc_data *src_vc) 711 { 712 struct uni_pagedir *q; 713 714 if (!*src_vc->vc_uni_pagedir_loc) 715 return -EINVAL; 716 if (*dst_vc->vc_uni_pagedir_loc == *src_vc->vc_uni_pagedir_loc) 717 return 0; 718 con_free_unimap(dst_vc); 719 q = (struct uni_pagedir *)*src_vc->vc_uni_pagedir_loc; 720 q->refcount++; 721 *dst_vc->vc_uni_pagedir_loc = (long)q; 722 return 0; 723 } 724 EXPORT_SYMBOL(con_copy_unimap); 725 726 /** 727 * con_get_unimap - get the unicode map 728 * @vc: the console to read from 729 * 730 * Read the console unicode data for this console. Called from the ioctl 731 * handlers. 732 */ 733 int con_get_unimap(struct vc_data *vc, ushort ct, ushort __user *uct, struct unipair __user *list) 734 { 735 int i, j, k, ect; 736 u16 **p1, *p2; 737 struct uni_pagedir *p; 738 739 console_lock(); 740 741 ect = 0; 742 if (*vc->vc_uni_pagedir_loc) { 743 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc; 744 for (i = 0; i < 32; i++) 745 if ((p1 = p->uni_pgdir[i])) 746 for (j = 0; j < 32; j++) 747 if ((p2 = *(p1++))) 748 for (k = 0; k < 64; k++) { 749 if (*p2 < MAX_GLYPH && ect++ < ct) { 750 __put_user((u_short)((i<<11)+(j<<6)+k), 751 &list->unicode); 752 __put_user((u_short) *p2, 753 &list->fontpos); 754 list++; 755 } 756 p2++; 757 } 758 } 759 __put_user(ect, uct); 760 console_unlock(); 761 return ((ect <= ct) ? 0 : -ENOMEM); 762 } 763 764 /* 765 * Always use USER_MAP. These functions are used by the keyboard, 766 * which shouldn't be affected by G0/G1 switching, etc. 767 * If the user map still contains default values, i.e. the 768 * direct-to-font mapping, then assume user is using Latin1. 769 * 770 * FIXME: at some point we need to decide if we want to lock the table 771 * update element itself via the keyboard_event_lock for consistency with the 772 * keyboard driver as well as the consoles 773 */ 774 /* may be called during an interrupt */ 775 u32 conv_8bit_to_uni(unsigned char c) 776 { 777 unsigned short uni = translations[USER_MAP][c]; 778 return uni == (0xf000 | c) ? c : uni; 779 } 780 781 int conv_uni_to_8bit(u32 uni) 782 { 783 int c; 784 for (c = 0; c < 0x100; c++) 785 if (translations[USER_MAP][c] == uni || 786 (translations[USER_MAP][c] == (c | 0xf000) && uni == c)) 787 return c; 788 return -1; 789 } 790 791 int 792 conv_uni_to_pc(struct vc_data *conp, long ucs) 793 { 794 int h; 795 u16 **p1, *p2; 796 struct uni_pagedir *p; 797 798 /* Only 16-bit codes supported at this time */ 799 if (ucs > 0xffff) 800 return -4; /* Not found */ 801 else if (ucs < 0x20) 802 return -1; /* Not a printable character */ 803 else if (ucs == 0xfeff || (ucs >= 0x200b && ucs <= 0x200f)) 804 return -2; /* Zero-width space */ 805 /* 806 * UNI_DIRECT_BASE indicates the start of the region in the User Zone 807 * which always has a 1:1 mapping to the currently loaded font. The 808 * UNI_DIRECT_MASK indicates the bit span of the region. 809 */ 810 else if ((ucs & ~UNI_DIRECT_MASK) == UNI_DIRECT_BASE) 811 return ucs & UNI_DIRECT_MASK; 812 813 if (!*conp->vc_uni_pagedir_loc) 814 return -3; 815 816 p = (struct uni_pagedir *)*conp->vc_uni_pagedir_loc; 817 if ((p1 = p->uni_pgdir[ucs >> 11]) && 818 (p2 = p1[(ucs >> 6) & 0x1f]) && 819 (h = p2[ucs & 0x3f]) < MAX_GLYPH) 820 return h; 821 822 return -4; /* not found */ 823 } 824 825 /* 826 * This is called at sys_setup time, after memory and the console are 827 * initialized. It must be possible to call kmalloc(..., GFP_KERNEL) 828 * from this function, hence the call from sys_setup. 829 */ 830 void __init 831 console_map_init(void) 832 { 833 int i; 834 835 for (i = 0; i < MAX_NR_CONSOLES; i++) 836 if (vc_cons_allocated(i) && !*vc_cons[i].d->vc_uni_pagedir_loc) 837 con_set_default_unimap(vc_cons[i].d); 838 } 839 840