system/freebsd-src
system/freebsd-src
1
0
Fork 0
mirror of https://github.com/freebsd/freebsd-src synced 2024-07-22 02:37:15 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity
freebsd-src/sys/dev/acpi_support/acpi_asus.c
Mark Johnston bad36a4998 acpi: Use device_set_descf() 
No functional change intended.

MFC after:	1 week
2024-06-02 19:38:41 -04:00

1265 lines
30 KiB
C
Raw Blame History

/*-
* Copyright (c) 2004, 2005 Philip Paeps <philip@FreeBSD.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <sys/cdefs.h>
/*
* Driver for extra ACPI-controlled gadgets (hotkeys, leds, etc) found on
* recent Asus (and Medion) laptops. Inspired by the acpi4asus project which
* implements these features in the Linux kernel.
*
* <http://sourceforge.net/projects/acpi4asus/>
*
* Currently should support most features, but could use some more testing.
* Particularly the display-switching stuff is a bit hairy. If you have an
* Asus laptop which doesn't appear to be supported, or strange things happen
* when using this driver, please report to <acpi@FreeBSD.org>.
*/
#include "opt_acpi.h"
#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/module.h>
#include <sys/bus.h>
#include <contrib/dev/acpica/include/acpi.h>
#include <contrib/dev/acpica/include/accommon.h>
#include <dev/acpica/acpivar.h>
#include <dev/led/led.h>
/* Methods */
#define ACPI_ASUS_METHOD_BRN 1
#define ACPI_ASUS_METHOD_DISP 2
#define ACPI_ASUS_METHOD_LCD 3
#define ACPI_ASUS_METHOD_CAMERA 4
#define ACPI_ASUS_METHOD_CARDRD 5
#define ACPI_ASUS_METHOD_WLAN 6
#define _COMPONENT ACPI_OEM
ACPI_MODULE_NAME("ASUS")
struct acpi_asus_model {
char *name;
char *bled_set;
char *dled_set;
char *gled_set;
char *mled_set;
char *tled_set;
char *wled_set;
char *brn_get;
char *brn_set;
char *brn_up;
char *brn_dn;
char *lcd_get;
char *lcd_set;
char *disp_get;
char *disp_set;
char *cam_get;
char *cam_set;
char *crd_get;
char *crd_set;
char *wlan_get;
char *wlan_set;
void (*n_func)(ACPI_HANDLE, UINT32, void *);
char *lcdd;
void (*lcdd_n_func)(ACPI_HANDLE, UINT32, void *);
};
struct acpi_asus_led {
struct acpi_asus_softc *sc;
struct cdev *cdev;
int busy;
int state;
enum {
ACPI_ASUS_LED_BLED,
ACPI_ASUS_LED_DLED,
ACPI_ASUS_LED_GLED,
ACPI_ASUS_LED_MLED,
ACPI_ASUS_LED_TLED,
ACPI_ASUS_LED_WLED,
} type;
};
struct acpi_asus_softc {
device_t dev;
ACPI_HANDLE handle;
ACPI_HANDLE lcdd_handle;
struct acpi_asus_model *model;
struct sysctl_ctx_list sysctl_ctx;
struct sysctl_oid *sysctl_tree;
struct acpi_asus_led s_bled;
struct acpi_asus_led s_dled;
struct acpi_asus_led s_gled;
struct acpi_asus_led s_mled;
struct acpi_asus_led s_tled;
struct acpi_asus_led s_wled;
int s_brn;
int s_disp;
int s_lcd;
int s_cam;
int s_crd;
int s_wlan;
};
static void acpi_asus_lcdd_notify(ACPI_HANDLE h, UINT32 notify,
void *context);
/*
* We can identify Asus laptops from the string they return
* as a result of calling the ATK0100 'INIT' method.
*/
static struct acpi_asus_model acpi_asus_models[] = {
{
.name = "xxN",
.mled_set = "MLED",
.wled_set = "WLED",
.lcd_get = "\\BKLT",
.lcd_set = "\\_SB.PCI0.SBRG.EC0._Q10",
.brn_get = "GPLV",
.brn_set = "SPLV",
.disp_get = "\\ADVG",
.disp_set = "SDSP"
},
{
.name = "A1x",
.mled_set = "MLED",
.lcd_get = "\\BKLI",
.lcd_set = "\\_SB.PCI0.ISA.EC0._Q10",
.brn_up = "\\_SB.PCI0.ISA.EC0._Q0E",
.brn_dn = "\\_SB.PCI0.ISA.EC0._Q0F"
},
{
.name = "A2x",
.mled_set = "MLED",
.wled_set = "WLED",
.lcd_get = "\\BAOF",
.lcd_set = "\\Q10",
.brn_get = "GPLV",
.brn_set = "SPLV",
.disp_get = "\\INFB",
.disp_set = "SDSP"
},
{
.name = "A3E",
.mled_set = "MLED",
.wled_set = "WLED",
.lcd_get = "\\_SB.PCI0.SBRG.EC0.RPIN(0x67)",
.lcd_set = "\\_SB.PCI0.SBRG.EC0._Q10",
.brn_get = "GPLV",
.brn_set = "SPLV",
.disp_get = "\\_SB.PCI0.P0P2.VGA.GETD",
.disp_set = "SDSP"
},
{
.name = "A3F",
.mled_set = "MLED",
.wled_set = "WLED",
.bled_set = "BLED",
.lcd_get = "\\_SB.PCI0.SBRG.EC0.RPIN(0x11)",
.lcd_set = "\\_SB.PCI0.SBRG.EC0._Q10",
.brn_get = "GPLV",
.brn_set = "SPLV",
.disp_get = "\\SSTE",
.disp_set = "SDSP"
},
{
.name = "A3N",
.mled_set = "MLED",
.bled_set = "BLED",
.wled_set = "WLED",
.lcd_get = "\\BKLT",
.lcd_set = "\\_SB.PCI0.SBRG.EC0._Q10",
.brn_get = "GPLV",
.brn_set = "SPLV",
.disp_get = "\\_SB.PCI0.P0P3.VGA.GETD",
.disp_set = "SDSP"
},
{
.name = "A4D",
.mled_set = "MLED",
.brn_up = "\\_SB_.PCI0.SBRG.EC0._Q0E",
.brn_dn = "\\_SB_.PCI0.SBRG.EC0._Q0F",
.brn_get = "GPLV",
.brn_set = "SPLV",
#ifdef notyet
.disp_get = "\\_SB_.PCI0.SBRG.EC0._Q10",
.disp_set = "\\_SB_.PCI0.SBRG.EC0._Q11"
#endif
},
{
.name = "A6V",
.bled_set = "BLED",
.mled_set = "MLED",
.wled_set = "WLED",
.lcd_get = NULL,
.lcd_set = "\\_SB.PCI0.SBRG.EC0._Q10",
.brn_get = "GPLV",
.brn_set = "SPLV",
.disp_get = "\\_SB.PCI0.P0P3.VGA.GETD",
.disp_set = "SDSP"
},
{
.name = "A8SR",
.bled_set = "BLED",
.mled_set = "MLED",
.wled_set = "WLED",
.lcd_get = NULL,
.lcd_set = "\\_SB.PCI0.SBRG.EC0._Q10",
.brn_get = "GPLV",
.brn_set = "SPLV",
.disp_get = "\\_SB.PCI0.P0P1.VGA.GETD",
.disp_set = "SDSP",
.lcdd = "\\_SB.PCI0.P0P1.VGA.LCDD",
.lcdd_n_func = acpi_asus_lcdd_notify
},
{
.name = "D1x",
.mled_set = "MLED",
.lcd_get = "\\GP11",
.lcd_set = "\\Q0D",
.brn_up = "\\Q0C",
.brn_dn = "\\Q0B",
.disp_get = "\\INFB",
.disp_set = "SDSP"
},
{
.name = "G2K",
.bled_set = "BLED",
.dled_set = "DLED",
.gled_set = "GLED",
.mled_set = "MLED",
.tled_set = "TLED",
.wled_set = "WLED",
.brn_get = "GPLV",
.brn_set = "SPLV",
.lcd_get = "GBTL",
.lcd_set = "SBTL",
.disp_get = "\\_SB.PCI0.PCE2.VGA.GETD",
.disp_set = "SDSP",
},
{
.name = "L2D",
.mled_set = "MLED",
.wled_set = "WLED",
.brn_up = "\\Q0E",
.brn_dn = "\\Q0F",
.lcd_get = "\\SGP0",
.lcd_set = "\\Q10"
},
{
.name = "L3C",
.mled_set = "MLED",
.wled_set = "WLED",
.brn_get = "GPLV",
.brn_set = "SPLV",
.lcd_get = "\\GL32",
.lcd_set = "\\_SB.PCI0.PX40.ECD0._Q10"
},
{
.name = "L3D",
.mled_set = "MLED",
.wled_set = "WLED",
.brn_get = "GPLV",
.brn_set = "SPLV",
.lcd_get = "\\BKLG",
.lcd_set = "\\Q10"
},
{
.name = "L3H",
.mled_set = "MLED",
.wled_set = "WLED",
.brn_get = "GPLV",
.brn_set = "SPLV",
.lcd_get = "\\_SB.PCI0.PM.PBC",
.lcd_set = "EHK",
.disp_get = "\\_SB.INFB",
.disp_set = "SDSP"
},
{
.name = "L4R",
.mled_set = "MLED",
.wled_set = "WLED",
.brn_get = "GPLV",
.brn_set = "SPLV",
.lcd_get = "\\_SB.PCI0.SBSM.SEO4",
.lcd_set = "\\_SB.PCI0.SBRG.EC0._Q10",
.disp_get = "\\_SB.PCI0.P0P1.VGA.GETD",
.disp_set = "SDSP"
},
{
.name = "L5x",
.mled_set = "MLED",
.tled_set = "TLED",
.lcd_get = "\\BAOF",
.lcd_set = "\\Q0D",
.brn_get = "GPLV",
.brn_set = "SPLV",
.disp_get = "\\INFB",
.disp_set = "SDSP"
},
{
.name = "L8L"
/* Only has hotkeys, apparently */
},
{
.name = "M1A",
.mled_set = "MLED",
.brn_up = "\\_SB.PCI0.PX40.EC0.Q0E",
.brn_dn = "\\_SB.PCI0.PX40.EC0.Q0F",
.lcd_get = "\\PNOF",
.lcd_set = "\\_SB.PCI0.PX40.EC0.Q10"
},
{
.name = "M2E",
.mled_set = "MLED",
.wled_set = "WLED",
.brn_get = "GPLV",
.brn_set = "SPLV",
.lcd_get = "\\GP06",
.lcd_set = "\\Q10"
},
{
.name = "M6N",
.mled_set = "MLED",
.wled_set = "WLED",
.lcd_set = "\\_SB.PCI0.SBRG.EC0._Q10",
.lcd_get = "\\_SB.BKLT",
.brn_set = "SPLV",
.brn_get = "GPLV",
.disp_set = "SDSP",
.disp_get = "\\SSTE"
},
{
.name = "M6R",
.mled_set = "MLED",
.wled_set = "WLED",
.brn_get = "GPLV",
.brn_set = "SPLV",
.lcd_get = "\\_SB.PCI0.SBSM.SEO4",
.lcd_set = "\\_SB.PCI0.SBRG.EC0._Q10",
.disp_get = "\\SSTE",
.disp_set = "SDSP"
},
{
.name = "S1x",
.mled_set = "MLED",
.wled_set = "WLED",
.lcd_get = "\\PNOF",
.lcd_set = "\\_SB.PCI0.PX40.Q10",
.brn_get = "GPLV",
.brn_set = "SPLV"
},
{
.name = "S2x",
.mled_set = "MLED",
.lcd_get = "\\BKLI",
.lcd_set = "\\_SB.PCI0.ISA.EC0._Q10",
.brn_up = "\\_SB.PCI0.ISA.EC0._Q0B",
.brn_dn = "\\_SB.PCI0.ISA.EC0._Q0A"
},
{
.name = "V6V",
.bled_set = "BLED",
.tled_set = "TLED",
.wled_set = "WLED",
.lcd_get = "\\BKLT",
.lcd_set = "\\_SB.PCI0.SBRG.EC0._Q10",
.brn_get = "GPLV",
.brn_set = "SPLV",
.disp_get = "\\_SB.PCI0.P0P1.VGA.GETD",
.disp_set = "SDSP"
},
{
.name = "W5A",
.bled_set = "BLED",
.lcd_get = "\\BKLT",
.lcd_set = "\\_SB.PCI0.SBRG.EC0._Q10",
.brn_get = "GPLV",
.brn_set = "SPLV",
.disp_get = "\\_SB.PCI0.P0P2.VGA.GETD",
.disp_set = "SDSP"
},
{ .name = NULL }
};
/*
* Samsung P30/P35 laptops have an Asus ATK0100 gadget interface,
* but they can't be probed quite the same way as Asus laptops.
*/
static struct acpi_asus_model acpi_samsung_models[] = {
{
.name = "P30",
.wled_set = "WLED",
.brn_up = "\\_SB.PCI0.LPCB.EC0._Q68",
.brn_dn = "\\_SB.PCI0.LPCB.EC0._Q69",
.lcd_get = "\\BKLT",
.lcd_set = "\\_SB.PCI0.LPCB.EC0._Q0E"
},
{ .name = NULL }
};
static void acpi_asus_eeepc_notify(ACPI_HANDLE h, UINT32 notify, void *context);
/*
* EeePC have an Asus ASUS010 gadget interface,
* but they can't be probed quite the same way as Asus laptops.
*/
static struct acpi_asus_model acpi_eeepc_models[] = {
{
.name = "EEE",
.brn_get = "\\_SB.ATKD.PBLG",
.brn_set = "\\_SB.ATKD.PBLS",
.cam_get = "\\_SB.ATKD.CAMG",
.cam_set = "\\_SB.ATKD.CAMS",
.crd_set = "\\_SB.ATKD.CRDS",
.crd_get = "\\_SB.ATKD.CRDG",
.wlan_get = "\\_SB.ATKD.WLDG",
.wlan_set = "\\_SB.ATKD.WLDS",
.n_func = acpi_asus_eeepc_notify
},
{ .name = NULL }
};
static struct {
char *name;
char *description;
int method;
int flag_anybody;
} acpi_asus_sysctls[] = {
{
.name = "lcd_backlight",
.method = ACPI_ASUS_METHOD_LCD,
.description = "state of the lcd backlight",
.flag_anybody = 1
},
{
.name = "lcd_brightness",
.method = ACPI_ASUS_METHOD_BRN,
.description = "brightness of the lcd panel",
.flag_anybody = 1
},
{
.name = "video_output",
.method = ACPI_ASUS_METHOD_DISP,
.description = "display output state",
},
{
.name = "camera",
.method = ACPI_ASUS_METHOD_CAMERA,
.description = "internal camera state",
},
{
.name = "cardreader",
.method = ACPI_ASUS_METHOD_CARDRD,
.description = "internal card reader state",
},
{
.name = "wlan",
.method = ACPI_ASUS_METHOD_WLAN,
.description = "wireless lan state",
},
{ .name = NULL }
};
ACPI_SERIAL_DECL(asus, "ACPI ASUS extras");
/* Function prototypes */
static int acpi_asus_probe(device_t dev);
static int acpi_asus_attach(device_t dev);
static int acpi_asus_detach(device_t dev);
static void acpi_asus_led(struct acpi_asus_led *led, int state);
static void acpi_asus_led_task(struct acpi_asus_led *led, int pending __unused);
static int acpi_asus_sysctl(SYSCTL_HANDLER_ARGS);
static int acpi_asus_sysctl_init(struct acpi_asus_softc *sc, int method);
static int acpi_asus_sysctl_get(struct acpi_asus_softc *sc, int method);
static int acpi_asus_sysctl_set(struct acpi_asus_softc *sc, int method, int val);
static void acpi_asus_notify(ACPI_HANDLE h, UINT32 notify, void *context);
static device_method_t acpi_asus_methods[] = {
DEVMETHOD(device_probe, acpi_asus_probe),
DEVMETHOD(device_attach, acpi_asus_attach),
DEVMETHOD(device_detach, acpi_asus_detach),
{ 0, 0 }
};
static driver_t acpi_asus_driver = {
"acpi_asus",
acpi_asus_methods,
sizeof(struct acpi_asus_softc)
};
DRIVER_MODULE(acpi_asus, acpi, acpi_asus_driver, 0, 0);
MODULE_DEPEND(acpi_asus, acpi, 1, 1, 1);
static int
acpi_asus_probe(device_t dev)
{
struct acpi_asus_model *model;
struct acpi_asus_softc *sc;
ACPI_BUFFER Buf;
ACPI_OBJECT Arg, *Obj;
ACPI_OBJECT_LIST Args;
static char *asus_ids[] = { "ATK0100", "ASUS010", NULL };
int rv;
char *rstr;
ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
if (acpi_disabled("asus"))
return (ENXIO);
rv = ACPI_ID_PROBE(device_get_parent(dev), dev, asus_ids, &rstr);
if (rv > 0) {
return (rv);
}
sc = device_get_softc(dev);
sc->dev = dev;
sc->handle = acpi_get_handle(dev);
Arg.Type = ACPI_TYPE_INTEGER;
Arg.Integer.Value = 0;
Args.Count = 1;
Args.Pointer = &Arg;
Buf.Pointer = NULL;
Buf.Length = ACPI_ALLOCATE_BUFFER;
AcpiEvaluateObject(sc->handle, "INIT", &Args, &Buf);
Obj = Buf.Pointer;
/*
* The Samsung P30 returns a null-pointer from INIT, we
* can identify it from the 'ODEM' string in the DSDT.
*/
if (Obj->String.Pointer == NULL) {
ACPI_STATUS status;
ACPI_TABLE_HEADER th;
status = AcpiGetTableHeader(ACPI_SIG_DSDT, 0, &th);
if (ACPI_FAILURE(status)) {
device_printf(dev, "Unsupported (Samsung?) laptop\n");
AcpiOsFree(Buf.Pointer);
return (ENXIO);
}
if (strncmp("ODEM", th.OemTableId, 4) == 0) {
sc->model = &acpi_samsung_models[0];
device_set_desc(dev, "Samsung P30 Laptop Extras");
AcpiOsFree(Buf.Pointer);
return (rv);
}
/* EeePC */
if (strncmp("ASUS010", rstr, 7) == 0) {
sc->model = &acpi_eeepc_models[0];
device_set_desc(dev, "ASUS EeePC");
AcpiOsFree(Buf.Pointer);
return (rv);
}
}
/*
* Asus laptops are simply identified by name, easy!
*/
for (model = acpi_asus_models; model->name != NULL; model++) {
if (strncmp(Obj->String.Pointer, model->name, 3) == 0) {
good:
sc->model = model;
device_set_descf(dev, "Asus %s Laptop Extras",
Obj->String.Pointer);
AcpiOsFree(Buf.Pointer);
return (rv);
}
/*
* Some models look exactly the same as other models, but have
* their own ids. If we spot these, set them up with the same
* details as the models they're like, possibly dealing with
* small differences.
*
* XXX: there must be a prettier way to do this!
*/
else if (strncmp(model->name, "xxN", 3) == 0 &&
(strncmp(Obj->String.Pointer, "M3N", 3) == 0 ||
strncmp(Obj->String.Pointer, "S1N", 3) == 0))
goto good;
else if (strncmp(model->name, "A1x", 3) == 0 &&
strncmp(Obj->String.Pointer, "A1", 2) == 0)
goto good;
else if (strncmp(model->name, "A2x", 3) == 0 &&
strncmp(Obj->String.Pointer, "A2", 2) == 0)
goto good;
else if (strncmp(model->name, "A3F", 3) == 0 &&
strncmp(Obj->String.Pointer, "A6F", 3) == 0)
goto good;
else if (strncmp(model->name, "D1x", 3) == 0 &&
strncmp(Obj->String.Pointer, "D1", 2) == 0)
goto good;
else if (strncmp(model->name, "L3H", 3) == 0 &&
strncmp(Obj->String.Pointer, "L2E", 3) == 0)
goto good;
else if (strncmp(model->name, "L5x", 3) == 0 &&
strncmp(Obj->String.Pointer, "L5", 2) == 0)
goto good;
else if (strncmp(model->name, "M2E", 3) == 0 &&
(strncmp(Obj->String.Pointer, "M2", 2) == 0 ||
strncmp(Obj->String.Pointer, "L4E", 3) == 0))
goto good;
else if (strncmp(model->name, "S1x", 3) == 0 &&
(strncmp(Obj->String.Pointer, "L8", 2) == 0 ||
strncmp(Obj->String.Pointer, "S1", 2) == 0))
goto good;
else if (strncmp(model->name, "S2x", 3) == 0 &&
(strncmp(Obj->String.Pointer, "J1", 2) == 0 ||
strncmp(Obj->String.Pointer, "S2", 2) == 0))
goto good;
/* L2B is like L3C but has no lcd_get method */
else if (strncmp(model->name, "L3C", 3) == 0 &&
strncmp(Obj->String.Pointer, "L2B", 3) == 0) {
model->lcd_get = NULL;
goto good;
}
/* A3G is like M6R but with a different lcd_get method */
else if (strncmp(model->name, "M6R", 3) == 0 &&
strncmp(Obj->String.Pointer, "A3G", 3) == 0) {
model->lcd_get = "\\BLFG";
goto good;
}
/* M2N and W1N are like xxN with added WLED */
else if (strncmp(model->name, "xxN", 3) == 0 &&
(strncmp(Obj->String.Pointer, "M2N", 3) == 0 ||
strncmp(Obj->String.Pointer, "W1N", 3) == 0)) {
model->wled_set = "WLED";
goto good;
}
/* M5N and S5N are like xxN without MLED */
else if (strncmp(model->name, "xxN", 3) == 0 &&
(strncmp(Obj->String.Pointer, "M5N", 3) == 0 ||
strncmp(Obj->String.Pointer, "S5N", 3) == 0)) {
model->mled_set = NULL;
goto good;
}
}
device_printf(dev, "Unsupported Asus laptop: %s\n",
Obj->String.Pointer);
AcpiOsFree(Buf.Pointer);
return (ENXIO);
}
static int
acpi_asus_attach(device_t dev)
{
struct acpi_asus_softc *sc;
struct acpi_softc *acpi_sc;
ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
sc = device_get_softc(dev);
acpi_sc = acpi_device_get_parent_softc(dev);
/* Build sysctl tree */
sysctl_ctx_init(&sc->sysctl_ctx);
sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctx,
SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree),
OID_AUTO, "asus", CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "");
/* Hook up nodes */
for (int i = 0; acpi_asus_sysctls[i].name != NULL; i++) {
if (!acpi_asus_sysctl_init(sc, acpi_asus_sysctls[i].method))
continue;
if (acpi_asus_sysctls[i].flag_anybody != 0) {
SYSCTL_ADD_PROC(&sc->sysctl_ctx,
SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
acpi_asus_sysctls[i].name,
CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY |
CTLFLAG_MPSAFE, sc, i, acpi_asus_sysctl, "I",
acpi_asus_sysctls[i].description);
} else {
SYSCTL_ADD_PROC(&sc->sysctl_ctx,
SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
acpi_asus_sysctls[i].name,
CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE,
sc, i, acpi_asus_sysctl, "I",
acpi_asus_sysctls[i].description);
}
}
/* Attach leds */
if (sc->model->bled_set) {
sc->s_bled.busy = 0;
sc->s_bled.sc = sc;
sc->s_bled.type = ACPI_ASUS_LED_BLED;
sc->s_bled.cdev =
led_create_state((led_t *)acpi_asus_led, &sc->s_bled,
"bled", 1);
}
if (sc->model->dled_set) {
sc->s_dled.busy = 0;
sc->s_dled.sc = sc;
sc->s_dled.type = ACPI_ASUS_LED_DLED;
sc->s_dled.cdev =
led_create((led_t *)acpi_asus_led, &sc->s_dled, "dled");
}
if (sc->model->gled_set) {
sc->s_gled.busy = 0;
sc->s_gled.sc = sc;
sc->s_gled.type = ACPI_ASUS_LED_GLED;
sc->s_gled.cdev =
led_create((led_t *)acpi_asus_led, &sc->s_gled, "gled");
}
if (sc->model->mled_set) {
sc->s_mled.busy = 0;
sc->s_mled.sc = sc;
sc->s_mled.type = ACPI_ASUS_LED_MLED;
sc->s_mled.cdev =
led_create((led_t *)acpi_asus_led, &sc->s_mled, "mled");
}
if (sc->model->tled_set) {
sc->s_tled.busy = 0;
sc->s_tled.sc = sc;
sc->s_tled.type = ACPI_ASUS_LED_TLED;
sc->s_tled.cdev =
led_create_state((led_t *)acpi_asus_led, &sc->s_tled,
"tled", 1);
}
if (sc->model->wled_set) {
sc->s_wled.busy = 0;
sc->s_wled.sc = sc;
sc->s_wled.type = ACPI_ASUS_LED_WLED;
sc->s_wled.cdev =
led_create_state((led_t *)acpi_asus_led, &sc->s_wled,
"wled", 1);
}
/* Activate hotkeys */
AcpiEvaluateObject(sc->handle, "BSTS", NULL, NULL);
/* Handle notifies */
if (sc->model->n_func == NULL)
sc->model->n_func = acpi_asus_notify;
AcpiInstallNotifyHandler(sc->handle, ACPI_SYSTEM_NOTIFY,
sc->model->n_func, dev);
/* Find and hook the 'LCDD' object */
if (sc->model->lcdd != NULL && sc->model->lcdd_n_func != NULL) {
ACPI_STATUS res;
sc->lcdd_handle = NULL;
res = AcpiGetHandle((sc->model->lcdd[0] == '\\' ?
NULL : sc->handle), sc->model->lcdd, &(sc->lcdd_handle));
if (ACPI_SUCCESS(res)) {
AcpiInstallNotifyHandler((sc->lcdd_handle),
ACPI_DEVICE_NOTIFY, sc->model->lcdd_n_func, dev);
} else {
printf("%s: unable to find LCD device '%s'\n",
__func__, sc->model->lcdd);
}
}
return (0);
}
static int
acpi_asus_detach(device_t dev)
{
struct acpi_asus_softc *sc;
ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
sc = device_get_softc(dev);
/* Turn the lights off */
if (sc->model->bled_set)
led_destroy(sc->s_bled.cdev);
if (sc->model->dled_set)
led_destroy(sc->s_dled.cdev);
if (sc->model->gled_set)
led_destroy(sc->s_gled.cdev);
if (sc->model->mled_set)
led_destroy(sc->s_mled.cdev);
if (sc->model->tled_set)
led_destroy(sc->s_tled.cdev);
if (sc->model->wled_set)
led_destroy(sc->s_wled.cdev);
/* Remove notify handler */
AcpiRemoveNotifyHandler(sc->handle, ACPI_SYSTEM_NOTIFY,
acpi_asus_notify);
if (sc->lcdd_handle) {
KASSERT(sc->model->lcdd_n_func != NULL,
("model->lcdd_n_func is NULL, but lcdd_handle is non-zero"));
AcpiRemoveNotifyHandler((sc->lcdd_handle),
ACPI_DEVICE_NOTIFY, sc->model->lcdd_n_func);
}
/* Free sysctl tree */
sysctl_ctx_free(&sc->sysctl_ctx);
return (0);
}
static void
acpi_asus_led_task(struct acpi_asus_led *led, int pending __unused)
{
struct acpi_asus_softc *sc;
char *method;
int state;
ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
sc = led->sc;
switch (led->type) {
case ACPI_ASUS_LED_BLED:
method = sc->model->bled_set;
state = led->state;
break;
case ACPI_ASUS_LED_DLED:
method = sc->model->dled_set;
state = led->state;
break;
case ACPI_ASUS_LED_GLED:
method = sc->model->gled_set;
state = led->state + 1; /* 1: off, 2: on */
break;
case ACPI_ASUS_LED_MLED:
method = sc->model->mled_set;
state = !led->state; /* inverted */
break;
case ACPI_ASUS_LED_TLED:
method = sc->model->tled_set;
state = led->state;
break;
case ACPI_ASUS_LED_WLED:
method = sc->model->wled_set;
state = led->state;
break;
default:
printf("acpi_asus_led: invalid LED type %d\n",
(int)led->type);
return;
}
acpi_SetInteger(sc->handle, method, state);
led->busy = 0;
}
static void
acpi_asus_led(struct acpi_asus_led *led, int state)
{
ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
if (led->busy)
return;
led->busy = 1;
led->state = state;
AcpiOsExecute(OSL_NOTIFY_HANDLER, (void *)acpi_asus_led_task, led);
}
static int
acpi_asus_sysctl(SYSCTL_HANDLER_ARGS)
{
struct acpi_asus_softc *sc;
int arg;
int error = 0;
int function;
int method;
ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
sc = (struct acpi_asus_softc *)oidp->oid_arg1;
function = oidp->oid_arg2;
method = acpi_asus_sysctls[function].method;
ACPI_SERIAL_BEGIN(asus);
arg = acpi_asus_sysctl_get(sc, method);
error = sysctl_handle_int(oidp, &arg, 0, req);
/* Sanity check */
if (error != 0 || req->newptr == NULL)
goto out;
/* Update */
error = acpi_asus_sysctl_set(sc, method, arg);
out:
ACPI_SERIAL_END(asus);
return (error);
}
static int
acpi_asus_sysctl_get(struct acpi_asus_softc *sc, int method)
{
int val = 0;
ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
ACPI_SERIAL_ASSERT(asus);
switch (method) {
case ACPI_ASUS_METHOD_BRN:
val = sc->s_brn;
break;
case ACPI_ASUS_METHOD_DISP:
val = sc->s_disp;
break;
case ACPI_ASUS_METHOD_LCD:
val = sc->s_lcd;
break;
case ACPI_ASUS_METHOD_CAMERA:
val = sc->s_cam;
break;
case ACPI_ASUS_METHOD_CARDRD:
val = sc->s_crd;
break;
case ACPI_ASUS_METHOD_WLAN:
val = sc->s_wlan;
break;
}
return (val);
}
static int
acpi_asus_sysctl_set(struct acpi_asus_softc *sc, int method, int arg)
{
ACPI_STATUS status = AE_OK;
ACPI_OBJECT_LIST acpiargs;
ACPI_OBJECT acpiarg[1];
ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
ACPI_SERIAL_ASSERT(asus);
acpiargs.Count = 1;
acpiargs.Pointer = acpiarg;
acpiarg[0].Type = ACPI_TYPE_INTEGER;
acpiarg[0].Integer.Value = arg;
switch (method) {
case ACPI_ASUS_METHOD_BRN:
if (arg < 0 || arg > 15)
return (EINVAL);
if (sc->model->brn_set)
status = acpi_SetInteger(sc->handle,
sc->model->brn_set, arg);
else {
while (arg != 0) {
status = AcpiEvaluateObject(sc->handle,
(arg > 0) ? sc->model->brn_up :
sc->model->brn_dn, NULL, NULL);
(arg > 0) ? arg-- : arg++;
}
}
if (ACPI_SUCCESS(status))
sc->s_brn = arg;
break;
case ACPI_ASUS_METHOD_DISP:
if (arg < 0 || arg > 7)
return (EINVAL);
status = acpi_SetInteger(sc->handle,
sc->model->disp_set, arg);
if (ACPI_SUCCESS(status))
sc->s_disp = arg;
break;
case ACPI_ASUS_METHOD_LCD:
if (arg < 0 || arg > 1)
return (EINVAL);
if (strncmp(sc->model->name, "L3H", 3) != 0)
status = AcpiEvaluateObject(sc->handle,
sc->model->lcd_set, NULL, NULL);
else
status = acpi_SetInteger(sc->handle,
sc->model->lcd_set, 0x7);
if (ACPI_SUCCESS(status))
sc->s_lcd = arg;
break;
case ACPI_ASUS_METHOD_CAMERA:
if (arg < 0 || arg > 1)
return (EINVAL);
status = AcpiEvaluateObject(sc->handle,
sc->model->cam_set, &acpiargs, NULL);
if (ACPI_SUCCESS(status))
sc->s_cam = arg;
break;
case ACPI_ASUS_METHOD_CARDRD:
if (arg < 0 || arg > 1)
return (EINVAL);
status = AcpiEvaluateObject(sc->handle,
sc->model->crd_set, &acpiargs, NULL);
if (ACPI_SUCCESS(status))
sc->s_crd = arg;
break;
case ACPI_ASUS_METHOD_WLAN:
if (arg < 0 || arg > 1)
return (EINVAL);
status = AcpiEvaluateObject(sc->handle,
sc->model->wlan_set, &acpiargs, NULL);
if (ACPI_SUCCESS(status))
sc->s_wlan = arg;
break;
}
return (0);
}
static int
acpi_asus_sysctl_init(struct acpi_asus_softc *sc, int method)
{
ACPI_STATUS status;
switch (method) {
case ACPI_ASUS_METHOD_BRN:
if (sc->model->brn_get) {
/* GPLV/SPLV models */
status = acpi_GetInteger(sc->handle,
sc->model->brn_get, &sc->s_brn);
if (ACPI_SUCCESS(status))
return (TRUE);
} else if (sc->model->brn_up) {
/* Relative models */
status = AcpiEvaluateObject(sc->handle,
sc->model->brn_up, NULL, NULL);
if (ACPI_FAILURE(status))
return (FALSE);
status = AcpiEvaluateObject(sc->handle,
sc->model->brn_dn, NULL, NULL);
if (ACPI_FAILURE(status))
return (FALSE);
return (TRUE);
}
return (FALSE);
case ACPI_ASUS_METHOD_DISP:
if (sc->model->disp_get) {
status = acpi_GetInteger(sc->handle,
sc->model->disp_get, &sc->s_disp);
if (ACPI_SUCCESS(status))
return (TRUE);
}
return (FALSE);
case ACPI_ASUS_METHOD_LCD:
if (sc->model->lcd_get) {
if (strncmp(sc->model->name, "L3H", 3) == 0) {
ACPI_BUFFER Buf;
ACPI_OBJECT Arg[2], Obj;
ACPI_OBJECT_LIST Args;
/* L3H is a bit special */
Arg[0].Type = ACPI_TYPE_INTEGER;
Arg[0].Integer.Value = 0x02;
Arg[1].Type = ACPI_TYPE_INTEGER;
Arg[1].Integer.Value = 0x03;
Args.Count = 2;
Args.Pointer = Arg;
Buf.Length = sizeof(Obj);
Buf.Pointer = &Obj;
status = AcpiEvaluateObject(sc->handle,
sc->model->lcd_get, &Args, &Buf);
if (ACPI_SUCCESS(status) &&
Obj.Type == ACPI_TYPE_INTEGER) {
sc->s_lcd = Obj.Integer.Value >> 8;
return (TRUE);
}
} else {
status = acpi_GetInteger(sc->handle,
sc->model->lcd_get, &sc->s_lcd);
if (ACPI_SUCCESS(status))
return (TRUE);
}
}
return (FALSE);
case ACPI_ASUS_METHOD_CAMERA:
if (sc->model->cam_get) {
status = acpi_GetInteger(sc->handle,
sc->model->cam_get, &sc->s_cam);
if (ACPI_SUCCESS(status))
return (TRUE);
}
return (FALSE);
case ACPI_ASUS_METHOD_CARDRD:
if (sc->model->crd_get) {
status = acpi_GetInteger(sc->handle,
sc->model->crd_get, &sc->s_crd);
if (ACPI_SUCCESS(status))
return (TRUE);
}
return (FALSE);
case ACPI_ASUS_METHOD_WLAN:
if (sc->model->wlan_get) {
status = acpi_GetInteger(sc->handle,
sc->model->wlan_get, &sc->s_wlan);
if (ACPI_SUCCESS(status))
return (TRUE);
}
return (FALSE);
}
return (FALSE);
}
static void
acpi_asus_notify(ACPI_HANDLE h, UINT32 notify, void *context)
{
struct acpi_asus_softc *sc;
struct acpi_softc *acpi_sc;
ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
sc = device_get_softc((device_t)context);
acpi_sc = acpi_device_get_parent_softc(sc->dev);
ACPI_SERIAL_BEGIN(asus);
if ((notify & ~0x10) <= 15) {
sc->s_brn = notify & ~0x10;
ACPI_VPRINT(sc->dev, acpi_sc, "Brightness increased\n");
} else if ((notify & ~0x20) <= 15) {
sc->s_brn = notify & ~0x20;
ACPI_VPRINT(sc->dev, acpi_sc, "Brightness decreased\n");
} else if (notify == 0x33) {
sc->s_lcd = 1;
ACPI_VPRINT(sc->dev, acpi_sc, "LCD turned on\n");
} else if (notify == 0x34) {
sc->s_lcd = 0;
ACPI_VPRINT(sc->dev, acpi_sc, "LCD turned off\n");
} else if (notify == 0x86) {
acpi_asus_sysctl_set(sc, ACPI_ASUS_METHOD_BRN, sc->s_brn-1);
ACPI_VPRINT(sc->dev, acpi_sc, "Brightness decreased\n");
} else if (notify == 0x87) {
acpi_asus_sysctl_set(sc, ACPI_ASUS_METHOD_BRN, sc->s_brn+1);
ACPI_VPRINT(sc->dev, acpi_sc, "Brightness increased\n");
} else {
/* Notify devd(8) */
acpi_UserNotify("ASUS", h, notify);
}
ACPI_SERIAL_END(asus);
}
static void
acpi_asus_lcdd_notify(ACPI_HANDLE h, UINT32 notify, void *context)
{
struct acpi_asus_softc *sc;
struct acpi_softc *acpi_sc;
ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
sc = device_get_softc((device_t)context);
acpi_sc = acpi_device_get_parent_softc(sc->dev);
ACPI_SERIAL_BEGIN(asus);
switch (notify) {
case 0x87:
acpi_asus_sysctl_set(sc, ACPI_ASUS_METHOD_BRN, sc->s_brn-1);
ACPI_VPRINT(sc->dev, acpi_sc, "Brightness decreased\n");
break;
case 0x86:
acpi_asus_sysctl_set(sc, ACPI_ASUS_METHOD_BRN, sc->s_brn+1);
ACPI_VPRINT(sc->dev, acpi_sc, "Brightness increased\n");
break;
}
ACPI_SERIAL_END(asus);
}
static void
acpi_asus_eeepc_notify(ACPI_HANDLE h, UINT32 notify, void *context)
{
struct acpi_asus_softc *sc;
struct acpi_softc *acpi_sc;
ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
sc = device_get_softc((device_t)context);
acpi_sc = acpi_device_get_parent_softc(sc->dev);
ACPI_SERIAL_BEGIN(asus);
if ((notify & ~0x20) <= 15) {
sc->s_brn = notify & ~0x20;
ACPI_VPRINT(sc->dev, acpi_sc,
"Brightness increased/decreased\n");
} else {
/* Notify devd(8) */
acpi_UserNotify("ASUS-Eee", h, notify);
}
ACPI_SERIAL_END(asus);
}
Reference in a new issue View git blame Copy permalink