/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
*/
/*
* Copyright 2015 Hans Rosenfeld <rosenfeld@grumpf.hope-2000.org>
*/
/*
* Solaris x86 Generic ACPI Video Extensions Hotkey driver
*/
#include <sys/hotkey_drv.h>
/*
* Vendor specific hotkey support list
* 1. Toshiba: acpi_toshiba
*/
/* vendor, module name, enable? */
/* Terminator */
};
enum vga_output_type {
};
struct acpi_video_output {
};
struct acpi_video_brightness {
int *levels;
int cur_level;
};
struct acpi_video_switch {
};
/* ACPI video extension hotkey for video switch and brightness control */
static struct acpi_video {
int hotkey_drv_debug = 0;
static struct acpi_video_smbios_info {
char *manufacturer;
char *product;
} acpi_brightness_get_blacklist[] = {
{ /* Dell AdamoXPS laptop */
"Dell Inc.",
"Adamo XPS"
},
{ /* termination entry */
NULL,
}
};
/*
* -1 = check acpi_brightness_get_blacklist[].
* 0 = enable brightness get.
* 1 = disable brightness get.
*/
/* Output device status */
/* _DOS default value is 1 */
/* _DOS bit 1:0 */
/* _DOS bit 2 */
/* Set _DOS for video control policy */
static void
{
if (ACPI_FAILURE(status))
}
}
/*
* Get the current brightness level and index.
*/
static int
{
int i;
if (acpi_brightness_get_disable) {
/* simply initialize current brightness to the highest level */
return (ACPI_DRV_OK);
}
!= AE_OK) {
return (ACPI_DRV_ERR);
}
vidbp->cur_level_index = i;
if (hotkey_drv_debug & HOTKEY_DBG_NOTICE) {
" cur_level = %d, cur_level_index = %d\n",
}
break;
}
}
return (ACPI_DRV_OK);
}
static int
{
!= AE_OK) {
return (ACPI_DRV_ERR);
}
return (ACPI_DRV_OK);
}
void
{
int err;
if (err != DDI_SUCCESS) {
"!failed to log hotkey sysevent, err code %x\n", err);
}
}
/*ARGSUSED*/
static void
{
if (hotkey_drv_debug & HOTKEY_DBG_NOTICE) {
notify);
}
switch (notify) {
case VIDEO_NOTIFY_SWITCH:
case VIDEO_NOTIFY_SWITCH_NEXT:
case VIDEO_NOTIFY_SWITCH_PREV:
break;
break;
default:
if (hotkey_drv_debug) {
"!acpi_video_switch_notify: unknown event 0x%x.\n",
notify);
}
}
}
/*ARGSUSED*/
static void
{
if (hotkey_drv_debug & HOTKEY_DBG_NOTICE) {
"!acpi_video_brightness_notify: got event 0x%x.\n",
notify);
}
switch (notify) {
break;
}
}
break;
if (vidbp->cur_level_index > 0) {
break;
}
}
0);
break;
break;
}
0);
break;
default:
if (hotkey_drv_debug) {
"unknown event 0x%x.\n", notify);
}
}
}
static int
{
int i;
/* bind video switch notify */
if (ACPI_FAILURE(status)) {
"!vids handler install failed = %d, vids = %p.",
}
}
/* bind brightness control notify */
if (ACPI_FAILURE(status)) {
"!brightness handler install failed = %x, "
}
}
return (ACPI_DRV_OK);
}
static int
{
int i;
/* unbind video switch notify */
}
/* unbind brightness control notify */
}
return (ACPI_DRV_OK);
}
static int
{
/* free video switch objects */
vidsp = vidsp_next;
}
/* free video brightness control objects */
vidbp = vidbp_next;
}
/* free video output objects */
vidop = vidop_next;
}
return (ACPI_DRV_OK);
}
static int
{
(void) acpi_video_notify_unintall(vidp);
return (acpi_video_free(vidp));
}
static int
{
int adr;
return (ACPI_DRV_ERR);
/* Allocate object */
KM_SLEEP);
/*
* op->nlev will be needed to free op->levels.
*/
/*
* Get all the supported brightness levels.
*/
for (i = 0; i < nlev; i++) {
if (hotkey_drv_debug & HOTKEY_DBG_NOTICE) {
}
if (o->Type != ACPI_TYPE_INTEGER) {
continue;
}
}
/*
* Sort the brightness levels.
*/
for (j = 0; j < nlev; j++) {
for (k = 0; k < nlev - 1; k++) {
}
}
}
/*
* The first two levels could be duplicated, so remove
* any duplicates.
*/
for (l = 0; l < nlev - 1; l++) {
}
nlev--;
}
}
(void) acpi_video_brightness_get(vidbp);
vidp->total_brightness++;
}
vidp->total_outputs++;
return (ACPI_DRV_OK);
}
/*ARGSUSED*/
static ACPI_STATUS
void **rv)
{
return (AE_OK);
return (AE_OK);
vidp->total_switch++;
/*
* Enumerate the output devices.
*/
}
if (hotkey_drv_debug & HOTKEY_DBG_NOTICE) {
"!acpi video switch hdl = 0x%p, path = %s.",
}
}
}
return (AE_OK);
}
int
{
return (ACPI_DRV_ERR);
}
}
}
return (ACPI_DRV_OK);
}
int
{
if (vidbp->cur_level_index > 0) {
return (ACPI_DRV_ERR);
}
}
}
return (ACPI_DRV_OK);
}
/*ARGSUSED*/
int
int *rval)
{
int res = 0;
return (ENXIO);
return (ENXIO);
if (hotkey_drv_debug & HOTKEY_DBG_NOTICE) {
}
switch (cmd) {
case ACPI_DRV_IOC_INFO:
{
}
break;
}
case ACPI_DRV_IOC_LEVELS:
}
break;
case ACPI_DRV_IOC_STATUS:
{
/*
* Need to get the current levels through ACPI first
* then go through array of levels to find index.
*/
int i;
status.cur_level_index = i;
if (hotkey_drv_debug & HOTKEY_DBG_NOTICE) {
"cur_level_index %d\n", i);
}
break;
}
}
}
break;
}
case ACPI_DRV_IOC_SET_BRIGHTNESS: {
int level;
break;
}
break;
}
if (hotkey_drv_debug & HOTKEY_DBG_NOTICE) {
"!acpi_video_ioctl: set BRIGHTNESS level=%d\n",
level);
}
}
break;
}
default:
break;
}
return (res);
}
/*ARGSUSED*/
int
int *rval)
{
switch (htkp->hotkey_method) {
case HOTKEY_METHOD_ACPI_VIDEO:
case HOTKEY_METHOD_MISC:
case HOTKEY_METHOD_VENDOR:
case HOTKEY_METHOD_NONE:
default:
return (ENXIO);
}
}
static void
{
goto done;
}
}
}
done:
}
static int
{
if (acpi_brightness_get_disable == -1)
/* Find ACPI Video device handle */
return (ACPI_DRV_ERR);
}
(void) acpi_video_fini(vidp);
return (ACPI_DRV_ERR);
}
}
return (ACPI_DRV_OK);
}
int
{
int i;
int modid;
/* Try to find vendor specific method */
if (!vendor_hotkey_drv_list[i].enable)
continue;
== -1) {
continue;
}
if (hotkey_drv_debug & HOTKEY_DBG_NOTICE) {
}
}
/* Check availability of ACPI Video Extension method */
htkp->check_acpi_video) {
} else
goto fail;
}
}
/* Create minor node for hotkey device. */
if (hotkey_drv_debug & HOTKEY_DBG_WARN)
goto fail;
}
return (ACPI_DRV_OK);
fail:
return (ACPI_DRV_ERR);
}
int
{
}
return (ACPI_DRV_OK);
}