| Author | Tokens | Token Proportion | Commits | Commit Proportion |
|---|---|---|---|---|
| Corentin Chary | 5174 | 68.22% | 19 | 38.78% |
| Greg Kroah-Hartman | 1382 | 18.22% | 2 | 4.08% |
| Julijonas Kikutis | 523 | 6.90% | 1 | 2.04% |
| Scott Thrasher | 163 | 2.15% | 1 | 2.04% |
| Jason Stubbs | 95 | 1.25% | 2 | 4.08% |
| Hans de Goede | 90 | 1.19% | 3 | 6.12% |
| Seth Forshee | 43 | 0.57% | 1 | 2.04% |
| John Serock | 20 | 0.26% | 1 | 2.04% |
| Alberto Mardegan | 19 | 0.25% | 1 | 2.04% |
| Matt Fleming | 14 | 0.18% | 1 | 2.04% |
| J Witteveen | 10 | 0.13% | 1 | 2.04% |
| Andy Shevchenko | 10 | 0.13% | 2 | 4.08% |
| Raul Gutierrez Segales | 8 | 0.11% | 1 | 2.04% |
| David Rientjes | 7 | 0.09% | 2 | 4.08% |
| Darren Hart | 6 | 0.08% | 1 | 2.04% |
| Thomas Courbon | 5 | 0.07% | 1 | 2.04% |
| Christoph Hellwig | 4 | 0.05% | 2 | 4.08% |
| Wolfram Sang | 2 | 0.03% | 1 | 2.04% |
| Thomas Gleixner | 2 | 0.03% | 1 | 2.04% |
| Rusty Russell | 2 | 0.03% | 1 | 2.04% |
| Bhumika Goyal | 2 | 0.03% | 1 | 2.04% |
| Dan Carpenter | 1 | 0.01% | 1 | 2.04% |
| Lad Prabhakar | 1 | 0.01% | 1 | 2.04% |
| Arvind Yadav | 1 | 0.01% | 1 | 2.04% |
| Total | 7584 | 49 |
// SPDX-License-Identifier: GPL-2.0-only /* * Samsung Laptop driver * * Copyright (C) 2009,2011 Greg Kroah-Hartman (gregkh@suse.de) * Copyright (C) 2009,2011 Novell Inc. */ #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt #include <linux/kernel.h> #include <linux/init.h> #include <linux/module.h> #include <linux/delay.h> #include <linux/pci.h> #include <linux/backlight.h> #include <linux/leds.h> #include <linux/fb.h> #include <linux/dmi.h> #include <linux/platform_device.h> #include <linux/rfkill.h> #include <linux/acpi.h> #include <linux/seq_file.h> #include <linux/debugfs.h> #include <linux/ctype.h> #include <linux/efi.h> #include <linux/suspend.h> #include <acpi/video.h> /* * This driver is needed because a number of Samsung laptops do not hook * their control settings through ACPI. So we have to poke around in the * BIOS to do things like brightness values, and "special" key controls. */ /* * We have 0 - 8 as valid brightness levels. The specs say that level 0 should * be reserved by the BIOS (which really doesn't make much sense), we tell * userspace that the value is 0 - 7 and then just tell the hardware 1 - 8 */ #define MAX_BRIGHT 0x07 #define SABI_IFACE_MAIN 0x00 #define SABI_IFACE_SUB 0x02 #define SABI_IFACE_COMPLETE 0x04 #define SABI_IFACE_DATA 0x05 #define WL_STATUS_WLAN 0x0 #define WL_STATUS_BT 0x2 /* Structure get/set data using sabi */ struct sabi_data { union { struct { u32 d0; u32 d1; u16 d2; u8 d3; }; u8 data[11]; }; }; struct sabi_header_offsets { u8 port; u8 re_mem; u8 iface_func; u8 en_mem; u8 data_offset; u8 data_segment; }; struct sabi_commands { /* * Brightness is 0 - 8, as described above. * Value 0 is for the BIOS to use */ u16 get_brightness; u16 set_brightness; /* * first byte: * 0x00 - wireless is off * 0x01 - wireless is on * second byte: * 0x02 - 3G is off * 0x03 - 3G is on * TODO, verify 3G is correct, that doesn't seem right... */ u16 get_wireless_button; u16 set_wireless_button; /* 0 is off, 1 is on */ u16 get_backlight; u16 set_backlight; /* * 0x80 or 0x00 - no action * 0x81 - recovery key pressed */ u16 get_recovery_mode; u16 set_recovery_mode; /* * on seclinux: 0 is low, 1 is high, * on swsmi: 0 is normal, 1 is silent, 2 is turbo */ u16 get_performance_level; u16 set_performance_level; /* 0x80 is off, 0x81 is on */ u16 get_battery_life_extender; u16 set_battery_life_extender; /* 0x80 is off, 0x81 is on */ u16 get_usb_charge; u16 set_usb_charge; /* the first byte is for bluetooth and the third one is for wlan */ u16 get_wireless_status; u16 set_wireless_status; /* 0x80 is off, 0x81 is on */ u16 get_lid_handling; u16 set_lid_handling; /* 0x81 to read, (0x82 | level << 8) to set, 0xaabb to enable */ u16 kbd_backlight; /* * Tell the BIOS that Linux is running on this machine. * 81 is on, 80 is off */ u16 set_linux; }; struct sabi_performance_level { const char *name; u16 value; }; struct sabi_config { int sabi_version; const char *test_string; u16 main_function; const struct sabi_header_offsets header_offsets; const struct sabi_commands commands; const struct sabi_performance_level performance_levels[4]; u8 min_brightness; u8 max_brightness; }; static const struct sabi_config sabi_configs[] = { { /* I don't know if it is really 2, but it it is * less than 3 anyway */ .sabi_version = 2, .test_string = "SECLINUX", .main_function = 0x4c49, .header_offsets = { .port = 0x00, .re_mem = 0x02, .iface_func = 0x03, .en_mem = 0x04, .data_offset = 0x05, .data_segment = 0x07, }, .commands = { .get_brightness = 0x00, .set_brightness = 0x01, .get_wireless_button = 0x02, .set_wireless_button = 0x03, .get_backlight = 0x04, .set_backlight = 0x05, .get_recovery_mode = 0x06, .set_recovery_mode = 0x07, .get_performance_level = 0x08, .set_performance_level = 0x09, .get_battery_life_extender = 0xFFFF, .set_battery_life_extender = 0xFFFF, .get_usb_charge = 0xFFFF, .set_usb_charge = 0xFFFF, .get_wireless_status = 0xFFFF, .set_wireless_status = 0xFFFF, .get_lid_handling = 0xFFFF, .set_lid_handling = 0xFFFF, .kbd_backlight = 0xFFFF, .set_linux = 0x0a, }, .performance_levels = { { .name = "silent", .value = 0, }, { .name = "normal", .value = 1, }, { }, }, .min_brightness = 1, .max_brightness = 8, }, { .sabi_version = 3, .test_string = "SwSmi@", .main_function = 0x5843, .header_offsets = { .port = 0x00, .re_mem = 0x04, .iface_func = 0x02, .en_mem = 0x03, .data_offset = 0x05, .data_segment = 0x07, }, .commands = { .get_brightness = 0x10, .set_brightness = 0x11, .get_wireless_button = 0x12, .set_wireless_button = 0x13, .get_backlight = 0x2d, .set_backlight = 0x2e, .get_recovery_mode = 0xff, .set_recovery_mode = 0xff, .get_performance_level = 0x31, .set_performance_level = 0x32, .get_battery_life_extender = 0x65, .set_battery_life_extender = 0x66, .get_usb_charge = 0x67, .set_usb_charge = 0x68, .get_wireless_status = 0x69, .set_wireless_status = 0x6a, .get_lid_handling = 0x6d, .set_lid_handling = 0x6e, .kbd_backlight = 0x78, .set_linux = 0xff, }, .performance_levels = { { .name = "normal", .value = 0, }, { .name = "silent", .value = 1, }, { .name = "overclock", .value = 2, }, { }, }, .min_brightness = 0, .max_brightness = 8, }, { }, }; /* * samsung-laptop/ - debugfs root directory * f0000_segment - dump f0000 segment * command - current command * data - current data * d0, d1, d2, d3 - data fields * call - call SABI using command and data * * This allow to call arbitrary sabi commands wihout * modifying the driver at all. * For example, setting the keyboard backlight brightness to 5 * * echo 0x78 > command * echo 0x0582 > d0 * echo 0 > d1 * echo 0 > d2 * echo 0 > d3 * cat call */ struct samsung_laptop_debug { struct dentry *root; struct sabi_data data; u16 command; struct debugfs_blob_wrapper f0000_wrapper; struct debugfs_blob_wrapper data_wrapper; struct debugfs_blob_wrapper sdiag_wrapper; }; struct samsung_laptop; struct samsung_rfkill { struct samsung_laptop *samsung; struct rfkill *rfkill; enum rfkill_type type; }; struct samsung_laptop { const struct sabi_config *config; void __iomem *sabi; void __iomem *sabi_iface; void __iomem *f0000_segment; struct mutex sabi_mutex; struct platform_device *platform_device; struct backlight_device *backlight_device; struct samsung_rfkill wlan; struct samsung_rfkill bluetooth; struct led_classdev kbd_led; int kbd_led_wk; struct workqueue_struct *led_workqueue; struct work_struct kbd_led_work; struct samsung_laptop_debug debug; struct samsung_quirks *quirks; struct notifier_block pm_nb; bool handle_backlight; bool has_stepping_quirk; char sdiag[64]; }; struct samsung_quirks { bool broken_acpi_video; bool four_kbd_backlight_levels; bool enable_kbd_backlight; bool use_native_backlight; bool lid_handling; }; static struct samsung_quirks samsung_unknown = {}; static struct samsung_quirks samsung_broken_acpi_video = { .broken_acpi_video = true, }; static struct samsung_quirks samsung_use_native_backlight = { .use_native_backlight = true, }; static struct samsung_quirks samsung_np740u3e = { .four_kbd_backlight_levels = true, .enable_kbd_backlight = true, }; static struct samsung_quirks samsung_lid_handling = { .lid_handling = true, }; static bool force; module_param(force, bool, 0); MODULE_PARM_DESC(force, "Disable the DMI check and forces the driver to be loaded"); static bool debug; module_param(debug, bool, S_IRUGO | S_IWUSR); MODULE_PARM_DESC(debug, "Debug enabled or not"); static int sabi_command(struct samsung_laptop *samsung, u16 command, struct sabi_data *in, struct sabi_data *out) { const struct sabi_config *config = samsung->config; int ret = 0; u16 port = readw(samsung->sabi + config->header_offsets.port); u8 complete, iface_data; mutex_lock(&samsung->sabi_mutex); if (debug) { if (in) pr_info("SABI command:0x%04x " "data:{0x%08x, 0x%08x, 0x%04x, 0x%02x}", command, in->d0, in->d1, in->d2, in->d3); else pr_info("SABI command:0x%04x", command); } /* enable memory to be able to write to it */ outb(readb(samsung->sabi + config->header_offsets.en_mem), port); /* write out the command */ writew(config->main_function, samsung->sabi_iface + SABI_IFACE_MAIN); writew(command, samsung->sabi_iface + SABI_IFACE_SUB); writeb(0, samsung->sabi_iface + SABI_IFACE_COMPLETE); if (in) { writel(in->d0, samsung->sabi_iface + SABI_IFACE_DATA); writel(in->d1, samsung->sabi_iface + SABI_IFACE_DATA + 4); writew(in->d2, samsung->sabi_iface + SABI_IFACE_DATA + 8); writeb(in->d3, samsung->sabi_iface + SABI_IFACE_DATA + 10); } outb(readb(samsung->sabi + config->header_offsets.iface_func), port); /* write protect memory to make it safe */ outb(readb(samsung->sabi + config->header_offsets.re_mem), port); /* see if the command actually succeeded */ complete = readb(samsung->sabi_iface + SABI_IFACE_COMPLETE); iface_data = readb(samsung->sabi_iface + SABI_IFACE_DATA); /* iface_data = 0xFF happens when a command is not known * so we only add a warning in debug mode since we will * probably issue some unknown command at startup to find * out which features are supported */ if (complete != 0xaa || (iface_data == 0xff && debug)) pr_warn("SABI command 0x%04x failed with" " completion flag 0x%02x and interface data 0x%02x", command, complete, iface_data); if (complete != 0xaa || iface_data == 0xff) { ret = -EINVAL; goto exit; } if (out) { out->d0 = readl(samsung->sabi_iface + SABI_IFACE_DATA); out->d1 = readl(samsung->sabi_iface + SABI_IFACE_DATA + 4); out->d2 = readw(samsung->sabi_iface + SABI_IFACE_DATA + 2); out->d3 = readb(samsung->sabi_iface + SABI_IFACE_DATA + 1); } if (debug && out) { pr_info("SABI return data:{0x%08x, 0x%08x, 0x%04x, 0x%02x}", out->d0, out->d1, out->d2, out->d3); } exit: mutex_unlock(&samsung->sabi_mutex); return ret; } /* simple wrappers usable with most commands */ static int sabi_set_commandb(struct samsung_laptop *samsung, u16 command, u8 data) { struct sabi_data in = { { { .d0 = 0, .d1 = 0, .d2 = 0, .d3 = 0 } } }; in.data[0] = data; return sabi_command(samsung, command, &in, NULL); } static int read_brightness(struct samsung_laptop *samsung) { const struct sabi_config *config = samsung->config; const struct sabi_commands *commands = &samsung->config->commands; struct sabi_data sretval; int user_brightness = 0; int retval; retval = sabi_command(samsung, commands->get_brightness, NULL, &sretval); if (retval) return retval; user_brightness = sretval.data[0]; if (user_brightness > config->min_brightness) user_brightness -= config->min_brightness; else user_brightness = 0; return user_brightness; } static void set_brightness(struct samsung_laptop *samsung, u8 user_brightness) { const struct sabi_config *config = samsung->config; const struct sabi_commands *commands = &samsung->config->commands; u8 user_level = user_brightness + config->min_brightness; if (samsung->has_stepping_quirk && user_level != 0) { /* * short circuit if the specified level is what's already set * to prevent the screen from flickering needlessly */ if (user_brightness == read_brightness(samsung)) return; sabi_set_commandb(samsung, commands->set_brightness, 0); } sabi_set_commandb(samsung, commands->set_brightness, user_level); } static int get_brightness(struct backlight_device *bd) { struct samsung_laptop *samsung = bl_get_data(bd); return read_brightness(samsung); } static void check_for_stepping_quirk(struct samsung_laptop *samsung) { int initial_level; int check_level; int orig_level = read_brightness(samsung); /* * Some laptops exhibit the strange behaviour of stepping toward * (rather than setting) the brightness except when changing to/from * brightness level 0. This behaviour is checked for here and worked * around in set_brightness. */ if (orig_level == 0) set_brightness(samsung, 1); initial_level = read_brightness(samsung); if (initial_level <= 2) check_level = initial_level + 2; else check_level = initial_level - 2; samsung->has_stepping_quirk = false; set_brightness(samsung, check_level); if (read_brightness(samsung) != check_level) { samsung->has_stepping_quirk = true; pr_info("enabled workaround for brightness stepping quirk\n"); } set_brightness(samsung, orig_level); } static int update_status(struct backlight_device *bd) { struct samsung_laptop *samsung = bl_get_data(bd); const struct sabi_commands *commands = &samsung->config->commands; set_brightness(samsung, bd->props.brightness); if (bd->props.power == FB_BLANK_UNBLANK) sabi_set_commandb(samsung, commands->set_backlight, 1); else sabi_set_commandb(samsung, commands->set_backlight, 0); return 0; } static const struct backlight_ops backlight_ops = { .get_brightness = get_brightness, .update_status = update_status, }; static int seclinux_rfkill_set(void *data, bool blocked) { struct samsung_rfkill *srfkill = data; struct samsung_laptop *samsung = srfkill->samsung; const struct sabi_commands *commands = &samsung->config->commands; return sabi_set_commandb(samsung, commands->set_wireless_button, !blocked); } static const struct rfkill_ops seclinux_rfkill_ops = { .set_block = seclinux_rfkill_set, }; static int swsmi_wireless_status(struct samsung_laptop *samsung, struct sabi_data *data) { const struct sabi_commands *commands = &samsung->config->commands; return sabi_command(samsung, commands->get_wireless_status, NULL, data); } static int swsmi_rfkill_set(void *priv, bool blocked) { struct samsung_rfkill *srfkill = priv; struct samsung_laptop *samsung = srfkill->samsung; const struct sabi_commands *commands = &samsung->config->commands; struct sabi_data data; int ret, i; ret = swsmi_wireless_status(samsung, &data); if (ret) return ret; /* Don't set the state for non-present devices */ for (i = 0; i < 4; i++) if (data.data[i] == 0x02) data.data[1] = 0; if (srfkill->type == RFKILL_TYPE_WLAN) data.data[WL_STATUS_WLAN] = !blocked; else if (srfkill->type == RFKILL_TYPE_BLUETOOTH) data.data[WL_STATUS_BT] = !blocked; return sabi_command(samsung, commands->set_wireless_status, &data, &data); } static void swsmi_rfkill_query(struct rfkill *rfkill, void *priv) { struct samsung_rfkill *srfkill = priv; struct samsung_laptop *samsung = srfkill->samsung; struct sabi_data data; int ret; ret = swsmi_wireless_status(samsung, &data); if (ret) return ; if (srfkill->type == RFKILL_TYPE_WLAN) ret = data.data[WL_STATUS_WLAN]; else if (srfkill->type == RFKILL_TYPE_BLUETOOTH) ret = data.data[WL_STATUS_BT]; else return ; rfkill_set_sw_state(rfkill, !ret); } static const struct rfkill_ops swsmi_rfkill_ops = { .set_block = swsmi_rfkill_set, .query = swsmi_rfkill_query, }; static ssize_t get_performance_level(struct device *dev, struct device_attribute *attr, char *buf) { struct samsung_laptop *samsung = dev_get_drvdata(dev); const struct sabi_config *config = samsung->config; const struct sabi_commands *commands = &config->commands; struct sabi_data sretval; int retval; int i; /* Read the state */ retval = sabi_command(samsung, commands->get_performance_level, NULL, &sretval); if (retval) return retval; /* The logic is backwards, yeah, lots of fun... */ for (i = 0; config->performance_levels[i].name; ++i) { if (sretval.data[0] == config->performance_levels[i].value) return sprintf(buf, "%s\n", config->performance_levels[i].name); } return sprintf(buf, "%s\n", "unknown"); } static ssize_t set_performance_level(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct samsung_laptop *samsung = dev_get_drvdata(dev); const struct sabi_config *config = samsung->config; const struct sabi_commands *commands = &config->commands; int i; if (count < 1) return count; for (i = 0; config->performance_levels[i].name; ++i) { const struct sabi_performance_level *level = &config->performance_levels[i]; if (!strncasecmp(level->name, buf, strlen(level->name))) { sabi_set_commandb(samsung, commands->set_performance_level, level->value); break; } } if (!config->performance_levels[i].name) return -EINVAL; return count; } static DEVICE_ATTR(performance_level, S_IWUSR | S_IRUGO, get_performance_level, set_performance_level); static int read_battery_life_extender(struct samsung_laptop *samsung) { const struct sabi_commands *commands = &samsung->config->commands; struct sabi_data data; int retval; if (commands->get_battery_life_extender == 0xFFFF) return -ENODEV; memset(&data, 0, sizeof(data)); data.data[0] = 0x80; retval = sabi_command(samsung, commands->get_battery_life_extender, &data, &data); if (retval) return retval; if (data.data[0] != 0 && data.data[0] != 1) return -ENODEV; return data.data[0]; } static int write_battery_life_extender(struct samsung_laptop *samsung, int enabled) { const struct sabi_commands *commands = &samsung->config->commands; struct sabi_data data; memset(&data, 0, sizeof(data)); data.data[0] = 0x80 | enabled; return sabi_command(samsung, commands->set_battery_life_extender, &data, NULL); } static ssize_t get_battery_life_extender(struct device *dev, struct device_attribute *attr, char *buf) { struct samsung_laptop *samsung = dev_get_drvdata(dev); int ret; ret = read_battery_life_extender(samsung); if (ret < 0) return ret; return sprintf(buf, "%d\n", ret); } static ssize_t set_battery_life_extender(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct samsung_laptop *samsung = dev_get_drvdata(dev); int ret, value; if (!count || kstrtoint(buf, 0, &value) != 0) return -EINVAL; ret = write_battery_life_extender(samsung, !!value); if (ret < 0) return ret; return count; } static DEVICE_ATTR(battery_life_extender, S_IWUSR | S_IRUGO, get_battery_life_extender, set_battery_life_extender); static int read_usb_charge(struct samsung_laptop *samsung) { const struct sabi_commands *commands = &samsung->config->commands; struct sabi_data data; int retval; if (commands->get_usb_charge == 0xFFFF) return -ENODEV; memset(&data, 0, sizeof(data)); data.data[0] = 0x80; retval = sabi_command(samsung, commands->get_usb_charge, &data, &data); if (retval) return retval; if (data.data[0] != 0 && data.data[0] != 1) return -ENODEV; return data.data[0]; } static int write_usb_charge(struct samsung_laptop *samsung, int enabled) { const struct sabi_commands *commands = &samsung->config->commands; struct sabi_data data; memset(&data, 0, sizeof(data)); data.data[0] = 0x80 | enabled; return sabi_command(samsung, commands->set_usb_charge, &data, NULL); } static ssize_t get_usb_charge(struct device *dev, struct device_attribute *attr, char *buf) { struct samsung_laptop *samsung = dev_get_drvdata(dev); int ret; ret = read_usb_charge(samsung); if (ret < 0) return ret; return sprintf(buf, "%d\n", ret); } static ssize_t set_usb_charge(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct samsung_laptop *samsung = dev_get_drvdata(dev); int ret, value; if (!count || kstrtoint(buf, 0, &value) != 0) return -EINVAL; ret = write_usb_charge(samsung, !!value); if (ret < 0) return ret; return count; } static DEVICE_ATTR(usb_charge, S_IWUSR | S_IRUGO, get_usb_charge, set_usb_charge); static int read_lid_handling(struct samsung_laptop *samsung) { const struct sabi_commands *commands = &samsung->config->commands; struct sabi_data data; int retval; if (commands->get_lid_handling == 0xFFFF) return -ENODEV; memset(&data, 0, sizeof(data)); retval = sabi_command(samsung, commands->get_lid_handling, &data, &data); if (retval) return retval; return data.data[0] & 0x1; } static int write_lid_handling(struct samsung_laptop *samsung, int enabled) { const struct sabi_commands *commands = &samsung->config->commands; struct sabi_data data; memset(&data, 0, sizeof(data)); data.data[0] = 0x80 | enabled; return sabi_command(samsung, commands->set_lid_handling, &data, NULL); } static ssize_t get_lid_handling(struct device *dev, struct device_attribute *attr, char *buf) { struct samsung_laptop *samsung = dev_get_drvdata(dev); int ret; ret = read_lid_handling(samsung); if (ret < 0) return ret; return sprintf(buf, "%d\n", ret); } static ssize_t set_lid_handling(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct samsung_laptop *samsung = dev_get_drvdata(dev); int ret, value; if (!count || kstrtoint(buf, 0, &value) != 0) return -EINVAL; ret = write_lid_handling(samsung, !!value); if (ret < 0) return ret; return count; } static DEVICE_ATTR(lid_handling, S_IWUSR | S_IRUGO, get_lid_handling, set_lid_handling); static struct attribute *platform_attributes[] = { &dev_attr_performance_level.attr, &dev_attr_battery_life_extender.attr, &dev_attr_usb_charge.attr, &dev_attr_lid_handling.attr, NULL }; static int find_signature(void __iomem *memcheck, const char *testStr) { int i = 0; int loca; for (loca = 0; loca < 0xffff; loca++) { char temp = readb(memcheck + loca); if (temp == testStr[i]) { if (i == strlen(testStr)-1) break; ++i; } else { i = 0; } } return loca; } static void samsung_rfkill_exit(struct samsung_laptop *samsung) { if (samsung->wlan.rfkill) { rfkill_unregister(samsung->wlan.rfkill); rfkill_destroy(samsung->wlan.rfkill); samsung->wlan.rfkill = NULL; } if (samsung->bluetooth.rfkill) { rfkill_unregister(samsung->bluetooth.rfkill); rfkill_destroy(samsung->bluetooth.rfkill); samsung->bluetooth.rfkill = NULL; } } static int samsung_new_rfkill(struct samsung_laptop *samsung, struct samsung_rfkill *arfkill, const char *name, enum rfkill_type type, const struct rfkill_ops *ops, int blocked) { struct rfkill **rfkill = &arfkill->rfkill; int ret; arfkill->type = type; arfkill->samsung = samsung; *rfkill = rfkill_alloc(name, &samsung->platform_device->dev, type, ops, arfkill); if (!*rfkill) return -EINVAL; if (blocked != -1) rfkill_init_sw_state(*rfkill, blocked); ret = rfkill_register(*rfkill); if (ret) { rfkill_destroy(*rfkill); *rfkill = NULL; return ret; } return 0; } static int __init samsung_rfkill_init_seclinux(struct samsung_laptop *samsung) { return samsung_new_rfkill(samsung, &samsung->wlan, "samsung-wlan", RFKILL_TYPE_WLAN, &seclinux_rfkill_ops, -1); } static int __init samsung_rfkill_init_swsmi(struct samsung_laptop *samsung) { struct sabi_data data; int ret; ret = swsmi_wireless_status(samsung, &data); if (ret) { /* Some swsmi laptops use the old seclinux way to control * wireless devices */ if (ret == -EINVAL) ret = samsung_rfkill_init_seclinux(samsung); return ret; } /* 0x02 seems to mean that the device is no present/available */ if (data.data[WL_STATUS_WLAN] != 0x02) ret = samsung_new_rfkill(samsung, &samsung->wlan, "samsung-wlan", RFKILL_TYPE_WLAN, &swsmi_rfkill_ops, !data.data[WL_STATUS_WLAN]); if (ret) goto exit; if (data.data[WL_STATUS_BT] != 0x02) ret = samsung_new_rfkill(samsung, &samsung->bluetooth, "samsung-bluetooth", RFKILL_TYPE_BLUETOOTH, &swsmi_rfkill_ops, !data.data[WL_STATUS_BT]); if (ret) goto exit; exit: if (ret) samsung_rfkill_exit(samsung); return ret; } static int __init samsung_rfkill_init(struct samsung_laptop *samsung) { if (samsung->config->sabi_version == 2) return samsung_rfkill_init_seclinux(samsung); if (samsung->config->sabi_version == 3) return samsung_rfkill_init_swsmi(samsung); return 0; } static void samsung_lid_handling_exit(struct samsung_laptop *samsung) { if (samsung->quirks->lid_handling) write_lid_handling(samsung, 0); } static int __init samsung_lid_handling_init(struct samsung_laptop *samsung) { int retval = 0; if (samsung->quirks->lid_handling) retval = write_lid_handling(samsung, 1); return retval; } static int kbd_backlight_enable(struct samsung_laptop *samsung) { const struct sabi_commands *commands = &samsung->config->commands; struct sabi_data data; int retval; if (commands->kbd_backlight == 0xFFFF) return -ENODEV; memset(&data, 0, sizeof(data)); data.d0 = 0xaabb; retval = sabi_command(samsung, commands->kbd_backlight, &data, &data); if (retval) return retval; if (data.d0 != 0xccdd) return -ENODEV; return 0; } static int kbd_backlight_read(struct samsung_laptop *samsung) { const struct sabi_commands *commands = &samsung->config->commands; struct sabi_data data; int retval; memset(&data, 0, sizeof(data)); data.data[0] = 0x81; retval = sabi_command(samsung, commands->kbd_backlight, &data, &data); if (retval) return retval; return data.data[0]; } static int kbd_backlight_write(struct samsung_laptop *samsung, int brightness) { const struct sabi_commands *commands = &samsung->config->commands; struct sabi_data data; memset(&data, 0, sizeof(data)); data.d0 = 0x82 | ((brightness & 0xFF) << 8); return sabi_command(samsung, commands->kbd_backlight, &data, NULL); } static void kbd_led_update(struct work_struct *work) { struct samsung_laptop *samsung; samsung = container_of(work, struct samsung_laptop, kbd_led_work); kbd_backlight_write(samsung, samsung->kbd_led_wk); } static void kbd_led_set(struct led_classdev *led_cdev, enum led_brightness value) { struct samsung_laptop *samsung; samsung = container_of(led_cdev, struct samsung_laptop, kbd_led); if (value > samsung->kbd_led.max_brightness) value = samsung->kbd_led.max_brightness; else if (value < 0) value = 0; samsung->kbd_led_wk = value; queue_work(samsung->led_workqueue, &samsung->kbd_led_work); } static enum led_brightness kbd_led_get(struct led_classdev *led_cdev) { struct samsung_laptop *samsung; samsung = container_of(led_cdev, struct samsung_laptop, kbd_led); return kbd_backlight_read(samsung); } static void samsung_leds_exit(struct samsung_laptop *samsung) { if (!IS_ERR_OR_NULL(samsung->kbd_led.dev)) led_classdev_unregister(&samsung->kbd_led); if (samsung->led_workqueue) destroy_workqueue(samsung->led_workqueue); } static int __init samsung_leds_init(struct samsung_laptop *samsung) { int ret = 0; samsung->led_workqueue = create_singlethread_workqueue("led_workqueue"); if (!samsung->led_workqueue) return -ENOMEM; if (kbd_backlight_enable(samsung) >= 0) { INIT_WORK(&samsung->kbd_led_work, kbd_led_update); samsung->kbd_led.name = "samsung::kbd_backlight"; samsung->kbd_led.brightness_set = kbd_led_set; samsung->kbd_led.brightness_get = kbd_led_get; samsung->kbd_led.max_brightness = 8; if (samsung->quirks->four_kbd_backlight_levels) samsung->kbd_led.max_brightness = 4; ret = led_classdev_register(&samsung->platform_device->dev, &samsung->kbd_led); } if (ret) samsung_leds_exit(samsung); return ret; } static void samsung_backlight_exit(struct samsung_laptop *samsung) { if (samsung->backlight_device) { backlight_device_unregister(samsung->backlight_device); samsung->backlight_device = NULL; } } static int __init samsung_backlight_init(struct samsung_laptop *samsung) { struct backlight_device *bd; struct backlight_properties props; if (!samsung->handle_backlight) return 0; memset(&props, 0, sizeof(struct backlight_properties)); props.type = BACKLIGHT_PLATFORM; props.max_brightness = samsung->config->max_brightness - samsung->config->min_brightness; bd = backlight_device_register("samsung", &samsung->platform_device->dev, samsung, &backlight_ops, &props); if (IS_ERR(bd)) return PTR_ERR(bd); samsung->backlight_device = bd; samsung->backlight_device->props.brightness = read_brightness(samsung); samsung->backlight_device->props.power = FB_BLANK_UNBLANK; backlight_update_status(samsung->backlight_device); return 0; } static umode_t samsung_sysfs_is_visible(struct kobject *kobj, struct attribute *attr, int idx) { struct device *dev = container_of(kobj, struct device, kobj); struct samsung_laptop *samsung = dev_get_drvdata(dev); bool ok = true; if (attr == &dev_attr_performance_level.attr) ok = !!samsung->config->performance_levels[0].name; if (attr == &dev_attr_battery_life_extender.attr) ok = !!(read_battery_life_extender(samsung) >= 0); if (attr == &dev_attr_usb_charge.attr) ok = !!(read_usb_charge(samsung) >= 0); if (attr == &dev_attr_lid_handling.attr) ok = !!(read_lid_handling(samsung) >= 0); return ok ? attr->mode : 0; } static const struct attribute_group platform_attribute_group = { .is_visible = samsung_sysfs_is_visible, .attrs = platform_attributes }; static void samsung_sysfs_exit(struct samsung_laptop *samsung) { struct platform_device *device = samsung->platform_device; sysfs_remove_group(&device->dev.kobj, &platform_attribute_group); } static int __init samsung_sysfs_init(struct samsung_laptop *samsung) { struct platform_device *device = samsung->platform_device; return sysfs_create_group(&device->dev.kobj, &platform_attribute_group); } static int samsung_laptop_call_show(struct seq_file *m, void *data) { struct samsung_laptop *samsung = m->private; struct sabi_data *sdata = &samsung->debug.data; int ret; seq_printf(m, "SABI 0x%04x {0x%08x, 0x%08x, 0x%04x, 0x%02x}\n", samsung->debug.command, sdata->d0, sdata->d1, sdata->d2, sdata->d3); ret = sabi_command(samsung, samsung->debug.command, sdata, sdata); if (ret) { seq_printf(m, "SABI command 0x%04x failed\n", samsung->debug.command); return ret; } seq_printf(m, "SABI {0x%08x, 0x%08x, 0x%04x, 0x%02x}\n", sdata->d0, sdata->d1, sdata->d2, sdata->d3); return 0; } DEFINE_SHOW_ATTRIBUTE(samsung_laptop_call); static void samsung_debugfs_exit(struct samsung_laptop *samsung) { debugfs_remove_recursive(samsung->debug.root); } static void samsung_debugfs_init(struct samsung_laptop *samsung) { struct dentry *root; root = debugfs_create_dir("samsung-laptop", NULL); samsung->debug.root = root; samsung->debug.f0000_wrapper.data = samsung->f0000_segment; samsung->debug.f0000_wrapper.size = 0xffff; samsung->debug.data_wrapper.data = &samsung->debug.data; samsung->debug.data_wrapper.size = sizeof(samsung->debug.data); samsung->debug.sdiag_wrapper.data = samsung->sdiag; samsung->debug.sdiag_wrapper.size = strlen(samsung->sdiag); debugfs_create_u16("command", S_IRUGO | S_IWUSR, root, &samsung->debug.command); debugfs_create_u32("d0", S_IRUGO | S_IWUSR, root, &samsung->debug.data.d0); debugfs_create_u32("d1", S_IRUGO | S_IWUSR, root, &samsung->debug.data.d1); debugfs_create_u16("d2", S_IRUGO | S_IWUSR, root, &samsung->debug.data.d2); debugfs_create_u8("d3", S_IRUGO | S_IWUSR, root, &samsung->debug.data.d3); debugfs_create_blob("data", S_IRUGO | S_IWUSR, root, &samsung->debug.data_wrapper); debugfs_create_blob("f0000_segment", S_IRUSR | S_IWUSR, root, &samsung->debug.f0000_wrapper); debugfs_create_file("call", S_IFREG | S_IRUGO, root, samsung, &samsung_laptop_call_fops); debugfs_create_blob("sdiag", S_IRUGO | S_IWUSR, root, &samsung->debug.sdiag_wrapper); } static void samsung_sabi_exit(struct samsung_laptop *samsung) { const struct sabi_config *config = samsung->config; /* Turn off "Linux" mode in the BIOS */ if (config && config->commands.set_linux != 0xff) sabi_set_commandb(samsung, config->commands.set_linux, 0x80); if (samsung->sabi_iface) { iounmap(samsung->sabi_iface); samsung->sabi_iface = NULL; } if (samsung->f0000_segment) { iounmap(samsung->f0000_segment); samsung->f0000_segment = NULL; } samsung->config = NULL; } static __init void samsung_sabi_infos(struct samsung_laptop *samsung, int loca, unsigned int ifaceP) { const struct sabi_config *config = samsung->config; printk(KERN_DEBUG "This computer supports SABI==%x\n", loca + 0xf0000 - 6); printk(KERN_DEBUG "SABI header:\n"); printk(KERN_DEBUG " SMI Port Number = 0x%04x\n", readw(samsung->sabi + config->header_offsets.port)); printk(KERN_DEBUG " SMI Interface Function = 0x%02x\n", readb(samsung->sabi + config->header_offsets.iface_func)); printk(KERN_DEBUG " SMI enable memory buffer = 0x%02x\n", readb(samsung->sabi + config->header_offsets.en_mem)); printk(KERN_DEBUG " SMI restore memory buffer = 0x%02x\n", readb(samsung->sabi + config->header_offsets.re_mem)); printk(KERN_DEBUG " SABI data offset = 0x%04x\n", readw(samsung->sabi + config->header_offsets.data_offset)); printk(KERN_DEBUG " SABI data segment = 0x%04x\n", readw(samsung->sabi + config->header_offsets.data_segment)); printk(KERN_DEBUG " SABI pointer = 0x%08x\n", ifaceP); } static void __init samsung_sabi_diag(struct samsung_laptop *samsung) { int loca = find_signature(samsung->f0000_segment, "SDiaG@"); int i; if (loca == 0xffff) return ; /* Example: * Ident: @SDiaG@686XX-N90X3A/966-SEC-07HL-S90X3A * * Product name: 90X3A * BIOS Version: 07HL */ loca += 1; for (i = 0; loca < 0xffff && i < sizeof(samsung->sdiag) - 1; loca++) { char temp = readb(samsung->f0000_segment + loca); if (isalnum(temp) || temp == '/' || temp == '-') samsung->sdiag[i++] = temp; else break ; } if (debug && samsung->sdiag[0]) pr_info("sdiag: %s", samsung->sdiag); } static int __init samsung_sabi_init(struct samsung_laptop *samsung) { const struct sabi_config *config = NULL; const struct sabi_commands *commands; unsigned int ifaceP; int loca = 0xffff; int ret = 0; int i; samsung->f0000_segment = ioremap(0xf0000, 0xffff); if (!samsung->f0000_segment) { if (debug || force) pr_err("Can't map the segment at 0xf0000\n"); ret = -EINVAL; goto exit; } samsung_sabi_diag(samsung); /* Try to find one of the signatures in memory to find the header */ for (i = 0; sabi_configs[i].test_string != NULL; ++i) { samsung->config = &sabi_configs[i]; loca = find_signature(samsung->f0000_segment, samsung->config->test_string); if (loca != 0xffff) break; } if (loca == 0xffff) { if (debug || force) pr_err("This computer does not support SABI\n"); ret = -ENODEV; goto exit; } config = samsung->config; commands = &config->commands; /* point to the SMI port Number */ loca += 1; samsung->sabi = (samsung->f0000_segment + loca); /* Get a pointer to the SABI Interface */ ifaceP = (readw(samsung->sabi + config->header_offsets.data_segment) & 0x0ffff) << 4; ifaceP += readw(samsung->sabi + config->header_offsets.data_offset) & 0x0ffff; if (debug) samsung_sabi_infos(samsung, loca, ifaceP); samsung->sabi_iface = ioremap(ifaceP, 16); if (!samsung->sabi_iface) { pr_err("Can't remap %x\n", ifaceP); ret = -EINVAL; goto exit; } /* Turn on "Linux" mode in the BIOS */ if (commands->set_linux != 0xff) { int retval = sabi_set_commandb(samsung, commands->set_linux, 0x81); if (retval) { pr_warn("Linux mode was not set!\n"); ret = -ENODEV; goto exit; } } /* Check for stepping quirk */ if (samsung->handle_backlight) check_for_stepping_quirk(samsung); pr_info("detected SABI interface: %s\n", samsung->config->test_string); exit: if (ret) samsung_sabi_exit(samsung); return ret; } static void samsung_platform_exit(struct samsung_laptop *samsung) { if (samsung->platform_device) { platform_device_unregister(samsung->platform_device); samsung->platform_device = NULL; } } static int samsung_pm_notification(struct notifier_block *nb, unsigned long val, void *ptr) { struct samsung_laptop *samsung; samsung = container_of(nb, struct samsung_laptop, pm_nb); if (val == PM_POST_HIBERNATION && samsung->quirks->enable_kbd_backlight) kbd_backlight_enable(samsung); if (val == PM_POST_HIBERNATION && samsung->quirks->lid_handling) write_lid_handling(samsung, 1); return 0; } static int __init samsung_platform_init(struct samsung_laptop *samsung) { struct platform_device *pdev; pdev = platform_device_register_simple("samsung", -1, NULL, 0); if (IS_ERR(pdev)) return PTR_ERR(pdev); samsung->platform_device = pdev; platform_set_drvdata(samsung->platform_device, samsung); return 0; } static struct samsung_quirks *quirks; static int __init samsung_dmi_matched(const struct dmi_system_id *d) { quirks = d->driver_data; return 0; } static const struct dmi_system_id samsung_dmi_table[] __initconst = { { .matches = { DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."), DMI_MATCH(DMI_CHASSIS_TYPE, "8"), /* Portable */ }, }, { .matches = { DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."), DMI_MATCH(DMI_CHASSIS_TYPE, "9"), /* Laptop */ }, }, { .matches = { DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."), DMI_MATCH(DMI_CHASSIS_TYPE, "10"), /* Notebook */ }, }, { .matches = { DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."), DMI_MATCH(DMI_CHASSIS_TYPE, "14"), /* Sub-Notebook */ }, }, /* DMI ids for laptops with bad Chassis Type */ { .ident = "R40/R41", .matches = { DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."), DMI_MATCH(DMI_PRODUCT_NAME, "R40/R41"), DMI_MATCH(DMI_BOARD_NAME, "R40/R41"), }, }, /* Specific DMI ids for laptop with quirks */ { .callback = samsung_dmi_matched, .ident = "N150P", .matches = { DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."), DMI_MATCH(DMI_PRODUCT_NAME, "N150P"), DMI_MATCH(DMI_BOARD_NAME, "N150P"), }, .driver_data = &samsung_use_native_backlight, }, { .callback = samsung_dmi_matched, .ident = "N145P/N250P/N260P", .matches = { DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."), DMI_MATCH(DMI_PRODUCT_NAME, "N145P/N250P/N260P"), DMI_MATCH(DMI_BOARD_NAME, "N145P/N250P/N260P"), }, .driver_data = &samsung_use_native_backlight, }, { .callback = samsung_dmi_matched, .ident = "N150/N210/N220", .matches = { DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."), DMI_MATCH(DMI_PRODUCT_NAME, "N150/N210/N220"), DMI_MATCH(DMI_BOARD_NAME, "N150/N210/N220"), }, .driver_data = &samsung_broken_acpi_video, }, { .callback = samsung_dmi_matched, .ident = "NF110/NF210/NF310", .matches = { DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."), DMI_MATCH(DMI_PRODUCT_NAME, "NF110/NF210/NF310"), DMI_MATCH(DMI_BOARD_NAME, "NF110/NF210/NF310"), }, .driver_data = &samsung_broken_acpi_video, }, { .callback = samsung_dmi_matched, .ident = "X360", .matches = { DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."), DMI_MATCH(DMI_PRODUCT_NAME, "X360"), DMI_MATCH(DMI_BOARD_NAME, "X360"), }, .driver_data = &samsung_broken_acpi_video, }, { .callback = samsung_dmi_matched, .ident = "N250P", .matches = { DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."), DMI_MATCH(DMI_PRODUCT_NAME, "N250P"), DMI_MATCH(DMI_BOARD_NAME, "N250P"), }, .driver_data = &samsung_use_native_backlight, }, { .callback = samsung_dmi_matched, .ident = "NC210", .matches = { DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."), DMI_MATCH(DMI_PRODUCT_NAME, "NC210/NC110"), DMI_MATCH(DMI_BOARD_NAME, "NC210/NC110"), }, .driver_data = &samsung_broken_acpi_video, }, { .callback = samsung_dmi_matched, .ident = "730U3E/740U3E", .matches = { DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."), DMI_MATCH(DMI_PRODUCT_NAME, "730U3E/740U3E"), }, .driver_data = &samsung_np740u3e, }, { .callback = samsung_dmi_matched, .ident = "300V3Z/300V4Z/300V5Z", .matches = { DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."), DMI_MATCH(DMI_PRODUCT_NAME, "300V3Z/300V4Z/300V5Z"), }, .driver_data = &samsung_lid_handling, }, { }, }; MODULE_DEVICE_TABLE(dmi, samsung_dmi_table); static struct platform_device *samsung_platform_device; static int __init samsung_init(void) { struct samsung_laptop *samsung; int ret; if (efi_enabled(EFI_BOOT)) return -ENODEV; quirks = &samsung_unknown; if (!force && !dmi_check_system(samsung_dmi_table)) return -ENODEV; samsung = kzalloc(sizeof(*samsung), GFP_KERNEL); if (!samsung) return -ENOMEM; mutex_init(&samsung->sabi_mutex); samsung->handle_backlight = true; samsung->quirks = quirks; #ifdef CONFIG_ACPI if (samsung->quirks->broken_acpi_video) acpi_video_set_dmi_backlight_type(acpi_backlight_vendor); if (samsung->quirks->use_native_backlight) acpi_video_set_dmi_backlight_type(acpi_backlight_native); if (acpi_video_get_backlight_type() != acpi_backlight_vendor) samsung->handle_backlight = false; #endif ret = samsung_platform_init(samsung); if (ret) goto error_platform; ret = samsung_sabi_init(samsung); if (ret) goto error_sabi; ret = samsung_sysfs_init(samsung); if (ret) goto error_sysfs; ret = samsung_backlight_init(samsung); if (ret) goto error_backlight; ret = samsung_rfkill_init(samsung); if (ret) goto error_rfkill; ret = samsung_leds_init(samsung); if (ret) goto error_leds; ret = samsung_lid_handling_init(samsung); if (ret) goto error_lid_handling; samsung_debugfs_init(samsung); samsung->pm_nb.notifier_call = samsung_pm_notification; register_pm_notifier(&samsung->pm_nb); samsung_platform_device = samsung->platform_device; return ret; error_lid_handling: samsung_leds_exit(samsung); error_leds: samsung_rfkill_exit(samsung); error_rfkill: samsung_backlight_exit(samsung); error_backlight: samsung_sysfs_exit(samsung); error_sysfs: samsung_sabi_exit(samsung); error_sabi: samsung_platform_exit(samsung); error_platform: kfree(samsung); return ret; } static void __exit samsung_exit(void) { struct samsung_laptop *samsung; samsung = platform_get_drvdata(samsung_platform_device); unregister_pm_notifier(&samsung->pm_nb); samsung_debugfs_exit(samsung); samsung_lid_handling_exit(samsung); samsung_leds_exit(samsung); samsung_rfkill_exit(samsung); samsung_backlight_exit(samsung); samsung_sysfs_exit(samsung); samsung_sabi_exit(samsung); samsung_platform_exit(samsung); kfree(samsung); samsung_platform_device = NULL; } module_init(samsung_init); module_exit(samsung_exit); MODULE_AUTHOR("Greg Kroah-Hartman <gregkh@suse.de>"); MODULE_DESCRIPTION("Samsung Backlight driver"); MODULE_LICENSE("GPL");
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1