SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/char/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/config.h>
  15 #include <linux/module.h>
  16 #include <linux/kd.h>
  17 #include <linux/errno.h>
  18 #include <linux/mm.h>
  19 #include <linux/slab.h>
  20 #include <linux/init.h>
  21 #include <linux/tty.h>
  22 #include <asm/uaccess.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         int             readonly;
 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] = (unsigned char *)
 197                         kmalloc(MAX_GLYPH, GFP_KERNEL);
 198                 if (!q) return;
 199         }
 200         memset(q, 0, MAX_GLYPH);
 201
 202         for (j = 0; j < E_TABSZ; j++) {
 203                 glyph = conv_uni_to_pc(conp, t[j]);
 204                 if (glyph >= 0 && glyph < MAX_GLYPH && q[glyph] < 32) {
 205                         /* prefer '-' above SHY etc. */
 206                         q[glyph] = j;
 207                 }
 208         }
 209 }
 210
 211 unsigned short *set_translate(int m, struct vc_data *vc)
 212 {
 213         inv_translate[vc->vc_num] = m;
 214         return translations[m];
 215 }
 216
 217 /*
 218  * Inverse translation is impossible for several reasons:
 219  * 1. The font<->character maps are not 1-1.
 220  * 2. The text may have been written while a different translation map
 221  *    was active, or using Unicode.
 222  * Still, it is now possible to a certain extent to cut and paste non-ASCII.
 223  */
 224 unsigned char inverse_translate(struct vc_data *conp, int glyph)
 225 {
 226         struct uni_pagedir *p;
 227         if (glyph < 0 || glyph >= MAX_GLYPH)
 228                 return 0;
 229         else if (!(p = (struct uni_pagedir *)*conp->vc_uni_pagedir_loc) ||
 230                  !p->inverse_translations[inv_translate[conp->vc_num]])
 231                 return glyph;
 232         else
 233                 return p->inverse_translations[inv_translate[conp->vc_num]][glyph];
 234 }
 235
 236 static void update_user_maps(void)
 237 {
 238         int i;
 239         struct uni_pagedir *p, *q = NULL;
 240
 241         for (i = 0; i < MAX_NR_CONSOLES; i++) {
 242                 if (!vc_cons_allocated(i))
 243                         continue;
 244                 p = (struct uni_pagedir *)*vc_cons[i].d->vc_uni_pagedir_loc;
 245                 if (p && p != q) {
 246                         set_inverse_transl(vc_cons[i].d, p, USER_MAP);
 247                         q = p;
 248                 }
 249         }
 250 }
 251
 252 /*
 253  * Load customizable translation table
 254  * arg points to a 256 byte translation table.
 255  *
 256  * The "old" variants are for translation directly to font (using the
 257  * 0xf000-0xf0ff "transparent" Unicodes) whereas the "new" variants set
 258  * Unicodes explicitly.
 259  */
 260 int con_set_trans_old(unsigned char __user * arg)
 261 {
 262         int i;
 263         unsigned short *p = translations[USER_MAP];
 264
 265         if (!access_ok(VERIFY_READ, arg, E_TABSZ))
 266                 return -EFAULT;
 267
 268         for (i=0; i<E_TABSZ ; i++) {
 269                 unsigned char uc;
 270                 __get_user(uc, arg+i);
 271                 p[i] = UNI_DIRECT_BASE | uc;
 272         }
 273
 274         update_user_maps();
 275         return 0;
 276 }
 277
 278 int con_get_trans_old(unsigned char __user * arg)
 279 {
 280         int i, ch;
 281         unsigned short *p = translations[USER_MAP];
 282
 283         if (!access_ok(VERIFY_WRITE, arg, E_TABSZ))
 284                 return -EFAULT;
 285
 286         for (i=0; i<E_TABSZ ; i++)
 287           {
 288             ch = conv_uni_to_pc(vc_cons[fg_console].d, p[i]);
 289             __put_user((ch & ~0xff) ? 0 : ch, arg+i);
 290           }
 291         return 0;
 292 }
 293
 294 int con_set_trans_new(ushort __user * arg)
 295 {
 296         int i;
 297         unsigned short *p = translations[USER_MAP];
 298
 299         if (!access_ok(VERIFY_READ, arg, E_TABSZ*sizeof(unsigned short)))
 300                 return -EFAULT;
 301
 302         for (i=0; i<E_TABSZ ; i++) {
 303                 unsigned short us;
 304                 __get_user(us, arg+i);
 305                 p[i] = us;
 306         }
 307
 308         update_user_maps();
 309         return 0;
 310 }
 311
 312 int con_get_trans_new(ushort __user * arg)
 313 {
 314         int i;
 315         unsigned short *p = translations[USER_MAP];
 316
 317         if (!access_ok(VERIFY_WRITE, arg, E_TABSZ*sizeof(unsigned short)))
 318                 return -EFAULT;
 319
 320         for (i=0; i<E_TABSZ ; i++)
 321           __put_user(p[i], arg+i);
 322
 323         return 0;
 324 }
 325
 326 /*
 327  * Unicode -> current font conversion
 328  *
 329  * A font has at most 512 chars, usually 256.
 330  * But one font position may represent several Unicode chars.
 331  * A hashtable is somewhat of a pain to deal with, so use a
 332  * "paged table" instead.  Simulation has shown the memory cost of
 333  * this 3-level paged table scheme to be comparable to a hash table.
 334  */
 335
 336 extern u8 dfont_unicount[];     /* Defined in console_defmap.c */
 337 extern u16 dfont_unitable[];
 338
 339 static void con_release_unimap(struct uni_pagedir *p)
 340 {
 341         u16 **p1;
 342         int i, j;
 343
 344         if (p == dflt) dflt = NULL;
 345         for (i = 0; i < 32; i++) {
 346                 if ((p1 = p->uni_pgdir[i]) != NULL) {
 347                         for (j = 0; j < 32; j++)
 348                                 if (p1[j])
 349                                         kfree(p1[j]);
 350                         kfree(p1);
 351                 }
 352                 p->uni_pgdir[i] = NULL;
 353         }
 354         for (i = 0; i < 4; i++)
 355                 if (p->inverse_translations[i]) {
 356                         kfree(p->inverse_translations[i]);
 357                         p->inverse_translations[i] = NULL;
 358                 }
 359 }
 360
 361 void con_free_unimap(struct vc_data *vc)
 362 {
 363         struct uni_pagedir *p;
 364
 365         p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
 366         if (!p)
 367                 return;
 368         *vc->vc_uni_pagedir_loc = 0;
 369         if (--p->refcount)
 370                 return;
 371         con_release_unimap(p);
 372         kfree(p);
 373 }
 374
 375 static int con_unify_unimap(struct vc_data *conp, struct uni_pagedir *p)
 376 {
 377         int i, j, k;
 378         struct uni_pagedir *q;
 379
 380         for (i = 0; i < MAX_NR_CONSOLES; i++) {
 381                 if (!vc_cons_allocated(i))
 382                         continue;
 383                 q = (struct uni_pagedir *)*vc_cons[i].d->vc_uni_pagedir_loc;
 384                 if (!q || q == p || q->sum != p->sum)
 385                         continue;
 386                 for (j = 0; j < 32; j++) {
 387                         u16 **p1, **q1;
 388                         p1 = p->uni_pgdir[j]; q1 = q->uni_pgdir[j];
 389                         if (!p1 && !q1)
 390                                 continue;
 391                         if (!p1 || !q1)
 392                                 break;
 393                         for (k = 0; k < 32; k++) {
 394                                 if (!p1[k] && !q1[k])
 395                                         continue;
 396                                 if (!p1[k] || !q1[k])
 397                                         break;
 398                                 if (memcmp(p1[k], q1[k], 64*sizeof(u16)))
 399                                         break;
 400                         }
 401                         if (k < 32)
 402                                 break;
 403                 }
 404                 if (j == 32) {
 405                         q->refcount++;
 406                         *conp->vc_uni_pagedir_loc = (unsigned long)q;
 407                         con_release_unimap(p);
 408                         kfree(p);
 409                         return 1;
 410                 }
 411         }
 412         return 0;
 413 }
 414
 415 static int
 416 con_insert_unipair(struct uni_pagedir *p, u_short unicode, u_short fontpos)
 417 {
 418         int i, n;
 419         u16 **p1, *p2;
 420
 421         if (!(p1 = p->uni_pgdir[n = unicode >> 11])) {
 422                 p1 = p->uni_pgdir[n] = kmalloc(32*sizeof(u16 *), GFP_KERNEL);
 423                 if (!p1) return -ENOMEM;
 424                 for (i = 0; i < 32; i++)
 425                         p1[i] = NULL;
 426         }
 427
 428         if (!(p2 = p1[n = (unicode >> 6) & 0x1f])) {
 429                 p2 = p1[n] = kmalloc(64*sizeof(u16), GFP_KERNEL);
 430                 if (!p2) return -ENOMEM;
 431                 memset(p2, 0xff, 64*sizeof(u16)); /* No glyphs for the characters (yet) */
 432         }
 433
 434         p2[unicode & 0x3f] = fontpos;
 435
 436         p->sum += (fontpos << 20) + unicode;
 437
 438         return 0;
 439 }
 440
 441 /* ui is a leftover from using a hashtable, but might be used again */
 442 int con_clear_unimap(struct vc_data *vc, struct unimapinit *ui)
 443 {
 444         struct uni_pagedir *p, *q;
 445
 446         p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
 447         if (p && p->readonly) return -EIO;
 448         if (!p || --p->refcount) {
 449                 q = (struct uni_pagedir *)kmalloc(sizeof(*p), GFP_KERNEL);
 450                 if (!q) {
 451                         if (p) p->refcount++;
 452                         return -ENOMEM;
 453                 }
 454                 memset(q, 0, sizeof(*q));
 455                 q->refcount=1;
 456                 *vc->vc_uni_pagedir_loc = (unsigned long)q;
 457         } else {
 458                 if (p == dflt) dflt = NULL;
 459                 p->refcount++;
 460                 p->sum = 0;
 461                 con_release_unimap(p);
 462         }
 463         return 0;
 464 }
 465
 466 int con_set_unimap(struct vc_data *vc, ushort ct, struct unipair __user *list)
 467 {
 468         int err = 0, err1, i;
 469         struct uni_pagedir *p, *q;
 470
 471         p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
 472         if (p->readonly) return -EIO;
 473
 474         if (!ct) return 0;
 475
 476         if (p->refcount > 1) {
 477                 int j, k;
 478                 u16 **p1, *p2, l;
 479
 480                 err1 = con_clear_unimap(vc, NULL);
 481                 if (err1) return err1;
 482
 483                 q = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
 484                 for (i = 0, l = 0; i < 32; i++)
 485                 if ((p1 = p->uni_pgdir[i]))
 486                         for (j = 0; j < 32; j++)
 487                         if ((p2 = p1[j]))
 488                                 for (k = 0; k < 64; k++, l++)
 489                                 if (p2[k] != 0xffff) {
 490                                         err1 = con_insert_unipair(q, l, p2[k]);
 491                                         if (err1) {
 492                                                 p->refcount++;
 493                                                 *vc->vc_uni_pagedir_loc = (unsigned long)p;
 494                                                 con_release_unimap(q);
 495                                                 kfree(q);
 496                                                 return err1;
 497                                         }
 498                                 }
 499                 p = q;
 500         } else if (p == dflt)
 501                 dflt = NULL;
 502
 503         while (ct--) {
 504                 unsigned short unicode, fontpos;
 505                 __get_user(unicode, &list->unicode);
 506                 __get_user(fontpos, &list->fontpos);
 507                 if ((err1 = con_insert_unipair(p, unicode,fontpos)) != 0)
 508                         err = err1;
 509                         list++;
 510         }
 511
 512         if (con_unify_unimap(vc, p))
 513                 return err;
 514
 515         for (i = 0; i <= 3; i++)
 516                 set_inverse_transl(vc, p, i); /* Update all inverse translations */
 517
 518         return err;
 519 }
 520
 521 /* Loads the unimap for the hardware font, as defined in uni_hash.tbl.
 522    The representation used was the most compact I could come up
 523    with.  This routine is executed at sys_setup time, and when the
 524    PIO_FONTRESET ioctl is called. */
 525
 526 int con_set_default_unimap(struct vc_data *vc)
 527 {
 528         int i, j, err = 0, err1;
 529         u16 *q;
 530         struct uni_pagedir *p;
 531
 532         if (dflt) {
 533                 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
 534                 if (p == dflt)
 535                         return 0;
 536                 dflt->refcount++;
 537                 *vc->vc_uni_pagedir_loc = (unsigned long)dflt;
 538                 if (p && --p->refcount) {
 539                         con_release_unimap(p);
 540                         kfree(p);
 541                 }
 542                 return 0;
 543         }
 544
 545         /* The default font is always 256 characters */
 546
 547         err = con_clear_unimap(vc, NULL);
 548         if (err) return err;
 549
 550         p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
 551         q = dfont_unitable;
 552
 553         for (i = 0; i < 256; i++)
 554                 for (j = dfont_unicount[i]; j; j--) {
 555                         err1 = con_insert_unipair(p, *(q++), i);
 556                         if (err1)
 557                                 err = err1;
 558                 }
 559
 560         if (con_unify_unimap(vc, p)) {
 561                 dflt = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
 562                 return err;
 563         }
 564
 565         for (i = 0; i <= 3; i++)
 566                 set_inverse_transl(vc, p, i);   /* Update all inverse translations */
 567         dflt = p;
 568         return err;
 569 }
 570 EXPORT_SYMBOL(con_set_default_unimap);
 571
 572 int con_copy_unimap(struct vc_data *dst_vc, struct vc_data *src_vc)
 573 {
 574         struct uni_pagedir *q;
 575
 576         if (!*src_vc->vc_uni_pagedir_loc)
 577                 return -EINVAL;
 578         if (*dst_vc->vc_uni_pagedir_loc == *src_vc->vc_uni_pagedir_loc)
 579                 return 0;
 580         con_free_unimap(dst_vc);
 581         q = (struct uni_pagedir *)*src_vc->vc_uni_pagedir_loc;
 582         q->refcount++;
 583         *dst_vc->vc_uni_pagedir_loc = (long)q;
 584         return 0;
 585 }
 586
 587 int con_get_unimap(struct vc_data *vc, ushort ct, ushort __user *uct, struct unipair __user *list)
 588 {
 589         int i, j, k, ect;
 590         u16 **p1, *p2;
 591         struct uni_pagedir *p;
 592
 593         ect = 0;
 594         if (*vc->vc_uni_pagedir_loc) {
 595                 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
 596                 for (i = 0; i < 32; i++)
 597                 if ((p1 = p->uni_pgdir[i]))
 598                         for (j = 0; j < 32; j++)
 599                         if ((p2 = *(p1++)))
 600                                 for (k = 0; k < 64; k++) {
 601                                         if (*p2 < MAX_GLYPH && ect++ < ct) {
 602                                                 __put_user((u_short)((i<<11)+(j<<6)+k),
 603                                                            &list->unicode);
 604                                                 __put_user((u_short) *p2,
 605                                                            &list->fontpos);
 606                                                 list++;
 607                                         }
 608                                         p2++;
 609                                 }
 610         }
 611         __put_user(ect, uct);
 612         return ((ect <= ct) ? 0 : -ENOMEM);
 613 }
 614
 615 void con_protect_unimap(struct vc_data *vc, int rdonly)
 616 {
 617         struct uni_pagedir *p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc;
 618
 619         if (p)
 620                 p->readonly = rdonly;
 621 }
 622
 623 int
 624 conv_uni_to_pc(struct vc_data *conp, long ucs)
 625 {
 626         int h;
 627         u16 **p1, *p2;
 628         struct uni_pagedir *p;
 629
 630         /* Only 16-bit codes supported at this time */
 631         if (ucs > 0xffff)
 632                 ucs = 0xfffd;           /* U+FFFD: REPLACEMENT CHARACTER */
 633         else if (ucs < 0x20 || ucs >= 0xfffe)
 634                 return -1;              /* Not a printable character */
 635         else if (ucs == 0xfeff || (ucs >= 0x200a && ucs <= 0x200f))
 636                 return -2;                      /* Zero-width space */
 637         /*
 638          * UNI_DIRECT_BASE indicates the start of the region in the User Zone
 639          * which always has a 1:1 mapping to the currently loaded font.  The
 640          * UNI_DIRECT_MASK indicates the bit span of the region.
 641          */
 642         else if ((ucs & ~UNI_DIRECT_MASK) == UNI_DIRECT_BASE)
 643                 return ucs & UNI_DIRECT_MASK;
 644
 645         if (!*conp->vc_uni_pagedir_loc)
 646                 return -3;
 647
 648         p = (struct uni_pagedir *)*conp->vc_uni_pagedir_loc;
 649         if ((p1 = p->uni_pgdir[ucs >> 11]) &&
 650             (p2 = p1[(ucs >> 6) & 0x1f]) &&
 651             (h = p2[ucs & 0x3f]) < MAX_GLYPH)
 652                 return h;
 653
 654         return -4;              /* not found */
 655 }
 656
 657 /*
 658  * This is called at sys_setup time, after memory and the console are
 659  * initialized.  It must be possible to call kmalloc(..., GFP_KERNEL)
 660  * from this function, hence the call from sys_setup.
 661  */
 662 void __init
 663 console_map_init(void)
 664 {
 665         int i;
 666
 667         for (i = 0; i < MAX_NR_CONSOLES; i++)
 668                 if (vc_cons_allocated(i) && !*vc_cons[i].d->vc_uni_pagedir_loc)
 669                         con_set_default_unimap(vc_cons[i].d);
 670 }
 671
 672 EXPORT_SYMBOL(con_copy_unimap);