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 * In order to prevent the following circular lock dependency: 14 * &mm->mmap_sem --> cpu_hotplug.lock --> console_lock --> &mm->mmap_sem 15 * 16 * We cannot allow page fault to happen while holding the console_lock. 17 * Therefore, all the userspace copy operations have to be done outside 18 * the console_lock critical sections. 19 * 20 * As all the affected functions are all called directly from vt_ioctl(), we 21 * can allocate some small buffers directly on stack without worrying about 22 * stack overflow. 23 */ 24 25 #include <linux/module.h> 26 #include <linux/kd.h> 27 #include <linux/errno.h> 28 #include <linux/mm.h> 29 #include <linux/slab.h> 30 #include <linux/init.h> 31 #include <linux/tty.h> 32 #include <linux/uaccess.h> 33 #include <linux/console.h> 34 #include <linux/consolemap.h> 35 #include <linux/vt_kern.h> 36 #include <linux/string.h> 37 38 static unsigned short translations[][256] = { 39 /* 8-bit Latin-1 mapped to Unicode -- trivial mapping */ 40 { 41 0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 42 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f, 43 0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 44 0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f, 45 0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 46 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f, 47 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 48 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f, 49 0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 50 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f, 51 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 52 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f, 53 0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 54 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f, 55 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 56 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f, 57 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 58 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f, 59 0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 60 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f, 61 0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7, 62 0x00a8, 0x00a9, 0x00aa, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af, 63 0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7, 64 0x00b8, 0x00b9, 0x00ba, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00bf, 65 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7, 66 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf, 67 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7, 68 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df, 69 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7, 70 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef, 71 0x00f0, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7, 72 0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x00ff 73 }, 74 /* VT100 graphics mapped to Unicode */ 75 { 76 0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 77 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f, 78 0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 79 0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f, 80 0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 81 0x0028, 0x0029, 0x002a, 0x2192, 0x2190, 0x2191, 0x2193, 0x002f, 82 0x2588, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 83 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f, 84 0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 85 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f, 86 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 87 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x00a0, 88 0x25c6, 0x2592, 0x2409, 0x240c, 0x240d, 0x240a, 0x00b0, 0x00b1, 89 0x2591, 0x240b, 0x2518, 0x2510, 0x250c, 0x2514, 0x253c, 0x23ba, 90 0x23bb, 0x2500, 0x23bc, 0x23bd, 0x251c, 0x2524, 0x2534, 0x252c, 91 0x2502, 0x2264, 0x2265, 0x03c0, 0x2260, 0x00a3, 0x00b7, 0x007f, 92 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 93 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f, 94 0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 95 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f, 96 0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7, 97 0x00a8, 0x00a9, 0x00aa, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af, 98 0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7, 99 0x00b8, 0x00b9, 0x00ba, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00bf, 100 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7, 101 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf, 102 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7, 103 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df, 104 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7, 105 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef, 106 0x00f0, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7, 107 0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x00ff 108 }, 109 /* IBM Codepage 437 mapped to Unicode */ 110 { 111 0x0000, 0x263a, 0x263b, 0x2665, 0x2666, 0x2663, 0x2660, 0x2022, 112 0x25d8, 0x25cb, 0x25d9, 0x2642, 0x2640, 0x266a, 0x266b, 0x263c, 113 0x25b6, 0x25c0, 0x2195, 0x203c, 0x00b6, 0x00a7, 0x25ac, 0x21a8, 114 0x2191, 0x2193, 0x2192, 0x2190, 0x221f, 0x2194, 0x25b2, 0x25bc, 115 0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 116 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f, 117 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 118 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f, 119 0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 120 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f, 121 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 122 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f, 123 0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 124 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f, 125 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 126 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x2302, 127 0x00c7, 0x00fc, 0x00e9, 0x00e2, 0x00e4, 0x00e0, 0x00e5, 0x00e7, 128 0x00ea, 0x00eb, 0x00e8, 0x00ef, 0x00ee, 0x00ec, 0x00c4, 0x00c5, 129 0x00c9, 0x00e6, 0x00c6, 0x00f4, 0x00f6, 0x00f2, 0x00fb, 0x00f9, 130 0x00ff, 0x00d6, 0x00dc, 0x00a2, 0x00a3, 0x00a5, 0x20a7, 0x0192, 131 0x00e1, 0x00ed, 0x00f3, 0x00fa, 0x00f1, 0x00d1, 0x00aa, 0x00ba, 132 0x00bf, 0x2310, 0x00ac, 0x00bd, 0x00bc, 0x00a1, 0x00ab, 0x00bb, 133 0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556, 134 0x2555, 0x2563, 0x2551, 0x2557, 0x255d, 0x255c, 0x255b, 0x2510, 135 0x2514, 0x2534, 0x252c, 0x251c, 0x2500, 0x253c, 0x255e, 0x255f, 136 0x255a, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256c, 0x2567, 137 0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256b, 138 0x256a, 0x2518, 0x250c, 0x2588, 0x2584, 0x258c, 0x2590, 0x2580, 139 0x03b1, 0x00df, 0x0393, 0x03c0, 0x03a3, 0x03c3, 0x00b5, 0x03c4, 140 0x03a6, 0x0398, 0x03a9, 0x03b4, 0x221e, 0x03c6, 0x03b5, 0x2229, 141 0x2261, 0x00b1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00f7, 0x2248, 142 0x00b0, 0x2219, 0x00b7, 0x221a, 0x207f, 0x00b2, 0x25a0, 0x00a0 143 }, 144 /* User mapping -- default to codes for direct font mapping */ 145 { 146 0xf000, 0xf001, 0xf002, 0xf003, 0xf004, 0xf005, 0xf006, 0xf007, 147 0xf008, 0xf009, 0xf00a, 0xf00b, 0xf00c, 0xf00d, 0xf00e, 0xf00f, 148 0xf010, 0xf011, 0xf012, 0xf013, 0xf014, 0xf015, 0xf016, 0xf017, 149 0xf018, 0xf019, 0xf01a, 0xf01b, 0xf01c, 0xf01d, 0xf01e, 0xf01f, 150 0xf020, 0xf021, 0xf022, 0xf023, 0xf024, 0xf025, 0xf026, 0xf027, 151 0xf028, 0xf029, 0xf02a, 0xf02b, 0xf02c, 0xf02d, 0xf02e, 0xf02f, 152 0xf030, 0xf031, 0xf032, 0xf033, 0xf034, 0xf035, 0xf036, 0xf037, 153 0xf038, 0xf039, 0xf03a, 0xf03b, 0xf03c, 0xf03d, 0xf03e, 0xf03f, 154 0xf040, 0xf041, 0xf042, 0xf043, 0xf044, 0xf045, 0xf046, 0xf047, 155 0xf048, 0xf049, 0xf04a, 0xf04b, 0xf04c, 0xf04d, 0xf04e, 0xf04f, 156 0xf050, 0xf051, 0xf052, 0xf053, 0xf054, 0xf055, 0xf056, 0xf057, 157 0xf058, 0xf059, 0xf05a, 0xf05b, 0xf05c, 0xf05d, 0xf05e, 0xf05f, 158 0xf060, 0xf061, 0xf062, 0xf063, 0xf064, 0xf065, 0xf066, 0xf067, 159 0xf068, 0xf069, 0xf06a, 0xf06b, 0xf06c, 0xf06d, 0xf06e, 0xf06f, 160 0xf070, 0xf071, 0xf072, 0xf073, 0xf074, 0xf075, 0xf076, 0xf077, 161 0xf078, 0xf079, 0xf07a, 0xf07b, 0xf07c, 0xf07d, 0xf07e, 0xf07f, 162 0xf080, 0xf081, 0xf082, 0xf083, 0xf084, 0xf085, 0xf086, 0xf087, 163 0xf088, 0xf089, 0xf08a, 0xf08b, 0xf08c, 0xf08d, 0xf08e, 0xf08f, 164 0xf090, 0xf091, 0xf092, 0xf093, 0xf094, 0xf095, 0xf096, 0xf097, 165 0xf098, 0xf099, 0xf09a, 0xf09b, 0xf09c, 0xf09d, 0xf09e, 0xf09f, 166 0xf0a0, 0xf0a1, 0xf0a2, 0xf0a3, 0xf0a4, 0xf0a5, 0xf0a6, 0xf0a7, 167 0xf0a8, 0xf0a9, 0xf0aa, 0xf0ab, 0xf0ac, 0xf0ad, 0xf0ae, 0xf0af, 168 0xf0b0, 0xf0b1, 0xf0b2, 0xf0b3, 0xf0b4, 0xf0b5, 0xf0b6, 0xf0b7, 169 0xf0b8, 0xf0b9, 0xf0ba, 0xf0bb, 0xf0bc, 0xf0bd, 0xf0be, 0xf0bf, 170 0xf0c0, 0xf0c1, 0xf0c2, 0xf0c3, 0xf0c4, 0xf0c5, 0xf0c6, 0xf0c7, 171 0xf0c8, 0xf0c9, 0xf0ca, 0xf0cb, 0xf0cc, 0xf0cd, 0xf0ce, 0xf0cf, 172 0xf0d0, 0xf0d1, 0xf0d2, 0xf0d3, 0xf0d4, 0xf0d5, 0xf0d6, 0xf0d7, 173 0xf0d8, 0xf0d9, 0xf0da, 0xf0db, 0xf0dc, 0xf0dd, 0xf0de, 0xf0df, 174 0xf0e0, 0xf0e1, 0xf0e2, 0xf0e3, 0xf0e4, 0xf0e5, 0xf0e6, 0xf0e7, 175 0xf0e8, 0xf0e9, 0xf0ea, 0xf0eb, 0xf0ec, 0xf0ed, 0xf0ee, 0xf0ef, 176 0xf0f0, 0xf0f1, 0xf0f2, 0xf0f3, 0xf0f4, 0xf0f5, 0xf0f6, 0xf0f7, 177 0xf0f8, 0xf0f9, 0xf0fa, 0xf0fb, 0xf0fc, 0xf0fd, 0xf0fe, 0xf0ff 178 } 179 }; 180 181 /* The standard kernel character-to-font mappings are not invertible 182 -- this is just a best effort. */ 183 184 #define MAX_GLYPH 512 /* Max possible glyph value */ 185 186 static int inv_translate[MAX_NR_CONSOLES]; 187 188 struct uni_pagedir { 189 u16 **uni_pgdir[32]; 190 unsigned long refcount; 191 unsigned long sum; 192 unsigned char *inverse_translations[4]; 193 u16 *inverse_trans_unicode; 194 }; 195 196 static struct uni_pagedir *dflt; 197 198 static void set_inverse_transl(struct vc_data *conp, struct uni_pagedir *p, int i) 199 { 200 int j, glyph; 201 unsigned short *t = translations[i]; 202 unsigned char *q; 203 204 if (!p) return; 205 q = p->inverse_translations[i]; 206 207 if (!q) { 208 q = p->inverse_translations[i] = kmalloc(MAX_GLYPH, GFP_KERNEL); 209 if (!q) return; 210 } 211 memset(q, 0, MAX_GLYPH); 212 213 for (j = 0; j < E_TABSZ; j++) { 214 glyph = conv_uni_to_pc(conp, t[j]); 215 if (glyph >= 0 && glyph < MAX_GLYPH && q[glyph] < 32) { 216 /* prefer '-' above SHY etc. */ 217 q[glyph] = j; 218 } 219 } 220 } 221 222 static void set_inverse_trans_unicode(struct vc_data *conp, 223 struct uni_pagedir *p) 224 { 225 int i, j, k, glyph; 226 u16 **p1, *p2; 227 u16 *q; 228 229 if (!p) return; 230 q = p->inverse_trans_unicode; 231 if (!q) { 232 q = p->inverse_trans_unicode = 233 kmalloc(MAX_GLYPH * sizeof(u16), GFP_KERNEL); 234 if (!q) 235 return; 236 } 237 memset(q, 0, MAX_GLYPH * sizeof(u16)); 238 239 for (i = 0; i < 32; i++) { 240 p1 = p->uni_pgdir[i]; 241 if (!p1) 242 continue; 243 for (j = 0; j < 32; j++) { 244 p2 = p1[j]; 245 if (!p2) 246 continue; 247 for (k = 0; k < 64; k++) { 248 glyph = p2[k]; 249 if (glyph >= 0 && glyph < MAX_GLYPH 250 && q[glyph] < 32) 251 q[glyph] = (i << 11) + (j << 6) + k; 252 } 253 } 254 } 255 } 256 257 unsigned short *set_translate(int m, struct vc_data *vc) 258 { 259 inv_translate[vc->vc_num] = m; 260 return translations[m]; 261 } 262 263 /* 264 * Inverse translation is impossible for several reasons: 265 * 1. The font<->character maps are not 1-1. 266 * 2. The text may have been written while a different translation map 267 * was active. 268 * Still, it is now possible to a certain extent to cut and paste non-ASCII. 269 */ 270 u16 inverse_translate(struct vc_data *conp, int glyph, int use_unicode) 271 { 272 struct uni_pagedir *p; 273 int m; 274 if (glyph < 0 || glyph >= MAX_GLYPH) 275 return 0; 276 else { 277 p = *conp->vc_uni_pagedir_loc; 278 if (!p) 279 return glyph; 280 else if (use_unicode) { 281 if (!p->inverse_trans_unicode) 282 return glyph; 283 else 284 return p->inverse_trans_unicode[glyph]; 285 } else { 286 m = inv_translate[conp->vc_num]; 287 if (!p->inverse_translations[m]) 288 return glyph; 289 else 290 return p->inverse_translations[m][glyph]; 291 } 292 } 293 } 294 EXPORT_SYMBOL_GPL(inverse_translate); 295 296 static void update_user_maps(void) 297 { 298 int i; 299 struct uni_pagedir *p, *q = NULL; 300 301 for (i = 0; i < MAX_NR_CONSOLES; i++) { 302 if (!vc_cons_allocated(i)) 303 continue; 304 p = *vc_cons[i].d->vc_uni_pagedir_loc; 305 if (p && p != q) { 306 set_inverse_transl(vc_cons[i].d, p, USER_MAP); 307 set_inverse_trans_unicode(vc_cons[i].d, p); 308 q = p; 309 } 310 } 311 } 312 313 /* 314 * Load customizable translation table 315 * arg points to a 256 byte translation table. 316 * 317 * The "old" variants are for translation directly to font (using the 318 * 0xf000-0xf0ff "transparent" Unicodes) whereas the "new" variants set 319 * Unicodes explicitly. 320 */ 321 int con_set_trans_old(unsigned char __user * arg) 322 { 323 int i; 324 unsigned short inbuf[E_TABSZ]; 325 326 if (!access_ok(VERIFY_READ, arg, E_TABSZ)) 327 return -EFAULT; 328 329 for (i = 0; i < E_TABSZ ; i++) { 330 unsigned char uc; 331 __get_user(uc, arg+i); 332 inbuf[i] = UNI_DIRECT_BASE | uc; 333 } 334 335 console_lock(); 336 memcpy(translations[USER_MAP], inbuf, sizeof(inbuf)); 337 update_user_maps(); 338 console_unlock(); 339 return 0; 340 } 341 342 int con_get_trans_old(unsigned char __user * arg) 343 { 344 int i, ch; 345 unsigned short *p = translations[USER_MAP]; 346 unsigned char outbuf[E_TABSZ]; 347 348 if (!access_ok(VERIFY_WRITE, arg, E_TABSZ)) 349 return -EFAULT; 350 351 console_lock(); 352 for (i = 0; i < E_TABSZ ; i++) 353 { 354 ch = conv_uni_to_pc(vc_cons[fg_console].d, p[i]); 355 outbuf[i] = (ch & ~0xff) ? 0 : ch; 356 } 357 console_unlock(); 358 359 for (i = 0; i < E_TABSZ ; i++) 360 __put_user(outbuf[i], arg+i); 361 return 0; 362 } 363 364 int con_set_trans_new(ushort __user * arg) 365 { 366 int i; 367 unsigned short inbuf[E_TABSZ]; 368 369 if (!access_ok(VERIFY_READ, arg, E_TABSZ*sizeof(unsigned short))) 370 return -EFAULT; 371 372 for (i = 0; i < E_TABSZ ; i++) 373 __get_user(inbuf[i], arg+i); 374 375 console_lock(); 376 memcpy(translations[USER_MAP], inbuf, sizeof(inbuf)); 377 update_user_maps(); 378 console_unlock(); 379 return 0; 380 } 381 382 int con_get_trans_new(ushort __user * arg) 383 { 384 int i; 385 unsigned short outbuf[E_TABSZ]; 386 387 if (!access_ok(VERIFY_WRITE, arg, E_TABSZ*sizeof(unsigned short))) 388 return -EFAULT; 389 390 console_lock(); 391 memcpy(outbuf, translations[USER_MAP], sizeof(outbuf)); 392 console_unlock(); 393 394 for (i = 0; i < E_TABSZ ; i++) 395 __put_user(outbuf[i], arg+i); 396 return 0; 397 } 398 399 /* 400 * Unicode -> current font conversion 401 * 402 * A font has at most 512 chars, usually 256. 403 * But one font position may represent several Unicode chars. 404 * A hashtable is somewhat of a pain to deal with, so use a 405 * "paged table" instead. Simulation has shown the memory cost of 406 * this 3-level paged table scheme to be comparable to a hash table. 407 */ 408 409 extern u8 dfont_unicount[]; /* Defined in console_defmap.c */ 410 extern u16 dfont_unitable[]; 411 412 static void con_release_unimap(struct uni_pagedir *p) 413 { 414 u16 **p1; 415 int i, j; 416 417 if (p == dflt) dflt = NULL; 418 for (i = 0; i < 32; i++) { 419 p1 = p->uni_pgdir[i]; 420 if (p1 != NULL) { 421 for (j = 0; j < 32; j++) 422 kfree(p1[j]); 423 kfree(p1); 424 } 425 p->uni_pgdir[i] = NULL; 426 } 427 for (i = 0; i < 4; i++) { 428 kfree(p->inverse_translations[i]); 429 p->inverse_translations[i] = NULL; 430 } 431 kfree(p->inverse_trans_unicode); 432 p->inverse_trans_unicode = NULL; 433 } 434 435 /* Caller must hold the console lock */ 436 void con_free_unimap(struct vc_data *vc) 437 { 438 struct uni_pagedir *p; 439 440 p = *vc->vc_uni_pagedir_loc; 441 if (!p) 442 return; 443 *vc->vc_uni_pagedir_loc = NULL; 444 if (--p->refcount) 445 return; 446 con_release_unimap(p); 447 kfree(p); 448 } 449 450 static int con_unify_unimap(struct vc_data *conp, struct uni_pagedir *p) 451 { 452 int i, j, k; 453 struct uni_pagedir *q; 454 455 for (i = 0; i < MAX_NR_CONSOLES; i++) { 456 if (!vc_cons_allocated(i)) 457 continue; 458 q = *vc_cons[i].d->vc_uni_pagedir_loc; 459 if (!q || q == p || q->sum != p->sum) 460 continue; 461 for (j = 0; j < 32; j++) { 462 u16 **p1, **q1; 463 p1 = p->uni_pgdir[j]; q1 = q->uni_pgdir[j]; 464 if (!p1 && !q1) 465 continue; 466 if (!p1 || !q1) 467 break; 468 for (k = 0; k < 32; k++) { 469 if (!p1[k] && !q1[k]) 470 continue; 471 if (!p1[k] || !q1[k]) 472 break; 473 if (memcmp(p1[k], q1[k], 64*sizeof(u16))) 474 break; 475 } 476 if (k < 32) 477 break; 478 } 479 if (j == 32) { 480 q->refcount++; 481 *conp->vc_uni_pagedir_loc = q; 482 con_release_unimap(p); 483 kfree(p); 484 return 1; 485 } 486 } 487 return 0; 488 } 489 490 static int 491 con_insert_unipair(struct uni_pagedir *p, u_short unicode, u_short fontpos) 492 { 493 int i, n; 494 u16 **p1, *p2; 495 496 p1 = p->uni_pgdir[n = unicode >> 11]; 497 if (!p1) { 498 p1 = p->uni_pgdir[n] = kmalloc(32*sizeof(u16 *), GFP_KERNEL); 499 if (!p1) return -ENOMEM; 500 for (i = 0; i < 32; i++) 501 p1[i] = NULL; 502 } 503 504 p2 = p1[n = (unicode >> 6) & 0x1f]; 505 if (!p2) { 506 p2 = p1[n] = kmalloc(64*sizeof(u16), GFP_KERNEL); 507 if (!p2) return -ENOMEM; 508 memset(p2, 0xff, 64*sizeof(u16)); /* No glyphs for the characters (yet) */ 509 } 510 511 p2[unicode & 0x3f] = fontpos; 512 513 p->sum += (fontpos << 20) + unicode; 514 515 return 0; 516 } 517 518 /* Caller must hold the lock */ 519 static int con_do_clear_unimap(struct vc_data *vc) 520 { 521 struct uni_pagedir *p, *q; 522 523 p = *vc->vc_uni_pagedir_loc; 524 if (!p || --p->refcount) { 525 q = kzalloc(sizeof(*p), GFP_KERNEL); 526 if (!q) { 527 if (p) 528 p->refcount++; 529 return -ENOMEM; 530 } 531 q->refcount=1; 532 *vc->vc_uni_pagedir_loc = q; 533 } else { 534 if (p == dflt) dflt = NULL; 535 p->refcount++; 536 p->sum = 0; 537 con_release_unimap(p); 538 } 539 return 0; 540 } 541 542 int con_clear_unimap(struct vc_data *vc) 543 { 544 int ret; 545 console_lock(); 546 ret = con_do_clear_unimap(vc); 547 console_unlock(); 548 return ret; 549 } 550 551 int con_set_unimap(struct vc_data *vc, ushort ct, struct unipair __user *list) 552 { 553 int err = 0, err1, i; 554 struct uni_pagedir *p, *q; 555 struct unipair *unilist, *plist; 556 557 if (!ct) 558 return 0; 559 560 unilist = kmalloc_array(ct, sizeof(struct unipair), GFP_KERNEL); 561 if (!unilist) 562 return -ENOMEM; 563 564 for (i = ct, plist = unilist; i; i--, plist++, list++) { 565 __get_user(plist->unicode, &list->unicode); 566 __get_user(plist->fontpos, &list->fontpos); 567 } 568 569 console_lock(); 570 571 /* Save original vc_unipagdir_loc in case we allocate a new one */ 572 p = *vc->vc_uni_pagedir_loc; 573 574 if (!p) { 575 err = -EINVAL; 576 577 goto out_unlock; 578 } 579 580 if (p->refcount > 1) { 581 int j, k; 582 u16 **p1, *p2, l; 583 584 err1 = con_do_clear_unimap(vc); 585 if (err1) { 586 err = err1; 587 goto out_unlock; 588 } 589 590 /* 591 * Since refcount was > 1, con_clear_unimap() allocated a 592 * a new uni_pagedir for this vc. Re: p != q 593 */ 594 q = *vc->vc_uni_pagedir_loc; 595 596 /* 597 * uni_pgdir is a 32*32*64 table with rows allocated 598 * when its first entry is added. The unicode value must 599 * still be incremented for empty rows. We are copying 600 * entries from "p" (old) to "q" (new). 601 */ 602 l = 0; /* unicode value */ 603 for (i = 0; i < 32; i++) { 604 p1 = p->uni_pgdir[i]; 605 if (p1) 606 for (j = 0; j < 32; j++) { 607 p2 = p1[j]; 608 if (p2) { 609 for (k = 0; k < 64; k++, l++) 610 if (p2[k] != 0xffff) { 611 /* 612 * Found one, copy entry for unicode 613 * l with fontpos value p2[k]. 614 */ 615 err1 = con_insert_unipair(q, l, p2[k]); 616 if (err1) { 617 p->refcount++; 618 *vc->vc_uni_pagedir_loc = p; 619 con_release_unimap(q); 620 kfree(q); 621 err = err1; 622 goto out_unlock; 623 } 624 } 625 } else { 626 /* Account for row of 64 empty entries */ 627 l += 64; 628 } 629 } 630 else 631 /* Account for empty table */ 632 l += 32 * 64; 633 } 634 635 /* 636 * Finished copying font table, set vc_uni_pagedir to new table 637 */ 638 p = q; 639 } else if (p == dflt) { 640 dflt = NULL; 641 } 642 643 /* 644 * Insert user specified unicode pairs into new table. 645 */ 646 for (plist = unilist; ct; ct--, plist++) { 647 err1 = con_insert_unipair(p, plist->unicode, plist->fontpos); 648 if (err1) 649 err = err1; 650 } 651 652 /* 653 * Merge with fontmaps of any other virtual consoles. 654 */ 655 if (con_unify_unimap(vc, p)) 656 goto out_unlock; 657 658 for (i = 0; i <= 3; i++) 659 set_inverse_transl(vc, p, i); /* Update inverse translations */ 660 set_inverse_trans_unicode(vc, p); 661 662 out_unlock: 663 console_unlock(); 664 kfree(unilist); 665 return err; 666 } 667 668 /** 669 * con_set_default_unimap - set default unicode map 670 * @vc: the console we are updating 671 * 672 * Loads the unimap for the hardware font, as defined in uni_hash.tbl. 673 * The representation used was the most compact I could come up 674 * with. This routine is executed at video setup, and when the 675 * PIO_FONTRESET ioctl is called. 676 * 677 * The caller must hold the console lock 678 */ 679 int con_set_default_unimap(struct vc_data *vc) 680 { 681 int i, j, err = 0, err1; 682 u16 *q; 683 struct uni_pagedir *p; 684 685 if (dflt) { 686 p = *vc->vc_uni_pagedir_loc; 687 if (p == dflt) 688 return 0; 689 690 dflt->refcount++; 691 *vc->vc_uni_pagedir_loc = dflt; 692 if (p && !--p->refcount) { 693 con_release_unimap(p); 694 kfree(p); 695 } 696 return 0; 697 } 698 699 /* The default font is always 256 characters */ 700 701 err = con_do_clear_unimap(vc); 702 if (err) 703 return err; 704 705 p = *vc->vc_uni_pagedir_loc; 706 q = dfont_unitable; 707 708 for (i = 0; i < 256; i++) 709 for (j = dfont_unicount[i]; j; j--) { 710 err1 = con_insert_unipair(p, *(q++), i); 711 if (err1) 712 err = err1; 713 } 714 715 if (con_unify_unimap(vc, p)) { 716 dflt = *vc->vc_uni_pagedir_loc; 717 return err; 718 } 719 720 for (i = 0; i <= 3; i++) 721 set_inverse_transl(vc, p, i); /* Update all inverse translations */ 722 set_inverse_trans_unicode(vc, p); 723 dflt = p; 724 return err; 725 } 726 EXPORT_SYMBOL(con_set_default_unimap); 727 728 /** 729 * con_copy_unimap - copy unimap between two vts 730 * @dst_vc: target 731 * @src_vt: source 732 * 733 * The caller must hold the console lock when invoking this method 734 */ 735 int con_copy_unimap(struct vc_data *dst_vc, struct vc_data *src_vc) 736 { 737 struct uni_pagedir *q; 738 739 if (!*src_vc->vc_uni_pagedir_loc) 740 return -EINVAL; 741 if (*dst_vc->vc_uni_pagedir_loc == *src_vc->vc_uni_pagedir_loc) 742 return 0; 743 con_free_unimap(dst_vc); 744 q = *src_vc->vc_uni_pagedir_loc; 745 q->refcount++; 746 *dst_vc->vc_uni_pagedir_loc = q; 747 return 0; 748 } 749 EXPORT_SYMBOL(con_copy_unimap); 750 751 /** 752 * con_get_unimap - get the unicode map 753 * @vc: the console to read from 754 * 755 * Read the console unicode data for this console. Called from the ioctl 756 * handlers. 757 */ 758 int con_get_unimap(struct vc_data *vc, ushort ct, ushort __user *uct, struct unipair __user *list) 759 { 760 int i, j, k; 761 ushort ect; 762 u16 **p1, *p2; 763 struct uni_pagedir *p; 764 struct unipair *unilist, *plist; 765 766 unilist = kmalloc_array(ct, sizeof(struct unipair), GFP_KERNEL); 767 if (!unilist) 768 return -ENOMEM; 769 770 console_lock(); 771 772 ect = 0; 773 if (*vc->vc_uni_pagedir_loc) { 774 p = *vc->vc_uni_pagedir_loc; 775 for (i = 0; i < 32; i++) { 776 p1 = p->uni_pgdir[i]; 777 if (p1) 778 for (j = 0; j < 32; j++) { 779 p2 = *(p1++); 780 if (p2) 781 for (k = 0; k < 64; k++, p2++) { 782 if (*p2 >= MAX_GLYPH) 783 continue; 784 if (ect < ct) { 785 unilist[ect].unicode = 786 (i<<11)+(j<<6)+k; 787 unilist[ect].fontpos = *p2; 788 } 789 ect++; 790 } 791 } 792 } 793 } 794 console_unlock(); 795 for (i = min(ect, ct), plist = unilist; i; i--, list++, plist++) { 796 __put_user(plist->unicode, &list->unicode); 797 __put_user(plist->fontpos, &list->fontpos); 798 } 799 __put_user(ect, uct); 800 kfree(unilist); 801 return ((ect <= ct) ? 0 : -ENOMEM); 802 } 803 804 /* 805 * Always use USER_MAP. These functions are used by the keyboard, 806 * which shouldn't be affected by G0/G1 switching, etc. 807 * If the user map still contains default values, i.e. the 808 * direct-to-font mapping, then assume user is using Latin1. 809 * 810 * FIXME: at some point we need to decide if we want to lock the table 811 * update element itself via the keyboard_event_lock for consistency with the 812 * keyboard driver as well as the consoles 813 */ 814 /* may be called during an interrupt */ 815 u32 conv_8bit_to_uni(unsigned char c) 816 { 817 unsigned short uni = translations[USER_MAP][c]; 818 return uni == (0xf000 | c) ? c : uni; 819 } 820 821 int conv_uni_to_8bit(u32 uni) 822 { 823 int c; 824 for (c = 0; c < 0x100; c++) 825 if (translations[USER_MAP][c] == uni || 826 (translations[USER_MAP][c] == (c | 0xf000) && uni == c)) 827 return c; 828 return -1; 829 } 830 831 int 832 conv_uni_to_pc(struct vc_data *conp, long ucs) 833 { 834 int h; 835 u16 **p1, *p2; 836 struct uni_pagedir *p; 837 838 /* Only 16-bit codes supported at this time */ 839 if (ucs > 0xffff) 840 return -4; /* Not found */ 841 else if (ucs < 0x20) 842 return -1; /* Not a printable character */ 843 else if (ucs == 0xfeff || (ucs >= 0x200b && ucs <= 0x200f)) 844 return -2; /* Zero-width space */ 845 /* 846 * UNI_DIRECT_BASE indicates the start of the region in the User Zone 847 * which always has a 1:1 mapping to the currently loaded font. The 848 * UNI_DIRECT_MASK indicates the bit span of the region. 849 */ 850 else if ((ucs & ~UNI_DIRECT_MASK) == UNI_DIRECT_BASE) 851 return ucs & UNI_DIRECT_MASK; 852 853 if (!*conp->vc_uni_pagedir_loc) 854 return -3; 855 856 p = *conp->vc_uni_pagedir_loc; 857 if ((p1 = p->uni_pgdir[ucs >> 11]) && 858 (p2 = p1[(ucs >> 6) & 0x1f]) && 859 (h = p2[ucs & 0x3f]) < MAX_GLYPH) 860 return h; 861 862 return -4; /* not found */ 863 } 864 865 /* 866 * This is called at sys_setup time, after memory and the console are 867 * initialized. It must be possible to call kmalloc(..., GFP_KERNEL) 868 * from this function, hence the call from sys_setup. 869 */ 870 void __init 871 console_map_init(void) 872 { 873 int i; 874 875 for (i = 0; i < MAX_NR_CONSOLES; i++) 876 if (vc_cons_allocated(i) && !*vc_cons[i].d->vc_uni_pagedir_loc) 877 con_set_default_unimap(vc_cons[i].d); 878 } 879 880