194934785a
The Prestigio 157, an old no-name clone laptop uses input keys very similar to the Wistron 1557/MS2141 with the addition of BIOS-controlled wireless radio frequency kill switch. This patch adds support for the RF kill switch control and adds manual identification of the model. The Prestigio does not expose any recognisable identity via dmidecode and so requires manual selection at module init using force=1 keymap=prestigio Signed-off-by: TJ <ubuntu@tjworld.net> Signed-off-by: Dmitry Torokhov <dtor@mail.ru>
1444 lines
35 KiB
C
1444 lines
35 KiB
C
/*
|
|
* Wistron laptop button driver
|
|
* Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
|
|
* Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
|
|
* Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
|
|
*
|
|
* You can redistribute and/or modify this program under the terms of the
|
|
* GNU General Public License version 2 as published by the Free Software
|
|
* Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
|
|
* Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
* 59 Temple Place Suite 330, Boston, MA 02111-1307, USA.
|
|
*/
|
|
#include <linux/io.h>
|
|
#include <linux/dmi.h>
|
|
#include <linux/init.h>
|
|
#include <linux/input-polldev.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/jiffies.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/mc146818rtc.h>
|
|
#include <linux/module.h>
|
|
#include <linux/preempt.h>
|
|
#include <linux/string.h>
|
|
#include <linux/types.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/leds.h>
|
|
|
|
/* How often we poll keys - msecs */
|
|
#define POLL_INTERVAL_DEFAULT 500 /* when idle */
|
|
#define POLL_INTERVAL_BURST 100 /* when a key was recently pressed */
|
|
|
|
/* BIOS subsystem IDs */
|
|
#define WIFI 0x35
|
|
#define BLUETOOTH 0x34
|
|
#define MAIL_LED 0x31
|
|
|
|
MODULE_AUTHOR("Miloslav Trmac <mitr@volny.cz>");
|
|
MODULE_DESCRIPTION("Wistron laptop button driver");
|
|
MODULE_LICENSE("GPL v2");
|
|
MODULE_VERSION("0.3");
|
|
|
|
static int force; /* = 0; */
|
|
module_param(force, bool, 0);
|
|
MODULE_PARM_DESC(force, "Load even if computer is not in database");
|
|
|
|
static char *keymap_name; /* = NULL; */
|
|
module_param_named(keymap, keymap_name, charp, 0);
|
|
MODULE_PARM_DESC(keymap, "Keymap name, if it can't be autodetected [generic, 1557/MS2141]");
|
|
|
|
static struct platform_device *wistron_device;
|
|
|
|
/* BIOS interface implementation */
|
|
|
|
static void __iomem *bios_entry_point; /* BIOS routine entry point */
|
|
static void __iomem *bios_code_map_base;
|
|
static void __iomem *bios_data_map_base;
|
|
|
|
static u8 cmos_address;
|
|
|
|
struct regs {
|
|
u32 eax, ebx, ecx;
|
|
};
|
|
|
|
static void call_bios(struct regs *regs)
|
|
{
|
|
unsigned long flags;
|
|
|
|
preempt_disable();
|
|
local_irq_save(flags);
|
|
asm volatile ("pushl %%ebp;"
|
|
"movl %7, %%ebp;"
|
|
"call *%6;"
|
|
"popl %%ebp"
|
|
: "=a" (regs->eax), "=b" (regs->ebx), "=c" (regs->ecx)
|
|
: "0" (regs->eax), "1" (regs->ebx), "2" (regs->ecx),
|
|
"m" (bios_entry_point), "m" (bios_data_map_base)
|
|
: "edx", "edi", "esi", "memory");
|
|
local_irq_restore(flags);
|
|
preempt_enable();
|
|
}
|
|
|
|
static ssize_t __init locate_wistron_bios(void __iomem *base)
|
|
{
|
|
static unsigned char __initdata signature[] =
|
|
{ 0x42, 0x21, 0x55, 0x30 };
|
|
ssize_t offset;
|
|
|
|
for (offset = 0; offset < 0x10000; offset += 0x10) {
|
|
if (check_signature(base + offset, signature,
|
|
sizeof(signature)) != 0)
|
|
return offset;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static int __init map_bios(void)
|
|
{
|
|
void __iomem *base;
|
|
ssize_t offset;
|
|
u32 entry_point;
|
|
|
|
base = ioremap(0xF0000, 0x10000); /* Can't fail */
|
|
offset = locate_wistron_bios(base);
|
|
if (offset < 0) {
|
|
printk(KERN_ERR "wistron_btns: BIOS entry point not found\n");
|
|
iounmap(base);
|
|
return -ENODEV;
|
|
}
|
|
|
|
entry_point = readl(base + offset + 5);
|
|
printk(KERN_DEBUG
|
|
"wistron_btns: BIOS signature found at %p, entry point %08X\n",
|
|
base + offset, entry_point);
|
|
|
|
if (entry_point >= 0xF0000) {
|
|
bios_code_map_base = base;
|
|
bios_entry_point = bios_code_map_base + (entry_point & 0xFFFF);
|
|
} else {
|
|
iounmap(base);
|
|
bios_code_map_base = ioremap(entry_point & ~0x3FFF, 0x4000);
|
|
if (bios_code_map_base == NULL) {
|
|
printk(KERN_ERR
|
|
"wistron_btns: Can't map BIOS code at %08X\n",
|
|
entry_point & ~0x3FFF);
|
|
goto err;
|
|
}
|
|
bios_entry_point = bios_code_map_base + (entry_point & 0x3FFF);
|
|
}
|
|
/* The Windows driver maps 0x10000 bytes, we keep only one page... */
|
|
bios_data_map_base = ioremap(0x400, 0xc00);
|
|
if (bios_data_map_base == NULL) {
|
|
printk(KERN_ERR "wistron_btns: Can't map BIOS data\n");
|
|
goto err_code;
|
|
}
|
|
return 0;
|
|
|
|
err_code:
|
|
iounmap(bios_code_map_base);
|
|
err:
|
|
return -ENOMEM;
|
|
}
|
|
|
|
static inline void unmap_bios(void)
|
|
{
|
|
iounmap(bios_code_map_base);
|
|
iounmap(bios_data_map_base);
|
|
}
|
|
|
|
/* BIOS calls */
|
|
|
|
static u16 bios_pop_queue(void)
|
|
{
|
|
struct regs regs;
|
|
|
|
memset(®s, 0, sizeof (regs));
|
|
regs.eax = 0x9610;
|
|
regs.ebx = 0x061C;
|
|
regs.ecx = 0x0000;
|
|
call_bios(®s);
|
|
|
|
return regs.eax;
|
|
}
|
|
|
|
static void __devinit bios_attach(void)
|
|
{
|
|
struct regs regs;
|
|
|
|
memset(®s, 0, sizeof (regs));
|
|
regs.eax = 0x9610;
|
|
regs.ebx = 0x012E;
|
|
call_bios(®s);
|
|
}
|
|
|
|
static void bios_detach(void)
|
|
{
|
|
struct regs regs;
|
|
|
|
memset(®s, 0, sizeof (regs));
|
|
regs.eax = 0x9610;
|
|
regs.ebx = 0x002E;
|
|
call_bios(®s);
|
|
}
|
|
|
|
static u8 __devinit bios_get_cmos_address(void)
|
|
{
|
|
struct regs regs;
|
|
|
|
memset(®s, 0, sizeof (regs));
|
|
regs.eax = 0x9610;
|
|
regs.ebx = 0x051C;
|
|
call_bios(®s);
|
|
|
|
return regs.ecx;
|
|
}
|
|
|
|
static u16 __devinit bios_get_default_setting(u8 subsys)
|
|
{
|
|
struct regs regs;
|
|
|
|
memset(®s, 0, sizeof (regs));
|
|
regs.eax = 0x9610;
|
|
regs.ebx = 0x0200 | subsys;
|
|
call_bios(®s);
|
|
|
|
return regs.eax;
|
|
}
|
|
|
|
static void bios_set_state(u8 subsys, int enable)
|
|
{
|
|
struct regs regs;
|
|
|
|
memset(®s, 0, sizeof (regs));
|
|
regs.eax = 0x9610;
|
|
regs.ebx = (enable ? 0x0100 : 0x0000) | subsys;
|
|
call_bios(®s);
|
|
}
|
|
|
|
/* Hardware database */
|
|
|
|
struct key_entry {
|
|
char type; /* See KE_* below */
|
|
u8 code;
|
|
union {
|
|
u16 keycode; /* For KE_KEY */
|
|
struct { /* For KE_SW */
|
|
u8 code;
|
|
u8 value;
|
|
} sw;
|
|
};
|
|
};
|
|
|
|
enum { KE_END, KE_KEY, KE_SW, KE_WIFI, KE_BLUETOOTH };
|
|
|
|
#define FE_MAIL_LED 0x01
|
|
#define FE_WIFI_LED 0x02
|
|
#define FE_UNTESTED 0x80
|
|
|
|
static struct key_entry *keymap; /* = NULL; Current key map */
|
|
static int have_wifi;
|
|
static int have_bluetooth;
|
|
static int have_leds;
|
|
|
|
static int __init dmi_matched(const struct dmi_system_id *dmi)
|
|
{
|
|
const struct key_entry *key;
|
|
|
|
keymap = dmi->driver_data;
|
|
for (key = keymap; key->type != KE_END; key++) {
|
|
if (key->type == KE_WIFI)
|
|
have_wifi = 1;
|
|
else if (key->type == KE_BLUETOOTH)
|
|
have_bluetooth = 1;
|
|
}
|
|
have_leds = key->code & (FE_MAIL_LED | FE_WIFI_LED);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static struct key_entry keymap_empty[] __initdata = {
|
|
{ KE_END, 0 }
|
|
};
|
|
|
|
static struct key_entry keymap_fs_amilo_pro_v2000[] __initdata = {
|
|
{ KE_KEY, 0x01, {KEY_HELP} },
|
|
{ KE_KEY, 0x11, {KEY_PROG1} },
|
|
{ KE_KEY, 0x12, {KEY_PROG2} },
|
|
{ KE_WIFI, 0x30 },
|
|
{ KE_KEY, 0x31, {KEY_MAIL} },
|
|
{ KE_KEY, 0x36, {KEY_WWW} },
|
|
{ KE_END, 0 }
|
|
};
|
|
|
|
static struct key_entry keymap_fs_amilo_pro_v3505[] __initdata = {
|
|
{ KE_KEY, 0x01, {KEY_HELP} }, /* Fn+F1 */
|
|
{ KE_KEY, 0x06, {KEY_DISPLAYTOGGLE} }, /* Fn+F4 */
|
|
{ KE_BLUETOOTH, 0x30 }, /* Fn+F10 */
|
|
{ KE_KEY, 0x31, {KEY_MAIL} }, /* mail button */
|
|
{ KE_KEY, 0x36, {KEY_WWW} }, /* www button */
|
|
{ KE_WIFI, 0x78 }, /* satelite dish button */
|
|
{ KE_END, 0 }
|
|
};
|
|
|
|
static struct key_entry keymap_fujitsu_n3510[] __initdata = {
|
|
{ KE_KEY, 0x11, {KEY_PROG1} },
|
|
{ KE_KEY, 0x12, {KEY_PROG2} },
|
|
{ KE_KEY, 0x36, {KEY_WWW} },
|
|
{ KE_KEY, 0x31, {KEY_MAIL} },
|
|
{ KE_KEY, 0x71, {KEY_STOPCD} },
|
|
{ KE_KEY, 0x72, {KEY_PLAYPAUSE} },
|
|
{ KE_KEY, 0x74, {KEY_REWIND} },
|
|
{ KE_KEY, 0x78, {KEY_FORWARD} },
|
|
{ KE_END, 0 }
|
|
};
|
|
|
|
static struct key_entry keymap_wistron_ms2111[] __initdata = {
|
|
{ KE_KEY, 0x11, {KEY_PROG1} },
|
|
{ KE_KEY, 0x12, {KEY_PROG2} },
|
|
{ KE_KEY, 0x13, {KEY_PROG3} },
|
|
{ KE_KEY, 0x31, {KEY_MAIL} },
|
|
{ KE_KEY, 0x36, {KEY_WWW} },
|
|
{ KE_END, FE_MAIL_LED }
|
|
};
|
|
|
|
static struct key_entry keymap_wistron_md40100[] __initdata = {
|
|
{ KE_KEY, 0x01, {KEY_HELP} },
|
|
{ KE_KEY, 0x02, {KEY_CONFIG} },
|
|
{ KE_KEY, 0x31, {KEY_MAIL} },
|
|
{ KE_KEY, 0x36, {KEY_WWW} },
|
|
{ KE_KEY, 0x37, {KEY_DISPLAYTOGGLE} }, /* Display on/off */
|
|
{ KE_END, FE_MAIL_LED | FE_WIFI_LED | FE_UNTESTED }
|
|
};
|
|
|
|
static struct key_entry keymap_wistron_ms2141[] __initdata = {
|
|
{ KE_KEY, 0x11, {KEY_PROG1} },
|
|
{ KE_KEY, 0x12, {KEY_PROG2} },
|
|
{ KE_WIFI, 0x30 },
|
|
{ KE_KEY, 0x22, {KEY_REWIND} },
|
|
{ KE_KEY, 0x23, {KEY_FORWARD} },
|
|
{ KE_KEY, 0x24, {KEY_PLAYPAUSE} },
|
|
{ KE_KEY, 0x25, {KEY_STOPCD} },
|
|
{ KE_KEY, 0x31, {KEY_MAIL} },
|
|
{ KE_KEY, 0x36, {KEY_WWW} },
|
|
{ KE_END, 0 }
|
|
};
|
|
|
|
static struct key_entry keymap_acer_aspire_1500[] __initdata = {
|
|
{ KE_KEY, 0x01, {KEY_HELP} },
|
|
{ KE_KEY, 0x03, {KEY_POWER} },
|
|
{ KE_KEY, 0x11, {KEY_PROG1} },
|
|
{ KE_KEY, 0x12, {KEY_PROG2} },
|
|
{ KE_WIFI, 0x30 },
|
|
{ KE_KEY, 0x31, {KEY_MAIL} },
|
|
{ KE_KEY, 0x36, {KEY_WWW} },
|
|
{ KE_KEY, 0x49, {KEY_CONFIG} },
|
|
{ KE_BLUETOOTH, 0x44 },
|
|
{ KE_END, FE_UNTESTED }
|
|
};
|
|
|
|
static struct key_entry keymap_acer_aspire_1600[] __initdata = {
|
|
{ KE_KEY, 0x01, {KEY_HELP} },
|
|
{ KE_KEY, 0x03, {KEY_POWER} },
|
|
{ KE_KEY, 0x08, {KEY_MUTE} },
|
|
{ KE_KEY, 0x11, {KEY_PROG1} },
|
|
{ KE_KEY, 0x12, {KEY_PROG2} },
|
|
{ KE_KEY, 0x13, {KEY_PROG3} },
|
|
{ KE_KEY, 0x31, {KEY_MAIL} },
|
|
{ KE_KEY, 0x36, {KEY_WWW} },
|
|
{ KE_KEY, 0x49, {KEY_CONFIG} },
|
|
{ KE_WIFI, 0x30 },
|
|
{ KE_BLUETOOTH, 0x44 },
|
|
{ KE_END, FE_MAIL_LED | FE_UNTESTED }
|
|
};
|
|
|
|
/* 3020 has been tested */
|
|
static struct key_entry keymap_acer_aspire_5020[] __initdata = {
|
|
{ KE_KEY, 0x01, {KEY_HELP} },
|
|
{ KE_KEY, 0x03, {KEY_POWER} },
|
|
{ KE_KEY, 0x05, {KEY_SWITCHVIDEOMODE} }, /* Display selection */
|
|
{ KE_KEY, 0x11, {KEY_PROG1} },
|
|
{ KE_KEY, 0x12, {KEY_PROG2} },
|
|
{ KE_KEY, 0x31, {KEY_MAIL} },
|
|
{ KE_KEY, 0x36, {KEY_WWW} },
|
|
{ KE_KEY, 0x6a, {KEY_CONFIG} },
|
|
{ KE_WIFI, 0x30 },
|
|
{ KE_BLUETOOTH, 0x44 },
|
|
{ KE_END, FE_MAIL_LED | FE_UNTESTED }
|
|
};
|
|
|
|
static struct key_entry keymap_acer_travelmate_2410[] __initdata = {
|
|
{ KE_KEY, 0x01, {KEY_HELP} },
|
|
{ KE_KEY, 0x6d, {KEY_POWER} },
|
|
{ KE_KEY, 0x11, {KEY_PROG1} },
|
|
{ KE_KEY, 0x12, {KEY_PROG2} },
|
|
{ KE_KEY, 0x31, {KEY_MAIL} },
|
|
{ KE_KEY, 0x36, {KEY_WWW} },
|
|
{ KE_KEY, 0x6a, {KEY_CONFIG} },
|
|
{ KE_WIFI, 0x30 },
|
|
{ KE_BLUETOOTH, 0x44 },
|
|
{ KE_END, FE_MAIL_LED | FE_UNTESTED }
|
|
};
|
|
|
|
static struct key_entry keymap_acer_travelmate_110[] __initdata = {
|
|
{ KE_KEY, 0x01, {KEY_HELP} },
|
|
{ KE_KEY, 0x02, {KEY_CONFIG} },
|
|
{ KE_KEY, 0x03, {KEY_POWER} },
|
|
{ KE_KEY, 0x08, {KEY_MUTE} },
|
|
{ KE_KEY, 0x11, {KEY_PROG1} },
|
|
{ KE_KEY, 0x12, {KEY_PROG2} },
|
|
{ KE_KEY, 0x20, {KEY_VOLUMEUP} },
|
|
{ KE_KEY, 0x21, {KEY_VOLUMEDOWN} },
|
|
{ KE_KEY, 0x31, {KEY_MAIL} },
|
|
{ KE_KEY, 0x36, {KEY_WWW} },
|
|
{ KE_SW, 0x4a, {.sw = {SW_LID, 1}} }, /* lid close */
|
|
{ KE_SW, 0x4b, {.sw = {SW_LID, 0}} }, /* lid open */
|
|
{ KE_WIFI, 0x30 },
|
|
{ KE_END, FE_MAIL_LED | FE_UNTESTED }
|
|
};
|
|
|
|
static struct key_entry keymap_acer_travelmate_300[] __initdata = {
|
|
{ KE_KEY, 0x01, {KEY_HELP} },
|
|
{ KE_KEY, 0x02, {KEY_CONFIG} },
|
|
{ KE_KEY, 0x03, {KEY_POWER} },
|
|
{ KE_KEY, 0x08, {KEY_MUTE} },
|
|
{ KE_KEY, 0x11, {KEY_PROG1} },
|
|
{ KE_KEY, 0x12, {KEY_PROG2} },
|
|
{ KE_KEY, 0x20, {KEY_VOLUMEUP} },
|
|
{ KE_KEY, 0x21, {KEY_VOLUMEDOWN} },
|
|
{ KE_KEY, 0x31, {KEY_MAIL} },
|
|
{ KE_KEY, 0x36, {KEY_WWW} },
|
|
{ KE_WIFI, 0x30 },
|
|
{ KE_BLUETOOTH, 0x44 },
|
|
{ KE_END, FE_MAIL_LED | FE_UNTESTED }
|
|
};
|
|
|
|
static struct key_entry keymap_acer_travelmate_380[] __initdata = {
|
|
{ KE_KEY, 0x01, {KEY_HELP} },
|
|
{ KE_KEY, 0x02, {KEY_CONFIG} },
|
|
{ KE_KEY, 0x03, {KEY_POWER} }, /* not 370 */
|
|
{ KE_KEY, 0x11, {KEY_PROG1} },
|
|
{ KE_KEY, 0x12, {KEY_PROG2} },
|
|
{ KE_KEY, 0x13, {KEY_PROG3} },
|
|
{ KE_KEY, 0x31, {KEY_MAIL} },
|
|
{ KE_KEY, 0x36, {KEY_WWW} },
|
|
{ KE_WIFI, 0x30 },
|
|
{ KE_END, FE_MAIL_LED | FE_UNTESTED }
|
|
};
|
|
|
|
/* unusual map */
|
|
static struct key_entry keymap_acer_travelmate_220[] __initdata = {
|
|
{ KE_KEY, 0x01, {KEY_HELP} },
|
|
{ KE_KEY, 0x02, {KEY_CONFIG} },
|
|
{ KE_KEY, 0x11, {KEY_MAIL} },
|
|
{ KE_KEY, 0x12, {KEY_WWW} },
|
|
{ KE_KEY, 0x13, {KEY_PROG2} },
|
|
{ KE_KEY, 0x31, {KEY_PROG1} },
|
|
{ KE_END, FE_WIFI_LED | FE_UNTESTED }
|
|
};
|
|
|
|
static struct key_entry keymap_acer_travelmate_230[] __initdata = {
|
|
{ KE_KEY, 0x01, {KEY_HELP} },
|
|
{ KE_KEY, 0x02, {KEY_CONFIG} },
|
|
{ KE_KEY, 0x11, {KEY_PROG1} },
|
|
{ KE_KEY, 0x12, {KEY_PROG2} },
|
|
{ KE_KEY, 0x31, {KEY_MAIL} },
|
|
{ KE_KEY, 0x36, {KEY_WWW} },
|
|
{ KE_END, FE_WIFI_LED | FE_UNTESTED }
|
|
};
|
|
|
|
static struct key_entry keymap_acer_travelmate_240[] __initdata = {
|
|
{ KE_KEY, 0x01, {KEY_HELP} },
|
|
{ KE_KEY, 0x02, {KEY_CONFIG} },
|
|
{ KE_KEY, 0x03, {KEY_POWER} },
|
|
{ KE_KEY, 0x08, {KEY_MUTE} },
|
|
{ KE_KEY, 0x31, {KEY_MAIL} },
|
|
{ KE_KEY, 0x36, {KEY_WWW} },
|
|
{ KE_KEY, 0x11, {KEY_PROG1} },
|
|
{ KE_KEY, 0x12, {KEY_PROG2} },
|
|
{ KE_BLUETOOTH, 0x44 },
|
|
{ KE_WIFI, 0x30 },
|
|
{ KE_END, FE_UNTESTED }
|
|
};
|
|
|
|
static struct key_entry keymap_acer_travelmate_350[] __initdata = {
|
|
{ KE_KEY, 0x01, {KEY_HELP} },
|
|
{ KE_KEY, 0x02, {KEY_CONFIG} },
|
|
{ KE_KEY, 0x11, {KEY_PROG1} },
|
|
{ KE_KEY, 0x12, {KEY_PROG2} },
|
|
{ KE_KEY, 0x13, {KEY_MAIL} },
|
|
{ KE_KEY, 0x14, {KEY_PROG3} },
|
|
{ KE_KEY, 0x15, {KEY_WWW} },
|
|
{ KE_END, FE_MAIL_LED | FE_WIFI_LED | FE_UNTESTED }
|
|
};
|
|
|
|
static struct key_entry keymap_acer_travelmate_360[] __initdata = {
|
|
{ KE_KEY, 0x01, {KEY_HELP} },
|
|
{ KE_KEY, 0x02, {KEY_CONFIG} },
|
|
{ KE_KEY, 0x11, {KEY_PROG1} },
|
|
{ KE_KEY, 0x12, {KEY_PROG2} },
|
|
{ KE_KEY, 0x13, {KEY_MAIL} },
|
|
{ KE_KEY, 0x14, {KEY_PROG3} },
|
|
{ KE_KEY, 0x15, {KEY_WWW} },
|
|
{ KE_KEY, 0x40, {KEY_WLAN} },
|
|
{ KE_END, FE_WIFI_LED | FE_UNTESTED } /* no mail led */
|
|
};
|
|
|
|
/* Wifi subsystem only activates the led. Therefore we need to pass
|
|
* wifi event as a normal key, then userspace can really change the wifi state.
|
|
* TODO we need to export led state to userspace (wifi and mail) */
|
|
static struct key_entry keymap_acer_travelmate_610[] __initdata = {
|
|
{ KE_KEY, 0x01, {KEY_HELP} },
|
|
{ KE_KEY, 0x02, {KEY_CONFIG} },
|
|
{ KE_KEY, 0x11, {KEY_PROG1} },
|
|
{ KE_KEY, 0x12, {KEY_PROG2} },
|
|
{ KE_KEY, 0x13, {KEY_PROG3} },
|
|
{ KE_KEY, 0x14, {KEY_MAIL} },
|
|
{ KE_KEY, 0x15, {KEY_WWW} },
|
|
{ KE_KEY, 0x40, {KEY_WLAN} },
|
|
{ KE_END, FE_MAIL_LED | FE_WIFI_LED }
|
|
};
|
|
|
|
static struct key_entry keymap_acer_travelmate_630[] __initdata = {
|
|
{ KE_KEY, 0x01, {KEY_HELP} },
|
|
{ KE_KEY, 0x02, {KEY_CONFIG} },
|
|
{ KE_KEY, 0x03, {KEY_POWER} },
|
|
{ KE_KEY, 0x08, {KEY_MUTE} }, /* not 620 */
|
|
{ KE_KEY, 0x11, {KEY_PROG1} },
|
|
{ KE_KEY, 0x12, {KEY_PROG2} },
|
|
{ KE_KEY, 0x13, {KEY_PROG3} },
|
|
{ KE_KEY, 0x20, {KEY_VOLUMEUP} },
|
|
{ KE_KEY, 0x21, {KEY_VOLUMEDOWN} },
|
|
{ KE_KEY, 0x31, {KEY_MAIL} },
|
|
{ KE_KEY, 0x36, {KEY_WWW} },
|
|
{ KE_WIFI, 0x30 },
|
|
{ KE_END, FE_MAIL_LED | FE_UNTESTED }
|
|
};
|
|
|
|
static struct key_entry keymap_aopen_1559as[] __initdata = {
|
|
{ KE_KEY, 0x01, {KEY_HELP} },
|
|
{ KE_KEY, 0x06, {KEY_PROG3} },
|
|
{ KE_KEY, 0x11, {KEY_PROG1} },
|
|
{ KE_KEY, 0x12, {KEY_PROG2} },
|
|
{ KE_WIFI, 0x30 },
|
|
{ KE_KEY, 0x31, {KEY_MAIL} },
|
|
{ KE_KEY, 0x36, {KEY_WWW} },
|
|
{ KE_END, 0 },
|
|
};
|
|
|
|
static struct key_entry keymap_fs_amilo_d88x0[] __initdata = {
|
|
{ KE_KEY, 0x01, {KEY_HELP} },
|
|
{ KE_KEY, 0x08, {KEY_MUTE} },
|
|
{ KE_KEY, 0x31, {KEY_MAIL} },
|
|
{ KE_KEY, 0x36, {KEY_WWW} },
|
|
{ KE_KEY, 0x11, {KEY_PROG1} },
|
|
{ KE_KEY, 0x12, {KEY_PROG2} },
|
|
{ KE_KEY, 0x13, {KEY_PROG3} },
|
|
{ KE_END, FE_MAIL_LED | FE_WIFI_LED | FE_UNTESTED }
|
|
};
|
|
|
|
static struct key_entry keymap_wistron_md2900[] __initdata = {
|
|
{ KE_KEY, 0x01, {KEY_HELP} },
|
|
{ KE_KEY, 0x02, {KEY_CONFIG} },
|
|
{ KE_KEY, 0x11, {KEY_PROG1} },
|
|
{ KE_KEY, 0x12, {KEY_PROG2} },
|
|
{ KE_KEY, 0x31, {KEY_MAIL} },
|
|
{ KE_KEY, 0x36, {KEY_WWW} },
|
|
{ KE_WIFI, 0x30 },
|
|
{ KE_END, FE_MAIL_LED | FE_UNTESTED }
|
|
};
|
|
|
|
static struct key_entry keymap_wistron_md96500[] __initdata = {
|
|
{ KE_KEY, 0x01, {KEY_HELP} },
|
|
{ KE_KEY, 0x02, {KEY_CONFIG} },
|
|
{ KE_KEY, 0x05, {KEY_SWITCHVIDEOMODE} }, /* Display selection */
|
|
{ KE_KEY, 0x06, {KEY_DISPLAYTOGGLE} }, /* Display on/off */
|
|
{ KE_KEY, 0x08, {KEY_MUTE} },
|
|
{ KE_KEY, 0x11, {KEY_PROG1} },
|
|
{ KE_KEY, 0x12, {KEY_PROG2} },
|
|
{ KE_KEY, 0x20, {KEY_VOLUMEUP} },
|
|
{ KE_KEY, 0x21, {KEY_VOLUMEDOWN} },
|
|
{ KE_KEY, 0x22, {KEY_REWIND} },
|
|
{ KE_KEY, 0x23, {KEY_FORWARD} },
|
|
{ KE_KEY, 0x24, {KEY_PLAYPAUSE} },
|
|
{ KE_KEY, 0x25, {KEY_STOPCD} },
|
|
{ KE_KEY, 0x31, {KEY_MAIL} },
|
|
{ KE_KEY, 0x36, {KEY_WWW} },
|
|
{ KE_WIFI, 0x30 },
|
|
{ KE_BLUETOOTH, 0x44 },
|
|
{ KE_END, FE_UNTESTED }
|
|
};
|
|
|
|
static struct key_entry keymap_wistron_generic[] __initdata = {
|
|
{ KE_KEY, 0x01, {KEY_HELP} },
|
|
{ KE_KEY, 0x02, {KEY_CONFIG} },
|
|
{ KE_KEY, 0x03, {KEY_POWER} },
|
|
{ KE_KEY, 0x05, {KEY_SWITCHVIDEOMODE} }, /* Display selection */
|
|
{ KE_KEY, 0x06, {KEY_DISPLAYTOGGLE} }, /* Display on/off */
|
|
{ KE_KEY, 0x08, {KEY_MUTE} },
|
|
{ KE_KEY, 0x11, {KEY_PROG1} },
|
|
{ KE_KEY, 0x12, {KEY_PROG2} },
|
|
{ KE_KEY, 0x13, {KEY_PROG3} },
|
|
{ KE_KEY, 0x14, {KEY_MAIL} },
|
|
{ KE_KEY, 0x15, {KEY_WWW} },
|
|
{ KE_KEY, 0x20, {KEY_VOLUMEUP} },
|
|
{ KE_KEY, 0x21, {KEY_VOLUMEDOWN} },
|
|
{ KE_KEY, 0x22, {KEY_REWIND} },
|
|
{ KE_KEY, 0x23, {KEY_FORWARD} },
|
|
{ KE_KEY, 0x24, {KEY_PLAYPAUSE} },
|
|
{ KE_KEY, 0x25, {KEY_STOPCD} },
|
|
{ KE_KEY, 0x31, {KEY_MAIL} },
|
|
{ KE_KEY, 0x36, {KEY_WWW} },
|
|
{ KE_KEY, 0x37, {KEY_DISPLAYTOGGLE} }, /* Display on/off */
|
|
{ KE_KEY, 0x40, {KEY_WLAN} },
|
|
{ KE_KEY, 0x49, {KEY_CONFIG} },
|
|
{ KE_SW, 0x4a, {.sw = {SW_LID, 1}} }, /* lid close */
|
|
{ KE_SW, 0x4b, {.sw = {SW_LID, 0}} }, /* lid open */
|
|
{ KE_KEY, 0x6a, {KEY_CONFIG} },
|
|
{ KE_KEY, 0x6d, {KEY_POWER} },
|
|
{ KE_KEY, 0x71, {KEY_STOPCD} },
|
|
{ KE_KEY, 0x72, {KEY_PLAYPAUSE} },
|
|
{ KE_KEY, 0x74, {KEY_REWIND} },
|
|
{ KE_KEY, 0x78, {KEY_FORWARD} },
|
|
{ KE_WIFI, 0x30 },
|
|
{ KE_BLUETOOTH, 0x44 },
|
|
{ KE_END, 0 }
|
|
};
|
|
|
|
static struct key_entry keymap_prestigio[] __initdata = {
|
|
{ KE_KEY, 0x11, {KEY_PROG1} },
|
|
{ KE_KEY, 0x12, {KEY_PROG2} },
|
|
{ KE_WIFI, 0x30 },
|
|
{ KE_KEY, 0x22, {KEY_REWIND} },
|
|
{ KE_KEY, 0x23, {KEY_FORWARD} },
|
|
{ KE_KEY, 0x24, {KEY_PLAYPAUSE} },
|
|
{ KE_KEY, 0x25, {KEY_STOPCD} },
|
|
{ KE_KEY, 0x31, {KEY_MAIL} },
|
|
{ KE_KEY, 0x36, {KEY_WWW} },
|
|
{ KE_END, 0 }
|
|
};
|
|
|
|
|
|
/*
|
|
* If your machine is not here (which is currently rather likely), please send
|
|
* a list of buttons and their key codes (reported when loading this module
|
|
* with force=1) and the output of dmidecode to $MODULE_AUTHOR.
|
|
*/
|
|
static struct dmi_system_id dmi_ids[] __initdata = {
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Fujitsu-Siemens Amilo Pro V2000",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pro V2000"),
|
|
},
|
|
.driver_data = keymap_fs_amilo_pro_v2000
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Fujitsu-Siemens Amilo Pro Edition V3505",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pro Edition V3505"),
|
|
},
|
|
.driver_data = keymap_fs_amilo_pro_v3505
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Fujitsu-Siemens Amilo M7400",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "AMILO M "),
|
|
},
|
|
.driver_data = keymap_fs_amilo_pro_v2000
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Maxdata Pro 7000 DX",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "MAXDATA"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "Pro 7000"),
|
|
},
|
|
.driver_data = keymap_fs_amilo_pro_v2000
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Fujitsu N3510",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "N3510"),
|
|
},
|
|
.driver_data = keymap_fujitsu_n3510
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Acer Aspire 1500",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 1500"),
|
|
},
|
|
.driver_data = keymap_acer_aspire_1500
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Acer Aspire 1600",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 1600"),
|
|
},
|
|
.driver_data = keymap_acer_aspire_1600
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Acer Aspire 3020",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 3020"),
|
|
},
|
|
.driver_data = keymap_acer_aspire_5020
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Acer Aspire 5020",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5020"),
|
|
},
|
|
.driver_data = keymap_acer_aspire_5020
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Acer TravelMate 2100",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 2100"),
|
|
},
|
|
.driver_data = keymap_acer_aspire_5020
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Acer TravelMate 2410",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 2410"),
|
|
},
|
|
.driver_data = keymap_acer_travelmate_2410
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Acer TravelMate C300",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate C300"),
|
|
},
|
|
.driver_data = keymap_acer_travelmate_300
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Acer TravelMate C100",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate C100"),
|
|
},
|
|
.driver_data = keymap_acer_travelmate_300
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Acer TravelMate C110",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate C110"),
|
|
},
|
|
.driver_data = keymap_acer_travelmate_110
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Acer TravelMate 380",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 380"),
|
|
},
|
|
.driver_data = keymap_acer_travelmate_380
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Acer TravelMate 370",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 370"),
|
|
},
|
|
.driver_data = keymap_acer_travelmate_380 /* keyboard minus 1 key */
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Acer TravelMate 220",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 220"),
|
|
},
|
|
.driver_data = keymap_acer_travelmate_220
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Acer TravelMate 260",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 260"),
|
|
},
|
|
.driver_data = keymap_acer_travelmate_220
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Acer TravelMate 230",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 230"),
|
|
/* acerhk looks for "TravelMate F4..." ?! */
|
|
},
|
|
.driver_data = keymap_acer_travelmate_230
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Acer TravelMate 280",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 280"),
|
|
},
|
|
.driver_data = keymap_acer_travelmate_230
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Acer TravelMate 240",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 240"),
|
|
},
|
|
.driver_data = keymap_acer_travelmate_240
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Acer TravelMate 250",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 250"),
|
|
},
|
|
.driver_data = keymap_acer_travelmate_240
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Acer TravelMate 2424NWXCi",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 2420"),
|
|
},
|
|
.driver_data = keymap_acer_travelmate_240
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Acer TravelMate 350",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 350"),
|
|
},
|
|
.driver_data = keymap_acer_travelmate_350
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Acer TravelMate 360",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 360"),
|
|
},
|
|
.driver_data = keymap_acer_travelmate_360
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Acer TravelMate 610",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "ACER"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 610"),
|
|
},
|
|
.driver_data = keymap_acer_travelmate_610
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Acer TravelMate 620",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 620"),
|
|
},
|
|
.driver_data = keymap_acer_travelmate_630
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Acer TravelMate 630",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 630"),
|
|
},
|
|
.driver_data = keymap_acer_travelmate_630
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "AOpen 1559AS",
|
|
.matches = {
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "E2U"),
|
|
DMI_MATCH(DMI_BOARD_NAME, "E2U"),
|
|
},
|
|
.driver_data = keymap_aopen_1559as
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Medion MD 9783",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "MEDIONNB"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "MD 9783"),
|
|
},
|
|
.driver_data = keymap_wistron_ms2111
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Medion MD 40100",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "MEDIONNB"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "WID2000"),
|
|
},
|
|
.driver_data = keymap_wistron_md40100
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Medion MD 2900",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "MEDIONNB"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "WIM 2000"),
|
|
},
|
|
.driver_data = keymap_wistron_md2900
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Medion MD 96500",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "MEDIONPC"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "WIM 2040"),
|
|
},
|
|
.driver_data = keymap_wistron_md96500
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Medion MD 95400",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "MEDIONPC"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "WIM 2050"),
|
|
},
|
|
.driver_data = keymap_wistron_md96500
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Fujitsu Siemens Amilo D7820",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"), /* not sure */
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "Amilo D"),
|
|
},
|
|
.driver_data = keymap_fs_amilo_d88x0
|
|
},
|
|
{
|
|
.callback = dmi_matched,
|
|
.ident = "Fujitsu Siemens Amilo D88x0",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "AMILO D"),
|
|
},
|
|
.driver_data = keymap_fs_amilo_d88x0
|
|
},
|
|
{ NULL, }
|
|
};
|
|
|
|
/* Copy the good keymap, as the original ones are free'd */
|
|
static int __init copy_keymap(void)
|
|
{
|
|
const struct key_entry *key;
|
|
struct key_entry *new_keymap;
|
|
unsigned int length = 1;
|
|
|
|
for (key = keymap; key->type != KE_END; key++)
|
|
length++;
|
|
|
|
new_keymap = kmalloc(length * sizeof(struct key_entry), GFP_KERNEL);
|
|
if (!new_keymap)
|
|
return -ENOMEM;
|
|
|
|
memcpy(new_keymap, keymap, length * sizeof(struct key_entry));
|
|
keymap = new_keymap;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int __init select_keymap(void)
|
|
{
|
|
dmi_check_system(dmi_ids);
|
|
if (keymap_name != NULL) {
|
|
if (strcmp (keymap_name, "1557/MS2141") == 0)
|
|
keymap = keymap_wistron_ms2141;
|
|
else if (strcmp (keymap_name, "prestigio") == 0)
|
|
keymap = keymap_prestigio;
|
|
else if (strcmp (keymap_name, "generic") == 0)
|
|
keymap = keymap_wistron_generic;
|
|
else {
|
|
printk(KERN_ERR "wistron_btns: Keymap unknown\n");
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
if (keymap == NULL) {
|
|
if (!force) {
|
|
printk(KERN_ERR "wistron_btns: System unknown\n");
|
|
return -ENODEV;
|
|
}
|
|
keymap = keymap_empty;
|
|
}
|
|
|
|
return copy_keymap();
|
|
}
|
|
|
|
/* Input layer interface */
|
|
|
|
static struct input_polled_dev *wistron_idev;
|
|
static unsigned long jiffies_last_press;
|
|
static int wifi_enabled;
|
|
static int bluetooth_enabled;
|
|
|
|
static void report_key(struct input_dev *dev, unsigned int keycode)
|
|
{
|
|
input_report_key(dev, keycode, 1);
|
|
input_sync(dev);
|
|
input_report_key(dev, keycode, 0);
|
|
input_sync(dev);
|
|
}
|
|
|
|
static void report_switch(struct input_dev *dev, unsigned int code, int value)
|
|
{
|
|
input_report_switch(dev, code, value);
|
|
input_sync(dev);
|
|
}
|
|
|
|
|
|
/* led management */
|
|
static void wistron_mail_led_set(struct led_classdev *led_cdev,
|
|
enum led_brightness value)
|
|
{
|
|
bios_set_state(MAIL_LED, (value != LED_OFF) ? 1 : 0);
|
|
}
|
|
|
|
/* same as setting up wifi card, but for laptops on which the led is managed */
|
|
static void wistron_wifi_led_set(struct led_classdev *led_cdev,
|
|
enum led_brightness value)
|
|
{
|
|
bios_set_state(WIFI, (value != LED_OFF) ? 1 : 0);
|
|
}
|
|
|
|
static struct led_classdev wistron_mail_led = {
|
|
.name = "wistron:green:mail",
|
|
.brightness_set = wistron_mail_led_set,
|
|
};
|
|
|
|
static struct led_classdev wistron_wifi_led = {
|
|
.name = "wistron:red:wifi",
|
|
.brightness_set = wistron_wifi_led_set,
|
|
};
|
|
|
|
static void __devinit wistron_led_init(struct device *parent)
|
|
{
|
|
if (have_leds & FE_WIFI_LED) {
|
|
u16 wifi = bios_get_default_setting(WIFI);
|
|
if (wifi & 1) {
|
|
wistron_wifi_led.brightness = (wifi & 2) ? LED_FULL : LED_OFF;
|
|
if (led_classdev_register(parent, &wistron_wifi_led))
|
|
have_leds &= ~FE_WIFI_LED;
|
|
else
|
|
bios_set_state(WIFI, wistron_wifi_led.brightness);
|
|
|
|
} else
|
|
have_leds &= ~FE_WIFI_LED;
|
|
}
|
|
|
|
if (have_leds & FE_MAIL_LED) {
|
|
/* bios_get_default_setting(MAIL) always retuns 0, so just turn the led off */
|
|
wistron_mail_led.brightness = LED_OFF;
|
|
if (led_classdev_register(parent, &wistron_mail_led))
|
|
have_leds &= ~FE_MAIL_LED;
|
|
else
|
|
bios_set_state(MAIL_LED, wistron_mail_led.brightness);
|
|
}
|
|
}
|
|
|
|
static void __devexit wistron_led_remove(void)
|
|
{
|
|
if (have_leds & FE_MAIL_LED)
|
|
led_classdev_unregister(&wistron_mail_led);
|
|
|
|
if (have_leds & FE_WIFI_LED)
|
|
led_classdev_unregister(&wistron_wifi_led);
|
|
}
|
|
|
|
static inline void wistron_led_suspend(void)
|
|
{
|
|
if (have_leds & FE_MAIL_LED)
|
|
led_classdev_suspend(&wistron_mail_led);
|
|
|
|
if (have_leds & FE_WIFI_LED)
|
|
led_classdev_suspend(&wistron_wifi_led);
|
|
}
|
|
|
|
static inline void wistron_led_resume(void)
|
|
{
|
|
if (have_leds & FE_MAIL_LED)
|
|
led_classdev_resume(&wistron_mail_led);
|
|
|
|
if (have_leds & FE_WIFI_LED)
|
|
led_classdev_resume(&wistron_wifi_led);
|
|
}
|
|
|
|
static struct key_entry *wistron_get_entry_by_scancode(int code)
|
|
{
|
|
struct key_entry *key;
|
|
|
|
for (key = keymap; key->type != KE_END; key++)
|
|
if (code == key->code)
|
|
return key;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static struct key_entry *wistron_get_entry_by_keycode(int keycode)
|
|
{
|
|
struct key_entry *key;
|
|
|
|
for (key = keymap; key->type != KE_END; key++)
|
|
if (key->type == KE_KEY && keycode == key->keycode)
|
|
return key;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static void handle_key(u8 code)
|
|
{
|
|
const struct key_entry *key = wistron_get_entry_by_scancode(code);
|
|
|
|
if (key) {
|
|
switch (key->type) {
|
|
case KE_KEY:
|
|
report_key(wistron_idev->input, key->keycode);
|
|
break;
|
|
|
|
case KE_SW:
|
|
report_switch(wistron_idev->input,
|
|
key->sw.code, key->sw.value);
|
|
break;
|
|
|
|
case KE_WIFI:
|
|
if (have_wifi) {
|
|
wifi_enabled = !wifi_enabled;
|
|
bios_set_state(WIFI, wifi_enabled);
|
|
}
|
|
break;
|
|
|
|
case KE_BLUETOOTH:
|
|
if (have_bluetooth) {
|
|
bluetooth_enabled = !bluetooth_enabled;
|
|
bios_set_state(BLUETOOTH, bluetooth_enabled);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
BUG();
|
|
}
|
|
jiffies_last_press = jiffies;
|
|
} else
|
|
printk(KERN_NOTICE
|
|
"wistron_btns: Unknown key code %02X\n", code);
|
|
}
|
|
|
|
static void poll_bios(bool discard)
|
|
{
|
|
u8 qlen;
|
|
u16 val;
|
|
|
|
for (;;) {
|
|
qlen = CMOS_READ(cmos_address);
|
|
if (qlen == 0)
|
|
break;
|
|
val = bios_pop_queue();
|
|
if (val != 0 && !discard)
|
|
handle_key((u8)val);
|
|
}
|
|
}
|
|
|
|
static void wistron_flush(struct input_polled_dev *dev)
|
|
{
|
|
/* Flush stale event queue */
|
|
poll_bios(true);
|
|
}
|
|
|
|
static void wistron_poll(struct input_polled_dev *dev)
|
|
{
|
|
poll_bios(false);
|
|
|
|
/* Increase poll frequency if user is currently pressing keys (< 2s ago) */
|
|
if (time_before(jiffies, jiffies_last_press + 2 * HZ))
|
|
dev->poll_interval = POLL_INTERVAL_BURST;
|
|
else
|
|
dev->poll_interval = POLL_INTERVAL_DEFAULT;
|
|
}
|
|
|
|
static int wistron_getkeycode(struct input_dev *dev, int scancode, int *keycode)
|
|
{
|
|
const struct key_entry *key = wistron_get_entry_by_scancode(scancode);
|
|
|
|
if (key && key->type == KE_KEY) {
|
|
*keycode = key->keycode;
|
|
return 0;
|
|
}
|
|
|
|
return -EINVAL;
|
|
}
|
|
|
|
static int wistron_setkeycode(struct input_dev *dev, int scancode, int keycode)
|
|
{
|
|
struct key_entry *key;
|
|
int old_keycode;
|
|
|
|
if (keycode < 0 || keycode > KEY_MAX)
|
|
return -EINVAL;
|
|
|
|
key = wistron_get_entry_by_scancode(scancode);
|
|
if (key && key->type == KE_KEY) {
|
|
old_keycode = key->keycode;
|
|
key->keycode = keycode;
|
|
set_bit(keycode, dev->keybit);
|
|
if (!wistron_get_entry_by_keycode(old_keycode))
|
|
clear_bit(old_keycode, dev->keybit);
|
|
return 0;
|
|
}
|
|
|
|
return -EINVAL;
|
|
}
|
|
|
|
static int __devinit setup_input_dev(void)
|
|
{
|
|
struct key_entry *key;
|
|
struct input_dev *input_dev;
|
|
int error;
|
|
|
|
wistron_idev = input_allocate_polled_device();
|
|
if (!wistron_idev)
|
|
return -ENOMEM;
|
|
|
|
wistron_idev->flush = wistron_flush;
|
|
wistron_idev->poll = wistron_poll;
|
|
wistron_idev->poll_interval = POLL_INTERVAL_DEFAULT;
|
|
|
|
input_dev = wistron_idev->input;
|
|
input_dev->name = "Wistron laptop buttons";
|
|
input_dev->phys = "wistron/input0";
|
|
input_dev->id.bustype = BUS_HOST;
|
|
input_dev->dev.parent = &wistron_device->dev;
|
|
|
|
input_dev->getkeycode = wistron_getkeycode;
|
|
input_dev->setkeycode = wistron_setkeycode;
|
|
|
|
for (key = keymap; key->type != KE_END; key++) {
|
|
switch (key->type) {
|
|
case KE_KEY:
|
|
set_bit(EV_KEY, input_dev->evbit);
|
|
set_bit(key->keycode, input_dev->keybit);
|
|
break;
|
|
|
|
case KE_SW:
|
|
set_bit(EV_SW, input_dev->evbit);
|
|
set_bit(key->sw.code, input_dev->swbit);
|
|
break;
|
|
|
|
/* if wifi or bluetooth are not available, create normal keys */
|
|
case KE_WIFI:
|
|
if (!have_wifi) {
|
|
key->type = KE_KEY;
|
|
key->keycode = KEY_WLAN;
|
|
key--;
|
|
}
|
|
break;
|
|
|
|
case KE_BLUETOOTH:
|
|
if (!have_bluetooth) {
|
|
key->type = KE_KEY;
|
|
key->keycode = KEY_BLUETOOTH;
|
|
key--;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* reads information flags on KE_END */
|
|
if (key->code & FE_UNTESTED)
|
|
printk(KERN_WARNING "Untested laptop multimedia keys, "
|
|
"please report success or failure to eric.piel"
|
|
"@tremplin-utc.net\n");
|
|
|
|
error = input_register_polled_device(wistron_idev);
|
|
if (error) {
|
|
input_free_polled_device(wistron_idev);
|
|
return error;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Driver core */
|
|
|
|
static int __devinit wistron_probe(struct platform_device *dev)
|
|
{
|
|
int err;
|
|
|
|
bios_attach();
|
|
cmos_address = bios_get_cmos_address();
|
|
|
|
if (have_wifi) {
|
|
u16 wifi = bios_get_default_setting(WIFI);
|
|
if (wifi & 1)
|
|
wifi_enabled = (wifi & 2) ? 1 : 0;
|
|
else
|
|
have_wifi = 0;
|
|
|
|
if (have_wifi)
|
|
bios_set_state(WIFI, wifi_enabled);
|
|
}
|
|
|
|
if (have_bluetooth) {
|
|
u16 bt = bios_get_default_setting(BLUETOOTH);
|
|
if (bt & 1)
|
|
bluetooth_enabled = (bt & 2) ? 1 : 0;
|
|
else
|
|
have_bluetooth = 0;
|
|
|
|
if (have_bluetooth)
|
|
bios_set_state(BLUETOOTH, bluetooth_enabled);
|
|
}
|
|
|
|
wistron_led_init(&dev->dev);
|
|
err = setup_input_dev();
|
|
if (err) {
|
|
bios_detach();
|
|
return err;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int __devexit wistron_remove(struct platform_device *dev)
|
|
{
|
|
wistron_led_remove();
|
|
input_unregister_polled_device(wistron_idev);
|
|
input_free_polled_device(wistron_idev);
|
|
bios_detach();
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_PM
|
|
static int wistron_suspend(struct platform_device *dev, pm_message_t state)
|
|
{
|
|
if (have_wifi)
|
|
bios_set_state(WIFI, 0);
|
|
|
|
if (have_bluetooth)
|
|
bios_set_state(BLUETOOTH, 0);
|
|
|
|
wistron_led_suspend();
|
|
return 0;
|
|
}
|
|
|
|
static int wistron_resume(struct platform_device *dev)
|
|
{
|
|
if (have_wifi)
|
|
bios_set_state(WIFI, wifi_enabled);
|
|
|
|
if (have_bluetooth)
|
|
bios_set_state(BLUETOOTH, bluetooth_enabled);
|
|
|
|
wistron_led_resume();
|
|
poll_bios(true);
|
|
|
|
return 0;
|
|
}
|
|
#else
|
|
#define wistron_suspend NULL
|
|
#define wistron_resume NULL
|
|
#endif
|
|
|
|
static struct platform_driver wistron_driver = {
|
|
.driver = {
|
|
.name = "wistron-bios",
|
|
.owner = THIS_MODULE,
|
|
},
|
|
.probe = wistron_probe,
|
|
.remove = __devexit_p(wistron_remove),
|
|
.suspend = wistron_suspend,
|
|
.resume = wistron_resume,
|
|
};
|
|
|
|
static int __init wb_module_init(void)
|
|
{
|
|
int err;
|
|
|
|
err = select_keymap();
|
|
if (err)
|
|
return err;
|
|
|
|
err = map_bios();
|
|
if (err)
|
|
return err;
|
|
|
|
err = platform_driver_register(&wistron_driver);
|
|
if (err)
|
|
goto err_unmap_bios;
|
|
|
|
wistron_device = platform_device_alloc("wistron-bios", -1);
|
|
if (!wistron_device) {
|
|
err = -ENOMEM;
|
|
goto err_unregister_driver;
|
|
}
|
|
|
|
err = platform_device_add(wistron_device);
|
|
if (err)
|
|
goto err_free_device;
|
|
|
|
return 0;
|
|
|
|
err_free_device:
|
|
platform_device_put(wistron_device);
|
|
err_unregister_driver:
|
|
platform_driver_unregister(&wistron_driver);
|
|
err_unmap_bios:
|
|
unmap_bios();
|
|
|
|
return err;
|
|
}
|
|
|
|
static void __exit wb_module_exit(void)
|
|
{
|
|
platform_device_unregister(wistron_device);
|
|
platform_driver_unregister(&wistron_driver);
|
|
unmap_bios();
|
|
kfree(keymap);
|
|
}
|
|
|
|
module_init(wb_module_init);
|
|
module_exit(wb_module_exit);
|