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