[PATCH v3 0/2]BugLink: https://bugs.launchpad.net/bugs/1727235

classic Classic list List threaded Threaded
5 messages Options
Reply | Threaded
Open this post in threaded view
|

[PATCH v3 0/2]BugLink: https://bugs.launchpad.net/bugs/1727235

AceLan Kao
[Impact]
New Dell AIO platforms requires a driver that can communicate with the
scalar IC FW through UART interface to get and set the brightness level.

[Test]
Verified on some new Dell AIO machines and confirmed it works.

[Fix]
Write a new driver to handle this task.

[Regression Potential]
Low, it's a new driver for new interface.

[Misc]
Upstream maintainer ask use to re-implement this driver by the new
interface, serdev, but serdev seems doesn't work with ACPI, so submit
this driver as Ubuntu sauce patch for now. I'll try re-write it when I'm
available.

AceLan Kao (2):
  UBUNTU: SAUCE: platform/x86: dell-uart-backlight: new backlight driver
    for DELL AIO
  UBUNTU: updateconfigs for Dell UART backlight driver

 debian.master/config/config.common.ubuntu  |   1 +
 drivers/platform/x86/Kconfig               |  14 +
 drivers/platform/x86/Makefile              |   1 +
 drivers/platform/x86/dell-uart-backlight.c | 463 +++++++++++++++++++++
 drivers/platform/x86/dell-uart-backlight.h |  36 ++
 5 files changed, 515 insertions(+)
 create mode 100644 drivers/platform/x86/dell-uart-backlight.c
 create mode 100644 drivers/platform/x86/dell-uart-backlight.h

--
2.17.1


--
kernel-team mailing list
[hidden email]
https://lists.ubuntu.com/mailman/listinfo/kernel-team
Reply | Threaded
Open this post in threaded view
|

[PATCH v3 1/2] UBUNTU: SAUCE: platform/x86: dell-uart-backlight: new backlight driver for DELL AIO

AceLan Kao
BugLink: https://bugs.launchpad.net/bugs/1727235

The Dell AIO machines released after 2017 come with a UART interface
to communicate with the backlight scalar board. This driver creates
a standard backlight interface and talks to the scalar board through
UART.

