kernel/drivers/tty/vt/consolemap.c

   1 /*
   2  * consolemap.c
   3  *
   4  * Mapping from internal code (such as Latin-1 or Unicode or IBM PC code)
   5  * to font positions.
   6  *
   7  * aeb, 950210
   8  *
   9  * Support for multiple unimaps by Jakub Jelinek <jj@ultra.linux.cz>, July 1998
  10  *
  11  * Fix bug in inverse translation. Stanislav Voronyi <stas@cnti.uanet.kharkov.ua>, Dec 1998
  12  */
  13
  14 #include <linux/module.h>
  15 #include <linux/kd.h>
  16 #include <linux/errno.h>
  17 #include <linux/mm.h>
  18 #include <linux/slab.h>
  19 #include <linux/init.h>
  20 #include <linux/tty.h>
  21 #include <asm/uaccess.h>
  22 #include <linux/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 };
 183
 184 static struct uni_pagedir *dflt;
 185
 186 static 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] = kmalloc(MAX_GLYPH, GFP_KERNEL);
 197                 if (!q) return;
 198         }
 199         memset(q, 0, MAX_GLYPH);
 200
 201         for (j = 0; j < E_TABSZ; j++) {
 202                 glyph = conv_uni_to_pc(conp, t[j]);
 203                 if (glyph >= 0 && glyph < MAX_GLYPH && q[glyph] < 32) {
 204                         /* prefer '-' above SHY etc. */
 205                         q[glyph] = j;
 206                 }
 207         }
 208 }
 209
 210 static void set_inverse_trans_unicode(struct vc_data *conp,
 211                                       struct uni_pagedir *p)
 212 {
 213         int i, j, k, glyph;
 214         u16 **p1, *p2;
 215         u16 *q;
 216
 217         if (!p) return;
 218         q = p->inverse_trans_unicode;
 219         if (!q) {
 220                 q = p->inverse_trans_unicode =
 221                         kmalloc(MAX_GLYPH * sizeof(u16), GFP_KERNEL);
 222                 if (!q)
 223                         return;
 224         }
 225         memset(q, 0, MAX_GLYPH * sizeof(u16));
 226
 227         for (i = 0; i < 32; i++) {
 228                 p1 = p->uni_pgdir[i];
 229                 if (!p1)
 230                         continue;
 231                 for (j = 0; j < 32; j++) {
 232                         p2 = p1[j];
 233                         if (!p2)
 234                                 continue;
 235                         for (k = 0; k < 64; k++) {
 236                                 glyph = p2[k];
 237                                 if (glyph >= 0 && glyph < MAX_GLYPH
 238                                                && q[glyph] < 32)
 239                                         q[glyph] = (i << 11) + (j << 6) + k;
 240                         }
 241                 }
 242         }
 243 }
 244
 245 unsigned short *set_translate(int m, struct vc_data *vc)
 246 {
 247         inv_translate[vc->vc_num] = m;
 248         return translations[m];
 249 }
 250
 251 /*
 252  * Inverse translation is impossible for several reasons:
 253  * 1. The font<->character maps are not 1-1.
 254  * 2. The text may have been written while a different translation map
 255  *    was active.
 256  * Still, it is now possible to a certain extent to cut and paste non-ASCII.
 257  */
 258 u16 inverse_translate(struct vc_data *conp, int glyph, int use_unicode)
 259 {
 260         struct uni_pagedir *p;
 261         int m;
 262         if (glyph < 0 || glyph >= MAX_GLYPH)
 263                 return 0;
 264         else {
 265                 p = *conp->vc_uni_pagedir_loc;
 266                 if (!p)
 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 }
 282 EXPORT_SYMBOL_GPL(inverse_translate);
 283
 284 static void update_user_maps(void)
 285 {
 286         int i;
 287         struct uni_pagedir *p, *q = NULL;
 288
 289         for (i = 0; i < MAX_NR_CONSOLES; i++) {
 290                 if (!vc_cons_allocated(i))
 291                         continue;
 292                 p = *vc_cons[i].d->vc_uni_pagedir_loc;
 293                 if (p && p != q) {
 294                         set_inverse_transl(vc_cons[i].d, p, USER_MAP);
 295                         set_inverse_trans_unicode(vc_cons[i].d, p);
 296                         q = p;
 297                 }
 298         }
 299 }
 300
 301 /*
 302  * Load customizable translation table
 303  * arg points to a 256 byte translation table.
 304  *
 305  * The "old" variants are for translation directly to font (using the
 306  * 0xf000-0xf0ff "transparent" Unicodes) whereas the "new" variants set
 307  * Unicodes explicitly.
 308  */
 309 int con_set_trans_old(unsigned char __user * arg)
 310 {
 311         int i;
 312         unsigned short *p = translations[USER_MAP];
 313
 314         if (!access_ok(VERIFY_READ, arg, E_TABSZ))
 315                 return -EFAULT;
 316
 317         console_lock();
 318         for (i=0; i<E_TABSZ ; i++) {
 319                 unsigned char uc;
 320                 __get_user(uc, arg+i);
 321                 p[i] = UNI_DIRECT_BASE | uc;
 322         }
 323
 324         update_user_maps();
 325         console_unlock();
 326         return 0;
 327 }
 328
 329 int con_get_trans_old(unsigned char __user * arg)
 330 {
 331         int i, ch;
 332         unsigned short *p = translations[USER_MAP];
 333
 334         if (!access_ok(VERIFY_WRITE, arg, E_TABSZ))
 335                 return -EFAULT;
 336
 337         console_lock();
 338         for (i=0; i<E_TABSZ ; i++)
 339         {
 340                 ch = conv_uni_to_pc(vc_cons[fg_console].d, p[i]);
 341                 __put_user((ch & ~0xff) ? 0 : ch, arg+i);
 342         }
 343         console_unlock();
 344         return 0;
 345 }
 346
 347 int con_set_trans_new(ushort __user * arg)
 348 {
 349         int i;
 350         unsigned short *p = translations[USER_MAP];
 351
 352         if (!access_ok(VERIFY_READ, arg, E_TABSZ*sizeof(unsigned short)))
 353                 return -EFAULT;
 354
 355         console_lock();
 356         for (i=0; i<E_TABSZ ; i++) {
 357                 unsigned short us;
 358                 __get_user(us, arg+i);
 359                 p[i] = us;
 360         }
 361
 362         update_user_maps();
 363         console_unlock();
 364         return 0;
 365 }
 366
 367 int con_get_trans_new(ushort __user * arg)
 368 {
 369         int i;
 370         unsigned short *p = translations[USER_MAP];
 371
 372         if (!access_ok(VERIFY_WRITE, arg, E_TABSZ*sizeof(unsigned short)))
 373                 return -EFAULT;
 374
 375         console_lock();
 376         for (i=0; i<E_TABSZ ; i++)
 377           __put_user(p[i], arg+i);
 378         console_unlock();
 379
 380         return 0;
 381 }
 382
 383 /*
 384  * Unicode -> current font conversion
 385  *
 386  * A font has at most 512 chars, usually 256.
 387  * But one font position may represent several Unicode chars.
 388  * A hashtable is somewhat of a pain to deal with, so use a
 389  * "paged table" instead.  Simulation has shown the memory cost of
 390  * this 3-level paged table scheme to be comparable to a hash table.
 391  */
 392
 393 extern u8 dfont_unicount[];     /* Defined in console_defmap.c */
 394 extern u16 dfont_unitable[];
 395
 396 static void con_release_unimap(struct uni_pagedir *p)
 397 {
 398         u16 **p1;
 399         int i, j;
 400
 401         if (p == dflt) dflt = NULL;
 402         for (i = 0; i < 32; i++) {
 403                 p1 = p->uni_pgdir[i];
 404                 if (p1 != NULL) {
 405                         for (j = 0; j < 32; j++)
 406                                 kfree(p1[j]);
 407                         kfree(p1);
 408                 }
 409                 p->uni_pgdir[i] = NULL;
 410         }
 411         for (i = 0; i < 4; i++) {
 412                 kfree(p->inverse_translations[i]);
 413                 p->inverse_translations[i] = NULL;
 414         }
 415         kfree(p->inverse_trans_unicode);
 416         p->inverse_trans_unicode = NULL;
 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 = *vc->vc_uni_pagedir_loc;
 425         if (!p)
 426                 return;
 427         *vc->vc_uni_pagedir_loc = NULL;
 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 = *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 = 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         p1 = p->uni_pgdir[n = unicode >> 11];
 481         if (!p1) {
 482                 p1 = p->uni_pgdir[n] = kmalloc(32*sizeof(u16 *), GFP_KERNEL);
 483                 if (!p1) return -ENOMEM;
 484                 for (i = 0; i < 32; i++)
 485                         p1[i] = NULL;
 486         }
 487
 488         p2 = p1[n = (unicode >> 6) & 0x1f];
 489         if (!p2) {
 490                 p2 = p1[n] = kmalloc(64*sizeof(u16), GFP_KERNEL);
 491                 if (!p2) return -ENOMEM;
 492                 memset(p2, 0xff, 64*sizeof(u16)); /* No glyphs for the characters (yet) */
 493         }
 494
 495         p2[unicode & 0x3f] = fontpos;
 496
 497         p->sum += (fontpos << 20) + unicode;
 498
 499         return 0;
 500 }
 501
 502 /* ui is a leftover from using a hashtable, but might be used again
 503    Caller must hold the lock */
 504 static int con_do_clear_unimap(struct vc_data *vc, struct unimapinit *ui)
 505 {
 506         struct uni_pagedir *p, *q;
 507
 508         p = *vc->vc_uni_pagedir_loc;
 509         if (!p || --p->refcount) {
 510                 q = kzalloc(sizeof(*p), GFP_KERNEL);
 511                 if (!q) {
 512                         if (p)
 513                                 p->refcount++;
 514                         return -ENOMEM;
 515                 }
 516                 q->refcount=1;
 517                 *vc->vc_uni_pagedir_loc = q;
 518         } else {
 519                 if (p == dflt) dflt = NULL;
 520                 p->refcount++;
 521                 p->sum = 0;
 522                 con_release_unimap(p);
 523         }
 524         return 0;
 525 }
 526
 527 int con_clear_unimap(struct vc_data *vc, struct unimapinit *ui)
 528 {
 529         int ret;
 530         console_lock();
 531         ret = con_do_clear_unimap(vc, ui);
 532         console_unlock();
 533         return ret;
 534 }
 535
 536 int con_set_unimap(struct vc_data *vc, ushort ct, struct unipair __user *list)
 537 {
 538         int err = 0, err1, i;
 539         struct uni_pagedir *p, *q;
 540
 541         if (!ct)
 542                 return 0;
 543
 544         console_lock();
 545
 546         /* Save original vc_unipagdir_loc in case we allocate a new one */
 547         p = *vc->vc_uni_pagedir_loc;
 548
 549         if (!p) {
 550                 err = -EINVAL;
 551
 552                 goto out_unlock;
 553         }
 554
 555         if (p->refcount > 1) {
 556                 int j, k;
 557                 u16 **p1, *p2, l;
 558
 559                 err1 = con_do_clear_unimap(vc, NULL);
 560                 if (err1) {
 561                         console_unlock();
 562                         return err1;
 563                 }
 564
 565                 /*
 566                  * Since refcount was > 1, con_clear_unimap() allocated a
 567                  * a new uni_pagedir for this vc.  Re: p != q
 568                  */
 569                 q = *vc->vc_uni_pagedir_loc;
 570
 571                 /*
 572                  * uni_pgdir is a 32*32*64 table with rows allocated
 573                  * when its first entry is added.  The unicode value must
 574                  * still be incremented for empty rows.  We are copying
 575                  * entries from "p" (old) to "q" (new).
 576                  */
 577                 l = 0;          /* unicode value */
 578                 for (i = 0; i < 32; i++) {
 579                 p1 = p->uni_pgdir[i];
 580                 if (p1)
 581                         for (j = 0; j < 32; j++) {
 582                         p2 = p1[j];
 583                         if (p2) {
 584                                 for (k = 0; k < 64; k++, l++)
 585                                 if (p2[k] != 0xffff) {
 586                                         /*
 587                                          * Found one, copy entry for unicode
 588                                          * l with fontpos value p2[k].
 589                                          */
 590                                         err1 = con_insert_unipair(q, l, p2[k]);
 591                                         if (err1) {
 592                                                 p->refcount++;
 593                                                 *vc->vc_uni_pagedir_loc = p;
 594                                                 con_release_unimap(q);
 595                                                 kfree(q);
 596                                                 console_unlock();
 597                                                 return err1;
 598                                         }
 599                                 }
 600                         } else {
 601                                 /* Account for row of 64 empty entries */
 602                                 l += 64;
 603                         }
 604                 }
 605                 else
 606                         /* Account for empty table */
 607                         l += 32 * 64;
 608                 }
 609
 610                 /*
 611                  * Finished copying font table, set vc_uni_pagedir to new table
 612                  */
 613                 p = q;
 614         } else if (p == dflt) {
 615                 dflt = NULL;
 616         }
 617
 618         /*
 619          * Insert user specified unicode pairs into new table.
 620          */
 621         while (ct--) {
 622                 unsigned short unicode, fontpos;
 623                 __get_user(unicode, &list->unicode);
 624                 __get_user(fontpos, &list->fontpos);
 625                 if ((err1 = con_insert_unipair(p, unicode,fontpos)) != 0)
 626                         err = err1;
 627                 list++;
 628         }
 629
 630         /*
 631          * Merge with fontmaps of any other virtual consoles.
 632          */
 633         if (con_unify_unimap(vc, p)) {
 634                 console_unlock();
 635                 return err;
 636         }
 637
 638         for (i = 0; i <= 3; i++)
 639                 set_inverse_transl(vc, p, i); /* Update inverse translations */
 640         set_inverse_trans_unicode(vc, p);
 641
 642 out_unlock:
 643         console_unlock();
 644         return err;
 645 }
 646
 647 /**
 648  *      con_set_default_unimap  -       set default unicode map
 649  *      @vc: the console we are updating
 650  *
 651  *      Loads the unimap for the hardware font, as defined in uni_hash.tbl.
 652  *      The representation used was the most compact I could come up
 653  *      with.  This routine is executed at video setup, and when the
 654  *      PIO_FONTRESET ioctl is called.
 655  *
 656  *      The caller must hold the console lock
 657  */
 658 int con_set_default_unimap(struct vc_data *vc)
 659 {
 660         int i, j, err = 0, err1;
 661         u16 *q;
 662         struct uni_pagedir *p;
 663
 664         if (dflt) {
 665                 p = *vc->vc_uni_pagedir_loc;
 666                 if (p == dflt)
 667                         return 0;
 668
 669                 dflt->refcount++;
 670                 *vc->vc_uni_pagedir_loc = dflt;
 671                 if (p && !--p->refcount) {
 672                         con_release_unimap(p);
 673                         kfree(p);
 674                 }
 675                 return 0;
 676         }
 677
 678         /* The default font is always 256 characters */
 679
 680         err = con_do_clear_unimap(vc, NULL);
 681         if (err)
 682                 return err;
 683
 684         p = *vc->vc_uni_pagedir_loc;
 685         q = dfont_unitable;
 686
 687         for (i = 0; i < 256; i++)
 688                 for (j = dfont_unicount[i]; j; j--) {
 689                         err1 = con_insert_unipair(p, *(q++), i);
 690                         if (err1)
 691                                 err = err1;
 692                 }
 693
 694         if (con_unify_unimap(vc, p)) {
 695                 dflt = *vc->vc_uni_pagedir_loc;
 696                 return err;
 697         }
 698
 699         for (i = 0; i <= 3; i++)
 700                 set_inverse_transl(vc, p, i);   /* Update all inverse translations */
 701         set_inverse_trans_unicode(vc, p);
 702         dflt = p;
 703         return err;
 704 }
 705 EXPORT_SYMBOL(con_set_default_unimap);
 706
 707 /**
 708  *      con_copy_unimap         -       copy unimap between two vts
 709  *      @dst_vc: target
 710  *      @src_vt: source
 711  *
 712  *      The caller must hold the console lock when invoking this method
 713  */
 714 int con_copy_unimap(struct vc_data *dst_vc, struct vc_data *src_vc)
 715 {
 716         struct uni_pagedir *q;
 717
 718         if (!*src_vc->vc_uni_pagedir_loc)
 719                 return -EINVAL;
 720         if (*dst_vc->vc_uni_pagedir_loc == *src_vc->vc_uni_pagedir_loc)
 721                 return 0;
 722         con_free_unimap(dst_vc);
 723         q = *src_vc->vc_uni_pagedir_loc;
 724         q->refcount++;
 725         *dst_vc->vc_uni_pagedir_loc = q;
 726         return 0;
 727 }
 728 EXPORT_SYMBOL(con_copy_unimap);
 729
 730 /**
 731  *      con_get_unimap          -       get the unicode map
 732  *      @vc: the console to read from
 733  *
 734  *      Read the console unicode data for this console. Called from the ioctl
 735  *      handlers.
 736  */
 737 int con_get_unimap(struct vc_data *vc, ushort ct, ushort __user *uct, struct unipair __user *list)
 738 {
 739         int i, j, k, ect;
 740         u16 **p1, *p2;
 741         struct uni_pagedir *p;
 742
 743         console_lock();
 744
 745         ect = 0;
 746         if (*vc->vc_uni_pagedir_loc) {
 747                 p = *vc->vc_uni_pagedir_loc;
 748                 for (i = 0; i < 32; i++) {
 749                 p1 = p->uni_pgdir[i];
 750                 if (p1)
 751                         for (j = 0; j < 32; j++) {
 752                         p2 = *(p1++);
 753                         if (p2)
 754                                 for (k = 0; k < 64; k++) {
 755                                         if (*p2 < MAX_GLYPH && ect++ < ct) {
 756                                                 __put_user((u_short)((i<<11)+(j<<6)+k),
 757                                                            &list->unicode);
 758                                                 __put_user((u_short) *p2,
 759                                                            &list->fontpos);
 760                                                 list++;
 761                                         }
 762                                         p2++;
 763                                 }
 764                         }
 765                 }
 766         }
 767         __put_user(ect, uct);
 768         console_unlock();
 769         return ((ect <= ct) ? 0 : -ENOMEM);
 770 }
 771
 772 /*
 773  * Always use USER_MAP. These functions are used by the keyboard,
 774  * which shouldn't be affected by G0/G1 switching, etc.
 775  * If the user map still contains default values, i.e. the
 776  * direct-to-font mapping, then assume user is using Latin1.
 777  *
 778  * FIXME: at some point we need to decide if we want to lock the table
 779  * update element itself via the keyboard_event_lock for consistency with the
 780  * keyboard driver as well as the consoles
 781  */
 782 /* may be called during an interrupt */
 783 u32 conv_8bit_to_uni(unsigned char c)
 784 {
 785         unsigned short uni = translations[USER_MAP][c];
 786         return uni == (0xf000 | c) ? c : uni;
 787 }
 788
 789 int conv_uni_to_8bit(u32 uni)
 790 {
 791         int c;
 792         for (c = 0; c < 0x100; c++)
 793                 if (translations[USER_MAP][c] == uni ||
 794                    (translations[USER_MAP][c] == (c | 0xf000) && uni == c))
 795                         return c;
 796         return -1;
 797 }
 798
 799 int
 800 conv_uni_to_pc(struct vc_data *conp, long ucs)
 801 {
 802         int h;
 803         u16 **p1, *p2;
 804         struct uni_pagedir *p;
 805
 806         /* Only 16-bit codes supported at this time */
 807         if (ucs > 0xffff)
 808                 return -4;              /* Not found */
 809         else if (ucs < 0x20)
 810                 return -1;              /* Not a printable character */
 811         else if (ucs == 0xfeff || (ucs >= 0x200b && ucs <= 0x200f))
 812                 return -2;                      /* Zero-width space */
 813         /*
 814          * UNI_DIRECT_BASE indicates the start of the region in the User Zone
 815          * which always has a 1:1 mapping to the currently loaded font.  The
 816          * UNI_DIRECT_MASK indicates the bit span of the region.
 817          */
 818         else if ((ucs & ~UNI_DIRECT_MASK) == UNI_DIRECT_BASE)
 819                 return ucs & UNI_DIRECT_MASK;
 820
 821         if (!*conp->vc_uni_pagedir_loc)
 822                 return -3;
 823
 824         p = *conp->vc_uni_pagedir_loc;
 825         if ((p1 = p->uni_pgdir[ucs >> 11]) &&
 826             (p2 = p1[(ucs >> 6) & 0x1f]) &&
 827             (h = p2[ucs & 0x3f]) < MAX_GLYPH)
 828                 return h;
 829
 830         return -4;              /* not found */
 831 }
 832
 833 /*
 834  * This is called at sys_setup time, after memory and the console are
 835  * initialized.  It must be possible to call kmalloc(..., GFP_KERNEL)
 836  * from this function, hence the call from sys_setup.
 837  */
 838 void __init
 839 console_map_init(void)
 840 {
 841         int i;
 842
 843         for (i = 0; i < MAX_NR_CONSOLES; i++)
 844                 if (vc_cons_allocated(i) && !*vc_cons[i].d->vc_uni_pagedir_loc)
 845                         con_set_default_unimap(vc_cons[i].d);
 846 }
 847