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