reformatted
This commit is contained in:
+89
-89
@@ -40,20 +40,20 @@
|
||||
* and finally ended up with this. Not nice, put paid (and working).
|
||||
*
|
||||
*/
|
||||
#define SREC_TYPE(a) (a)[0] /* type of record */
|
||||
#define SREC_COUNT(a) (a)[1] /* length of valid bytes to follow */
|
||||
#define SREC_ADDR16(a) (256 * (a)[2] + (a)[3]) /* 2 byte address field */
|
||||
#define SREC_ADDR24(a) (0x10000 * (a)[2] + 0x100 * \
|
||||
(a)[3] + (a)[4]) /* 3 byte address field */
|
||||
#define SREC_TYPE(a) (a)[0] /* type of record */
|
||||
#define SREC_COUNT(a) (a)[1] /* length of valid bytes to follow */
|
||||
#define SREC_ADDR16(a) (256 * (a)[2] + (a)[3]) /* 2 byte address field */
|
||||
#define SREC_ADDR24(a) (0x10000 * (a)[2] + 0x100 * \
|
||||
(a)[3] + (a)[4]) /* 3 byte address field */
|
||||
#define SREC_ADDR32(a) (0x1000000 * a[2] + 0x10000 * \
|
||||
a[3] + 0x100 * (a)[4] + (a)[5]) /* 4 byte address field */
|
||||
#define SREC_DATA16(a) ((uint8_t *)&((a)[4])) /* address of first byte of data in a record */
|
||||
#define SREC_DATA24(a) ((uint8_t *)&((a)[5])) /* address of first data byte in 24 bit record */
|
||||
#define SREC_DATA32(a) ((uint8_t *)&((a)[6])) /* adress of first byte of a record with 32 bit address field */
|
||||
#define SREC_DATA16_SIZE(a) (SREC_COUNT((a)) - 3) /* length of the data[] array without the checksum field */
|
||||
#define SREC_DATA24_SIZE(a) (SREC_COUNT((a)) - 4) /* length of the data[] array without the checksum field */
|
||||
#define SREC_DATA32_SIZE(a) (SREC_COUNT((a)) - 5) /* length of the data[] array without the checksum field */
|
||||
#define SREC_CHECKSUM(a) (a)[SREC_COUNT(a) + 2 - 1] /* record's checksum (two's complement of the sum of all bytes) */
|
||||
(a)[3] + 0x100 * (a)[4] + (a)[5]) /* 4 byte address field */
|
||||
#define SREC_DATA16(a) ((uint8_t *)&((a)[4])) /* address of first byte of data in a record */
|
||||
#define SREC_DATA24(a) ((uint8_t *)&((a)[5])) /* address of first data byte in 24 bit record */
|
||||
#define SREC_DATA32(a) ((uint8_t *)&((a)[6])) /* adress of first byte of a record with 32 bit address field */
|
||||
#define SREC_DATA16_SIZE(a) (SREC_COUNT((a)) - 3) /* length of the data[] array without the checksum field */
|
||||
#define SREC_DATA24_SIZE(a) (SREC_COUNT((a)) - 4) /* length of the data[] array without the checksum field */
|
||||
#define SREC_DATA32_SIZE(a) (SREC_COUNT((a)) - 5) /* length of the data[] array without the checksum field */
|
||||
#define SREC_CHECKSUM(a) (a)[SREC_COUNT(a) + 2 - 1] /* record's checksum (two's complement of the sum of all bytes) */
|
||||
|
||||
/*
|
||||
* convert a single hex character into byte
|
||||
@@ -118,26 +118,26 @@ void print_record(uint8_t *arr)
|
||||
switch (SREC_TYPE(arr))
|
||||
{
|
||||
case 0:
|
||||
{
|
||||
xprintf("type 0x%x ", SREC_TYPE(arr));
|
||||
xprintf("count 0x%x ", SREC_COUNT(arr));
|
||||
xprintf("addr 0x%x ", SREC_ADDR16(arr));
|
||||
xprintf("module %11.11s ", SREC_DATA16(arr));
|
||||
xprintf("chk 0x%x 0x%x\r\n", SREC_CHECKSUM(arr), checksum(arr));
|
||||
}
|
||||
break;
|
||||
{
|
||||
xprintf("type 0x%x ", SREC_TYPE(arr));
|
||||
xprintf("count 0x%x ", SREC_COUNT(arr));
|
||||
xprintf("addr 0x%x ", SREC_ADDR16(arr));
|
||||
xprintf("module %11.11s ", SREC_DATA16(arr));
|
||||
xprintf("chk 0x%x 0x%x\r\n", SREC_CHECKSUM(arr), checksum(arr));
|
||||
}
|
||||
break;
|
||||
|
||||
case 3:
|
||||
case 7:
|
||||
{
|
||||
xprintf("type 0x%x ", SREC_TYPE(arr));
|
||||
xprintf("count 0x%x ", SREC_COUNT(arr));
|
||||
xprintf("addr 0x%x ", SREC_ADDR32(arr));
|
||||
xprintf("data %02x,%02x,%02x,%02x,... ",
|
||||
SREC_DATA32(arr)[0], SREC_DATA32(arr)[1], SREC_DATA32(arr)[3], SREC_DATA32(arr)[4]);
|
||||
xprintf("chk 0x%x 0x%x\r\n", SREC_CHECKSUM(arr), checksum(arr));
|
||||
}
|
||||
break;
|
||||
{
|
||||
xprintf("type 0x%x ", SREC_TYPE(arr));
|
||||
xprintf("count 0x%x ", SREC_COUNT(arr));
|
||||
xprintf("addr 0x%x ", SREC_ADDR32(arr));
|
||||
xprintf("data %02x,%02x,%02x,%02x,... ",
|
||||
SREC_DATA32(arr)[0], SREC_DATA32(arr)[1], SREC_DATA32(arr)[3], SREC_DATA32(arr)[4]);
|
||||
xprintf("chk 0x%x 0x%x\r\n", SREC_CHECKSUM(arr), checksum(arr));
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
xprintf("unsupported report type %d in print_record\r\n", arr[0]);
|
||||
@@ -220,66 +220,66 @@ err_t read_srecords(char *filename, void **start_address, uint32_t *actual_lengt
|
||||
|
||||
switch (vector[0])
|
||||
{
|
||||
case 0: /* block header */
|
||||
found_block_header = true;
|
||||
if (found_block_data || found_block_end)
|
||||
{
|
||||
xprintf("S7 or S3 record found before S0: S-records corrupt?\r\n");
|
||||
case 0: /* block header */
|
||||
found_block_header = true;
|
||||
if (found_block_data || found_block_end)
|
||||
{
|
||||
xprintf("S7 or S3 record found before S0: S-records corrupt?\r\n");
|
||||
ret = FAIL;
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
case 2: /* three byte address field data record */
|
||||
if (!found_block_header || found_block_end)
|
||||
{
|
||||
xprintf("S3 record found before S0 or after S7: S-records corrupt?\r\n");
|
||||
ret = FAIL;
|
||||
}
|
||||
ret = callback((uint8_t *) SREC_ADDR24(vector), SREC_DATA24(vector), SREC_DATA24_SIZE(vector));
|
||||
data_records++;
|
||||
break;
|
||||
|
||||
case 3: /* four byte address field data record */
|
||||
if (!found_block_header || found_block_end)
|
||||
{
|
||||
xprintf("S3 record found before S0 or after S7: S-records corrupt?\r\n");
|
||||
ret = FAIL;
|
||||
}
|
||||
ret = callback((uint8_t *) SREC_ADDR32(vector), SREC_DATA32(vector), SREC_DATA32_SIZE(vector));
|
||||
data_records++;
|
||||
break;
|
||||
|
||||
case 7: /* four byte address field end record */
|
||||
if (!found_block_header || found_block_end)
|
||||
{
|
||||
xprintf("S7 record found before S0 or after S7: S-records corrupt?\r\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
// xprintf("S7 record (end) found after %d valid data blocks\r\n", data_records);
|
||||
*start_address = (void *) SREC_ADDR32(vector);
|
||||
}
|
||||
break;
|
||||
|
||||
case 8: /* three byte address field end record */
|
||||
if (!found_block_header || found_block_end)
|
||||
{
|
||||
xprintf("S8 record found before S0 or after S8: S-records corrupt?\r\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
// xprintf("S7 record (end) found after %d valid data blocks\r\n", data_records);
|
||||
*start_address = (void *) SREC_ADDR24(vector);
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
xprintf("unsupported record type (%d) found in line %d\r\n", vector[0], lineno);
|
||||
xprintf("offending line: \r\n");
|
||||
xprintf("%s\r\n", line);
|
||||
ret = FAIL;
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
case 2: /* three byte address field data record */
|
||||
if (!found_block_header || found_block_end)
|
||||
{
|
||||
xprintf("S3 record found before S0 or after S7: S-records corrupt?\r\n");
|
||||
ret = FAIL;
|
||||
}
|
||||
ret = callback((uint8_t *) SREC_ADDR24(vector), SREC_DATA24(vector), SREC_DATA24_SIZE(vector));
|
||||
data_records++;
|
||||
break;
|
||||
|
||||
case 3: /* four byte address field data record */
|
||||
if (!found_block_header || found_block_end)
|
||||
{
|
||||
xprintf("S3 record found before S0 or after S7: S-records corrupt?\r\n");
|
||||
ret = FAIL;
|
||||
}
|
||||
ret = callback((uint8_t *) SREC_ADDR32(vector), SREC_DATA32(vector), SREC_DATA32_SIZE(vector));
|
||||
data_records++;
|
||||
break;
|
||||
|
||||
case 7: /* four byte address field end record */
|
||||
if (!found_block_header || found_block_end)
|
||||
{
|
||||
xprintf("S7 record found before S0 or after S7: S-records corrupt?\r\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
// xprintf("S7 record (end) found after %d valid data blocks\r\n", data_records);
|
||||
*start_address = (void *) SREC_ADDR32(vector);
|
||||
}
|
||||
break;
|
||||
|
||||
case 8: /* three byte address field end record */
|
||||
if (!found_block_header || found_block_end)
|
||||
{
|
||||
xprintf("S8 record found before S0 or after S8: S-records corrupt?\r\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
// xprintf("S7 record (end) found after %d valid data blocks\r\n", data_records);
|
||||
*start_address = (void *) SREC_ADDR24(vector);
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
xprintf("unsupported record type (%d) found in line %d\r\n", vector[0], lineno);
|
||||
xprintf("offending line: \r\n");
|
||||
xprintf("%s\r\n", line);
|
||||
ret = FAIL;
|
||||
break;
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
|
||||
+3753
-3753
File diff suppressed because it is too large
Load Diff
+10935
-10935
File diff suppressed because it is too large
Load Diff
+8563
-8563
File diff suppressed because it is too large
Load Diff
+6789
-6789
File diff suppressed because it is too large
Load Diff
+460
-381
@@ -31,463 +31,505 @@
|
||||
#if _CODE_PAGE == 437
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const uint16_t Tbl[] = { /* CP437(0x80-0xFF) to Unicode conversion table */
|
||||
0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7,
|
||||
0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4, 0x00C5,
|
||||
0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9,
|
||||
0x00FF, 0x00D6, 0x00DC, 0x00A2, 0x00A3, 0x00A5, 0x20A7, 0x0192,
|
||||
0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA,
|
||||
0x00BF, 0x2310, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
|
||||
0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
|
||||
0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
|
||||
0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
|
||||
0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
|
||||
0x03B1, 0x00DF, 0x0393, 0x03C0, 0x03A3, 0x03C3, 0x00B5, 0x03C4,
|
||||
0x03A6, 0x0398, 0x03A9, 0x03B4, 0x221E, 0x03C6, 0x03B5, 0x2229,
|
||||
0x2261, 0x00B1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00F7, 0x2248,
|
||||
0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0
|
||||
const uint16_t Tbl[] =
|
||||
{
|
||||
/* CP437(0x80-0xFF) to Unicode conversion table */
|
||||
0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7,
|
||||
0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4, 0x00C5,
|
||||
0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9,
|
||||
0x00FF, 0x00D6, 0x00DC, 0x00A2, 0x00A3, 0x00A5, 0x20A7, 0x0192,
|
||||
0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA,
|
||||
0x00BF, 0x2310, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
|
||||
0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
|
||||
0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
|
||||
0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
|
||||
0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
|
||||
0x03B1, 0x00DF, 0x0393, 0x03C0, 0x03A3, 0x03C3, 0x00B5, 0x03C4,
|
||||
0x03A6, 0x0398, 0x03A9, 0x03B4, 0x221E, 0x03C6, 0x03B5, 0x2229,
|
||||
0x2261, 0x00B1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00F7, 0x2248,
|
||||
0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 720
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const uint16_t Tbl[] = { /* CP720(0x80-0xFF) to Unicode conversion table */
|
||||
0x0000, 0x0000, 0x00E9, 0x00E2, 0x0000, 0x00E0, 0x0000, 0x00E7,
|
||||
0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x0651, 0x0652, 0x00F4, 0x00A4, 0x0640, 0x00FB, 0x00F9,
|
||||
0x0621, 0x0622, 0x0623, 0x0624, 0x00A3, 0x0625, 0x0626, 0x0627,
|
||||
0x0628, 0x0629, 0x062A, 0x062B, 0x062C, 0x062D, 0x062E, 0x062F,
|
||||
0x0630, 0x0631, 0x0632, 0x0633, 0x0634, 0x0635, 0x00AB, 0x00BB,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
|
||||
0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
|
||||
0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
|
||||
0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
|
||||
0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
|
||||
0x0636, 0x0637, 0x0638, 0x0639, 0x063A, 0x0641, 0x00B5, 0x0642,
|
||||
0x0643, 0x0644, 0x0645, 0x0646, 0x0647, 0x0648, 0x0649, 0x064A,
|
||||
0x2261, 0x064B, 0x064C, 0x064D, 0x064E, 0x064F, 0xO650, 0x2248,
|
||||
0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0
|
||||
const uint16_t Tbl[] =
|
||||
{
|
||||
/* CP720(0x80-0xFF) to Unicode conversion table */
|
||||
0x0000, 0x0000, 0x00E9, 0x00E2, 0x0000, 0x00E0, 0x0000, 0x00E7,
|
||||
0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x0651, 0x0652, 0x00F4, 0x00A4, 0x0640, 0x00FB, 0x00F9,
|
||||
0x0621, 0x0622, 0x0623, 0x0624, 0x00A3, 0x0625, 0x0626, 0x0627,
|
||||
0x0628, 0x0629, 0x062A, 0x062B, 0x062C, 0x062D, 0x062E, 0x062F,
|
||||
0x0630, 0x0631, 0x0632, 0x0633, 0x0634, 0x0635, 0x00AB, 0x00BB,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
|
||||
0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
|
||||
0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
|
||||
0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
|
||||
0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
|
||||
0x0636, 0x0637, 0x0638, 0x0639, 0x063A, 0x0641, 0x00B5, 0x0642,
|
||||
0x0643, 0x0644, 0x0645, 0x0646, 0x0647, 0x0648, 0x0649, 0x064A,
|
||||
0x2261, 0x064B, 0x064C, 0x064D, 0x064E, 0x064F, 0xO650, 0x2248,
|
||||
0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 737
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const uint16_t Tbl[] = { /* CP737(0x80-0xFF) to Unicode conversion table */
|
||||
0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x0398,
|
||||
0x0399, 0x039A, 0x039B, 0x039C, 0x039D, 0x039E, 0x039F, 0x03A0,
|
||||
0x03A1, 0x03A3, 0x03A4, 0x03A5, 0x03A6, 0x03A7, 0x03A8, 0x03A9,
|
||||
0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7, 0x03B8,
|
||||
0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF, 0x03C0,
|
||||
0x03C1, 0x03C3, 0x03C2, 0x03C4, 0x03C5, 0x03C6, 0x03C7, 0x03C8,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
|
||||
0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
|
||||
0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
|
||||
0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
|
||||
0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
|
||||
0x03C9, 0x03AC, 0x03AD, 0x03AE, 0x03CA, 0x03AF, 0x03CC, 0x03CD,
|
||||
0x03CB, 0x03CE, 0x0386, 0x0388, 0x0389, 0x038A, 0x038C, 0x038E,
|
||||
0x038F, 0x00B1, 0x2265, 0x2264, 0x03AA, 0x03AB, 0x00F7, 0x2248,
|
||||
0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0
|
||||
const uint16_t Tbl[] =
|
||||
{
|
||||
/* CP737(0x80-0xFF) to Unicode conversion table */
|
||||
0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x0398,
|
||||
0x0399, 0x039A, 0x039B, 0x039C, 0x039D, 0x039E, 0x039F, 0x03A0,
|
||||
0x03A1, 0x03A3, 0x03A4, 0x03A5, 0x03A6, 0x03A7, 0x03A8, 0x03A9,
|
||||
0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7, 0x03B8,
|
||||
0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF, 0x03C0,
|
||||
0x03C1, 0x03C3, 0x03C2, 0x03C4, 0x03C5, 0x03C6, 0x03C7, 0x03C8,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
|
||||
0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
|
||||
0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
|
||||
0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
|
||||
0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
|
||||
0x03C9, 0x03AC, 0x03AD, 0x03AE, 0x03CA, 0x03AF, 0x03CC, 0x03CD,
|
||||
0x03CB, 0x03CE, 0x0386, 0x0388, 0x0389, 0x038A, 0x038C, 0x038E,
|
||||
0x038F, 0x00B1, 0x2265, 0x2264, 0x03AA, 0x03AB, 0x00F7, 0x2248,
|
||||
0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 775
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const uint16_t Tbl[] = { /* CP775(0x80-0xFF) to Unicode conversion table */
|
||||
0x0106, 0x00FC, 0x00E9, 0x0101, 0x00E4, 0x0123, 0x00E5, 0x0107,
|
||||
0x0142, 0x0113, 0x0156, 0x0157, 0x012B, 0x0179, 0x00C4, 0x00C5,
|
||||
0x00C9, 0x00E6, 0x00C6, 0x014D, 0x00F6, 0x0122, 0x00A2, 0x015A,
|
||||
0x015B, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x00D7, 0x00A4,
|
||||
0x0100, 0x012A, 0x00F3, 0x017B, 0x017C, 0x017A, 0x201D, 0x00A6,
|
||||
0x00A9, 0x00AE, 0x00AC, 0x00BD, 0x00BC, 0x0141, 0x00AB, 0x00BB,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x0104, 0x010C, 0x0118,
|
||||
0x0116, 0x2563, 0x2551, 0x2557, 0x255D, 0x012E, 0x0160, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x0172, 0x016A,
|
||||
0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x017D,
|
||||
0x0105, 0x010D, 0x0119, 0x0117, 0x012F, 0x0161, 0x0173, 0x016B,
|
||||
0x017E, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
|
||||
0x00D3, 0x00DF, 0x014C, 0x0143, 0x00F5, 0x00D5, 0x00B5, 0x0144,
|
||||
0x0136, 0x0137, 0x013B, 0x013C, 0x0146, 0x0112, 0x0145, 0x2019,
|
||||
0x00AD, 0x00B1, 0x201C, 0x00BE, 0x00B6, 0x00A7, 0x00F7, 0x201E,
|
||||
0x00B0, 0x2219, 0x00B7, 0x00B9, 0x00B3, 0x00B2, 0x25A0, 0x00A0
|
||||
const uint16_t Tbl[] =
|
||||
{
|
||||
/* CP775(0x80-0xFF) to Unicode conversion table */
|
||||
0x0106, 0x00FC, 0x00E9, 0x0101, 0x00E4, 0x0123, 0x00E5, 0x0107,
|
||||
0x0142, 0x0113, 0x0156, 0x0157, 0x012B, 0x0179, 0x00C4, 0x00C5,
|
||||
0x00C9, 0x00E6, 0x00C6, 0x014D, 0x00F6, 0x0122, 0x00A2, 0x015A,
|
||||
0x015B, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x00D7, 0x00A4,
|
||||
0x0100, 0x012A, 0x00F3, 0x017B, 0x017C, 0x017A, 0x201D, 0x00A6,
|
||||
0x00A9, 0x00AE, 0x00AC, 0x00BD, 0x00BC, 0x0141, 0x00AB, 0x00BB,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x0104, 0x010C, 0x0118,
|
||||
0x0116, 0x2563, 0x2551, 0x2557, 0x255D, 0x012E, 0x0160, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x0172, 0x016A,
|
||||
0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x017D,
|
||||
0x0105, 0x010D, 0x0119, 0x0117, 0x012F, 0x0161, 0x0173, 0x016B,
|
||||
0x017E, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
|
||||
0x00D3, 0x00DF, 0x014C, 0x0143, 0x00F5, 0x00D5, 0x00B5, 0x0144,
|
||||
0x0136, 0x0137, 0x013B, 0x013C, 0x0146, 0x0112, 0x0145, 0x2019,
|
||||
0x00AD, 0x00B1, 0x201C, 0x00BE, 0x00B6, 0x00A7, 0x00F7, 0x201E,
|
||||
0x00B0, 0x2219, 0x00B7, 0x00B9, 0x00B3, 0x00B2, 0x25A0, 0x00A0
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 850
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const uint16_t Tbl[] = { /* CP850(0x80-0xFF) to Unicode conversion table */
|
||||
0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7,
|
||||
0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4, 0x00C5,
|
||||
0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9,
|
||||
0x00FF, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x00D7, 0x0192,
|
||||
0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA,
|
||||
0x00BF, 0x00AE, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00C1, 0x00C2, 0x00C0,
|
||||
0x00A9, 0x2563, 0x2551, 0x2557, 0x255D, 0x00A2, 0x00A5, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x00E3, 0x00C3,
|
||||
0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
|
||||
0x00F0, 0x00D0, 0x00CA, 0x00CB, 0x00C8, 0x0131, 0x00CD, 0x00CE,
|
||||
0x00CF, 0x2518, 0x250C, 0x2588, 0x2584, 0x00A6, 0x00CC, 0x2580,
|
||||
0x00D3, 0x00DF, 0x00D4, 0x00D2, 0x00F5, 0x00D5, 0x00B5, 0x00FE,
|
||||
0x00DE, 0x00DA, 0x00DB, 0x00D9, 0x00FD, 0x00DD, 0x00AF, 0x00B4,
|
||||
0x00AD, 0x00B1, 0x2017, 0x00BE, 0x00B6, 0x00A7, 0x00F7, 0x00B8,
|
||||
0x00B0, 0x00A8, 0x00B7, 0x00B9, 0x00B3, 0x00B2, 0x25A0, 0x00A0
|
||||
const uint16_t Tbl[] =
|
||||
{
|
||||
/* CP850(0x80-0xFF) to Unicode conversion table */
|
||||
0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7,
|
||||
0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4, 0x00C5,
|
||||
0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9,
|
||||
0x00FF, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x00D7, 0x0192,
|
||||
0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA,
|
||||
0x00BF, 0x00AE, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00C1, 0x00C2, 0x00C0,
|
||||
0x00A9, 0x2563, 0x2551, 0x2557, 0x255D, 0x00A2, 0x00A5, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x00E3, 0x00C3,
|
||||
0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
|
||||
0x00F0, 0x00D0, 0x00CA, 0x00CB, 0x00C8, 0x0131, 0x00CD, 0x00CE,
|
||||
0x00CF, 0x2518, 0x250C, 0x2588, 0x2584, 0x00A6, 0x00CC, 0x2580,
|
||||
0x00D3, 0x00DF, 0x00D4, 0x00D2, 0x00F5, 0x00D5, 0x00B5, 0x00FE,
|
||||
0x00DE, 0x00DA, 0x00DB, 0x00D9, 0x00FD, 0x00DD, 0x00AF, 0x00B4,
|
||||
0x00AD, 0x00B1, 0x2017, 0x00BE, 0x00B6, 0x00A7, 0x00F7, 0x00B8,
|
||||
0x00B0, 0x00A8, 0x00B7, 0x00B9, 0x00B3, 0x00B2, 0x25A0, 0x00A0
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 852
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const uint16_t Tbl[] = { /* CP852(0x80-0xFF) to Unicode conversion table */
|
||||
0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x016F, 0x0107, 0x00E7,
|
||||
0x0142, 0x00EB, 0x0150, 0x0151, 0x00EE, 0x0179, 0x00C4, 0x0106,
|
||||
0x00C9, 0x0139, 0x013A, 0x00F4, 0x00F6, 0x013D, 0x013E, 0x015A,
|
||||
0x015B, 0x00D6, 0x00DC, 0x0164, 0x0165, 0x0141, 0x00D7, 0x010D,
|
||||
0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x0104, 0x0105, 0x017D, 0x017E,
|
||||
0x0118, 0x0119, 0x00AC, 0x017A, 0x010C, 0x015F, 0x00AB, 0x00BB,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00C1, 0x00C2, 0x011A,
|
||||
0x015E, 0x2563, 0x2551, 0x2557, 0x255D, 0x017B, 0x017C, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x0102, 0x0103,
|
||||
0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
|
||||
0x0111, 0x0110, 0x010E, 0x00CB, 0x010F, 0x0147, 0x00CD, 0x00CE,
|
||||
0x011B, 0x2518, 0x250C, 0x2588, 0x2584, 0x0162, 0x016E, 0x2580,
|
||||
0x00D3, 0x00DF, 0x00D4, 0x0143, 0x0144, 0x0148, 0x0160, 0x0161,
|
||||
0x0154, 0x00DA, 0x0155, 0x0170, 0x00FD, 0x00DD, 0x0163, 0x00B4,
|
||||
0x00AD, 0x02DD, 0x02DB, 0x02C7, 0x02D8, 0x00A7, 0x00F7, 0x00B8,
|
||||
0x00B0, 0x00A8, 0x02D9, 0x0171, 0x0158, 0x0159, 0x25A0, 0x00A0
|
||||
const uint16_t Tbl[] =
|
||||
{
|
||||
/* CP852(0x80-0xFF) to Unicode conversion table */
|
||||
0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x016F, 0x0107, 0x00E7,
|
||||
0x0142, 0x00EB, 0x0150, 0x0151, 0x00EE, 0x0179, 0x00C4, 0x0106,
|
||||
0x00C9, 0x0139, 0x013A, 0x00F4, 0x00F6, 0x013D, 0x013E, 0x015A,
|
||||
0x015B, 0x00D6, 0x00DC, 0x0164, 0x0165, 0x0141, 0x00D7, 0x010D,
|
||||
0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x0104, 0x0105, 0x017D, 0x017E,
|
||||
0x0118, 0x0119, 0x00AC, 0x017A, 0x010C, 0x015F, 0x00AB, 0x00BB,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00C1, 0x00C2, 0x011A,
|
||||
0x015E, 0x2563, 0x2551, 0x2557, 0x255D, 0x017B, 0x017C, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x0102, 0x0103,
|
||||
0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
|
||||
0x0111, 0x0110, 0x010E, 0x00CB, 0x010F, 0x0147, 0x00CD, 0x00CE,
|
||||
0x011B, 0x2518, 0x250C, 0x2588, 0x2584, 0x0162, 0x016E, 0x2580,
|
||||
0x00D3, 0x00DF, 0x00D4, 0x0143, 0x0144, 0x0148, 0x0160, 0x0161,
|
||||
0x0154, 0x00DA, 0x0155, 0x0170, 0x00FD, 0x00DD, 0x0163, 0x00B4,
|
||||
0x00AD, 0x02DD, 0x02DB, 0x02C7, 0x02D8, 0x00A7, 0x00F7, 0x00B8,
|
||||
0x00B0, 0x00A8, 0x02D9, 0x0171, 0x0158, 0x0159, 0x25A0, 0x00A0
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 855
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const uint16_t Tbl[] = { /* CP855(0x80-0xFF) to Unicode conversion table */
|
||||
0x0452, 0x0402, 0x0453, 0x0403, 0x0451, 0x0401, 0x0454, 0x0404,
|
||||
0x0455, 0x0405, 0x0456, 0x0406, 0x0457, 0x0407, 0x0458, 0x0408,
|
||||
0x0459, 0x0409, 0x045A, 0x040A, 0x045B, 0x040B, 0x045C, 0x040C,
|
||||
0x045E, 0x040E, 0x045F, 0x040F, 0x044E, 0x042E, 0x044A, 0x042A,
|
||||
0x0430, 0x0410, 0x0431, 0x0411, 0x0446, 0x0426, 0x0434, 0x0414,
|
||||
0x0435, 0x0415, 0x0444, 0x0424, 0x0433, 0x0413, 0x00AB, 0x00BB,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x0445, 0x0425, 0x0438,
|
||||
0x0418, 0x2563, 0x2551, 0x2557, 0x255D, 0x0439, 0x0419, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x043A, 0x041A,
|
||||
0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
|
||||
0x043B, 0x041B, 0x043C, 0x041C, 0x043D, 0x041D, 0x043E, 0x041E,
|
||||
0x043F, 0x2518, 0x250C, 0x2588, 0x2584, 0x041F, 0x044F, 0x2580,
|
||||
0x042F, 0x0440, 0x0420, 0x0441, 0x0421, 0x0442, 0x0422, 0x0443,
|
||||
0x0423, 0x0436, 0x0416, 0x0432, 0x0412, 0x044C, 0x042C, 0x2116,
|
||||
0x00AD, 0x044B, 0x042B, 0x0437, 0x0417, 0x0448, 0x0428, 0x044D,
|
||||
0x042D, 0x0449, 0x0429, 0x0447, 0x0427, 0x00A7, 0x25A0, 0x00A0
|
||||
const uint16_t Tbl[] =
|
||||
{
|
||||
/* CP855(0x80-0xFF) to Unicode conversion table */
|
||||
0x0452, 0x0402, 0x0453, 0x0403, 0x0451, 0x0401, 0x0454, 0x0404,
|
||||
0x0455, 0x0405, 0x0456, 0x0406, 0x0457, 0x0407, 0x0458, 0x0408,
|
||||
0x0459, 0x0409, 0x045A, 0x040A, 0x045B, 0x040B, 0x045C, 0x040C,
|
||||
0x045E, 0x040E, 0x045F, 0x040F, 0x044E, 0x042E, 0x044A, 0x042A,
|
||||
0x0430, 0x0410, 0x0431, 0x0411, 0x0446, 0x0426, 0x0434, 0x0414,
|
||||
0x0435, 0x0415, 0x0444, 0x0424, 0x0433, 0x0413, 0x00AB, 0x00BB,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x0445, 0x0425, 0x0438,
|
||||
0x0418, 0x2563, 0x2551, 0x2557, 0x255D, 0x0439, 0x0419, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x043A, 0x041A,
|
||||
0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
|
||||
0x043B, 0x041B, 0x043C, 0x041C, 0x043D, 0x041D, 0x043E, 0x041E,
|
||||
0x043F, 0x2518, 0x250C, 0x2588, 0x2584, 0x041F, 0x044F, 0x2580,
|
||||
0x042F, 0x0440, 0x0420, 0x0441, 0x0421, 0x0442, 0x0422, 0x0443,
|
||||
0x0423, 0x0436, 0x0416, 0x0432, 0x0412, 0x044C, 0x042C, 0x2116,
|
||||
0x00AD, 0x044B, 0x042B, 0x0437, 0x0417, 0x0448, 0x0428, 0x044D,
|
||||
0x042D, 0x0449, 0x0429, 0x0447, 0x0427, 0x00A7, 0x25A0, 0x00A0
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 857
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const uint16_t Tbl[] = { /* CP857(0x80-0xFF) to Unicode conversion table */
|
||||
0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7,
|
||||
0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x0131, 0x00C4, 0x00C5,
|
||||
0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9,
|
||||
0x0130, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x015E, 0x015F,
|
||||
0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x011E, 0x011F,
|
||||
0x00BF, 0x00AE, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00C1, 0x00C2, 0x00C0,
|
||||
0x00A9, 0x2563, 0x2551, 0x2557, 0x255D, 0x00A2, 0x00A5, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x00E3, 0x00C3,
|
||||
0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
|
||||
0x00BA, 0x00AA, 0x00CA, 0x00CB, 0x00C8, 0x0000, 0x00CD, 0x00CE,
|
||||
0x00CF, 0x2518, 0x250C, 0x2588, 0x2584, 0x00A6, 0x00CC, 0x2580,
|
||||
0x00D3, 0x00DF, 0x00D4, 0x00D2, 0x00F5, 0x00D5, 0x00B5, 0x0000,
|
||||
0x00D7, 0x00DA, 0x00DB, 0x00D9, 0x00EC, 0x00FF, 0x00AF, 0x00B4,
|
||||
0x00AD, 0x00B1, 0x0000, 0x00BE, 0x00B6, 0x00A7, 0x00F7, 0x00B8,
|
||||
0x00B0, 0x00A8, 0x00B7, 0x00B9, 0x00B3, 0x00B2, 0x25A0, 0x00A0
|
||||
const uint16_t Tbl[] =
|
||||
{
|
||||
/* CP857(0x80-0xFF) to Unicode conversion table */
|
||||
0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7,
|
||||
0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x0131, 0x00C4, 0x00C5,
|
||||
0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9,
|
||||
0x0130, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x015E, 0x015F,
|
||||
0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x011E, 0x011F,
|
||||
0x00BF, 0x00AE, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00C1, 0x00C2, 0x00C0,
|
||||
0x00A9, 0x2563, 0x2551, 0x2557, 0x255D, 0x00A2, 0x00A5, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x00E3, 0x00C3,
|
||||
0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
|
||||
0x00BA, 0x00AA, 0x00CA, 0x00CB, 0x00C8, 0x0000, 0x00CD, 0x00CE,
|
||||
0x00CF, 0x2518, 0x250C, 0x2588, 0x2584, 0x00A6, 0x00CC, 0x2580,
|
||||
0x00D3, 0x00DF, 0x00D4, 0x00D2, 0x00F5, 0x00D5, 0x00B5, 0x0000,
|
||||
0x00D7, 0x00DA, 0x00DB, 0x00D9, 0x00EC, 0x00FF, 0x00AF, 0x00B4,
|
||||
0x00AD, 0x00B1, 0x0000, 0x00BE, 0x00B6, 0x00A7, 0x00F7, 0x00B8,
|
||||
0x00B0, 0x00A8, 0x00B7, 0x00B9, 0x00B3, 0x00B2, 0x25A0, 0x00A0
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 858
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const uint16_t Tbl[] = { /* CP858(0x80-0xFF) to Unicode conversion table */
|
||||
0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7,
|
||||
0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4, 0x00C5,
|
||||
0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9,
|
||||
0x00FF, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x00D7, 0x0192,
|
||||
0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA,
|
||||
0x00BF, 0x00AE, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00C1, 0x00C2, 0x00C0,
|
||||
0x00A9, 0x2563, 0x2551, 0x2557, 0x2550, 0x00A2, 0x00A5, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x00E3, 0x00C3,
|
||||
0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
|
||||
0x00F0, 0x00D0, 0x00CA, 0x00CB, 0x00C8, 0x20AC, 0x00CD, 0x00CE,
|
||||
0x00CF, 0x2518, 0x250C, 0x2588, 0x2584, 0x00C6, 0x00CC, 0x2580,
|
||||
0x00D3, 0x00DF, 0x00D4, 0x00D2, 0x00F5, 0x00D5, 0x00B5, 0x00FE,
|
||||
0x00DE, 0x00DA, 0x00DB, 0x00D9, 0x00FD, 0x00DD, 0x00AF, 0x00B4,
|
||||
0x00AD, 0x00B1, 0x2017, 0x00BE, 0x00B6, 0x00A7, 0x00F7, 0x00B8,
|
||||
0x00B0, 0x00A8, 0x00B7, 0x00B9, 0x00B3, 0x00B2, 0x25A0, 0x00A0
|
||||
const uint16_t Tbl[] =
|
||||
{
|
||||
/* CP858(0x80-0xFF) to Unicode conversion table */
|
||||
0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7,
|
||||
0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4, 0x00C5,
|
||||
0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9,
|
||||
0x00FF, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x00D7, 0x0192,
|
||||
0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA,
|
||||
0x00BF, 0x00AE, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00C1, 0x00C2, 0x00C0,
|
||||
0x00A9, 0x2563, 0x2551, 0x2557, 0x2550, 0x00A2, 0x00A5, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x00E3, 0x00C3,
|
||||
0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
|
||||
0x00F0, 0x00D0, 0x00CA, 0x00CB, 0x00C8, 0x20AC, 0x00CD, 0x00CE,
|
||||
0x00CF, 0x2518, 0x250C, 0x2588, 0x2584, 0x00C6, 0x00CC, 0x2580,
|
||||
0x00D3, 0x00DF, 0x00D4, 0x00D2, 0x00F5, 0x00D5, 0x00B5, 0x00FE,
|
||||
0x00DE, 0x00DA, 0x00DB, 0x00D9, 0x00FD, 0x00DD, 0x00AF, 0x00B4,
|
||||
0x00AD, 0x00B1, 0x2017, 0x00BE, 0x00B6, 0x00A7, 0x00F7, 0x00B8,
|
||||
0x00B0, 0x00A8, 0x00B7, 0x00B9, 0x00B3, 0x00B2, 0x25A0, 0x00A0
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 862
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const uint16_t Tbl[] = { /* CP862(0x80-0xFF) to Unicode conversion table */
|
||||
0x05D0, 0x05D1, 0x05D2, 0x05D3, 0x05D4, 0x05D5, 0x05D6, 0x05D7,
|
||||
0x05D8, 0x05D9, 0x05DA, 0x05DB, 0x05DC, 0x05DD, 0x05DE, 0x05DF,
|
||||
0x05E0, 0x05E1, 0x05E2, 0x05E3, 0x05E4, 0x05E5, 0x05E6, 0x05E7,
|
||||
0x05E8, 0x05E9, 0x05EA, 0x00A2, 0x00A3, 0x00A5, 0x20A7, 0x0192,
|
||||
0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA,
|
||||
0x00BF, 0x2310, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
|
||||
0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
|
||||
0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
|
||||
0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
|
||||
0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
|
||||
0x03B1, 0x00DF, 0x0393, 0x03C0, 0x03A3, 0x03C3, 0x00B5, 0x03C4,
|
||||
0x03A6, 0x0398, 0x03A9, 0x03B4, 0x221E, 0x03C6, 0x03B5, 0x2229,
|
||||
0x2261, 0x00B1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00F7, 0x2248,
|
||||
0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0
|
||||
const uint16_t Tbl[] =
|
||||
{
|
||||
/* CP862(0x80-0xFF) to Unicode conversion table */
|
||||
0x05D0, 0x05D1, 0x05D2, 0x05D3, 0x05D4, 0x05D5, 0x05D6, 0x05D7,
|
||||
0x05D8, 0x05D9, 0x05DA, 0x05DB, 0x05DC, 0x05DD, 0x05DE, 0x05DF,
|
||||
0x05E0, 0x05E1, 0x05E2, 0x05E3, 0x05E4, 0x05E5, 0x05E6, 0x05E7,
|
||||
0x05E8, 0x05E9, 0x05EA, 0x00A2, 0x00A3, 0x00A5, 0x20A7, 0x0192,
|
||||
0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA,
|
||||
0x00BF, 0x2310, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
|
||||
0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
|
||||
0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
|
||||
0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
|
||||
0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
|
||||
0x03B1, 0x00DF, 0x0393, 0x03C0, 0x03A3, 0x03C3, 0x00B5, 0x03C4,
|
||||
0x03A6, 0x0398, 0x03A9, 0x03B4, 0x221E, 0x03C6, 0x03B5, 0x2229,
|
||||
0x2261, 0x00B1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00F7, 0x2248,
|
||||
0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 866
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const uint16_t Tbl[] = { /* CP866(0x80-0xFF) to Unicode conversion table */
|
||||
0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417,
|
||||
0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
|
||||
0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427,
|
||||
0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
|
||||
0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437,
|
||||
0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
|
||||
0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
|
||||
0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
|
||||
0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
|
||||
0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
|
||||
0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
|
||||
0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,
|
||||
0x0401, 0x0451, 0x0404, 0x0454, 0x0407, 0x0457, 0x040E, 0x045E,
|
||||
0x00B0, 0x2219, 0x00B7, 0x221A, 0x2116, 0x00A4, 0x25A0, 0x00A0
|
||||
const uint16_t Tbl[] =
|
||||
{
|
||||
/* CP866(0x80-0xFF) to Unicode conversion table */
|
||||
0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417,
|
||||
0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
|
||||
0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427,
|
||||
0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
|
||||
0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437,
|
||||
0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
|
||||
0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
|
||||
0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
|
||||
0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
|
||||
0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
|
||||
0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
|
||||
0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,
|
||||
0x0401, 0x0451, 0x0404, 0x0454, 0x0407, 0x0457, 0x040E, 0x045E,
|
||||
0x00B0, 0x2219, 0x00B7, 0x221A, 0x2116, 0x00A4, 0x25A0, 0x00A0
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 874
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const uint16_t Tbl[] = { /* CP874(0x80-0xFF) to Unicode conversion table */
|
||||
0x20AC, 0x0000, 0x0000, 0x0000, 0x0000, 0x2026, 0x0000, 0x0000,
|
||||
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
|
||||
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x00A0, 0x0E01, 0x0E02, 0x0E03, 0x0E04, 0x0E05, 0x0E06, 0x0E07,
|
||||
0x0E08, 0x0E09, 0x0E0A, 0x0E0B, 0x0E0C, 0x0E0D, 0x0E0E, 0x0E0F,
|
||||
0x0E10, 0x0E11, 0x0E12, 0x0E13, 0x0E14, 0x0E15, 0x0E16, 0x0E17,
|
||||
0x0E18, 0x0E19, 0x0E1A, 0x0E1B, 0x0E1C, 0x0E1D, 0x0E1E, 0x0E1F,
|
||||
0x0E20, 0x0E21, 0x0E22, 0x0E23, 0x0E24, 0x0E25, 0x0E26, 0x0E27,
|
||||
0x0E28, 0x0E29, 0x0E2A, 0x0E2B, 0x0E2C, 0x0E2D, 0x0E2E, 0x0E2F,
|
||||
0x0E30, 0x0E31, 0x0E32, 0x0E33, 0x0E34, 0x0E35, 0x0E36, 0x0E37,
|
||||
0x0E38, 0x0E39, 0x0E3A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0E3F,
|
||||
0x0E40, 0x0E41, 0x0E42, 0x0E43, 0x0E44, 0x0E45, 0x0E46, 0x0E47,
|
||||
0x0E48, 0x0E49, 0x0E4A, 0x0E4B, 0x0E4C, 0x0E4D, 0x0E4E, 0x0E4F,
|
||||
0x0E50, 0x0E51, 0x0E52, 0x0E53, 0x0E54, 0x0E55, 0x0E56, 0x0E57,
|
||||
0x0E58, 0x0E59, 0x0E5A, 0x0E5B, 0x0000, 0x0000, 0x0000, 0x0000
|
||||
const uint16_t Tbl[] =
|
||||
{
|
||||
/* CP874(0x80-0xFF) to Unicode conversion table */
|
||||
0x20AC, 0x0000, 0x0000, 0x0000, 0x0000, 0x2026, 0x0000, 0x0000,
|
||||
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
|
||||
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x00A0, 0x0E01, 0x0E02, 0x0E03, 0x0E04, 0x0E05, 0x0E06, 0x0E07,
|
||||
0x0E08, 0x0E09, 0x0E0A, 0x0E0B, 0x0E0C, 0x0E0D, 0x0E0E, 0x0E0F,
|
||||
0x0E10, 0x0E11, 0x0E12, 0x0E13, 0x0E14, 0x0E15, 0x0E16, 0x0E17,
|
||||
0x0E18, 0x0E19, 0x0E1A, 0x0E1B, 0x0E1C, 0x0E1D, 0x0E1E, 0x0E1F,
|
||||
0x0E20, 0x0E21, 0x0E22, 0x0E23, 0x0E24, 0x0E25, 0x0E26, 0x0E27,
|
||||
0x0E28, 0x0E29, 0x0E2A, 0x0E2B, 0x0E2C, 0x0E2D, 0x0E2E, 0x0E2F,
|
||||
0x0E30, 0x0E31, 0x0E32, 0x0E33, 0x0E34, 0x0E35, 0x0E36, 0x0E37,
|
||||
0x0E38, 0x0E39, 0x0E3A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0E3F,
|
||||
0x0E40, 0x0E41, 0x0E42, 0x0E43, 0x0E44, 0x0E45, 0x0E46, 0x0E47,
|
||||
0x0E48, 0x0E49, 0x0E4A, 0x0E4B, 0x0E4C, 0x0E4D, 0x0E4E, 0x0E4F,
|
||||
0x0E50, 0x0E51, 0x0E52, 0x0E53, 0x0E54, 0x0E55, 0x0E56, 0x0E57,
|
||||
0x0E58, 0x0E59, 0x0E5A, 0x0E5B, 0x0000, 0x0000, 0x0000, 0x0000
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 1250
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const uint16_t Tbl[] = { /* CP1250(0x80-0xFF) to Unicode conversion table */
|
||||
0x20AC, 0x0000, 0x201A, 0x0000, 0x201E, 0x2026, 0x2020, 0x2021,
|
||||
0x0000, 0x2030, 0x0160, 0x2039, 0x015A, 0x0164, 0x017D, 0x0179,
|
||||
0x0000, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
|
||||
0x0000, 0x2122, 0x0161, 0x203A, 0x015B, 0x0165, 0x017E, 0x017A,
|
||||
0x00A0, 0x02C7, 0x02D8, 0x0141, 0x00A4, 0x0104, 0x00A6, 0x00A7,
|
||||
0x00A8, 0x00A9, 0x015E, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x017B,
|
||||
0x00B0, 0x00B1, 0x02DB, 0x0142, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
|
||||
0x00B8, 0x0105, 0x015F, 0x00BB, 0x013D, 0x02DD, 0x013E, 0x017C,
|
||||
0x0154, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x0139, 0x0106, 0x00C7,
|
||||
0x010C, 0x00C9, 0x0118, 0x00CB, 0x011A, 0x00CD, 0x00CE, 0x010E,
|
||||
0x0110, 0x0143, 0x0147, 0x00D3, 0x00D4, 0x0150, 0x00D6, 0x00D7,
|
||||
0x0158, 0x016E, 0x00DA, 0x0170, 0x00DC, 0x00DD, 0x0162, 0x00DF,
|
||||
0x0155, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x013A, 0x0107, 0x00E7,
|
||||
0x010D, 0x00E9, 0x0119, 0x00EB, 0x011B, 0x00ED, 0x00EE, 0x010F,
|
||||
0x0111, 0x0144, 0x0148, 0x00F3, 0x00F4, 0x0151, 0x00F6, 0x00F7,
|
||||
0x0159, 0x016F, 0x00FA, 0x0171, 0x00FC, 0x00FD, 0x0163, 0x02D9
|
||||
const uint16_t Tbl[] =
|
||||
{
|
||||
/* CP1250(0x80-0xFF) to Unicode conversion table */
|
||||
0x20AC, 0x0000, 0x201A, 0x0000, 0x201E, 0x2026, 0x2020, 0x2021,
|
||||
0x0000, 0x2030, 0x0160, 0x2039, 0x015A, 0x0164, 0x017D, 0x0179,
|
||||
0x0000, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
|
||||
0x0000, 0x2122, 0x0161, 0x203A, 0x015B, 0x0165, 0x017E, 0x017A,
|
||||
0x00A0, 0x02C7, 0x02D8, 0x0141, 0x00A4, 0x0104, 0x00A6, 0x00A7,
|
||||
0x00A8, 0x00A9, 0x015E, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x017B,
|
||||
0x00B0, 0x00B1, 0x02DB, 0x0142, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
|
||||
0x00B8, 0x0105, 0x015F, 0x00BB, 0x013D, 0x02DD, 0x013E, 0x017C,
|
||||
0x0154, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x0139, 0x0106, 0x00C7,
|
||||
0x010C, 0x00C9, 0x0118, 0x00CB, 0x011A, 0x00CD, 0x00CE, 0x010E,
|
||||
0x0110, 0x0143, 0x0147, 0x00D3, 0x00D4, 0x0150, 0x00D6, 0x00D7,
|
||||
0x0158, 0x016E, 0x00DA, 0x0170, 0x00DC, 0x00DD, 0x0162, 0x00DF,
|
||||
0x0155, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x013A, 0x0107, 0x00E7,
|
||||
0x010D, 0x00E9, 0x0119, 0x00EB, 0x011B, 0x00ED, 0x00EE, 0x010F,
|
||||
0x0111, 0x0144, 0x0148, 0x00F3, 0x00F4, 0x0151, 0x00F6, 0x00F7,
|
||||
0x0159, 0x016F, 0x00FA, 0x0171, 0x00FC, 0x00FD, 0x0163, 0x02D9
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 1251
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const uint16_t Tbl[] = { /* CP1251(0x80-0xFF) to Unicode conversion table */
|
||||
0x0402, 0x0403, 0x201A, 0x0453, 0x201E, 0x2026, 0x2020, 0x2021,
|
||||
0x20AC, 0x2030, 0x0409, 0x2039, 0x040A, 0x040C, 0x040B, 0x040F,
|
||||
0x0452, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
|
||||
0x0000, 0x2111, 0x0459, 0x203A, 0x045A, 0x045C, 0x045B, 0x045F,
|
||||
0x00A0, 0x040E, 0x045E, 0x0408, 0x00A4, 0x0490, 0x00A6, 0x00A7,
|
||||
0x0401, 0x00A9, 0x0404, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x0407,
|
||||
0x00B0, 0x00B1, 0x0406, 0x0456, 0x0491, 0x00B5, 0x00B6, 0x00B7,
|
||||
0x0451, 0x2116, 0x0454, 0x00BB, 0x0458, 0x0405, 0x0455, 0x0457,
|
||||
0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417,
|
||||
0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
|
||||
0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427,
|
||||
0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
|
||||
0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437,
|
||||
0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
|
||||
0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
|
||||
0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F
|
||||
const uint16_t Tbl[] =
|
||||
{
|
||||
/* CP1251(0x80-0xFF) to Unicode conversion table */
|
||||
0x0402, 0x0403, 0x201A, 0x0453, 0x201E, 0x2026, 0x2020, 0x2021,
|
||||
0x20AC, 0x2030, 0x0409, 0x2039, 0x040A, 0x040C, 0x040B, 0x040F,
|
||||
0x0452, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
|
||||
0x0000, 0x2111, 0x0459, 0x203A, 0x045A, 0x045C, 0x045B, 0x045F,
|
||||
0x00A0, 0x040E, 0x045E, 0x0408, 0x00A4, 0x0490, 0x00A6, 0x00A7,
|
||||
0x0401, 0x00A9, 0x0404, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x0407,
|
||||
0x00B0, 0x00B1, 0x0406, 0x0456, 0x0491, 0x00B5, 0x00B6, 0x00B7,
|
||||
0x0451, 0x2116, 0x0454, 0x00BB, 0x0458, 0x0405, 0x0455, 0x0457,
|
||||
0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417,
|
||||
0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
|
||||
0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427,
|
||||
0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
|
||||
0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437,
|
||||
0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
|
||||
0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
|
||||
0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 1252
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const uint16_t Tbl[] = { /* CP1252(0x80-0xFF) to Unicode conversion table */
|
||||
0x20AC, 0x0000, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
|
||||
0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0x0000, 0x017D, 0x0000,
|
||||
0x0000, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
|
||||
0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0x0000, 0x017E, 0x0178,
|
||||
0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
|
||||
0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
|
||||
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
|
||||
0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
|
||||
0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
|
||||
0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
|
||||
0x00D0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
|
||||
0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF,
|
||||
0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
|
||||
0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
|
||||
0x00F0, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
|
||||
0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x00FF
|
||||
const uint16_t Tbl[] =
|
||||
{
|
||||
/* CP1252(0x80-0xFF) to Unicode conversion table */
|
||||
0x20AC, 0x0000, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
|
||||
0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0x0000, 0x017D, 0x0000,
|
||||
0x0000, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
|
||||
0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0x0000, 0x017E, 0x0178,
|
||||
0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
|
||||
0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
|
||||
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
|
||||
0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
|
||||
0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
|
||||
0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
|
||||
0x00D0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
|
||||
0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF,
|
||||
0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
|
||||
0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
|
||||
0x00F0, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
|
||||
0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x00FF
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 1253
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const uint16_t Tbl[] = { /* CP1253(0x80-0xFF) to Unicode conversion table */
|
||||
0x20AC, 0x0000, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
|
||||
0x0000, 0x2030, 0x0000, 0x2039, 0x000C, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
|
||||
0x0000, 0x2122, 0x0000, 0x203A, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x00A0, 0x0385, 0x0386, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
|
||||
0x00A8, 0x00A9, 0x0000, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x2015,
|
||||
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x0384, 0x00B5, 0x00B6, 0x00B7,
|
||||
0x0388, 0x0389, 0x038A, 0x00BB, 0x038C, 0x00BD, 0x038E, 0x038F,
|
||||
0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397,
|
||||
0x0398, 0x0399, 0x039A, 0x039B, 0x039C, 0x039D, 0x039E, 0x039F,
|
||||
0x03A0, 0x03A1, 0x0000, 0x03A3, 0x03A4, 0x03A5, 0x03A6, 0x03A7,
|
||||
0x03A8, 0x03A9, 0x03AA, 0x03AD, 0x03AC, 0x03AD, 0x03AE, 0x03AF,
|
||||
0x03B0, 0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7,
|
||||
0x03B8, 0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF,
|
||||
0x03C0, 0x03C1, 0x03C2, 0x03C3, 0x03C4, 0x03C5, 0x03C6, 0x03C7,
|
||||
0x03C8, 0x03C9, 0x03CA, 0x03CB, 0x03CC, 0x03CD, 0x03CE, 0x0000
|
||||
const uint16_t Tbl[] =
|
||||
{
|
||||
/* CP1253(0x80-0xFF) to Unicode conversion table */
|
||||
0x20AC, 0x0000, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
|
||||
0x0000, 0x2030, 0x0000, 0x2039, 0x000C, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
|
||||
0x0000, 0x2122, 0x0000, 0x203A, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x00A0, 0x0385, 0x0386, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
|
||||
0x00A8, 0x00A9, 0x0000, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x2015,
|
||||
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x0384, 0x00B5, 0x00B6, 0x00B7,
|
||||
0x0388, 0x0389, 0x038A, 0x00BB, 0x038C, 0x00BD, 0x038E, 0x038F,
|
||||
0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397,
|
||||
0x0398, 0x0399, 0x039A, 0x039B, 0x039C, 0x039D, 0x039E, 0x039F,
|
||||
0x03A0, 0x03A1, 0x0000, 0x03A3, 0x03A4, 0x03A5, 0x03A6, 0x03A7,
|
||||
0x03A8, 0x03A9, 0x03AA, 0x03AD, 0x03AC, 0x03AD, 0x03AE, 0x03AF,
|
||||
0x03B0, 0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7,
|
||||
0x03B8, 0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF,
|
||||
0x03C0, 0x03C1, 0x03C2, 0x03C3, 0x03C4, 0x03C5, 0x03C6, 0x03C7,
|
||||
0x03C8, 0x03C9, 0x03CA, 0x03CB, 0x03CC, 0x03CD, 0x03CE, 0x0000
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 1254
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const uint16_t Tbl[] = { /* CP1254(0x80-0xFF) to Unicode conversion table */
|
||||
0x20AC, 0x0000, 0x210A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
|
||||
0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
|
||||
0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0x0000, 0x0000, 0x0178,
|
||||
0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
|
||||
0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
|
||||
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
|
||||
0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
|
||||
0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
|
||||
0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
|
||||
0x011E, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
|
||||
0x00D8, 0x00D9, 0x00DA, 0x00BD, 0x00DC, 0x0130, 0x015E, 0x00DF,
|
||||
0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
|
||||
0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
|
||||
0x011F, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
|
||||
0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x0131, 0x015F, 0x00FF
|
||||
const uint16_t Tbl[] =
|
||||
{
|
||||
/* CP1254(0x80-0xFF) to Unicode conversion table */
|
||||
0x20AC, 0x0000, 0x210A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
|
||||
0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
|
||||
0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0x0000, 0x0000, 0x0178,
|
||||
0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
|
||||
0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
|
||||
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
|
||||
0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
|
||||
0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
|
||||
0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
|
||||
0x011E, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
|
||||
0x00D8, 0x00D9, 0x00DA, 0x00BD, 0x00DC, 0x0130, 0x015E, 0x00DF,
|
||||
0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
|
||||
0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
|
||||
0x011F, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
|
||||
0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x0131, 0x015F, 0x00FF
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 1255
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const uint16_t Tbl[] = { /* CP1255(0x80-0xFF) to Unicode conversion table */
|
||||
0x20AC, 0x0000, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
|
||||
0x02C6, 0x2030, 0x0000, 0x2039, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
|
||||
0x02DC, 0x2122, 0x0000, 0x203A, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
|
||||
0x00A8, 0x00A9, 0x00D7, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
|
||||
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
|
||||
0x00B8, 0x00B9, 0x00F7, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
|
||||
0x05B0, 0x05B1, 0x05B2, 0x05B3, 0x05B4, 0x05B5, 0x05B6, 0x05B7,
|
||||
0x05B8, 0x05B9, 0x0000, 0x05BB, 0x05BC, 0x05BD, 0x05BE, 0x05BF,
|
||||
0x05C0, 0x05C1, 0x05C2, 0x05C3, 0x05F0, 0x05F1, 0x05F2, 0x05F3,
|
||||
0x05F4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x05D0, 0x05D1, 0x05D2, 0x05D3, 0x05D4, 0x05D5, 0x05D6, 0x05D7,
|
||||
0x05D8, 0x05D9, 0x05DA, 0x05DB, 0x05DC, 0x05DD, 0x05DE, 0x05DF,
|
||||
0x05E0, 0x05E1, 0x05E2, 0x05E3, 0x05E4, 0x05E5, 0x05E6, 0x05E7,
|
||||
0x05E8, 0x05E9, 0x05EA, 0x0000, 0x0000, 0x200E, 0x200F, 0x0000
|
||||
const uint16_t Tbl[] =
|
||||
{
|
||||
/* CP1255(0x80-0xFF) to Unicode conversion table */
|
||||
0x20AC, 0x0000, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
|
||||
0x02C6, 0x2030, 0x0000, 0x2039, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
|
||||
0x02DC, 0x2122, 0x0000, 0x203A, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
|
||||
0x00A8, 0x00A9, 0x00D7, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
|
||||
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
|
||||
0x00B8, 0x00B9, 0x00F7, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
|
||||
0x05B0, 0x05B1, 0x05B2, 0x05B3, 0x05B4, 0x05B5, 0x05B6, 0x05B7,
|
||||
0x05B8, 0x05B9, 0x0000, 0x05BB, 0x05BC, 0x05BD, 0x05BE, 0x05BF,
|
||||
0x05C0, 0x05C1, 0x05C2, 0x05C3, 0x05F0, 0x05F1, 0x05F2, 0x05F3,
|
||||
0x05F4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x05D0, 0x05D1, 0x05D2, 0x05D3, 0x05D4, 0x05D5, 0x05D6, 0x05D7,
|
||||
0x05D8, 0x05D9, 0x05DA, 0x05DB, 0x05DC, 0x05DD, 0x05DE, 0x05DF,
|
||||
0x05E0, 0x05E1, 0x05E2, 0x05E3, 0x05E4, 0x05E5, 0x05E6, 0x05E7,
|
||||
0x05E8, 0x05E9, 0x05EA, 0x0000, 0x0000, 0x200E, 0x200F, 0x0000
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 1256
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const uint16_t Tbl[] = { /* CP1256(0x80-0xFF) to Unicode conversion table */
|
||||
0x20AC, 0x067E, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
|
||||
0x02C6, 0x2030, 0x0679, 0x2039, 0x0152, 0x0686, 0x0698, 0x0688,
|
||||
0x06AF, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
|
||||
0x06A9, 0x2122, 0x0691, 0x203A, 0x0153, 0x200C, 0x200D, 0x06BA,
|
||||
0x00A0, 0x060C, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
|
||||
0x00A8, 0x00A9, 0x06BE, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
|
||||
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
|
||||
0x00B8, 0x00B9, 0x061B, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x061F,
|
||||
0x06C1, 0x0621, 0x0622, 0x0623, 0x0624, 0x0625, 0x0626, 0x0627,
|
||||
0x0628, 0x0629, 0x062A, 0x062B, 0x062C, 0x062D, 0x062E, 0x062F,
|
||||
0x0630, 0x0631, 0x0632, 0x0633, 0x0634, 0x0635, 0x0636, 0x00D7,
|
||||
0x0637, 0x0638, 0x0639, 0x063A, 0x0640, 0x0640, 0x0642, 0x0643,
|
||||
0x00E0, 0x0644, 0x00E2, 0x0645, 0x0646, 0x0647, 0x0648, 0x00E7,
|
||||
0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x0649, 0x064A, 0x00EE, 0x00EF,
|
||||
0x064B, 0x064C, 0x064D, 0x064E, 0x00F4, 0x064F, 0x0650, 0x00F7,
|
||||
0x0651, 0x00F9, 0x0652, 0x00FB, 0x00FC, 0x200E, 0x200F, 0x06D2
|
||||
const uint16_t Tbl[] =
|
||||
{
|
||||
/* CP1256(0x80-0xFF) to Unicode conversion table */
|
||||
0x20AC, 0x067E, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
|
||||
0x02C6, 0x2030, 0x0679, 0x2039, 0x0152, 0x0686, 0x0698, 0x0688,
|
||||
0x06AF, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
|
||||
0x06A9, 0x2122, 0x0691, 0x203A, 0x0153, 0x200C, 0x200D, 0x06BA,
|
||||
0x00A0, 0x060C, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
|
||||
0x00A8, 0x00A9, 0x06BE, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
|
||||
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
|
||||
0x00B8, 0x00B9, 0x061B, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x061F,
|
||||
0x06C1, 0x0621, 0x0622, 0x0623, 0x0624, 0x0625, 0x0626, 0x0627,
|
||||
0x0628, 0x0629, 0x062A, 0x062B, 0x062C, 0x062D, 0x062E, 0x062F,
|
||||
0x0630, 0x0631, 0x0632, 0x0633, 0x0634, 0x0635, 0x0636, 0x00D7,
|
||||
0x0637, 0x0638, 0x0639, 0x063A, 0x0640, 0x0640, 0x0642, 0x0643,
|
||||
0x00E0, 0x0644, 0x00E2, 0x0645, 0x0646, 0x0647, 0x0648, 0x00E7,
|
||||
0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x0649, 0x064A, 0x00EE, 0x00EF,
|
||||
0x064B, 0x064C, 0x064D, 0x064E, 0x00F4, 0x064F, 0x0650, 0x00F7,
|
||||
0x0651, 0x00F9, 0x0652, 0x00FB, 0x00FC, 0x200E, 0x200F, 0x06D2
|
||||
}
|
||||
|
||||
#elif _CODE_PAGE == 1257
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const uint16_t Tbl[] = { /* CP1257(0x80-0xFF) to Unicode conversion table */
|
||||
0x20AC, 0x0000, 0x201A, 0x0000, 0x201E, 0x2026, 0x2020, 0x2021,
|
||||
0x0000, 0x2030, 0x0000, 0x2039, 0x0000, 0x00A8, 0x02C7, 0x00B8,
|
||||
0x0000, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
|
||||
0x0000, 0x2122, 0x0000, 0x203A, 0x0000, 0x00AF, 0x02DB, 0x0000,
|
||||
0x00A0, 0x0000, 0x00A2, 0x00A3, 0x00A4, 0x0000, 0x00A6, 0x00A7,
|
||||
0x00D8, 0x00A9, 0x0156, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
|
||||
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
|
||||
0x00B8, 0x00B9, 0x0157, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00E6,
|
||||
0x0104, 0x012E, 0x0100, 0x0106, 0x00C4, 0x00C5, 0x0118, 0x0112,
|
||||
0x010C, 0x00C9, 0x0179, 0x0116, 0x0122, 0x0136, 0x012A, 0x013B,
|
||||
0x0160, 0x0143, 0x0145, 0x00D3, 0x014C, 0x00D5, 0x00D6, 0x00D7,
|
||||
0x0172, 0x0141, 0x015A, 0x016A, 0x00DC, 0x017B, 0x017D, 0x00DF,
|
||||
0x0105, 0x012F, 0x0101, 0x0107, 0x00E4, 0x00E5, 0x0119, 0x0113,
|
||||
0x010D, 0x00E9, 0x017A, 0x0117, 0x0123, 0x0137, 0x012B, 0x013C,
|
||||
0x0161, 0x0144, 0x0146, 0x00F3, 0x014D, 0x00F5, 0x00F6, 0x00F7,
|
||||
0x0173, 0x014E, 0x015B, 0x016B, 0x00FC, 0x017C, 0x017E, 0x02D9
|
||||
const uint16_t Tbl[] =
|
||||
{
|
||||
/* CP1257(0x80-0xFF) to Unicode conversion table */
|
||||
0x20AC, 0x0000, 0x201A, 0x0000, 0x201E, 0x2026, 0x2020, 0x2021,
|
||||
0x0000, 0x2030, 0x0000, 0x2039, 0x0000, 0x00A8, 0x02C7, 0x00B8,
|
||||
0x0000, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
|
||||
0x0000, 0x2122, 0x0000, 0x203A, 0x0000, 0x00AF, 0x02DB, 0x0000,
|
||||
0x00A0, 0x0000, 0x00A2, 0x00A3, 0x00A4, 0x0000, 0x00A6, 0x00A7,
|
||||
0x00D8, 0x00A9, 0x0156, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
|
||||
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
|
||||
0x00B8, 0x00B9, 0x0157, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00E6,
|
||||
0x0104, 0x012E, 0x0100, 0x0106, 0x00C4, 0x00C5, 0x0118, 0x0112,
|
||||
0x010C, 0x00C9, 0x0179, 0x0116, 0x0122, 0x0136, 0x012A, 0x013B,
|
||||
0x0160, 0x0143, 0x0145, 0x00D3, 0x014C, 0x00D5, 0x00D6, 0x00D7,
|
||||
0x0172, 0x0141, 0x015A, 0x016A, 0x00DC, 0x017B, 0x017D, 0x00DF,
|
||||
0x0105, 0x012F, 0x0101, 0x0107, 0x00E4, 0x00E5, 0x0119, 0x0113,
|
||||
0x010D, 0x00E9, 0x017A, 0x0117, 0x0123, 0x0137, 0x012B, 0x013C,
|
||||
0x0161, 0x0144, 0x0146, 0x00F3, 0x014D, 0x00F5, 0x00F6, 0x00F7,
|
||||
0x0173, 0x014E, 0x015B, 0x016B, 0x00FC, 0x017C, 0x017E, 0x02D9
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 1258
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const uint16_t Tbl[] = { /* CP1258(0x80-0xFF) to Unicode conversion table */
|
||||
0x20AC, 0x0000, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
|
||||
0x02C6, 0x2030, 0x0000, 0x2039, 0x0152, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
|
||||
0x02DC, 0x2122, 0x0000, 0x203A, 0x0153, 0x0000, 0x0000, 0x0178,
|
||||
0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
|
||||
0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
|
||||
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
|
||||
0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
|
||||
0x00C0, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
|
||||
0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x0300, 0x00CD, 0x00CE, 0x00CF,
|
||||
0x0110, 0x00D1, 0x0309, 0x00D3, 0x00D4, 0x01A0, 0x00D6, 0x00D7,
|
||||
0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x01AF, 0x0303, 0x00DF,
|
||||
0x00E0, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
|
||||
0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x0301, 0x00ED, 0x00EE, 0x00EF,
|
||||
0x0111, 0x00F1, 0x0323, 0x00F3, 0x00F4, 0x01A1, 0x00F6, 0x00F7,
|
||||
0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x01B0, 0x20AB, 0x00FF
|
||||
const uint16_t Tbl[] =
|
||||
{
|
||||
/* CP1258(0x80-0xFF) to Unicode conversion table */
|
||||
0x20AC, 0x0000, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
|
||||
0x02C6, 0x2030, 0x0000, 0x2039, 0x0152, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
|
||||
0x02DC, 0x2122, 0x0000, 0x203A, 0x0153, 0x0000, 0x0000, 0x0178,
|
||||
0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
|
||||
0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
|
||||
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
|
||||
0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
|
||||
0x00C0, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
|
||||
0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x0300, 0x00CD, 0x00CE, 0x00CF,
|
||||
0x0110, 0x00D1, 0x0309, 0x00D3, 0x00D4, 0x01A0, 0x00D6, 0x00D7,
|
||||
0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x01AF, 0x0303, 0x00DF,
|
||||
0x00E0, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
|
||||
0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x0301, 0x00ED, 0x00EE, 0x00EF,
|
||||
0x0111, 0x00F1, 0x0323, 0x00F3, 0x00F4, 0x01A1, 0x00F6, 0x00F7,
|
||||
0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x01B0, 0x20AB, 0x00FF
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -499,42 +541,79 @@ const uint16_t Tbl[] = { /* CP1258(0x80-0xFF) to Unicode conversion table */
|
||||
|
||||
|
||||
uint16_t ff_convert ( /* Converted character, Returns zero on error */
|
||||
uint16_t src, /* Character code to be converted */
|
||||
uint32_t dir /* 0: Unicode to OEMCP, 1: OEMCP to Unicode */
|
||||
)
|
||||
uint16_t src, /* Character code to be converted */
|
||||
uint32_t dir /* 0: Unicode to OEMCP, 1: OEMCP to Unicode */
|
||||
)
|
||||
{
|
||||
uint16_t c;
|
||||
uint16_t c;
|
||||
|
||||
|
||||
if (src < 0x80) { /* ASCII */
|
||||
c = src;
|
||||
if (src < 0x80) { /* ASCII */
|
||||
c = src;
|
||||
|
||||
} else {
|
||||
if (dir) { /* OEMCP to Unicode */
|
||||
c = (src >= 0x100) ? 0 : Tbl[src - 0x80];
|
||||
} else {
|
||||
if (dir) { /* OEMCP to Unicode */
|
||||
c = (src >= 0x100) ? 0 : Tbl[src - 0x80];
|
||||
|
||||
} else { /* Unicode to OEMCP */
|
||||
for (c = 0; c < 0x80; c++) {
|
||||
if (src == Tbl[c]) break;
|
||||
}
|
||||
c = (c + 0x80) & 0xFF;
|
||||
}
|
||||
}
|
||||
} else { /* Unicode to OEMCP */
|
||||
for (c = 0; c < 0x80; c++) {
|
||||
if (src == Tbl[c]) break;
|
||||
}
|
||||
c = (c + 0x80) & 0xFF;
|
||||
}
|
||||
}
|
||||
|
||||
return c;
|
||||
return c;
|
||||
}
|
||||
|
||||
|
||||
uint16_t ff_wtoupper ( /* Upper converted character */
|
||||
uint16_t chr /* Input character */
|
||||
)
|
||||
uint16_t chr /* Input character */
|
||||
)
|
||||
{
|
||||
static const uint16_t tbl_lower[] = { 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0xA1, 0x00A2, 0x00A3, 0x00A5, 0x00AC, 0x00AF, 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0x0FF, 0x101, 0x103, 0x105, 0x107, 0x109, 0x10B, 0x10D, 0x10F, 0x111, 0x113, 0x115, 0x117, 0x119, 0x11B, 0x11D, 0x11F, 0x121, 0x123, 0x125, 0x127, 0x129, 0x12B, 0x12D, 0x12F, 0x131, 0x133, 0x135, 0x137, 0x13A, 0x13C, 0x13E, 0x140, 0x142, 0x144, 0x146, 0x148, 0x14B, 0x14D, 0x14F, 0x151, 0x153, 0x155, 0x157, 0x159, 0x15B, 0x15D, 0x15F, 0x161, 0x163, 0x165, 0x167, 0x169, 0x16B, 0x16D, 0x16F, 0x171, 0x173, 0x175, 0x177, 0x17A, 0x17C, 0x17E, 0x192, 0x3B1, 0x3B2, 0x3B3, 0x3B4, 0x3B5, 0x3B6, 0x3B7, 0x3B8, 0x3B9, 0x3BA, 0x3BB, 0x3BC, 0x3BD, 0x3BE, 0x3BF, 0x3C0, 0x3C1, 0x3C3, 0x3C4, 0x3C5, 0x3C6, 0x3C7, 0x3C8, 0x3C9, 0x3CA, 0x430, 0x431, 0x432, 0x433, 0x434, 0x435, 0x436, 0x437, 0x438, 0x439, 0x43A, 0x43B, 0x43C, 0x43D, 0x43E, 0x43F, 0x440, 0x441, 0x442, 0x443, 0x444, 0x445, 0x446, 0x447, 0x448, 0x449, 0x44A, 0x44B, 0x44C, 0x44D, 0x44E, 0x44F, 0x451, 0x452, 0x453, 0x454, 0x455, 0x456, 0x457, 0x458, 0x459, 0x45A, 0x45B, 0x45C, 0x45E, 0x45F, 0x2170, 0x2171, 0x2172, 0x2173, 0x2174, 0x2175, 0x2176, 0x2177, 0x2178, 0x2179, 0x217A, 0x217B, 0x217C, 0x217D, 0x217E, 0x217F, 0xFF41, 0xFF42, 0xFF43, 0xFF44, 0xFF45, 0xFF46, 0xFF47, 0xFF48, 0xFF49, 0xFF4A, 0xFF4B, 0xFF4C, 0xFF4D, 0xFF4E, 0xFF4F, 0xFF50, 0xFF51, 0xFF52, 0xFF53, 0xFF54, 0xFF55, 0xFF56, 0xFF57, 0xFF58, 0xFF59, 0xFF5A, 0 };
|
||||
static const uint16_t tbl_upper[] = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x21, 0xFFE0, 0xFFE1, 0xFFE5, 0xFFE2, 0xFFE3, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0x178, 0x100, 0x102, 0x104, 0x106, 0x108, 0x10A, 0x10C, 0x10E, 0x110, 0x112, 0x114, 0x116, 0x118, 0x11A, 0x11C, 0x11E, 0x120, 0x122, 0x124, 0x126, 0x128, 0x12A, 0x12C, 0x12E, 0x130, 0x132, 0x134, 0x136, 0x139, 0x13B, 0x13D, 0x13F, 0x141, 0x143, 0x145, 0x147, 0x14A, 0x14C, 0x14E, 0x150, 0x152, 0x154, 0x156, 0x158, 0x15A, 0x15C, 0x15E, 0x160, 0x162, 0x164, 0x166, 0x168, 0x16A, 0x16C, 0x16E, 0x170, 0x172, 0x174, 0x176, 0x179, 0x17B, 0x17D, 0x191, 0x391, 0x392, 0x393, 0x394, 0x395, 0x396, 0x397, 0x398, 0x399, 0x39A, 0x39B, 0x39C, 0x39D, 0x39E, 0x39F, 0x3A0, 0x3A1, 0x3A3, 0x3A4, 0x3A5, 0x3A6, 0x3A7, 0x3A8, 0x3A9, 0x3AA, 0x410, 0x411, 0x412, 0x413, 0x414, 0x415, 0x416, 0x417, 0x418, 0x419, 0x41A, 0x41B, 0x41C, 0x41D, 0x41E, 0x41F, 0x420, 0x421, 0x422, 0x423, 0x424, 0x425, 0x426, 0x427, 0x428, 0x429, 0x42A, 0x42B, 0x42C, 0x42D, 0x42E, 0x42F, 0x401, 0x402, 0x403, 0x404, 0x405, 0x406, 0x407, 0x408, 0x409, 0x40A, 0x40B, 0x40C, 0x40E, 0x40F, 0x2160, 0x2161, 0x2162, 0x2163, 0x2164, 0x2165, 0x2166, 0x2167, 0x2168, 0x2169, 0x216A, 0x216B, 0x216C, 0x216D, 0x216E, 0x216F, 0xFF21, 0xFF22, 0xFF23, 0xFF24, 0xFF25, 0xFF26, 0xFF27, 0xFF28, 0xFF29, 0xFF2A, 0xFF2B, 0xFF2C, 0xFF2D, 0xFF2E, 0xFF2F, 0xFF30, 0xFF31, 0xFF32, 0xFF33, 0xFF34, 0xFF35, 0xFF36, 0xFF37, 0xFF38, 0xFF39, 0xFF3A, 0 };
|
||||
int i;
|
||||
static const uint16_t tbl_lower[] =
|
||||
{
|
||||
0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
|
||||
0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70,
|
||||
0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
|
||||
0x79, 0x7A, 0xA1, 0x00A2, 0x00A3, 0x00A5, 0x00AC, 0x00AF,
|
||||
0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7,
|
||||
0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF,
|
||||
0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF8,
|
||||
0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0x0FF, 0x101,
|
||||
0x103, 0x105, 0x107, 0x109, 0x10B, 0x10D, 0x10F,
|
||||
0x111, 0x113, 0x115, 0x117, 0x119, 0x11B, 0x11D,
|
||||
0x11F, 0x121, 0x123, 0x125, 0x127, 0x129, 0x12B,
|
||||
0x12D, 0x12F, 0x131, 0x133, 0x135, 0x137, 0x13A,
|
||||
0x13C, 0x13E, 0x140, 0x142, 0x144, 0x146, 0x148,
|
||||
0x14B, 0x14D, 0x14F, 0x151, 0x153, 0x155, 0x157,
|
||||
0x159, 0x15B, 0x15D, 0x15F, 0x161, 0x163, 0x165,
|
||||
0x167, 0x169, 0x16B, 0x16D, 0x16F, 0x171, 0x173,
|
||||
0x175, 0x177, 0x17A, 0x17C, 0x17E, 0x192, 0x3B1,
|
||||
0x3B2, 0x3B3, 0x3B4, 0x3B5, 0x3B6, 0x3B7, 0x3B8,
|
||||
0x3B9, 0x3BA, 0x3BB, 0x3BC, 0x3BD, 0x3BE, 0x3BF,
|
||||
0x3C0, 0x3C1, 0x3C3, 0x3C4, 0x3C5, 0x3C6, 0x3C7,
|
||||
0x3C8, 0x3C9, 0x3CA, 0x430, 0x431, 0x432, 0x433,
|
||||
0x434, 0x435, 0x436, 0x437, 0x438, 0x439, 0x43A,
|
||||
0x43B, 0x43C, 0x43D, 0x43E, 0x43F, 0x440, 0x441,
|
||||
0x442, 0x443, 0x444, 0x445, 0x446, 0x447, 0x448,
|
||||
0x449, 0x44A, 0x44B, 0x44C, 0x44D, 0x44E, 0x44F,
|
||||
0x451, 0x452, 0x453, 0x454, 0x455, 0x456, 0x457,
|
||||
0x458, 0x459, 0x45A, 0x45B, 0x45C, 0x45E, 0x45F,
|
||||
0x2170, 0x2171, 0x2172, 0x2173, 0x2174, 0x2175, 0x2176, 0x2177,
|
||||
0x2178, 0x2179, 0x217A, 0x217B, 0x217C, 0x217D, 0x217E, 0x217F,
|
||||
0xFF41, 0xFF42, 0xFF43, 0xFF44, 0xFF45, 0xFF46, 0xFF47, 0xFF48,
|
||||
0xFF49, 0xFF4A, 0xFF4B, 0xFF4C, 0xFF4D, 0xFF4E, 0xFF4F, 0xFF50,
|
||||
0xFF51, 0xFF52, 0xFF53, 0xFF54, 0xFF55, 0xFF56, 0xFF57, 0xFF58,
|
||||
0xFF59, 0xFF5A, 0
|
||||
};
|
||||
static const uint16_t tbl_upper[] =
|
||||
{
|
||||
0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x21, 0xFFE0, 0xFFE1, 0xFFE5, 0xFFE2, 0xFFE3, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0x178, 0x100, 0x102, 0x104, 0x106, 0x108, 0x10A, 0x10C, 0x10E, 0x110, 0x112, 0x114, 0x116, 0x118, 0x11A, 0x11C, 0x11E, 0x120, 0x122, 0x124, 0x126, 0x128, 0x12A, 0x12C, 0x12E, 0x130, 0x132, 0x134, 0x136, 0x139, 0x13B, 0x13D, 0x13F, 0x141, 0x143, 0x145, 0x147, 0x14A, 0x14C, 0x14E, 0x150, 0x152, 0x154, 0x156, 0x158, 0x15A, 0x15C, 0x15E, 0x160, 0x162, 0x164, 0x166, 0x168, 0x16A, 0x16C, 0x16E, 0x170, 0x172, 0x174, 0x176, 0x179, 0x17B, 0x17D, 0x191, 0x391, 0x392, 0x393, 0x394, 0x395, 0x396, 0x397, 0x398, 0x399, 0x39A, 0x39B, 0x39C, 0x39D, 0x39E, 0x39F, 0x3A0, 0x3A1, 0x3A3, 0x3A4, 0x3A5, 0x3A6, 0x3A7, 0x3A8, 0x3A9, 0x3AA, 0x410, 0x411, 0x412, 0x413, 0x414, 0x415, 0x416, 0x417, 0x418, 0x419, 0x41A, 0x41B, 0x41C, 0x41D, 0x41E, 0x41F, 0x420, 0x421, 0x422, 0x423, 0x424, 0x425, 0x426, 0x427, 0x428, 0x429, 0x42A, 0x42B, 0x42C, 0x42D, 0x42E, 0x42F, 0x401, 0x402, 0x403, 0x404, 0x405, 0x406, 0x407, 0x408, 0x409, 0x40A, 0x40B, 0x40C, 0x40E, 0x40F, 0x2160, 0x2161, 0x2162, 0x2163, 0x2164, 0x2165, 0x2166, 0x2167, 0x2168, 0x2169, 0x216A, 0x216B, 0x216C, 0x216D, 0x216E, 0x216F, 0xFF21, 0xFF22, 0xFF23, 0xFF24, 0xFF25, 0xFF26, 0xFF27, 0xFF28, 0xFF29, 0xFF2A, 0xFF2B, 0xFF2C, 0xFF2D, 0xFF2E, 0xFF2F, 0xFF30, 0xFF31, 0xFF32, 0xFF33, 0xFF34, 0xFF35, 0xFF36, 0xFF37, 0xFF38, 0xFF39, 0xFF3A, 0 };
|
||||
int i;
|
||||
|
||||
|
||||
for (i = 0; tbl_lower[i] && chr != tbl_lower[i]; i++) ;
|
||||
for (i = 0; tbl_lower[i] && chr != tbl_lower[i]; i++) ;
|
||||
|
||||
return tbl_lower[i] ? tbl_upper[i] : chr;
|
||||
return tbl_lower[i] ? tbl_upper[i] : chr;
|
||||
}
|
||||
|
||||
+2545
-2544
File diff suppressed because it is too large
Load Diff
+208
-208
@@ -35,305 +35,305 @@
|
||||
|
||||
#define IKBD_DEFAULT IKBD_STATE_JOYSTICK_EVENT_REPORTING
|
||||
|
||||
#define QUEUE_LEN 16 // power of 2!
|
||||
#define QUEUE_LEN 16 // power of 2!
|
||||
static unsigned char tx_queue[QUEUE_LEN];
|
||||
static unsigned char wptr = 0, rptr = 0;
|
||||
|
||||
// structure to keep track of ikbd state
|
||||
static struct
|
||||
{
|
||||
unsigned char cmd;
|
||||
unsigned char state;
|
||||
unsigned char expect;
|
||||
unsigned char cmd;
|
||||
unsigned char state;
|
||||
unsigned char expect;
|
||||
|
||||
// joystick state
|
||||
unsigned char joystick[2];
|
||||
// joystick state
|
||||
unsigned char joystick[2];
|
||||
|
||||
// mouse state
|
||||
unsigned short mouse_pos_x, mouse_pos_y;
|
||||
unsigned char mouse_buttons;
|
||||
// mouse state
|
||||
unsigned short mouse_pos_x, mouse_pos_y;
|
||||
unsigned char mouse_buttons;
|
||||
} ikbd;
|
||||
|
||||
// #define IKBD_DEBUG
|
||||
|
||||
void ikbd_init()
|
||||
{
|
||||
// reset ikbd state
|
||||
memset(&ikbd, 0, sizeof(ikbd));
|
||||
ikbd.state = IKBD_DEFAULT;
|
||||
// reset ikbd state
|
||||
memset(&ikbd, 0, sizeof(ikbd));
|
||||
ikbd.state = IKBD_DEFAULT;
|
||||
}
|
||||
|
||||
static void enqueue(unsigned char b)
|
||||
{
|
||||
if (((wptr + 1)&(QUEUE_LEN-1)) == rptr)
|
||||
{
|
||||
xprintf("IKBD: !!!!!!! tx queue overflow !!!!!!!!!\n");
|
||||
return;
|
||||
}
|
||||
if (((wptr + 1)&(QUEUE_LEN-1)) == rptr)
|
||||
{
|
||||
xprintf("IKBD: !!!!!!! tx queue overflow !!!!!!!!!\n");
|
||||
return;
|
||||
}
|
||||
|
||||
tx_queue[wptr] = b;
|
||||
wptr = (wptr + 1) & (QUEUE_LEN - 1);
|
||||
tx_queue[wptr] = b;
|
||||
wptr = (wptr + 1) & (QUEUE_LEN - 1);
|
||||
}
|
||||
|
||||
// convert internal joystick format into atari ikbd format
|
||||
static unsigned char joystick_map2ikbd(unsigned in)
|
||||
{
|
||||
unsigned char out = 0;
|
||||
unsigned char out = 0;
|
||||
|
||||
if (in & JOY_UP) out |= 0x01;
|
||||
if (in & JOY_DOWN) out |= 0x02;
|
||||
if (in & JOY_LEFT) out |= 0x04;
|
||||
if (in & JOY_RIGHT) out |= 0x08;
|
||||
if (in & JOY_BTN1) out |= 0x80;
|
||||
if (in & JOY_UP) out |= 0x01;
|
||||
if (in & JOY_DOWN) out |= 0x02;
|
||||
if (in & JOY_LEFT) out |= 0x04;
|
||||
if (in & JOY_RIGHT) out |= 0x08;
|
||||
if (in & JOY_BTN1) out |= 0x80;
|
||||
|
||||
return out;
|
||||
return out;
|
||||
}
|
||||
|
||||
// process inout from atari core into ikbd
|
||||
void ikbd_handle_input(unsigned char cmd)
|
||||
{
|
||||
// expecting a second byte for command
|
||||
if (ikbd.expect)
|
||||
{
|
||||
ikbd.expect--;
|
||||
// expecting a second byte for command
|
||||
if (ikbd.expect)
|
||||
{
|
||||
ikbd.expect--;
|
||||
|
||||
// last byte of command received
|
||||
if (!ikbd.expect)
|
||||
{
|
||||
switch(ikbd.cmd)
|
||||
{
|
||||
case 0x07: // set mouse button action
|
||||
xprintf("IKBD: mouse button action = %x\n", cmd);
|
||||
// last byte of command received
|
||||
if (!ikbd.expect)
|
||||
{
|
||||
switch(ikbd.cmd)
|
||||
{
|
||||
case 0x07: // set mouse button action
|
||||
xprintf("IKBD: mouse button action = %x\n", cmd);
|
||||
|
||||
// bit 2: Mouse buttons act like keys (LEFT=0x74 & RIGHT=0x75)
|
||||
if(cmd & 0x04) ikbd.state |= IKBD_STATE_MOUSE_BUTTON_AS_KEY;
|
||||
else ikbd.state &= ~IKBD_STATE_MOUSE_BUTTON_AS_KEY;
|
||||
// bit 2: Mouse buttons act like keys (LEFT=0x74 & RIGHT=0x75)
|
||||
if(cmd & 0x04) ikbd.state |= IKBD_STATE_MOUSE_BUTTON_AS_KEY;
|
||||
else ikbd.state &= ~IKBD_STATE_MOUSE_BUTTON_AS_KEY;
|
||||
|
||||
break;
|
||||
break;
|
||||
|
||||
case 0x80: // ibkd reset
|
||||
// reply "everything is ok"
|
||||
enqueue(0xf0);
|
||||
break;
|
||||
case 0x80: // ibkd reset
|
||||
// reply "everything is ok"
|
||||
enqueue(0xf0);
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
ikbd.cmd = cmd;
|
||||
ikbd.cmd = cmd;
|
||||
|
||||
switch(cmd)
|
||||
{
|
||||
case 0x07:
|
||||
xprintf("IKBD: Set mouse button action");
|
||||
ikbd.expect = 1;
|
||||
break;
|
||||
switch(cmd)
|
||||
{
|
||||
case 0x07:
|
||||
xprintf("IKBD: Set mouse button action");
|
||||
ikbd.expect = 1;
|
||||
break;
|
||||
|
||||
case 0x08:
|
||||
xprintf("IKBD: Set relative mouse positioning");
|
||||
ikbd.state &= ~IKBD_STATE_MOUSE_DISABLED;
|
||||
ikbd.state &= ~IKBD_STATE_MOUSE_ABSOLUTE;
|
||||
break;
|
||||
case 0x08:
|
||||
xprintf("IKBD: Set relative mouse positioning");
|
||||
ikbd.state &= ~IKBD_STATE_MOUSE_DISABLED;
|
||||
ikbd.state &= ~IKBD_STATE_MOUSE_ABSOLUTE;
|
||||
break;
|
||||
|
||||
case 0x09:
|
||||
xprintf("IKBD: Set absolute mouse positioning");
|
||||
ikbd.state &= ~IKBD_STATE_MOUSE_DISABLED;
|
||||
ikbd.state |= IKBD_STATE_MOUSE_ABSOLUTE;
|
||||
ikbd.expect = 4;
|
||||
break;
|
||||
case 0x09:
|
||||
xprintf("IKBD: Set absolute mouse positioning");
|
||||
ikbd.state &= ~IKBD_STATE_MOUSE_DISABLED;
|
||||
ikbd.state |= IKBD_STATE_MOUSE_ABSOLUTE;
|
||||
ikbd.expect = 4;
|
||||
break;
|
||||
|
||||
case 0x0b:
|
||||
xprintf("IKBD: Set Mouse threshold");
|
||||
ikbd.expect = 2;
|
||||
break;
|
||||
case 0x0b:
|
||||
xprintf("IKBD: Set Mouse threshold");
|
||||
ikbd.expect = 2;
|
||||
break;
|
||||
|
||||
case 0x0f:
|
||||
xprintf("IKBD: Set Y at bottom");
|
||||
ikbd.state |= IKBD_STATE_MOUSE_Y_BOTTOM;
|
||||
break;
|
||||
case 0x0f:
|
||||
xprintf("IKBD: Set Y at bottom");
|
||||
ikbd.state |= IKBD_STATE_MOUSE_Y_BOTTOM;
|
||||
break;
|
||||
|
||||
case 0x10:
|
||||
xprintf("IKBD: Set Y at top");
|
||||
ikbd.state &= ~IKBD_STATE_MOUSE_Y_BOTTOM;
|
||||
break;
|
||||
case 0x10:
|
||||
xprintf("IKBD: Set Y at top");
|
||||
ikbd.state &= ~IKBD_STATE_MOUSE_Y_BOTTOM;
|
||||
break;
|
||||
|
||||
case 0x12:
|
||||
xprintf("IKBD: Disable mouse");
|
||||
ikbd.state |= IKBD_STATE_MOUSE_DISABLED;
|
||||
break;
|
||||
case 0x12:
|
||||
xprintf("IKBD: Disable mouse");
|
||||
ikbd.state |= IKBD_STATE_MOUSE_DISABLED;
|
||||
break;
|
||||
|
||||
case 0x14:
|
||||
xprintf("IKBD: Set Joystick event reporting");
|
||||
ikbd.state |= IKBD_STATE_JOYSTICK_EVENT_REPORTING;
|
||||
break;
|
||||
case 0x14:
|
||||
xprintf("IKBD: Set Joystick event reporting");
|
||||
ikbd.state |= IKBD_STATE_JOYSTICK_EVENT_REPORTING;
|
||||
break;
|
||||
|
||||
case 0x15:
|
||||
xprintf("IKBD: Set Joystick interrogation mode");
|
||||
ikbd.state &= ~IKBD_STATE_JOYSTICK_EVENT_REPORTING;
|
||||
break;
|
||||
case 0x15:
|
||||
xprintf("IKBD: Set Joystick interrogation mode");
|
||||
ikbd.state &= ~IKBD_STATE_JOYSTICK_EVENT_REPORTING;
|
||||
break;
|
||||
|
||||
case 0x16: // interrogate joystick
|
||||
// send reply
|
||||
enqueue(0xfd);
|
||||
enqueue(joystick_map2ikbd(ikbd.joystick[0]));
|
||||
enqueue(joystick_map2ikbd(ikbd.joystick[1]));
|
||||
break;
|
||||
case 0x16: // interrogate joystick
|
||||
// send reply
|
||||
enqueue(0xfd);
|
||||
enqueue(joystick_map2ikbd(ikbd.joystick[0]));
|
||||
enqueue(joystick_map2ikbd(ikbd.joystick[1]));
|
||||
break;
|
||||
|
||||
case 0x1a:
|
||||
xprintf("IKBD: Disable joysticks");
|
||||
ikbd.state &= ~IKBD_STATE_JOYSTICK_EVENT_REPORTING;
|
||||
break;
|
||||
case 0x1a:
|
||||
xprintf("IKBD: Disable joysticks");
|
||||
ikbd.state &= ~IKBD_STATE_JOYSTICK_EVENT_REPORTING;
|
||||
break;
|
||||
|
||||
case 0x1c:
|
||||
xprintf("IKBD: Interrogate time of day");
|
||||
case 0x1c:
|
||||
xprintf("IKBD: Interrogate time of day");
|
||||
|
||||
enqueue(0xfc);
|
||||
enqueue(0x13); // year bcd
|
||||
enqueue(0x03); // month bcd
|
||||
enqueue(0x07); // day bcd
|
||||
enqueue(0x20); // hour bcd
|
||||
enqueue(0x58); // minute bcd
|
||||
enqueue(0x00); // second bcd
|
||||
break;
|
||||
enqueue(0xfc);
|
||||
enqueue(0x13); // year bcd
|
||||
enqueue(0x03); // month bcd
|
||||
enqueue(0x07); // day bcd
|
||||
enqueue(0x20); // hour bcd
|
||||
enqueue(0x58); // minute bcd
|
||||
enqueue(0x00); // second bcd
|
||||
break;
|
||||
|
||||
|
||||
case 0x80:
|
||||
xprintf("IKBD: Reset");
|
||||
ikbd.expect = 1;
|
||||
ikbd.state = IKBD_DEFAULT;
|
||||
break;
|
||||
case 0x80:
|
||||
xprintf("IKBD: Reset");
|
||||
ikbd.expect = 1;
|
||||
ikbd.state = IKBD_DEFAULT;
|
||||
break;
|
||||
|
||||
default:
|
||||
xprintf("IKBD: unknown command: %x\n", cmd);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
xprintf("IKBD: unknown command: %x\n", cmd);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void ikbd_poll(void) {
|
||||
static int mtimer = 0;
|
||||
if (CheckTimer(mtimer))
|
||||
{
|
||||
mtimer = GetTimer(10);
|
||||
static int mtimer = 0;
|
||||
if (CheckTimer(mtimer))
|
||||
{
|
||||
mtimer = GetTimer(10);
|
||||
|
||||
// check for incoming ikbd data
|
||||
EnableIO();
|
||||
SPI(UIO_IKBD_IN);
|
||||
// check for incoming ikbd data
|
||||
EnableIO();
|
||||
SPI(UIO_IKBD_IN);
|
||||
|
||||
while(SPI(0))
|
||||
ikbd_handle_input(SPI(0));
|
||||
while(SPI(0))
|
||||
ikbd_handle_input(SPI(0));
|
||||
|
||||
DisableIO();
|
||||
}
|
||||
DisableIO();
|
||||
}
|
||||
|
||||
// send data from queue if present
|
||||
if(rptr == wptr) return;
|
||||
// send data from queue if present
|
||||
if(rptr == wptr) return;
|
||||
|
||||
// transmit data from queue
|
||||
EnableIO();
|
||||
SPI(UIO_IKBD_OUT);
|
||||
SPI(tx_queue[rptr]);
|
||||
DisableIO();
|
||||
// transmit data from queue
|
||||
EnableIO();
|
||||
SPI(UIO_IKBD_OUT);
|
||||
SPI(tx_queue[rptr]);
|
||||
DisableIO();
|
||||
|
||||
rptr = (rptr + 1) & (QUEUE_LEN - 1);
|
||||
rptr = (rptr + 1) & (QUEUE_LEN - 1);
|
||||
}
|
||||
|
||||
void ikbd_joystick(unsigned char joystick, unsigned char map)
|
||||
{
|
||||
// todo: suppress events for joystick 0 as long as mouse
|
||||
// is enabled?
|
||||
// todo: suppress events for joystick 0 as long as mouse
|
||||
// is enabled?
|
||||
|
||||
if (ikbd.state & IKBD_STATE_JOYSTICK_EVENT_REPORTING)
|
||||
{
|
||||
if (ikbd.state & IKBD_STATE_JOYSTICK_EVENT_REPORTING)
|
||||
{
|
||||
#ifdef IKBD_DEBUG
|
||||
xprintf("IKBD: joy %d %x\n", joystick, map);
|
||||
xprintf("IKBD: joy %d %x\n", joystick, map);
|
||||
#endif
|
||||
|
||||
// only report joystick data for joystick 0 if the mouse is disabled
|
||||
if ((ikbd.state & IKBD_STATE_MOUSE_DISABLED) || (joystick == 1))
|
||||
{
|
||||
enqueue(0xfe + joystick);
|
||||
enqueue(joystick_map2ikbd(map));
|
||||
}
|
||||
// only report joystick data for joystick 0 if the mouse is disabled
|
||||
if ((ikbd.state & IKBD_STATE_MOUSE_DISABLED) || (joystick == 1))
|
||||
{
|
||||
enqueue(0xfe + joystick);
|
||||
enqueue(joystick_map2ikbd(map));
|
||||
}
|
||||
|
||||
if (!(ikbd.state & IKBD_STATE_MOUSE_DISABLED))
|
||||
{
|
||||
// the fire button also generates a mouse event if
|
||||
// mouse reporting is enabled
|
||||
if ((map & JOY_BTN1) != (ikbd.joystick[joystick] & JOY_BTN1))
|
||||
{
|
||||
// generate mouse event (ikbd_joystick_buttons is evaluated inside
|
||||
// user_io_mouse)
|
||||
ikbd.joystick[joystick] = map;
|
||||
ikbd_mouse(0, 0, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!(ikbd.state & IKBD_STATE_MOUSE_DISABLED))
|
||||
{
|
||||
// the fire button also generates a mouse event if
|
||||
// mouse reporting is enabled
|
||||
if ((map & JOY_BTN1) != (ikbd.joystick[joystick] & JOY_BTN1))
|
||||
{
|
||||
// generate mouse event (ikbd_joystick_buttons is evaluated inside
|
||||
// user_io_mouse)
|
||||
ikbd.joystick[joystick] = map;
|
||||
ikbd_mouse(0, 0, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
#ifdef IKBD_DEBUG
|
||||
else
|
||||
xprintf("IKBD: no monitor, drop joy %d %x\n", joystick, map);
|
||||
else
|
||||
xprintf("IKBD: no monitor, drop joy %d %x\n", joystick, map);
|
||||
#endif
|
||||
|
||||
// save state of joystick for interrogation mode
|
||||
ikbd.joystick[joystick] = map;
|
||||
// save state of joystick for interrogation mode
|
||||
ikbd.joystick[joystick] = map;
|
||||
}
|
||||
|
||||
void ikbd_keyboard(unsigned char code)
|
||||
{
|
||||
#ifdef IKBD_DEBUG
|
||||
xprintf("IKBD: send keycode %x%s\n", code&0x7f, (code&0x80)?" BREAK":"");
|
||||
xprintf("IKBD: send keycode %x%s\n", code&0x7f, (code&0x80)?" BREAK":"");
|
||||
#endif
|
||||
enqueue(code);
|
||||
enqueue(code);
|
||||
}
|
||||
|
||||
void ikbd_mouse(uint8_t b, int8_t x, int8_t y)
|
||||
{
|
||||
if (ikbd.state & IKBD_STATE_MOUSE_DISABLED)
|
||||
return;
|
||||
if (ikbd.state & IKBD_STATE_MOUSE_DISABLED)
|
||||
return;
|
||||
|
||||
// joystick and mouse buttons are wired together in
|
||||
// atari st
|
||||
b |= (ikbd.joystick[0] & JOY_BTN1)?1:0;
|
||||
b |= (ikbd.joystick[1] & JOY_BTN1)?2:0;
|
||||
// joystick and mouse buttons are wired together in
|
||||
// atari st
|
||||
b |= (ikbd.joystick[0] & JOY_BTN1)?1:0;
|
||||
b |= (ikbd.joystick[1] & JOY_BTN1)?2:0;
|
||||
|
||||
static unsigned char b_old = 0;
|
||||
// monitor state of two mouse buttons
|
||||
if (b != b_old)
|
||||
{
|
||||
// check if mouse buttons are supposed to be treated like keys
|
||||
if (ikbd.state & IKBD_STATE_MOUSE_BUTTON_AS_KEY)
|
||||
{
|
||||
// Mouse buttons act like keys (LEFT=0x74 & RIGHT=0x75)
|
||||
static unsigned char b_old = 0;
|
||||
// monitor state of two mouse buttons
|
||||
if (b != b_old)
|
||||
{
|
||||
// check if mouse buttons are supposed to be treated like keys
|
||||
if (ikbd.state & IKBD_STATE_MOUSE_BUTTON_AS_KEY)
|
||||
{
|
||||
// Mouse buttons act like keys (LEFT=0x74 & RIGHT=0x75)
|
||||
|
||||
// handle left mouse button
|
||||
if((b ^ b_old) & 1) ikbd_keyboard(0x74 | ((b&1)?0x00:0x80));
|
||||
// handle right mouse button
|
||||
if((b ^ b_old) & 2) ikbd_keyboard(0x75 | ((b&2)?0x00:0x80));
|
||||
}
|
||||
b_old = b;
|
||||
}
|
||||
// handle left mouse button
|
||||
if((b ^ b_old) & 1) ikbd_keyboard(0x74 | ((b&1)?0x00:0x80));
|
||||
// handle right mouse button
|
||||
if((b ^ b_old) & 2) ikbd_keyboard(0x75 | ((b&2)?0x00:0x80));
|
||||
}
|
||||
b_old = b;
|
||||
}
|
||||
|
||||
#if 0
|
||||
if(ikbd.state & IKBD_STATE_MOUSE_BUTTON_AS_KEY)
|
||||
{
|
||||
b = 0;
|
||||
// if mouse position is 0/0 quit here
|
||||
if(!x && !y) return;
|
||||
}
|
||||
if(ikbd.state & IKBD_STATE_MOUSE_BUTTON_AS_KEY)
|
||||
{
|
||||
b = 0;
|
||||
// if mouse position is 0/0 quit here
|
||||
if(!x && !y) return;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (ikbd.state & IKBD_STATE_MOUSE_ABSOLUTE)
|
||||
{
|
||||
}
|
||||
else
|
||||
{
|
||||
// atari has mouse button bits swapped
|
||||
enqueue(0xf8|((b&1)?2:0)|((b&2)?1:0));
|
||||
enqueue(x);
|
||||
enqueue((ikbd.state & IKBD_STATE_MOUSE_Y_BOTTOM)?-y:y);
|
||||
}
|
||||
if (ikbd.state & IKBD_STATE_MOUSE_ABSOLUTE)
|
||||
{
|
||||
}
|
||||
else
|
||||
{
|
||||
// atari has mouse button bits swapped
|
||||
enqueue(0xf8|((b&1)?2:0)|((b&2)?1:0));
|
||||
enqueue(x);
|
||||
enqueue((ikbd.state & IKBD_STATE_MOUSE_Y_BOTTOM)?-y:y);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+63
-63
@@ -32,7 +32,7 @@
|
||||
* This function sets up the Auto-Negotiate Advertisement register
|
||||
* within the PHY and then forces the PHY to auto-negotiate for
|
||||
* it's settings.
|
||||
*
|
||||
*
|
||||
* Params:
|
||||
* fec_ch FEC channel
|
||||
* phy_addr Address of the PHY.
|
||||
@@ -45,80 +45,80 @@
|
||||
*/
|
||||
int am79c874_init(uint8_t fec_ch, uint8_t phy_addr, uint8_t speed, uint8_t duplex)
|
||||
{
|
||||
int timeout;
|
||||
uint16_t settings;
|
||||
if (speed); /* to do */
|
||||
if (duplex); /* to do */
|
||||
|
||||
/* Initialize the MII interface */
|
||||
fec_mii_init(fec_ch, SYSCLK / 1000);
|
||||
dbg("%s: PHY reset\r\n", __FUNCTION__);
|
||||
|
||||
/* Reset the PHY */
|
||||
if (!fec_mii_write(fec_ch, phy_addr, MII_AM79C874_CR, MII_AM79C874_CR_RESET))
|
||||
return 0;
|
||||
int timeout;
|
||||
uint16_t settings;
|
||||
if (speed); /* to do */
|
||||
if (duplex); /* to do */
|
||||
|
||||
/* Wait for the PHY to reset */
|
||||
for (timeout = 0; timeout < FEC_MII_TIMEOUT; timeout++)
|
||||
{
|
||||
fec_mii_read(fec_ch, phy_addr, MII_AM79C874_CR, &settings);
|
||||
if (!(settings & MII_AM79C874_CR_RESET))
|
||||
break;
|
||||
}
|
||||
/* Initialize the MII interface */
|
||||
fec_mii_init(fec_ch, SYSCLK / 1000);
|
||||
dbg("%s: PHY reset\r\n", __FUNCTION__);
|
||||
|
||||
if (timeout >= FEC_MII_TIMEOUT)
|
||||
{
|
||||
dbg("%s: PHY reset failed\r\n", __FUNCTION__);
|
||||
return 0;
|
||||
};
|
||||
dbg("%s: PHY reset OK\r\n", __FUNCTION__);
|
||||
dbg("%s: PHY Enable Auto-Negotiation\r\n", __FUNCTION__);
|
||||
/* Reset the PHY */
|
||||
if (!fec_mii_write(fec_ch, phy_addr, MII_AM79C874_CR, MII_AM79C874_CR_RESET))
|
||||
return 0;
|
||||
|
||||
/* Enable Auto-Negotiation */
|
||||
if (!fec_mii_write(fec_ch, phy_addr, MII_AM79C874_CR, MII_AM79C874_CR_AUTON | MII_AM79C874_CR_RST_NEG))
|
||||
return 0;
|
||||
|
||||
dbg("%s:PHY Wait for auto-negotiation to complete\r\n", __FUNCTION__);
|
||||
/* Wait for the PHY to reset */
|
||||
for (timeout = 0; timeout < FEC_MII_TIMEOUT; timeout++)
|
||||
{
|
||||
fec_mii_read(fec_ch, phy_addr, MII_AM79C874_CR, &settings);
|
||||
if (!(settings & MII_AM79C874_CR_RESET))
|
||||
break;
|
||||
}
|
||||
|
||||
/* Wait for auto-negotiation to complete */
|
||||
for (timeout = 0; timeout < FEC_MII_TIMEOUT; timeout++)
|
||||
{
|
||||
settings = 0;
|
||||
fec_mii_read(fec_ch, phy_addr, MII_AM79C874_SR, &settings);
|
||||
if ((settings & AUTONEGLINK) == AUTONEGLINK)
|
||||
break;
|
||||
}
|
||||
if (timeout >= FEC_MII_TIMEOUT)
|
||||
{
|
||||
dbg("%s: PHY reset failed\r\n", __FUNCTION__);
|
||||
return 0;
|
||||
};
|
||||
dbg("%s: PHY reset OK\r\n", __FUNCTION__);
|
||||
dbg("%s: PHY Enable Auto-Negotiation\r\n", __FUNCTION__);
|
||||
|
||||
if (timeout >= FEC_MII_TIMEOUT)
|
||||
{
|
||||
dbg("%s: Auto-negotiation failed (timeout). Set default mode (100Mbps, full duplex)\r\n", __FUNCTION__);
|
||||
/* Enable Auto-Negotiation */
|
||||
if (!fec_mii_write(fec_ch, phy_addr, MII_AM79C874_CR, MII_AM79C874_CR_AUTON | MII_AM79C874_CR_RST_NEG))
|
||||
return 0;
|
||||
|
||||
/* Set the default mode (Full duplex, 100 Mbps) */
|
||||
if (!fec_mii_write(fec_ch, phy_addr, MII_AM79C874_CR, MII_AM79C874_CR_100MB | MII_AM79C874_CR_DPLX))
|
||||
{
|
||||
dbg("%s: forced setting 100Mbps/full failed.\r\n", __FUNCTION__);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
dbg("%s:PHY Wait for auto-negotiation to complete\r\n", __FUNCTION__);
|
||||
|
||||
/* Wait for auto-negotiation to complete */
|
||||
for (timeout = 0; timeout < FEC_MII_TIMEOUT; timeout++)
|
||||
{
|
||||
settings = 0;
|
||||
fec_mii_read(fec_ch, phy_addr, MII_AM79C874_SR, &settings);
|
||||
if ((settings & AUTONEGLINK) == AUTONEGLINK)
|
||||
break;
|
||||
}
|
||||
|
||||
if (timeout >= FEC_MII_TIMEOUT)
|
||||
{
|
||||
dbg("%s: Auto-negotiation failed (timeout). Set default mode (100Mbps, full duplex)\r\n", __FUNCTION__);
|
||||
|
||||
/* Set the default mode (Full duplex, 100 Mbps) */
|
||||
if (!fec_mii_write(fec_ch, phy_addr, MII_AM79C874_CR, MII_AM79C874_CR_100MB | MII_AM79C874_CR_DPLX))
|
||||
{
|
||||
dbg("%s: forced setting 100Mbps/full failed.\r\n", __FUNCTION__);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef DBG_AM79
|
||||
settings = 0;
|
||||
settings = 0;
|
||||
|
||||
fec_mii_read(fec_ch, phy_addr, MII_AM79C874_DR, &settings);
|
||||
fec_mii_read(fec_ch, phy_addr, MII_AM79C874_DR, &settings);
|
||||
|
||||
dbg("%s: PHY Mode:\r\n", __FUNCTION__);
|
||||
if (settings & MII_AM79C874_DR_DATA_RATE)
|
||||
dbg("%s: 100Mbps", __FUNCTION__);
|
||||
else
|
||||
dbg("%s: 10Mbps ", __FUNCTION__);
|
||||
dbg("%s: PHY Mode:\r\n", __FUNCTION__);
|
||||
if (settings & MII_AM79C874_DR_DATA_RATE)
|
||||
dbg("%s: 100Mbps", __FUNCTION__);
|
||||
else
|
||||
dbg("%s: 10Mbps ", __FUNCTION__);
|
||||
|
||||
if (settings & MII_AM79C874_DR_DPLX)
|
||||
dbg("%s: Full-duplex\r\n", __FUNCTION__);
|
||||
else
|
||||
dbg("%s: Half-duplex\r\n", __FUNCTION__);
|
||||
if (settings & MII_AM79C874_DR_DPLX)
|
||||
dbg("%s: Full-duplex\r\n", __FUNCTION__);
|
||||
else
|
||||
dbg("%s: Half-duplex\r\n", __FUNCTION__);
|
||||
|
||||
dbg("%s:PHY auto-negotiation complete\r\n", __FUNCTION__);
|
||||
dbg("%s:PHY auto-negotiation complete\r\n", __FUNCTION__);
|
||||
#endif /* DBG_AM79 */
|
||||
|
||||
return 1;
|
||||
return 1;
|
||||
}
|
||||
|
||||
+95
-95
@@ -37,7 +37,7 @@
|
||||
* This function sets up the Auto-Negotiate Advertisement register
|
||||
* within the PHY and then forces the PHY to auto-negotiate for
|
||||
* it's settings.
|
||||
*
|
||||
*
|
||||
* Params:
|
||||
* fec_ch FEC channel
|
||||
* phy_addr Address of the PHY.
|
||||
@@ -50,133 +50,133 @@
|
||||
*/
|
||||
int bcm5222_init(uint8_t fec_ch, uint8_t phy_addr, uint8_t speed, uint8_t duplex)
|
||||
{
|
||||
int timeout;
|
||||
uint16_t settings;
|
||||
int timeout;
|
||||
uint16_t settings;
|
||||
|
||||
/* Initialize the MII interface */
|
||||
fec_mii_init(fec_ch, SYSCLK / 1000);
|
||||
/* Initialize the MII interface */
|
||||
fec_mii_init(fec_ch, SYSCLK / 1000);
|
||||
dbg("PHY reset\r\n");
|
||||
|
||||
/* Reset the PHY */
|
||||
if (!fec_mii_write(fec_ch, phy_addr, BCM5222_CTRL, BCM5222_CTRL_RESET | BCM5222_CTRL_ANE))
|
||||
return 0;
|
||||
/* Reset the PHY */
|
||||
if (!fec_mii_write(fec_ch, phy_addr, BCM5222_CTRL, BCM5222_CTRL_RESET | BCM5222_CTRL_ANE))
|
||||
return 0;
|
||||
|
||||
/* Wait for the PHY to reset */
|
||||
for (timeout = 0; timeout < FEC_MII_TIMEOUT; timeout++)
|
||||
{
|
||||
fec_mii_read(fec_ch, phy_addr, BCM5222_CTRL, &settings);
|
||||
if (!(settings & BCM5222_CTRL_RESET))
|
||||
break;
|
||||
}
|
||||
if(timeout >= FEC_MII_TIMEOUT)
|
||||
return 0;
|
||||
/* Wait for the PHY to reset */
|
||||
for (timeout = 0; timeout < FEC_MII_TIMEOUT; timeout++)
|
||||
{
|
||||
fec_mii_read(fec_ch, phy_addr, BCM5222_CTRL, &settings);
|
||||
if (!(settings & BCM5222_CTRL_RESET))
|
||||
break;
|
||||
}
|
||||
if(timeout >= FEC_MII_TIMEOUT)
|
||||
return 0;
|
||||
|
||||
dbg("PHY reset OK\r\n");
|
||||
|
||||
settings = (BCM5222_AN_ADV_NEXT_PAGE | BCM5222_AN_ADV_PAUSE);
|
||||
settings = (BCM5222_AN_ADV_NEXT_PAGE | BCM5222_AN_ADV_PAUSE);
|
||||
|
||||
if (speed == FEC_MII_10BASE_T)
|
||||
settings |= (uint16_t)((duplex == FEC_MII_FULL_DUPLEX)
|
||||
? (BCM5222_AN_ADV_10BT_FDX | BCM5222_AN_ADV_10BT)
|
||||
: BCM5222_AN_ADV_10BT);
|
||||
else /* (speed == FEC_MII_100BASE_TX) */
|
||||
settings = (uint16_t)((duplex == FEC_MII_FULL_DUPLEX)
|
||||
? (BCM5222_AN_ADV_100BTX_FDX | BCM5222_AN_ADV_100BTX
|
||||
| BCM5222_AN_ADV_10BT_FDX | BCM5222_AN_ADV_10BT)
|
||||
: (BCM5222_AN_ADV_100BTX | BCM5222_AN_ADV_10BT));
|
||||
if (speed == FEC_MII_10BASE_T)
|
||||
settings |= (uint16_t)((duplex == FEC_MII_FULL_DUPLEX)
|
||||
? (BCM5222_AN_ADV_10BT_FDX | BCM5222_AN_ADV_10BT)
|
||||
: BCM5222_AN_ADV_10BT);
|
||||
else /* (speed == FEC_MII_100BASE_TX) */
|
||||
settings = (uint16_t)((duplex == FEC_MII_FULL_DUPLEX)
|
||||
? (BCM5222_AN_ADV_100BTX_FDX | BCM5222_AN_ADV_100BTX
|
||||
| BCM5222_AN_ADV_10BT_FDX | BCM5222_AN_ADV_10BT)
|
||||
: (BCM5222_AN_ADV_100BTX | BCM5222_AN_ADV_10BT));
|
||||
|
||||
/* Set the Auto-Negotiation Advertisement Register */
|
||||
if (!fec_mii_write(fec_ch, phy_addr, BCM5222_AN_ADV, settings))
|
||||
return 0;
|
||||
/* Set the Auto-Negotiation Advertisement Register */
|
||||
if (!fec_mii_write(fec_ch, phy_addr, BCM5222_AN_ADV, settings))
|
||||
return 0;
|
||||
|
||||
dbg("PHY Enable Auto-Negotiation\r\n");
|
||||
|
||||
/* Enable Auto-Negotiation */
|
||||
if (!fec_mii_write(fec_ch, phy_addr, BCM5222_CTRL, (BCM5222_CTRL_ANE | BCM5222_CTRL_RESTART_AN)))
|
||||
return 0;
|
||||
/* Enable Auto-Negotiation */
|
||||
if (!fec_mii_write(fec_ch, phy_addr, BCM5222_CTRL, (BCM5222_CTRL_ANE | BCM5222_CTRL_RESTART_AN)))
|
||||
return 0;
|
||||
|
||||
dbg("PHY Wait for auto-negotiation to complete\r\n");
|
||||
|
||||
/* Wait for auto-negotiation to complete */
|
||||
for (timeout = 0; timeout < FEC_MII_TIMEOUT; timeout++)
|
||||
{
|
||||
if (!fec_mii_read(fec_ch, phy_addr, BCM5222_STAT, &settings))
|
||||
return 0;
|
||||
if (settings & BCM5222_STAT_AN_COMPLETE)
|
||||
break;
|
||||
}
|
||||
/* Wait for auto-negotiation to complete */
|
||||
for (timeout = 0; timeout < FEC_MII_TIMEOUT; timeout++)
|
||||
{
|
||||
if (!fec_mii_read(fec_ch, phy_addr, BCM5222_STAT, &settings))
|
||||
return 0;
|
||||
if (settings & BCM5222_STAT_AN_COMPLETE)
|
||||
break;
|
||||
}
|
||||
|
||||
if (timeout < FEC_MII_TIMEOUT)
|
||||
{
|
||||
if (timeout < FEC_MII_TIMEOUT)
|
||||
{
|
||||
dbg("PHY auto-negociation complete\r\n");
|
||||
|
||||
/* Read Auxiliary Control/Status Register */
|
||||
if (!fec_mii_read(fec_ch, phy_addr, BCM5222_ACSR, &settings))
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Read Auxiliary Control/Status Register */
|
||||
if (!fec_mii_read(fec_ch, phy_addr, BCM5222_ACSR, &settings))
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
dbg("auto negotiation failed, PHY Set the default mode\r\n");
|
||||
|
||||
/* Set the default mode (Full duplex, 100 Mbps) */
|
||||
if (!fec_mii_write(fec_ch, phy_addr, BCM5222_ACSR, settings = (BCM5222_ACSR_100BTX | BCM5222_ACSR_FDX)))
|
||||
return 0;
|
||||
}
|
||||
/* Set the default mode (Full duplex, 100 Mbps) */
|
||||
if (!fec_mii_write(fec_ch, phy_addr, BCM5222_ACSR, settings = (BCM5222_ACSR_100BTX | BCM5222_ACSR_FDX)))
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Set the proper duplex in the FEC now that we have auto-negotiated */
|
||||
if (settings & BCM5222_ACSR_FDX)
|
||||
fec_duplex(fec_ch, FEC_MII_FULL_DUPLEX);
|
||||
else
|
||||
fec_duplex(fec_ch, FEC_MII_HALF_DUPLEX);
|
||||
/* Set the proper duplex in the FEC now that we have auto-negotiated */
|
||||
if (settings & BCM5222_ACSR_FDX)
|
||||
fec_duplex(fec_ch, FEC_MII_FULL_DUPLEX);
|
||||
else
|
||||
fec_duplex(fec_ch, FEC_MII_HALF_DUPLEX);
|
||||
|
||||
dbg("PHY Mode: ");
|
||||
|
||||
if (settings & BCM5222_ACSR_100BTX)
|
||||
if (settings & BCM5222_ACSR_100BTX)
|
||||
dbg("100Mbps\r\n");
|
||||
else
|
||||
else
|
||||
dbg("10Mbps\r\n");
|
||||
|
||||
if (settings & BCM5222_ACSR_FDX)
|
||||
if (settings & BCM5222_ACSR_FDX)
|
||||
dbg("Full-duplex\r\n");
|
||||
else
|
||||
else
|
||||
dbg("Half-duplex\r\n");
|
||||
|
||||
return 1;
|
||||
return 1;
|
||||
}
|
||||
|
||||
void bcm5222_get_reg(uint16_t* status0, uint16_t* status1)
|
||||
{
|
||||
fec_mii_read(0, 0x00, 0x00000000, &status0[0]);
|
||||
fec_mii_read(0, 0x00, 0x00000001, &status0[1]);
|
||||
fec_mii_read(0, 0x00, 0x00000004, &status0[4]);
|
||||
fec_mii_read(0, 0x00, 0x00000005, &status0[5]);
|
||||
fec_mii_read(0, 0x00, 0x00000006, &status0[6]);
|
||||
fec_mii_read(0, 0x00, 0x00000007, &status0[7]);
|
||||
fec_mii_read(0, 0x00, 0x00000008, &status0[8]);
|
||||
fec_mii_read(0, 0x00, 0x00000010, &status0[16]);
|
||||
fec_mii_read(0, 0x00, 0x00000011, &status0[17]);
|
||||
fec_mii_read(0, 0x00, 0x00000012, &status0[18]);
|
||||
fec_mii_read(0, 0x00, 0x00000013, &status0[19]);
|
||||
fec_mii_read(0, 0x00, 0x00000018, &status0[24]);
|
||||
fec_mii_read(0, 0x00, 0x00000019, &status0[25]);
|
||||
fec_mii_read(0, 0x00, 0x0000001B, &status0[27]);
|
||||
fec_mii_read(0, 0x00, 0x0000001C, &status0[28]);
|
||||
fec_mii_read(0, 0x00, 0x0000001E, &status0[30]);
|
||||
fec_mii_read(0, 0x01, 0x00000000, &status1[0]);
|
||||
fec_mii_read(0, 0x01, 0x00000001, &status1[1]);
|
||||
fec_mii_read(0, 0x01, 0x00000004, &status1[4]);
|
||||
fec_mii_read(0, 0x01, 0x00000005, &status1[5]);
|
||||
fec_mii_read(0, 0x01, 0x00000006, &status1[6]);
|
||||
fec_mii_read(0, 0x01, 0x00000007, &status1[7]);
|
||||
fec_mii_read(0, 0x01, 0x00000008, &status1[8]);
|
||||
fec_mii_read(0, 0x01, 0x00000010, &status1[16]);
|
||||
fec_mii_read(0, 0x01, 0x00000011, &status1[17]);
|
||||
fec_mii_read(0, 0x01, 0x00000012, &status1[18]);
|
||||
fec_mii_read(0, 0x01, 0x00000013, &status1[19]);
|
||||
fec_mii_read(0, 0x01, 0x00000018, &status1[24]);
|
||||
fec_mii_read(0, 0x01, 0x00000019, &status1[25]);
|
||||
fec_mii_read(0, 0x01, 0x0000001B, &status1[27]);
|
||||
fec_mii_read(0, 0x01, 0x0000001C, &status1[28]);
|
||||
fec_mii_read(0, 0x01, 0x0000001E, &status1[30]);
|
||||
fec_mii_read(0, 0x00, 0x00000000, &status0[0]);
|
||||
fec_mii_read(0, 0x00, 0x00000001, &status0[1]);
|
||||
fec_mii_read(0, 0x00, 0x00000004, &status0[4]);
|
||||
fec_mii_read(0, 0x00, 0x00000005, &status0[5]);
|
||||
fec_mii_read(0, 0x00, 0x00000006, &status0[6]);
|
||||
fec_mii_read(0, 0x00, 0x00000007, &status0[7]);
|
||||
fec_mii_read(0, 0x00, 0x00000008, &status0[8]);
|
||||
fec_mii_read(0, 0x00, 0x00000010, &status0[16]);
|
||||
fec_mii_read(0, 0x00, 0x00000011, &status0[17]);
|
||||
fec_mii_read(0, 0x00, 0x00000012, &status0[18]);
|
||||
fec_mii_read(0, 0x00, 0x00000013, &status0[19]);
|
||||
fec_mii_read(0, 0x00, 0x00000018, &status0[24]);
|
||||
fec_mii_read(0, 0x00, 0x00000019, &status0[25]);
|
||||
fec_mii_read(0, 0x00, 0x0000001B, &status0[27]);
|
||||
fec_mii_read(0, 0x00, 0x0000001C, &status0[28]);
|
||||
fec_mii_read(0, 0x00, 0x0000001E, &status0[30]);
|
||||
fec_mii_read(0, 0x01, 0x00000000, &status1[0]);
|
||||
fec_mii_read(0, 0x01, 0x00000001, &status1[1]);
|
||||
fec_mii_read(0, 0x01, 0x00000004, &status1[4]);
|
||||
fec_mii_read(0, 0x01, 0x00000005, &status1[5]);
|
||||
fec_mii_read(0, 0x01, 0x00000006, &status1[6]);
|
||||
fec_mii_read(0, 0x01, 0x00000007, &status1[7]);
|
||||
fec_mii_read(0, 0x01, 0x00000008, &status1[8]);
|
||||
fec_mii_read(0, 0x01, 0x00000010, &status1[16]);
|
||||
fec_mii_read(0, 0x01, 0x00000011, &status1[17]);
|
||||
fec_mii_read(0, 0x01, 0x00000012, &status1[18]);
|
||||
fec_mii_read(0, 0x01, 0x00000013, &status1[19]);
|
||||
fec_mii_read(0, 0x01, 0x00000018, &status1[24]);
|
||||
fec_mii_read(0, 0x01, 0x00000019, &status1[25]);
|
||||
fec_mii_read(0, 0x01, 0x0000001B, &status1[27]);
|
||||
fec_mii_read(0, 0x01, 0x0000001C, &status1[28]);
|
||||
fec_mii_read(0, 0x01, 0x0000001E, &status1[30]);
|
||||
}
|
||||
|
||||
|
||||
+96
-96
@@ -39,46 +39,46 @@ uint8_t *unaligned_buffers[NBUF_MAX];
|
||||
*/
|
||||
int nbuf_init(void)
|
||||
{
|
||||
int i;
|
||||
NBUF *nbuf;
|
||||
int i;
|
||||
NBUF *nbuf;
|
||||
|
||||
for (i = 0; i < NBUF_MAXQ; ++i)
|
||||
{
|
||||
/* Initialize all the queues */
|
||||
queue_init(&nbuf_queue[i]);
|
||||
}
|
||||
for (i = 0; i < NBUF_MAXQ; ++i)
|
||||
{
|
||||
/* Initialize all the queues */
|
||||
queue_init(&nbuf_queue[i]);
|
||||
}
|
||||
|
||||
dbg("Creating %d net buffers of %d bytes\r\n", NBUF_MAX, NBUF_SZ);
|
||||
dbg("Creating %d net buffers of %d bytes\r\n", NBUF_MAX, NBUF_SZ);
|
||||
|
||||
for (i = 0; i < NBUF_MAX; ++i)
|
||||
{
|
||||
/* Allocate memory for the network buffer structure */
|
||||
nbuf = (NBUF *) driver_mem_alloc(sizeof(NBUF));
|
||||
if (!nbuf)
|
||||
{
|
||||
xprintf("failed to allocate nbuf\r\n");
|
||||
return 1;
|
||||
}
|
||||
for (i = 0; i < NBUF_MAX; ++i)
|
||||
{
|
||||
/* Allocate memory for the network buffer structure */
|
||||
nbuf = (NBUF *) driver_mem_alloc(sizeof(NBUF));
|
||||
if (!nbuf)
|
||||
{
|
||||
xprintf("failed to allocate nbuf\r\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Allocate memory for the actual data */
|
||||
unaligned_buffers[i] = driver_mem_alloc(NBUF_SZ + 16);
|
||||
nbuf->data = (uint8_t *)((uint32_t)(unaligned_buffers[i] + 15) & 0xFFFFFFF0);
|
||||
if (!nbuf->data)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
/* Allocate memory for the actual data */
|
||||
unaligned_buffers[i] = driver_mem_alloc(NBUF_SZ + 16);
|
||||
nbuf->data = (uint8_t *)((uint32_t)(unaligned_buffers[i] + 15) & 0xFFFFFFF0);
|
||||
if (!nbuf->data)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Initialize the network buffer */
|
||||
nbuf->offset = 0;
|
||||
nbuf->length = 0;
|
||||
/* Initialize the network buffer */
|
||||
nbuf->offset = 0;
|
||||
nbuf->length = 0;
|
||||
|
||||
/* Add the network buffer to the free list */
|
||||
queue_add(&nbuf_queue[NBUF_FREE], (QNODE *)nbuf);
|
||||
}
|
||||
/* Add the network buffer to the free list */
|
||||
queue_add(&nbuf_queue[NBUF_FREE], (QNODE *)nbuf);
|
||||
}
|
||||
|
||||
dbg("NBUF allocation complete\r\n");
|
||||
dbg("NBUF allocation complete\r\n");
|
||||
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -86,23 +86,23 @@ int nbuf_init(void)
|
||||
*/
|
||||
void nbuf_flush(void)
|
||||
{
|
||||
NBUF *nbuf;
|
||||
int i;
|
||||
int level = set_ipl(7);
|
||||
int n = 0;
|
||||
NBUF *nbuf;
|
||||
int i;
|
||||
int level = set_ipl(7);
|
||||
int n = 0;
|
||||
|
||||
for (i = 0; i < NBUF_MAX; ++i)
|
||||
driver_mem_free((uint8_t *) unaligned_buffers[i]);
|
||||
for (i = 0; i < NBUF_MAX; ++i)
|
||||
driver_mem_free((uint8_t *) unaligned_buffers[i]);
|
||||
|
||||
for (i = 0; i < NBUF_MAXQ; ++i)
|
||||
{
|
||||
while ((nbuf = (NBUF *) queue_remove(&nbuf_queue[i])) != NULL)
|
||||
{
|
||||
driver_mem_free(nbuf);
|
||||
++n;
|
||||
}
|
||||
}
|
||||
set_ipl(level);
|
||||
for (i = 0; i < NBUF_MAXQ; ++i)
|
||||
{
|
||||
while ((nbuf = (NBUF *) queue_remove(&nbuf_queue[i])) != NULL)
|
||||
{
|
||||
driver_mem_free(nbuf);
|
||||
++n;
|
||||
}
|
||||
}
|
||||
set_ipl(level);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -114,13 +114,13 @@ void nbuf_flush(void)
|
||||
*/
|
||||
NBUF *nbuf_alloc(void)
|
||||
{
|
||||
NBUF *nbuf;
|
||||
int level = set_ipl(7);
|
||||
NBUF *nbuf;
|
||||
int level = set_ipl(7);
|
||||
|
||||
nbuf = (NBUF *) queue_remove(&nbuf_queue[NBUF_FREE]);
|
||||
set_ipl(level);
|
||||
nbuf = (NBUF *) queue_remove(&nbuf_queue[NBUF_FREE]);
|
||||
set_ipl(level);
|
||||
|
||||
return nbuf;
|
||||
return nbuf;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -131,13 +131,13 @@ NBUF *nbuf_alloc(void)
|
||||
*/
|
||||
void nbuf_free(NBUF *nbuf)
|
||||
{
|
||||
int level = set_ipl(7);
|
||||
int level = set_ipl(7);
|
||||
|
||||
nbuf->offset = 0;
|
||||
nbuf->length = NBUF_SZ;
|
||||
queue_add(&nbuf_queue[NBUF_FREE],(QNODE *) nbuf);
|
||||
nbuf->offset = 0;
|
||||
nbuf->length = NBUF_SZ;
|
||||
queue_add(&nbuf_queue[NBUF_FREE],(QNODE *) nbuf);
|
||||
|
||||
set_ipl(level);
|
||||
set_ipl(level);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -148,13 +148,13 @@ void nbuf_free(NBUF *nbuf)
|
||||
*/
|
||||
NBUF *nbuf_remove(int q)
|
||||
{
|
||||
NBUF *nbuf;
|
||||
int level = set_ipl(7);
|
||||
NBUF *nbuf;
|
||||
int level = set_ipl(7);
|
||||
|
||||
nbuf = (NBUF *) queue_remove(&nbuf_queue[q]);
|
||||
set_ipl(level);
|
||||
nbuf = (NBUF *) queue_remove(&nbuf_queue[q]);
|
||||
set_ipl(level);
|
||||
|
||||
return nbuf;
|
||||
return nbuf;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -165,10 +165,10 @@ NBUF *nbuf_remove(int q)
|
||||
*/
|
||||
void nbuf_add(int q, NBUF *nbuf)
|
||||
{
|
||||
int level = set_ipl(7);
|
||||
int level = set_ipl(7);
|
||||
|
||||
queue_add(&nbuf_queue[q], (QNODE *) nbuf);
|
||||
set_ipl(level);
|
||||
queue_add(&nbuf_queue[q], (QNODE *) nbuf);
|
||||
set_ipl(level);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -176,16 +176,16 @@ void nbuf_add(int q, NBUF *nbuf)
|
||||
*/
|
||||
void nbuf_reset(void)
|
||||
{
|
||||
NBUF *nbuf;
|
||||
int i;
|
||||
int level = set_ipl(7);
|
||||
NBUF *nbuf;
|
||||
int i;
|
||||
int level = set_ipl(7);
|
||||
|
||||
for (i = 1; i < NBUF_MAXQ; ++i)
|
||||
{
|
||||
while ((nbuf = nbuf_remove(i)) != NULL)
|
||||
nbuf_free(nbuf);
|
||||
}
|
||||
set_ipl(level);
|
||||
for (i = 1; i < NBUF_MAXQ; ++i)
|
||||
{
|
||||
while ((nbuf = nbuf_remove(i)) != NULL)
|
||||
nbuf_free(nbuf);
|
||||
}
|
||||
set_ipl(level);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -194,31 +194,31 @@ void nbuf_reset(void)
|
||||
void nbuf_debug_dump(void)
|
||||
{
|
||||
#ifdef DBG_NBUF
|
||||
NBUF *nbuf;
|
||||
int i;
|
||||
int j;
|
||||
int level;
|
||||
NBUF *nbuf;
|
||||
int i;
|
||||
int j;
|
||||
int level;
|
||||
|
||||
level = set_ipl(7);
|
||||
level = set_ipl(7);
|
||||
|
||||
for (i = 0; i < NBUF_MAXQ; ++i)
|
||||
{
|
||||
dbg("\r\n\r\nQueue #%d\r\n\r\n", i);
|
||||
dbg("\tBuffer Location\tOffset\tLength\r\n");
|
||||
dbg("--------------------------------------\r\n");
|
||||
j = 0;
|
||||
nbuf = (NBUF *) queue_peek(&nbuf_queue[i]);
|
||||
for (i = 0; i < NBUF_MAXQ; ++i)
|
||||
{
|
||||
dbg("\r\n\r\nQueue #%d\r\n\r\n", i);
|
||||
dbg("\tBuffer Location\tOffset\tLength\r\n");
|
||||
dbg("--------------------------------------\r\n");
|
||||
j = 0;
|
||||
nbuf = (NBUF *) queue_peek(&nbuf_queue[i]);
|
||||
|
||||
while (nbuf != NULL)
|
||||
{
|
||||
dbg("%d\t0x%08x\t0x%04x\t0x%04x\r\n", j++, nbuf->data,
|
||||
nbuf->offset,
|
||||
nbuf->length);
|
||||
nbuf = (NBUF *) nbuf->node.next;
|
||||
}
|
||||
}
|
||||
dbg("\r\n");
|
||||
while (nbuf != NULL)
|
||||
{
|
||||
dbg("%d\t0x%08x\t0x%04x\t0x%04x\r\n", j++, nbuf->data,
|
||||
nbuf->offset,
|
||||
nbuf->length);
|
||||
nbuf = (NBUF *) nbuf->node.next;
|
||||
}
|
||||
}
|
||||
dbg("\r\n");
|
||||
|
||||
set_ipl(level);
|
||||
set_ipl(level);
|
||||
#endif /* DBG_NBUF */
|
||||
}
|
||||
|
||||
+82
-82
@@ -20,111 +20,111 @@
|
||||
|
||||
int nif_protocol_exist(NIF *nif, uint16_t protocol)
|
||||
{
|
||||
/*
|
||||
* This function searches the list of supported protocols
|
||||
* on the particular NIF and if a protocol handler exists,
|
||||
* true is returned. This function is useful for network cards
|
||||
* that needn't read in the entire frame but can discard frames
|
||||
* arbitrarily.
|
||||
*/
|
||||
int index;
|
||||
/*
|
||||
* This function searches the list of supported protocols
|
||||
* on the particular NIF and if a protocol handler exists,
|
||||
* true is returned. This function is useful for network cards
|
||||
* that needn't read in the entire frame but can discard frames
|
||||
* arbitrarily.
|
||||
*/
|
||||
int index;
|
||||
|
||||
for (index = 0; index < nif->num_protocol; ++index)
|
||||
{
|
||||
if (nif->protocol[index].protocol == protocol)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
for (index = 0; index < nif->num_protocol; ++index)
|
||||
{
|
||||
if (nif->protocol[index].protocol == protocol)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void nif_protocol_handler(NIF *nif, uint16_t protocol, NBUF *pNbuf)
|
||||
{
|
||||
/*
|
||||
* This function searches the list of supported protocols
|
||||
* on the particular NIF and if a protocol handler exists,
|
||||
* the protocol handler is invoked. This routine called by
|
||||
* network device driver after receiving a frame.
|
||||
*/
|
||||
int index;
|
||||
/*
|
||||
* This function searches the list of supported protocols
|
||||
* on the particular NIF and if a protocol handler exists,
|
||||
* the protocol handler is invoked. This routine called by
|
||||
* network device driver after receiving a frame.
|
||||
*/
|
||||
int index;
|
||||
|
||||
for (index = 0; index < nif->num_protocol; ++index)
|
||||
{
|
||||
if (nif->protocol[index].protocol == protocol)
|
||||
{
|
||||
dbg("call protocol handler for protocol %d at %p\r\n", protocol,
|
||||
nif->protocol[index].handler);
|
||||
nif->protocol[index].handler(nif,pNbuf);
|
||||
return;
|
||||
}
|
||||
}
|
||||
dbg("no protocol handler found for protocol %d\r\n", protocol);
|
||||
for (index = 0; index < nif->num_protocol; ++index)
|
||||
{
|
||||
if (nif->protocol[index].protocol == protocol)
|
||||
{
|
||||
dbg("call protocol handler for protocol %d at %p\r\n", protocol,
|
||||
nif->protocol[index].handler);
|
||||
nif->protocol[index].handler(nif,pNbuf);
|
||||
return;
|
||||
}
|
||||
}
|
||||
dbg("no protocol handler found for protocol %d\r\n", protocol);
|
||||
}
|
||||
|
||||
void *nif_get_protocol_info(NIF *nif, uint16_t protocol)
|
||||
{
|
||||
/*
|
||||
* This function searches the list of supported protocols
|
||||
* on the particular NIF and returns a pointer to the
|
||||
* config info for 'protocol', otherwise NULL is returned.
|
||||
*/
|
||||
int index;
|
||||
/*
|
||||
* This function searches the list of supported protocols
|
||||
* on the particular NIF and returns a pointer to the
|
||||
* config info for 'protocol', otherwise NULL is returned.
|
||||
*/
|
||||
int index;
|
||||
|
||||
for (index = 0; index < nif->num_protocol; ++index)
|
||||
{
|
||||
if (nif->protocol[index].protocol == protocol)
|
||||
return (void *)nif->protocol[index].info;
|
||||
}
|
||||
return (void *)0;
|
||||
for (index = 0; index < nif->num_protocol; ++index)
|
||||
{
|
||||
if (nif->protocol[index].protocol == protocol)
|
||||
return (void *)nif->protocol[index].info;
|
||||
}
|
||||
return (void *)0;
|
||||
}
|
||||
|
||||
int nif_bind_protocol(NIF *nif, uint16_t protocol, void (*handler)(NIF *,NBUF *),
|
||||
void *info)
|
||||
void *info)
|
||||
{
|
||||
/*
|
||||
* This function registers 'protocol' as a supported
|
||||
* protocol in 'nif'.
|
||||
*/
|
||||
if (nif->num_protocol < (MAX_SUP_PROTO - 1))
|
||||
{
|
||||
nif->protocol[nif->num_protocol].protocol = protocol;
|
||||
nif->protocol[nif->num_protocol].handler = (void(*)(NIF *, NBUF *)) handler;
|
||||
nif->protocol[nif->num_protocol].info = info;
|
||||
++nif->num_protocol;
|
||||
/*
|
||||
* This function registers 'protocol' as a supported
|
||||
* protocol in 'nif'.
|
||||
*/
|
||||
if (nif->num_protocol < (MAX_SUP_PROTO - 1))
|
||||
{
|
||||
nif->protocol[nif->num_protocol].protocol = protocol;
|
||||
nif->protocol[nif->num_protocol].handler = (void(*)(NIF *, NBUF *)) handler;
|
||||
nif->protocol[nif->num_protocol].info = info;
|
||||
++nif->num_protocol;
|
||||
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
NIF *nif_init (NIF *nif)
|
||||
{
|
||||
int i;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < ETH_ADDR_LEN; ++i)
|
||||
{
|
||||
nif->hwa[i] = 0;
|
||||
nif->broadcast[i] = 0xFF;
|
||||
}
|
||||
for (i = 0; i < ETH_ADDR_LEN; ++i)
|
||||
{
|
||||
nif->hwa[i] = 0;
|
||||
nif->broadcast[i] = 0xFF;
|
||||
}
|
||||
|
||||
for (i = 0; i < MAX_SUP_PROTO; ++i)
|
||||
{
|
||||
nif->protocol[i].protocol = 0;
|
||||
nif->protocol[i].handler = 0;
|
||||
nif->protocol[i].info = 0;
|
||||
}
|
||||
nif->num_protocol = 0;
|
||||
for (i = 0; i < MAX_SUP_PROTO; ++i)
|
||||
{
|
||||
nif->protocol[i].protocol = 0;
|
||||
nif->protocol[i].handler = 0;
|
||||
nif->protocol[i].info = 0;
|
||||
}
|
||||
nif->num_protocol = 0;
|
||||
|
||||
nif->mtu = 0;
|
||||
nif->ch = 0;
|
||||
nif->send = 0;
|
||||
nif->mtu = 0;
|
||||
nif->ch = 0;
|
||||
nif->send = 0;
|
||||
|
||||
nif->f_rx = 0;
|
||||
nif->f_tx = 0;
|
||||
nif->f_rx_err = 0;
|
||||
nif->f_tx_err = 0;
|
||||
nif->f_err = 0;
|
||||
nif->f_rx = 0;
|
||||
nif->f_tx = 0;
|
||||
nif->f_rx_err = 0;
|
||||
nif->f_tx_err = 0;
|
||||
nif->f_err = 0;
|
||||
|
||||
return nif;
|
||||
return nif;
|
||||
}
|
||||
|
||||
+525
-525
File diff suppressed because it is too large
Load Diff
+201
-201
@@ -42,9 +42,9 @@
|
||||
#define SREC_COUNT(a) (a)[1] /* length of valid bytes to follow */
|
||||
#define SREC_ADDR16(a) (256 * (a)[2] + (a)[3]) /* 2 byte address field */
|
||||
#define SREC_ADDR24(a) (0x10000 * (a)[2] + 0x100 * \
|
||||
(a)[3] + (a)[4]) /* 3 byte address field */
|
||||
(a)[3] + (a)[4]) /* 3 byte address field */
|
||||
#define SREC_ADDR32(a) (0x1000000 * a[2] + 0x10000 * \
|
||||
a[3] + 0x100 * (a)[4] + (a)[5]) /* 4 byte address field */
|
||||
a[3] + 0x100 * (a)[4] + (a)[5]) /* 4 byte address field */
|
||||
#define SREC_DATA16(a) ((uint8_t *)&((a)[4])) /* address of first byte of data in a record */
|
||||
#define SREC_DATA24(a) ((uint8_t *)&((a)[5])) /* address of first data byte in 24 bit record */
|
||||
#define SREC_DATA32(a) ((uint8_t *)&((a)[6])) /* adress of first byte of a record with 32 bit address field */
|
||||
@@ -67,13 +67,13 @@
|
||||
*/
|
||||
static uint8_t nibble_to_byte(uint8_t nibble)
|
||||
{
|
||||
if ((nibble >= '0') && (nibble <= '9'))
|
||||
return nibble - '0';
|
||||
else if ((nibble >= 'A' && nibble <= 'F'))
|
||||
return 10 + nibble - 'A';
|
||||
else if ((nibble >= 'a' && nibble <= 'f'))
|
||||
return 10 + nibble - 'a';
|
||||
return 0;
|
||||
if ((nibble >= '0') && (nibble <= '9'))
|
||||
return nibble - '0';
|
||||
else if ((nibble >= 'A' && nibble <= 'F'))
|
||||
return 10 + nibble - 'A';
|
||||
else if ((nibble >= 'a' && nibble <= 'f'))
|
||||
return 10 + nibble - 'a';
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -81,7 +81,7 @@ static uint8_t nibble_to_byte(uint8_t nibble)
|
||||
*/
|
||||
static uint8_t hex_to_byte(uint8_t hex[2])
|
||||
{
|
||||
return 16 * (nibble_to_byte(hex[0])) + (nibble_to_byte(hex[1]));
|
||||
return 16 * (nibble_to_byte(hex[0])) + (nibble_to_byte(hex[1]));
|
||||
}
|
||||
|
||||
#ifdef _NOT_USED_
|
||||
@@ -90,7 +90,7 @@ static uint8_t hex_to_byte(uint8_t hex[2])
|
||||
*/
|
||||
static uint16_t hex_to_word(uint8_t hex[4])
|
||||
{
|
||||
return 256 * hex_to_byte(&hex[0]) + hex_to_byte(&hex[2]);
|
||||
return 256 * hex_to_byte(&hex[0]) + hex_to_byte(&hex[2]);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -98,7 +98,7 @@ static uint16_t hex_to_word(uint8_t hex[4])
|
||||
*/
|
||||
static uint32_t hex_to_long(uint8_t hex[8])
|
||||
{
|
||||
return 65536 * hex_to_word(&hex[0]) + hex_to_word(&hex[4]);
|
||||
return 65536 * hex_to_word(&hex[0]) + hex_to_word(&hex[4]);
|
||||
}
|
||||
#endif /* _NOT_USED_ */
|
||||
|
||||
@@ -109,46 +109,46 @@ static uint32_t hex_to_long(uint8_t hex[8])
|
||||
*/
|
||||
static uint8_t checksum(uint8_t arr[])
|
||||
{
|
||||
int i;
|
||||
uint8_t checksum = SREC_COUNT(arr);
|
||||
int i;
|
||||
uint8_t checksum = SREC_COUNT(arr);
|
||||
|
||||
for (i = 0; i < SREC_COUNT(arr) - 1; i++)
|
||||
{
|
||||
checksum += arr[i + 2];
|
||||
}
|
||||
return ~checksum;
|
||||
for (i = 0; i < SREC_COUNT(arr) - 1; i++)
|
||||
{
|
||||
checksum += arr[i + 2];
|
||||
}
|
||||
return ~checksum;
|
||||
}
|
||||
|
||||
void print_record(uint8_t *arr)
|
||||
{
|
||||
switch (SREC_TYPE(arr))
|
||||
{
|
||||
case 0:
|
||||
{
|
||||
printf("type 0x%x ", SREC_TYPE(arr));
|
||||
printf("count 0x%x ", SREC_COUNT(arr));
|
||||
printf("addr 0x%x ", SREC_ADDR16(arr));
|
||||
printf("module %11.11s ", SREC_DATA16(arr));
|
||||
printf("chk 0x%x 0x%x\r\n", SREC_CHECKSUM(arr), checksum(arr));
|
||||
}
|
||||
break;
|
||||
switch (SREC_TYPE(arr))
|
||||
{
|
||||
case 0:
|
||||
{
|
||||
printf("type 0x%x ", SREC_TYPE(arr));
|
||||
printf("count 0x%x ", SREC_COUNT(arr));
|
||||
printf("addr 0x%x ", SREC_ADDR16(arr));
|
||||
printf("module %11.11s ", SREC_DATA16(arr));
|
||||
printf("chk 0x%x 0x%x\r\n", SREC_CHECKSUM(arr), checksum(arr));
|
||||
}
|
||||
break;
|
||||
|
||||
case 3:
|
||||
case 7:
|
||||
{
|
||||
printf("type 0x%x ", SREC_TYPE(arr));
|
||||
printf("count 0x%x ", SREC_COUNT(arr));
|
||||
printf("addr 0x%x ", SREC_ADDR32(arr));
|
||||
printf("data %02x,%02x,%02x,%02x,... ",
|
||||
SREC_DATA32(arr)[0], SREC_DATA32(arr)[1], SREC_DATA32(arr)[3], SREC_DATA32(arr)[4]);
|
||||
printf("chk 0x%x 0x%x\r\n", SREC_CHECKSUM(arr), checksum(arr));
|
||||
}
|
||||
break;
|
||||
case 3:
|
||||
case 7:
|
||||
{
|
||||
printf("type 0x%x ", SREC_TYPE(arr));
|
||||
printf("count 0x%x ", SREC_COUNT(arr));
|
||||
printf("addr 0x%x ", SREC_ADDR32(arr));
|
||||
printf("data %02x,%02x,%02x,%02x,... ",
|
||||
SREC_DATA32(arr)[0], SREC_DATA32(arr)[1], SREC_DATA32(arr)[3], SREC_DATA32(arr)[4]);
|
||||
printf("chk 0x%x 0x%x\r\n", SREC_CHECKSUM(arr), checksum(arr));
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
printf("unsupported report type %d in print_record\r\n", arr[0]);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
printf("unsupported report type %d in print_record\r\n", arr[0]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -156,26 +156,26 @@ void print_record(uint8_t *arr)
|
||||
*/
|
||||
static void line_to_vector(uint8_t *buff, uint8_t *vector)
|
||||
{
|
||||
int i;
|
||||
int length;
|
||||
uint8_t *vp = vector;
|
||||
int i;
|
||||
int length;
|
||||
uint8_t *vp = vector;
|
||||
|
||||
length = hex_to_byte(buff + 2);
|
||||
length = hex_to_byte(buff + 2);
|
||||
|
||||
buff++;
|
||||
*vp++ = nibble_to_byte(*buff); /* record type. Only one single nibble */
|
||||
buff++;
|
||||
buff++;
|
||||
*vp++ = nibble_to_byte(*buff); /* record type. Only one single nibble */
|
||||
buff++;
|
||||
|
||||
for (i = 0; i <= length; i++)
|
||||
{
|
||||
*vp++ = hex_to_byte(buff);
|
||||
buff += 2;
|
||||
}
|
||||
for (i = 0; i <= length; i++)
|
||||
{
|
||||
*vp++ = hex_to_byte(buff);
|
||||
buff += 2;
|
||||
}
|
||||
}
|
||||
|
||||
static void vector_to_line(uint8_t *vector, uint8_t *buff)
|
||||
{
|
||||
sprintf(buff, "S");
|
||||
sprintf(buff, "S");
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -199,157 +199,157 @@ static void vector_to_line(uint8_t *vector, uint8_t *buff)
|
||||
*/
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
int fres;
|
||||
int set;
|
||||
char *filename = NULL;
|
||||
FILE *file;
|
||||
int ret = OK;
|
||||
int i;
|
||||
int fres;
|
||||
int set;
|
||||
char *filename = NULL;
|
||||
FILE *file;
|
||||
int ret = OK;
|
||||
int i;
|
||||
|
||||
|
||||
for (i = 1; i < argc; i++)
|
||||
{
|
||||
if (argv[i][0] == '-')
|
||||
{
|
||||
/* option */
|
||||
if (strcmp(argv[i], "-s") == 0)
|
||||
{
|
||||
set = 1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
filename = argv[i];
|
||||
}
|
||||
}
|
||||
for (i = 1; i < argc; i++)
|
||||
{
|
||||
if (argv[i][0] == '-')
|
||||
{
|
||||
/* option */
|
||||
if (strcmp(argv[i], "-s") == 0)
|
||||
{
|
||||
set = 1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
filename = argv[i];
|
||||
}
|
||||
}
|
||||
|
||||
if (filename == NULL)
|
||||
{
|
||||
fprintf(stderr, "no filename given\n");
|
||||
exit(1);
|
||||
}
|
||||
if (filename == NULL)
|
||||
{
|
||||
fprintf(stderr, "no filename given\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
if ((file = fopen(filename, "r")) != NULL)
|
||||
{
|
||||
uint8_t line[80];
|
||||
int lineno = 0;
|
||||
int data_records = 0;
|
||||
bool found_block_header = false;
|
||||
bool found_block_end = false;
|
||||
bool found_block_data = false;
|
||||
if ((file = fopen(filename, "r")) != NULL)
|
||||
{
|
||||
uint8_t line[80];
|
||||
int lineno = 0;
|
||||
int data_records = 0;
|
||||
bool found_block_header = false;
|
||||
bool found_block_end = false;
|
||||
bool found_block_data = false;
|
||||
|
||||
while (ret == OK && (uint8_t *) fgets((char *) line, sizeof(line), file) != NULL)
|
||||
{
|
||||
lineno++;
|
||||
uint8_t vector[80];
|
||||
char str[255];
|
||||
int length;
|
||||
while (ret == OK && (uint8_t *) fgets((char *) line, sizeof(line), file) != NULL)
|
||||
{
|
||||
lineno++;
|
||||
uint8_t vector[80];
|
||||
char str[255];
|
||||
int length;
|
||||
|
||||
|
||||
|
||||
line_to_vector(line, vector); /* vector now contains the decoded contents of line, from line[1] on */
|
||||
line_to_vector(line, vector); /* vector now contains the decoded contents of line, from line[1] on */
|
||||
|
||||
if (line[0] == 'S')
|
||||
{
|
||||
char header[256];
|
||||
if (line[0] == 'S')
|
||||
{
|
||||
char header[256];
|
||||
|
||||
if (SREC_CHECKSUM(vector) != checksum(vector))
|
||||
{
|
||||
printf("invalid checksum 0x%x (should be 0x%x) in line %d\r\n",
|
||||
SREC_CHECKSUM(vector), checksum(vector), lineno);
|
||||
ret = FAIL;
|
||||
}
|
||||
if (SREC_CHECKSUM(vector) != checksum(vector))
|
||||
{
|
||||
printf("invalid checksum 0x%x (should be 0x%x) in line %d\r\n",
|
||||
SREC_CHECKSUM(vector), checksum(vector), lineno);
|
||||
ret = FAIL;
|
||||
}
|
||||
|
||||
switch (vector[0])
|
||||
{
|
||||
case 0: /* block header */
|
||||
found_block_header = true;
|
||||
if (found_block_data || found_block_end)
|
||||
{
|
||||
printf("S7 or S3 record found before S0: S-records corrupt?\r\n");
|
||||
ret = FAIL;
|
||||
}
|
||||
printf("address: 0x%04x\n", SREC_ADDR16(vector));
|
||||
printf("length of record: %d\n", SREC_COUNT(vector));
|
||||
length = SREC_DATA16_SIZE(vector) - (SREC_DATA16(vector) - vector);
|
||||
printf("length: %d\n", length);
|
||||
strncpy(str, SREC_DATA16(vector), length);
|
||||
str[length] = '\0';
|
||||
printf("Name: %s\n", str);
|
||||
printf("version: %d, revision %d\n",
|
||||
* (unsigned short *)((char *) SREC_DATA16(vector) + length),
|
||||
* (unsigned short *)((char *) SREC_DATA16(vector) + length + 1));
|
||||
print_record(vector);
|
||||
switch (vector[0])
|
||||
{
|
||||
case 0: /* block header */
|
||||
found_block_header = true;
|
||||
if (found_block_data || found_block_end)
|
||||
{
|
||||
printf("S7 or S3 record found before S0: S-records corrupt?\r\n");
|
||||
ret = FAIL;
|
||||
}
|
||||
printf("address: 0x%04x\n", SREC_ADDR16(vector));
|
||||
printf("length of record: %d\n", SREC_COUNT(vector));
|
||||
length = SREC_DATA16_SIZE(vector) - (SREC_DATA16(vector) - vector);
|
||||
printf("length: %d\n", length);
|
||||
strncpy(str, SREC_DATA16(vector), length);
|
||||
str[length] = '\0';
|
||||
printf("Name: %s\n", str);
|
||||
printf("version: %d, revision %d\n",
|
||||
* (unsigned short *)((char *) SREC_DATA16(vector) + length),
|
||||
* (unsigned short *)((char *) SREC_DATA16(vector) + length + 1));
|
||||
print_record(vector);
|
||||
|
||||
break;
|
||||
break;
|
||||
|
||||
case 2: /* three byte address field data record */
|
||||
if (!found_block_header || found_block_end)
|
||||
{
|
||||
printf("S3 record found before S0 or after S7: S-records corrupt?\r\n");
|
||||
ret = FAIL;
|
||||
}
|
||||
// ret = callback((uint8_t *) SREC_ADDR24(vector), SREC_DATA24(vector), SREC_DATA24_SIZE(vector));
|
||||
data_records++;
|
||||
break;
|
||||
case 2: /* three byte address field data record */
|
||||
if (!found_block_header || found_block_end)
|
||||
{
|
||||
printf("S3 record found before S0 or after S7: S-records corrupt?\r\n");
|
||||
ret = FAIL;
|
||||
}
|
||||
// ret = callback((uint8_t *) SREC_ADDR24(vector), SREC_DATA24(vector), SREC_DATA24_SIZE(vector));
|
||||
data_records++;
|
||||
break;
|
||||
|
||||
case 3: /* four byte address field data record */
|
||||
if (!found_block_header || found_block_end)
|
||||
{
|
||||
printf("S3 record found before S0 or after S7: S-records corrupt?\r\n");
|
||||
ret = FAIL;
|
||||
}
|
||||
// ret = callback((uint8_t *) SREC_ADDR32(vector), SREC_DATA32(vector), SREC_DATA32_SIZE(vector));
|
||||
data_records++;
|
||||
break;
|
||||
case 3: /* four byte address field data record */
|
||||
if (!found_block_header || found_block_end)
|
||||
{
|
||||
printf("S3 record found before S0 or after S7: S-records corrupt?\r\n");
|
||||
ret = FAIL;
|
||||
}
|
||||
// ret = callback((uint8_t *) SREC_ADDR32(vector), SREC_DATA32(vector), SREC_DATA32_SIZE(vector));
|
||||
data_records++;
|
||||
break;
|
||||
|
||||
case 7: /* four byte address field end record */
|
||||
if (!found_block_header || found_block_end)
|
||||
{
|
||||
printf("S7 record found before S0 or after S7: S-records corrupt?\r\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
// printf("S7 record (end) found after %d valid data blocks\r\n", data_records);
|
||||
//*start_address = (void *) SREC_ADDR32(vector);
|
||||
}
|
||||
break;
|
||||
case 7: /* four byte address field end record */
|
||||
if (!found_block_header || found_block_end)
|
||||
{
|
||||
printf("S7 record found before S0 or after S7: S-records corrupt?\r\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
// printf("S7 record (end) found after %d valid data blocks\r\n", data_records);
|
||||
//*start_address = (void *) SREC_ADDR32(vector);
|
||||
}
|
||||
break;
|
||||
|
||||
case 8: /* three byte address field end record */
|
||||
if (!found_block_header || found_block_end)
|
||||
{
|
||||
printf("S8 record found before S0 or after S8: S-records corrupt?\r\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
// printf("S7 record (end) found after %d valid data blocks\r\n", data_records);
|
||||
//*start_address = (void *) SREC_ADDR24(vector);
|
||||
}
|
||||
break;
|
||||
case 8: /* three byte address field end record */
|
||||
if (!found_block_header || found_block_end)
|
||||
{
|
||||
printf("S8 record found before S0 or after S8: S-records corrupt?\r\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
// printf("S7 record (end) found after %d valid data blocks\r\n", data_records);
|
||||
//*start_address = (void *) SREC_ADDR24(vector);
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
printf("unsupported record type (%d) found in line %d\r\n", vector[0], lineno);
|
||||
printf("offending line: \r\n");
|
||||
printf("%s\r\n", line);
|
||||
ret = FAIL;
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("illegal character ('%c') found on line %d: S-records corrupt?\r\n", line[0], lineno);
|
||||
ret = FAIL;
|
||||
break;
|
||||
}
|
||||
}
|
||||
fclose(file);
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("could not open file %s\r\n", filename);
|
||||
ret = FILE_OPEN;
|
||||
}
|
||||
return ret;
|
||||
default:
|
||||
printf("unsupported record type (%d) found in line %d\r\n", vector[0], lineno);
|
||||
printf("offending line: \r\n");
|
||||
printf("%s\r\n", line);
|
||||
ret = FAIL;
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("illegal character ('%c') found on line %d: S-records corrupt?\r\n", line[0], lineno);
|
||||
ret = FAIL;
|
||||
break;
|
||||
}
|
||||
}
|
||||
fclose(file);
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("could not open file %s\r\n", filename);
|
||||
ret = FILE_OPEN;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -357,9 +357,9 @@ int main(int argc, char *argv[])
|
||||
*/
|
||||
static err_t simulate()
|
||||
{
|
||||
err_t ret = OK;
|
||||
err_t ret = OK;
|
||||
|
||||
return ret;
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
@@ -368,15 +368,15 @@ static err_t simulate()
|
||||
*/
|
||||
static err_t verify(uint8_t *dst, uint8_t *src, uint32_t length)
|
||||
{
|
||||
uint8_t *end = src + length;
|
||||
uint8_t *end = src + length;
|
||||
|
||||
do
|
||||
{
|
||||
if (*src++ != *dst++)
|
||||
return FAIL;
|
||||
} while (src < end);
|
||||
do
|
||||
{
|
||||
if (*src++ != *dst++)
|
||||
return FAIL;
|
||||
} while (src < end);
|
||||
|
||||
return OK;
|
||||
return OK;
|
||||
}
|
||||
|
||||
void srec_execute(char *flasher_filename)
|
||||
|
||||
+570
-570
File diff suppressed because it is too large
Load Diff
+84
-84
@@ -109,52 +109,52 @@ inline void writel(uint32_t value, uint32_t *address)
|
||||
|
||||
struct pci_device_id ohci_usb_pci_table[] =
|
||||
{
|
||||
{
|
||||
PCI_VENDOR_ID_AL,
|
||||
PCI_DEVICE_ID_AL_M5237,
|
||||
PCI_ANY_ID,
|
||||
PCI_ANY_ID,
|
||||
PCI_CLASS_SERIAL_USB_OHCI,
|
||||
0,
|
||||
0
|
||||
}, /* ULI1575 PCI OHCI module ids */
|
||||
{
|
||||
PCI_VENDOR_ID_NEC,
|
||||
PCI_DEVICE_ID_NEC_USB,
|
||||
PCI_ANY_ID,
|
||||
PCI_ANY_ID,
|
||||
PCI_CLASS_SERIAL_USB_OHCI,
|
||||
0,
|
||||
0
|
||||
}, /* NEC PCI OHCI module ids */
|
||||
{
|
||||
PCI_VENDOR_ID_NEC,
|
||||
PCI_DEVICE_ID_NEC_USB_A,
|
||||
PCI_ANY_ID,
|
||||
PCI_ANY_ID,
|
||||
PCI_CLASS_SERIAL_USB_OHCI,
|
||||
0,
|
||||
0
|
||||
}, /* NEC PCI OHCI module ids */
|
||||
{
|
||||
PCI_VENDOR_ID_PHILIPS,
|
||||
PCI_DEVICE_ID_PHILIPS_ISP1561,
|
||||
PCI_ANY_ID,
|
||||
PCI_ANY_ID,
|
||||
PCI_CLASS_SERIAL_USB_OHCI,
|
||||
0,
|
||||
0
|
||||
}, /* Philips 1561 PCI OHCI module ids */
|
||||
/* Please add supported PCI OHCI controller ids here */
|
||||
{
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0
|
||||
}
|
||||
{
|
||||
PCI_VENDOR_ID_AL,
|
||||
PCI_DEVICE_ID_AL_M5237,
|
||||
PCI_ANY_ID,
|
||||
PCI_ANY_ID,
|
||||
PCI_CLASS_SERIAL_USB_OHCI,
|
||||
0,
|
||||
0
|
||||
}, /* ULI1575 PCI OHCI module ids */
|
||||
{
|
||||
PCI_VENDOR_ID_NEC,
|
||||
PCI_DEVICE_ID_NEC_USB,
|
||||
PCI_ANY_ID,
|
||||
PCI_ANY_ID,
|
||||
PCI_CLASS_SERIAL_USB_OHCI,
|
||||
0,
|
||||
0
|
||||
}, /* NEC PCI OHCI module ids */
|
||||
{
|
||||
PCI_VENDOR_ID_NEC,
|
||||
PCI_DEVICE_ID_NEC_USB_A,
|
||||
PCI_ANY_ID,
|
||||
PCI_ANY_ID,
|
||||
PCI_CLASS_SERIAL_USB_OHCI,
|
||||
0,
|
||||
0
|
||||
}, /* NEC PCI OHCI module ids */
|
||||
{
|
||||
PCI_VENDOR_ID_PHILIPS,
|
||||
PCI_DEVICE_ID_PHILIPS_ISP1561,
|
||||
PCI_ANY_ID,
|
||||
PCI_ANY_ID,
|
||||
PCI_CLASS_SERIAL_USB_OHCI,
|
||||
0,
|
||||
0
|
||||
}, /* Philips 1561 PCI OHCI module ids */
|
||||
/* Please add supported PCI OHCI controller ids here */
|
||||
{
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0
|
||||
}
|
||||
};
|
||||
|
||||
/* global ohci_t */
|
||||
@@ -169,8 +169,8 @@ static inline uint32_t roothub_portstatus(ohci_t *ohci, int i) { return readl(&o
|
||||
/* forward declaration */
|
||||
static int hc_interrupt(ohci_t *ohci);
|
||||
static void td_submit_job(ohci_t *ohci, struct usb_device *dev, uint32_t pipe,
|
||||
void *buffer, int transfer_len, struct devrequest *setup,
|
||||
urb_priv_t *urb, int interval);
|
||||
void *buffer, int transfer_len, struct devrequest *setup,
|
||||
urb_priv_t *urb, int interval);
|
||||
|
||||
|
||||
static struct td *ptd;
|
||||
@@ -231,20 +231,20 @@ static int sohci_get_current_frame_number(ohci_t *ohci, struct usb_device *dev);
|
||||
* small: 0) header + data packets 1) just header */
|
||||
|
||||
static void pkt_print(ohci_t *ohci, urb_priv_t *purb, struct usb_device *dev,
|
||||
uint32_t pipe, void *buffer, int transfer_len,
|
||||
struct devrequest *setup, char *str, int small)
|
||||
uint32_t pipe, void *buffer, int transfer_len,
|
||||
struct devrequest *setup, char *str, int small)
|
||||
{
|
||||
dbg("%s URB:[%4x] dev:%2lu,ep:%2lu-%c,type:%s,len:%d/%d stat:%#lx\r\n",
|
||||
str,
|
||||
sohci_get_current_frame_number(ohci, dev),
|
||||
usb_pipedevice(pipe),
|
||||
usb_pipeendpoint(pipe),
|
||||
usb_pipeout(pipe)? 'O': 'I',
|
||||
usb_pipetype(pipe) < 2 ? \
|
||||
(usb_pipeint(pipe)? "INTR": "ISOC"): \
|
||||
(usb_pipecontrol(pipe)? "CTRL": "BULK"),
|
||||
(purb ? purb->actual_length : 0),
|
||||
transfer_len, dev->status);
|
||||
str,
|
||||
sohci_get_current_frame_number(ohci, dev),
|
||||
usb_pipedevice(pipe),
|
||||
usb_pipeendpoint(pipe),
|
||||
usb_pipeout(pipe)? 'O': 'I',
|
||||
usb_pipetype(pipe) < 2 ? \
|
||||
(usb_pipeint(pipe)? "INTR": "ISOC"): \
|
||||
(usb_pipecontrol(pipe)? "CTRL": "BULK"),
|
||||
(purb ? purb->actual_length : 0),
|
||||
transfer_len, dev->status);
|
||||
#ifdef OHCI_VERBOSE_DEBUG
|
||||
if (!small)
|
||||
{
|
||||
@@ -313,7 +313,7 @@ static void ohci_dump_intr_mask(char *label, uint32_t mask)
|
||||
(mask & OHCI_INTR_SF) ? " SF" : "",
|
||||
(mask & OHCI_INTR_WDH) ? " WDH" : "",
|
||||
(mask & OHCI_INTR_SO) ? " SO" : ""
|
||||
);
|
||||
);
|
||||
}
|
||||
|
||||
static void maybe_print_eds(ohci_t *controller, char *label, uint32_t value)
|
||||
@@ -375,7 +375,7 @@ static void ohci_dump_status(ohci_t *controller)
|
||||
(temp & OHCI_BLF) ? " BLF" : "",
|
||||
(temp & OHCI_CLF) ? " CLF" : "",
|
||||
(temp & OHCI_HCR) ? " HCR" : ""
|
||||
);
|
||||
);
|
||||
ohci_dump_intr_mask("intrstatus", readl(®s->intrstatus));
|
||||
ohci_dump_intr_mask("intrenable", readl(®s->intrenable));
|
||||
maybe_print_eds(controller, "ed_periodcurrent", readl(®s->ed_periodcurrent));
|
||||
@@ -395,7 +395,7 @@ static void ohci_dump_roothub(ohci_t *controller, int verbose)
|
||||
temp = roothub_a(controller);
|
||||
(void) temp;
|
||||
|
||||
// ndp = (temp & RH_A_NDP);
|
||||
// ndp = (temp & RH_A_NDP);
|
||||
ndp = controller->ndp;
|
||||
if (verbose)
|
||||
{
|
||||
@@ -423,7 +423,7 @@ static void ohci_dump_roothub(ohci_t *controller, int verbose)
|
||||
(temp & RH_HS_DRWE) ? " DRWE" : "",
|
||||
(temp & RH_HS_OCI) ? " OCI" : "",
|
||||
(temp & RH_HS_LPS) ? " LPS" : ""
|
||||
);
|
||||
);
|
||||
}
|
||||
|
||||
for (i = 0; i < ndp; i++)
|
||||
@@ -446,7 +446,7 @@ static void ohci_dump_roothub(ohci_t *controller, int verbose)
|
||||
|
||||
(temp & RH_PS_PES) ? " PES" : "",
|
||||
(temp & RH_PS_CCS) ? " CCS" : ""
|
||||
);
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -736,8 +736,8 @@ static int ep_link(ohci_t *ohci, ed_t *edi)
|
||||
{
|
||||
inter = 1;
|
||||
for (ed_p = &(ohci->hcca->int_table[ep_rev(5, i) + int_branch]);
|
||||
(*ed_p != 0) && (((ed_t *)ed_p)->int_interval >= interval);
|
||||
ed_p = &(((ed_t *)ed_p)->hwNextED))
|
||||
(*ed_p != 0) && (((ed_t *)ed_p)->int_interval >= interval);
|
||||
ed_p = &(((ed_t *)ed_p)->hwNextED))
|
||||
inter = ep_rev(6, ((ed_t *)ed_p)->int_interval);
|
||||
ed->hwNextED = *ed_p;
|
||||
*ed_p = swpl((uint32_t)ed - ohci->dma_offset);
|
||||
@@ -869,11 +869,11 @@ static ed_t *ep_add_ed(ohci_t *ohci, struct usb_device *usb_dev, uint32_t pipe,
|
||||
}
|
||||
|
||||
ed->hwINFO = swpl(usb_pipedevice(pipe)
|
||||
| usb_pipeendpoint(pipe) << 7
|
||||
| (usb_pipeisoc(pipe)? 0x8000: 0)
|
||||
| (usb_pipecontrol(pipe)? 0: (usb_pipeout(pipe)? 0x800: 0x1000))
|
||||
| usb_pipeslow(pipe) << 13
|
||||
| usb_maxpacket(usb_dev, pipe) << 16);
|
||||
| usb_pipeendpoint(pipe) << 7
|
||||
| (usb_pipeisoc(pipe)? 0x8000: 0)
|
||||
| (usb_pipecontrol(pipe)? 0: (usb_pipeout(pipe)? 0x800: 0x1000))
|
||||
| usb_pipeslow(pipe) << 13
|
||||
| usb_maxpacket(usb_dev, pipe) << 16);
|
||||
|
||||
if (ed->type == PIPE_INTERRUPT && ed->state == ED_UNLINK)
|
||||
{
|
||||
@@ -943,14 +943,14 @@ static void td_fill(ohci_t *ohci, unsigned int info, void *data, int len,
|
||||
{
|
||||
int i;
|
||||
dbg("td_fill: %08x %08x %08X %08X at 0x%08X\r\n",
|
||||
swpl(td->hwINFO), swpl(td->hwCBP), swpl(td->hwNextTD), swpl(td->hwBE), td);
|
||||
swpl(td->hwINFO), swpl(td->hwCBP), swpl(td->hwNextTD), swpl(td->hwBE), td);
|
||||
for (i = 0; i < len; i++)
|
||||
dbg("%02X ", *(unsigned char *)(data + i) & 0xff);
|
||||
dbg("\r\n");
|
||||
}
|
||||
else
|
||||
dbg("td_fill: %08x %08x %08X %08X at 0x%08X\r\n",
|
||||
swpl(td->hwINFO), swpl(td->hwCBP), swpl(td->hwNextTD), swpl(td->hwBE), td);
|
||||
swpl(td->hwINFO), swpl(td->hwCBP), swpl(td->hwNextTD), swpl(td->hwBE), td);
|
||||
#endif
|
||||
}
|
||||
|
||||
@@ -959,8 +959,8 @@ static void td_fill(ohci_t *ohci, unsigned int info, void *data, int len,
|
||||
/* prepare all TDs of a transfer */
|
||||
|
||||
static void td_submit_job(ohci_t *ohci, struct usb_device *dev, uint32_t pipe,
|
||||
void *buffer, int transfer_len, struct devrequest *setup,
|
||||
urb_priv_t *urb, int interval)
|
||||
void *buffer, int transfer_len, struct devrequest *setup,
|
||||
urb_priv_t *urb, int interval)
|
||||
{
|
||||
int data_len = transfer_len;
|
||||
void *data;
|
||||
@@ -1258,7 +1258,7 @@ static uint8_t root_hub_config_des[] =
|
||||
0x01, /* uint8_t bConfigurationValue; */
|
||||
0x00, /* uint8_t iConfiguration; */
|
||||
0x40, /* uint8_t bmAttributes;
|
||||
Bit 7: Bus-powered, 6: Self-powered, 5 Remote-wakwup, 4..0: resvd */
|
||||
Bit 7: Bus-powered, 6: Self-powered, 5 Remote-wakwup, 4..0: resvd */
|
||||
0x00, /* uint8_t MaxPower; */
|
||||
|
||||
/* interface */
|
||||
@@ -1344,7 +1344,7 @@ int rh_check_port_status(ohci_t *controller)
|
||||
uint32_t temp, ndp, i;
|
||||
int res = -1;
|
||||
temp = roothub_a(controller);
|
||||
// ndp = (temp & RH_A_NDP);
|
||||
// ndp = (temp & RH_A_NDP);
|
||||
ndp = controller->ndp;
|
||||
for (i = 0; i < ndp; i++)
|
||||
{
|
||||
@@ -1368,7 +1368,7 @@ int rh_check_port_status(ohci_t *controller)
|
||||
}
|
||||
|
||||
static int ohci_submit_rh_msg(ohci_t *ohci, struct usb_device *dev, uint32_t pipe,
|
||||
void *buffer, int transfer_len, struct devrequest *cmd)
|
||||
void *buffer, int transfer_len, struct devrequest *cmd)
|
||||
{
|
||||
void *data = buffer;
|
||||
int leni = transfer_len;
|
||||
@@ -1524,7 +1524,7 @@ static int ohci_submit_rh_msg(ohci_t *ohci, struct usb_device *dev, uint32_t pip
|
||||
uint32_t temp = roothub_a(ohci);
|
||||
data_buf[0] = 9; /* min length; */
|
||||
data_buf[1] = 0x29;
|
||||
// data_buf[2] = temp & RH_A_NDP;
|
||||
// data_buf[2] = temp & RH_A_NDP;
|
||||
data_buf[2] = (uint8_t)ohci->ndp;
|
||||
data_buf[3] = 0;
|
||||
|
||||
@@ -1607,7 +1607,7 @@ static int ohci_submit_rh_msg(ohci_t *ohci, struct usb_device *dev, uint32_t pip
|
||||
*/
|
||||
|
||||
static int submit_common_msg(ohci_t *ohci, struct usb_device *dev, uint32_t pipe, void *buffer,
|
||||
int transfer_len, struct devrequest *setup, int interval)
|
||||
int transfer_len, struct devrequest *setup, int interval)
|
||||
{
|
||||
int stat = 0;
|
||||
int maxsize = usb_maxpacket(dev, pipe);
|
||||
@@ -1688,7 +1688,7 @@ static int submit_common_msg(ohci_t *ohci, struct usb_device *dev, uint32_t pipe
|
||||
}
|
||||
else
|
||||
#endif
|
||||
stat = hc_interrupt(ohci);
|
||||
stat = hc_interrupt(ohci);
|
||||
if (stat < 0)
|
||||
{
|
||||
dbg("USB CRC error\r\n");
|
||||
@@ -1820,7 +1820,7 @@ static int hc_reset(ohci_t *ohci)
|
||||
uint32_t id = 0;
|
||||
id = pci_read_config_longword(handle, PCIIDR);
|
||||
if ((PCI_VENDOR_ID_PHILIPS == (id & 0xFFFF)) && (PCI_DEVICE_ID_PHILIPS_ISP1561_2 == (id >> 16)))
|
||||
{
|
||||
{
|
||||
int timeout = 1000;
|
||||
uint32_t usb_base_addr = 0xFFFFFFFF;
|
||||
struct pci_rd *pci_rsc_desc;
|
||||
@@ -1859,7 +1859,7 @@ static int hc_reset(ohci_t *ohci)
|
||||
}
|
||||
|
||||
if ((ohci->controller == 0) && (ohci->ent->vendor == PCI_VENDOR_ID_NEC)
|
||||
&& (ohci->ent->device == PCI_DEVICE_ID_NEC_USB))
|
||||
&& (ohci->ent->device == PCI_DEVICE_ID_NEC_USB))
|
||||
{
|
||||
//if (ohci->handle == 1) /* NEC on motherboard has FPGA clock */
|
||||
#if defined(MACHINE_FIREBEE)
|
||||
|
||||
@@ -84,7 +84,7 @@ extern void run_bios(struct radeonfb_info *rinfo);
|
||||
0, \
|
||||
0, \
|
||||
(flags) | (CHIP_FAMILY_##family) \
|
||||
}
|
||||
}
|
||||
|
||||
struct pci_device_id radeonfb_pci_table[] =
|
||||
{
|
||||
@@ -424,18 +424,18 @@ static int radeon_map_ROM(struct radeonfb_info *rinfo)
|
||||
rom_type = BIOS_IN8(dptr + 0x14);
|
||||
switch(rom_type)
|
||||
{
|
||||
case 0:
|
||||
dbg("Found Intel x86 BIOS ROM Image\r\n");
|
||||
break;
|
||||
case 1:
|
||||
dbg("Found Open Firmware ROM Image\r\n");
|
||||
goto failed;
|
||||
case 2:
|
||||
dbg("Found HP PA-RISC ROM Image\r\n");
|
||||
goto failed;
|
||||
default:
|
||||
dbg("Found unknown type %d ROM Image\r\n", rom_type);
|
||||
goto failed;
|
||||
case 0:
|
||||
dbg("Found Intel x86 BIOS ROM Image\r\n");
|
||||
break;
|
||||
case 1:
|
||||
dbg("Found Open Firmware ROM Image\r\n");
|
||||
goto failed;
|
||||
case 2:
|
||||
dbg("Found HP PA-RISC ROM Image\r\n");
|
||||
goto failed;
|
||||
default:
|
||||
dbg("Found unknown type %d ROM Image\r\n", rom_type);
|
||||
goto failed;
|
||||
}
|
||||
anyway:
|
||||
/* Locate the flat panel infos, do some sanity checking !!! */
|
||||
@@ -743,9 +743,9 @@ found:
|
||||
rinfo->pll.sclk = 20000;
|
||||
|
||||
dbg("Reference=%d MHz (RefDiv=0x%x) Memory=%d MHz\r\n",
|
||||
rinfo->pll.ref_clk / 100, rinfo->pll.ref_div, rinfo->pll.mclk / 100);
|
||||
rinfo->pll.ref_clk / 100, rinfo->pll.ref_div, rinfo->pll.mclk / 100);
|
||||
dbg("System=%d MHz PLL min %d, max %d\r\n",
|
||||
rinfo->pll.sclk / 100, rinfo->pll.ppll_min, rinfo->pll.ppll_max);
|
||||
rinfo->pll.sclk / 100, rinfo->pll.ppll_min, rinfo->pll.ppll_max);
|
||||
}
|
||||
|
||||
static int var_to_depth(const struct fb_var_screeninfo *var)
|
||||
@@ -852,9 +852,9 @@ int radeonfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
|
||||
v.transp.length = 8;
|
||||
break;
|
||||
|
||||
default:
|
||||
default:
|
||||
dbg("radeonfb: mode %d x %d x %d rejected, color depth invalid\r\n ",
|
||||
var->xres, var->yres, var->bits_per_pixel);
|
||||
var->xres, var->yres, var->bits_per_pixel);
|
||||
return -1; //-EINVAL;
|
||||
}
|
||||
|
||||
@@ -904,12 +904,12 @@ int radeonfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
|
||||
int radeonfb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
|
||||
{
|
||||
struct radeonfb_info *rinfo = info->par;
|
||||
// DPRINT("radeonfb: radeonfb_pan_display\r\n");
|
||||
// DPRINT("radeonfb: radeonfb_pan_display\r\n");
|
||||
if ((var->xoffset + var->xres) > var->xres_virtual)
|
||||
return -1; //-EINVAL;
|
||||
|
||||
if (((var->yoffset * var->xres_virtual) + var->xoffset) >=
|
||||
(rinfo->mapped_vram - (var->yres * var->xres * (var->bits_per_pixel / 8))))
|
||||
(rinfo->mapped_vram - (var->yres * var->xres * (var->bits_per_pixel / 8))))
|
||||
return -1; //-EINVAL;
|
||||
|
||||
if (rinfo->asleep)
|
||||
@@ -1045,7 +1045,7 @@ int32_t radeon_screen_blank(struct radeonfb_info *rinfo, int32_t blank, int32_t
|
||||
if (unblank)
|
||||
{
|
||||
uint32_t target_val = (val & ~LVDS_DISPLAY_DIS) | LVDS_BLON | LVDS_ON
|
||||
| LVDS_EN | (rinfo->init_state.lvds_gen_cntl & (LVDS_DIGON | LVDS_BL_MOD_EN));
|
||||
| LVDS_EN | (rinfo->init_state.lvds_gen_cntl & (LVDS_DIGON | LVDS_BL_MOD_EN));
|
||||
if ((val ^ target_val) == LVDS_DISPLAY_DIS)
|
||||
OUTREG(LVDS_GEN_CNTL, target_val);
|
||||
else if ((val ^ target_val) != 0)
|
||||
@@ -1154,7 +1154,7 @@ static int radeon_setcolreg(unsigned regno, unsigned red, unsigned green,
|
||||
{
|
||||
OUTREG(PALETTE_INDEX, pindex>>1);
|
||||
OUTREG(PALETTE_DATA,(rinfo->palette[regno>>1].red << 16)
|
||||
| (green << 8) | (rinfo->palette[regno>>1].blue));
|
||||
| (green << 8) | (rinfo->palette[regno>>1].blue));
|
||||
green = rinfo->palette[regno<<1].green;
|
||||
}
|
||||
}
|
||||
@@ -1168,7 +1168,7 @@ static int radeon_setcolreg(unsigned regno, unsigned red, unsigned green,
|
||||
}
|
||||
|
||||
int radeonfb_setcolreg(unsigned regno, unsigned red, unsigned green,
|
||||
unsigned blue, unsigned transp, struct fb_info *info)
|
||||
unsigned blue, unsigned transp, struct fb_info *info)
|
||||
{
|
||||
struct radeonfb_info *rinfo = info->par;
|
||||
uint32_t dac_cntl2, vclk_cntl = 0;
|
||||
@@ -1243,7 +1243,7 @@ static void radeon_write_pll_regs(struct radeonfb_info *rinfo, struct radeon_reg
|
||||
/* Workaround from XFree */
|
||||
if (rinfo->is_mobility)
|
||||
{
|
||||
/* A temporal workaround for the occational blanking on certain laptop
|
||||
/* A temporal workaround for the occational blanking on certain laptop
|
||||
* panels. This appears to related to the PLL divider registers
|
||||
* (fail to lock?). It occurs even when all dividers are the same
|
||||
* with their old settings. In this case we really don't need to
|
||||
@@ -1251,14 +1251,14 @@ static void radeon_write_pll_regs(struct radeonfb_info *rinfo, struct radeon_reg
|
||||
* problem with some panels.
|
||||
*/
|
||||
if ((mode->ppll_ref_div == (INPLL(PPLL_REF_DIV) & PPLL_REF_DIV_MASK))
|
||||
&& (mode->ppll_div_3 == (INPLL(PPLL_DIV_3) & (PPLL_POST3_DIV_MASK | PPLL_FB3_DIV_MASK))))
|
||||
&& (mode->ppll_div_3 == (INPLL(PPLL_DIV_3) & (PPLL_POST3_DIV_MASK | PPLL_FB3_DIV_MASK))))
|
||||
{
|
||||
/* We still have to force a switch to selected PPLL div thanks to
|
||||
* an XFree86 driver bug which will switch it away in some cases
|
||||
* even when using UseFDev */
|
||||
OUTREGP(CLOCK_CNTL_INDEX,
|
||||
mode->clk_cntl_index & PPLL_DIV_SEL_MASK,
|
||||
~PPLL_DIV_SEL_MASK);
|
||||
mode->clk_cntl_index & PPLL_DIV_SEL_MASK,
|
||||
~PPLL_DIV_SEL_MASK);
|
||||
radeon_pll_errata_after_index(rinfo);
|
||||
radeon_pll_errata_after_data(rinfo);
|
||||
return;
|
||||
@@ -1271,7 +1271,7 @@ static void radeon_write_pll_regs(struct radeonfb_info *rinfo, struct radeon_reg
|
||||
|
||||
/* Reset PPLL & enable atomic update */
|
||||
OUTPLLP(PPLL_CNTL, PPLL_RESET | PPLL_ATOMIC_UPDATE_EN | PPLL_VGA_ATOMIC_UPDATE_EN,
|
||||
~(PPLL_RESET | PPLL_ATOMIC_UPDATE_EN | PPLL_VGA_ATOMIC_UPDATE_EN));
|
||||
~(PPLL_RESET | PPLL_ATOMIC_UPDATE_EN | PPLL_VGA_ATOMIC_UPDATE_EN));
|
||||
|
||||
/* Switch to selected PPLL divider */
|
||||
OUTREGP(CLOCK_CNTL_INDEX, mode->clk_cntl_index & PPLL_DIV_SEL_MASK, ~PPLL_DIV_SEL_MASK);
|
||||
@@ -1280,7 +1280,7 @@ static void radeon_write_pll_regs(struct radeonfb_info *rinfo, struct radeon_reg
|
||||
|
||||
/* Set PPLL ref. div */
|
||||
if (rinfo->family == CHIP_FAMILY_R300 || rinfo->family == CHIP_FAMILY_RS300
|
||||
|| rinfo->family == CHIP_FAMILY_R350 || rinfo->family == CHIP_FAMILY_RV350)
|
||||
|| rinfo->family == CHIP_FAMILY_R350 || rinfo->family == CHIP_FAMILY_RV350)
|
||||
{
|
||||
if (mode->ppll_ref_div & R300_PPLL_REF_DIV_ACC_MASK)
|
||||
{
|
||||
@@ -1373,7 +1373,7 @@ static void radeon_timer_func(void)
|
||||
int w = (int)info->var.xres_virtual;
|
||||
int h = (int)info->var.yres_virtual;
|
||||
|
||||
// info->fbops->SetClippingRectangle(info,0,0,w-1,h-1);
|
||||
// info->fbops->SetClippingRectangle(info,0,0,w-1,h-1);
|
||||
src_buf = (uint8_t*)((int32_t)src_buf & ~3);
|
||||
dst_x -= (int32_t)skipleft;
|
||||
w += (int32_t)skipleft;
|
||||
@@ -1386,13 +1386,13 @@ static void radeon_timer_func(void)
|
||||
src_buf += (info->var.xres_virtual >> 3);
|
||||
}
|
||||
|
||||
// info->fbops->DisableClipping(info);
|
||||
// info->fbops->DisableClipping(info);
|
||||
if (info->update_mono > 0)
|
||||
info->update_mono = 0;
|
||||
}
|
||||
|
||||
if ((info->var.xres_virtual != info->var.xres)
|
||||
|| (info->var.yres_virtual != info->var.yres))
|
||||
|| (info->var.yres_virtual != info->var.yres))
|
||||
{
|
||||
int ipl;
|
||||
ipl = set_ipl(0);
|
||||
@@ -1526,16 +1526,16 @@ static void radeon_calc_pll_regs(struct radeonfb_info *rinfo, struct radeon_regs
|
||||
} *post_div,
|
||||
post_divs[] =
|
||||
{
|
||||
{ 1, 0 },
|
||||
{ 2, 1 },
|
||||
{ 4, 2 },
|
||||
{ 8, 3 },
|
||||
{ 3, 4 },
|
||||
{ 16, 5 },
|
||||
{ 6, 6 },
|
||||
{ 12, 7 },
|
||||
{ 0, 0 },
|
||||
};
|
||||
{ 1, 0 },
|
||||
{ 2, 1 },
|
||||
{ 4, 2 },
|
||||
{ 8, 3 },
|
||||
{ 3, 4 },
|
||||
{ 16, 5 },
|
||||
{ 6, 6 },
|
||||
{ 12, 7 },
|
||||
{ 0, 0 },
|
||||
};
|
||||
int fb_div, pll_output_freq = 0;
|
||||
int uses_dvo = 0;
|
||||
|
||||
@@ -1567,7 +1567,7 @@ static void radeon_calc_pll_regs(struct radeonfb_info *rinfo, struct radeon_regs
|
||||
* extract the source selection
|
||||
*/
|
||||
if (rinfo->family == CHIP_FAMILY_R200 || rinfo->family == CHIP_FAMILY_R300
|
||||
|| rinfo->family == CHIP_FAMILY_R350 || rinfo->family == CHIP_FAMILY_RV350)
|
||||
|| rinfo->family == CHIP_FAMILY_R350 || rinfo->family == CHIP_FAMILY_RV350)
|
||||
{
|
||||
source = (fp2_gen_cntl >> 10) & 0x3;
|
||||
/* sourced from transform unit, check for transform unit
|
||||
@@ -1609,7 +1609,7 @@ static void radeon_calc_pll_regs(struct radeonfb_info *rinfo, struct radeon_regs
|
||||
continue;
|
||||
|
||||
if (pll_output_freq >= rinfo->pll.ppll_min &&
|
||||
pll_output_freq <= rinfo->pll.ppll_max)
|
||||
pll_output_freq <= rinfo->pll.ppll_max)
|
||||
break;
|
||||
}
|
||||
|
||||
@@ -1841,7 +1841,7 @@ int radeonfb_set_par(struct fb_info *info)
|
||||
{
|
||||
hRatio = round_div(mode->xres * HORZ_STRETCH_RATIO_MAX, rinfo->panel_info.xres);
|
||||
newmode->fp_horz_stretch = (((hRatio & HORZ_STRETCH_RATIO_MASK))
|
||||
| (newmode->fp_horz_stretch & (HORZ_PANEL_SIZE | HORZ_FP_LOOP_STRETCH | HORZ_AUTO_RATIO_INC)));
|
||||
| (newmode->fp_horz_stretch & (HORZ_PANEL_SIZE | HORZ_FP_LOOP_STRETCH | HORZ_AUTO_RATIO_INC)));
|
||||
newmode->fp_horz_stretch |= (HORZ_STRETCH_BLEND | HORZ_STRETCH_ENABLE);
|
||||
use_rmx = 1;
|
||||
}
|
||||
@@ -1851,14 +1851,14 @@ int radeonfb_set_par(struct fb_info *info)
|
||||
{
|
||||
vRatio = round_div(mode->yres * VERT_STRETCH_RATIO_MAX, rinfo->panel_info.yres);
|
||||
newmode->fp_vert_stretch = (((((uint32_t)vRatio) & VERT_STRETCH_RATIO_MASK))
|
||||
| (newmode->fp_vert_stretch & (VERT_PANEL_SIZE | VERT_STRETCH_RESERVED)));
|
||||
| (newmode->fp_vert_stretch & (VERT_PANEL_SIZE | VERT_STRETCH_RESERVED)));
|
||||
newmode->fp_vert_stretch |= (VERT_STRETCH_BLEND | VERT_STRETCH_ENABLE);
|
||||
use_rmx = 1;
|
||||
}
|
||||
newmode->fp_vert_stretch &= ~VERT_AUTO_RATIO_EN;
|
||||
newmode->fp_gen_cntl = (rinfo->init_state.fp_gen_cntl
|
||||
& ~(FP_SEL_CRTC2 | FP_RMX_HVSYNC_CONTROL_EN | FP_DFP_SYNC_SEL | FP_CRT_SYNC_SEL
|
||||
| FP_CRTC_LOCK_8DOT | FP_USE_SHADOW_EN | FP_CRTC_USE_SHADOW_VEND | FP_CRT_SYNC_ALT));
|
||||
& ~(FP_SEL_CRTC2 | FP_RMX_HVSYNC_CONTROL_EN | FP_DFP_SYNC_SEL | FP_CRT_SYNC_SEL
|
||||
| FP_CRTC_LOCK_8DOT | FP_USE_SHADOW_EN | FP_CRTC_USE_SHADOW_VEND | FP_CRT_SYNC_ALT));
|
||||
newmode->fp_gen_cntl |= (FP_CRTC_DONT_SHADOW_VPAR | FP_CRTC_DONT_SHADOW_HEND | FP_PANEL_FORMAT);
|
||||
|
||||
if (IS_R300_VARIANT(rinfo) || (rinfo->family == CHIP_FAMILY_R200))
|
||||
@@ -2020,8 +2020,8 @@ static void radeon_identify_vram(struct radeonfb_info *rinfo)
|
||||
uint32_t tmp;
|
||||
/* framebuffer size */
|
||||
if ((rinfo->family == CHIP_FAMILY_RS100)
|
||||
|| (rinfo->family == CHIP_FAMILY_RS200)
|
||||
|| (rinfo->family == CHIP_FAMILY_RS300))
|
||||
|| (rinfo->family == CHIP_FAMILY_RS200)
|
||||
|| (rinfo->family == CHIP_FAMILY_RS300))
|
||||
{
|
||||
uint32_t tom = INREG(NB_TOM);
|
||||
tmp = ((((tom >> 16) - (tom & 0xffff) + 1) << 6) * 1024);
|
||||
@@ -2051,7 +2051,7 @@ static void radeon_identify_vram(struct radeonfb_info *rinfo)
|
||||
{
|
||||
switch(rinfo->chipset)
|
||||
{
|
||||
case PCI_CHIP_RADEON_LY:
|
||||
case PCI_CHIP_RADEON_LY:
|
||||
case PCI_CHIP_RADEON_LZ: rinfo->video_ram = 8192 * 1024; break;
|
||||
default: break;
|
||||
}
|
||||
@@ -2060,7 +2060,7 @@ static void radeon_identify_vram(struct radeonfb_info *rinfo)
|
||||
* Now try to identify VRAM type
|
||||
*/
|
||||
if (rinfo->is_IGP || (rinfo->family >= CHIP_FAMILY_R300)
|
||||
|| (INREG(MEM_SDRAM_MODE_REG) & (1<<30)))
|
||||
|| (INREG(MEM_SDRAM_MODE_REG) & (1<<30)))
|
||||
rinfo->vram_ddr = 1;
|
||||
else
|
||||
rinfo->vram_ddr = 0;
|
||||
@@ -2077,8 +2077,8 @@ static void radeon_identify_vram(struct radeonfb_info *rinfo)
|
||||
}
|
||||
}
|
||||
else if ((rinfo->family == CHIP_FAMILY_RV100)
|
||||
|| (rinfo->family == CHIP_FAMILY_RS100)
|
||||
|| (rinfo->family == CHIP_FAMILY_RS200))
|
||||
|| (rinfo->family == CHIP_FAMILY_RS100)
|
||||
|| (rinfo->family == CHIP_FAMILY_RS200))
|
||||
{
|
||||
if (tmp & RV100_MEM_HALF_MODE)
|
||||
rinfo->vram_width = 32;
|
||||
@@ -2117,7 +2117,7 @@ static void radeon_identify_vram(struct radeonfb_info *rinfo)
|
||||
default: dbg("chip type: %s\r\n", "UNKNOW"); break;
|
||||
}
|
||||
dbg("found %d KB of %d bits wide %s video RAM\r\n", rinfo->video_ram / 1024,
|
||||
rinfo->vram_width, rinfo->vram_ddr ? "DDR " : "SDRAM ");
|
||||
rinfo->vram_width, rinfo->vram_ddr ? "DDR " : "SDRAM ");
|
||||
}
|
||||
|
||||
int32_t radeonfb_pci_register(int32_t handle, const struct pci_device_id *ent)
|
||||
@@ -2174,7 +2174,7 @@ int32_t radeonfb_pci_register(int32_t handle, const struct pci_device_id *ent)
|
||||
rinfo->fb_base = (void *)(pci_rsc_desc->offset + pci_rsc_desc->start);
|
||||
rinfo->fb_base_phys = pci_rsc_desc->start;
|
||||
rinfo->mapped_vram = pci_rsc_desc->length;
|
||||
// rinfo->dma_offset = pci_rsc_desc->dmaoffset;
|
||||
// rinfo->dma_offset = pci_rsc_desc->dmaoffset;
|
||||
if ((pci_rsc_desc->flags & FLG_ENDMASK) == ORD_MOTOROLA)
|
||||
{
|
||||
rinfo->big_endian = 0; /* host bridge make swapping intel -> motorola */
|
||||
@@ -2269,13 +2269,13 @@ int32_t radeonfb_pci_register(int32_t handle, const struct pci_device_id *ent)
|
||||
dbg("check for errata\r\n");
|
||||
rinfo->errata = 0;
|
||||
if (rinfo->family == CHIP_FAMILY_R300
|
||||
&& (INREG(CONFIG_CNTL) & CFG_ATI_REV_ID_MASK) == CFG_ATI_REV_A11)
|
||||
&& (INREG(CONFIG_CNTL) & CFG_ATI_REV_ID_MASK) == CFG_ATI_REV_A11)
|
||||
rinfo->errata |= CHIP_ERRATA_R300_CG;
|
||||
if (rinfo->family == CHIP_FAMILY_RV200 || rinfo->family == CHIP_FAMILY_RS200)
|
||||
rinfo->errata |= CHIP_ERRATA_PLL_DUMMYREADS;
|
||||
if (rinfo->family == CHIP_FAMILY_RV100
|
||||
|| rinfo->family == CHIP_FAMILY_RS100
|
||||
|| rinfo->family == CHIP_FAMILY_RS200)
|
||||
|| rinfo->family == CHIP_FAMILY_RS100
|
||||
|| rinfo->family == CHIP_FAMILY_RS200)
|
||||
rinfo->errata |= CHIP_ERRATA_PLL_DELAY;
|
||||
|
||||
/*
|
||||
@@ -2362,8 +2362,8 @@ int32_t radeonfb_pci_register(int32_t handle, const struct pci_device_id *ent)
|
||||
memcpy(&rinfo->state, &rinfo->init_state, sizeof(struct radeon_regs));
|
||||
|
||||
/* Setup Power Management capabilities */
|
||||
// DPRINT("radeonfb: radeonfb_pci_register: setup power management\r\n");
|
||||
// radeonfb_pm_init(rinfo, (int)default_dynclk);
|
||||
// DPRINT("radeonfb: radeonfb_pci_register: setup power management\r\n");
|
||||
// radeonfb_pm_init(rinfo, (int)default_dynclk);
|
||||
|
||||
dbg("install VBL timer\r\n");
|
||||
rinfo->lvds_timer = 0;
|
||||
@@ -2383,7 +2383,7 @@ void radeonfb_pci_unregister(void)
|
||||
{
|
||||
struct fb_info *info = info_fb;
|
||||
struct radeonfb_info *rinfo = info->par;
|
||||
// radeonfb_pm_exit(rinfo);
|
||||
// radeonfb_pm_exit(rinfo);
|
||||
uninstall_vbl_timer(radeon_timer_func);
|
||||
if (rinfo->mon1_EDID!=NULL)
|
||||
driver_mem_free(rinfo->mon1_EDID);
|
||||
|
||||
+199
-199
@@ -70,41 +70,41 @@
|
||||
#define CURSOR_SWAPPING_START() \
|
||||
if (rinfo->big_endian) \
|
||||
OUTREG(SURFACE_CNTL, \
|
||||
((__surface_cntl = INREG(SURFACE_CNTL)) | \
|
||||
NONSURF_AP0_SWP_32BPP) & \
|
||||
~NONSURF_AP0_SWP_16BPP);
|
||||
((__surface_cntl = INREG(SURFACE_CNTL)) | \
|
||||
NONSURF_AP0_SWP_32BPP) & \
|
||||
~NONSURF_AP0_SWP_16BPP);
|
||||
#define CURSOR_SWAPPING_END() \
|
||||
if (rinfo->big_endian) \
|
||||
(OUTREG(SURFACE_CNTL, __surface_cntl));
|
||||
(OUTREG(SURFACE_CNTL, __surface_cntl));
|
||||
|
||||
/* Set cursor foreground and background colors */
|
||||
void radeon_set_cursor_colors(struct fb_info *info, int bg, int fg)
|
||||
{
|
||||
struct radeonfb_info *rinfo = info->par;
|
||||
struct radeonfb_info *rinfo = info->par;
|
||||
unsigned long *pixels = (unsigned long *)((unsigned long) rinfo->fb_base + rinfo->cursor_start);
|
||||
int pixel, i;
|
||||
CURSOR_SWAPPING_DECL_MMIO
|
||||
CURSOR_SWAPPING_DECL
|
||||
// DPRINTVALHEX("radeonfb: RADEONSetCursorColors: cursor_start ",rinfo->cursor_start);
|
||||
// DPRINT("\r\n");
|
||||
fg |= 0xff000000;
|
||||
bg |= 0xff000000;
|
||||
/* Don't recolour the image if we don't have to. */
|
||||
int pixel, i;
|
||||
CURSOR_SWAPPING_DECL_MMIO
|
||||
CURSOR_SWAPPING_DECL
|
||||
// DPRINTVALHEX("radeonfb: RADEONSetCursorColors: cursor_start ",rinfo->cursor_start);
|
||||
// DPRINT("\r\n");
|
||||
fg |= 0xff000000;
|
||||
bg |= 0xff000000;
|
||||
/* Don't recolour the image if we don't have to. */
|
||||
if (fg == rinfo->cursor_fg && bg == rinfo->cursor_bg)
|
||||
return;
|
||||
CURSOR_SWAPPING_START();
|
||||
return;
|
||||
CURSOR_SWAPPING_START();
|
||||
|
||||
/*
|
||||
* Note: We assume that the pixels are either fully opaque or fully
|
||||
* transparent, so we won't premultiply them, and we can just
|
||||
* check for non-zero pixel values; those are either fg or bg
|
||||
*/
|
||||
* transparent, so we won't premultiply them, and we can just
|
||||
* check for non-zero pixel values; those are either fg or bg
|
||||
*/
|
||||
for (i = 0; i < CURSOR_WIDTH * CURSOR_HEIGHT; i++, pixels++)
|
||||
if ((pixel = *pixels))
|
||||
*pixels = (pixel == rinfo->cursor_fg) ? fg : bg;
|
||||
CURSOR_SWAPPING_END();
|
||||
rinfo->cursor_fg = fg;
|
||||
rinfo->cursor_bg = bg;
|
||||
*pixels = (pixel == rinfo->cursor_fg) ? fg : bg;
|
||||
CURSOR_SWAPPING_END();
|
||||
rinfo->cursor_fg = fg;
|
||||
rinfo->cursor_bg = bg;
|
||||
}
|
||||
|
||||
/* Set cursor position to (x,y) with offset into cursor bitmap at
|
||||
@@ -112,29 +112,29 @@ void radeon_set_cursor_colors(struct fb_info *info, int bg, int fg)
|
||||
*/
|
||||
void radeon_set_cursor_position(struct fb_info *info, int x, int y)
|
||||
{
|
||||
struct radeonfb_info *rinfo = info->par;
|
||||
struct fb_var_screeninfo *mode = &info->var;
|
||||
int xorigin = 0;
|
||||
int yorigin = 0;
|
||||
struct radeonfb_info *rinfo = info->par;
|
||||
struct fb_var_screeninfo *mode = &info->var;
|
||||
int xorigin = 0;
|
||||
int yorigin = 0;
|
||||
if (mode->vmode & FB_VMODE_DOUBLE)
|
||||
y <<= 1;
|
||||
y <<= 1;
|
||||
if (x < 0)
|
||||
xorigin = 1 - x;
|
||||
xorigin = 1 - x;
|
||||
if (y < 0)
|
||||
yorigin = 1 - y;
|
||||
yorigin = 1 - y;
|
||||
|
||||
// DPRINTVALHEX("radeonfb: RADEONSetCursorPosition: cursor_start ",rinfo->cursor_start);
|
||||
// DPRINTVAL(" x ",x);
|
||||
// DPRINTVAL(" y ",y);
|
||||
// DPRINT("\r\n");
|
||||
// DPRINTVALHEX("radeonfb: RADEONSetCursorPosition: cursor_start ",rinfo->cursor_start);
|
||||
// DPRINTVAL(" x ",x);
|
||||
// DPRINTVAL(" y ",y);
|
||||
// DPRINT("\r\n");
|
||||
|
||||
OUTREG(CUR_HORZ_VERT_OFF, (CUR_LOCK | (xorigin << 16) | yorigin));
|
||||
OUTREG(CUR_HORZ_VERT_POSN, (CUR_LOCK | ((xorigin ? 0 : x) << 16) | (yorigin ? 0 : y)));
|
||||
OUTREG(CUR_OFFSET, rinfo->cursor_start + yorigin * 256);
|
||||
rinfo->cursor_x = (unsigned long)x;
|
||||
OUTREG(CUR_HORZ_VERT_OFF, (CUR_LOCK | (xorigin << 16) | yorigin));
|
||||
OUTREG(CUR_HORZ_VERT_POSN, (CUR_LOCK | ((xorigin ? 0 : x) << 16) | (yorigin ? 0 : y)));
|
||||
OUTREG(CUR_OFFSET, rinfo->cursor_start + yorigin * 256);
|
||||
rinfo->cursor_x = (unsigned long)x;
|
||||
if (mode->vmode & FB_VMODE_DOUBLE)
|
||||
rinfo->cursor_y = (unsigned long) y >> 1;
|
||||
else
|
||||
else
|
||||
rinfo->cursor_y = (unsigned long) y;
|
||||
}
|
||||
|
||||
@@ -144,192 +144,192 @@ void radeon_set_cursor_position(struct fb_info *info, int x, int y)
|
||||
*/
|
||||
void radeon_load_cursor_image(struct fb_info *info, unsigned short *mask, unsigned short *data, int zoom)
|
||||
{
|
||||
struct radeonfb_info *rinfo = info->par;
|
||||
unsigned long *d = (unsigned long *)((unsigned long)rinfo->fb_base+rinfo->cursor_start);
|
||||
unsigned long save = 0;
|
||||
unsigned short chunk, mchunk;
|
||||
unsigned long i, j, k;
|
||||
CURSOR_SWAPPING_DECL
|
||||
struct radeonfb_info *rinfo = info->par;
|
||||
unsigned long *d = (unsigned long *)((unsigned long)rinfo->fb_base+rinfo->cursor_start);
|
||||
unsigned long save = 0;
|
||||
unsigned short chunk, mchunk;
|
||||
unsigned long i, j, k;
|
||||
CURSOR_SWAPPING_DECL
|
||||
|
||||
// DPRINTVALHEX("radeonfb: RADEONLoadCursorImage: cursor_start ",rinfo->cursor_start);
|
||||
// DPRINT("\r\n");
|
||||
// DPRINTVALHEX("radeonfb: RADEONLoadCursorImage: cursor_start ",rinfo->cursor_start);
|
||||
// DPRINT("\r\n");
|
||||
|
||||
save = INREG(CRTC_GEN_CNTL) & ~(unsigned long) (3 << 20);
|
||||
save |= (unsigned long) (2 << 20);
|
||||
OUTREG(CRTC_GEN_CNTL, save & (unsigned long)~CRTC_CUR_EN);
|
||||
save = INREG(CRTC_GEN_CNTL) & ~(unsigned long) (3 << 20);
|
||||
save |= (unsigned long) (2 << 20);
|
||||
OUTREG(CRTC_GEN_CNTL, save & (unsigned long)~CRTC_CUR_EN);
|
||||
|
||||
/*
|
||||
* Convert the bitmap to ARGB32.
|
||||
*/
|
||||
CURSOR_SWAPPING_START();
|
||||
/*
|
||||
* Convert the bitmap to ARGB32.
|
||||
*/
|
||||
CURSOR_SWAPPING_START();
|
||||
#define ARGB_PER_CHUNK (8 * sizeof (chunk))
|
||||
switch(zoom)
|
||||
{
|
||||
case 1:
|
||||
default:
|
||||
for (i = 0; i < CURSOR_HEIGHT; i++)
|
||||
{
|
||||
if (i < 16)
|
||||
{
|
||||
mchunk = *mask++;
|
||||
chunk = *data++;
|
||||
}
|
||||
else
|
||||
mchunk = chunk = 0;
|
||||
for (j = 0; j < CURSOR_WIDTH / ARGB_PER_CHUNK; j++)
|
||||
{
|
||||
for (k = 0; k < ARGB_PER_CHUNK; k++, chunk <<= 1, mchunk <<= 1)
|
||||
{
|
||||
if (mchunk & 0x8000)
|
||||
{
|
||||
if (chunk & 0x8000)
|
||||
*d++ = 0xff000000; /* Black, fully opaque. */
|
||||
else
|
||||
*d++ = 0xffffffff; /* White, fully opaque. */
|
||||
}
|
||||
else
|
||||
*d++ = 0x00000000; /* White/Black, fully transparent. */
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
for (i = 0; i < CURSOR_HEIGHT; i++)
|
||||
{
|
||||
if (i < 16*2)
|
||||
{
|
||||
mchunk = *mask;
|
||||
chunk = *data;
|
||||
if ((i & 1) == 1)
|
||||
{
|
||||
mask++;
|
||||
data++;
|
||||
}
|
||||
}
|
||||
else
|
||||
mchunk = chunk = 0;
|
||||
for (j = 0; j < CURSOR_WIDTH / ARGB_PER_CHUNK; j+=2)
|
||||
{
|
||||
for (k = 0; k < ARGB_PER_CHUNK; k++, chunk <<= 1, mchunk <<= 1)
|
||||
{
|
||||
if (mchunk & 0x8000)
|
||||
{
|
||||
if (chunk & 0x8000)
|
||||
{
|
||||
*d++ = 0xff000000; /* Black, fully opaque. */
|
||||
*d++ = 0xff000000;
|
||||
}
|
||||
else
|
||||
{
|
||||
*d++ = 0xffffffff; /* White, fully opaque. */
|
||||
*d++ = 0xffffffff;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
*d++ = 0x00000000; /* White/Black, fully transparent. */
|
||||
*d++ = 0x00000000;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 4:
|
||||
for (i = 0; i < CURSOR_HEIGHT; i++)
|
||||
{
|
||||
if (i < 16 * 4)
|
||||
{
|
||||
mchunk = *mask;
|
||||
chunk = *data;
|
||||
if ((i & 3) == 3)
|
||||
{
|
||||
mask++;
|
||||
data++;
|
||||
}
|
||||
}
|
||||
else
|
||||
mchunk = chunk = 0;
|
||||
for (j = 0; j < CURSOR_WIDTH / ARGB_PER_CHUNK; j+=4)
|
||||
{
|
||||
for (k = 0; k < ARGB_PER_CHUNK; k++, chunk <<= 1, mchunk <<= 1)
|
||||
{
|
||||
if (mchunk & 0x8000)
|
||||
{
|
||||
if (chunk & 0x8000)
|
||||
{
|
||||
*d++ = 0xff000000; /* Black, fully opaque. */
|
||||
*d++ = 0xff000000;
|
||||
*d++ = 0xff000000;
|
||||
*d++ = 0xff000000;
|
||||
}
|
||||
else
|
||||
{
|
||||
*d++ = 0xffffffff; /* White, fully opaque. */
|
||||
*d++ = 0xffffffff;
|
||||
*d++ = 0xffffffff;
|
||||
*d++ = 0xffffffff;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
*d++ = 0x00000000; /* White/Black, fully transparent. */
|
||||
*d++ = 0x00000000;
|
||||
*d++ = 0x00000000;
|
||||
*d++ = 0x00000000;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
CURSOR_SWAPPING_END();
|
||||
rinfo->cursor_bg = 0xffffffff; /* White, fully opaque. */
|
||||
rinfo->cursor_fg = 0xff000000; /* Black, fully opaque. */
|
||||
OUTREG(CRTC_GEN_CNTL, save);
|
||||
switch(zoom)
|
||||
{
|
||||
case 1:
|
||||
default:
|
||||
for (i = 0; i < CURSOR_HEIGHT; i++)
|
||||
{
|
||||
if (i < 16)
|
||||
{
|
||||
mchunk = *mask++;
|
||||
chunk = *data++;
|
||||
}
|
||||
else
|
||||
mchunk = chunk = 0;
|
||||
for (j = 0; j < CURSOR_WIDTH / ARGB_PER_CHUNK; j++)
|
||||
{
|
||||
for (k = 0; k < ARGB_PER_CHUNK; k++, chunk <<= 1, mchunk <<= 1)
|
||||
{
|
||||
if (mchunk & 0x8000)
|
||||
{
|
||||
if (chunk & 0x8000)
|
||||
*d++ = 0xff000000; /* Black, fully opaque. */
|
||||
else
|
||||
*d++ = 0xffffffff; /* White, fully opaque. */
|
||||
}
|
||||
else
|
||||
*d++ = 0x00000000; /* White/Black, fully transparent. */
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
for (i = 0; i < CURSOR_HEIGHT; i++)
|
||||
{
|
||||
if (i < 16*2)
|
||||
{
|
||||
mchunk = *mask;
|
||||
chunk = *data;
|
||||
if ((i & 1) == 1)
|
||||
{
|
||||
mask++;
|
||||
data++;
|
||||
}
|
||||
}
|
||||
else
|
||||
mchunk = chunk = 0;
|
||||
for (j = 0; j < CURSOR_WIDTH / ARGB_PER_CHUNK; j+=2)
|
||||
{
|
||||
for (k = 0; k < ARGB_PER_CHUNK; k++, chunk <<= 1, mchunk <<= 1)
|
||||
{
|
||||
if (mchunk & 0x8000)
|
||||
{
|
||||
if (chunk & 0x8000)
|
||||
{
|
||||
*d++ = 0xff000000; /* Black, fully opaque. */
|
||||
*d++ = 0xff000000;
|
||||
}
|
||||
else
|
||||
{
|
||||
*d++ = 0xffffffff; /* White, fully opaque. */
|
||||
*d++ = 0xffffffff;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
*d++ = 0x00000000; /* White/Black, fully transparent. */
|
||||
*d++ = 0x00000000;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 4:
|
||||
for (i = 0; i < CURSOR_HEIGHT; i++)
|
||||
{
|
||||
if (i < 16 * 4)
|
||||
{
|
||||
mchunk = *mask;
|
||||
chunk = *data;
|
||||
if ((i & 3) == 3)
|
||||
{
|
||||
mask++;
|
||||
data++;
|
||||
}
|
||||
}
|
||||
else
|
||||
mchunk = chunk = 0;
|
||||
for (j = 0; j < CURSOR_WIDTH / ARGB_PER_CHUNK; j+=4)
|
||||
{
|
||||
for (k = 0; k < ARGB_PER_CHUNK; k++, chunk <<= 1, mchunk <<= 1)
|
||||
{
|
||||
if (mchunk & 0x8000)
|
||||
{
|
||||
if (chunk & 0x8000)
|
||||
{
|
||||
*d++ = 0xff000000; /* Black, fully opaque. */
|
||||
*d++ = 0xff000000;
|
||||
*d++ = 0xff000000;
|
||||
*d++ = 0xff000000;
|
||||
}
|
||||
else
|
||||
{
|
||||
*d++ = 0xffffffff; /* White, fully opaque. */
|
||||
*d++ = 0xffffffff;
|
||||
*d++ = 0xffffffff;
|
||||
*d++ = 0xffffffff;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
*d++ = 0x00000000; /* White/Black, fully transparent. */
|
||||
*d++ = 0x00000000;
|
||||
*d++ = 0x00000000;
|
||||
*d++ = 0x00000000;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
CURSOR_SWAPPING_END();
|
||||
rinfo->cursor_bg = 0xffffffff; /* White, fully opaque. */
|
||||
rinfo->cursor_fg = 0xff000000; /* Black, fully opaque. */
|
||||
OUTREG(CRTC_GEN_CNTL, save);
|
||||
}
|
||||
|
||||
/* Hide hardware cursor. */
|
||||
void radeon_hide_cursor(struct fb_info *info)
|
||||
{
|
||||
struct radeonfb_info *rinfo = info->par;
|
||||
struct radeonfb_info *rinfo = info->par;
|
||||
|
||||
// DPRINT("radeonfb: RADEONHideCursor\r\n");
|
||||
OUTREGP(CRTC_GEN_CNTL, 0, ~CRTC_CUR_EN);
|
||||
rinfo->cursor_show = 0;
|
||||
// DPRINT("radeonfb: RADEONHideCursor\r\n");
|
||||
OUTREGP(CRTC_GEN_CNTL, 0, ~CRTC_CUR_EN);
|
||||
rinfo->cursor_show = 0;
|
||||
}
|
||||
|
||||
/* Show hardware cursor. */
|
||||
void radeon_show_cursor(struct fb_info *info)
|
||||
{
|
||||
struct radeonfb_info *rinfo = info->par;
|
||||
struct radeonfb_info *rinfo = info->par;
|
||||
|
||||
// DPRINT("radeonfb: RADEONShowCursor\r\n");
|
||||
OUTREGP(CRTC_GEN_CNTL, CRTC_CUR_EN, ~CRTC_CUR_EN);
|
||||
rinfo->cursor_show = 1;
|
||||
// DPRINT("radeonfb: RADEONShowCursor\r\n");
|
||||
OUTREGP(CRTC_GEN_CNTL, CRTC_CUR_EN, ~CRTC_CUR_EN);
|
||||
rinfo->cursor_show = 1;
|
||||
}
|
||||
|
||||
/* Initialize hardware cursor support. */
|
||||
long radeon_cursor_init(struct fb_info *info)
|
||||
{
|
||||
struct radeonfb_info *rinfo = info->par;
|
||||
int size_bytes = CURSOR_WIDTH * 4 * CURSOR_HEIGHT;
|
||||
unsigned long fbarea = offscreen_alloc(rinfo->info, size_bytes + 256);
|
||||
struct radeonfb_info *rinfo = info->par;
|
||||
int size_bytes = CURSOR_WIDTH * 4 * CURSOR_HEIGHT;
|
||||
unsigned long fbarea = offscreen_alloc(rinfo->info, size_bytes + 256);
|
||||
|
||||
dbg("radeonfb: %s: fbarea: %p\r\n", fbarea);
|
||||
|
||||
if (!fbarea)
|
||||
rinfo->cursor_start = 0;
|
||||
else
|
||||
{
|
||||
unsigned short data[16], mask[16];
|
||||
rinfo->cursor_start = 0;
|
||||
else
|
||||
{
|
||||
unsigned short data[16], mask[16];
|
||||
|
||||
memset(data, 0, sizeof(data));
|
||||
memset(mask, 0, sizeof(data));
|
||||
rinfo->cursor_start = RADEON_ALIGN(fbarea - (unsigned long) rinfo->fb_base, 256);
|
||||
rinfo->cursor_end = rinfo->cursor_start + size_bytes;
|
||||
radeon_load_cursor_image(info, mask, data, 1);
|
||||
}
|
||||
dbg("radeonfb: %s cursor_start: %p\r\n", rinfo->cursor_start);
|
||||
memset(data, 0, sizeof(data));
|
||||
memset(mask, 0, sizeof(data));
|
||||
rinfo->cursor_start = RADEON_ALIGN(fbarea - (unsigned long) rinfo->fb_base, 256);
|
||||
rinfo->cursor_end = rinfo->cursor_start + size_bytes;
|
||||
radeon_load_cursor_image(info, mask, data, 1);
|
||||
}
|
||||
dbg("radeonfb: %s cursor_start: %p\r\n", rinfo->cursor_start);
|
||||
|
||||
return (rinfo->cursor_start ? fbarea : 0);
|
||||
return (rinfo->cursor_start ? fbarea : 0);
|
||||
}
|
||||
|
||||
+598
-598
File diff suppressed because it is too large
Load Diff
+103
-103
@@ -30,79 +30,79 @@
|
||||
|
||||
struct baudrate
|
||||
{
|
||||
int br_divisor;
|
||||
int pbr_divisor;
|
||||
int divider;
|
||||
int br_divisor;
|
||||
int pbr_divisor;
|
||||
int divider;
|
||||
};
|
||||
|
||||
static const int system_clock = 132000000; /* System clock in Hz */
|
||||
|
||||
struct baudrate baudrates[] =
|
||||
static struct baudrate baudrates[] =
|
||||
{
|
||||
{ 0b0000, 0b00, 4 },
|
||||
{ 0b0000, 0b01, 6 },
|
||||
{ 0b0001, 0b00, 8 },
|
||||
{ 0b0000, 0b10, 10 },
|
||||
{ 0b0001, 0b01, 12 },
|
||||
{ 0b0010, 0b00, 12 },
|
||||
{ 0b0000, 0b11, 14 },
|
||||
{ 0b0011, 0b00, 16 },
|
||||
{ 0b0010, 0b01, 18 },
|
||||
{ 0b0001, 0b10, 20 },
|
||||
{ 0b0011, 0b01, 24 },
|
||||
{ 0b0001, 0b11, 28 },
|
||||
{ 0b0010, 0b10, 30 },
|
||||
{ 0b0100, 0b00, 32 },
|
||||
{ 0b0011, 0b10, 40 },
|
||||
{ 0b0010, 0b11, 42 },
|
||||
{ 0b0100, 0b01, 48 },
|
||||
{ 0b0011, 0b11, 56 },
|
||||
{ 0b0101, 0b00, 64 },
|
||||
{ 0b0100, 0b10, 80 },
|
||||
{ 0b0101, 0b01, 96 },
|
||||
{ 0b0100, 0b11, 112 },
|
||||
{ 0b0110, 0b00, 128 },
|
||||
{ 0b0101, 0b10, 160 },
|
||||
{ 0b0110, 0b01, 192 },
|
||||
{ 0b0101, 0b11, 224 },
|
||||
{ 0b0111, 0b00, 256 },
|
||||
{ 0b0110, 0b10, 320 },
|
||||
{ 0b0111, 0b01, 384 },
|
||||
{ 0b0110, 0b11, 448 },
|
||||
{ 0b1000, 0b00, 512 },
|
||||
{ 0b0111, 0b10, 640 },
|
||||
{ 0b1000, 0b01, 768 },
|
||||
{ 0b0111, 0b11, 896 },
|
||||
{ 0b1001, 0b00, 1024 },
|
||||
{ 0b1000, 0b10, 1280 },
|
||||
{ 0b1001, 0b01, 1536 },
|
||||
{ 0b1000, 0b11, 1792 },
|
||||
{ 0b1010, 0b00, 2048 },
|
||||
{ 0b1001, 0b10, 2560 },
|
||||
{ 0b1010, 0b01, 3072 },
|
||||
{ 0b1001, 0b11, 3584 },
|
||||
{ 0b1011, 0b00, 4096 },
|
||||
{ 0b1010, 0b10, 5120 },
|
||||
{ 0b1011, 0b01, 6144 },
|
||||
{ 0b1010, 0b11, 7168 },
|
||||
{ 0b1100, 0b00, 8192 },
|
||||
{ 0b1011, 0b10, 10240 },
|
||||
{ 0b1100, 0b01, 12288 },
|
||||
{ 0b1011, 0b11, 14336 },
|
||||
{ 0b1101, 0b00, 16384 },
|
||||
{ 0b1100, 0b10, 20480 },
|
||||
{ 0b1101, 0b01, 24576 },
|
||||
{ 0b1100, 0b11, 28672 },
|
||||
{ 0b1110, 0b00, 32768 },
|
||||
{ 0b1101, 0b10, 40960 },
|
||||
{ 0b1110, 0b01, 49152 },
|
||||
{ 0b1101, 0b11, 57344 },
|
||||
{ 0b1111, 0b00, 65536 },
|
||||
{ 0b1110, 0b10, 81920 },
|
||||
{ 0b1111, 0b01, 98304 },
|
||||
{ 0b1110, 0b11, 114688 },
|
||||
{ 0b1111, 0b10, 163840 },
|
||||
{ 0b1111, 0b11, 229376 },
|
||||
{ 0b0000, 0b00, 4 },
|
||||
{ 0b0000, 0b01, 6 },
|
||||
{ 0b0001, 0b00, 8 },
|
||||
{ 0b0000, 0b10, 10 },
|
||||
{ 0b0001, 0b01, 12 },
|
||||
{ 0b0010, 0b00, 12 },
|
||||
{ 0b0000, 0b11, 14 },
|
||||
{ 0b0011, 0b00, 16 },
|
||||
{ 0b0010, 0b01, 18 },
|
||||
{ 0b0001, 0b10, 20 },
|
||||
{ 0b0011, 0b01, 24 },
|
||||
{ 0b0001, 0b11, 28 },
|
||||
{ 0b0010, 0b10, 30 },
|
||||
{ 0b0100, 0b00, 32 },
|
||||
{ 0b0011, 0b10, 40 },
|
||||
{ 0b0010, 0b11, 42 },
|
||||
{ 0b0100, 0b01, 48 },
|
||||
{ 0b0011, 0b11, 56 },
|
||||
{ 0b0101, 0b00, 64 },
|
||||
{ 0b0100, 0b10, 80 },
|
||||
{ 0b0101, 0b01, 96 },
|
||||
{ 0b0100, 0b11, 112 },
|
||||
{ 0b0110, 0b00, 128 },
|
||||
{ 0b0101, 0b10, 160 },
|
||||
{ 0b0110, 0b01, 192 },
|
||||
{ 0b0101, 0b11, 224 },
|
||||
{ 0b0111, 0b00, 256 },
|
||||
{ 0b0110, 0b10, 320 },
|
||||
{ 0b0111, 0b01, 384 },
|
||||
{ 0b0110, 0b11, 448 },
|
||||
{ 0b1000, 0b00, 512 },
|
||||
{ 0b0111, 0b10, 640 },
|
||||
{ 0b1000, 0b01, 768 },
|
||||
{ 0b0111, 0b11, 896 },
|
||||
{ 0b1001, 0b00, 1024 },
|
||||
{ 0b1000, 0b10, 1280 },
|
||||
{ 0b1001, 0b01, 1536 },
|
||||
{ 0b1000, 0b11, 1792 },
|
||||
{ 0b1010, 0b00, 2048 },
|
||||
{ 0b1001, 0b10, 2560 },
|
||||
{ 0b1010, 0b01, 3072 },
|
||||
{ 0b1001, 0b11, 3584 },
|
||||
{ 0b1011, 0b00, 4096 },
|
||||
{ 0b1010, 0b10, 5120 },
|
||||
{ 0b1011, 0b01, 6144 },
|
||||
{ 0b1010, 0b11, 7168 },
|
||||
{ 0b1100, 0b00, 8192 },
|
||||
{ 0b1011, 0b10, 10240 },
|
||||
{ 0b1100, 0b01, 12288 },
|
||||
{ 0b1011, 0b11, 14336 },
|
||||
{ 0b1101, 0b00, 16384 },
|
||||
{ 0b1100, 0b10, 20480 },
|
||||
{ 0b1101, 0b01, 24576 },
|
||||
{ 0b1100, 0b11, 28672 },
|
||||
{ 0b1110, 0b00, 32768 },
|
||||
{ 0b1101, 0b10, 40960 },
|
||||
{ 0b1110, 0b01, 49152 },
|
||||
{ 0b1101, 0b11, 57344 },
|
||||
{ 0b1111, 0b00, 65536 },
|
||||
{ 0b1110, 0b10, 81920 },
|
||||
{ 0b1111, 0b01, 98304 },
|
||||
{ 0b1110, 0b11, 114688 },
|
||||
{ 0b1111, 0b10, 163840 },
|
||||
{ 0b1111, 0b11, 229376 },
|
||||
};
|
||||
|
||||
/*
|
||||
@@ -110,28 +110,28 @@ struct baudrate baudrates[] =
|
||||
*/
|
||||
int dspi_set_baudrate(int rate)
|
||||
{
|
||||
int set_baudrate = 0;
|
||||
int br;
|
||||
int pbr;
|
||||
int i;
|
||||
int set_baudrate = 0;
|
||||
int br;
|
||||
int pbr;
|
||||
int i;
|
||||
|
||||
for (i = sizeof(baudrates) / sizeof(struct baudrate) - 1; i >= 0; i--)
|
||||
{
|
||||
set_baudrate = system_clock / baudrates[i].divider;
|
||||
for (i = sizeof(baudrates) / sizeof(struct baudrate) - 1; i >= 0; i--)
|
||||
{
|
||||
set_baudrate = system_clock / baudrates[i].divider;
|
||||
|
||||
if (set_baudrate > rate)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
br = baudrates[i].br_divisor;
|
||||
pbr = baudrates[i].pbr_divisor;
|
||||
if (set_baudrate > rate)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
br = baudrates[i].br_divisor;
|
||||
pbr = baudrates[i].pbr_divisor;
|
||||
|
||||
/* TODO: set br and pbr here */
|
||||
/* TODO: set br and pbr here */
|
||||
|
||||
return set_baudrate;
|
||||
}
|
||||
return set_baudrate;
|
||||
}
|
||||
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static uint32_t dspi_fifo_val = MCF_DSPI_DTFR_CTCNT;
|
||||
@@ -141,20 +141,20 @@ static uint32_t dspi_fifo_val = MCF_DSPI_DTFR_CTCNT;
|
||||
*/
|
||||
uint8_t dspi_xchg_byte(int device, uint8_t byte, int last)
|
||||
{
|
||||
uint32_t fifo;
|
||||
uint8_t res;
|
||||
uint32_t fifo;
|
||||
uint8_t res;
|
||||
|
||||
fifo = dspi_fifo_val | (byte & 0xff); /* transfer bytes only */
|
||||
fifo |= (last ? MCF_DSPI_DTFR_EOQ : 0); /* mark last transfer */
|
||||
MCF_DSPI_DTFR = fifo;
|
||||
while (! (MCF_DSPI_DSR & MCF_DSPI_DSR_TCF)); /* wait until DSPI transfer complete */
|
||||
fifo = MCF_DSPI_DRFR; /* read transferred word */
|
||||
fifo = dspi_fifo_val | (byte & 0xff); /* transfer bytes only */
|
||||
fifo |= (last ? MCF_DSPI_DTFR_EOQ : 0); /* mark last transfer */
|
||||
MCF_DSPI_DTFR = fifo;
|
||||
while (! (MCF_DSPI_DSR & MCF_DSPI_DSR_TCF)); /* wait until DSPI transfer complete */
|
||||
fifo = MCF_DSPI_DRFR; /* read transferred word */
|
||||
|
||||
MCF_DSPI_DSR = -1; /* clear DSPI status register */
|
||||
MCF_DSPI_DSR = -1; /* clear DSPI status register */
|
||||
|
||||
res = fifo & 0xff;
|
||||
res = fifo & 0xff;
|
||||
|
||||
return res;
|
||||
return res;
|
||||
}
|
||||
|
||||
/* Receive multiple byte with 0xff as output
|
||||
@@ -164,11 +164,11 @@ uint8_t dspi_xchg_byte(int device, uint8_t byte, int last)
|
||||
*/
|
||||
static void dspi_rcv_byte_multi(int device, uint8_t *buff, uint32_t count)
|
||||
{
|
||||
int i;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < count - 1; i++)
|
||||
*buff++ = dspi_xchg_byte(device, 0xff, 0);
|
||||
*buff++ = dspi_xchg_byte(device, 0xff, 1); /* transfer last byte and stop transmission */
|
||||
for (i = 0; i < count - 1; i++)
|
||||
*buff++ = dspi_xchg_byte(device, 0xff, 0);
|
||||
*buff++ = dspi_xchg_byte(device, 0xff, 1); /* transfer last byte and stop transmission */
|
||||
}
|
||||
|
||||
/* Send multiple byte, discard input
|
||||
@@ -178,10 +178,10 @@ static void dspi_rcv_byte_multi(int device, uint8_t *buff, uint32_t count)
|
||||
*/
|
||||
static void dspi_xmt_byte_multi(int device, const uint8_t *buff, uint32_t btx)
|
||||
{
|
||||
int i;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < btx - 1; i++)
|
||||
dspi_xchg_byte(device, *buff++, 0);
|
||||
dspi_xchg_byte(device, *buff++, 1); /* transfer last byte and indicate end of transmission */
|
||||
for (i = 0; i < btx - 1; i++)
|
||||
dspi_xchg_byte(device, *buff++, 0);
|
||||
dspi_xchg_byte(device, *buff++, 1); /* transfer last byte and indicate end of transmission */
|
||||
}
|
||||
|
||||
|
||||
+459
-459
File diff suppressed because it is too large
Load Diff
+69
-69
@@ -41,81 +41,81 @@
|
||||
*/
|
||||
void sd_card_init(void)
|
||||
{
|
||||
DRESULT res;
|
||||
FATFS fs;
|
||||
FRESULT fres;
|
||||
DRESULT res;
|
||||
FATFS fs;
|
||||
FRESULT fres;
|
||||
|
||||
disk_initialize(0);
|
||||
res = disk_status(0);
|
||||
xprintf("disk status of SD card is %d\r\n", res);
|
||||
if (res == RES_OK)
|
||||
{
|
||||
fres = f_mount(0, &fs);
|
||||
xprintf("mount status of SD card fs is %d\r\n", fres);
|
||||
if (fres == FR_OK)
|
||||
{
|
||||
DIR directory;
|
||||
FIL file;
|
||||
disk_initialize(0);
|
||||
res = disk_status(0);
|
||||
xprintf("disk status of SD card is %d\r\n", res);
|
||||
if (res == RES_OK)
|
||||
{
|
||||
fres = f_mount(0, &fs);
|
||||
xprintf("mount status of SD card fs is %d\r\n", fres);
|
||||
if (fres == FR_OK)
|
||||
{
|
||||
DIR directory;
|
||||
FIL file;
|
||||
|
||||
fres = f_opendir(&directory, "\\");
|
||||
if (fres == FR_OK)
|
||||
{
|
||||
FILINFO fi;
|
||||
fres = f_opendir(&directory, "\\");
|
||||
if (fres == FR_OK)
|
||||
{
|
||||
FILINFO fi;
|
||||
|
||||
while (((fres = f_readdir(&directory, &fi)) == FR_OK) && fi.fname[0])
|
||||
{
|
||||
xprintf("%13.13s %d\r\n", fi.fname, fi.fsize);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
xprintf("could not open directory \"\\\" on SD-card! Error code: %d\r\n", fres);
|
||||
}
|
||||
while (((fres = f_readdir(&directory, &fi)) == FR_OK) && fi.fname[0])
|
||||
{
|
||||
xprintf("%13.13s %d\r\n", fi.fname, fi.fsize);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
xprintf("could not open directory \"\\\" on SD-card! Error code: %d\r\n", fres);
|
||||
}
|
||||
|
||||
/*
|
||||
* let's see if we find our boot flashing executable on disk
|
||||
*/
|
||||
fres = f_open(&file, FLASHCODE_NAME, FA_READ);
|
||||
if (fres == FR_OK)
|
||||
{
|
||||
/*
|
||||
* yes, load and execute it
|
||||
*
|
||||
* FIXME: we will need some kind of user confirmation here
|
||||
* to avoid unwanted flashing or "bootsector viruses" before going productive
|
||||
*/
|
||||
uint32_t size; /* length of code piece read */
|
||||
uint32_t total_size = 0L;
|
||||
int32_t start_time = MCF_SLT_SCNT(0);
|
||||
int32_t end_time;
|
||||
int32_t time = 0;
|
||||
/*
|
||||
* let's see if we find our boot flashing executable on disk
|
||||
*/
|
||||
fres = f_open(&file, FLASHCODE_NAME, FA_READ);
|
||||
if (fres == FR_OK)
|
||||
{
|
||||
/*
|
||||
* yes, load and execute it
|
||||
*
|
||||
* FIXME: we will need some kind of user confirmation here
|
||||
* to avoid unwanted flashing or "bootsector viruses" before going productive
|
||||
*/
|
||||
uint32_t size; /* length of code piece read */
|
||||
uint32_t total_size = 0L;
|
||||
int32_t start_time = MCF_SLT_SCNT(0);
|
||||
int32_t end_time;
|
||||
int32_t time = 0;
|
||||
|
||||
while ((fres = f_read(&file, (void *) FLASHCODE_ADDRESS, 1024 * 1000, &size)) == FR_OK && size > 0)
|
||||
{
|
||||
total_size += size / 1024;
|
||||
xprintf("read hunk of %d bytes, total_size = %d kBytes\r\n", size, total_size);
|
||||
}
|
||||
end_time = MCF_SLT_SCNT(0);
|
||||
time = (end_time - start_time) / 132L;
|
||||
xprintf("result of f_read: %ld, %ld kbytes read\r\n", fres, total_size);
|
||||
xprintf("time to load %s: %ld s\r\n", FLASHCODE_NAME, time / 1000 / 100);
|
||||
xprintf("equals to about %ld kBytes/second\r\n", total_size / (time / 1000 / 100));
|
||||
while ((fres = f_read(&file, (void *) FLASHCODE_ADDRESS, 1024 * 1000, &size)) == FR_OK && size > 0)
|
||||
{
|
||||
total_size += size / 1024;
|
||||
xprintf("read hunk of %d bytes, total_size = %d kBytes\r\n", size, total_size);
|
||||
}
|
||||
end_time = MCF_SLT_SCNT(0);
|
||||
time = (end_time - start_time) / 132L;
|
||||
xprintf("result of f_read: %ld, %ld kbytes read\r\n", fres, total_size);
|
||||
xprintf("time to load %s: %ld s\r\n", FLASHCODE_NAME, time / 1000 / 100);
|
||||
xprintf("equals to about %ld kBytes/second\r\n", total_size / (time / 1000 / 100));
|
||||
|
||||
}
|
||||
f_close(&file);
|
||||
}
|
||||
f_close(&file);
|
||||
|
||||
fres = f_open(&file, WELCOME_NAME, FA_READ);
|
||||
if (fres == FR_OK)
|
||||
{
|
||||
char line[128];
|
||||
fres = f_open(&file, WELCOME_NAME, FA_READ);
|
||||
if (fres == FR_OK)
|
||||
{
|
||||
char line[128];
|
||||
|
||||
while (f_gets(line, sizeof(line), &file))
|
||||
{
|
||||
xprintf("%s", line);
|
||||
}
|
||||
}
|
||||
f_close(&file);
|
||||
}
|
||||
f_mount(0, 0L); /* release work area */
|
||||
}
|
||||
while (f_gets(line, sizeof(line), &file))
|
||||
{
|
||||
xprintf("%s", line);
|
||||
}
|
||||
}
|
||||
f_close(&file);
|
||||
}
|
||||
f_mount(0, 0L); /* release work area */
|
||||
}
|
||||
}
|
||||
|
||||
+98
-98
@@ -27,12 +27,12 @@
|
||||
|
||||
long mem_cmp(char *p1, char *p2, long size)
|
||||
{
|
||||
while(size--)
|
||||
{
|
||||
if (*p1++ != *p2++)
|
||||
return(1);
|
||||
}
|
||||
return(0);
|
||||
while(size--)
|
||||
{
|
||||
if (*p1++ != *p2++)
|
||||
return(1);
|
||||
}
|
||||
return(0);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -43,93 +43,93 @@ long mem_cmp(char *p1, char *p2, long size)
|
||||
|
||||
int fb_pan_display(struct fb_info *info, struct fb_var_screeninfo *var)
|
||||
{
|
||||
int xoffset = var->xoffset;
|
||||
int yoffset = var->yoffset;
|
||||
int err;
|
||||
// DPRINT("fb_pan_display\r\n");
|
||||
if ((xoffset < 0) || (yoffset < 0)
|
||||
|| ((xoffset + info->var.xres) > info->var.xres_virtual))
|
||||
return -1; //-EINVAL;
|
||||
if ((err = info->fbops->fb_pan_display(var, info)))
|
||||
return err;
|
||||
info->var.xoffset = var->xoffset;
|
||||
info->var.yoffset = var->yoffset;
|
||||
if (var->vmode & FB_VMODE_YWRAP)
|
||||
info->var.vmode |= FB_VMODE_YWRAP;
|
||||
else
|
||||
info->var.vmode &= ~FB_VMODE_YWRAP;
|
||||
return 0;
|
||||
int xoffset = var->xoffset;
|
||||
int yoffset = var->yoffset;
|
||||
int err;
|
||||
// DPRINT("fb_pan_display\r\n");
|
||||
if ((xoffset < 0) || (yoffset < 0)
|
||||
|| ((xoffset + info->var.xres) > info->var.xres_virtual))
|
||||
return -1; //-EINVAL;
|
||||
if ((err = info->fbops->fb_pan_display(var, info)))
|
||||
return err;
|
||||
info->var.xoffset = var->xoffset;
|
||||
info->var.yoffset = var->yoffset;
|
||||
if (var->vmode & FB_VMODE_YWRAP)
|
||||
info->var.vmode |= FB_VMODE_YWRAP;
|
||||
else
|
||||
info->var.vmode &= ~FB_VMODE_YWRAP;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int fb_set_var(struct fb_info *info, struct fb_var_screeninfo *var)
|
||||
{
|
||||
int err;
|
||||
// DPRINT("fb_set_var\r\n");
|
||||
if (var->activate & FB_ACTIVATE_INV_MODE)
|
||||
/* return 1 if equal */
|
||||
return(!mem_cmp((char *)&info->var, (char *)var, sizeof(struct fb_var_screeninfo)));
|
||||
if ((var->activate & FB_ACTIVATE_FORCE)
|
||||
|| mem_cmp((char *)&info->var, (char *)var, sizeof(struct fb_var_screeninfo)))
|
||||
{
|
||||
if ((err = info->fbops->fb_check_var(var, info)))
|
||||
return err;
|
||||
if ((var->activate & FB_ACTIVATE_MASK) == FB_ACTIVATE_NOW)
|
||||
{
|
||||
memcpy(&info->var, var, sizeof(struct fb_var_screeninfo));
|
||||
info->fbops->fb_set_par(info);
|
||||
fb_pan_display(info, &info->var);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
int err;
|
||||
// DPRINT("fb_set_var\r\n");
|
||||
if (var->activate & FB_ACTIVATE_INV_MODE)
|
||||
/* return 1 if equal */
|
||||
return(!mem_cmp((char *)&info->var, (char *)var, sizeof(struct fb_var_screeninfo)));
|
||||
if ((var->activate & FB_ACTIVATE_FORCE)
|
||||
|| mem_cmp((char *)&info->var, (char *)var, sizeof(struct fb_var_screeninfo)))
|
||||
{
|
||||
if ((err = info->fbops->fb_check_var(var, info)))
|
||||
return err;
|
||||
if ((var->activate & FB_ACTIVATE_MASK) == FB_ACTIVATE_NOW)
|
||||
{
|
||||
memcpy(&info->var, var, sizeof(struct fb_var_screeninfo));
|
||||
info->fbops->fb_set_par(info);
|
||||
fb_pan_display(info, &info->var);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int fb_blank(struct fb_info *info, int blank)
|
||||
{
|
||||
dbg("fb_blank\r\n");
|
||||
if (blank > FB_BLANK_POWERDOWN)
|
||||
blank = FB_BLANK_POWERDOWN;
|
||||
return(info->fbops->fb_blank(blank, info));
|
||||
{
|
||||
dbg("fb_blank\r\n");
|
||||
if (blank > FB_BLANK_POWERDOWN)
|
||||
blank = FB_BLANK_POWERDOWN;
|
||||
return(info->fbops->fb_blank(blank, info));
|
||||
}
|
||||
|
||||
int fb_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
struct fb_var_screeninfo var;
|
||||
struct fb_fix_screeninfo fix;
|
||||
void *argp = (void *) arg;
|
||||
int i;
|
||||
struct fb_var_screeninfo var;
|
||||
struct fb_fix_screeninfo fix;
|
||||
void *argp = (void *) arg;
|
||||
int i;
|
||||
|
||||
switch(cmd)
|
||||
{
|
||||
case FBIOGET_VSCREENINFO:
|
||||
memcpy(argp, &info->var, sizeof(var));
|
||||
return 0;
|
||||
case FBIOPUT_VSCREENINFO:
|
||||
memcpy(&var, argp, sizeof(var));
|
||||
i = fb_set_var(info, &var);
|
||||
if (i)
|
||||
return i;
|
||||
memcpy(argp, &var, sizeof(var));
|
||||
return 0;
|
||||
case FBIOGET_FSCREENINFO:
|
||||
memcpy(argp, &info->fix, sizeof(fix));
|
||||
return 0;
|
||||
case FBIOPAN_DISPLAY:
|
||||
memcpy(&var, argp, sizeof(var));
|
||||
i = fb_pan_display(info, &var);
|
||||
if (i)
|
||||
return i;
|
||||
memcpy(argp, &var, sizeof(var));
|
||||
return 0;
|
||||
case FBIOBLANK:
|
||||
i = fb_blank(info, arg);
|
||||
return i;
|
||||
case FBIO_ALLOC:
|
||||
return(offscreen_alloc(info,(long)arg));
|
||||
case FBIO_FREE:
|
||||
return(offscreen_free(info,(long)arg));
|
||||
default:
|
||||
return(info->fbops->fb_ioctl(cmd, arg, info));
|
||||
}
|
||||
switch(cmd)
|
||||
{
|
||||
case FBIOGET_VSCREENINFO:
|
||||
memcpy(argp, &info->var, sizeof(var));
|
||||
return 0;
|
||||
case FBIOPUT_VSCREENINFO:
|
||||
memcpy(&var, argp, sizeof(var));
|
||||
i = fb_set_var(info, &var);
|
||||
if (i)
|
||||
return i;
|
||||
memcpy(argp, &var, sizeof(var));
|
||||
return 0;
|
||||
case FBIOGET_FSCREENINFO:
|
||||
memcpy(argp, &info->fix, sizeof(fix));
|
||||
return 0;
|
||||
case FBIOPAN_DISPLAY:
|
||||
memcpy(&var, argp, sizeof(var));
|
||||
i = fb_pan_display(info, &var);
|
||||
if (i)
|
||||
return i;
|
||||
memcpy(argp, &var, sizeof(var));
|
||||
return 0;
|
||||
case FBIOBLANK:
|
||||
i = fb_blank(info, arg);
|
||||
return i;
|
||||
case FBIO_ALLOC:
|
||||
return(offscreen_alloc(info,(long)arg));
|
||||
case FBIO_FREE:
|
||||
return(offscreen_free(info,(long)arg));
|
||||
default:
|
||||
return(info->fbops->fb_ioctl(cmd, arg, info));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -148,25 +148,25 @@ int fb_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg)
|
||||
*/
|
||||
struct fb_info *framebuffer_alloc(unsigned long size)
|
||||
{
|
||||
struct fb_info *info = driver_mem_alloc(sizeof(struct fb_info));
|
||||
struct fb_info *info = driver_mem_alloc(sizeof(struct fb_info));
|
||||
|
||||
if (info == NULL)
|
||||
{
|
||||
dbg("%s: could not allocate fb_info structure\r\n", __FUNCTION__);
|
||||
return 0;
|
||||
}
|
||||
memset(info, 0, sizeof(struct fb_info));
|
||||
if (info == NULL)
|
||||
{
|
||||
dbg("%s: could not allocate fb_info structure\r\n", __FUNCTION__);
|
||||
return 0;
|
||||
}
|
||||
memset(info, 0, sizeof(struct fb_info));
|
||||
|
||||
if (size)
|
||||
{
|
||||
char *p = driver_mem_alloc(size);
|
||||
if (size)
|
||||
{
|
||||
char *p = driver_mem_alloc(size);
|
||||
|
||||
if (!p)
|
||||
return NULL;
|
||||
memset(p, 0, size);
|
||||
info->par = p;
|
||||
}
|
||||
return info;
|
||||
if (!p)
|
||||
return NULL;
|
||||
memset(p, 0, size);
|
||||
info->par = p;
|
||||
}
|
||||
return info;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -180,6 +180,6 @@ struct fb_info *framebuffer_alloc(unsigned long size)
|
||||
*/
|
||||
void framebuffer_release(struct fb_info *info)
|
||||
{
|
||||
driver_mem_free(info->par);
|
||||
driver_mem_free(info->par);
|
||||
}
|
||||
|
||||
|
||||
+472
-472
@@ -27,8 +27,8 @@
|
||||
((v).name && !strncmp((s), (v).name, (l)) && strlen((v).name) == (l))
|
||||
#define res_matches(v, x, y) \
|
||||
((v).xres == (x) && (v).yres == (y))
|
||||
|
||||
/*
|
||||
|
||||
/*
|
||||
* Standard video mode definitions (taken from XFree86)
|
||||
*/
|
||||
|
||||
@@ -36,366 +36,366 @@
|
||||
|
||||
const struct fb_videomode modedb[] =
|
||||
{
|
||||
{
|
||||
/* 640x400 @ 70 Hz, 31.5 kHz hsync */
|
||||
70, 640, 400, 39721, 40, 24, 39, 9, 96, 2,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 640x480 @ 60 Hz, 31.5 kHz hsync */
|
||||
60, 640, 480, 39721, 40, 24, 32, 11, 96, 2,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 800x600 @ 56 Hz, 35.15 kHz hsync */
|
||||
56, 800, 600, 27777, 128, 24, 22, 1, 72, 2,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1024x768 @ 87 Hz interlaced, 35.5 kHz hsync */
|
||||
87, 1024, 768, 22271, 56, 24, 33, 8, 160, 8,
|
||||
0, FB_VMODE_INTERLACED
|
||||
},
|
||||
{
|
||||
/* 640x400 @ 85 Hz, 37.86 kHz hsync */
|
||||
85, 640, 400, 31746, 96, 32, 41, 1, 64, 3,
|
||||
FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 640x480 @ 72 Hz, 36.5 kHz hsync */
|
||||
72, 640, 480, 31746, 144, 40, 30, 8, 40, 3,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 640x480 @ 75 Hz, 37.50 kHz hsync */
|
||||
75, 640, 480, 31746, 120, 16, 16, 1, 64, 3,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 800x600 @ 60 Hz, 37.8 kHz hsync */
|
||||
60, 800, 600, 25000, 88, 40, 23, 1, 128, 4,
|
||||
FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 640x480 @ 85 Hz, 43.27 kHz hsync */
|
||||
85, 640, 480, 27777, 80, 56, 25, 1, 56, 3,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1152x864 @ 89 Hz interlaced, 44 kHz hsync */
|
||||
69, 1152, 864, 15384, 96, 16, 110, 1, 216, 10,
|
||||
0, FB_VMODE_INTERLACED
|
||||
},
|
||||
{
|
||||
/* 800x600 @ 72 Hz, 48.0 kHz hsync */
|
||||
72, 800, 600, 20000, 64, 56, 23, 37, 120, 6,
|
||||
FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1024x768 @ 60 Hz, 48.4 kHz hsync */
|
||||
60, 1024, 768, 15384, 168, 8, 29, 3, 144, 6,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 640x480 @ 100 Hz, 53.01 kHz hsync */
|
||||
100, 640, 480, 21834, 96, 32, 36, 8, 96, 6,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1152x864 @ 60 Hz, 53.5 kHz hsync */
|
||||
60, 1152, 864, 11123, 208, 64, 16, 4, 256, 8,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 800x600 @ 85 Hz, 55.84 kHz hsync */
|
||||
85, 800, 600, 16460, 160, 64, 36, 16, 64, 5,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1024x768 @ 70 Hz, 56.5 kHz hsync */
|
||||
70, 1024, 768, 13333, 144, 24, 29, 3, 136, 6,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1280x1024 @ 87 Hz interlaced, 51 kHz hsync */
|
||||
87, 1280, 1024, 12500, 56, 16, 128, 1, 216, 12,
|
||||
0, FB_VMODE_INTERLACED
|
||||
},
|
||||
{
|
||||
/* 800x600 @ 100 Hz, 64.02 kHz hsync */
|
||||
100, 800, 600, 14357, 160, 64, 30, 4, 64, 6,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1024x768 @ 76 Hz, 62.5 kHz hsync */
|
||||
76, 1024, 768, 11764, 208, 8, 36, 16, 120, 3,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1152x864 @ 70 Hz, 62.4 kHz hsync */
|
||||
70, 1152, 864, 10869, 106, 56, 20, 1, 160, 10,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1280x1024 @ 61 Hz, 64.2 kHz hsync */
|
||||
61, 1280, 1024, 9090, 200, 48, 26, 1, 184, 3,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1400x1050 @ 60Hz, 63.9 kHz hsync */
|
||||
68, 1400, 1050, 9259, 136, 40, 13, 1, 112, 3,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1400x1050 @ 75,107 Hz, 82,392 kHz +hsync +vsync*/
|
||||
75, 1400, 1050, 9271, 120, 56, 13, 0, 112, 3,
|
||||
FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1400x1050 @ 60 Hz, ? kHz +hsync +vsync*/
|
||||
60, 1400, 1050, 9259, 128, 40, 12, 0, 112, 3,
|
||||
FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1024x768 @ 85 Hz, 70.24 kHz hsync */
|
||||
85, 1024, 768, 10111, 192, 32, 34, 14, 160, 6,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1152x864 @ 78 Hz, 70.8 kHz hsync */
|
||||
78, 1152, 864, 9090, 228, 88, 32, 0, 84, 12,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1280x1024 @ 70 Hz, 74.59 kHz hsync */
|
||||
70, 1280, 1024, 7905, 224, 32, 28, 8, 160, 8,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1600x1200 @ 60Hz, 75.00 kHz hsync */
|
||||
60, 1600, 1200, 6172, 304, 64, 46, 1, 192, 3,
|
||||
FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1152x864 @ 84 Hz, 76.0 kHz hsync */
|
||||
84, 1152, 864, 7407, 184, 312, 32, 0, 128, 12,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1280x1024 @ 74 Hz, 78.85 kHz hsync */
|
||||
74, 1280, 1024, 7407, 256, 32, 34, 3, 144, 3,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1024x768 @ 100Hz, 80.21 kHz hsync */
|
||||
100, 1024, 768, 8658, 192, 32, 21, 3, 192, 10,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1280x1024 @ 76 Hz, 81.13 kHz hsync */
|
||||
76, 1280, 1024, 7407, 248, 32, 34, 3, 104, 3,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1600x1200 @ 70 Hz, 87.50 kHz hsync */
|
||||
70, 1600, 1200, 5291, 304, 64, 46, 1, 192, 3,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1152x864 @ 100 Hz, 89.62 kHz hsync */
|
||||
100, 1152, 864, 7264, 224, 32, 17, 2, 128, 19,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1280x1024 @ 85 Hz, 91.15 kHz hsync */
|
||||
85, 1280, 1024, 6349, 224, 64, 44, 1, 160, 3,
|
||||
FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1600x1200 @ 75 Hz, 93.75 kHz hsync */
|
||||
75, 1600, 1200, 4938, 304, 64, 46, 1, 192, 3,
|
||||
FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1600x1200 @ 85 Hz, 105.77 kHz hsync */
|
||||
85, 1600, 1200, 4545, 272, 16, 37, 4, 192, 3,
|
||||
FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1280x1024 @ 100 Hz, 107.16 kHz hsync */
|
||||
100, 1280, 1024, 5502, 256, 32, 26, 7, 128, 15,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1800x1440 @ 64Hz, 96.15 kHz hsync */
|
||||
64, 1800, 1440, 4347, 304, 96, 46, 1, 192, 3,
|
||||
FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1800x1440 @ 70Hz, 104.52 kHz hsync */
|
||||
70, 1800, 1440, 4000, 304, 96, 46, 1, 192, 3,
|
||||
FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 512x384 @ 78 Hz, 31.50 kHz hsync */
|
||||
78, 512, 384, 49603, 48, 16, 16, 1, 64, 3,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 512x384 @ 85 Hz, 34.38 kHz hsync */
|
||||
85, 512, 384, 45454, 48, 16, 16, 1, 64, 3,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 320x200 @ 70 Hz, 31.5 kHz hsync, 8:5 aspect ratio */
|
||||
70, 320, 200, 79440, 16, 16, 20, 4, 48, 1,
|
||||
0, FB_VMODE_DOUBLE
|
||||
},
|
||||
{
|
||||
/* 320x240 @ 60 Hz, 31.5 kHz hsync, 4:3 aspect ratio */
|
||||
60, 320, 240, 79440, 16, 16, 16, 5, 48, 1,
|
||||
0, FB_VMODE_DOUBLE
|
||||
},
|
||||
{
|
||||
/* 320x240 @ 72 Hz, 36.5 kHz hsync */
|
||||
72, 320, 240, 63492, 16, 16, 16, 4, 48, 2,
|
||||
0, FB_VMODE_DOUBLE
|
||||
},
|
||||
{
|
||||
/* 400x300 @ 56 Hz, 35.2 kHz hsync, 4:3 aspect ratio */
|
||||
56, 400, 300, 55555, 64, 16, 10, 1, 32, 1,
|
||||
0, FB_VMODE_DOUBLE
|
||||
},
|
||||
{
|
||||
/* 400x300 @ 60 Hz, 37.8 kHz hsync */
|
||||
60, 400, 300, 50000, 48, 16, 11, 1, 64, 2,
|
||||
0, FB_VMODE_DOUBLE
|
||||
},
|
||||
{
|
||||
/* 400x300 @ 72 Hz, 48.0 kHz hsync */
|
||||
72, 400, 300, 40000, 32, 24, 11, 19, 64, 3,
|
||||
0, FB_VMODE_DOUBLE
|
||||
},
|
||||
{
|
||||
/* 480x300 @ 56 Hz, 35.2 kHz hsync, 8:5 aspect ratio */
|
||||
56, 480, 300, 46176, 80, 16, 10, 1, 40, 1,
|
||||
0, FB_VMODE_DOUBLE
|
||||
},
|
||||
{
|
||||
/* 480x300 @ 60 Hz, 37.8 kHz hsync */
|
||||
60, 480, 300, 41858, 56, 16, 11, 1, 80, 2,
|
||||
0, FB_VMODE_DOUBLE
|
||||
},
|
||||
{
|
||||
/* 480x300 @ 63 Hz, 39.6 kHz hsync */
|
||||
63, 480, 300, 40000, 56, 16, 11, 1, 80, 2,
|
||||
0, FB_VMODE_DOUBLE
|
||||
},
|
||||
{
|
||||
/* 480x300 @ 72 Hz, 48.0 kHz hsync */
|
||||
72, 480, 300, 33386, 40, 24, 11, 19, 80, 3,
|
||||
0, FB_VMODE_DOUBLE
|
||||
},
|
||||
{
|
||||
/* 1920x1200 @ 60 Hz, 74.5 Khz hsync */
|
||||
60, 1920, 1200, 5177, 128, 336, 1, 38, 208, 3,
|
||||
FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
|
||||
FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1152x768, 60 Hz, PowerBook G4 Titanium I and II */
|
||||
60, 1152, 768, 14047, 158, 26, 29, 3, 136, 6,
|
||||
FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1920x1080, 60 Hz, 1080pf */
|
||||
60, 1920, 1080, 6741, 148, 44, 36, 4, 88, 5,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1366x768, 60 Hz, 47.403 kHz hsync, WXGA 16:9 aspect ratio */
|
||||
60, 1366, 768, 13806, 120, 10, 14, 3, 32, 5,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1280x800, 60 Hz, 47.403 kHz hsync, WXGA 16:10 aspect ratio */
|
||||
60, 1280, 800, 12048, 200, 64, 24, 1, 136, 3,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 640x400 @ 70 Hz, 31.5 kHz hsync */
|
||||
70, 640, 400, 39721, 40, 24, 39, 9, 96, 2,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 640x480 @ 60 Hz, 31.5 kHz hsync */
|
||||
60, 640, 480, 39721, 40, 24, 32, 11, 96, 2,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 800x600 @ 56 Hz, 35.15 kHz hsync */
|
||||
56, 800, 600, 27777, 128, 24, 22, 1, 72, 2,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1024x768 @ 87 Hz interlaced, 35.5 kHz hsync */
|
||||
87, 1024, 768, 22271, 56, 24, 33, 8, 160, 8,
|
||||
0, FB_VMODE_INTERLACED
|
||||
},
|
||||
{
|
||||
/* 640x400 @ 85 Hz, 37.86 kHz hsync */
|
||||
85, 640, 400, 31746, 96, 32, 41, 1, 64, 3,
|
||||
FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 640x480 @ 72 Hz, 36.5 kHz hsync */
|
||||
72, 640, 480, 31746, 144, 40, 30, 8, 40, 3,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 640x480 @ 75 Hz, 37.50 kHz hsync */
|
||||
75, 640, 480, 31746, 120, 16, 16, 1, 64, 3,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 800x600 @ 60 Hz, 37.8 kHz hsync */
|
||||
60, 800, 600, 25000, 88, 40, 23, 1, 128, 4,
|
||||
FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 640x480 @ 85 Hz, 43.27 kHz hsync */
|
||||
85, 640, 480, 27777, 80, 56, 25, 1, 56, 3,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1152x864 @ 89 Hz interlaced, 44 kHz hsync */
|
||||
69, 1152, 864, 15384, 96, 16, 110, 1, 216, 10,
|
||||
0, FB_VMODE_INTERLACED
|
||||
},
|
||||
{
|
||||
/* 800x600 @ 72 Hz, 48.0 kHz hsync */
|
||||
72, 800, 600, 20000, 64, 56, 23, 37, 120, 6,
|
||||
FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1024x768 @ 60 Hz, 48.4 kHz hsync */
|
||||
60, 1024, 768, 15384, 168, 8, 29, 3, 144, 6,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 640x480 @ 100 Hz, 53.01 kHz hsync */
|
||||
100, 640, 480, 21834, 96, 32, 36, 8, 96, 6,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1152x864 @ 60 Hz, 53.5 kHz hsync */
|
||||
60, 1152, 864, 11123, 208, 64, 16, 4, 256, 8,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 800x600 @ 85 Hz, 55.84 kHz hsync */
|
||||
85, 800, 600, 16460, 160, 64, 36, 16, 64, 5,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1024x768 @ 70 Hz, 56.5 kHz hsync */
|
||||
70, 1024, 768, 13333, 144, 24, 29, 3, 136, 6,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1280x1024 @ 87 Hz interlaced, 51 kHz hsync */
|
||||
87, 1280, 1024, 12500, 56, 16, 128, 1, 216, 12,
|
||||
0, FB_VMODE_INTERLACED
|
||||
},
|
||||
{
|
||||
/* 800x600 @ 100 Hz, 64.02 kHz hsync */
|
||||
100, 800, 600, 14357, 160, 64, 30, 4, 64, 6,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1024x768 @ 76 Hz, 62.5 kHz hsync */
|
||||
76, 1024, 768, 11764, 208, 8, 36, 16, 120, 3,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1152x864 @ 70 Hz, 62.4 kHz hsync */
|
||||
70, 1152, 864, 10869, 106, 56, 20, 1, 160, 10,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1280x1024 @ 61 Hz, 64.2 kHz hsync */
|
||||
61, 1280, 1024, 9090, 200, 48, 26, 1, 184, 3,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1400x1050 @ 60Hz, 63.9 kHz hsync */
|
||||
68, 1400, 1050, 9259, 136, 40, 13, 1, 112, 3,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1400x1050 @ 75,107 Hz, 82,392 kHz +hsync +vsync*/
|
||||
75, 1400, 1050, 9271, 120, 56, 13, 0, 112, 3,
|
||||
FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1400x1050 @ 60 Hz, ? kHz +hsync +vsync*/
|
||||
60, 1400, 1050, 9259, 128, 40, 12, 0, 112, 3,
|
||||
FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1024x768 @ 85 Hz, 70.24 kHz hsync */
|
||||
85, 1024, 768, 10111, 192, 32, 34, 14, 160, 6,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1152x864 @ 78 Hz, 70.8 kHz hsync */
|
||||
78, 1152, 864, 9090, 228, 88, 32, 0, 84, 12,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1280x1024 @ 70 Hz, 74.59 kHz hsync */
|
||||
70, 1280, 1024, 7905, 224, 32, 28, 8, 160, 8,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1600x1200 @ 60Hz, 75.00 kHz hsync */
|
||||
60, 1600, 1200, 6172, 304, 64, 46, 1, 192, 3,
|
||||
FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1152x864 @ 84 Hz, 76.0 kHz hsync */
|
||||
84, 1152, 864, 7407, 184, 312, 32, 0, 128, 12,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1280x1024 @ 74 Hz, 78.85 kHz hsync */
|
||||
74, 1280, 1024, 7407, 256, 32, 34, 3, 144, 3,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1024x768 @ 100Hz, 80.21 kHz hsync */
|
||||
100, 1024, 768, 8658, 192, 32, 21, 3, 192, 10,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1280x1024 @ 76 Hz, 81.13 kHz hsync */
|
||||
76, 1280, 1024, 7407, 248, 32, 34, 3, 104, 3,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1600x1200 @ 70 Hz, 87.50 kHz hsync */
|
||||
70, 1600, 1200, 5291, 304, 64, 46, 1, 192, 3,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1152x864 @ 100 Hz, 89.62 kHz hsync */
|
||||
100, 1152, 864, 7264, 224, 32, 17, 2, 128, 19,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1280x1024 @ 85 Hz, 91.15 kHz hsync */
|
||||
85, 1280, 1024, 6349, 224, 64, 44, 1, 160, 3,
|
||||
FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1600x1200 @ 75 Hz, 93.75 kHz hsync */
|
||||
75, 1600, 1200, 4938, 304, 64, 46, 1, 192, 3,
|
||||
FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1600x1200 @ 85 Hz, 105.77 kHz hsync */
|
||||
85, 1600, 1200, 4545, 272, 16, 37, 4, 192, 3,
|
||||
FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1280x1024 @ 100 Hz, 107.16 kHz hsync */
|
||||
100, 1280, 1024, 5502, 256, 32, 26, 7, 128, 15,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1800x1440 @ 64Hz, 96.15 kHz hsync */
|
||||
64, 1800, 1440, 4347, 304, 96, 46, 1, 192, 3,
|
||||
FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1800x1440 @ 70Hz, 104.52 kHz hsync */
|
||||
70, 1800, 1440, 4000, 304, 96, 46, 1, 192, 3,
|
||||
FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 512x384 @ 78 Hz, 31.50 kHz hsync */
|
||||
78, 512, 384, 49603, 48, 16, 16, 1, 64, 3,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 512x384 @ 85 Hz, 34.38 kHz hsync */
|
||||
85, 512, 384, 45454, 48, 16, 16, 1, 64, 3,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 320x200 @ 70 Hz, 31.5 kHz hsync, 8:5 aspect ratio */
|
||||
70, 320, 200, 79440, 16, 16, 20, 4, 48, 1,
|
||||
0, FB_VMODE_DOUBLE
|
||||
},
|
||||
{
|
||||
/* 320x240 @ 60 Hz, 31.5 kHz hsync, 4:3 aspect ratio */
|
||||
60, 320, 240, 79440, 16, 16, 16, 5, 48, 1,
|
||||
0, FB_VMODE_DOUBLE
|
||||
},
|
||||
{
|
||||
/* 320x240 @ 72 Hz, 36.5 kHz hsync */
|
||||
72, 320, 240, 63492, 16, 16, 16, 4, 48, 2,
|
||||
0, FB_VMODE_DOUBLE
|
||||
},
|
||||
{
|
||||
/* 400x300 @ 56 Hz, 35.2 kHz hsync, 4:3 aspect ratio */
|
||||
56, 400, 300, 55555, 64, 16, 10, 1, 32, 1,
|
||||
0, FB_VMODE_DOUBLE
|
||||
},
|
||||
{
|
||||
/* 400x300 @ 60 Hz, 37.8 kHz hsync */
|
||||
60, 400, 300, 50000, 48, 16, 11, 1, 64, 2,
|
||||
0, FB_VMODE_DOUBLE
|
||||
},
|
||||
{
|
||||
/* 400x300 @ 72 Hz, 48.0 kHz hsync */
|
||||
72, 400, 300, 40000, 32, 24, 11, 19, 64, 3,
|
||||
0, FB_VMODE_DOUBLE
|
||||
},
|
||||
{
|
||||
/* 480x300 @ 56 Hz, 35.2 kHz hsync, 8:5 aspect ratio */
|
||||
56, 480, 300, 46176, 80, 16, 10, 1, 40, 1,
|
||||
0, FB_VMODE_DOUBLE
|
||||
},
|
||||
{
|
||||
/* 480x300 @ 60 Hz, 37.8 kHz hsync */
|
||||
60, 480, 300, 41858, 56, 16, 11, 1, 80, 2,
|
||||
0, FB_VMODE_DOUBLE
|
||||
},
|
||||
{
|
||||
/* 480x300 @ 63 Hz, 39.6 kHz hsync */
|
||||
63, 480, 300, 40000, 56, 16, 11, 1, 80, 2,
|
||||
0, FB_VMODE_DOUBLE
|
||||
},
|
||||
{
|
||||
/* 480x300 @ 72 Hz, 48.0 kHz hsync */
|
||||
72, 480, 300, 33386, 40, 24, 11, 19, 80, 3,
|
||||
0, FB_VMODE_DOUBLE
|
||||
},
|
||||
{
|
||||
/* 1920x1200 @ 60 Hz, 74.5 Khz hsync */
|
||||
60, 1920, 1200, 5177, 128, 336, 1, 38, 208, 3,
|
||||
FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
|
||||
FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1152x768, 60 Hz, PowerBook G4 Titanium I and II */
|
||||
60, 1152, 768, 14047, 158, 26, 29, 3, 136, 6,
|
||||
FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1920x1080, 60 Hz, 1080pf */
|
||||
60, 1920, 1080, 6741, 148, 44, 36, 4, 88, 5,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1366x768, 60 Hz, 47.403 kHz hsync, WXGA 16:9 aspect ratio */
|
||||
60, 1366, 768, 13806, 120, 10, 14, 3, 32, 5,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
{
|
||||
/* 1280x800, 60 Hz, 47.403 kHz hsync, WXGA 16:10 aspect ratio */
|
||||
60, 1280, 800, 12048, 200, 64, 24, 1, 136, 3,
|
||||
0, FB_VMODE_NONINTERLACED
|
||||
},
|
||||
};
|
||||
|
||||
long total_modedb = sizeof(modedb) / sizeof(*modedb);
|
||||
|
||||
const struct fb_videomode vesa_modes[] =
|
||||
{
|
||||
/* 0 640x350-85 VESA */
|
||||
{ 85, 640, 350, 31746, 96, 32, 60, 32, 64, 3, FB_SYNC_HOR_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA},
|
||||
/* 1 640x400-85 VESA */
|
||||
{ 85, 640, 400, 31746, 96, 32, 41, 01, 64, 3, FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 2 720x400-85 VESA */
|
||||
{ 85, 721, 400, 28169, 108, 36, 42, 01, 72, 3, FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 3 640x480-60 VESA */
|
||||
{ 60, 640, 480, 39682, 48, 16, 33, 10, 96, 2, 0, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 4 640x480-72 VESA */
|
||||
{ 72, 640, 480, 31746, 128, 24, 29, 9, 40, 2, 0, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 5 640x480-75 VESA */
|
||||
{ 75, 640, 480, 31746, 120, 16, 16, 01, 64, 3, 0, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 6 640x480-85 VESA */
|
||||
{ 85, 640, 480, 27777, 80, 56, 25, 01, 56, 3, 0, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 7 800x600-56 VESA */
|
||||
{ 56, 800, 600, 27777, 128, 24, 22, 01, 72, 2, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 8 800x600-60 VESA */
|
||||
{ 60, 800, 600, 25000, 88, 40, 23, 01, 128, 4, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 9 800x600-72 VESA */
|
||||
{ 72, 800, 600, 20000, 64, 56, 23, 37, 120, 6, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 10 800x600-75 VESA */
|
||||
{ 75, 800, 600, 20202, 160, 16, 21, 01, 80, 3, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 11 800x600-85 VESA */
|
||||
{ 85, 800, 600, 17761, 152, 32, 27, 01, 64, 3, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 12 1024x768i-43 VESA */
|
||||
{ 53, 1024, 768, 22271, 56, 8, 41, 0, 176, 8, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_INTERLACED, FB_MODE_IS_VESA },
|
||||
/* 13 1024x768-60 VESA */
|
||||
{ 60, 1024, 768, 15384, 160, 24, 29, 3, 136, 6, 0, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 14 1024x768-70 VESA */
|
||||
{ 70, 1024, 768, 13333, 144, 24, 29, 3, 136, 6, 0, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 15 1024x768-75 VESA */
|
||||
{ 75, 1024, 768, 12690, 176, 16, 28, 1, 96, 3, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 16 1024x768-85 VESA */
|
||||
{ 85, 1024, 768, 10582, 208, 48, 36, 1, 96, 3, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 17 1152x864-75 VESA */
|
||||
{ 75, 1153, 864, 9259, 256, 64, 32, 1, 128, 3, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 18 1280x960-60 VESA */
|
||||
{ 60, 1280, 960, 9259, 312, 96, 36, 1, 112, 3, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 19 1280x960-85 VESA */
|
||||
{ 85, 1280, 960, 6734, 224, 64, 47, 1, 160, 3, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 20 1280x1024-60 VESA */
|
||||
{ 60, 1280, 1024, 9259, 248, 48, 38, 1, 112, 3, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 21 1280x1024-75 VESA */
|
||||
{ 75, 1280, 1024, 7407, 248, 16, 38, 1, 144, 3, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 22 1280x1024-85 VESA */
|
||||
{ 85, 1280, 1024, 6349, 224, 64, 44, 1, 160, 3, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 23 1600x1200-60 VESA */
|
||||
{ 60, 1600, 1200, 6172, 304, 64, 46, 1, 192, 3, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 24 1600x1200-65 VESA */
|
||||
{ 65, 1600, 1200, 5698, 304, 64, 46, 1, 192, 3, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 25 1600x1200-70 VESA */
|
||||
{ 70, 1600, 1200, 5291, 304, 64, 46, 1, 192, 3, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 26 1600x1200-75 VESA */
|
||||
{ 75, 1600, 1200, 4938, 304, 64, 46, 1, 192, 3, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 27 1600x1200-85 VESA */
|
||||
{ 85, 1600, 1200, 4357, 304, 64, 46, 1, 192, 3, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 28 1792x1344-60 VESA */
|
||||
{ 60, 1792, 1344, 4882, 328, 128, 46, 1, 200, 3, FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 29 1792x1344-75 VESA */
|
||||
{ 75, 1792, 1344, 3831, 352, 96, 69, 1, 216, 3, FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 30 1856x1392-60 VESA */
|
||||
{ 60, 1856, 1392, 4580, 352, 96, 43, 1, 224, 3, FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 31 1856x1392-75 VESA */
|
||||
{ 75, 1856, 1392, 3472, 352, 128, 104, 1, 224, 3, FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 32 1920x1440-60 VESA */
|
||||
{ 60, 1920, 1440, 4273, 344, 128, 56, 1, 200, 3, FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 33 1920x1440-75 VESA */
|
||||
{ 60, 1920, 1440, 3367, 352, 144, 56, 1, 224, 3, FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 0 640x350-85 VESA */
|
||||
{ 85, 640, 350, 31746, 96, 32, 60, 32, 64, 3, FB_SYNC_HOR_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA},
|
||||
/* 1 640x400-85 VESA */
|
||||
{ 85, 640, 400, 31746, 96, 32, 41, 01, 64, 3, FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 2 720x400-85 VESA */
|
||||
{ 85, 721, 400, 28169, 108, 36, 42, 01, 72, 3, FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 3 640x480-60 VESA */
|
||||
{ 60, 640, 480, 39682, 48, 16, 33, 10, 96, 2, 0, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 4 640x480-72 VESA */
|
||||
{ 72, 640, 480, 31746, 128, 24, 29, 9, 40, 2, 0, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 5 640x480-75 VESA */
|
||||
{ 75, 640, 480, 31746, 120, 16, 16, 01, 64, 3, 0, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 6 640x480-85 VESA */
|
||||
{ 85, 640, 480, 27777, 80, 56, 25, 01, 56, 3, 0, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 7 800x600-56 VESA */
|
||||
{ 56, 800, 600, 27777, 128, 24, 22, 01, 72, 2, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 8 800x600-60 VESA */
|
||||
{ 60, 800, 600, 25000, 88, 40, 23, 01, 128, 4, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 9 800x600-72 VESA */
|
||||
{ 72, 800, 600, 20000, 64, 56, 23, 37, 120, 6, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 10 800x600-75 VESA */
|
||||
{ 75, 800, 600, 20202, 160, 16, 21, 01, 80, 3, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 11 800x600-85 VESA */
|
||||
{ 85, 800, 600, 17761, 152, 32, 27, 01, 64, 3, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 12 1024x768i-43 VESA */
|
||||
{ 53, 1024, 768, 22271, 56, 8, 41, 0, 176, 8, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_INTERLACED, FB_MODE_IS_VESA },
|
||||
/* 13 1024x768-60 VESA */
|
||||
{ 60, 1024, 768, 15384, 160, 24, 29, 3, 136, 6, 0, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 14 1024x768-70 VESA */
|
||||
{ 70, 1024, 768, 13333, 144, 24, 29, 3, 136, 6, 0, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 15 1024x768-75 VESA */
|
||||
{ 75, 1024, 768, 12690, 176, 16, 28, 1, 96, 3, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 16 1024x768-85 VESA */
|
||||
{ 85, 1024, 768, 10582, 208, 48, 36, 1, 96, 3, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 17 1152x864-75 VESA */
|
||||
{ 75, 1153, 864, 9259, 256, 64, 32, 1, 128, 3, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 18 1280x960-60 VESA */
|
||||
{ 60, 1280, 960, 9259, 312, 96, 36, 1, 112, 3, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 19 1280x960-85 VESA */
|
||||
{ 85, 1280, 960, 6734, 224, 64, 47, 1, 160, 3, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 20 1280x1024-60 VESA */
|
||||
{ 60, 1280, 1024, 9259, 248, 48, 38, 1, 112, 3, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 21 1280x1024-75 VESA */
|
||||
{ 75, 1280, 1024, 7407, 248, 16, 38, 1, 144, 3, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 22 1280x1024-85 VESA */
|
||||
{ 85, 1280, 1024, 6349, 224, 64, 44, 1, 160, 3, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 23 1600x1200-60 VESA */
|
||||
{ 60, 1600, 1200, 6172, 304, 64, 46, 1, 192, 3, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 24 1600x1200-65 VESA */
|
||||
{ 65, 1600, 1200, 5698, 304, 64, 46, 1, 192, 3, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 25 1600x1200-70 VESA */
|
||||
{ 70, 1600, 1200, 5291, 304, 64, 46, 1, 192, 3, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 26 1600x1200-75 VESA */
|
||||
{ 75, 1600, 1200, 4938, 304, 64, 46, 1, 192, 3, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 27 1600x1200-85 VESA */
|
||||
{ 85, 1600, 1200, 4357, 304, 64, 46, 1, 192, 3, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 28 1792x1344-60 VESA */
|
||||
{ 60, 1792, 1344, 4882, 328, 128, 46, 1, 200, 3, FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 29 1792x1344-75 VESA */
|
||||
{ 75, 1792, 1344, 3831, 352, 96, 69, 1, 216, 3, FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 30 1856x1392-60 VESA */
|
||||
{ 60, 1856, 1392, 4580, 352, 96, 43, 1, 224, 3, FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 31 1856x1392-75 VESA */
|
||||
{ 75, 1856, 1392, 3472, 352, 128, 104, 1, 224, 3, FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 32 1920x1440-60 VESA */
|
||||
{ 60, 1920, 1440, 4273, 344, 128, 56, 1, 200, 3, FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
/* 33 1920x1440-75 VESA */
|
||||
{ 60, 1920, 1440, 3367, 352, 144, 56, 1, 224, 3, FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
|
||||
};
|
||||
|
||||
/**
|
||||
@@ -412,7 +412,7 @@ const struct fb_videomode vesa_modes[] =
|
||||
*/
|
||||
|
||||
static int fb_try_mode(struct fb_var_screeninfo *var, struct fb_info *info,
|
||||
const struct fb_videomode *mode, unsigned int bpp)
|
||||
const struct fb_videomode *mode, unsigned int bpp)
|
||||
{
|
||||
int err = 0;
|
||||
|
||||
@@ -435,7 +435,7 @@ static int fb_try_mode(struct fb_var_screeninfo *var, struct fb_info *info,
|
||||
var->sync = mode->sync;
|
||||
var->vmode = mode->vmode;
|
||||
var->refresh = mode->refresh;
|
||||
err = info->fbops->fb_check_var(var, info);
|
||||
err = info->fbops->fb_check_var(var, info);
|
||||
|
||||
var->activate &= ~FB_ACTIVATE_TEST;
|
||||
|
||||
@@ -475,122 +475,122 @@ static int fb_try_mode(struct fb_var_screeninfo *var, struct fb_info *info,
|
||||
*/
|
||||
|
||||
int fb_find_mode(struct fb_var_screeninfo *var,
|
||||
struct fb_info *info, struct mode_option *resolution ,
|
||||
const struct fb_videomode *db, unsigned int dbsize,
|
||||
const struct fb_videomode *default_mode,
|
||||
unsigned int default_bpp)
|
||||
struct fb_info *info, struct mode_option *resolution ,
|
||||
const struct fb_videomode *db, unsigned int dbsize,
|
||||
const struct fb_videomode *default_mode,
|
||||
unsigned int default_bpp)
|
||||
{
|
||||
int i,abs;
|
||||
int res_specified = 0, bpp_specified = 0, refresh_specified = 0;
|
||||
unsigned int xres = 0, yres = 0, bpp = default_bpp, refresh = 0;
|
||||
int yres_specified = 0;
|
||||
unsigned long best, diff;
|
||||
int i,abs;
|
||||
int res_specified = 0, bpp_specified = 0, refresh_specified = 0;
|
||||
unsigned int xres = 0, yres = 0, bpp = default_bpp, refresh = 0;
|
||||
int yres_specified = 0;
|
||||
unsigned long best, diff;
|
||||
|
||||
dbg("fb_find_mode\r\n");
|
||||
dbg("fb_find_mode\r\n");
|
||||
|
||||
/* Set up defaults */
|
||||
if (!db)
|
||||
{
|
||||
dbg("fb_find_mode, use default modedb\r\n");
|
||||
if (resolution->used && (resolution->flags & MODE_VESA_FLAG))
|
||||
{
|
||||
db = vesa_modes;
|
||||
dbsize = sizeof(vesa_modes)/sizeof(*vesa_modes);
|
||||
}
|
||||
else
|
||||
{
|
||||
db = modedb;
|
||||
dbsize = sizeof(modedb)/sizeof(*modedb);
|
||||
}
|
||||
}
|
||||
if (!default_mode)
|
||||
default_mode = &modedb[DEFAULT_MODEDB_INDEX];
|
||||
if (!default_bpp)
|
||||
default_bpp = 8;
|
||||
|
||||
/* Did the user specify a video mode? */
|
||||
if (resolution->used) /* fVDI mode */
|
||||
{
|
||||
refresh = (unsigned int)resolution->freq;
|
||||
if (refresh)
|
||||
refresh_specified = 1;
|
||||
bpp = (unsigned int)resolution->bpp;
|
||||
if (resolution->flags & MODE_EMUL_MONO_FLAG)
|
||||
bpp = 8;
|
||||
if (bpp)
|
||||
bpp_specified = 1;
|
||||
yres = (unsigned int)resolution->height;
|
||||
if (yres)
|
||||
yres_specified = 1;
|
||||
xres = (unsigned int)resolution->width;
|
||||
if (xres)
|
||||
res_specified = 1;
|
||||
}
|
||||
dbg("Trying specified video mode %d x %d\r\n", xres, yres);
|
||||
|
||||
diff = refresh;
|
||||
best = -1;
|
||||
for (i = 0; i < dbsize; i++)
|
||||
{
|
||||
if (res_specified && res_matches(db[i], xres, yres))
|
||||
{
|
||||
if (!fb_try_mode(var, info, &db[i], bpp))
|
||||
{
|
||||
if (!refresh_specified || db[i].refresh == refresh)
|
||||
return 1;
|
||||
else
|
||||
{
|
||||
abs = db[i].refresh - refresh;
|
||||
if (abs < 0)
|
||||
abs = -abs;
|
||||
if (diff > abs)
|
||||
{
|
||||
diff = abs;
|
||||
best = i;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (best != -1)
|
||||
{
|
||||
fb_try_mode(var, info, &db[best], bpp);
|
||||
return 2;
|
||||
}
|
||||
diff = xres + yres;
|
||||
dbg("Trying best-fit modes\r\n");
|
||||
best = -1;
|
||||
for (i = 0; i < dbsize; i++)
|
||||
{
|
||||
if (xres <= db[i].xres && yres <= db[i].yres)
|
||||
{
|
||||
dbg("Trying %d x %d\r\n", db[i].xres, db[i].yres);
|
||||
|
||||
if (!fb_try_mode(var, info, &db[i], bpp))
|
||||
{
|
||||
if (diff > (db[i].xres - xres) + (db[i].yres - yres))
|
||||
{
|
||||
diff = (db[i].xres - xres) + (db[i].yres - yres);
|
||||
best = i;
|
||||
}
|
||||
}
|
||||
/* Set up defaults */
|
||||
if (!db)
|
||||
{
|
||||
dbg("fb_find_mode, use default modedb\r\n");
|
||||
if (resolution->used && (resolution->flags & MODE_VESA_FLAG))
|
||||
{
|
||||
db = vesa_modes;
|
||||
dbsize = sizeof(vesa_modes)/sizeof(*vesa_modes);
|
||||
}
|
||||
else
|
||||
{
|
||||
db = modedb;
|
||||
dbsize = sizeof(modedb)/sizeof(*modedb);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (best != -1)
|
||||
{
|
||||
fb_try_mode(var, info, &db[best], bpp);
|
||||
return 5;
|
||||
}
|
||||
dbg("Trying default video mode\r\n");
|
||||
if (!fb_try_mode(var, info, default_mode, default_bpp))
|
||||
return 3;
|
||||
dbg("Trying all modes\r\n");
|
||||
for (i = 0; i < dbsize; i++)
|
||||
{
|
||||
if (!fb_try_mode(var, info, &db[i], default_bpp))
|
||||
return 4;
|
||||
}
|
||||
dbg("No valid mode found\r\n");
|
||||
return 0;
|
||||
if (!default_mode)
|
||||
default_mode = &modedb[DEFAULT_MODEDB_INDEX];
|
||||
if (!default_bpp)
|
||||
default_bpp = 8;
|
||||
|
||||
/* Did the user specify a video mode? */
|
||||
if (resolution->used) /* fVDI mode */
|
||||
{
|
||||
refresh = (unsigned int)resolution->freq;
|
||||
if (refresh)
|
||||
refresh_specified = 1;
|
||||
bpp = (unsigned int)resolution->bpp;
|
||||
if (resolution->flags & MODE_EMUL_MONO_FLAG)
|
||||
bpp = 8;
|
||||
if (bpp)
|
||||
bpp_specified = 1;
|
||||
yres = (unsigned int)resolution->height;
|
||||
if (yres)
|
||||
yres_specified = 1;
|
||||
xres = (unsigned int)resolution->width;
|
||||
if (xres)
|
||||
res_specified = 1;
|
||||
}
|
||||
dbg("Trying specified video mode %d x %d\r\n", xres, yres);
|
||||
|
||||
diff = refresh;
|
||||
best = -1;
|
||||
for (i = 0; i < dbsize; i++)
|
||||
{
|
||||
if (res_specified && res_matches(db[i], xres, yres))
|
||||
{
|
||||
if (!fb_try_mode(var, info, &db[i], bpp))
|
||||
{
|
||||
if (!refresh_specified || db[i].refresh == refresh)
|
||||
return 1;
|
||||
else
|
||||
{
|
||||
abs = db[i].refresh - refresh;
|
||||
if (abs < 0)
|
||||
abs = -abs;
|
||||
if (diff > abs)
|
||||
{
|
||||
diff = abs;
|
||||
best = i;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (best != -1)
|
||||
{
|
||||
fb_try_mode(var, info, &db[best], bpp);
|
||||
return 2;
|
||||
}
|
||||
diff = xres + yres;
|
||||
dbg("Trying best-fit modes\r\n");
|
||||
best = -1;
|
||||
for (i = 0; i < dbsize; i++)
|
||||
{
|
||||
if (xres <= db[i].xres && yres <= db[i].yres)
|
||||
{
|
||||
dbg("Trying %d x %d\r\n", db[i].xres, db[i].yres);
|
||||
|
||||
if (!fb_try_mode(var, info, &db[i], bpp))
|
||||
{
|
||||
if (diff > (db[i].xres - xres) + (db[i].yres - yres))
|
||||
{
|
||||
diff = (db[i].xres - xres) + (db[i].yres - yres);
|
||||
best = i;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (best != -1)
|
||||
{
|
||||
fb_try_mode(var, info, &db[best], bpp);
|
||||
return 5;
|
||||
}
|
||||
dbg("Trying default video mode\r\n");
|
||||
if (!fb_try_mode(var, info, default_mode, default_bpp))
|
||||
return 3;
|
||||
dbg("Trying all modes\r\n");
|
||||
for (i = 0; i < dbsize; i++)
|
||||
{
|
||||
if (!fb_try_mode(var, info, &db[i], default_bpp))
|
||||
return 4;
|
||||
}
|
||||
dbg("No valid mode found\r\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
+962
-962
File diff suppressed because it is too large
Load Diff
+207
-207
@@ -2,7 +2,7 @@
|
||||
* offscreen.c
|
||||
*
|
||||
* based from Emutos / BDOS
|
||||
*
|
||||
*
|
||||
* Copyright (c) 2001 Lineo, Inc.
|
||||
*
|
||||
* Authors: Karl T. Braun, Martin Doering, Laurent Vogel
|
||||
@@ -23,10 +23,10 @@
|
||||
|
||||
MD
|
||||
{
|
||||
MD *m_link;
|
||||
long m_start;
|
||||
long m_length;
|
||||
void *m_own;
|
||||
MD *m_link;
|
||||
long m_start;
|
||||
long m_length;
|
||||
void *m_own;
|
||||
};
|
||||
|
||||
/* MPB - Memory Partition Block */
|
||||
@@ -35,9 +35,9 @@ MD
|
||||
|
||||
MPB
|
||||
{
|
||||
MD *mp_mfl;
|
||||
MD *mp_mal;
|
||||
MD *mp_rover;
|
||||
MD *mp_mfl;
|
||||
MD *mp_mal;
|
||||
MD *mp_rover;
|
||||
};
|
||||
|
||||
#define MAXMD 256
|
||||
@@ -48,247 +48,247 @@ static long wrap;
|
||||
|
||||
static void *xmgetblk(void)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < MAXMD; i++)
|
||||
{
|
||||
if(tab_md[i].m_own == NULL)
|
||||
{
|
||||
tab_md[i].m_own = (void*)1L;
|
||||
return(&tab_md[i]);
|
||||
}
|
||||
}
|
||||
return(NULL);
|
||||
int i;
|
||||
for (i = 0; i < MAXMD; i++)
|
||||
{
|
||||
if(tab_md[i].m_own == NULL)
|
||||
{
|
||||
tab_md[i].m_own = (void*)1L;
|
||||
return(&tab_md[i]);
|
||||
}
|
||||
}
|
||||
return(NULL);
|
||||
}
|
||||
|
||||
static void xmfreblk(void *m)
|
||||
{
|
||||
int i = (int)(((long)m - (long)tab_md) / sizeof(MD));
|
||||
if((i > 0) && (i < MAXMD))
|
||||
tab_md[i].m_own = NULL;
|
||||
int i = (int)(((long)m - (long)tab_md) / sizeof(MD));
|
||||
if((i > 0) && (i < MAXMD))
|
||||
tab_md[i].m_own = NULL;
|
||||
}
|
||||
|
||||
static MD *ffit(long amount, MPB *mp)
|
||||
{
|
||||
MD *p,*q,*p1; /* free list is composed of MD's */
|
||||
int maxflg;
|
||||
long maxval;
|
||||
if(amount != -1)
|
||||
{
|
||||
MD *p,*q,*p1; /* free list is composed of MD's */
|
||||
int maxflg;
|
||||
long maxval;
|
||||
if(amount != -1)
|
||||
{
|
||||
#if 1
|
||||
amount += (wrap - 1);
|
||||
amount /= wrap;
|
||||
amount *= wrap; /* screen line alignment */
|
||||
amount += (wrap - 1);
|
||||
amount /= wrap;
|
||||
amount *= wrap; /* screen line alignment */
|
||||
#else
|
||||
amount += 15; /* 16 bytes alignment */
|
||||
amount &= 0xFFFFFFF0;
|
||||
amount += 15; /* 16 bytes alignment */
|
||||
amount &= 0xFFFFFFF0;
|
||||
#endif
|
||||
}
|
||||
if((q = mp->mp_rover) == 0) /* get rotating pointer */
|
||||
return(0) ;
|
||||
maxval = 0;
|
||||
maxflg = ((amount == -1) ? true : false) ;
|
||||
p = q->m_link; /* start with next MD */
|
||||
do /* search the list for an MD with enough space */
|
||||
{
|
||||
if(p == NULL)
|
||||
{
|
||||
/* at end of list, wrap back to start */
|
||||
q = (MD *) &mp->mp_mfl; /* q => mfl field */
|
||||
p = q->m_link; /* p => 1st MD */
|
||||
}
|
||||
if((!maxflg) && (p->m_length >= amount))
|
||||
{
|
||||
/* big enough */
|
||||
if(p->m_length == amount)
|
||||
q->m_link = p->m_link; /* take the whole thing */
|
||||
else
|
||||
{
|
||||
/* break it up - 1st allocate a new
|
||||
MD to describe the remainder */
|
||||
p1 = xmgetblk();
|
||||
if(p1 == NULL)
|
||||
return(NULL);
|
||||
/* init new MD */
|
||||
p1->m_length = p->m_length - amount;
|
||||
p1->m_start = p->m_start + amount;
|
||||
p1->m_link = p->m_link;
|
||||
p->m_length = amount; /* adjust allocated block */
|
||||
q->m_link = p1;
|
||||
}
|
||||
/* link allocate block into allocated list,
|
||||
mark owner of block, & adjust rover */
|
||||
p->m_link = mp->mp_mal;
|
||||
mp->mp_mal = p;
|
||||
mp->mp_rover = (q == (MD *) &mp->mp_mfl ? q->m_link : q);
|
||||
return(p); /* got some */
|
||||
}
|
||||
else if(p->m_length > maxval)
|
||||
maxval = p->m_length;
|
||||
p = ( q=p )->m_link;
|
||||
}
|
||||
while(q != mp->mp_rover);
|
||||
/* return either the max, or 0 (error) */
|
||||
if(maxflg)
|
||||
{
|
||||
maxval -= 15; /* 16 bytes alignment */
|
||||
if(maxval < 0)
|
||||
maxval = 0;
|
||||
else
|
||||
maxval &= 0xFFFFFFF0;
|
||||
}
|
||||
return(maxflg ? (MD *) maxval : 0);
|
||||
}
|
||||
if((q = mp->mp_rover) == 0) /* get rotating pointer */
|
||||
return(0) ;
|
||||
maxval = 0;
|
||||
maxflg = ((amount == -1) ? true : false) ;
|
||||
p = q->m_link; /* start with next MD */
|
||||
do /* search the list for an MD with enough space */
|
||||
{
|
||||
if(p == NULL)
|
||||
{
|
||||
/* at end of list, wrap back to start */
|
||||
q = (MD *) &mp->mp_mfl; /* q => mfl field */
|
||||
p = q->m_link; /* p => 1st MD */
|
||||
}
|
||||
if((!maxflg) && (p->m_length >= amount))
|
||||
{
|
||||
/* big enough */
|
||||
if(p->m_length == amount)
|
||||
q->m_link = p->m_link; /* take the whole thing */
|
||||
else
|
||||
{
|
||||
/* break it up - 1st allocate a new
|
||||
MD to describe the remainder */
|
||||
p1 = xmgetblk();
|
||||
if(p1 == NULL)
|
||||
return(NULL);
|
||||
/* init new MD */
|
||||
p1->m_length = p->m_length - amount;
|
||||
p1->m_start = p->m_start + amount;
|
||||
p1->m_link = p->m_link;
|
||||
p->m_length = amount; /* adjust allocated block */
|
||||
q->m_link = p1;
|
||||
}
|
||||
/* link allocate block into allocated list,
|
||||
mark owner of block, & adjust rover */
|
||||
p->m_link = mp->mp_mal;
|
||||
mp->mp_mal = p;
|
||||
mp->mp_rover = (q == (MD *) &mp->mp_mfl ? q->m_link : q);
|
||||
return(p); /* got some */
|
||||
}
|
||||
else if(p->m_length > maxval)
|
||||
maxval = p->m_length;
|
||||
p = ( q=p )->m_link;
|
||||
}
|
||||
while(q != mp->mp_rover);
|
||||
/* return either the max, or 0 (error) */
|
||||
if(maxflg)
|
||||
{
|
||||
maxval -= 15; /* 16 bytes alignment */
|
||||
if(maxval < 0)
|
||||
maxval = 0;
|
||||
else
|
||||
maxval &= 0xFFFFFFF0;
|
||||
}
|
||||
return(maxflg ? (MD *) maxval : 0);
|
||||
}
|
||||
|
||||
static void freeit(MD *m, MPB *mp)
|
||||
{
|
||||
MD *p, *q;
|
||||
q = NULL;
|
||||
for (p = mp->mp_mfl; p ; p = (q=p) -> m_link)
|
||||
{
|
||||
if(m->m_start <= p->m_start)
|
||||
break;
|
||||
}
|
||||
m->m_link = p;
|
||||
if(q)
|
||||
q->m_link = m;
|
||||
else
|
||||
mp->mp_mfl = m;
|
||||
if(!mp->mp_rover)
|
||||
mp->mp_rover = m;
|
||||
if(p)
|
||||
{
|
||||
if(m->m_start + m->m_length == p->m_start)
|
||||
{ /* join to higher neighbor */
|
||||
m->m_length += p->m_length;
|
||||
m->m_link = p->m_link;
|
||||
if(p == mp->mp_rover)
|
||||
mp->mp_rover = m;
|
||||
xmfreblk(p);
|
||||
}
|
||||
}
|
||||
if(q)
|
||||
{
|
||||
if(q->m_start + q->m_length == m->m_start)
|
||||
{ /* join to lower neighbor */
|
||||
q->m_length += m->m_length;
|
||||
q->m_link = m->m_link;
|
||||
if(m == mp->mp_rover)
|
||||
mp->mp_rover = q;
|
||||
xmfreblk(m);
|
||||
}
|
||||
}
|
||||
MD *p, *q;
|
||||
q = NULL;
|
||||
for (p = mp->mp_mfl; p ; p = (q=p) -> m_link)
|
||||
{
|
||||
if(m->m_start <= p->m_start)
|
||||
break;
|
||||
}
|
||||
m->m_link = p;
|
||||
if(q)
|
||||
q->m_link = m;
|
||||
else
|
||||
mp->mp_mfl = m;
|
||||
if(!mp->mp_rover)
|
||||
mp->mp_rover = m;
|
||||
if(p)
|
||||
{
|
||||
if(m->m_start + m->m_length == p->m_start)
|
||||
{ /* join to higher neighbor */
|
||||
m->m_length += p->m_length;
|
||||
m->m_link = p->m_link;
|
||||
if(p == mp->mp_rover)
|
||||
mp->mp_rover = m;
|
||||
xmfreblk(p);
|
||||
}
|
||||
}
|
||||
if(q)
|
||||
{
|
||||
if(q->m_start + q->m_length == m->m_start)
|
||||
{ /* join to lower neighbor */
|
||||
q->m_length += m->m_length;
|
||||
q->m_link = m->m_link;
|
||||
if(m == mp->mp_rover)
|
||||
mp->mp_rover = q;
|
||||
xmfreblk(m);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
long offscreen_free(struct fb_info *info, long addr)
|
||||
{
|
||||
MD *p,**q;
|
||||
MPB *mpb;
|
||||
MD *p,**q;
|
||||
MPB *mpb;
|
||||
#ifdef DEBUG
|
||||
char buf[10];
|
||||
Funcs_puts("radeon_offscreen_free(0x");
|
||||
Funcs_ltoa(buf, addr, 16);
|
||||
Funcs_puts(buf);
|
||||
Funcs_puts("\r\n");
|
||||
char buf[10];
|
||||
Funcs_puts("radeon_offscreen_free(0x");
|
||||
Funcs_ltoa(buf, addr, 16);
|
||||
Funcs_puts(buf);
|
||||
Funcs_puts("\r\n");
|
||||
#endif
|
||||
//*vblsem = 0;
|
||||
mpb = &pmd;
|
||||
for (p = *(q = &mpb->mp_mal); p; p = *(q = &p->m_link))
|
||||
{
|
||||
if(addr == p->m_start)
|
||||
break;
|
||||
}
|
||||
if(!p)
|
||||
{
|
||||
// *vblsem = 1;
|
||||
return -1; //(EFAULT);
|
||||
}
|
||||
*q = p->m_link;
|
||||
freeit(p,mpb);
|
||||
//*vblsem = 1;
|
||||
return(0);
|
||||
//*vblsem = 0;
|
||||
mpb = &pmd;
|
||||
for (p = *(q = &mpb->mp_mal); p; p = *(q = &p->m_link))
|
||||
{
|
||||
if(addr == p->m_start)
|
||||
break;
|
||||
}
|
||||
if(!p)
|
||||
{
|
||||
// *vblsem = 1;
|
||||
return -1; //(EFAULT);
|
||||
}
|
||||
*q = p->m_link;
|
||||
freeit(p,mpb);
|
||||
//*vblsem = 1;
|
||||
return(0);
|
||||
}
|
||||
|
||||
long offscreen_alloc(struct fb_info *info, long amount)
|
||||
{
|
||||
long ret;
|
||||
MD *m;
|
||||
long ret;
|
||||
MD *m;
|
||||
#ifdef DEBUG
|
||||
char buf[10];
|
||||
Funcs_puts("radeon_offscreen_alloc(0x");
|
||||
Funcs_ltoa(buf, amount, 16);
|
||||
Funcs_puts(buf);
|
||||
Funcs_puts(") = 0x");
|
||||
char buf[10];
|
||||
Funcs_puts("radeon_offscreen_alloc(0x");
|
||||
Funcs_ltoa(buf, amount, 16);
|
||||
Funcs_puts(buf);
|
||||
Funcs_puts(") = 0x");
|
||||
#endif
|
||||
// *vblsem = 0;
|
||||
if(amount == -1L)
|
||||
{
|
||||
ret = (long)ffit(-1L,&pmd);
|
||||
// *vblsem = 1;
|
||||
return(ret);
|
||||
}
|
||||
if(amount <= 0 )
|
||||
{
|
||||
// *vblsem = 1;
|
||||
return(0);
|
||||
}
|
||||
if((amount & 1))
|
||||
amount++;
|
||||
m = ffit(amount,&pmd);
|
||||
if(m == NULL)
|
||||
{
|
||||
// *vblsem = 0;
|
||||
if(amount == -1L)
|
||||
{
|
||||
ret = (long)ffit(-1L,&pmd);
|
||||
// *vblsem = 1;
|
||||
return(ret);
|
||||
}
|
||||
if(amount <= 0 )
|
||||
{
|
||||
// *vblsem = 1;
|
||||
return(0);
|
||||
}
|
||||
if((amount & 1))
|
||||
amount++;
|
||||
m = ffit(amount,&pmd);
|
||||
if(m == NULL)
|
||||
{
|
||||
#ifdef DEBUG
|
||||
Funcs_puts("0\r\n");
|
||||
Funcs_puts("0\r\n");
|
||||
#endif
|
||||
// *vblsem = 1;
|
||||
return(0);
|
||||
}
|
||||
// *vblsem = 1;
|
||||
return(0);
|
||||
}
|
||||
#ifdef DEBUG
|
||||
Funcs_ltoa(buf, m->m_start, 16);
|
||||
Funcs_puts(buf);
|
||||
Funcs_puts("\r\n");
|
||||
Funcs_ltoa(buf, m->m_start, 16);
|
||||
Funcs_puts(buf);
|
||||
Funcs_puts("\r\n");
|
||||
#endif
|
||||
ret = (long)m->m_start;
|
||||
// *vblsem = 1;
|
||||
return(ret);
|
||||
ret = (long)m->m_start;
|
||||
// *vblsem = 1;
|
||||
return(ret);
|
||||
}
|
||||
|
||||
long offscren_reserved(struct fb_info *info)
|
||||
{
|
||||
return((long) info->ram_base + (long) info->ram_size);
|
||||
return((long) info->ram_base + (long) info->ram_size);
|
||||
}
|
||||
|
||||
void offscreen_init(struct fb_info *info)
|
||||
{
|
||||
#ifdef DEBUG
|
||||
char buf[10];
|
||||
char buf[10];
|
||||
#endif
|
||||
long size_screen, max_offscreen_size;
|
||||
wrap = (long) info->var.xres_virtual * (long)(info->var.bits_per_pixel / 8);
|
||||
size_screen = (long)info->var.yres_virtual * wrap;
|
||||
if(!size_screen)
|
||||
size_screen = (long)info->screen_size;
|
||||
pmd.mp_mfl = pmd.mp_rover = &tab_md[0];
|
||||
tab_md[0].m_link = (MD *)NULL;
|
||||
tab_md[0].m_start = (long)((unsigned long)info->ram_base + (unsigned long)size_screen);
|
||||
tab_md[0].m_length = (long)info->ram_size - size_screen;
|
||||
tab_md[0].m_own = (void *)1L;
|
||||
max_offscreen_size = ((long)info->var.xres_virtual * 8192L * (long)(info->var.bits_per_pixel / 8)) - size_screen;
|
||||
if(max_offscreen_size < 0)
|
||||
max_offscreen_size = 0;
|
||||
if(tab_md[0].m_length > max_offscreen_size)
|
||||
tab_md[0].m_length = max_offscreen_size;
|
||||
long size_screen, max_offscreen_size;
|
||||
wrap = (long) info->var.xres_virtual * (long)(info->var.bits_per_pixel / 8);
|
||||
size_screen = (long)info->var.yres_virtual * wrap;
|
||||
if(!size_screen)
|
||||
size_screen = (long)info->screen_size;
|
||||
pmd.mp_mfl = pmd.mp_rover = &tab_md[0];
|
||||
tab_md[0].m_link = (MD *)NULL;
|
||||
tab_md[0].m_start = (long)((unsigned long)info->ram_base + (unsigned long)size_screen);
|
||||
tab_md[0].m_length = (long)info->ram_size - size_screen;
|
||||
tab_md[0].m_own = (void *)1L;
|
||||
max_offscreen_size = ((long)info->var.xres_virtual * 8192L * (long)(info->var.bits_per_pixel / 8)) - size_screen;
|
||||
if(max_offscreen_size < 0)
|
||||
max_offscreen_size = 0;
|
||||
if(tab_md[0].m_length > max_offscreen_size)
|
||||
tab_md[0].m_length = max_offscreen_size;
|
||||
#ifdef DEBUG
|
||||
Funcs_puts("offscreen_init start 0x");
|
||||
Funcs_ltoa(buf, tab_md[0].m_start, 16);
|
||||
Funcs_puts(buf);
|
||||
Funcs_puts(", length 0x");
|
||||
Funcs_ltoa(buf, tab_md[0].m_length, 16);
|
||||
Funcs_puts(buf);
|
||||
Funcs_puts(", ram_size 0x");
|
||||
Funcs_ltoa(buf, (long)info->ram_size, 16);
|
||||
Funcs_puts(buf);
|
||||
Funcs_puts("\r\n");
|
||||
Funcs_puts("offscreen_init start 0x");
|
||||
Funcs_ltoa(buf, tab_md[0].m_start, 16);
|
||||
Funcs_puts(buf);
|
||||
Funcs_puts(", length 0x");
|
||||
Funcs_ltoa(buf, tab_md[0].m_length, 16);
|
||||
Funcs_puts(buf);
|
||||
Funcs_puts(", ram_size 0x");
|
||||
Funcs_ltoa(buf, (long)info->ram_size, 16);
|
||||
Funcs_puts(buf);
|
||||
Funcs_puts("\r\n");
|
||||
#endif
|
||||
pmd.mp_mal = (MD *)NULL;
|
||||
pmd.mp_mal = (MD *)NULL;
|
||||
}
|
||||
|
||||
|
||||
+241
-241
@@ -35,39 +35,39 @@
|
||||
|
||||
typedef struct
|
||||
{
|
||||
long ident;
|
||||
union
|
||||
{
|
||||
long l;
|
||||
short i[2];
|
||||
char c[4];
|
||||
} v;
|
||||
long ident;
|
||||
union
|
||||
{
|
||||
long l;
|
||||
short i[2];
|
||||
char c[4];
|
||||
} v;
|
||||
} COOKIE;
|
||||
|
||||
struct rom_header
|
||||
{
|
||||
uint16_t signature;
|
||||
uint8_t size;
|
||||
uint8_t init[3];
|
||||
uint8_t reserved[0x12];
|
||||
uint16_t data;
|
||||
uint16_t signature;
|
||||
uint8_t size;
|
||||
uint8_t init[3];
|
||||
uint8_t reserved[0x12];
|
||||
uint16_t data;
|
||||
};
|
||||
|
||||
struct pci_data
|
||||
{
|
||||
uint32_t signature;
|
||||
uint16_t vendor;
|
||||
uint16_t device;
|
||||
uint16_t reserved_1;
|
||||
uint16_t dlen;
|
||||
uint8_t drevision;
|
||||
uint8_t class_lo;
|
||||
uint16_t class_hi;
|
||||
uint16_t ilen;
|
||||
uint16_t irevision;
|
||||
uint8_t type;
|
||||
uint8_t indicator;
|
||||
uint16_t reserved_2;
|
||||
uint32_t signature;
|
||||
uint16_t vendor;
|
||||
uint16_t device;
|
||||
uint16_t reserved_1;
|
||||
uint16_t dlen;
|
||||
uint8_t drevision;
|
||||
uint8_t class_lo;
|
||||
uint16_t class_hi;
|
||||
uint16_t ilen;
|
||||
uint16_t irevision;
|
||||
uint8_t type;
|
||||
uint8_t indicator;
|
||||
uint16_t reserved_2;
|
||||
};
|
||||
|
||||
static struct radeonfb_info *rinfo_biosemu;
|
||||
@@ -83,7 +83,7 @@ extern int x86_pcibios_emulator();
|
||||
/* general software interrupt handler */
|
||||
uint32_t getIntVect(struct X86EMU *emu, int num)
|
||||
{
|
||||
return MEM_RW(num << 2) + (MEM_RW((num << 2) + 2) << 4);
|
||||
return MEM_RW(num << 2) + (MEM_RW((num << 2) + 2) << 4);
|
||||
}
|
||||
|
||||
/* FixME: There is already a push_word() in the emulator */
|
||||
@@ -95,7 +95,7 @@ void pushw(struct X86EMU *emu, uint16_t val)
|
||||
|
||||
int run_bios_int(struct X86EMU *emu, int num)
|
||||
{
|
||||
uint32_t eflags;
|
||||
uint32_t eflags;
|
||||
eflags = emu->x86.R_EFLG;
|
||||
pushw(emu, eflags);
|
||||
pushw(emu, emu->x86.R_CS);
|
||||
@@ -103,253 +103,253 @@ int run_bios_int(struct X86EMU *emu, int num)
|
||||
emu->x86.R_CS = MEM_RW((num << 2) + 2);
|
||||
emu->x86.R_IP = MEM_RW(num << 2);
|
||||
|
||||
return 1;
|
||||
return 1;
|
||||
}
|
||||
|
||||
uint8_t inb(uint16_t port)
|
||||
{
|
||||
uint8_t val = 0;
|
||||
uint8_t val = 0;
|
||||
|
||||
if ((port >= offset_port) && (port <= offset_port + 0xFF))
|
||||
{
|
||||
val = * (uint8_t *) (offset_io + (uint32_t) port);
|
||||
//dbg("%s: inb(0x%x) = 0x%x\r\n", __FUNCTION__, port, val);
|
||||
}
|
||||
return val;
|
||||
if ((port >= offset_port) && (port <= offset_port + 0xFF))
|
||||
{
|
||||
val = * (uint8_t *) (offset_io + (uint32_t) port);
|
||||
//dbg("%s: inb(0x%x) = 0x%x\r\n", __FUNCTION__, port, val);
|
||||
}
|
||||
return val;
|
||||
}
|
||||
|
||||
uint16_t inw(uint16_t port)
|
||||
{
|
||||
uint16_t val = 0;
|
||||
uint16_t val = 0;
|
||||
|
||||
if ((port >= offset_port) && (port <= offset_port + 0xFF))
|
||||
{
|
||||
val = swpw(*(uint16_t *)(offset_io + (uint32_t) port));
|
||||
//dbg("inw(0x%x) = 0x%x\r\n", port, val);
|
||||
}
|
||||
return val;
|
||||
if ((port >= offset_port) && (port <= offset_port + 0xFF))
|
||||
{
|
||||
val = swpw(*(uint16_t *)(offset_io + (uint32_t) port));
|
||||
//dbg("inw(0x%x) = 0x%x\r\n", port, val);
|
||||
}
|
||||
return val;
|
||||
}
|
||||
|
||||
uint32_t inl(uint16_t port)
|
||||
{
|
||||
uint32_t val = 0;
|
||||
if ((port >= offset_port) && (port <= offset_port + 0xFF))
|
||||
{
|
||||
val = swpl(*(uint32_t *)(offset_io + (uint32_t) port));
|
||||
//dbg("0x%x) = 0x%x\r\n", port, val);
|
||||
}
|
||||
else if (port == 0xCF8)
|
||||
{
|
||||
val = config_address_reg;
|
||||
dbg("inl(0x%x) = 0x%x\r\n", port, val);
|
||||
}
|
||||
else if ((port == 0xCFC) && ((config_address_reg & 0x80000000) != 0))
|
||||
{
|
||||
dbg("%s: PCI BIOS access to register %x\r\n", __FUNCTION__, config_address_reg);
|
||||
switch (config_address_reg & 0xFC)
|
||||
{
|
||||
case PCIIDR:
|
||||
val = ((uint32_t) rinfo_biosemu->chipset << 16) + PCI_VENDOR_ID_ATI;
|
||||
break;
|
||||
uint32_t val = 0;
|
||||
if ((port >= offset_port) && (port <= offset_port + 0xFF))
|
||||
{
|
||||
val = swpl(*(uint32_t *)(offset_io + (uint32_t) port));
|
||||
//dbg("0x%x) = 0x%x\r\n", port, val);
|
||||
}
|
||||
else if (port == 0xCF8)
|
||||
{
|
||||
val = config_address_reg;
|
||||
dbg("inl(0x%x) = 0x%x\r\n", port, val);
|
||||
}
|
||||
else if ((port == 0xCFC) && ((config_address_reg & 0x80000000) != 0))
|
||||
{
|
||||
dbg("%s: PCI BIOS access to register %x\r\n", __FUNCTION__, config_address_reg);
|
||||
switch (config_address_reg & 0xFC)
|
||||
{
|
||||
case PCIIDR:
|
||||
val = ((uint32_t) rinfo_biosemu->chipset << 16) + PCI_VENDOR_ID_ATI;
|
||||
break;
|
||||
|
||||
case PCIBAR1:
|
||||
val = (uint32_t) offset_port + 1;
|
||||
break;
|
||||
case PCIBAR1:
|
||||
val = (uint32_t) offset_port + 1;
|
||||
break;
|
||||
|
||||
default:
|
||||
val = pci_read_config_longword(rinfo_biosemu->handle, config_address_reg & 0xFC);
|
||||
break;
|
||||
}
|
||||
dbg("inl(0x%x) = 0x%x\r\n", port, val);
|
||||
}
|
||||
return val;
|
||||
default:
|
||||
val = pci_read_config_longword(rinfo_biosemu->handle, config_address_reg & 0xFC);
|
||||
break;
|
||||
}
|
||||
dbg("inl(0x%x) = 0x%x\r\n", port, val);
|
||||
}
|
||||
return val;
|
||||
}
|
||||
|
||||
void outb(uint8_t val, uint16_t port)
|
||||
{
|
||||
if ((port >= offset_port) && (port <= offset_port + 0xFF))
|
||||
{
|
||||
//dbg("outb(0x%x, 0x%x)\r\n", port, val);
|
||||
*(uint8_t *)(offset_io + (uint32_t) port) = val;
|
||||
}
|
||||
if ((port >= offset_port) && (port <= offset_port + 0xFF))
|
||||
{
|
||||
//dbg("outb(0x%x, 0x%x)\r\n", port, val);
|
||||
*(uint8_t *)(offset_io + (uint32_t) port) = val;
|
||||
}
|
||||
}
|
||||
|
||||
void outw(uint16_t val, uint16_t port)
|
||||
{
|
||||
if ((port >= offset_port) && (port <= offset_port + 0xFF))
|
||||
{
|
||||
//dbg("outw(0x%x, 0x%x)\r\n", port, val);
|
||||
*(uint16_t *)(offset_io + (uint32_t) port) = swpw(val);
|
||||
}
|
||||
if ((port >= offset_port) && (port <= offset_port + 0xFF))
|
||||
{
|
||||
//dbg("outw(0x%x, 0x%x)\r\n", port, val);
|
||||
*(uint16_t *)(offset_io + (uint32_t) port) = swpw(val);
|
||||
}
|
||||
}
|
||||
|
||||
void outl(uint32_t val, uint16_t port)
|
||||
{
|
||||
if ((port >= offset_port) && (port <= offset_port + 0xFF))
|
||||
{
|
||||
//dbg("outl(0x%x, 0x%x)\r\n", port, val);
|
||||
*(uint32_t *)(offset_io + (uint32_t) port) = swpl(val);
|
||||
}
|
||||
else if (port == 0xCF8)
|
||||
{
|
||||
dbg("outl(0x%x, 0x%x)\r\n", port, val);
|
||||
config_address_reg = val;
|
||||
}
|
||||
else if ((port == 0xCFC) && ((config_address_reg & 0x80000000) !=0))
|
||||
{
|
||||
if ((config_address_reg & 0xFC) == PCIBAR1)
|
||||
offset_port = (uint16_t)val & 0xFFFC;
|
||||
else
|
||||
{
|
||||
dbg("outl(0x%x, 0x%x) to PCI config space\r\n", port, val);
|
||||
pci_write_config_longword(rinfo_biosemu->handle, config_address_reg & 0xFC, val);
|
||||
}
|
||||
}
|
||||
if ((port >= offset_port) && (port <= offset_port + 0xFF))
|
||||
{
|
||||
//dbg("outl(0x%x, 0x%x)\r\n", port, val);
|
||||
*(uint32_t *)(offset_io + (uint32_t) port) = swpl(val);
|
||||
}
|
||||
else if (port == 0xCF8)
|
||||
{
|
||||
dbg("outl(0x%x, 0x%x)\r\n", port, val);
|
||||
config_address_reg = val;
|
||||
}
|
||||
else if ((port == 0xCFC) && ((config_address_reg & 0x80000000) !=0))
|
||||
{
|
||||
if ((config_address_reg & 0xFC) == PCIBAR1)
|
||||
offset_port = (uint16_t)val & 0xFFFC;
|
||||
else
|
||||
{
|
||||
dbg("outl(0x%x, 0x%x) to PCI config space\r\n", port, val);
|
||||
pci_write_config_longword(rinfo_biosemu->handle, config_address_reg & 0xFC, val);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Interrupt multiplexer */
|
||||
|
||||
void do_int(struct X86EMU *emu, int num)
|
||||
{
|
||||
int ret = 0;
|
||||
int ret = 0;
|
||||
|
||||
switch (num)
|
||||
{
|
||||
switch (num)
|
||||
{
|
||||
#ifndef _PC
|
||||
case 0x10:
|
||||
case 0x42:
|
||||
case 0x6D:
|
||||
if (getIntVect(emu, num) == 0x0000)
|
||||
dbg("uninitialised int vector\r\n");
|
||||
if (getIntVect(emu, num) == 0xFF065)
|
||||
{
|
||||
//ret = int42_handler();
|
||||
ret = 1;
|
||||
}
|
||||
break;
|
||||
case 0x10:
|
||||
case 0x42:
|
||||
case 0x6D:
|
||||
if (getIntVect(emu, num) == 0x0000)
|
||||
dbg("uninitialised int vector\r\n");
|
||||
if (getIntVect(emu, num) == 0xFF065)
|
||||
{
|
||||
//ret = int42_handler();
|
||||
ret = 1;
|
||||
}
|
||||
break;
|
||||
#endif
|
||||
case 0x15:
|
||||
//ret = int15_handler();
|
||||
ret = 1;
|
||||
break;
|
||||
case 0x16:
|
||||
//ret = int16_handler();
|
||||
ret = 0;
|
||||
break;
|
||||
case 0x1A:
|
||||
ret = x86_pcibios_handler(emu);
|
||||
ret = 1;
|
||||
break;
|
||||
case 0xe6:
|
||||
//ret = intE6_handler();
|
||||
ret = 0;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
if (!ret)
|
||||
case 0x15:
|
||||
//ret = int15_handler();
|
||||
ret = 1;
|
||||
break;
|
||||
case 0x16:
|
||||
//ret = int16_handler();
|
||||
ret = 0;
|
||||
break;
|
||||
case 0x1A:
|
||||
ret = x86_pcibios_handler(emu);
|
||||
ret = 1;
|
||||
break;
|
||||
case 0xe6:
|
||||
//ret = intE6_handler();
|
||||
ret = 0;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
if (!ret)
|
||||
ret = run_bios_int(emu, num);
|
||||
}
|
||||
|
||||
static int setup_system_bios(void *base_addr)
|
||||
{
|
||||
char *base = (char *) base_addr;
|
||||
int i;
|
||||
/*
|
||||
* we trap the "industry standard entry points" to the BIOS
|
||||
* and all other locations by filling them with "hlt"
|
||||
* TODO: implement hlt-handler for these
|
||||
*/
|
||||
for(i = 0; i < SIZE_EMU + 4; base[i++] = 0xF4);
|
||||
char *base = (char *) base_addr;
|
||||
int i;
|
||||
/*
|
||||
* we trap the "industry standard entry points" to the BIOS
|
||||
* and all other locations by filling them with "hlt"
|
||||
* TODO: implement hlt-handler for these
|
||||
*/
|
||||
for(i = 0; i < SIZE_EMU + 4; base[i++] = 0xF4);
|
||||
|
||||
return(1);
|
||||
return(1);
|
||||
}
|
||||
|
||||
void run_bios(struct radeonfb_info *rinfo)
|
||||
{
|
||||
long i, j;
|
||||
unsigned char *ptr;
|
||||
struct rom_header *rom_header;
|
||||
struct pci_data *rom_data;
|
||||
unsigned long rom_size=0;
|
||||
unsigned long image_size=0;
|
||||
void *biosmem = (void *) 0x0100000; /* when run_bios() is called, SDRAM is valid but not added to the system */
|
||||
unsigned long addr;
|
||||
unsigned short initialcs;
|
||||
unsigned short initialip;
|
||||
unsigned short devfn = (unsigned short) rinfo->handle;
|
||||
long i, j;
|
||||
unsigned char *ptr;
|
||||
struct rom_header *rom_header;
|
||||
struct pci_data *rom_data;
|
||||
unsigned long rom_size=0;
|
||||
unsigned long image_size=0;
|
||||
void *biosmem = (void *) 0x0100000; /* when run_bios() is called, SDRAM is valid but not added to the system */
|
||||
unsigned long addr;
|
||||
unsigned short initialcs;
|
||||
unsigned short initialip;
|
||||
unsigned short devfn = (unsigned short) rinfo->handle;
|
||||
|
||||
struct X86EMU emu;
|
||||
|
||||
X86EMU_init_default(&emu);
|
||||
|
||||
if ((rinfo->mmio_base == NULL) || (rinfo->io_base == NULL))
|
||||
{
|
||||
if ((rinfo->mmio_base == NULL) || (rinfo->io_base == NULL))
|
||||
{
|
||||
dbg("rinfo->mmio_base = %p, rinfo->io_base = %p\r\n", rinfo->mmio_base, rinfo->io_base);
|
||||
return;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
rinfo_biosemu = rinfo;
|
||||
config_address_reg = 0;
|
||||
offset_port = 0x300;
|
||||
offset_io = (uint32_t) rinfo->io_base - (uint32_t) offset_port;
|
||||
offset_mem = (uint32_t) rinfo->fb_base - 0xA0000;
|
||||
rinfo_biosemu = rinfo;
|
||||
config_address_reg = 0;
|
||||
offset_port = 0x300;
|
||||
offset_io = (uint32_t) rinfo->io_base - (uint32_t) offset_port;
|
||||
offset_mem = (uint32_t) rinfo->fb_base - 0xA0000;
|
||||
|
||||
rom_header = NULL;
|
||||
do
|
||||
{
|
||||
rom_header = (struct rom_header *) ((unsigned long) rom_header + image_size); // get next image
|
||||
rom_data = (struct pci_data *) ((unsigned long)rom_header + (unsigned long) BIOS_IN16((long) &rom_header->data));
|
||||
image_size = (unsigned long) BIOS_IN16((long) &rom_data->ilen) * 512;
|
||||
} while ((BIOS_IN8((long) &rom_data->type) != 0) && (BIOS_IN8((long) &rom_data->indicator) != 0)); // make sure we got x86 version
|
||||
rom_header = NULL;
|
||||
do
|
||||
{
|
||||
rom_header = (struct rom_header *) ((unsigned long) rom_header + image_size); // get next image
|
||||
rom_data = (struct pci_data *) ((unsigned long)rom_header + (unsigned long) BIOS_IN16((long) &rom_header->data));
|
||||
image_size = (unsigned long) BIOS_IN16((long) &rom_data->ilen) * 512;
|
||||
} while ((BIOS_IN8((long) &rom_data->type) != 0) && (BIOS_IN8((long) &rom_data->indicator) != 0)); // make sure we got x86 version
|
||||
|
||||
if (BIOS_IN8((long) &rom_data->type) != 0)
|
||||
{
|
||||
dbg("%s: ROM data type = 0x%x\r\n", __FUNCTION__, BIOS_IN8((long) &rom_data->type));
|
||||
return;
|
||||
}
|
||||
if (BIOS_IN8((long) &rom_data->type) != 0)
|
||||
{
|
||||
dbg("%s: ROM data type = 0x%x\r\n", __FUNCTION__, BIOS_IN8((long) &rom_data->type));
|
||||
return;
|
||||
}
|
||||
|
||||
rom_size = (unsigned long) BIOS_IN8((long) &rom_header->size) * 512;
|
||||
rom_size = (unsigned long) BIOS_IN8((long) &rom_header->size) * 512;
|
||||
|
||||
if (PCI_CLASS_DISPLAY_VGA == BIOS_IN16((long) &rom_data->class_hi))
|
||||
{
|
||||
memset((char *) biosmem, 0, SIZE_EMU);
|
||||
setup_system_bios((char *) biosmem);
|
||||
if (PCI_CLASS_DISPLAY_VGA == BIOS_IN16((long) &rom_data->class_hi))
|
||||
{
|
||||
memset((char *) biosmem, 0, SIZE_EMU);
|
||||
setup_system_bios((char *) biosmem);
|
||||
|
||||
dbg("%s: Copying VGA ROM Image from %p to %p (0x%lx bytes)\r\n",
|
||||
__FUNCTION__, (long) rinfo->bios_seg + (long) rom_header,
|
||||
biosmem + PCI_VGA_RAM_IMAGE_START, rom_size);
|
||||
{
|
||||
long bytes_align = (long) rom_header & 3;
|
||||
dbg("%s: Copying VGA ROM Image from %p to %p (0x%lx bytes)\r\n",
|
||||
__FUNCTION__, (long) rinfo->bios_seg + (long) rom_header,
|
||||
biosmem + PCI_VGA_RAM_IMAGE_START, rom_size);
|
||||
{
|
||||
long bytes_align = (long) rom_header & 3;
|
||||
|
||||
ptr = (unsigned char *) biosmem;
|
||||
i = (long) rom_header;
|
||||
j = PCI_VGA_RAM_IMAGE_START;
|
||||
ptr = (unsigned char *) biosmem;
|
||||
i = (long) rom_header;
|
||||
j = PCI_VGA_RAM_IMAGE_START;
|
||||
|
||||
if (bytes_align)
|
||||
for(; i < 4 - bytes_align; ptr[j++] = BIOS_IN8(i++));
|
||||
if (bytes_align)
|
||||
for(; i < 4 - bytes_align; ptr[j++] = BIOS_IN8(i++));
|
||||
|
||||
for(; i < (long) rom_header + rom_size; i += 4, j += 4)
|
||||
*((unsigned long *) &ptr[j]) = swpl(BIOS_IN32(i));
|
||||
}
|
||||
addr = PCI_VGA_RAM_IMAGE_START;
|
||||
}
|
||||
else
|
||||
{
|
||||
memset((char *) biosmem, 0, SIZE_EMU);
|
||||
setup_system_bios((char *) biosmem);
|
||||
for(; i < (long) rom_header + rom_size; i += 4, j += 4)
|
||||
*((unsigned long *) &ptr[j]) = swpl(BIOS_IN32(i));
|
||||
}
|
||||
addr = PCI_VGA_RAM_IMAGE_START;
|
||||
}
|
||||
else
|
||||
{
|
||||
memset((char *) biosmem, 0, SIZE_EMU);
|
||||
setup_system_bios((char *) biosmem);
|
||||
|
||||
dbg("%s: Copying non-VGA ROM Image from %p to %p (0x%lx bytes)\r\n", __FUNCTION__,
|
||||
(long) rinfo->bios_seg + (long) rom_header,
|
||||
biosmem + PCI_RAM_IMAGE_START,
|
||||
rom_size);
|
||||
ptr = (unsigned char *) biosmem;
|
||||
for (i = (long) rom_header, j = PCI_RAM_IMAGE_START; i < (long) rom_header+rom_size; ptr[j++] = BIOS_IN8(i++));
|
||||
addr = PCI_RAM_IMAGE_START;
|
||||
}
|
||||
dbg("%s: Copying non-VGA ROM Image from %p to %p (0x%lx bytes)\r\n", __FUNCTION__,
|
||||
(long) rinfo->bios_seg + (long) rom_header,
|
||||
biosmem + PCI_RAM_IMAGE_START,
|
||||
rom_size);
|
||||
ptr = (unsigned char *) biosmem;
|
||||
for (i = (long) rom_header, j = PCI_RAM_IMAGE_START; i < (long) rom_header+rom_size; ptr[j++] = BIOS_IN8(i++));
|
||||
addr = PCI_RAM_IMAGE_START;
|
||||
}
|
||||
|
||||
initialcs = (addr & 0xF0000) >> 4;
|
||||
initialip = (addr + 3) & 0xFFFF;
|
||||
initialcs = (addr & 0xF0000) >> 4;
|
||||
initialip = (addr + 3) & 0xFFFF;
|
||||
|
||||
/*
|
||||
* set emulator memory
|
||||
@@ -357,61 +357,61 @@ void run_bios(struct radeonfb_info *rinfo)
|
||||
emu.mem_base = (void *) biosmem;
|
||||
emu.mem_size = SIZE_EMU;
|
||||
|
||||
for (i = 0; i < 256; i++)
|
||||
for (i = 0; i < 256; i++)
|
||||
{
|
||||
emu._X86EMU_intrTab[i] = do_int;
|
||||
}
|
||||
|
||||
{
|
||||
char *date = "01/01/99";
|
||||
for (i = 0; date[i]; i++)
|
||||
{
|
||||
char *date = "01/01/99";
|
||||
for (i = 0; date[i]; i++)
|
||||
emu.emu_wrb(&emu, 0xffff5 + i, date[i]);
|
||||
emu.emu_wrb(&emu, 0xffff7, '/');
|
||||
emu.emu_wrb(&emu, 0xffffa, '/');
|
||||
}
|
||||
{
|
||||
/* FixME: move PIT init to its own file */
|
||||
outb(0x36, 0x43);
|
||||
outb(0x00, 0x40);
|
||||
outb(0x00, 0x40);
|
||||
}
|
||||
// setup_int_vect();
|
||||
}
|
||||
{
|
||||
/* FixME: move PIT init to its own file */
|
||||
outb(0x36, 0x43);
|
||||
outb(0x00, 0x40);
|
||||
outb(0x00, 0x40);
|
||||
}
|
||||
// setup_int_vect();
|
||||
|
||||
/* cpu setup */
|
||||
/* cpu setup */
|
||||
emu.x86.R_AX = devfn ? devfn : 0xff;
|
||||
emu.x86.R_DX = 0x80;
|
||||
emu.x86.R_EIP = initialip;
|
||||
emu.x86.R_CS = initialcs;
|
||||
|
||||
/* Initialize stack and data segment */
|
||||
/* Initialize stack and data segment */
|
||||
emu.x86.R_SS = initialcs;
|
||||
emu.x86.R_SP = 0xfffe;
|
||||
emu.x86.R_DS = 0x0040;
|
||||
emu.x86.R_ES = 0x0000;
|
||||
|
||||
/*
|
||||
* We need a sane way to return from bios
|
||||
* execution. A hlt instruction and a pointer
|
||||
* to it, both kept on the stack, will do.
|
||||
*/
|
||||
/*
|
||||
* We need a sane way to return from bios
|
||||
* execution. A hlt instruction and a pointer
|
||||
* to it, both kept on the stack, will do.
|
||||
*/
|
||||
pushw(&emu, 0xf4f4); /* hlt; hlt */
|
||||
|
||||
// pushw(0x10cd); /* int #0x10 */
|
||||
// pushw(0x0013); /* 320 x 200 x 256 colors */
|
||||
// // pushw(0x000F); /* 640 x 350 x mono */
|
||||
// pushw(0xb890); /* nop, mov ax,#0x13 */
|
||||
// pushw(0x10cd); /* int #0x10 */
|
||||
// pushw(0x0013); /* 320 x 200 x 256 colors */
|
||||
// // pushw(0x000F); /* 640 x 350 x mono */
|
||||
// pushw(0xb890); /* nop, mov ax,#0x13 */
|
||||
pushw(&emu, emu.x86.R_SS);
|
||||
pushw(&emu, emu.x86.R_SP + 2);
|
||||
#ifdef DBG_X86EMU
|
||||
X86EMU_trace_on();
|
||||
X86EMU_set_debug(DEBUG_DECODE_F | DEBUG_TRACE_F);
|
||||
X86EMU_trace_on();
|
||||
X86EMU_set_debug(DEBUG_DECODE_F | DEBUG_TRACE_F);
|
||||
#endif
|
||||
|
||||
dbg("%s: X86EMU entering emulator\r\n", __FUNCTION__);
|
||||
//*vblsem = 0;
|
||||
dbg("%s: X86EMU entering emulator\r\n", __FUNCTION__);
|
||||
//*vblsem = 0;
|
||||
X86EMU_exec(&emu);
|
||||
//*vblsem = 1;
|
||||
dbg("%s: X86EMU halted\r\n", __FUNCTION__);
|
||||
// biosfn_set_video_mode(0x13); /* 320 x 200 x 256 colors */
|
||||
memset((char *) biosmem, 0, SIZE_EMU);
|
||||
//*vblsem = 1;
|
||||
dbg("%s: X86EMU halted\r\n", __FUNCTION__);
|
||||
// biosfn_set_video_mode(0x13); /* 320 x 200 x 256 colors */
|
||||
memset((char *) biosmem, 0, SIZE_EMU);
|
||||
}
|
||||
|
||||
+4918
-4918
File diff suppressed because it is too large
Load Diff
+65
-65
@@ -17,12 +17,12 @@ extern unsigned short offset_port;
|
||||
|
||||
int x86_pcibios_handler(struct X86EMU *emu)
|
||||
{
|
||||
int ret = 0;
|
||||
unsigned long dev;
|
||||
int ret = 0;
|
||||
unsigned long dev;
|
||||
|
||||
switch (emu->x86.R_AX)
|
||||
{
|
||||
case PCI_BIOS_PRESENT:
|
||||
{
|
||||
case PCI_BIOS_PRESENT:
|
||||
dbg("PCI_BIOS_PRESENT\r\n");
|
||||
emu->x86.R_AH = 0x00; /* no config space/special cycle support */
|
||||
emu->x86.R_AL = 0x01; /* config mechanism 1 */
|
||||
@@ -30,147 +30,147 @@ int x86_pcibios_handler(struct X86EMU *emu)
|
||||
emu->x86.R_EBX = 0x0210; /* Version 2.10 */
|
||||
emu->x86.R_ECX = 0xFF00; /* FixME: Max bus number */
|
||||
emu->x86.R_EFLG &= ~FB_CF; /* clear carry flag */
|
||||
ret = 1;
|
||||
break;
|
||||
ret = 1;
|
||||
break;
|
||||
|
||||
case FIND_PCI_DEVICE:
|
||||
case FIND_PCI_DEVICE:
|
||||
dbg("FIND_PCI_DEVICE vendor = %04x, device = %04x\r\n", emu->x86.R_DX, emu->x86.R_CX);
|
||||
dev = pci_find_device((unsigned long) emu->x86.R_DX, ((unsigned long) emu->x86.R_CX), 0);
|
||||
|
||||
if (dev != 0)
|
||||
{
|
||||
if (dev != 0)
|
||||
{
|
||||
dbg("dev = %d\r\n", dev);
|
||||
emu->x86.R_BH = PCI_BUS_FROM_HANDLE(dev);
|
||||
//X86_BH = (char)(dev >> 16) / PCI_MAX_FUNCTION); // dev->bus->secondary;
|
||||
//X86_BH = (char)(dev >> 16) / PCI_MAX_FUNCTION); // dev->bus->secondary;
|
||||
emu->x86.R_BL = PCI_DEVICE_FROM_HANDLE(dev) << 3 | PCI_FUNCTION_FROM_HANDLE(dev);
|
||||
//X86_BL = (char)dev; // dev->path.u.pci.devfn;
|
||||
//X86_BL = (char)dev; // dev->path.u.pci.devfn;
|
||||
emu->x86.R_AH = SUCCESSFUL;
|
||||
emu->x86.R_EFLG &= ~FB_CF; /* clear carry flag */
|
||||
ret = 1;
|
||||
ret = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
dbg("device not found\r\n");
|
||||
emu->x86.R_AH = DEVICE_NOT_FOUND;
|
||||
emu->x86.R_EFLG |= FB_CF; /* set carry flag */
|
||||
ret = 0;
|
||||
}
|
||||
break;
|
||||
ret = 0;
|
||||
}
|
||||
break;
|
||||
|
||||
case FIND_PCI_CLASS_CODE:
|
||||
/* FixME: support SI != 0 */
|
||||
case FIND_PCI_CLASS_CODE:
|
||||
/* FixME: support SI != 0 */
|
||||
dbg("FIND_PCI_CLASS_CODE %x", emu->x86.R_ECX);
|
||||
dev = pci_find_classcode(emu->x86.R_ECX, 0);
|
||||
if (dev != 0) {
|
||||
if (dev != 0) {
|
||||
dbg(" ...OK\r\n");
|
||||
emu->x86.R_BH = PCI_BUS_FROM_HANDLE(dev);
|
||||
emu->x86.R_BL = PCI_DEVICE_FROM_HANDLE(dev) << 3 | PCI_FUNCTION_FROM_HANDLE(dev);
|
||||
emu->x86.R_AH = SUCCESSFUL;
|
||||
emu->x86.R_EFLG &= ~FB_CF; /* clear carry flag */
|
||||
ret = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
ret = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
dbg(" ... error\r\n");
|
||||
emu->x86.R_AH = DEVICE_NOT_FOUND;
|
||||
emu->x86.R_EFLG |= FB_CF; /* set carry flag */
|
||||
ret = 0;
|
||||
}
|
||||
break;
|
||||
ret = 0;
|
||||
}
|
||||
break;
|
||||
|
||||
case READ_CONFIG_BYTE:
|
||||
// bus, devfn
|
||||
case READ_CONFIG_BYTE:
|
||||
// bus, devfn
|
||||
dbg("READ_CONFIG_BYTE bus = %x, devfn = %x, reg = %x\r\n", emu->x86.R_BH, emu->x86.R_BL, emu->x86.R_DI);
|
||||
dev = PCI_HANDLE(emu->x86.R_BH, emu->x86.R_BL >> 3, emu->x86.R_BL & 3);
|
||||
emu->x86.R_CL = pci_read_config_byte(dev, emu->x86.R_DI);
|
||||
dbg("value = %x\r\n", emu->x86.R_CL);
|
||||
emu->x86.R_AH = SUCCESSFUL;
|
||||
emu->x86.R_EFLG &= ~FB_CF; /* clear carry flag */
|
||||
ret = 1;
|
||||
break;
|
||||
ret = 1;
|
||||
break;
|
||||
|
||||
case READ_CONFIG_WORD:
|
||||
// bus, devfn
|
||||
case READ_CONFIG_WORD:
|
||||
// bus, devfn
|
||||
dbg("READ_CONFIG_WORD bus = %x, devfn = %x, reg = %x\r\n", emu->x86.R_BH, emu->x86.R_BL, emu->x86.R_DI);
|
||||
dev = PCI_HANDLE(emu->x86.R_BH, emu->x86.R_BL >> 3, emu->x86.R_BL & 3);
|
||||
if (emu->x86.R_DI == PCIBAR1)
|
||||
emu->x86.R_CX = offset_port + 1;
|
||||
else
|
||||
else
|
||||
emu->x86.R_CX = pci_read_config_word(dev, emu->x86.R_DI);
|
||||
dbg("value = %x\r\n", emu->x86.R_CX);
|
||||
emu->x86.R_AH = SUCCESSFUL;
|
||||
emu->x86.R_EFLG &= ~FB_CF; /* clear carry flag */
|
||||
ret = 1;
|
||||
break;
|
||||
ret = 1;
|
||||
break;
|
||||
|
||||
case READ_CONFIG_DWORD:
|
||||
// bus, devfn
|
||||
case READ_CONFIG_DWORD:
|
||||
// bus, devfn
|
||||
dbg("READ_CONFIG_DWORD bus = %x, devfn = %x, reg = %x\r\n", emu->x86.R_BH, emu->x86.R_BL, emu->x86.R_DI);
|
||||
dev = PCI_HANDLE(emu->x86.R_BH, emu->x86.R_BL >> 3, emu->x86.R_BL & 3);
|
||||
if (emu->x86.R_DI == PCIBAR1)
|
||||
emu->x86.R_CX = (unsigned long) offset_port + 1;
|
||||
else
|
||||
else
|
||||
emu->x86.R_ECX = pci_read_config_longword(dev, emu->x86.R_DI);
|
||||
dbg("value = %x\r\n", emu->x86.R_ECX);
|
||||
emu->x86.R_AH = SUCCESSFUL;
|
||||
emu->x86.R_EFLG &= ~FB_CF; /* clear carry flag */
|
||||
ret = 1;
|
||||
break;
|
||||
ret = 1;
|
||||
break;
|
||||
|
||||
case WRITE_CONFIG_BYTE:
|
||||
// bus, devfn
|
||||
case WRITE_CONFIG_BYTE:
|
||||
// bus, devfn
|
||||
dbg("READ_CONFIG_BYTE bus = %x, devfn = %x, reg = %x, value = %x\r\n",
|
||||
emu->x86.R_BH, emu->x86.R_BL, emu->x86.R_DI, emu->x86.R_CL);
|
||||
emu->x86.R_BH, emu->x86.R_BL, emu->x86.R_DI, emu->x86.R_CL);
|
||||
dev = PCI_HANDLE(emu->x86.R_BH, emu->x86.R_BL >> 3, emu->x86.R_BL & 3);
|
||||
pci_write_config_byte(dev, emu->x86.R_DI, emu->x86.R_CL);
|
||||
emu->x86.R_AH = SUCCESSFUL;
|
||||
emu->x86.R_EFLG &= ~FB_CF; /* clear carry flag */
|
||||
ret = 1;
|
||||
break;
|
||||
ret = 1;
|
||||
break;
|
||||
|
||||
case WRITE_CONFIG_WORD:
|
||||
// bus, devfn
|
||||
case WRITE_CONFIG_WORD:
|
||||
// bus, devfn
|
||||
dev = PCI_HANDLE(emu->x86.R_BH, emu->x86.R_BL >> 3, emu->x86.R_BL & 3);
|
||||
dbg("WRITE_CONFIG_WORD bus = %x, devfn = %x, reg = %x, value = %x\r\n", emu->x86.R_BH, emu->x86.R_BL, emu->x86.R_DI, emu->x86.R_CX);
|
||||
if (emu->x86.R_DI == PCIBAR1)
|
||||
{
|
||||
{
|
||||
offset_port = emu->x86.R_CX;
|
||||
emu->x86.R_AH = SUCCESSFUL;
|
||||
emu->x86.R_EFLG &= ~FB_CF; /* clear carry flag */
|
||||
ret = 1;
|
||||
break;
|
||||
}
|
||||
ret = 1;
|
||||
break;
|
||||
}
|
||||
pci_write_config_word(dev, emu->x86.R_DI, emu->x86.R_CX);
|
||||
emu->x86.R_AH = SUCCESSFUL;
|
||||
emu->x86.R_EFLG &= ~FB_CF; /* clear carry flag */
|
||||
ret = 1;
|
||||
break;
|
||||
ret = 1;
|
||||
break;
|
||||
|
||||
case WRITE_CONFIG_DWORD:
|
||||
// bus, devfn
|
||||
case WRITE_CONFIG_DWORD:
|
||||
// bus, devfn
|
||||
dev = PCI_HANDLE(emu->x86.R_BH, emu->x86.R_BL >> 3, emu->x86.R_BL & 3);
|
||||
dbg("WRITE_CONFIG_DWORD bus = %x, devfn = %x, value = %x\r\n",
|
||||
emu->x86.R_BH, emu->x86.R_BL, emu->x86.R_DI, emu->x86.R_ECX);
|
||||
emu->x86.R_BH, emu->x86.R_BL, emu->x86.R_DI, emu->x86.R_ECX);
|
||||
if (emu->x86.R_DI == PCIBAR1)
|
||||
{
|
||||
{
|
||||
offset_port = (unsigned short) emu->x86.R_ECX & 0xFFFC;
|
||||
emu->x86.R_AH = SUCCESSFUL;
|
||||
emu->x86.R_EFLG &= ~FB_CF; /* clear carry flag */
|
||||
ret = 1;
|
||||
break;
|
||||
}
|
||||
ret = 1;
|
||||
break;
|
||||
}
|
||||
pci_write_config_longword(dev, emu->x86.R_DI, emu->x86.R_ECX);
|
||||
emu->x86.R_AH = SUCCESSFUL;
|
||||
emu->x86.R_EFLG &= ~FB_CF; /* clear carry flag */
|
||||
ret = 1;
|
||||
break;
|
||||
ret = 1;
|
||||
break;
|
||||
|
||||
default:
|
||||
default:
|
||||
dbg("PCI_BIOS FUNC_NOT_SUPPORTED\r\n");
|
||||
emu->x86.R_AH = FUNC_NOT_SUPPORTED;
|
||||
emu->x86.R_EFLG |= FB_CF;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
return ret;
|
||||
return ret;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user