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