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 /* Caller must hold the lock */
 503 static int con_do_clear_unimap(struct vc_data *vc)
 504 {
 505         struct uni_pagedir *p, *q;
 506
 507         p = *vc->vc_uni_pagedir_loc;
 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 = 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)
 527 {
 528         int ret;
 529         console_lock();
 530         ret = con_do_clear_unimap(vc);
 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         if (!ct)
 541                 return 0;
 542
 543         console_lock();
 544
 545         /* Save original vc_unipagdir_loc in case we allocate a new one */
 546         p = *vc->vc_uni_pagedir_loc;
 547
 548         if (!p) {
 549                 err = -EINVAL;
 550
 551                 goto out_unlock;
 552         }
 553
 554         if (p->refcount > 1) {
 555                 int j, k;
 556                 u16 **p1, *p2, l;
 557
 558                 err1 = con_do_clear_unimap(vc);
 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 = *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                 p1 = p->uni_pgdir[i];
 579                 if (p1)
 580                         for (j = 0; j < 32; j++) {
 581                         p2 = p1[j];
 582                         if (p2) {
 583                                 for (k = 0; k < 64; k++, l++)
 584                                 if (p2[k] != 0xffff) {
 585                                         /*
 586                                          * Found one, copy entry for unicode
 587                                          * l with fontpos value p2[k].
 588                                          */
 589                                         err1 = con_insert_unipair(q, l, p2[k]);
 590                                         if (err1) {
 591                                                 p->refcount++;
 592                                                 *vc->vc_uni_pagedir_loc = p;
 593                                                 con_release_unimap(q);
 594                                                 kfree(q);
 595                                                 console_unlock();
 596                                                 return err1;
 597                                         }
 598                                 }
 599                         } else {
 600                                 /* Account for row of 64 empty entries */
 601                                 l += 64;
 602                         }
 603                 }
 604                 else
 605                         /* Account for empty table */
 606                         l += 32 * 64;
 607                 }
 608
 609                 /*
 610                  * Finished copying font table, set vc_uni_pagedir to new table
 611                  */
 612                 p = q;
 613         } else if (p == dflt) {
 614                 dflt = NULL;
 615         }
 616
 617         /*
 618          * Insert user specified unicode pairs into new table.
 619          */
 620         while (ct--) {
 621                 unsigned short unicode, fontpos;
 622                 __get_user(unicode, &list->unicode);
 623                 __get_user(fontpos, &list->fontpos);
 624                 if ((err1 = con_insert_unipair(p, unicode,fontpos)) != 0)
 625                         err = err1;
 626                 list++;
 627         }
 628
 629         /*
 630          * Merge with fontmaps of any other virtual consoles.
 631          */
 632         if (con_unify_unimap(vc, p)) {
 633                 console_unlock();
 634                 return err;
 635         }
 636
 637         for (i = 0; i <= 3; i++)
 638                 set_inverse_transl(vc, p, i); /* Update inverse translations */
 639         set_inverse_trans_unicode(vc, p);
 640
 641 out_unlock:
 642         console_unlock();
 643         return err;
 644 }
 645
 646 /**
 647  *      con_set_default_unimap  -       set default unicode map
 648  *      @vc: the console we are updating
 649  *
 650  *      Loads the unimap for the hardware font, as defined in uni_hash.tbl.
 651  *      The representation used was the most compact I could come up
 652  *      with.  This routine is executed at video setup, and when the
 653  *      PIO_FONTRESET ioctl is called.
 654  *
 655  *      The caller must hold the console lock
 656  */
 657 int con_set_default_unimap(struct vc_data *vc)
 658 {
 659         int i, j, err = 0, err1;
 660         u16 *q;
 661         struct uni_pagedir *p;
 662
 663         if (dflt) {
 664                 p = *vc->vc_uni_pagedir_loc;
 665                 if (p == dflt)
 666                         return 0;
 667
 668                 dflt->refcount++;
 669                 *vc->vc_uni_pagedir_loc = dflt;
 670                 if (p && !--p->refcount) {
 671                         con_release_unimap(p);
 672                         kfree(p);
 673                 }
 674                 return 0;
 675         }
 676
 677         /* The default font is always 256 characters */
 678
 679         err = con_do_clear_unimap(vc);
 680         if (err)
 681                 return err;
 682
 683         p = *vc->vc_uni_pagedir_loc;
 684         q = dfont_unitable;
 685
 686         for (i = 0; i < 256; i++)
 687                 for (j = dfont_unicount[i]; j; j--) {
 688                         err1 = con_insert_unipair(p, *(q++), i);
 689                         if (err1)
 690                                 err = err1;
 691                 }
 692
 693         if (con_unify_unimap(vc, p)) {
 694                 dflt = *vc->vc_uni_pagedir_loc;
 695                 return err;
 696         }
 697
 698         for (i = 0; i <= 3; i++)
 699                 set_inverse_transl(vc, p, i);   /* Update all inverse translations */
 700         set_inverse_trans_unicode(vc, p);
 701         dflt = p;
 702         return err;
 703 }
 704 EXPORT_SYMBOL(con_set_default_unimap);
 705
 706 /**
 707  *      con_copy_unimap         -       copy unimap between two vts
 708  *      @dst_vc: target
 709  *      @src_vt: source
 710  *
 711  *      The caller must hold the console lock when invoking this method
 712  */
 713 int con_copy_unimap(struct vc_data *dst_vc, struct vc_data *src_vc)
 714 {
 715         struct uni_pagedir *q;
 716
 717         if (!*src_vc->vc_uni_pagedir_loc)
 718                 return -EINVAL;
 719         if (*dst_vc->vc_uni_pagedir_loc == *src_vc->vc_uni_pagedir_loc)
 720                 return 0;
 721         con_free_unimap(dst_vc);
 722         q = *src_vc->vc_uni_pagedir_loc;
 723         q->refcount++;
 724         *dst_vc->vc_uni_pagedir_loc = q;
 725         return 0;
 726 }
 727 EXPORT_SYMBOL(con_copy_unimap);
 728
 729 /**
 730  *      con_get_unimap          -       get the unicode map
 731  *      @vc: the console to read from
 732  *
 733  *      Read the console unicode data for this console. Called from the ioctl
 734  *      handlers.
 735  */
 736 int con_get_unimap(struct vc_data *vc, ushort ct, ushort __user *uct, struct unipair __user *list)
 737 {
 738         int i, j, k, ect;
 739         u16 **p1, *p2;
 740         struct uni_pagedir *p;
 741
 742         console_lock();
 743
 744         ect = 0;
 745         if (*vc->vc_uni_pagedir_loc) {
 746                 p = *vc->vc_uni_pagedir_loc;
 747                 for (i = 0; i < 32; i++) {
 748                 p1 = p->uni_pgdir[i];
 749                 if (p1)
 750                         for (j = 0; j < 32; j++) {
 751                         p2 = *(p1++);
 752                         if (p2)
 753                                 for (k = 0; k < 64; k++) {
 754                                         if (*p2 < MAX_GLYPH && ect++ < ct) {
 755                                                 __put_user((u_short)((i<<11)+(j<<6)+k),
 756                                                            &list->unicode);
 757                                                 __put_user((u_short) *p2,
 758                                                            &list->fontpos);
 759                                                 list++;
 760                                         }
 761                                         p2++;
 762                                 }
 763                         }
 764                 }
 765         }
 766         __put_user(ect, uct);
 767         console_unlock();
 768         return ((ect <= ct) ? 0 : -ENOMEM);
 769 }
 770
 771 /*
 772  * Always use USER_MAP. These functions are used by the keyboard,
 773  * which shouldn't be affected by G0/G1 switching, etc.
 774  * If the user map still contains default values, i.e. the
 775  * direct-to-font mapping, then assume user is using Latin1.
 776  *
 777  * FIXME: at some point we need to decide if we want to lock the table
 778  * update element itself via the keyboard_event_lock for consistency with the
 779  * keyboard driver as well as the consoles
 780  */
 781 /* may be called during an interrupt */
 782 u32 conv_8bit_to_uni(unsigned char c)
 783 {
 784         unsigned short uni = translations[USER_MAP][c];
 785         return uni == (0xf000 | c) ? c : uni;
 786 }
 787
 788 int conv_uni_to_8bit(u32 uni)
 789 {
 790         int c;
 791         for (c = 0; c < 0x100; c++)
 792                 if (translations[USER_MAP][c] == uni ||
 793                    (translations[USER_MAP][c] == (c | 0xf000) && uni == c))
 794                         return c;
 795         return -1;
 796 }
 797
 798 int
 799 conv_uni_to_pc(struct vc_data *conp, long ucs)
 800 {
 801         int h;
 802         u16 **p1, *p2;
 803         struct uni_pagedir *p;
 804
 805         /* Only 16-bit codes supported at this time */
 806         if (ucs > 0xffff)
 807                 return -4;              /* Not found */
 808         else if (ucs < 0x20)
 809                 return -1;              /* Not a printable character */
 810         else if (ucs == 0xfeff || (ucs >= 0x200b && ucs <= 0x200f))
 811                 return -2;                      /* Zero-width space */
 812         /*
 813          * UNI_DIRECT_BASE indicates the start of the region in the User Zone
 814          * which always has a 1:1 mapping to the currently loaded font.  The
 815          * UNI_DIRECT_MASK indicates the bit span of the region.
 816          */
 817         else if ((ucs & ~UNI_DIRECT_MASK) == UNI_DIRECT_BASE)
 818                 return ucs & UNI_DIRECT_MASK;
 819
 820         if (!*conp->vc_uni_pagedir_loc)
 821                 return -3;
 822
 823         p = *conp->vc_uni_pagedir_loc;
 824         if ((p1 = p->uni_pgdir[ucs >> 11]) &&
 825             (p2 = p1[(ucs >> 6) & 0x1f]) &&
 826             (h = p2[ucs & 0x3f]) < MAX_GLYPH)
 827                 return h;
 828
 829         return -4;              /* not found */
 830 }
 831
 832 /*
 833  * This is called at sys_setup time, after memory and the console are
 834  * initialized.  It must be possible to call kmalloc(..., GFP_KERNEL)
 835  * from this function, hence the call from sys_setup.
 836  */
 837 void __init
 838 console_map_init(void)
 839 {
 840         int i;
 841
 842         for (i = 0; i < MAX_NR_CONSOLES; i++)
 843                 if (vc_cons_allocated(i) && !*vc_cons[i].d->vc_uni_pagedir_loc)
 844                         con_set_default_unimap(vc_cons[i].d);
 845 }
 846