In DSDT this uart port will be defined as
   Name (_HID, "DELL0501")
   Name (_CID, EisaId ("PNP0501")
The 8250 PNP driver will be loaded by default, and this driver uses
"DELL0501" to confirm the uart port is a backlight interface and
leverage the port created by 8250 PNP driver to communicate with
the scalar board.

v2:
   1. move struct uart_cmd to .c file
   2. make dell_uart_get_bl_power() inline
   3. add space to ternary operator "bl_cmd->cmd[2] = power ? 0 : 1;"
   4. check return value of kzalloc()
   5. add kzfree()
   6. check return value of backlight_device_register()
   7. check return value of filp_open() at init
v3:
   1. Fix compiling warning.

Signed-off-by: AceLan Kao <[hidden email]>
---
 drivers/platform/x86/Kconfig               |  14 +
 drivers/platform/x86/Makefile              |   1 +
 drivers/platform/x86/dell-uart-backlight.c | 463 +++++++++++++++++++++
 drivers/platform/x86/dell-uart-backlight.h |  36 ++
 4 files changed, 514 insertions(+)
 create mode 100644 drivers/platform/x86/dell-uart-backlight.c
 create mode 100644 drivers/platform/x86/dell-uart-backlight.h

diff --git a/drivers/platform/x86/Kconfig b/drivers/platform/x86/Kconfig
index b6ac37a5d06d..b6ce1a5b01e5 100644
--- a/drivers/platform/x86/Kconfig
+++ b/drivers/platform/x86/Kconfig
@@ -199,6 +199,20 @@ config DELL_RBTN
   To compile this driver as a module, choose M here: the module will
   be called dell-rbtn.
 
+config DELL_UART_BACKLIGHT
+ tristate "Dell AIO UART Backlight driver"
+ depends on SERIAL_8250
+ depends on ACPI
+ ---help---
+  Say Y here if you want to support Dell AIO UART backlight interface.
+  The Dell AIO machines released after 2017 come with a UART interface
+  to communicate with the backlight scalar board. This driver creates
+  a standard backlight interface and talks to the scalar board through
+  UART to adjust the AIO screen brightness.
+
+  To compile this driver as a module, choose M here: the module will
+  be called dell_uart_backlight.
+
 
 config FUJITSU_LAPTOP
  tristate "Fujitsu Laptop Extras"
diff --git a/drivers/platform/x86/Makefile b/drivers/platform/x86/Makefile
index c32b34a72467..85329fd26afd 100644
--- a/drivers/platform/x86/Makefile
+++ b/drivers/platform/x86/Makefile
@@ -22,6 +22,7 @@ obj-$(CONFIG_DELL_WMI_AIO) += dell-wmi-aio.o
 obj-$(CONFIG_DELL_WMI_LED) += dell-wmi-led.o
 obj-$(CONFIG_DELL_SMO8800) += dell-smo8800.o
 obj-$(CONFIG_DELL_RBTN) += dell-rbtn.o
+obj-$(CONFIG_DELL_UART_BACKLIGHT) += dell-uart-backlight.o
 obj-$(CONFIG_ACER_WMI) += acer-wmi.o
 obj-$(CONFIG_ACERHDF) += acerhdf.o
 obj-$(CONFIG_HP_ACCEL) += hp_accel.o
diff --git a/drivers/platform/x86/dell-uart-backlight.c b/drivers/platform/x86/dell-uart-backlight.c
new file mode 100644
index 000000000000..eae075cfcadb
--- /dev/null
+++ b/drivers/platform/x86/dell-uart-backlight.c
@@ -0,0 +1,463 @@
+/*
+ *  Dell AIO Serial Backlight Driver
+ *
+ *  Copyright (C) 2017 AceLan Kao <[hidden email]>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  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.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/acpi.h>
+#include <linux/serial_8250.h>
+#include <linux/delay.h>
+#include <linux/backlight.h>
+#include <acpi/video.h>
+
+#include "dell-uart-backlight.h"
+
+struct dell_uart_backlight {
+ struct device *dev;
+ struct backlight_device *dell_uart_bd;
+ struct mutex brightness_mutex;
+ int line;
+ int bl_power;
+};
+struct uart_8250_port *serial8250_get_port(int line);
+struct tty_struct *tty;
+struct file *ftty;
+
+unsigned int (*io_serial_in)(struct uart_port *p, int offset);
+int (*uart_write)(struct tty_struct *tty, const unsigned char *buf, int count);
+int (*uart_chars_in_buffer)(struct tty_struct *tty);
+
+static struct dell_uart_bl_cmd uart_cmd[] = {
+ /*
+ * Get Firmware Version: Tool uses this command to get firmware version.
+ * Command: 0x6A 0x06 0x8F (Length:3 Type: 0x0A, Cmd:6 Checksum:0x8F)
+ * Return data: 0x0D 0x06 Data checksum (Length:13,Cmd:0x06,
+ *        Data :F/W version(APRILIA=APR27-VXXX,PHINE=PHI23-VXXX),
+ *        checksum:SUM(Length and Cmd and Data)xor 0xFF .
+ */
+ [DELL_UART_GET_FIRMWARE_VER] = {
+ .cmd = {0x6A, 0x06, 0x8F},
+ .tx_len = 3,
+ },
+ /*
+ * Get Brightness level: Application uses this command for scaler to get brightness.
+ * Command: 0x6A 0x0C 0x89 (Length:3 Type: 0x0A, Cmd:0x0C, Checksum:0x89)
+ * Return data: 0x04 0x0C Data checksum
+ * (Length:4 Cmd: 0x0C Data: brightness level checksum: SUM(Length and Cmd and Data)xor 0xFF)
+ *           brightness level which ranges from 0~100.
+ */
+ [DELL_UART_GET_BRIGHTNESS] = {
+ .cmd = {0x6A, 0x0C, 0x89},
+ .ret = {0x04, 0x0C, 0x00, 0x00},
+ .tx_len = 3,
+ .rx_len = 4,
+ },
+ /* Set Brightness level: Application uses this command for scaler to set brightness.
+ * Command: 0x8A 0x0B Byte2 Checksum (Length:4 Type: 0x0A, Cmd:0x0B)
+ *    where Byte2 is the brightness level which ranges from 0~100.
+ * Return data: 0x03 0x0B 0xF1(Length:3,Cmd:B,checksum:0xF1)
+ * Scaler must send the 3bytes ack within 1 second when success, other value if error
+ */
+ [DELL_UART_SET_BRIGHTNESS] = {
+ .cmd = {0x8A, 0x0B, 0x0, 0x0},
+ .ret = {0x03, 0x0B, 0xF1},
+ .tx_len = 4,
+ .rx_len = 3,
+ },
+ /*
+ * Screen ON/OFF Control: Application uses this command to control screen ON or OFF.
+ * Command: 0x8A 0x0E Byte2 Checksum (Length:4 Type: 0x0A, Cmd:0x0E) where
+ *    Byte2=0 to turn OFF the screen.
+ *    Byte2=1 to turn ON the screen
+ *    Other value of Byte2 is reserved and invalid.
+ * Return data: 0x03 0x0E 0xEE(Length:3,Cmd:E,checksum:0xEE)
+ */
+ [DELL_UART_SET_BACKLIGHT_POWER] = {
+ .cmd = {0x8A, 0x0E, 0x00, 0x0},
+ .ret = {0x03, 0x0E, 0xEE},
+ .tx_len = 4,
+ .rx_len = 3,
+ },
+};
+
+static int dell_uart_write(struct uart_8250_port *up, __u8 *buf, int len)
+{
+ int actual = 0;
+ struct uart_port *port = &up->port;
+
+ tty_port_tty_wakeup(&port->state->port);
+ tty = tty_port_tty_get(&port->state->port);
+ actual = uart_write(tty, buf, len);
+ while (uart_chars_in_buffer(tty)) {
+ udelay(10);
+ }
+
+ return actual;
+}
+
+static int dell_uart_read(struct uart_8250_port *up, __u8 *buf, int len)
+{
+ int i, retry;
+ unsigned long flags;
+
+ spin_lock_irqsave(&up->port.lock, flags);
+ for (i = 0; i < len; i++) {
+ retry = 10;
+ while (!(io_serial_in(&up->port, UART_LSR) & UART_LSR_DR)) {
+ if (--retry == 0)
+ break;
+ mdelay(20);
+ }
+
+ if (retry == 0)
+ break;
+ buf[i] = io_serial_in(&up->port, UART_RX);
+ }
+ spin_unlock_irqrestore(&up->port.lock, flags);
+
+ return i;
+}
+
+static void dell_uart_dump_cmd(const char *func, const char *prefix,
+       const char *cmd, int len)
+{
+ char buf[80];
+
+ snprintf(buf, 80, "dell_uart_backlight:%s:%s", func, prefix);
+ if (len != 0)
+ print_hex_dump_debug(buf, DUMP_PREFIX_NONE,
+ 16, 1, cmd, len, false);
+ else
+ pr_debug("dell_uart_backlight:%s:%sNULL\n", func, prefix);
+
+}
+
+/*
+ * checksum: SUM(Length and Cmd and Data)xor 0xFF)
+ */
+static unsigned char dell_uart_checksum(unsigned char *buf, int len)
+{
+ unsigned char val = 0;
+
+ while (len-- > 0)
+ val += buf[len];
+
+ return val ^ 0xff;
+}
+
+/*
+ * There is no command to get backlight power status,
+ * so we set the backlight power to "on" while initializing,
+ * and then track and report its status by bl_power variable
+ */
+static int inline dell_uart_get_bl_power(struct dell_uart_backlight *dell_pdata)
+{
+ return dell_pdata->bl_power;
+}
+
+static int dell_uart_set_bl_power(struct backlight_device *bd, int power)
+{
+ struct dell_uart_bl_cmd *bl_cmd =
+ &uart_cmd[DELL_UART_SET_BACKLIGHT_POWER];
+ struct dell_uart_backlight *dell_pdata = bl_get_data(bd);
+ struct uart_8250_port *uart = serial8250_get_port(dell_pdata->line);
+ int rx_len;
+
+ if (power != FB_BLANK_POWERDOWN)
+ power = FB_BLANK_UNBLANK;
+
+ bl_cmd->cmd[2] = power ? 0 : 1;
+ bl_cmd->cmd[3] = dell_uart_checksum(bl_cmd->cmd, bl_cmd->tx_len - 1);
+
+ dell_uart_dump_cmd(__func__, "tx: ", bl_cmd->cmd, bl_cmd->tx_len);
+
+ if (mutex_lock_killable(&dell_pdata->brightness_mutex) < 0) {
+ pr_debug("Failed to get mutex_lock");
+ return 0;
+ }
+
+ dell_uart_write(uart, bl_cmd->cmd, bl_cmd->tx_len);
+ rx_len = dell_uart_read(uart, bl_cmd->ret, bl_cmd->rx_len);
+
+ mutex_unlock(&dell_pdata->brightness_mutex);
+
+ dell_uart_dump_cmd(__func__, "rx: ", bl_cmd->ret, rx_len);
+
+ bd->props.power = power;
+ dell_pdata->bl_power = power;
+
+ return 0;
+}
+
+static int dell_uart_get_brightness(struct backlight_device *bd)
+{
+ struct dell_uart_bl_cmd *bl_cmd = &uart_cmd[DELL_UART_GET_BRIGHTNESS];
+ struct dell_uart_backlight *dell_pdata = bl_get_data(bd);
+ struct uart_8250_port *uart = serial8250_get_port(dell_pdata->line);
+ int rx_len, brightness = 0;
+
+ dell_uart_dump_cmd(__func__, "tx: ", bl_cmd->cmd, bl_cmd->tx_len);
+
+ if (mutex_lock_killable(&dell_pdata->brightness_mutex) < 0) {
+ pr_debug("Failed to get mutex_lock");
+ return 0;
+ }
+
+ dell_uart_write(uart, bl_cmd->cmd, bl_cmd->tx_len);
+ rx_len = dell_uart_read(uart, bl_cmd->ret, bl_cmd->rx_len);
+
+ mutex_unlock(&dell_pdata->brightness_mutex);
+
+ dell_uart_dump_cmd(__func__, "rx: ", bl_cmd->ret, rx_len);
+
+ brightness = (unsigned int)bl_cmd->ret[2];
+
+ return brightness;
+}
+
+static int dell_uart_update_status(struct backlight_device *bd)
+{
+ struct dell_uart_bl_cmd *bl_cmd = &uart_cmd[DELL_UART_SET_BRIGHTNESS];
+ struct dell_uart_backlight *dell_pdata = bl_get_data(bd);
+ struct uart_8250_port *uart = serial8250_get_port(dell_pdata->line);
+ int rx_len;
+
+ bl_cmd->cmd[2] = bd->props.brightness;
+ bl_cmd->cmd[3] = dell_uart_checksum(bl_cmd->cmd, bl_cmd->tx_len - 1);
+
+ dell_uart_dump_cmd(__func__, "tx: ", bl_cmd->cmd, bl_cmd->tx_len);
+
+ if (mutex_lock_killable(&dell_pdata->brightness_mutex) < 0) {
+ pr_debug("Failed to get mutex_lock");
+ return 0;
+ }
+
+ dell_uart_write(uart, bl_cmd->cmd, bl_cmd->tx_len);
+ rx_len = dell_uart_read(uart, bl_cmd->ret, bl_cmd->rx_len);
+
+ mutex_unlock(&dell_pdata->brightness_mutex);
+
+ dell_uart_dump_cmd(__func__, "rx: ", bl_cmd->ret, rx_len);
+
+ if (bd->props.power != dell_uart_get_bl_power(dell_pdata))
+ dell_uart_set_bl_power(bd, bd->props.power);
+
+ return 0;
+}
+
+static int dell_uart_get_scalar_status(struct dell_uart_backlight *dell_pdata)
+{
+ struct dell_uart_bl_cmd *bl_cmd = &uart_cmd[DELL_UART_GET_SCALAR];
+ struct uart_8250_port *uart = serial8250_get_port(dell_pdata->line);
+ int rx_len, status = 1; /* assume the scalar IC controls backlight if the command failed */
+
+ dell_uart_dump_cmd(__func__, "tx: ", bl_cmd->cmd, bl_cmd->tx_len);
+
+ if (mutex_lock_killable(&dell_pdata->brightness_mutex) < 0) {
+ pr_debug("Failed to get mutex_lock");
+ return 0;
+ }
+
+ dell_uart_write(uart, bl_cmd->cmd, bl_cmd->tx_len);
+ rx_len = dell_uart_read(uart, bl_cmd->ret, bl_cmd->rx_len);
+
+ mutex_unlock(&dell_pdata->brightness_mutex);
+
+ dell_uart_dump_cmd(__func__, "rx: ", bl_cmd->ret, rx_len);
+
+ if (rx_len == 4)
+ status = (unsigned int)bl_cmd->ret[2];
+
+ return status;
+}
+
+static int dell_uart_show_firmware_ver(struct dell_uart_backlight *dell_pdata)
+{
+ struct dell_uart_bl_cmd *bl_cmd = &uart_cmd[DELL_UART_GET_FIRMWARE_VER];
+ struct uart_8250_port *uart = serial8250_get_port(dell_pdata->line);
+ int rx_len = 0, retry = 10;
+
+ dell_uart_dump_cmd(__func__, "tx: ", bl_cmd->cmd, bl_cmd->tx_len);
+
+ if (mutex_lock_killable(&dell_pdata->brightness_mutex) < 0) {
+ pr_debug("Failed to get mutex_lock");
+ return -1;
+ }
+
+ dell_uart_write(uart, bl_cmd->cmd, bl_cmd->tx_len);
+ while (retry-- > 0) {
+ /* first byte is data length */
+ dell_uart_read(uart, bl_cmd->ret, 1);
+ rx_len = (int)bl_cmd->ret[0];
+ if (bl_cmd->ret[0] > 80 || bl_cmd->ret[0] <= 0) {
+ pr_debug("Failed to get firmware version\n");
+ if (retry == 0) {
+ mutex_unlock(&dell_pdata->brightness_mutex);
+ return -1;
+ }
+ msleep(100);
+ continue;
+ }
+
+ dell_uart_read(uart, bl_cmd->ret+1, rx_len-1);
+ break;
+ }
+ mutex_unlock(&dell_pdata->brightness_mutex);
+
+ dell_uart_dump_cmd(__func__, "rx: ", bl_cmd->ret, rx_len);
+
+ pr_debug("Firmare str(%d)= %s\n", (int)bl_cmd->ret[0], bl_cmd->ret+2);
+ return rx_len;
+}
+
+static const struct backlight_ops dell_uart_backlight_ops = {
+ .get_brightness = dell_uart_get_brightness,
+ .update_status = dell_uart_update_status,
+};
+
+static int dell_uart_startup(struct dell_uart_backlight *dell_pdata)
+{
+ struct uart_8250_port *uartp;
+ struct uart_port *port;
+
+ dell_pdata->line = 0;
+ uartp = serial8250_get_port(dell_pdata->line);
+ port = &uartp->port;
+ tty = port->state->port.tty;
+ io_serial_in = port->serial_in;
+ uart_write = tty->driver->ops->write;
+ uart_chars_in_buffer = tty->driver->ops->chars_in_buffer;
+
+ return 0;
+}
+
+static int dell_uart_bl_add(struct acpi_device *dev)
+{
+ struct dell_uart_backlight *dell_pdata;
+ struct backlight_properties props;
+ struct backlight_device *dell_uart_bd;
+
+ dell_pdata = kzalloc(sizeof(struct dell_uart_backlight), GFP_KERNEL);
+ if (!dell_pdata) {
+ pr_debug("Failed to allocate memory for dell_uart_backlight\n");
+ return -1;
+ }
+ dell_pdata->dev = &dev->dev;
+ dell_uart_startup(dell_pdata);
+ dev->driver_data = dell_pdata;
+
+ mutex_init(&dell_pdata->brightness_mutex);
+
+ if (!dell_uart_get_scalar_status(dell_pdata)) {
+ udelay(50);
+ /* try another command to make sure there is no scalar IC */
+ if (dell_uart_show_firmware_ver(dell_pdata) <= 0) {
+ pr_debug("Scalar is not in charge of brightness adjustment.\n");
+ kzfree(dell_pdata);
+ return -1;
+ }
+ }
+
+ memset(&props, 0, sizeof(struct backlight_properties));
+ props.type = BACKLIGHT_PLATFORM;
+ props.max_brightness = 100;
+
+ dell_uart_bd = backlight_device_register("dell_uart_backlight",
+ &dev->dev,
+ dell_pdata,
+ &dell_uart_backlight_ops,
+ &props);
+ if (IS_ERR(dell_uart_bd)) {
+ kzfree(dell_pdata);
+ pr_debug("Backlight registration failed\n");
+ return -1;
+ }
+
+ dell_pdata->dell_uart_bd = dell_uart_bd;
+
+ dell_uart_set_bl_power(dell_uart_bd, FB_BLANK_UNBLANK);
+ dell_uart_bd->props.brightness = 100;
+ backlight_update_status(dell_uart_bd);
+
+ /* unregister acpi backlight interface */
+ acpi_video_set_dmi_backlight_type(acpi_backlight_vendor);
+
+ return 0;
+}
+
+static int dell_uart_bl_remove(struct acpi_device *dev)
+{
+ struct dell_uart_backlight *dell_pdata = dev->driver_data;
+
+ backlight_device_unregister(dell_pdata->dell_uart_bd);
+ kzfree(dell_pdata);
+
+ return 0;
+}
+
+static int dell_uart_bl_suspend(struct device *dev)
+{
+ filp_close(ftty, NULL);
+ return 0;
+}
+
+static int dell_uart_bl_resume(struct device *dev)
+{
+ ftty = filp_open("/dev/ttyS0", O_RDWR | O_NOCTTY | O_NDELAY, 0);
+ return 0;
+}
+
+static SIMPLE_DEV_PM_OPS(dell_uart_bl_pm, dell_uart_bl_suspend, dell_uart_bl_resume);
+
+static const struct acpi_device_id dell_uart_bl_ids[] = {
+ {"DELL0501", 0},
+ {"", 0},
+};
+
+static struct acpi_driver dell_uart_backlight_driver = {
+ .name = "Dell AIO serial backlight",
+ .ids = dell_uart_bl_ids,
+ .ops = {
+ .add = dell_uart_bl_add,
+ .remove = dell_uart_bl_remove,
+ },
+ .drv.pm = &dell_uart_bl_pm,
+};
+
+static int __init dell_uart_bl_init(void)
+{
+ ftty = filp_open("/dev/ttyS0", O_RDWR | O_NOCTTY | O_NDELAY, 0);
+ if (IS_ERR(ftty)) {
+ pr_debug("cannot open /dev/ttyS0\n");
+ return -EINVAL;
+ }
+
+ return acpi_bus_register_driver(&dell_uart_backlight_driver);
+}
+
+static void __exit dell_uart_bl_exit(void)
+{
+ filp_close(ftty, NULL);
+
+ acpi_bus_unregister_driver(&dell_uart_backlight_driver);
+}
+
+module_init(dell_uart_bl_init);
+module_exit(dell_uart_bl_exit);
+MODULE_DEVICE_TABLE(acpi, dell_uart_bl_ids);
+MODULE_DESCRIPTION("Dell AIO Serial Backlight module");
+MODULE_AUTHOR("AceLan Kao <[hidden email]>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/platform/x86/dell-uart-backlight.h b/drivers/platform/x86/dell-uart-backlight.h
new file mode 100644
index 000000000000..e4fe74fae6a8
--- /dev/null
+++ b/drivers/platform/x86/dell-uart-backlight.h
@@ -0,0 +1,36 @@
+/*
+ *  Dell AIO Serial Backlight Driver
+ *
+ *  Copyright (C) 2017 AceLan Kao <[hidden email]>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  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.
+ *
+ */
+
+#ifndef _DELL_UART_BACKLIGHT_H_
+#define _DELL_UART_BACKLIGHT_H_
+
+enum {
+ DELL_UART_GET_FIRMWARE_VER,
+ DELL_UART_GET_SCALAR,
+ DELL_UART_GET_BRIGHTNESS,
+ DELL_UART_SET_BRIGHTNESS,
+ DELL_UART_SET_BACKLIGHT_POWER,
+};
+
+struct dell_uart_bl_cmd {
+ unsigned char cmd[10];
+ unsigned char ret[80];
+ unsigned short tx_len;
+ unsigned short rx_len;
+};
+
+#endif /* _DELL_UART_BACKLIGHT_H_ */
--
2.17.1


--
kernel-team mailing list
[hidden email]
https://lists.ubuntu.com/mailman/listinfo/kernel-team
Reply | Threaded
Open this post in threaded view
|

[PATCH v3 2/2] UBUNTU: updateconfigs for Dell UART backlight driver

AceLan Kao
In reply to this post by AceLan Kao
BugLink: https://bugs.launchpad.net/bugs/1727235

Signed-off-by: AceLan Kao <[hidden email]>
---
 debian.master/config/config.common.ubuntu | 1 +
 1 file changed, 1 insertion(+)

diff --git a/debian.master/config/config.common.ubuntu b/debian.master/config/config.common.ubuntu
index c4ce582d5d90..49e10e43ebeb 100644
--- a/debian.master/config/config.common.ubuntu
+++ b/debian.master/config/config.common.ubuntu
@@ -2123,6 +2123,7 @@ CONFIG_DELL_SMBIOS=m
 CONFIG_DELL_SMBIOS_SMM=m
 CONFIG_DELL_SMBIOS_WMI=m
 CONFIG_DELL_SMO8800=m
+CONFIG_DELL_UART_BACKLIGHT=m
 CONFIG_DELL_WMI=m
 CONFIG_DELL_WMI_AIO=m
 CONFIG_DELL_WMI_DESCRIPTOR=m
--
2.17.1


--
kernel-team mailing list
[hidden email]
https://lists.ubuntu.com/mailman/listinfo/kernel-team
Reply | Threaded
Open this post in threaded view
|

Re: [PATCH v3 1/2] UBUNTU: SAUCE: platform/x86: dell-uart-backlight: new backlight driver for DELL AIO

Colin Ian King-2
In reply to this post by AceLan Kao
On 06/09/18 09:19, AceLan Kao wrote:

> BugLink: https://bugs.launchpad.net/bugs/1727235
>
> The Dell AIO machines released after 2017 come with a UART interface
> to communicate with the backlight scalar board. This driver creates
> a standard backlight interface and talks to the scalar board through
> UART.
>
> In DSDT this uart port will be defined as
>    Name (_HID, "DELL0501")
>    Name (_CID, EisaId ("PNP0501")
> The 8250 PNP driver will be loaded by default, and this driver uses
> "DELL0501" to confirm the uart port is a backlight interface and
> leverage the port created by 8250 PNP driver to communicate with
> the scalar board.
>
> v2:
>    1. move struct uart_cmd to .c file
>    2. make dell_uart_get_bl_power() inline
>    3. add space to ternary operator "bl_cmd->cmd[2] = power ? 0 : 1;"
>    4. check return value of kzalloc()
>    5. add kzfree()
>    6. check return value of backlight_device_register()
>    7. check return value of filp_open() at init
> v3:
>    1. Fix compiling warning.
>
> Signed-off-by: AceLan Kao <[hidden email]>
> ---
>  drivers/platform/x86/Kconfig               |  14 +
>  drivers/platform/x86/Makefile              |   1 +
>  drivers/platform/x86/dell-uart-backlight.c | 463 +++++++++++++++++++++
>  drivers/platform/x86/dell-uart-backlight.h |  36 ++
>  4 files changed, 514 insertions(+)
>  create mode 100644 drivers/platform/x86/dell-uart-backlight.c
>  create mode 100644 drivers/platform/x86/dell-uart-backlight.h
>
> diff --git a/drivers/platform/x86/Kconfig b/drivers/platform/x86/Kconfig
> index b6ac37a5d06d..b6ce1a5b01e5 100644
> --- a/drivers/platform/x86/Kconfig
> +++ b/drivers/platform/x86/Kconfig
> @@ -199,6 +199,20 @@ config DELL_RBTN
>    To compile this driver as a module, choose M here: the module will
>    be called dell-rbtn.
>  
> +config DELL_UART_BACKLIGHT
> + tristate "Dell AIO UART Backlight driver"
> + depends on SERIAL_8250
> + depends on ACPI
> + ---help---
> +  Say Y here if you want to support Dell AIO UART backlight interface.
> +  The Dell AIO machines released after 2017 come with a UART interface
> +  to communicate with the backlight scalar board. This driver creates
> +  a standard backlight interface and talks to the scalar board through
> +  UART to adjust the AIO screen brightness.
> +
> +  To compile this driver as a module, choose M here: the module will
> +  be called dell_uart_backlight.
> +
>  
>  config FUJITSU_LAPTOP
>   tristate "Fujitsu Laptop Extras"
> diff --git a/drivers/platform/x86/Makefile b/drivers/platform/x86/Makefile
> index c32b34a72467..85329fd26afd 100644
> --- a/drivers/platform/x86/Makefile
> +++ b/drivers/platform/x86/Makefile
> @@ -22,6 +22,7 @@ obj-$(CONFIG_DELL_WMI_AIO) += dell-wmi-aio.o
>  obj-$(CONFIG_DELL_WMI_LED) += dell-wmi-led.o
>  obj-$(CONFIG_DELL_SMO8800) += dell-smo8800.o
>  obj-$(CONFIG_DELL_RBTN) += dell-rbtn.o
> +obj-$(CONFIG_DELL_UART_BACKLIGHT) += dell-uart-backlight.o
>  obj-$(CONFIG_ACER_WMI) += acer-wmi.o
>  obj-$(CONFIG_ACERHDF) += acerhdf.o
>  obj-$(CONFIG_HP_ACCEL) += hp_accel.o
> diff --git a/drivers/platform/x86/dell-uart-backlight.c b/drivers/platform/x86/dell-uart-backlight.c
> new file mode 100644
> index 000000000000..eae075cfcadb
> --- /dev/null
> +++ b/drivers/platform/x86/dell-uart-backlight.c
> @@ -0,0 +1,463 @@
> +/*
> + *  Dell AIO Serial Backlight Driver
> + *
> + *  Copyright (C) 2017 AceLan Kao <[hidden email]>
> + *
> + *  This program is free software; you can redistribute it and/or modify
> + *  it under the terms of the GNU General Public License as published by
> + *  the Free Software Foundation; either version 2 of the License, or
> + *  (at your option) any later version.
> + *
> + *  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.
> + *
> + */
> +
> +#include <linux/kernel.h>
> +#include <linux/module.h>
> +#include <linux/acpi.h>
> +#include <linux/serial_8250.h>
> +#include <linux/delay.h>
> +#include <linux/backlight.h>
> +#include <acpi/video.h>
> +
> +#include "dell-uart-backlight.h"
> +
> +struct dell_uart_backlight {
> + struct device *dev;
> + struct backlight_device *dell_uart_bd;
> + struct mutex brightness_mutex;
> + int line;
> + int bl_power;
> +};
> +struct uart_8250_port *serial8250_get_port(int line);
> +struct tty_struct *tty;
> +struct file *ftty;

Should tty and ftty be static?

> +
> +unsigned int (*io_serial_in)(struct uart_port *p, int offset);
> +int (*uart_write)(struct tty_struct *tty, const unsigned char *buf, int count);
> +int (*uart_chars_in_buffer)(struct tty_struct *tty);
> +
> +static struct dell_uart_bl_cmd uart_cmd[] = {

Would it make sense for uart_cmd to be also const?

> + /*
> + * Get Firmware Version: Tool uses this command to get firmware version.
> + * Command: 0x6A 0x06 0x8F (Length:3 Type: 0x0A, Cmd:6 Checksum:0x8F)
> + * Return data: 0x0D 0x06 Data checksum (Length:13,Cmd:0x06,
> + *        Data :F/W version(APRILIA=APR27-VXXX,PHINE=PHI23-VXXX),
> + *        checksum:SUM(Length and Cmd and Data)xor 0xFF .
> + */
> + [DELL_UART_GET_FIRMWARE_VER] = {
> + .cmd = {0x6A, 0x06, 0x8F},
> + .tx_len = 3,
> + },
> + /*
> + * Get Brightness level: Application uses this command for scaler to get brightness.
> + * Command: 0x6A 0x0C 0x89 (Length:3 Type: 0x0A, Cmd:0x0C, Checksum:0x89)
> + * Return data: 0x04 0x0C Data checksum
> + * (Length:4 Cmd: 0x0C Data: brightness level checksum: SUM(Length and Cmd and Data)xor 0xFF)
> + *           brightness level which ranges from 0~100.
> + */
> + [DELL_UART_GET_BRIGHTNESS] = {
> + .cmd = {0x6A, 0x0C, 0x89},
> + .ret = {0x04, 0x0C, 0x00, 0x00},
> + .tx_len = 3,
> + .rx_len = 4,
> + },
> + /* Set Brightness level: Application uses this command for scaler to set brightness.
> + * Command: 0x8A 0x0B Byte2 Checksum (Length:4 Type: 0x0A, Cmd:0x0B)
> + *    where Byte2 is the brightness level which ranges from 0~100.
> + * Return data: 0x03 0x0B 0xF1(Length:3,Cmd:B,checksum:0xF1)
> + * Scaler must send the 3bytes ack within 1 second when success, other value if error
> + */
> + [DELL_UART_SET_BRIGHTNESS] = {
> + .cmd = {0x8A, 0x0B, 0x0, 0x0},
> + .ret = {0x03, 0x0B, 0xF1},
> + .tx_len = 4,
> + .rx_len = 3,
> + },
> + /*
> + * Screen ON/OFF Control: Application uses this command to control screen ON or OFF.
> + * Command: 0x8A 0x0E Byte2 Checksum (Length:4 Type: 0x0A, Cmd:0x0E) where
> + *    Byte2=0 to turn OFF the screen.
> + *    Byte2=1 to turn ON the screen
> + *    Other value of Byte2 is reserved and invalid.
> + * Return data: 0x03 0x0E 0xEE(Length:3,Cmd:E,checksum:0xEE)
> + */
> + [DELL_UART_SET_BACKLIGHT_POWER] = {
> + .cmd = {0x8A, 0x0E, 0x00, 0x0},
> + .ret = {0x03, 0x0E, 0xEE},
> + .tx_len = 4,
> + .rx_len = 3,
> + },
> +};
> +
> +static int dell_uart_write(struct uart_8250_port *up, __u8 *buf, int len)
> +{
> + int actual = 0;
> + struct uart_port *port = &up->port;
> +
> + tty_port_tty_wakeup(&port->state->port);
> + tty = tty_port_tty_get(&port->state->port);
> + actual = uart_write(tty, buf, len);
> + while (uart_chars_in_buffer(tty)) {
> + udelay(10);
> + }
> +
> + return actual;
> +}
> +
> +static int dell_uart_read(struct uart_8250_port *up, __u8 *buf, int len)
> +{
> + int i, retry;
> + unsigned long flags;
> +
> + spin_lock_irqsave(&up->port.lock, flags);
> + for (i = 0; i < len; i++) {
> + retry = 10;
> + while (!(io_serial_in(&up->port, UART_LSR) & UART_LSR_DR)) {
> + if (--retry == 0)
> + break;
> + mdelay(20);
> + }
> +
> + if (retry == 0)
> + break;
> + buf[i] = io_serial_in(&up->port, UART_RX);
> + }
> + spin_unlock_irqrestore(&up->port.lock, flags);
> +
> + return i;
> +}
> +
> +static void dell_uart_dump_cmd(const char *func, const char *prefix,
> +       const char *cmd, int len)
> +{
> + char buf[80];
> +
> + snprintf(buf, 80, "dell_uart_backlight:%s:%s", func, prefix);
> + if (len != 0)
> + print_hex_dump_debug(buf, DUMP_PREFIX_NONE,
> + 16, 1, cmd, len, false);
> + else
> + pr_debug("dell_uart_backlight:%s:%sNULL\n", func, prefix);
> +
> +}
> +
> +/*
> + * checksum: SUM(Length and Cmd and Data)xor 0xFF)
> + */
> +static unsigned char dell_uart_checksum(unsigned char *buf, int len)
> +{
> + unsigned char val = 0;
> +
> + while (len-- > 0)
> + val += buf[len];
> +
> + return val ^ 0xff;
> +}
> +
> +/*
> + * There is no command to get backlight power status,
> + * so we set the backlight power to "on" while initializing,
> + * and then track and report its status by bl_power variable
> + */
> +static int inline dell_uart_get_bl_power(struct dell_uart_backlight *dell_pdata)
> +{
> + return dell_pdata->bl_power;
> +}
> +
> +static int dell_uart_set_bl_power(struct backlight_device *bd, int power)
> +{
> + struct dell_uart_bl_cmd *bl_cmd =
> + &uart_cmd[DELL_UART_SET_BACKLIGHT_POWER];
> + struct dell_uart_backlight *dell_pdata = bl_get_data(bd);
> + struct uart_8250_port *uart = serial8250_get_port(dell_pdata->line);
> + int rx_len;
> +
> + if (power != FB_BLANK_POWERDOWN)
> + power = FB_BLANK_UNBLANK;
> +
> + bl_cmd->cmd[2] = power ? 0 : 1;
> + bl_cmd->cmd[3] = dell_uart_checksum(bl_cmd->cmd, bl_cmd->tx_len - 1);
> +
> + dell_uart_dump_cmd(__func__, "tx: ", bl_cmd->cmd, bl_cmd->tx_len);
> +
> + if (mutex_lock_killable(&dell_pdata->brightness_mutex) < 0) {
> + pr_debug("Failed to get mutex_lock");
> + return 0;
> + }
> +
> + dell_uart_write(uart, bl_cmd->cmd, bl_cmd->tx_len);
> + rx_len = dell_uart_read(uart, bl_cmd->ret, bl_cmd->rx_len);
> +
> + mutex_unlock(&dell_pdata->brightness_mutex);
> +
> + dell_uart_dump_cmd(__func__, "rx: ", bl_cmd->ret, rx_len);
> +
> + bd->props.power = power;
> + dell_pdata->bl_power = power;
> +
> + return 0;
> +}
> +
> +static int dell_uart_get_brightness(struct backlight_device *bd)
> +{
> + struct dell_uart_bl_cmd *bl_cmd = &uart_cmd[DELL_UART_GET_BRIGHTNESS];
> + struct dell_uart_backlight *dell_pdata = bl_get_data(bd);
> + struct uart_8250_port *uart = serial8250_get_port(dell_pdata->line);
> + int rx_len, brightness = 0;
> +
> + dell_uart_dump_cmd(__func__, "tx: ", bl_cmd->cmd, bl_cmd->tx_len);
> +
> + if (mutex_lock_killable(&dell_pdata->brightness_mutex) < 0) {
> + pr_debug("Failed to get mutex_lock");
> + return 0;
> + }
> +
> + dell_uart_write(uart, bl_cmd->cmd, bl_cmd->tx_len);
> + rx_len = dell_uart_read(uart, bl_cmd->ret, bl_cmd->rx_len);
> +
> + mutex_unlock(&dell_pdata->brightness_mutex);
> +
> + dell_uart_dump_cmd(__func__, "rx: ", bl_cmd->ret, rx_len);
> +
> + brightness = (unsigned int)bl_cmd->ret[2];
> +
> + return brightness;
> +}
> +
> +static int dell_uart_update_status(struct backlight_device *bd)
> +{
> + struct dell_uart_bl_cmd *bl_cmd = &uart_cmd[DELL_UART_SET_BRIGHTNESS];
> + struct dell_uart_backlight *dell_pdata = bl_get_data(bd);
> + struct uart_8250_port *uart = serial8250_get_port(dell_pdata->line);
> + int rx_len;
> +
> + bl_cmd->cmd[2] = bd->props.brightness;
> + bl_cmd->cmd[3] = dell_uart_checksum(bl_cmd->cmd, bl_cmd->tx_len - 1);
> +
> + dell_uart_dump_cmd(__func__, "tx: ", bl_cmd->cmd, bl_cmd->tx_len);
> +
> + if (mutex_lock_killable(&dell_pdata->brightness_mutex) < 0) {
> + pr_debug("Failed to get mutex_lock");
> + return 0;
> + }
> +
> + dell_uart_write(uart, bl_cmd->cmd, bl_cmd->tx_len);
> + rx_len = dell_uart_read(uart, bl_cmd->ret, bl_cmd->rx_len);
> +
> + mutex_unlock(&dell_pdata->brightness_mutex);
> +
> + dell_uart_dump_cmd(__func__, "rx: ", bl_cmd->ret, rx_len);
> +
> + if (bd->props.power != dell_uart_get_bl_power(dell_pdata))
> + dell_uart_set_bl_power(bd, bd->props.power);
> +
> + return 0;
> +}
> +
> +static int dell_uart_get_scalar_status(struct dell_uart_backlight *dell_pdata)
> +{
> + struct dell_uart_bl_cmd *bl_cmd = &uart_cmd[DELL_UART_GET_SCALAR];
> + struct uart_8250_port *uart = serial8250_get_port(dell_pdata->line);
> + int rx_len, status = 1; /* assume the scalar IC controls backlight if the command failed */
> +
> + dell_uart_dump_cmd(__func__, "tx: ", bl_cmd->cmd, bl_cmd->tx_len);
> +
> + if (mutex_lock_killable(&dell_pdata->brightness_mutex) < 0) {
> + pr_debug("Failed to get mutex_lock");
> + return 0;
> + }
> +
> + dell_uart_write(uart, bl_cmd->cmd, bl_cmd->tx_len);
> + rx_len = dell_uart_read(uart, bl_cmd->ret, bl_cmd->rx_len);
> +
> + mutex_unlock(&dell_pdata->brightness_mutex);
> +
> + dell_uart_dump_cmd(__func__, "rx: ", bl_cmd->ret, rx_len);
> +
> + if (rx_len == 4)
> + status = (unsigned int)bl_cmd->ret[2];
> +
> + return status;
> +}
> +
> +static int dell_uart_show_firmware_ver(struct dell_uart_backlight *dell_pdata)
> +{
> + struct dell_uart_bl_cmd *bl_cmd = &uart_cmd[DELL_UART_GET_FIRMWARE_VER];
> + struct uart_8250_port *uart = serial8250_get_port(dell_pdata->line);
> + int rx_len = 0, retry = 10;
> +
> + dell_uart_dump_cmd(__func__, "tx: ", bl_cmd->cmd, bl_cmd->tx_len);
> +
> + if (mutex_lock_killable(&dell_pdata->brightness_mutex) < 0) {
> + pr_debug("Failed to get mutex_lock");
> + return -1;
> + }
> +
> + dell_uart_write(uart, bl_cmd->cmd, bl_cmd->tx_len);
> + while (retry-- > 0) {
> + /* first byte is data length */
> + dell_uart_read(uart, bl_cmd->ret, 1);
> + rx_len = (int)bl_cmd->ret[0];
> + if (bl_cmd->ret[0] > 80 || bl_cmd->ret[0] <= 0) {

Minor quibble, bl_cmd->ret is unsigned char, so it can never be < than
zero. Perhaps bl_cmd->ret[0] == 0 is better

> + pr_debug("Failed to get firmware version\n");
> + if (retry == 0) {
> + mutex_unlock(&dell_pdata->brightness_mutex);
> + return -1;
> + }
> + msleep(100);
> + continue;
> + }
> +
> + dell_uart_read(uart, bl_cmd->ret+1, rx_len-1);
> + break;
> + }
> + mutex_unlock(&dell_pdata->brightness_mutex);
> +
> + dell_uart_dump_cmd(__func__, "rx: ", bl_cmd->ret, rx_len);
> +
> + pr_debug("Firmare str(%d)= %s\n", (int)bl_cmd->ret[0], bl_cmd->ret+2);
> + return rx_len;
> +}
> +
> +static const struct backlight_ops dell_uart_backlight_ops = {
> + .get_brightness = dell_uart_get_brightness,
> + .update_status = dell_uart_update_status,
> +};
> +
> +static int dell_uart_startup(struct dell_uart_backlight *dell_pdata)
> +{
> + struct uart_8250_port *uartp;
> + struct uart_port *port;
> +
> + dell_pdata->line = 0;
> + uartp = serial8250_get_port(dell_pdata->line);
> + port = &uartp->port;
> + tty = port->state->port.tty;
> + io_serial_in = port->serial_in;
> + uart_write = tty->driver->ops->write;
> + uart_chars_in_buffer = tty->driver->ops->chars_in_buffer;
> +
> + return 0;
> +}
> +
> +static int dell_uart_bl_add(struct acpi_device *dev)
> +{
> + struct dell_uart_backlight *dell_pdata;
> + struct backlight_properties props;
> + struct backlight_device *dell_uart_bd;
> +
> + dell_pdata = kzalloc(sizeof(struct dell_uart_backlight), GFP_KERNEL);
> + if (!dell_pdata) {
> + pr_debug("Failed to allocate memory for dell_uart_backlight\n");
> + return -1;
> + }
> + dell_pdata->dev = &dev->dev;
> + dell_uart_startup(dell_pdata);
> + dev->driver_data = dell_pdata;
> +
> + mutex_init(&dell_pdata->brightness_mutex);
> +
> + if (!dell_uart_get_scalar_status(dell_pdata)) {
> + udelay(50);
> + /* try another command to make sure there is no scalar IC */
> + if (dell_uart_show_firmware_ver(dell_pdata) <= 0) {
> + pr_debug("Scalar is not in charge of brightness adjustment.\n");
> + kzfree(dell_pdata);
> + return -1;
> + }
> + }
> +
> + memset(&props, 0, sizeof(struct backlight_properties));
> + props.type = BACKLIGHT_PLATFORM;
> + props.max_brightness = 100;
> +
> + dell_uart_bd = backlight_device_register("dell_uart_backlight",
> + &dev->dev,
> + dell_pdata,
> + &dell_uart_backlight_ops,
> + &props);
> + if (IS_ERR(dell_uart_bd)) {
> + kzfree(dell_pdata);
> + pr_debug("Backlight registration failed\n");
> + return -1;
> + }
> +
> + dell_pdata->dell_uart_bd = dell_uart_bd;
> +
> + dell_uart_set_bl_power(dell_uart_bd, FB_BLANK_UNBLANK);
> + dell_uart_bd->props.brightness = 100;
> + backlight_update_status(dell_uart_bd);
> +
> + /* unregister acpi backlight interface */
> + acpi_video_set_dmi_backlight_type(acpi_backlight_vendor);
> +
> + return 0;
> +}
> +
> +static int dell_uart_bl_remove(struct acpi_device *dev)
> +{
> + struct dell_uart_backlight *dell_pdata = dev->driver_data;
> +
> + backlight_device_unregister(dell_pdata->dell_uart_bd);
> + kzfree(dell_pdata);
> +
> + return 0;
> +}
> +
> +static int dell_uart_bl_suspend(struct device *dev)
> +{
> + filp_close(ftty, NULL);
> + return 0;
> +}
> +
> +static int dell_uart_bl_resume(struct device *dev)
> +{
> + ftty = filp_open("/dev/ttyS0", O_RDWR | O_NOCTTY | O_NDELAY, 0);
> + return 0;
> +}
> +
> +static SIMPLE_DEV_PM_OPS(dell_uart_bl_pm, dell_uart_bl_suspend, dell_uart_bl_resume);
> +
> +static const struct acpi_device_id dell_uart_bl_ids[] = {
> + {"DELL0501", 0},
> + {"", 0},
> +};
> +
> +static struct acpi_driver dell_uart_backlight_driver = {
> + .name = "Dell AIO serial backlight",
> + .ids = dell_uart_bl_ids,
> + .ops = {
> + .add = dell_uart_bl_add,
> + .remove = dell_uart_bl_remove,
> + },
> + .drv.pm = &dell_uart_bl_pm,
> +};
> +
> +static int __init dell_uart_bl_init(void)
> +{
> + ftty = filp_open("/dev/ttyS0", O_RDWR | O_NOCTTY | O_NDELAY, 0);
> + if (IS_ERR(ftty)) {
> + pr_debug("cannot open /dev/ttyS0\n");
> + return -EINVAL;
> + }
> +
> + return acpi_bus_register_driver(&dell_uart_backlight_driver);
> +}
> +
> +static void __exit dell_uart_bl_exit(void)
> +{
> + filp_close(ftty, NULL);
> +
> + acpi_bus_unregister_driver(&dell_uart_backlight_driver);
> +}
> +
> +module_init(dell_uart_bl_init);
> +module_exit(dell_uart_bl_exit);
> +MODULE_DEVICE_TABLE(acpi, dell_uart_bl_ids);
> +MODULE_DESCRIPTION("Dell AIO Serial Backlight module");
> +MODULE_AUTHOR("AceLan Kao <[hidden email]>");
> +MODULE_LICENSE("GPL");
> diff --git a/drivers/platform/x86/dell-uart-backlight.h b/drivers/platform/x86/dell-uart-backlight.h
> new file mode 100644
> index 000000000000..e4fe74fae6a8
> --- /dev/null
> +++ b/drivers/platform/x86/dell-uart-backlight.h
> @@ -0,0 +1,36 @@
> +/*
> + *  Dell AIO Serial Backlight Driver
> + *
> + *  Copyright (C) 2017 AceLan Kao <[hidden email]>
> + *
> + *  This program is free software; you can redistribute it and/or modify
> + *  it under the terms of the GNU General Public License as published by
> + *  the Free Software Foundation; either version 2 of the License, or
> + *  (at your option) any later version.
> + *
> + *  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.
> + *
> + */
> +
> +#ifndef _DELL_UART_BACKLIGHT_H_
> +#define _DELL_UART_BACKLIGHT_H_
> +
> +enum {
> + DELL_UART_GET_FIRMWARE_VER,
> + DELL_UART_GET_SCALAR,
> + DELL_UART_GET_BRIGHTNESS,
> + DELL_UART_SET_BRIGHTNESS,
> + DELL_UART_SET_BACKLIGHT_POWER,
> +};
> +
> +struct dell_uart_bl_cmd {
> + unsigned char cmd[10];
> + unsigned char ret[80];
> + unsigned short tx_len;
> + unsigned short rx_len;
> +};
> +
> +#endif /* _DELL_UART_BACKLIGHT_H_ */
>


--
kernel-team mailing list
[hidden email]
https://lists.ubuntu.com/mailman/listinfo/kernel-team
Reply | Threaded
Open this post in threaded view
|

Re: [PATCH v3 1/2] UBUNTU: SAUCE: platform/x86: dell-uart-backlight: new backlight driver for DELL AIO

AceLan Kao
Colin Ian King <[hidden email]> 於 2018年9月7日 週五 下午5:11寫道:

>
> On 06/09/18 09:19, AceLan Kao wrote:
> > BugLink: https://bugs.launchpad.net/bugs/1727235
> >
> > The Dell AIO machines released after 2017 come with a UART interface
> > to communicate with the backlight scalar board. This driver creates
> > a standard backlight interface and talks to the scalar board through
> > UART.
> >
> > In DSDT this uart port will be defined as
> >    Name (_HID, "DELL0501")
> >    Name (_CID, EisaId ("PNP0501")
> > The 8250 PNP driver will be loaded by default, and this driver uses
> > "DELL0501" to confirm the uart port is a backlight interface and
> > leverage the port created by 8250 PNP driver to communicate with
> > the scalar board.
> >
> > v2:
> >    1. move struct uart_cmd to .c file
> >    2. make dell_uart_get_bl_power() inline
> >    3. add space to ternary operator "bl_cmd->cmd[2] = power ? 0 : 1;"
> >    4. check return value of kzalloc()
> >    5. add kzfree()
> >    6. check return value of backlight_device_register()
> >    7. check return value of filp_open() at init
> > v3:
> >    1. Fix compiling warning.
> >
> > Signed-off-by: AceLan Kao <[hidden email]>
> > ---
> >  drivers/platform/x86/Kconfig               |  14 +
> >  drivers/platform/x86/Makefile              |   1 +
> >  drivers/platform/x86/dell-uart-backlight.c | 463 +++++++++++++++++++++
> >  drivers/platform/x86/dell-uart-backlight.h |  36 ++
> >  4 files changed, 514 insertions(+)
> >  create mode 100644 drivers/platform/x86/dell-uart-backlight.c
> >  create mode 100644 drivers/platform/x86/dell-uart-backlight.h
> >
> > diff --git a/drivers/platform/x86/Kconfig b/drivers/platform/x86/Kconfig
> > index b6ac37a5d06d..b6ce1a5b01e5 100644
> > --- a/drivers/platform/x86/Kconfig
> > +++ b/drivers/platform/x86/Kconfig
> > @@ -199,6 +199,20 @@ config DELL_RBTN
> >         To compile this driver as a module, choose M here: the module will
> >         be called dell-rbtn.
> >
> > +config DELL_UART_BACKLIGHT
> > +     tristate "Dell AIO UART Backlight driver"
> > +     depends on SERIAL_8250
> > +     depends on ACPI
> > +     ---help---
> > +       Say Y here if you want to support Dell AIO UART backlight interface.
> > +       The Dell AIO machines released after 2017 come with a UART interface
> > +       to communicate with the backlight scalar board. This driver creates
> > +       a standard backlight interface and talks to the scalar board through
> > +       UART to adjust the AIO screen brightness.
> > +
> > +       To compile this driver as a module, choose M here: the module will
> > +       be called dell_uart_backlight.
> > +
> >
> >  config FUJITSU_LAPTOP
> >       tristate "Fujitsu Laptop Extras"
> > diff --git a/drivers/platform/x86/Makefile b/drivers/platform/x86/Makefile
> > index c32b34a72467..85329fd26afd 100644
> > --- a/drivers/platform/x86/Makefile
> > +++ b/drivers/platform/x86/Makefile
> > @@ -22,6 +22,7 @@ obj-$(CONFIG_DELL_WMI_AIO)  += dell-wmi-aio.o
> >  obj-$(CONFIG_DELL_WMI_LED)   += dell-wmi-led.o
> >  obj-$(CONFIG_DELL_SMO8800)   += dell-smo8800.o
> >  obj-$(CONFIG_DELL_RBTN)              += dell-rbtn.o
> > +obj-$(CONFIG_DELL_UART_BACKLIGHT) += dell-uart-backlight.o
> >  obj-$(CONFIG_ACER_WMI)               += acer-wmi.o
> >  obj-$(CONFIG_ACERHDF)                += acerhdf.o
> >  obj-$(CONFIG_HP_ACCEL)               += hp_accel.o
> > diff --git a/drivers/platform/x86/dell-uart-backlight.c b/drivers/platform/x86/dell-uart-backlight.c
> > new file mode 100644
> > index 000000000000..eae075cfcadb
> > --- /dev/null
> > +++ b/drivers/platform/x86/dell-uart-backlight.c
> > @@ -0,0 +1,463 @@
> > +/*
> > + *  Dell AIO Serial Backlight Driver
> > + *
> > + *  Copyright (C) 2017 AceLan Kao <[hidden email]>
> > + *
> > + *  This program is free software; you can redistribute it and/or modify
> > + *  it under the terms of the GNU General Public License as published by
> > + *  the Free Software Foundation; either version 2 of the License, or
> > + *  (at your option) any later version.
> > + *
> > + *  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.
> > + *
> > + */
> > +
> > +#include <linux/kernel.h>
> > +#include <linux/module.h>
> > +#include <linux/acpi.h>
> > +#include <linux/serial_8250.h>
> > +#include <linux/delay.h>
> > +#include <linux/backlight.h>
> > +#include <acpi/video.h>
> > +
> > +#include "dell-uart-backlight.h"
> > +
> > +struct dell_uart_backlight {
> > +     struct device *dev;
> > +     struct backlight_device *dell_uart_bd;
> > +     struct mutex brightness_mutex;
> > +     int line;
> > +     int bl_power;
> > +};
> > +struct uart_8250_port *serial8250_get_port(int line);
> > +struct tty_struct *tty;
> > +struct file *ftty;
>
> Should tty and ftty be static?
Right, thanks.

>
> > +
> > +unsigned int (*io_serial_in)(struct uart_port *p, int offset);
> > +int (*uart_write)(struct tty_struct *tty, const unsigned char *buf, int count);
> > +int (*uart_chars_in_buffer)(struct tty_struct *tty);
> > +
> > +static struct dell_uart_bl_cmd uart_cmd[] = {
>
> Would it make sense for uart_cmd to be also const?
uart_cmd provides the return buffer, so it can't be const

>
> > +     /*
> > +      * Get Firmware Version: Tool uses this command to get firmware version.
> > +      * Command: 0x6A 0x06 0x8F (Length:3 Type: 0x0A, Cmd:6 Checksum:0x8F)
> > +      * Return data: 0x0D 0x06 Data checksum (Length:13,Cmd:0x06,
> > +      *              Data :F/W version(APRILIA=APR27-VXXX,PHINE=PHI23-VXXX),
> > +      *              checksum:SUM(Length and Cmd and Data)xor 0xFF .
> > +      */
> > +     [DELL_UART_GET_FIRMWARE_VER] = {
> > +             .cmd    = {0x6A, 0x06, 0x8F},
> > +             .tx_len = 3,
> > +     },
> > +     /*
> > +      * Get Brightness level: Application uses this command for scaler to get brightness.
> > +      * Command: 0x6A 0x0C 0x89 (Length:3 Type: 0x0A, Cmd:0x0C, Checksum:0x89)
> > +      * Return data: 0x04 0x0C Data checksum
> > +      * (Length:4 Cmd: 0x0C Data: brightness level checksum: SUM(Length and Cmd and Data)xor 0xFF)
> > +      *           brightness level which ranges from 0~100.
> > +      */
> > +     [DELL_UART_GET_BRIGHTNESS] = {
> > +             .cmd    = {0x6A, 0x0C, 0x89},
> > +             .ret    = {0x04, 0x0C, 0x00, 0x00},
> > +             .tx_len = 3,
> > +             .rx_len = 4,
> > +     },
> > +     /* Set Brightness level: Application uses this command for scaler to set brightness.
> > +      * Command: 0x8A 0x0B Byte2 Checksum (Length:4 Type: 0x0A, Cmd:0x0B)
> > +      *          where Byte2 is the brightness level which ranges from 0~100.
> > +      * Return data: 0x03 0x0B 0xF1(Length:3,Cmd:B,checksum:0xF1)
> > +      * Scaler must send the 3bytes ack within 1 second when success, other value if error
> > +      */
> > +     [DELL_UART_SET_BRIGHTNESS] = {
> > +             .cmd    = {0x8A, 0x0B, 0x0, 0x0},
> > +             .ret    = {0x03, 0x0B, 0xF1},
> > +             .tx_len = 4,
> > +             .rx_len = 3,
> > +     },
> > +     /*
> > +      * Screen ON/OFF Control: Application uses this command to control screen ON or OFF.
> > +      * Command: 0x8A 0x0E Byte2 Checksum (Length:4 Type: 0x0A, Cmd:0x0E) where
> > +      *          Byte2=0 to turn OFF the screen.
> > +      *          Byte2=1 to turn ON the screen
> > +      *          Other value of Byte2 is reserved and invalid.
> > +      * Return data: 0x03 0x0E 0xEE(Length:3,Cmd:E,checksum:0xEE)
> > +      */
> > +     [DELL_UART_SET_BACKLIGHT_POWER] = {
> > +             .cmd    = {0x8A, 0x0E, 0x00, 0x0},
> > +             .ret    = {0x03, 0x0E, 0xEE},
> > +             .tx_len = 4,
> > +             .rx_len = 3,
> > +     },
> > +};
> > +
> > +static int dell_uart_write(struct uart_8250_port *up, __u8 *buf, int len)
> > +{
> > +     int actual = 0;
> > +     struct uart_port *port = &up->port;
> > +
> > +     tty_port_tty_wakeup(&port->state->port);
> > +     tty = tty_port_tty_get(&port->state->port);
> > +     actual = uart_write(tty, buf, len);
> > +     while (uart_chars_in_buffer(tty)) {
> > +             udelay(10);
> > +     }
> > +
> > +     return actual;
> > +}
> > +
> > +static int dell_uart_read(struct uart_8250_port *up, __u8 *buf, int len)
> > +{
> > +     int i, retry;
> > +     unsigned long flags;
> > +
> > +     spin_lock_irqsave(&up->port.lock, flags);
> > +     for (i = 0; i < len; i++) {
> > +             retry = 10;
> > +             while (!(io_serial_in(&up->port, UART_LSR) & UART_LSR_DR)) {
> > +                     if (--retry == 0)
> > +                             break;
> > +                     mdelay(20);
> > +             }
> > +
> > +             if (retry == 0)
> > +                     break;
> > +             buf[i] = io_serial_in(&up->port, UART_RX);
> > +     }
> > +     spin_unlock_irqrestore(&up->port.lock, flags);
> > +
> > +     return i;
> > +}
> > +
> > +static void dell_uart_dump_cmd(const char *func, const char *prefix,
> > +                            const char *cmd, int len)
> > +{
> > +     char buf[80];
> > +
> > +     snprintf(buf, 80, "dell_uart_backlight:%s:%s", func, prefix);
> > +     if (len != 0)
> > +             print_hex_dump_debug(buf, DUMP_PREFIX_NONE,
> > +                                     16, 1, cmd, len, false);
> > +     else
> > +             pr_debug("dell_uart_backlight:%s:%sNULL\n", func, prefix);
> > +
> > +}
> > +
> > +/*
> > + * checksum: SUM(Length and Cmd and Data)xor 0xFF)
> > + */
> > +static unsigned char dell_uart_checksum(unsigned char *buf, int len)
> > +{
> > +     unsigned char val = 0;
> > +
> > +     while (len-- > 0)
> > +             val += buf[len];
> > +
> > +     return val ^ 0xff;
> > +}
> > +
> > +/*
> > + * There is no command to get backlight power status,
> > + * so we set the backlight power to "on" while initializing,
> > + * and then track and report its status by bl_power variable
> > + */
> > +static int inline dell_uart_get_bl_power(struct dell_uart_backlight *dell_pdata)
> > +{
> > +     return dell_pdata->bl_power;
> > +}
> > +
> > +static int dell_uart_set_bl_power(struct backlight_device *bd, int power)
> > +{
> > +     struct dell_uart_bl_cmd *bl_cmd =
> > +             &uart_cmd[DELL_UART_SET_BACKLIGHT_POWER];
> > +     struct dell_uart_backlight *dell_pdata = bl_get_data(bd);
> > +     struct uart_8250_port *uart = serial8250_get_port(dell_pdata->line);
> > +     int rx_len;
> > +
> > +     if (power != FB_BLANK_POWERDOWN)
> > +             power = FB_BLANK_UNBLANK;
> > +
> > +     bl_cmd->cmd[2] = power ? 0 : 1;
> > +     bl_cmd->cmd[3] = dell_uart_checksum(bl_cmd->cmd, bl_cmd->tx_len - 1);
> > +
> > +     dell_uart_dump_cmd(__func__, "tx: ", bl_cmd->cmd, bl_cmd->tx_len);
> > +
> > +     if (mutex_lock_killable(&dell_pdata->brightness_mutex) < 0) {
> > +             pr_debug("Failed to get mutex_lock");
> > +             return 0;
> > +     }
> > +
> > +     dell_uart_write(uart, bl_cmd->cmd, bl_cmd->tx_len);
> > +     rx_len = dell_uart_read(uart, bl_cmd->ret, bl_cmd->rx_len);
> > +
> > +     mutex_unlock(&dell_pdata->brightness_mutex);
> > +
> > +     dell_uart_dump_cmd(__func__, "rx: ", bl_cmd->ret, rx_len);
> > +
> > +     bd->props.power = power;
> > +     dell_pdata->bl_power = power;
> > +
> > +     return 0;
> > +}
> > +
> > +static int dell_uart_get_brightness(struct backlight_device *bd)
> > +{
> > +     struct dell_uart_bl_cmd *bl_cmd = &uart_cmd[DELL_UART_GET_BRIGHTNESS];
> > +     struct dell_uart_backlight *dell_pdata = bl_get_data(bd);
> > +     struct uart_8250_port *uart = serial8250_get_port(dell_pdata->line);
> > +     int rx_len, brightness = 0;
> > +
> > +     dell_uart_dump_cmd(__func__, "tx: ", bl_cmd->cmd, bl_cmd->tx_len);
> > +
> > +     if (mutex_lock_killable(&dell_pdata->brightness_mutex) < 0) {
> > +             pr_debug("Failed to get mutex_lock");
> > +             return 0;
> > +     }
> > +
> > +     dell_uart_write(uart, bl_cmd->cmd, bl_cmd->tx_len);
> > +     rx_len = dell_uart_read(uart, bl_cmd->ret, bl_cmd->rx_len);
> > +
> > +     mutex_unlock(&dell_pdata->brightness_mutex);
> > +
> > +     dell_uart_dump_cmd(__func__, "rx: ", bl_cmd->ret, rx_len);
> > +
> > +     brightness = (unsigned int)bl_cmd->ret[2];
> > +
> > +     return brightness;
> > +}
> > +
> > +static int dell_uart_update_status(struct backlight_device *bd)
> > +{
> > +     struct dell_uart_bl_cmd *bl_cmd = &uart_cmd[DELL_UART_SET_BRIGHTNESS];
> > +     struct dell_uart_backlight *dell_pdata = bl_get_data(bd);
> > +     struct uart_8250_port *uart = serial8250_get_port(dell_pdata->line);
> > +     int rx_len;
> > +
> > +     bl_cmd->cmd[2] = bd->props.brightness;
> > +     bl_cmd->cmd[3] = dell_uart_checksum(bl_cmd->cmd, bl_cmd->tx_len - 1);
> > +
> > +     dell_uart_dump_cmd(__func__, "tx: ", bl_cmd->cmd, bl_cmd->tx_len);
> > +
> > +     if (mutex_lock_killable(&dell_pdata->brightness_mutex) < 0) {
> > +             pr_debug("Failed to get mutex_lock");
> > +             return 0;
> > +     }
> > +
> > +     dell_uart_write(uart, bl_cmd->cmd, bl_cmd->tx_len);
> > +     rx_len = dell_uart_read(uart, bl_cmd->ret, bl_cmd->rx_len);
> > +
> > +     mutex_unlock(&dell_pdata->brightness_mutex);
> > +
> > +     dell_uart_dump_cmd(__func__, "rx: ", bl_cmd->ret, rx_len);
> > +
> > +     if (bd->props.power != dell_uart_get_bl_power(dell_pdata))
> > +             dell_uart_set_bl_power(bd, bd->props.power);
> > +
> > +     return 0;
> > +}
> > +
> > +static int dell_uart_get_scalar_status(struct dell_uart_backlight *dell_pdata)
> > +{
> > +     struct dell_uart_bl_cmd *bl_cmd = &uart_cmd[DELL_UART_GET_SCALAR];
> > +     struct uart_8250_port *uart = serial8250_get_port(dell_pdata->line);
> > +     int rx_len, status = 1; /* assume the scalar IC controls backlight if the command failed */
> > +
> > +     dell_uart_dump_cmd(__func__, "tx: ", bl_cmd->cmd, bl_cmd->tx_len);
> > +
> > +     if (mutex_lock_killable(&dell_pdata->brightness_mutex) < 0) {
> > +             pr_debug("Failed to get mutex_lock");
> > +             return 0;
> > +     }
> > +
> > +     dell_uart_write(uart, bl_cmd->cmd, bl_cmd->tx_len);
> > +     rx_len = dell_uart_read(uart, bl_cmd->ret, bl_cmd->rx_len);
> > +
> > +     mutex_unlock(&dell_pdata->brightness_mutex);
> > +
> > +     dell_uart_dump_cmd(__func__, "rx: ", bl_cmd->ret, rx_len);
> > +
> > +     if (rx_len == 4)
> > +             status = (unsigned int)bl_cmd->ret[2];
> > +
> > +     return status;
> > +}
> > +
> > +static int dell_uart_show_firmware_ver(struct dell_uart_backlight *dell_pdata)
> > +{
> > +     struct dell_uart_bl_cmd *bl_cmd = &uart_cmd[DELL_UART_GET_FIRMWARE_VER];
> > +     struct uart_8250_port *uart = serial8250_get_port(dell_pdata->line);
> > +     int rx_len = 0, retry = 10;
> > +
> > +     dell_uart_dump_cmd(__func__, "tx: ", bl_cmd->cmd, bl_cmd->tx_len);
> > +
> > +     if (mutex_lock_killable(&dell_pdata->brightness_mutex) < 0) {
> > +             pr_debug("Failed to get mutex_lock");
> > +             return -1;
> > +     }
> > +
> > +     dell_uart_write(uart, bl_cmd->cmd, bl_cmd->tx_len);
> > +     while (retry-- > 0) {
> > +             /* first byte is data length */
> > +             dell_uart_read(uart, bl_cmd->ret, 1);
> > +             rx_len = (int)bl_cmd->ret[0];
> > +             if (bl_cmd->ret[0] > 80 || bl_cmd->ret[0] <= 0) {
>
> Minor quibble, bl_cmd->ret is unsigned char, so it can never be < than
> zero. Perhaps bl_cmd->ret[0] == 0 is better
Fixed, thanks.

>
> > +                     pr_debug("Failed to get firmware version\n");
> > +                     if (retry == 0) {
> > +                             mutex_unlock(&dell_pdata->brightness_mutex);
> > +                             return -1;
> > +                     }
> > +                     msleep(100);
> > +                     continue;
> > +             }
> > +
> > +             dell_uart_read(uart, bl_cmd->ret+1, rx_len-1);
> > +             break;
> > +     }
> > +     mutex_unlock(&dell_pdata->brightness_mutex);
> > +
> > +     dell_uart_dump_cmd(__func__, "rx: ", bl_cmd->ret, rx_len);
> > +
> > +     pr_debug("Firmare str(%d)= %s\n", (int)bl_cmd->ret[0], bl_cmd->ret+2);
> > +     return rx_len;
> > +}
> > +
> > +static const struct backlight_ops dell_uart_backlight_ops = {
> > +     .get_brightness = dell_uart_get_brightness,
> > +     .update_status = dell_uart_update_status,
> > +};
> > +
> > +static int dell_uart_startup(struct dell_uart_backlight *dell_pdata)
> > +{
> > +     struct uart_8250_port *uartp;
> > +     struct uart_port *port;
> > +
> > +     dell_pdata->line = 0;
> > +     uartp = serial8250_get_port(dell_pdata->line);
> > +     port = &uartp->port;
> > +     tty = port->state->port.tty;
> > +     io_serial_in = port->serial_in;
> > +     uart_write = tty->driver->ops->write;
> > +     uart_chars_in_buffer = tty->driver->ops->chars_in_buffer;
> > +
> > +     return 0;
> > +}
> > +
> > +static int dell_uart_bl_add(struct acpi_device *dev)
> > +{
> > +     struct dell_uart_backlight *dell_pdata;
> > +     struct backlight_properties props;
> > +     struct backlight_device *dell_uart_bd;
> > +
> > +     dell_pdata = kzalloc(sizeof(struct dell_uart_backlight), GFP_KERNEL);
> > +     if (!dell_pdata) {
> > +             pr_debug("Failed to allocate memory for dell_uart_backlight\n");
> > +             return -1;
> > +     }
> > +     dell_pdata->dev = &dev->dev;
> > +     dell_uart_startup(dell_pdata);
> > +     dev->driver_data = dell_pdata;
> > +
> > +     mutex_init(&dell_pdata->brightness_mutex);
> > +
> > +     if (!dell_uart_get_scalar_status(dell_pdata)) {
> > +             udelay(50);
> > +             /* try another command to make sure there is no scalar IC */
> > +             if (dell_uart_show_firmware_ver(dell_pdata) <= 0) {
> > +                     pr_debug("Scalar is not in charge of brightness adjustment.\n");
> > +                     kzfree(dell_pdata);
> > +                     return -1;
> > +             }
> > +     }
> > +
> > +     memset(&props, 0, sizeof(struct backlight_properties));
> > +     props.type = BACKLIGHT_PLATFORM;
> > +     props.max_brightness = 100;
> > +
> > +     dell_uart_bd = backlight_device_register("dell_uart_backlight",
> > +                                              &dev->dev,
> > +                                              dell_pdata,
> > +                                              &dell_uart_backlight_ops,
> > +                                              &props);
> > +     if (IS_ERR(dell_uart_bd)) {
> > +             kzfree(dell_pdata);
> > +             pr_debug("Backlight registration failed\n");
> > +             return -1;
> > +     }
> > +
> > +     dell_pdata->dell_uart_bd = dell_uart_bd;
> > +
> > +     dell_uart_set_bl_power(dell_uart_bd, FB_BLANK_UNBLANK);
> > +     dell_uart_bd->props.brightness = 100;
> > +     backlight_update_status(dell_uart_bd);
> > +
> > +     /* unregister acpi backlight interface */
> > +     acpi_video_set_dmi_backlight_type(acpi_backlight_vendor);
> > +
> > +     return 0;
> > +}
> > +
> > +static int dell_uart_bl_remove(struct acpi_device *dev)
> > +{
> > +     struct dell_uart_backlight *dell_pdata = dev->driver_data;
> > +
> > +     backlight_device_unregister(dell_pdata->dell_uart_bd);
> > +     kzfree(dell_pdata);
> > +
> > +     return 0;
> > +}
> > +
> > +static int dell_uart_bl_suspend(struct device *dev)
> > +{
> > +     filp_close(ftty, NULL);
> > +     return 0;
> > +}
> > +
> > +static int dell_uart_bl_resume(struct device *dev)
> > +{
> > +     ftty = filp_open("/dev/ttyS0", O_RDWR | O_NOCTTY | O_NDELAY, 0);
> > +     return 0;
> > +}
> > +
> > +static SIMPLE_DEV_PM_OPS(dell_uart_bl_pm, dell_uart_bl_suspend, dell_uart_bl_resume);
> > +
> > +static const struct acpi_device_id dell_uart_bl_ids[] = {
> > +     {"DELL0501", 0},
> > +     {"", 0},
> > +};
> > +
> > +static struct acpi_driver dell_uart_backlight_driver = {
> > +     .name = "Dell AIO serial backlight",
> > +     .ids = dell_uart_bl_ids,
> > +     .ops = {
> > +             .add = dell_uart_bl_add,
> > +             .remove = dell_uart_bl_remove,
> > +     },
> > +     .drv.pm = &dell_uart_bl_pm,
> > +};
> > +
> > +static int __init dell_uart_bl_init(void)
> > +{
> > +     ftty = filp_open("/dev/ttyS0", O_RDWR | O_NOCTTY | O_NDELAY, 0);
> > +     if (IS_ERR(ftty)) {
> > +             pr_debug("cannot open /dev/ttyS0\n");
> > +             return -EINVAL;
> > +     }
> > +
> > +     return acpi_bus_register_driver(&dell_uart_backlight_driver);
> > +}
> > +
> > +static void __exit dell_uart_bl_exit(void)
> > +{
> > +     filp_close(ftty, NULL);
> > +
> > +     acpi_bus_unregister_driver(&dell_uart_backlight_driver);
> > +}
> > +
> > +module_init(dell_uart_bl_init);
> > +module_exit(dell_uart_bl_exit);
> > +MODULE_DEVICE_TABLE(acpi, dell_uart_bl_ids);
> > +MODULE_DESCRIPTION("Dell AIO Serial Backlight module");
> > +MODULE_AUTHOR("AceLan Kao <[hidden email]>");
> > +MODULE_LICENSE("GPL");
> > diff --git a/drivers/platform/x86/dell-uart-backlight.h b/drivers/platform/x86/dell-uart-backlight.h
> > new file mode 100644
> > index 000000000000..e4fe74fae6a8
> > --- /dev/null
> > +++ b/drivers/platform/x86/dell-uart-backlight.h
> > @@ -0,0 +1,36 @@
> > +/*
> > + *  Dell AIO Serial Backlight Driver
> > + *
> > + *  Copyright (C) 2017 AceLan Kao <[hidden email]>
> > + *
> > + *  This program is free software; you can redistribute it and/or modify
> > + *  it under the terms of the GNU General Public License as published by
> > + *  the Free Software Foundation; either version 2 of the License, or
> > + *  (at your option) any later version.
> > + *
> > + *  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.
> > + *
> > + */
> > +
> > +#ifndef _DELL_UART_BACKLIGHT_H_
> > +#define _DELL_UART_BACKLIGHT_H_
> > +
> > +enum {
> > +     DELL_UART_GET_FIRMWARE_VER,
> > +     DELL_UART_GET_SCALAR,
> > +     DELL_UART_GET_BRIGHTNESS,
> > +     DELL_UART_SET_BRIGHTNESS,
> > +     DELL_UART_SET_BACKLIGHT_POWER,
> > +};
> > +
> > +struct dell_uart_bl_cmd {
> > +     unsigned char   cmd[10];
> > +     unsigned char   ret[80];
> > +     unsigned short  tx_len;
> > +     unsigned short  rx_len;
> > +};
> > +
> > +#endif /* _DELL_UART_BACKLIGHT_H_ */
> >
I'll submit v4 soon.

--
kernel-team mailing list
[hidden email]
https://lists.ubuntu.com/mailman/listinfo/kernel-team