static int builtin_input_id(struct udev_device *dev, int argc, char *argv[], bool test)
{
struct udev_device *pdev;
unsigned long bitmask_ev[NBITS(EV_MAX)];
unsigned long bitmask_abs[NBITS(ABS_MAX)];
unsigned long bitmask_key[NBITS(KEY_MAX)];
unsigned long bitmask_rel[NBITS(REL_MAX)];
/* walk up the parental chain until we find the real input device; the
* argument is very likely a subdevice of this, like eventN */
pdev = dev;
while (pdev != NULL && udev_device_get_sysattr_value(pdev, "capabilities/ev") == NULL)
pdev = udev_device_get_parent_with_subsystem_devtype(pdev, "input", NULL);
/* not an "input" class device */
if (pdev == NULL)
return EXIT_SUCCESS;
/* Use this as a flag that input devices were detected, so that this
* program doesn't need to be called more than once per device */
udev_builtin_add_property(dev, test, "ID_INPUT", "1");
get_cap_mask(dev, pdev, "capabilities/ev", bitmask_ev, sizeof(bitmask_ev), test);
get_cap_mask(dev, pdev, "capabilities/abs", bitmask_abs, sizeof(bitmask_abs), test);
get_cap_mask(dev, pdev, "capabilities/rel", bitmask_rel, sizeof(bitmask_rel), test);
get_cap_mask(dev, pdev, "capabilities/key", bitmask_key, sizeof(bitmask_key), test);
test_pointers(dev, bitmask_ev, bitmask_abs, bitmask_key, bitmask_rel, test);
test_key(dev, bitmask_ev, bitmask_key, test);
return EXIT_SUCCESS;
}
static int
IsJoystick(int fd, char *namebuf, const size_t namebuflen, SDL_JoystickGUID *guid)
{
struct input_id inpid;
Uint16 *guid16 = (Uint16 *) ((char *) &guid->data);
#if !SDL_USE_LIBUDEV
/* When udev is enabled we only get joystick devices here, so there's no need to test them */
unsigned long evbit[NBITS(EV_MAX)] = { 0 };
unsigned long keybit[NBITS(KEY_MAX)] = { 0 };
unsigned long absbit[NBITS(ABS_MAX)] = { 0 };
if ((ioctl(fd, EVIOCGBIT(0, sizeof(evbit)), evbit) < 0) ||
(ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(keybit)), keybit) < 0) ||
(ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(absbit)), absbit) < 0)) {
return (0);
}
if (!(test_bit(EV_KEY, evbit) && test_bit(EV_ABS, evbit) &&
test_bit(ABS_X, absbit) && test_bit(ABS_Y, absbit))) {
return 0;
}
#endif
if (ioctl(fd, EVIOCGNAME(namebuflen), namebuf) < 0) {
return 0;
}
if (ioctl(fd, EVIOCGID, &inpid) < 0) {
return 0;
}
#ifdef DEBUG_JOYSTICK
printf("Joystick: %s, bustype = %d, vendor = 0x%x, product = 0x%x, version = %d\n", namebuf, inpid.bustype, inpid.vendor, inpid.product, inpid.version);
#endif
SDL_memset(guid->data, 0, sizeof(guid->data));
/* We only need 16 bits for each of these; space them out to fill 128. */
/* Byteswap so devices get same GUID on little/big endian platforms. */
*(guid16++) = SDL_SwapLE16(inpid.bustype);
*(guid16++) = 0;
if (inpid.vendor && inpid.product && inpid.version) {
*(guid16++) = SDL_SwapLE16(inpid.vendor);
*(guid16++) = 0;
*(guid16++) = SDL_SwapLE16(inpid.product);
*(guid16++) = 0;
*(guid16++) = SDL_SwapLE16(inpid.version);
*(guid16++) = 0;
} else {
SDL_strlcpy((char*)guid16, namebuf, sizeof(guid->data) - 4);
}
return 1;
}
void JoypadLinux::setup_joypad_properties(int p_id) {
Joypad *joy = &joypads[p_id];
unsigned long keybit[NBITS(KEY_MAX)] = { 0 };
unsigned long absbit[NBITS(ABS_MAX)] = { 0 };
int num_buttons = 0;
int num_axes = 0;
if ((ioctl(joy->fd, EVIOCGBIT(EV_KEY, sizeof(keybit)), keybit) < 0) ||
(ioctl(joy->fd, EVIOCGBIT(EV_ABS, sizeof(absbit)), absbit) < 0)) {
return;
}
for (int i = BTN_JOYSTICK; i < KEY_MAX; ++i) {
if (test_bit(i, keybit)) {
joy->key_map[i] = num_buttons++;
}
}
for (int i = BTN_MISC; i < BTN_JOYSTICK; ++i) {
if (test_bit(i, keybit)) {
joy->key_map[i] = num_buttons++;
}
}
for (int i = 0; i < ABS_MISC; ++i) {
/* Skip hats */
if (i == ABS_HAT0X) {
i = ABS_HAT3Y;
continue;
}
if (test_bit(i, absbit)) {
joy->abs_map[i] = num_axes++;
joy->abs_info[i] = memnew(input_absinfo);
if (ioctl(joy->fd, EVIOCGABS(i), joy->abs_info[i]) < 0) {
memdelete(joy->abs_info[i]);
joy->abs_info[i] = NULL;
}
}
}
joy->force_feedback = false;
joy->ff_effect_timestamp = 0;
unsigned long ffbit[NBITS(FF_CNT)];
if (ioctl(joy->fd, EVIOCGBIT(EV_FF, sizeof(ffbit)), ffbit) != -1) {
if (test_bit(FF_RUMBLE, ffbit)) {
joy->force_feedback = true;
}
}
}
int main (int argc, char** argv)
{
struct udev *udev;
struct udev_device *dev;
char devpath[PATH_MAX];
unsigned long bitmask_ev[NBITS(EV_MAX)];
unsigned long bitmask_abs[NBITS(ABS_MAX)];
unsigned long bitmask_key[NBITS(KEY_MAX)];
unsigned long bitmask_rel[NBITS(REL_MAX)];
if (argc != 2) {
fprintf(stderr, "Usage: %s <device path (without /sys)>\n", argv[0]);
exit(1);
}
/* get the device */
udev = udev_new();
if (udev == NULL)
return 1;
snprintf(devpath, sizeof(devpath), "%s/%s", udev_get_sys_path(udev), argv[1]);
dev = udev_device_new_from_syspath(udev, devpath);
if (dev == NULL) {
fprintf(stderr, "unable to access '%s'\n", devpath);
return 1;
}
/* walk up the parental chain until we find the real input device; the
* argument is very likely a subdevice of this, like eventN */
while (dev != NULL && udev_device_get_sysattr_value(dev, "capabilities/ev") == NULL)
dev = udev_device_get_parent_with_subsystem_devtype(dev, "input", NULL);
/* not an "input" class device */
if (dev == NULL)
return 0;
/* Use this as a flag that input devices were detected, so that this
* program doesn't need to be called more than once per device */
puts("ID_INPUT=1");
get_cap_mask (dev, "capabilities/ev", bitmask_ev, sizeof (bitmask_ev));
get_cap_mask (dev, "capabilities/abs", bitmask_abs, sizeof (bitmask_abs));
get_cap_mask (dev, "capabilities/rel", bitmask_rel, sizeof (bitmask_rel));
get_cap_mask (dev, "capabilities/key", bitmask_key, sizeof (bitmask_key));
test_pointers(bitmask_ev, bitmask_abs, bitmask_key, bitmask_rel);
test_key(bitmask_ev, bitmask_key);
return 0;
}
int
chantodepth(ulong c)
{
int n;
for(n=0; c; c>>=8){
if(TYPE(c) >= NChan || NBITS(c) > 8 || NBITS(c) <= 0)
return 0;
n += NBITS(c);
}
if(n==0 || (n>8 && n%8) || (n<8 && 8%n))
return 0;
return n;
}
static int builtin_input_id(struct udev_device *dev, int argc, char *argv[], bool test) {
struct udev_device *pdev;
unsigned long bitmask_ev[NBITS(EV_MAX)];
unsigned long bitmask_abs[NBITS(ABS_MAX)];
unsigned long bitmask_key[NBITS(KEY_MAX)];
unsigned long bitmask_rel[NBITS(REL_MAX)];
unsigned long bitmask_props[NBITS(INPUT_PROP_MAX)];
const char *sysname, *devnode;
bool is_pointer;
bool is_key;
assert(dev);
/* walk up the parental chain until we find the real input device; the
* argument is very likely a subdevice of this, like eventN */
pdev = dev;
while (pdev != NULL && udev_device_get_sysattr_value(pdev, "capabilities/ev") == NULL)
pdev = udev_device_get_parent_with_subsystem_devtype(pdev, "input", NULL);
if (pdev) {
/* Use this as a flag that input devices were detected, so that this
* program doesn't need to be called more than once per device */
udev_builtin_add_property(dev, test, "ID_INPUT", "1");
get_cap_mask(dev, pdev, "capabilities/ev", bitmask_ev, sizeof(bitmask_ev), test);
get_cap_mask(dev, pdev, "capabilities/abs", bitmask_abs, sizeof(bitmask_abs), test);
get_cap_mask(dev, pdev, "capabilities/rel", bitmask_rel, sizeof(bitmask_rel), test);
get_cap_mask(dev, pdev, "capabilities/key", bitmask_key, sizeof(bitmask_key), test);
get_cap_mask(dev, pdev, "properties", bitmask_props, sizeof(bitmask_props), test);
is_pointer = test_pointers(dev, bitmask_ev, bitmask_abs,
bitmask_key, bitmask_rel,
bitmask_props, test);
is_key = test_key(dev, bitmask_ev, bitmask_key, test);
/* Some evdev nodes have only a scrollwheel */
if (!is_pointer && !is_key && test_bit(EV_REL, bitmask_ev) &&
(test_bit(REL_WHEEL, bitmask_rel) || test_bit(REL_HWHEEL, bitmask_rel)))
udev_builtin_add_property(dev, test, "ID_INPUT_KEY", "1");
if (test_bit(EV_SW, bitmask_ev))
udev_builtin_add_property(dev, test, "ID_INPUT_SWITCH", "1");
}
devnode = udev_device_get_devnode(dev);
sysname = udev_device_get_sysname(dev);
if (devnode && sysname && startswith(sysname, "event"))
extract_info(dev, devnode, test);
return EXIT_SUCCESS;
}
char*
chantostr(char *buf, ulong cc)
{
ulong c, rc;
char *p;
if(chantodepth(cc) == 0)
return nil;
/* reverse the channel descriptor so we can easily generate the string in the right order */
rc = 0;
for(c=cc; c; c>>=8){
rc <<= 8;
rc |= c&0xFF;
}
p = buf;
for(c=rc; c; c>>=8) {
*p++ = channames[TYPE(c)];
*p++ = '0'+NBITS(c);
}
*p = 0;
return buf;
}
// Check for EV_REL (REL_X and REL_Y) and, because touchscreens can have those too,
// check also for EV_KEY (BTN_LEFT and BTN_RIGHT)
static void check_mouse(int fd)
{
if (has_mouse) {
return;
}
unsigned long bit[EV_MAX][NBITS(KEY_MAX)];
memset(bit, 0, sizeof(bit));
ioctl(fd, EVIOCGBIT(0, EV_MAX), bit[0]);
if (!test_bit(EV_REL, bit[0]) || !test_bit(EV_KEY, bit[0])) {
return;
}
ioctl(fd, EVIOCGBIT(EV_REL, KEY_MAX), bit[EV_REL]);
if (!test_bit(REL_X, bit[EV_REL]) || !test_bit(REL_Y, bit[EV_REL])) {
return;
}
ioctl(fd, EVIOCGBIT(EV_KEY, KEY_MAX), bit[EV_KEY]);
if (!test_bit(BTN_LEFT, bit[EV_KEY]) || !test_bit(BTN_RIGHT, bit[EV_KEY])) {
return;
}
has_mouse = 1;
}
void InputEventSystem::getTouchBounds(int fd)
{
unsigned long bits[NBITS(KEY_MAX)];
struct input_absinfo abs;
ioctl (fd, EVIOCGBIT (EV_ABS, KEY_MAX), bits);
if (!(test_bit (ABS_MT_POSITION_X, bits) &&
test_bit (ABS_MT_POSITION_Y, bits)))
{
DOUT("absolute events");
ioctl (fd, EVIOCGABS (ABS_X), &abs);
minX = abs.minimum;
maxX = abs.maximum;
ioctl (fd, EVIOCGABS (ABS_Y), &abs);
minY = abs.minimum;
maxY = abs.maximum;
DOUT("NO multitouch");
}
else
{
DOUT("absolute multitouch events");
ioctl (fd, EVIOCGABS (ABS_MT_POSITION_X), &abs);
minX = abs.minimum;
maxX = abs.maximum;
ioctl (fd, EVIOCGABS (ABS_MT_POSITION_Y), &abs);
minY = abs.minimum;
maxY = abs.maximum;
DOUT("HAS multitouch");
}
dx = maxX - minX;
dy = maxY - minY;
}
int openfd(void)
{
int fd;
const char *dirname = "/dev/input";
DIR *dir;
if ((dir = opendir(dirname))) {
struct dirent *de;
unsigned long caps[NBITS(SW_TABLET_MODE+1)];
while ((de = readdir(dir))) {
if (de->d_name[0] != 'e') // eventX
continue;
char name[PATH_MAX];
snprintf(name, PATH_MAX, "%s/%s", dirname, de->d_name);
fd = open(name, O_RDONLY);
if (fd < 0) {
ALOGE("could not open %s, %s", name, strerror(errno));
continue;
}
memset(caps, 0, sizeof(caps));
if (ioctl(fd, EVIOCGBIT(EV_SW, sizeof(caps)), caps) < 1) {
ALOGE("could not get device caps for %s, %s\n", name, strerror(errno));
continue;
}
if (test_bit(SW_TABLET_MODE, caps)) {
ALOGI("open %s(%s) ok", de->d_name, name);
return fd;
}
close(fd);
}
closedir(dir);
}
return -1;
}
/*
* set_resolution_params()
*
* Due to usage of multiple display related APIs resolution data is located in
* more than one place. This function updates them all.
*/
static void set_resolution_params(int x, int y)
{
panel_cfg.lcd_size = PANEL_LCD_SIZE(x, y);
panel_info.vl_col = x;
panel_info.vl_row = y;
lcd_line_length = (panel_info.vl_col * NBITS(panel_info.vl_bpix)) / 8;
}
static int EV_IsJoystick(int fd)
{
unsigned long evbit[NBITS(EV_MAX)] = { 0 };
unsigned long keybit[NBITS(KEY_MAX)] = { 0 };
unsigned long absbit[NBITS(ABS_MAX)] = { 0 };
if ( (ioctl(fd, EVIOCGBIT(0, sizeof(evbit)), evbit) < 0) ||
(ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(keybit)), keybit) < 0) ||
(ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(absbit)), absbit) < 0) ) {
return(0);
}
if (!(test_bit(EV_KEY, evbit) && test_bit(EV_ABS, evbit) &&
test_bit(ABS_X, absbit) && test_bit(ABS_Y, absbit) &&
(test_bit(BTN_TRIGGER, keybit) || test_bit(BTN_A, keybit) || test_bit(BTN_1, keybit)))) return 0;
return(1);
}
static int print_device_info(int fd) {
int i, j;
int version;
unsigned short id[4];
unsigned long bit[EV_MAX][NBITS(KEY_MAX)];
if (ioctl(fd, EVIOCGVERSION, &version)) {
perror("can't get version");
return 1;
}
printf("Input driver version is %d.%d.%d\n",
version >> 16, (version >> 8) & 0xff, version & 0xff);
ioctl(fd, EVIOCGID, id);
printf("Input device ID: bus 0x%x vendor 0x%x product 0x%x version 0x%x\n",
id[ID_BUS], id[ID_VENDOR], id[ID_PRODUCT], id[ID_VERSION]);
memset(bit, 0, sizeof(bit));
ioctl(fd, EVIOCGBIT(0, EV_MAX), bit[0]);
printf("Supported events:\n");
for (i = 0; i < EV_MAX; i++) {
if (test_bit(i, bit[0])) {
printf(" Event type %d\n", i);
if (!i) continue;
ioctl(fd, EVIOCGBIT(i, KEY_MAX), bit[i]);
for (j = 0; j < KEY_MAX; j++) {
if (test_bit(j, bit[i])) {
printf("%d, ", j);
}
}
printf("\n");
}
}
return 0;
}
static int pxafb_init_mem (void *lcdbase, vidinfo_t *vid)
{
u_long palette_mem_size;
struct pxafb_info *fbi = &vid->pxa;
int fb_size = vid->vl_row * (vid->vl_col * NBITS (vid->vl_bpix)) / 8;
fbi->screen = (u_long)lcdbase;
fbi->palette_size = NBITS(vid->vl_bpix) == 8 ? 256 : 16;
palette_mem_size = fbi->palette_size * sizeof(u16);
debug("palette_mem_size = 0x%08lx\n", (u_long) palette_mem_size);
/* locate palette and descs at end of page following fb */
fbi->palette = (u_long)lcdbase + fb_size + PAGE_SIZE - palette_mem_size;
return 0;
}
int epdc_ctrl_init(void *lcdbase)
{
/*
* We rely on lcdbase being a physical address, i.e., either MMU off,
* or 1-to-1 mapping. Might want to add some virt2phys here.
*/
if (!lcdbase)
return -1;
eink_color_fg = 0xFF;
eink_color_bg = 0xFF;
/* Reset */
REG_SET(EPDC_BASE, EPDC_CTRL, EPDC_CTRL_SFTRST);
while (!(REG_RD(EPDC_BASE, EPDC_CTRL) & EPDC_CTRL_CLKGATE))
;
REG_CLR(EPDC_BASE, EPDC_CTRL, EPDC_CTRL_SFTRST);
/* Enable clock gating (clear to enable) */
REG_CLR(EPDC_BASE, EPDC_CTRL, EPDC_CTRL_CLKGATE);
while (REG_RD(EPDC_BASE, EPDC_CTRL) &
(EPDC_CTRL_SFTRST | EPDC_CTRL_CLKGATE))
;
debug("resolution %dx%d, bpp %d\n", (int)panel_info.vl_col,
(int)panel_info.vl_row, NBITS(panel_info.vl_bpix));
/* Set framebuffer pointer */
REG_WR(EPDC_BASE, EPDC_UPD_ADDR, (u32)lcdbase);
#if 0
/* Set Working Buffer pointer */
REG_WR(EPDC_BASE, EPDC_WB_ADDR, panel_info.epdc_data.working_buf_addr);
/* Set Waveform Buffer pointer */
REG_WR(EPDC_BASE, EPDC_WVADDR, panel_info.epdc_data.waveform_buf_addr);
#endif
/* Set waveform and working buffer, they will be changed later */
REG_WR(EPDC_BASE, EPDC_WVADDR, (unsigned long)CONFIG_TEMP_INIT_WAVEFORM_ADDR);
REG_WR(EPDC_BASE, EPDC_WB_ADDR, (unsigned long)CONFIG_WORKING_BUF_ADDR);
#if 0
/* Get waveform data address and offset */
int data_offs = setup_waveform_file();
if(data_offs == -1) {
printf("Can't load waveform data!\n");
return -1;
}
#endif
/* Initialize EPDC, passing pointer to EPDC registers */
epdc_init_settings();
epdc_initialized = 1;
return;
}
void joystick_linux::setup_joystick_properties(int p_id) {
Joystick* joy = &joysticks[p_id];
unsigned long keybit[NBITS(KEY_MAX)] = { 0 };
unsigned long absbit[NBITS(ABS_MAX)] = { 0 };
int num_buttons = 0;
int num_axes = 0;
if ((ioctl(joy->fd, EVIOCGBIT(EV_KEY, sizeof(keybit)), keybit) < 0) ||
(ioctl(joy->fd, EVIOCGBIT(EV_ABS, sizeof(absbit)), absbit) < 0)) {
return;
}
for (int i = BTN_JOYSTICK; i < KEY_MAX; ++i) {
if (test_bit(i, keybit)) {
joy->key_map[i] = num_buttons++;
}
}
for (int i = BTN_MISC; i < BTN_JOYSTICK; ++i) {
if (test_bit(i, keybit)) {
joy->key_map[i] = num_buttons++;
}
}
for (int i = 0; i < ABS_MISC; ++i) {
/* Skip hats */
if (i == ABS_HAT0X) {
i = ABS_HAT3Y;
continue;
}
if (test_bit(i, absbit)) {
joy->abs_map[i] = num_axes++;
joy->abs_info[i] = memnew(input_absinfo);
if (ioctl(joy->fd, EVIOCGABS(i), joy->abs_info[i]) < 0) {
memdelete(joy->abs_info[i]);
joy->abs_info[i] = NULL;
}
}
}
}
/*
* Calculate fb size for VIDEOLFB_ATAG.
*/
ulong calc_fbsize (void)
{
ulong size;
int line_length = (panel_info.vl_col * NBITS (panel_info.vl_bpix)) / 8;
size = line_length * panel_info.vl_row;
return size;
}
static void jz_lcd_desc_init(vidinfo_t *vid)
{
struct jz_fb_info * fbi;
fbi = &vid->jz_fb;
fbi->dmadesc_fblow = (struct jz_fb_dma_descriptor *)((unsigned int)fbi->palette - 3*32);
fbi->dmadesc_fbhigh = (struct jz_fb_dma_descriptor *)((unsigned int)fbi->palette - 2*32);
fbi->dmadesc_palette = (struct jz_fb_dma_descriptor *)((unsigned int)fbi->palette - 1*32);
// #define BYTES_PER_PANEL (vid->vl_col * vid->vl_row * NBITS(vid->vl_bpix) / 8)
#define BYTES_PER_PANEL (((vid->vl_col * NBITS(vid->vl_bpix) / 8 + 3) >> 2 << 2) * vid->vl_row)
/* populate descriptors */
fbi->dmadesc_fblow->fdadr = virt_to_phys(fbi->dmadesc_fblow);
fbi->dmadesc_fblow->fsadr = virt_to_phys((void *)(fbi->screen + BYTES_PER_PANEL));
fbi->dmadesc_fblow->fidr = 1;
fbi->dmadesc_fblow->ldcmd = BYTES_PER_PANEL / 4 ;
fbi->dmadesc_fblow->offsize = 0;
fbi->dmadesc_fblow->page_width = 0;
fbi->dmadesc_fblow->desc_size = jzfb.osd.fg1.h << 16 | jzfb.osd.fg1.w;
REG_LCD_SIZE1 = (jzfb.osd.fg1.h<<16)|jzfb.osd.fg1.w;
fbi->fdadr1 = virt_to_phys(fbi->dmadesc_fblow); /* only used in dual-panel mode */
fbi->dmadesc_fbhigh->fsadr = virt_to_phys((void *)fbi->screen);
fbi->dmadesc_fbhigh->fidr = 0;
fbi->dmadesc_fbhigh->ldcmd = BYTES_PER_PANEL / 4; /* length in word */
fbi->dmadesc_fbhigh->offsize = 0;
fbi->dmadesc_fbhigh->page_width = 0;
fbi->dmadesc_fbhigh->desc_size = jzfb.osd.fg0.h << 16 | jzfb.osd.fg0.w;
REG_LCD_SIZE0 = jzfb.osd.fg0.h << 16|jzfb.osd.fg0.w;
fbi->dmadesc_palette->fsadr = virt_to_phys((void *)fbi->palette);
fbi->dmadesc_palette->fidr = 0;
fbi->dmadesc_palette->ldcmd = (fbi->palette_size * 2)/4 | (1<<28);
if( NBITS(vid->vl_bpix) < 12)
{
/* assume any mode with <12 bpp is palette driven */
fbi->dmadesc_palette->fdadr = virt_to_phys(fbi->dmadesc_fbhigh);
fbi->dmadesc_fbhigh->fdadr = virt_to_phys(fbi->dmadesc_palette);
/* flips back and forth between pal and fbhigh */
fbi->fdadr0 = virt_to_phys(fbi->dmadesc_palette);
}
else
{
/* palette shouldn't be loaded in true-color mode */
fbi->dmadesc_fbhigh->fdadr = virt_to_phys((void *)fbi->dmadesc_fbhigh);
fbi->dmadesc_fblow->fdadr = virt_to_phys((void *)fbi->dmadesc_fblow);
fbi->fdadr0 = virt_to_phys(fbi->dmadesc_fbhigh); /* no pal just fbhigh */
fbi->fdadr1 = virt_to_phys(fbi->dmadesc_fblow); /* just fblow */
}
// print_lcdc_desc(fbi);
flush_cache_all();
// print_lcdc_desc(fbi);
}
static int Verify_Sign(const_longnum_ptr mdc, const_longnum_ptr r,
const_longnum_ptr s, const_longnum_ptr y) {
/*>>>> <<<<*
*>>>> AUFGABE: Verifizieren einer El-Gamal-Signatur <<<<*
*>>>> <<<<*/
longnum gleich_links, gleich_rechts;
LInitNumber(&gleich_links, NBITS(&p), 0);
LInitNumber(&gleich_rechts, NBITS(&p), 0);
LModMultExp(y, r, r, s, &gleich_links, &p);
LModExp(&w, mdc, &gleich_rechts, &p);
if (!LCompare(&gleich_links, &gleich_rechts))
return 1;
else
return 0;
}
int
memsetchan(Memimage *i, ulong chan)
{
int d;
int t, j, k;
ulong cc;
int bytes;
if((d = chantodepth(chan)) == 0) {
werrstr("bad channel descriptor");
return -1;
}
i->depth = d;
i->chan = chan;
i->flags &= ~(Fgrey|Falpha|Fcmap|Fbytes);
bytes = 1;
for(cc=chan, j=0, k=0; cc; j+=NBITS(cc), cc>>=8, k++){
t=TYPE(cc);
if(t < 0 || t >= NChan){
werrstr("bad channel string");
return -1;
}
if(t == CGrey)
i->flags |= Fgrey;
if(t == CAlpha)
i->flags |= Falpha;
if(t == CMap && i->cmap == nil){
i->cmap = memdefcmap;
i->flags |= Fcmap;
}
i->shift[t] = j;
i->mask[t] = (1<<NBITS(cc))-1;
i->nbits[t] = NBITS(cc);
if(NBITS(cc) != 8)
bytes = 0;
}
i->nchan = k;
if(bytes)
i->flags |= Fbytes;
return 0;
}
bool hasAbsolutEvents(int fd)
{
unsigned long bits[NBITS(KEY_MAX)];
ioctl (fd, EVIOCGBIT(0, EV_MAX), bits);
if (!test_bit (EV_ABS, bits))
{
return false;
}
return true;
}
static void Generate_Sign(const_longnum_ptr m, longnum_ptr r, longnum_ptr s,
const_longnum_ptr x) {
/*>>>> <<<<*
*>>>> AUFGABE: Erzeugen einer El-Gamal-Signatur <<<<*
*>>>> <<<<*/
longnum k, pMinusEins, kInvert, gtt, us, vs;
int sign = 0;
LInitNumber(&k, NBITS(&p), 0);
LInitNumber(&pMinusEins, NBITS(&p), 0);
LInitNumber(&kInvert, NBITS(&p), 0);
LInitNumber(>t, NBITS(&p), 0);
LInitNumber(&us, NBITS(&p), 0);
LInitNumber(&vs, NBITS(&p), 0);
LCpy(&pMinusEins, &p);
LAddq(-1, &pMinusEins);
//Generate zufalls zahl k
while (1) {
LRand(&pMinusEins, &k);
LggT(&k, &pMinusEins, >t, &us, &vs, &sign);
if (!LIntCmp(1, >t))
break;
}
LModExp(&w, &k, r, &p);
LModMult(r, x, s, &pMinusEins);
LNegMod(s, &pMinusEins);
LAddMod(m, s, &pMinusEins);
LCpy(&kInvert, &k);
LInvert(&kInvert, &pMinusEins);
LModMult(s, &kInvert, s, &pMinusEins);
}
static void exynos_fimd_set_buffer_address(unsigned int win_id)
{
unsigned long start_addr, end_addr;
start_addr = (unsigned long)lcd_base_addr;
end_addr = start_addr + ((pvid->vl_col * (NBITS(pvid->vl_bpix) / 8)) *
pvid->vl_row);
writel(start_addr, (unsigned int)&fimd_ctrl->vidw00add0b0 +
EXYNOS_BUFFER_OFFSET(win_id));
writel(end_addr, (unsigned int)&fimd_ctrl->vidw00add1b0 +
EXYNOS_BUFFER_OFFSET(win_id));
}
void lcd_ctrl_init(void *lcdbase)
{
u32 mem_len = panel_info.vl_col *
panel_info.vl_row *
NBITS(panel_info.vl_bpix) / 8;
/*
* We rely on lcdbase being a physical address, i.e., either MMU off,
* or 1-to-1 mapping. Might want to add some virt2phys here.
*/
if (!lcdbase)
return;
memset(lcdbase, 0, mem_len);
}
void lcd_ctrl_init(void *lcdbase)
{
/*
* We rely on lcdbase being a physical address, i.e., either MMU off,
* or 1-to-1 mapping. Might want to add some virt2phys here.
*/
if (!lcdbase)
return;
lcd_color_fg = 0xFF;
lcd_color_bg = 0xFF;
/* Reset */
REG_SET(EPDC_BASE, EPDC_CTRL, EPDC_CTRL_SFTRST);
while (!(REG_RD(EPDC_BASE, EPDC_CTRL) & EPDC_CTRL_CLKGATE))
;
REG_CLR(EPDC_BASE, EPDC_CTRL, EPDC_CTRL_SFTRST);
/* Enable clock gating (clear to enable) */
REG_CLR(EPDC_BASE, EPDC_CTRL, EPDC_CTRL_CLKGATE);
while (REG_RD(EPDC_BASE, EPDC_CTRL) &
(EPDC_CTRL_SFTRST | EPDC_CTRL_CLKGATE))
;
debug("resolution %dx%d, bpp %d\n", (int)panel_info.vl_col,
(int)panel_info.vl_row, NBITS(panel_info.vl_bpix));
/* Set framebuffer pointer */
REG_WR(EPDC_BASE, EPDC_UPD_ADDR, (u32)lcdbase);
/* Set Working Buffer pointer */
REG_WR(EPDC_BASE, EPDC_WB_ADDR, panel_info.epdc_data.working_buf_addr);
/* Get waveform data address and offset */
if (setup_waveform_file()) {
printf("Can't load waveform data!\n");
return;
}
/* Set Waveform Buffer pointer */
REG_WR(EPDC_BASE, EPDC_WVADDR,
panel_info.epdc_data.waveform_buf_addr);
/* Initialize EPDC, passing pointer to EPDC registers */
epdc_init_settings();
return;
}
int main(void)
{
int ifd = openfd();
if (ifd < 0) {
ALOGE("could not find any tablet mode switch, exiting.");
return -1;
}
sleep(10); //wait some time or otherwise EventHub might not pick up our events correctly!?
int ufd = open("/dev/uinput", O_WRONLY | O_NDELAY);
if (ufd >= 0) {
struct uinput_user_dev ud;
memset(&ud, 0, sizeof(struct uinput_user_dev));
strcpy(ud.name, "Android Tablet Lid Switch");
write(ufd, &ud, sizeof(struct uinput_user_dev));
ioctl(ufd, UI_SET_EVBIT, EV_SW);
ioctl(ufd, UI_SET_SWBIT, SW_LID);
ioctl(ufd, UI_DEV_CREATE, 0);
} else {
ALOGE("could not open uinput device: %s", strerror(errno));
return -1;
}
// send initial switch state
unsigned long sw_state[NBITS(SW_TABLET_MODE+1)];
memset(sw_state, 0, sizeof(sw_state));
if (ioctl(ifd, EVIOCGSW(sizeof(sw_state)), sw_state) >= 0) {
send_switch(ufd, test_bit(SW_TABLET_MODE, sw_state) ? 1 : 0);
}
// read events and pass them on modified
while (1) {
struct input_event iev;
size_t res = read(ifd, &iev, sizeof(struct input_event));
if (res < sizeof(struct input_event)) {
ALOGW("insufficient input data(%d)? fd=%d", res, ifd);
continue;
}
//LOGV("type=%d scancode=%d value=%d from fd=%d", iev.type, iev.code, iev.value, ifd);
if (iev.type == EV_SW && iev.code == SW_TABLET_MODE) {
send_switch(ufd, iev.value);
}
}
return 0;
}
void KbSliderPlugin::readSliderStatus()
{
unsigned long bits[NBITS(KEY_MAX)] = {0};
if (ioctl(eventFd, EVIOCGSW(KEY_MAX), bits) > 0)
kbOpen = QVariant(test_bit(SW_KEYPAD_SLIDE, bits) == 0);
if (!kbPresent.isNull() && kbPresent == false) {
// But if the keyboard is not present, it cannot be open. Also stop
// watching the open/closed status.
kbOpen = QVariant();
unsubscribe(QSet<QString>() << KEY_KB_OPEN);
}
emit valueChanged(KEY_KB_OPEN, kbOpen);
emit subscribeFinished(KEY_KB_OPEN);
}
int main(int argc, char **argv)
{
int fd, i, num_buttons;
unsigned long buttons[NBITS(KEY_MAX)];
fd = open("/dev/input/by-path/platform-gpio-keys-event", O_RDONLY);
if (fd < 0) {
perror("open");
return 1;
}
memset(buttons, 0, sizeof(buttons));
if (ioctl(fd, EVIOCGBIT(EV_KEY, KEY_MAX), buttons) < 0) {
perror("EVIOCGBIT(EV_KEY, KEY_MAX)");
goto done;
}
num_buttons = 0;
for (i = 0; i < KEY_MAX; i++) {
if (test_bit(i, buttons)) {
if (i == BTN_0)
printf("btn_0 (GPIO14) code %d\n", i);
else if (i == BTN_1)
printf("btn_1 (GPIO21) code %d\n", i);
else
printf("Unknown button code %d\n", i);
num_buttons++;
}
}
printf("Watching %d buttons (ctrl-C to exit)\n", num_buttons);
watch_events(fd, num_buttons);
done:
close(fd);
return 0;
}
static void jz_lcd_desc_init(vidinfo_t *vid)
{
struct jz_fb_info * fbi;
fbi = &vid->jz_fb;
fbi->dmadesc_fblow = (struct jz_fb_dma_descriptor *)((unsigned int)fbi->palette - 3*16);
fbi->dmadesc_fbhigh = (struct jz_fb_dma_descriptor *)((unsigned int)fbi->palette - 2*16);
fbi->dmadesc_palette = (struct jz_fb_dma_descriptor *)((unsigned int)fbi->palette - 1*16);
#define BYTES_PER_PANEL (vid->vl_col * vid->vl_row * NBITS(vid->vl_bpix) / 8)
/* populate descriptors */
fbi->dmadesc_fblow->fdadr = virt_to_phys(fbi->dmadesc_fblow);
fbi->dmadesc_fblow->fsadr = virt_to_phys((void *)(fbi->screen + BYTES_PER_PANEL));
fbi->dmadesc_fblow->fidr = 0;
fbi->dmadesc_fblow->ldcmd = BYTES_PER_PANEL / 4 ;
fbi->fdadr1 = virt_to_phys(fbi->dmadesc_fblow); /* only used in dual-panel mode */
fbi->dmadesc_fbhigh->fsadr = virt_to_phys((void *)fbi->screen);
fbi->dmadesc_fbhigh->fidr = 0;
fbi->dmadesc_fbhigh->ldcmd = BYTES_PER_PANEL / 4; /* length in word */
fbi->dmadesc_palette->fsadr = virt_to_phys((void *)fbi->palette);
fbi->dmadesc_palette->fidr = 0;
fbi->dmadesc_palette->ldcmd = (fbi->palette_size * 2)/4 | (1<<28);
if( NBITS(vid->vl_bpix) < 12)
{
/* assume any mode with <12 bpp is palette driven */
fbi->dmadesc_palette->fdadr = virt_to_phys(fbi->dmadesc_fbhigh);
fbi->dmadesc_fbhigh->fdadr = virt_to_phys(fbi->dmadesc_palette);
/* flips back and forth between pal and fbhigh */
fbi->fdadr0 = virt_to_phys(fbi->dmadesc_palette);
}
else
{
/* palette shouldn't be loaded in true-color mode */
fbi->dmadesc_fbhigh->fdadr = virt_to_phys((void *)fbi->dmadesc_fbhigh);
fbi->fdadr0 = virt_to_phys(fbi->dmadesc_fbhigh); /* no pal just fbhigh */
}
flush_cache_all();
}
void getTouchScreenDetails(int *screenXmin,int *screenXmax,int *screenYmin,int *screenYmax)
{
//unsigned short id[4];
unsigned long bit[EV_MAX][NBITS(KEY_MAX)];
char name[256] = "Unknown";
int abs[6] = {0};
ioctl(fd, EVIOCGNAME(sizeof(name)), name);
//printf("Input device name: \"%s\"\n", name);
memset(bit, 0, sizeof(bit));
ioctl(fd, EVIOCGBIT(0, EV_MAX), bit[0]);
//printf("Supported events:\n");
int i,j,k;
for (i = 0; i < EV_MAX; i++)
if (test_bit(i, bit[0])) {
//printf(" Event type %d (%s)\n", i, events[i] ? events[i] : "?");
if (!i) continue;
ioctl(fd, EVIOCGBIT(i, KEY_MAX), bit[i]);
for (j = 0; j < KEY_MAX; j++){
if (test_bit(j, bit[i])) {
//printf(" Event code %d (%s)\n", j, names[i] ? (names[i][j] ? names[i][j] : "?") : "?");
if (i == EV_ABS) {
ioctl(fd, EVIOCGABS(j), abs);
for (k = 0; k < 5; k++)
if ((k < 3) || abs[k]){
//printf(" %s %6d\n", absval[k], abs[k]);
if (j == 0){
if (strcmp(absval[k], "Min ") == 0) *screenXmin = abs[k];
if (strcmp(absval[k], "Max ") == 0) *screenXmax = abs[k];
}
if (j == 1){
if (strcmp(absval[k], "Min ") == 0) *screenYmin = abs[k];
if (strcmp(absval[k], "Max ") == 0) *screenYmax = abs[k];
}
}
}
}
}
}
}