system/freebsd-src
system/freebsd-src
1
0
Fork 0
mirror of https://github.com/freebsd/freebsd-src synced 2024-07-08 20:26:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add atopcase, the Apple HID over SPI input driver

Browse Source 
The driver provides support for Human Interface Devices (HID) on
Serial Peripheral Interface (SPI) buses on Apple Intel Macs
produced in 2015-2018.

The driver appears to work more stable after installation of Darwin OSI
in acpi(4) driver.
To install Darwin OSI insert following lines into /boot/loader.conf:

hw.acpi.install_interface="Darwin"
hw.acpi.remove_interface="Windows 2009, Windows 2012"

Reviewed by:	wulf
Differential revision:	https://reviews.freebsd.org/D39863
This commit is contained in:
Val Packett 2023-08-20 12:53:32 +03:00 committed by Vladimir Kondratyev
parent 1c4edee342
commit 64fbda90da
10 changed files with 1583 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
share/man/man4/Makefile
View File

@ -57,6 +57,7 @@ MAN= aac.4 \
ath_hal.4 \
atkbd.4 \
atkbdc.4 \
${_atopcase.4} \
atp.4 \
${_atf_test_case.4} \
${_atrtc.4} \
@ -794,6 +795,7 @@ _amdsmb.4= amdsmb.4
_amdsmn.4= amdsmn.4
_amdtemp.4= amdtemp.4
_asmc.4= asmc.4
_atopcase.4= atopcase.4
_bxe.4= bxe.4
_bytgpio.4= bytgpio.4
_chvgpio.4= chvgpio.4

134
share/man/man4/atopcase.4 Normal file
View File

@ -0,0 +1,134 @@
.\" Copyright (c) 2023 Vladimir Kondratyev <wulf@FreeBSD.org>
.\"
.\" 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.
.\"
.Dd August 17, 2023
.Dt ATOPCASE 4
.Os
.Sh NAME
.Nm atopcase
.Nd Apple HID-over-SPI transport driver
.Sh SYNOPSIS
To compile this driver into the kernel,
place the following lines in your
kernel configuration file:
.Bd -ragged -offset indent
.Cd "device atopcase"
.Cd "device intelspi"
.Cd "device spibus"
.Cd "device hidbus"
.Cd "device hkbd"
.Ed
.Pp
Alternatively, to load the driver as a
module at boot time, place the following line in
.Xr loader.conf 5 :
.Bd -literal -offset indent
atopcase_load="YES"
hkbd_load="YES"
.Ed
.Sh DESCRIPTION
The
.Nm
driver provides support for Human Interface Devices (HID) on
Serial Peripheral Interface (SPI) buses on Apple Intel Macs.
.Sh HARDWARE
The
.Nm
driver supports the following MacBooks produced in 2015-2018 years:
.Pp
.Bl -bullet -compact
.It
Macbook8,1
.It
Macbook9,1
.It
Macbook10,1
.It
MacbookPro11,4
.It
MacbookPro12,1
.It
MacbookPro13,1
.It
MacbookPro13,2
.It
MacbookPro13,3
.It
MacbookPro14,1
.It
MacbookPro14,2
.It
MacbookPro14,3
.El
.Sh SYSCTL VARIABLES
The following variables are available as both
.Xr sysctl 8
variables and
.Xr loader 8
tunables:
.Bl -tag -width indent
.It Va hw.hid.atopcase.debug
Debug output level, where 0 is debugging disabled and larger values increase
debug message verbosity.
Default is 0.
.El
.Sh FILES
.Bl -tag -width ".Pa /dev/backlight/atopcase0" -compact
.It Pa /dev/backlight/atopcase0
Keyboard
.Xr backlight 8
device node.
.El
.Sh SEE ALSO
.Xr acpi 4 ,
.Xr backlight 8 ,
.Xr loader 8 ,
.Xr loader.conf 5 .
.Sh HISTORY
The
.Nm
driver first appeared in
.Fx 14.0.
.Sh AUTHORS
.An -nosplit
The
.Nm
driver was originally written by
.An Val Packett Aq Mt val@packett.cool
and marginally improved upon by
.An Vladimir Kondratyev Aq Mt wulf@FreeBSD.org .
.Pp
This manual page was written by
.An Vladimir Kondratyev Aq Mt wulf@FreeBSD.org .
.Sh BUGS
Device interrupts are not acknowledged on some hardware that results in
interrupt storm.
Installation of Darwin OSI in
.Xr acpi 4
driver fixes the issue.
To install Darwin OSI add following lines to
.Xr loader.conf 5 :
.Bl -tag -width indent
.It Va hw.acpi.install_interface="Darwin"
.It Va hw.acpi.remove_interface="Windows 2009, Windows 2012"
.El

2
sys/conf/files.x86
View File

@ -69,6 +69,8 @@ dev/atkbdc/atkbdc.c optional atkbdc
dev/atkbdc/atkbdc_isa.c optional atkbdc isa
dev/atkbdc/atkbdc_subr.c optional atkbdc
dev/atkbdc/psm.c optional psm atkbdc
dev/atopcase/atopcase.c optional atopcase acpi hid spibus
dev/atopcase/atopcase_acpi.c optional atopcase acpi hid spibus
dev/bxe/bxe.c optional bxe pci
dev/bxe/bxe_stats.c optional bxe pci
dev/bxe/bxe_debug.c optional bxe pci

722
sys/dev/atopcase/atopcase.c Normal file
View File

@ -0,0 +1,722 @@
/*-
* SPDX-License-Identifier: BSD-2-Clause
*
* Copyright (c) 2021-2023 Val Packett <val@packett.cool>
* Copyright (c) 2023 Vladimir Kondratyev <wulf@FreeBSD.org>
*
* 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 "opt_hid.h"
#include "opt_spi.h"
#include <sys/param.h>
#include <sys/bus.h>
#include <sys/crc16.h>
#include <sys/endian.h>
#include <sys/kdb.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/mutex.h>
#include <sys/module.h>
#include <sys/proc.h>
#include <sys/rman.h>
#include <sys/sysctl.h>
#include <sys/sx.h>
#include <sys/taskqueue.h>
#include <dev/backlight/backlight.h>
#include <dev/evdev/input.h>
#define HID_DEBUG_VAR atopcase_debug
#include <dev/hid/hid.h>
#include <dev/hid/hidquirk.h>
#include <dev/spibus/spi.h>
#include <dev/spibus/spibusvar.h>
#include "spibus_if.h"
#include "atopcase_reg.h"
#include "atopcase_var.h"
#define ATOPCASE_IN_KDB() (SCHEDULER_STOPPED() || kdb_active)
#define ATOPCASE_IN_POLLING_MODE(sc) \
(((sc)->sc_gpe_bit == 0 && ((sc)->sc_irq_ih == NULL)) || cold ||\
ATOPCASE_IN_KDB())
#define ATOPCASE_WAKEUP(sc, chan) do { \
if (!ATOPCASE_IN_POLLING_MODE(sc)) { \
DPRINTFN(ATOPCASE_LLEVEL_DEBUG, "wakeup: %p\n", chan); \
wakeup(chan); \
} \
} while (0)
#define ATOPCASE_SPI_PAUSE() DELAY(100)
#define ATOPCASE_SPI_NO_SLEEP_FLAG(sc) \
((sc)->sc_irq_ih != NULL ? SPI_FLAG_NO_SLEEP : 0)
/* Tunables */
static SYSCTL_NODE(_hw_hid, OID_AUTO, atopcase, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
"Apple MacBook Topcase HID driver");
#ifdef HID_DEBUG
enum atopcase_log_level atopcase_debug = ATOPCASE_LLEVEL_DISABLED;
SYSCTL_INT(_hw_hid_atopcase, OID_AUTO, debug, CTLFLAG_RWTUN,
&atopcase_debug, ATOPCASE_LLEVEL_DISABLED, "atopcase log level");
#endif /* !HID_DEBUG */
static const uint8_t booted[] = { 0xa0, 0x80, 0x00, 0x00 };
static const uint8_t status_ok[] = { 0xac, 0x27, 0x68, 0xd5 };
static inline struct atopcase_child *
atopcase_get_child_by_device(struct atopcase_softc *sc, uint8_t device)
{
switch (device) {
case ATOPCASE_DEV_KBRD:
return (&sc->sc_kb);
case ATOPCASE_DEV_TPAD:
return (&sc->sc_tp);
default:
return (NULL);
}
}
static int
atopcase_receive_status(struct atopcase_softc *sc)
{
struct spi_command cmd = SPI_COMMAND_INITIALIZER;
uint8_t dummy_buffer[4] = { 0 };
uint8_t status_buffer[4] = { 0 };
int err;
cmd.tx_cmd = dummy_buffer;
cmd.tx_cmd_sz = sizeof(dummy_buffer);
cmd.rx_cmd = status_buffer;
cmd.rx_cmd_sz = sizeof(status_buffer);
cmd.flags = ATOPCASE_SPI_NO_SLEEP_FLAG(sc);
err = SPIBUS_TRANSFER(device_get_parent(sc->sc_dev), sc->sc_dev, &cmd);
ATOPCASE_SPI_PAUSE();
if (err) {
device_printf(sc->sc_dev, "SPI error: %d\n", err);
return (err);
}
DPRINTFN(ATOPCASE_LLEVEL_TRACE, "Status: %*D\n", 4, status_buffer, " ");
if (memcmp(status_buffer, status_ok, sizeof(status_ok)) == 0) {
DPRINTFN(ATOPCASE_LLEVEL_DEBUG, "Wrote command\n");
ATOPCASE_WAKEUP(sc, sc->sc_dev);
} else {
device_printf(sc->sc_dev, "Failed to write command\n");
return (EIO);
}
return (0);
}
static int
atopcase_process_message(struct atopcase_softc *sc, uint8_t device, void *msg,
uint16_t msg_len)
{
struct atopcase_header *hdr = msg;
struct atopcase_child *ac;
void *payload;
uint16_t pl_len, crc;
payload = (uint8_t *)msg + sizeof(*hdr);
pl_len = le16toh(hdr->len);
if (pl_len + sizeof(*hdr) + sizeof(crc) != msg_len) {
DPRINTFN(ATOPCASE_LLEVEL_DEBUG,
"message with length overflow\n");
return (EIO);
}
crc = le16toh(*(uint16_t *)((uint8_t *)payload + pl_len));
if (crc != crc16(0, msg, msg_len - sizeof(crc))) {
DPRINTFN(ATOPCASE_LLEVEL_DEBUG,
"message with failed checksum\n");
return (EIO);
}
#define CPOFF(dst, len, off) do { \
unsigned _len = le16toh(len); \
unsigned _off = le16toh(off); \
if (pl_len >= _len + _off) { \
memcpy(dst, (uint8_t*)payload + _off, MIN(_len, sizeof(dst)));\
(dst)[MIN(_len, sizeof(dst) - 1)] = '\0'; \
}} while (0);
if ((ac = atopcase_get_child_by_device(sc, device)) != NULL
&& hdr->type == ATOPCASE_MSG_TYPE_REPORT(device)) {
if (ac->open)
ac->intr_handler(ac->intr_ctx, payload, pl_len);
} else if (device == ATOPCASE_DEV_INFO
&& hdr->type == ATOPCASE_MSG_TYPE_INFO(ATOPCASE_INFO_IFACE)
&& (ac = atopcase_get_child_by_device(sc, hdr->type_arg)) != NULL) {
struct atopcase_iface_info_payload *iface = payload;
CPOFF(ac->name, iface->name_len, iface->name_off);
DPRINTF("Interface #%d name: %s\n", ac->device, ac->name);
} else if (device == ATOPCASE_DEV_INFO
&& hdr->type == ATOPCASE_MSG_TYPE_INFO(ATOPCASE_INFO_DESCRIPTOR)
&& (ac = atopcase_get_child_by_device(sc, hdr->type_arg)) != NULL) {
memcpy(ac->rdesc, payload, pl_len);
ac->rdesc_len = ac->hw.rdescsize = pl_len;
DPRINTF("%s HID report descriptor: %*D\n", ac->name,
(int) ac->hw.rdescsize, ac->rdesc, " ");
} else if (device == ATOPCASE_DEV_INFO
&& hdr->type == ATOPCASE_MSG_TYPE_INFO(ATOPCASE_INFO_DEVICE)
&& hdr->type_arg == ATOPCASE_INFO_DEVICE) {
struct atopcase_device_info_payload *dev = payload;
sc->sc_vid = le16toh(dev->vid);
sc->sc_pid = le16toh(dev->pid);
sc->sc_ver = le16toh(dev->ver);
CPOFF(sc->sc_vendor, dev->vendor_len, dev->vendor_off);
CPOFF(sc->sc_product, dev->product_len, dev->product_off);
CPOFF(sc->sc_serial, dev->serial_len, dev->serial_off);
if (bootverbose) {
device_printf(sc->sc_dev, "Device info descriptor:\n");
printf(" Vendor: %s\n", sc->sc_vendor);
printf(" Product: %s\n", sc->sc_product);
printf(" Serial: %s\n", sc->sc_serial);
}
}
return (0);
}
int
atopcase_receive_packet(struct atopcase_softc *sc)
{
struct atopcase_packet pkt = { 0 };
struct spi_command cmd = SPI_COMMAND_INITIALIZER;
void *msg;
int err;
uint16_t length, remaining, offset, msg_len;
bzero(&sc->sc_junk, sizeof(struct atopcase_packet));
cmd.tx_cmd = &sc->sc_junk;
cmd.tx_cmd_sz = sizeof(struct atopcase_packet);
cmd.rx_cmd = &pkt;
cmd.rx_cmd_sz = sizeof(struct atopcase_packet);
cmd.flags = ATOPCASE_SPI_NO_SLEEP_FLAG(sc);
err = SPIBUS_TRANSFER(device_get_parent(sc->sc_dev), sc->sc_dev, &cmd);
ATOPCASE_SPI_PAUSE();
if (err) {
device_printf(sc->sc_dev, "SPI error: %d\n", err);
return (err);
}
DPRINTFN(ATOPCASE_LLEVEL_TRACE, "Response: %*D\n", 256, &pkt, " ");
if (le16toh(pkt.checksum) != crc16(0, &pkt, sizeof(pkt) - 2)) {
DPRINTFN(ATOPCASE_LLEVEL_DEBUG, "packet with failed checksum\n");
return (EIO);
}
/*
* When we poll and nothing has arrived we get a particular packet
* starting with '80 11 00 01'
*/
if (pkt.direction == ATOPCASE_DIR_NOTHING) {
DPRINTFN(ATOPCASE_LLEVEL_DEBUG, "'Nothing' packet: %*D\n", 4,
&pkt, " ");
return (EAGAIN);
}
if (pkt.direction != ATOPCASE_DIR_READ &&
pkt.direction != ATOPCASE_DIR_WRITE) {
DPRINTFN(ATOPCASE_LLEVEL_DEBUG,
"unknown message direction 0x%x\n", pkt.direction);
return (EIO);
}
length = le16toh(pkt.length);
remaining = le16toh(pkt.remaining);
offset = le16toh(pkt.offset);
if (length > sizeof(pkt.data)) {
DPRINTFN(ATOPCASE_LLEVEL_DEBUG,
"packet with length overflow: %u\n", length);
return (EIO);
}
if (pkt.direction == ATOPCASE_DIR_READ &&
pkt.device == ATOPCASE_DEV_INFO &&
length == sizeof(booted) &&
memcmp(pkt.data, booted, length) == 0) {
DPRINTFN(ATOPCASE_LLEVEL_DEBUG, "GPE boot packet\n");
sc->sc_booted = true;
ATOPCASE_WAKEUP(sc, sc);
return (0);
}
/* handle multi-packet messages */
if (remaining != 0 || offset != 0) {
if (offset != sc->sc_msg_len) {
DPRINTFN(ATOPCASE_LLEVEL_DEBUG,
"Unexpected offset (got %u, expected %u)\n",
offset, sc->sc_msg_len);
sc->sc_msg_len = 0;
return (EIO);
}
if ((size_t)remaining + length + offset > sizeof(sc->sc_msg)) {
DPRINTFN(ATOPCASE_LLEVEL_DEBUG,
"Message with length overflow: %zu\n",
(size_t)remaining + length + offset);
sc->sc_msg_len = 0;
return (EIO);
}
memcpy(sc->sc_msg + offset, &pkt.data, length);
sc->sc_msg_len += length;
if (remaining != 0)
return (0);
msg = sc->sc_msg;
msg_len = sc->sc_msg_len;
} else {
msg = pkt.data;
msg_len = length;
}
sc->sc_msg_len = 0;
err = atopcase_process_message(sc, pkt.device, msg, msg_len);
if (err == 0 && pkt.direction == ATOPCASE_DIR_WRITE) {
DPRINTFN(ATOPCASE_LLEVEL_DEBUG, "Write ack\n");
ATOPCASE_WAKEUP(sc, sc);
}
return (err);
}
static int
atopcase_send(struct atopcase_softc *sc, struct atopcase_packet *pkt)
{
struct spi_command cmd = SPI_COMMAND_INITIALIZER;
int err, retries;
cmd.tx_cmd = pkt;
cmd.tx_cmd_sz = sizeof(struct atopcase_packet);
cmd.rx_cmd = &sc->sc_junk;
cmd.rx_cmd_sz = sizeof(struct atopcase_packet);
cmd.flags = SPI_FLAG_KEEP_CS | ATOPCASE_SPI_NO_SLEEP_FLAG(sc);
DPRINTFN(ATOPCASE_LLEVEL_TRACE, "Request: %*D\n",
(int)sizeof(struct atopcase_packet), cmd.tx_cmd, " ");
if (!ATOPCASE_IN_POLLING_MODE(sc)) {
if (sc->sc_irq_ih != NULL)
mtx_lock(&sc->sc_mtx);
else
sx_xlock(&sc->sc_sx);
}
sc->sc_wait_for_status = true;
err = SPIBUS_TRANSFER(device_get_parent(sc->sc_dev), sc->sc_dev, &cmd);
ATOPCASE_SPI_PAUSE();
if (!ATOPCASE_IN_POLLING_MODE(sc)) {
if (sc->sc_irq_ih != NULL)
mtx_unlock(&sc->sc_mtx);
else
sx_xunlock(&sc->sc_sx);
}
if (err != 0) {
device_printf(sc->sc_dev, "SPI error: %d\n", err);
goto exit;
}
if (ATOPCASE_IN_POLLING_MODE(sc)) {
err = atopcase_receive_status(sc);
} else {
DPRINTFN(ATOPCASE_LLEVEL_DEBUG, "wait for: %p\n", sc->sc_dev);
err = tsleep(sc->sc_dev, 0, "atcstat", hz / 10);
}
sc->sc_wait_for_status = false;
if (err != 0) {
DPRINTF("Write status read failed: %d\n", err);
goto exit;
}
if (ATOPCASE_IN_POLLING_MODE(sc)) {
/* Backlight setting may require a lot of time */
retries = 20;
while ((err = atopcase_receive_packet(sc)) == EAGAIN &&
--retries != 0)
DELAY(1000);
} else {
DPRINTFN(ATOPCASE_LLEVEL_DEBUG, "wait for: %p\n", sc);
err = tsleep(sc, 0, "atcack", hz / 10);
}
if (err != 0)
DPRINTF("Write ack read failed: %d\n", err);
exit:
if (err == EWOULDBLOCK)
err = EIO;
return (err);
}
static void
atopcase_create_message(struct atopcase_packet *pkt, uint8_t device,
uint16_t type, uint8_t type_arg, const void *payload, uint8_t len,
uint16_t resp_len)
{
struct atopcase_header *hdr = (struct atopcase_header *)pkt->data;
uint16_t msg_checksum;
static uint8_t seq_no;
KASSERT(len <= ATOPCASE_DATA_SIZE - sizeof(struct atopcase_header),
("outgoing msg must be 1 packet"));
bzero(pkt, sizeof(struct atopcase_packet));
pkt->direction = ATOPCASE_DIR_WRITE;
pkt->device = device;
pkt->length = htole16(sizeof(*hdr) + len + 2);
hdr->type = htole16(type);
hdr->type_arg = type_arg;
hdr->seq_no = seq_no++;
hdr->resp_len = htole16((resp_len == 0) ? len : resp_len);
hdr->len = htole16(len);
memcpy(pkt->data + sizeof(*hdr), payload, len);
msg_checksum = htole16(crc16(0, pkt->data, pkt->length - 2));
memcpy(pkt->data + sizeof(*hdr) + len, &msg_checksum, 2);
pkt->checksum = htole16(crc16(0, (uint8_t*)pkt, sizeof(*pkt) - 2));
return;
}
static int
atopcase_request_desc(struct atopcase_softc *sc, uint16_t type, uint8_t device)
{
atopcase_create_message(
&sc->sc_buf, ATOPCASE_DEV_INFO, type, device, NULL, 0, 0x200);
return (atopcase_send(sc, &sc->sc_buf));
}
int
atopcase_intr(struct atopcase_softc *sc)
{
int err;
DPRINTFN(ATOPCASE_LLEVEL_DEBUG, "Interrupt event\n");
if (sc->sc_wait_for_status) {
err = atopcase_receive_status(sc);
sc->sc_wait_for_status = false;
} else
err = atopcase_receive_packet(sc);
return (err);
}
static int
atopcase_add_child(struct atopcase_softc *sc, struct atopcase_child *ac,
uint8_t device)
{
device_t hidbus;
int err = 0;
ac->device = device;
/* fill device info */
strlcpy(ac->hw.name, "Apple MacBook", sizeof(ac->hw.name));
ac->hw.idBus = BUS_SPI;
ac->hw.idVendor = sc->sc_vid;
ac->hw.idProduct = sc->sc_pid;
ac->hw.idVersion = sc->sc_ver;
strlcpy(ac->hw.idPnP, sc->sc_hid, sizeof(ac->hw.idPnP));
strlcpy(ac->hw.serial, sc->sc_serial, sizeof(ac->hw.serial));
/*
* HID write and set_report methods executed on Apple SPI topcase
* hardware do the same request on SPI layer. Set HQ_NOWRITE quirk to
* force hidmap to convert writes to set_reports. That makes HID bus
* write handler unnecessary and reduces code duplication.
*/
hid_add_dynamic_quirk(&ac->hw, HQ_NOWRITE);
DPRINTF("Get the interface #%d descriptor\n", device);
err = atopcase_request_desc(sc,
ATOPCASE_MSG_TYPE_INFO(ATOPCASE_INFO_IFACE), device);
if (err) {
device_printf(sc->sc_dev, "can't receive iface descriptor\n");
goto exit;
}
DPRINTF("Get the \"%s\" HID report descriptor\n", ac->name);
err = atopcase_request_desc(sc,
ATOPCASE_MSG_TYPE_INFO(ATOPCASE_INFO_DESCRIPTOR), device);
if (err) {
device_printf(sc->sc_dev, "can't receive report descriptor\n");
goto exit;
}
hidbus = device_add_child(sc->sc_dev, "hidbus", -1);
if (hidbus == NULL) {
device_printf(sc->sc_dev, "can't add child\n");
err = ENOMEM;
goto exit;
}
device_set_ivars(hidbus, &ac->hw);
ac->hidbus = hidbus;
exit:
return (err);
}
int
atopcase_init(struct atopcase_softc *sc)
{
int err;
/* Wait until we know we're getting reasonable responses */
if(!sc->sc_booted && tsleep(sc, 0, "atcboot", hz / 20) != 0) {
device_printf(sc->sc_dev, "can't establish communication\n");
err = EIO;
goto err;
}
/*
* Management device may send a message on first boot after power off.
* Let interrupt handler to read and discard it.
*/
DELAY(2000);
DPRINTF("Get the device descriptor\n");
err = atopcase_request_desc(sc,
ATOPCASE_MSG_TYPE_INFO(ATOPCASE_INFO_DEVICE),
ATOPCASE_INFO_DEVICE);
if (err) {
device_printf(sc->sc_dev, "can't receive device descriptor\n");
goto err;
}
err = atopcase_add_child(sc, &sc->sc_kb, ATOPCASE_DEV_KBRD);
if (err != 0)
goto err;
err = atopcase_add_child(sc, &sc->sc_tp, ATOPCASE_DEV_TPAD);
if (err != 0)
goto err;
/* TODO: skip on 2015 models where it's controlled by asmc */
sc->sc_backlight = backlight_register("atopcase", sc->sc_dev);
if (!sc->sc_backlight) {
device_printf(sc->sc_dev, "can't register backlight\n");
err = ENOMEM;
}
if (sc->sc_tq != NULL)
taskqueue_enqueue_timeout(sc->sc_tq, &sc->sc_task, hz / 120);
return (bus_generic_attach(sc->sc_dev));
err:
return (err);
}
int
atopcase_destroy(struct atopcase_softc *sc)
{
int err;
err = device_delete_children(sc->sc_dev);
if (err)
return (err);
if (sc->sc_backlight)
backlight_destroy(sc->sc_backlight);
return (0);
}
static struct atopcase_child *
atopcase_get_child_by_hidbus(device_t child)
{
device_t parent = device_get_parent(child);
struct atopcase_softc *sc = device_get_softc(parent);
if (child == sc->sc_kb.hidbus)
return (&sc->sc_kb);
if (child == sc->sc_tp.hidbus)
return (&sc->sc_tp);
panic("unknown child");
}
void
atopcase_intr_setup(device_t dev, device_t child, hid_intr_t intr,
void *context, struct hid_rdesc_info *rdesc)
{
struct atopcase_child *ac = atopcase_get_child_by_hidbus(child);
if (intr == NULL)
return;
rdesc->rdsize = ATOPCASE_MSG_SIZE - sizeof(struct atopcase_header) - 2;
rdesc->grsize = 0;
rdesc->srsize = ATOPCASE_DATA_SIZE - sizeof(struct atopcase_header) - 2;
rdesc->wrsize = 0;
ac->intr_handler = intr;
ac->intr_ctx = context;
}
void
atopcase_intr_unsetup(device_t dev, device_t child)
{
}
int
atopcase_intr_start(device_t dev, device_t child)
{
struct atopcase_softc *sc = device_get_softc(dev);
struct atopcase_child *ac = atopcase_get_child_by_hidbus(child);
if (ATOPCASE_IN_POLLING_MODE(sc))
sx_xlock(&sc->sc_write_sx);
else if (sc->sc_irq_ih != NULL)
mtx_lock(&sc->sc_mtx);
else
sx_xlock(&sc->sc_sx);
ac->open = true;
if (ATOPCASE_IN_POLLING_MODE(sc))
sx_xunlock(&sc->sc_write_sx);
else if (sc->sc_irq_ih != NULL)
mtx_unlock(&sc->sc_mtx);
else
sx_xunlock(&sc->sc_sx);
return (0);
}
int
atopcase_intr_stop(device_t dev, device_t child)
{
struct atopcase_softc *sc = device_get_softc(dev);
struct atopcase_child *ac = atopcase_get_child_by_hidbus(child);
if (ATOPCASE_IN_POLLING_MODE(sc))
sx_xlock(&sc->sc_write_sx);
else if (sc->sc_irq_ih != NULL)
mtx_lock(&sc->sc_mtx);
else
sx_xlock(&sc->sc_sx);
ac->open = false;
if (ATOPCASE_IN_POLLING_MODE(sc))
sx_xunlock(&sc->sc_write_sx);
else if (sc->sc_irq_ih != NULL)
mtx_unlock(&sc->sc_mtx);
else
sx_xunlock(&sc->sc_sx);
return (0);
}
void
atopcase_intr_poll(device_t dev, device_t child)
{
struct atopcase_softc *sc = device_get_softc(dev);
(void)atopcase_receive_packet(sc);
}
int
atopcase_get_rdesc(device_t dev, device_t child, void *buf, hid_size_t len)
{
struct atopcase_child *ac = atopcase_get_child_by_hidbus(child);
if (ac->rdesc_len != len)
return (ENXIO);
memcpy(buf, ac->rdesc, len);
return (0);
}
int
atopcase_set_report(device_t dev, device_t child, const void *buf,
hid_size_t len, uint8_t type __unused, uint8_t id)
{
struct atopcase_softc *sc = device_get_softc(dev);
struct atopcase_child *ac = atopcase_get_child_by_hidbus(child);
int err;
if (len >= ATOPCASE_DATA_SIZE - sizeof(struct atopcase_header) - 2)
return (EINVAL);
DPRINTF("%s HID command SET_REPORT %d (len %d): %*D\n",
ac->name, id, len, len, buf, " ");
if (!ATOPCASE_IN_KDB())
sx_xlock(&sc->sc_write_sx);
atopcase_create_message(&sc->sc_buf, ac->device,
ATOPCASE_MSG_TYPE_SET_REPORT(ac->device, id), 0, buf, len, 0);
err = atopcase_send(sc, &sc->sc_buf);
if (!ATOPCASE_IN_KDB())
sx_xunlock(&sc->sc_write_sx);
return (err);
}
int
atopcase_backlight_update_status(device_t dev, struct backlight_props *props)
{
struct atopcase_softc *sc = device_get_softc(dev);
struct atopcase_bl_payload payload = { 0 };
payload.report_id = ATOPCASE_BKL_REPORT_ID;
payload.device = ATOPCASE_DEV_KBRD;
/*
* Hardware range is 32-255 for visible backlight,
* convert from percentages
*/
payload.level = (props->brightness == 0) ? 0 :
(32 + (223 * props->brightness / 100));
payload.status = (payload.level > 0) ? 0x01F4 : 0x1;
return (atopcase_set_report(dev, sc->sc_kb.hidbus, &payload,
sizeof(payload), HID_OUTPUT_REPORT, ATOPCASE_BKL_REPORT_ID));
}
int
atopcase_backlight_get_status(device_t dev, struct backlight_props *props)
{
struct atopcase_softc *sc = device_get_softc(dev);
props->brightness = sc->sc_backlight_level;
props->nlevels = 0;
return (0);
}
int
atopcase_backlight_get_info(device_t dev, struct backlight_info *info)
{
info->type = BACKLIGHT_TYPE_KEYBOARD;
strlcpy(info->name, "Apple MacBook Keyboard", BACKLIGHTMAXNAMELENGTH);
return (0);
}

458
sys/dev/atopcase/atopcase_acpi.c Normal file
View File

@ -0,0 +1,458 @@
/*-
* SPDX-License-Identifier: BSD-2-Clause
*
* Copyright (c) 2021-2023 Val Packett <val@packett.cool>
* Copyright (c) 2023 Vladimir Kondratyev <wulf@FreeBSD.org>
*
* 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 "opt_acpi.h"
#include "opt_hid.h"
#include <sys/param.h>
#include <sys/bus.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/mutex.h>
#include <sys/module.h>
#include <sys/rman.h>
#include <sys/sx.h>
#include <sys/taskqueue.h>
#include <contrib/dev/acpica/include/acpi.h>
#include <contrib/dev/acpica/include/accommon.h>
#include <contrib/dev/acpica/include/acevents.h>
#include <dev/acpica/acpivar.h>
#include <dev/acpica/acpiio.h>
#include <dev/backlight/backlight.h>
#include <dev/evdev/input.h>
#define HID_DEBUG_VAR atopcase_debug
#include <dev/hid/hid.h>
#include <dev/hid/hidquirk.h>
#include <dev/spibus/spi.h>
#include <dev/spibus/spibusvar.h>
#include "backlight_if.h"
#include "hid_if.h"
#include "atopcase_reg.h"
#include "atopcase_var.h"
/*
* XXX: The Linux driver only supports ACPI GPEs, but we only receive
* interrupts in this driver on a MacBookPro 12,1 and 14,1. This is because
* Linux responds to _OSI("Darwin") while we don't!
*
* ACPI GPE is enabled on FreeBSD by addition of following lines to
* /boot/loader.conf:
* hw.acpi.install_interface="Darwin"
* hw.acpi.remove_interface="Windows 2009, Windows 2012"
*/
static const char *atopcase_ids[] = { "APP000D", NULL };
static device_probe_t atopcase_acpi_probe;
static device_attach_t atopcase_acpi_attach;
static device_detach_t atopcase_acpi_detach;
static device_suspend_t atopcase_acpi_suspend;
static device_resume_t atopcase_acpi_resume;
static bool
acpi_is_atopcase(ACPI_HANDLE handle)
{
const char **ids;
UINT32 sta;
for (ids = atopcase_ids; *ids != NULL; ids++) {
if (acpi_MatchHid(handle, *ids))
break;
}
if (*ids == NULL)
return (false);
/*
* If no _STA method or if it failed, then assume that
* the device is present.
*/
if (ACPI_FAILURE(acpi_GetInteger(handle, "_STA", &sta)) ||
ACPI_DEVICE_PRESENT(sta))
return (true);
return (false);
}
static int
atopcase_acpi_set_comm_enabled(struct atopcase_softc *sc, char *prop,
const bool on)
{
ACPI_OBJECT argobj;
ACPI_OBJECT_LIST args;
argobj.Type = ACPI_TYPE_INTEGER;
argobj.Integer.Value = on;
args.Count = 1;
args.Pointer = &argobj;
if (ACPI_FAILURE(
AcpiEvaluateObject(sc->sc_handle, prop, &args, NULL)))
return (ENXIO);
DELAY(100);
return (0);
}
static int
atopcase_acpi_test_comm_enabled(ACPI_HANDLE handle, char *prop, int *enabled)
{
if (ACPI_FAILURE(acpi_GetInteger(handle, prop, enabled)))
return (ENXIO);
return (0);
}
static void
atopcase_acpi_task(void *ctx, int pending __unused)
{
struct atopcase_softc *sc = ctx;
int err = EAGAIN;
DPRINTFN(ATOPCASE_LLEVEL_DEBUG, "Timer event\n");
sx_xlock(&sc->sc_write_sx);
err = atopcase_receive_packet(sc);
sx_xunlock(&sc->sc_write_sx);
/* Rearm timer */
taskqueue_enqueue_timeout(sc->sc_tq, &sc->sc_task,
hz / (err == EAGAIN ? 10 : 120));
}
static void
atopcase_acpi_gpe_task(void *ctx)
{
struct atopcase_softc *sc = ctx;
DPRINTFN(ATOPCASE_LLEVEL_DEBUG, "GPE event\n");
sx_xlock(&sc->sc_sx);
(void)atopcase_intr(sc);
sx_xunlock(&sc->sc_sx);
/* Rearm GPE */
if (ACPI_FAILURE(AcpiFinishGpe(NULL, sc->sc_gpe_bit)))
device_printf(sc->sc_dev, "GPE rearm failed\n");
}
static UINT32
atopcase_acpi_notify(ACPI_HANDLE h __unused, UINT32 notify __unused, void *ctx)
{
AcpiOsExecute(OSL_GPE_HANDLER, atopcase_acpi_gpe_task, ctx);
return (0);
}
static void
atopcase_acpi_intr(void *ctx)
{
struct atopcase_softc *sc = ctx;
DPRINTFN(ATOPCASE_LLEVEL_DEBUG, "Interrupt event\n");
mtx_lock(&sc->sc_mtx);
sc->sc_intr_cnt++;
(void)atopcase_intr(sc);
mtx_unlock(&sc->sc_mtx);
}
static int
atopcase_acpi_probe(device_t dev)
{
ACPI_HANDLE handle;
int usb_enabled;
if (acpi_disabled("atopcase"))
return (ENXIO);
handle = acpi_get_handle(dev);
if (handle == NULL)
return (ENXIO);
if (!acpi_is_atopcase(handle))
return (ENXIO);
/* If USB interface exists and is enabled, use USB driver */
if (atopcase_acpi_test_comm_enabled(handle, "UIST", &usb_enabled) == 0
&& usb_enabled != 0)
return (ENXIO);
device_set_desc(dev, "Apple MacBook SPI Topcase");
return (BUS_PROBE_DEFAULT);
}
static int
atopcase_acpi_attach(device_t dev)
{
struct atopcase_softc *sc = device_get_softc(dev);
ACPI_DEVICE_INFO *device_info;
uint32_t cs_delay;
int spi_enabled, err;
sc->sc_dev = dev;
sc->sc_handle = acpi_get_handle(dev);
if (atopcase_acpi_test_comm_enabled(sc->sc_handle, "SIST",
&spi_enabled) != 0) {
device_printf(dev, "can't test SPI communication\n");
return (ENXIO);
}
/* Turn SPI off if enabled to force "booted" packet to appear */
if (spi_enabled != 0 &&
atopcase_acpi_set_comm_enabled(sc, "SIEN", false) != 0) {
device_printf(dev, "can't disable SPI communication\n");
return (ENXIO);
}
if (atopcase_acpi_set_comm_enabled(sc, "SIEN", true) != 0) {
device_printf(dev, "can't enable SPI communication\n");
return (ENXIO);
}
/*
* Apple encodes a CS delay in ACPI properties, but
* - they're encoded in a non-standard way that predates _DSD, and
* - they're only exported if you respond to _OSI(Darwin) which we don't
* - because that has more side effects than we're prepared to handle
* - Apple makes a Windows driver and Windows is not Darwin
* - so presumably that one uses hardcoded values too
*/
spibus_get_cs_delay(sc->sc_dev, &cs_delay);
if (cs_delay == 0)
spibus_set_cs_delay(sc->sc_dev, 10);
/* Retrieve ACPI _HID */
if (ACPI_FAILURE(AcpiGetObjectInfo(sc->sc_handle, &device_info)))
return (ENXIO);
if (device_info->Valid & ACPI_VALID_HID)
strlcpy(sc->sc_hid, device_info->HardwareId.String,
sizeof(sc->sc_hid));
AcpiOsFree(device_info);
sx_init(&sc->sc_write_sx, "atc_wr");
sx_init(&sc->sc_sx, "atc_sx");
mtx_init(&sc->sc_mtx, device_get_nameunit(dev), NULL, MTX_DEF);
err = ENXIO;
sc->sc_irq_res = bus_alloc_resource_any(sc->sc_dev,
SYS_RES_IRQ, &sc->sc_irq_rid, RF_ACTIVE);
if (sc->sc_irq_res != NULL) {
if (bus_setup_intr(dev, sc->sc_irq_res,
INTR_TYPE_MISC | INTR_MPSAFE, NULL,
atopcase_acpi_intr, sc, &sc->sc_irq_ih) != 0) {
device_printf(dev, "can't setup interrupt handler\n");
goto err;
}
device_printf(dev, "Using interrupts.\n");
/*
* On some hardware interrupts are not acked by SPI read for
* unknown reasons that leads to interrupt storm due to level
* triggering. GPE does not suffer from this problem.
*
* TODO: Find out what Windows driver does to ack IRQ.
*/
pause("atopcase", hz / 5);
DPRINTF("interrupts asserted: %u\n", sc->sc_intr_cnt);
if (sc->sc_intr_cnt > 2 || sc->sc_intr_cnt == 0) {
bus_teardown_intr(dev, sc->sc_irq_res, sc->sc_irq_ih);
sc->sc_irq_ih = NULL;
device_printf(dev, "Interrupt storm detected. "
"Falling back to polling\n");
sc->sc_tq = taskqueue_create("atc_tq", M_WAITOK|M_ZERO,
taskqueue_thread_enqueue, &sc->sc_tq);
TIMEOUT_TASK_INIT(sc->sc_tq, &sc->sc_task, 0,
atopcase_acpi_task, sc);
taskqueue_start_threads(&sc->sc_tq, 1, PI_TTY,
"%s taskq", device_get_nameunit(dev));
}
/*
* Interrupts does not work at all. It may happen if kernel
* erroneously detected stray irq at bus_teardown_intr() and
* completelly disabled it after than.
* Fetch "booted" packet manually to pass communication check.
*/
if (sc->sc_intr_cnt == 0)
atopcase_receive_packet(sc);
} else {
if (bootverbose)
device_printf(dev, "can't allocate IRQ resource\n");
if (ACPI_FAILURE(acpi_GetInteger(sc->sc_handle, "_GPE",
&sc->sc_gpe_bit))) {
device_printf(dev, "can't allocate nor IRQ nor GPE\n");
goto err;
}
if (ACPI_FAILURE(AcpiInstallGpeHandler(NULL, sc->sc_gpe_bit,
ACPI_GPE_LEVEL_TRIGGERED, atopcase_acpi_notify, sc))) {
device_printf(dev, "can't install ACPI GPE handler\n");
goto err;
}
if (ACPI_FAILURE(AcpiEnableGpe(NULL, sc->sc_gpe_bit))) {
device_printf(dev, "can't enable ACPI notification\n");
goto err;
}
device_printf(dev, "Using ACPI GPE.\n");
if (bootverbose)
device_printf(dev, "GPE int %d\n", sc->sc_gpe_bit);
}
err = atopcase_init(sc);
err:
if (err != 0)
atopcase_acpi_detach(dev);
return (err);
}
static int
atopcase_acpi_detach(device_t dev)
{
struct atopcase_softc *sc = device_get_softc(dev);
int err;
err = atopcase_destroy(sc);
if (err != 0)
return (err);
if (sc->sc_irq_ih)
bus_teardown_intr(dev, sc->sc_irq_res, sc->sc_irq_ih);
if (sc->sc_irq_res != NULL)
bus_release_resource(dev, SYS_RES_IRQ,
sc->sc_irq_rid, sc->sc_irq_res);
if (sc->sc_tq != NULL) {
while (taskqueue_cancel_timeout(sc->sc_tq, &sc->sc_task, NULL))
taskqueue_drain_timeout(sc->sc_tq, &sc->sc_task);
taskqueue_free(sc->sc_tq);
}
if (sc->sc_gpe_bit != 0 && ACPI_FAILURE(AcpiRemoveGpeHandler(NULL,
sc->sc_gpe_bit, atopcase_acpi_notify)))
device_printf(dev, "can't remove ACPI GPE handler\n");
if (atopcase_acpi_set_comm_enabled(sc, "SIEN", false) != 0)
device_printf(dev, "can't disable SPI communication\n");
mtx_destroy(&sc->sc_mtx);
sx_destroy(&sc->sc_sx);
sx_destroy(&sc->sc_write_sx);
return (0);
}
static int
atopcase_acpi_suspend(device_t dev)
{
struct atopcase_softc *sc = device_get_softc(dev);
int err;
err = bus_generic_suspend(dev);
if (err)
return (err);
if (sc->sc_gpe_bit != 0)
AcpiDisableGpe(NULL, sc->sc_gpe_bit);
if (sc->sc_tq != NULL)
while (taskqueue_cancel_timeout(sc->sc_tq, &sc->sc_task, NULL))
taskqueue_drain_timeout(sc->sc_tq, &sc->sc_task);
if (atopcase_acpi_set_comm_enabled(sc, "SIEN", false) != 0)
device_printf(dev, "can't disable SPI communication\n");
return (0);
}
static int
atopcase_acpi_resume(device_t dev)
{
struct atopcase_softc *sc = device_get_softc(dev);
if (sc->sc_gpe_bit != 0)
AcpiEnableGpe(NULL, sc->sc_gpe_bit);
if (sc->sc_tq != NULL)
taskqueue_enqueue_timeout(sc->sc_tq, &sc->sc_task, hz / 120);
if (atopcase_acpi_set_comm_enabled(sc, "SIEN", true) != 0) {
device_printf(dev, "can't enable SPI communication\n");
return (ENXIO);
}
return (bus_generic_resume(dev));
}
static device_method_t atopcase_methods[] = {
/* Device interface */
DEVMETHOD(device_probe, atopcase_acpi_probe),
DEVMETHOD(device_attach, atopcase_acpi_attach),
DEVMETHOD(device_detach, atopcase_acpi_detach),
DEVMETHOD(device_suspend, atopcase_acpi_suspend),
DEVMETHOD(device_resume, atopcase_acpi_resume),
/* HID interrupt interface */
DEVMETHOD(hid_intr_setup, atopcase_intr_setup),
DEVMETHOD(hid_intr_unsetup, atopcase_intr_unsetup),
DEVMETHOD(hid_intr_start, atopcase_intr_start),
DEVMETHOD(hid_intr_stop, atopcase_intr_stop),
DEVMETHOD(hid_intr_poll, atopcase_intr_poll),
/* HID interface */
DEVMETHOD(hid_get_rdesc, atopcase_get_rdesc),
DEVMETHOD(hid_set_report, atopcase_set_report),
/* Backlight interface */
DEVMETHOD(backlight_update_status, atopcase_backlight_update_status),
DEVMETHOD(backlight_get_status, atopcase_backlight_get_status),
DEVMETHOD(backlight_get_info, atopcase_backlight_get_info),
DEVMETHOD_END
};
static driver_t atopcase_driver = {
"atopcase",
atopcase_methods,
sizeof(struct atopcase_softc),
};
DRIVER_MODULE(atopcase, spibus, atopcase_driver, 0, 0);
MODULE_DEPEND(atopcase, acpi, 1, 1, 1);
MODULE_DEPEND(atopcase, backlight, 1, 1, 1);
MODULE_DEPEND(atopcase, hid, 1, 1, 1);
MODULE_DEPEND(atopcase, hidbus, 1, 1, 1);
MODULE_DEPEND(atopcase, spibus, 1, 1, 1);
MODULE_VERSION(atopcase, 1);
SPIBUS_ACPI_PNP_INFO(atopcase_ids);

110
sys/dev/atopcase/atopcase_reg.h Normal file
View File

@ -0,0 +1,110 @@
/*-
* SPDX-License-Identifier: BSD-2-Clause
*
* Copyright (c) 2021-2023 Val Packett <val@packett.cool>
* Copyright (c) 2023 Vladimir Kondratyev <wulf@FreeBSD.org>
*
* 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.
*/
#ifndef _ATOPCASE_REG_H_
#define _ATOPCASE_REG_H_
#include <sys/types.h>
#define ATOPCASE_PACKET_SIZE 256
#define ATOPCASE_DATA_SIZE 246
#define ATOPCASE_PKT_PER_MSG 2
#define ATOPCASE_MSG_SIZE (ATOPCASE_DATA_SIZE * ATOPCASE_PKT_PER_MSG)
/* Read == device-initiated, Write == host-initiated or reply to that */
#define ATOPCASE_DIR_READ 0x20
#define ATOPCASE_DIR_WRITE 0x40
#define ATOPCASE_DIR_NOTHING 0x80
#define ATOPCASE_DEV_MGMT 0x00
#define ATOPCASE_DEV_KBRD 0x01
#define ATOPCASE_DEV_TPAD 0x02
#define ATOPCASE_DEV_INFO 0xD0
#define ATOPCASE_BKL_REPORT_ID 0xB0
#define ATOPCASE_INFO_DEVICE 0x01
#define ATOPCASE_INFO_IFACE 0x02
#define ATOPCASE_INFO_DESCRIPTOR 0x10
#define ATOPCASE_MSG_TYPE_SET_REPORT(dev,rid) ((rid << 8) | 0x50 | dev)
#define ATOPCASE_MSG_TYPE_REPORT(dev) ((dev << 8) | 0x10)
#define ATOPCASE_MSG_TYPE_INFO(inf) ((inf << 8) | 0x20)
struct atopcase_bl_payload {
uint8_t report_id;
uint8_t device;
uint16_t level;
uint16_t status;
} __packed;
struct atopcase_device_info_payload {
uint16_t unknown[2];
uint16_t num_devs;
uint16_t vid;
uint16_t pid;
uint16_t ver;
uint16_t vendor_off;
uint16_t vendor_len;
uint16_t product_off;
uint16_t product_len;
uint16_t serial_off;
uint16_t serial_len;
} __packed;
struct atopcase_iface_info_payload {
uint8_t unknown0;
uint8_t iface_num;
uint8_t unknown1[3];
uint8_t country_code;
uint16_t max_input_report_len;
uint16_t max_output_report_len;
uint16_t max_control_report_len;
uint16_t name_off;
uint16_t name_len;
} __packed;
struct atopcase_header {
uint16_t type;
uint8_t type_arg; /* means "device" for ATOPCASE_MSG_TYPE_DESCRIPTOR */
uint8_t seq_no;
uint16_t resp_len;
uint16_t len;
} __packed;
struct atopcase_packet {
uint8_t direction;
uint8_t device;
uint16_t offset;
uint16_t remaining;
uint16_t length;
uint8_t data[ATOPCASE_DATA_SIZE];
uint16_t checksum;
} __packed;
#endif /* _ATOPCASE_REG_H_ */

142
sys/dev/atopcase/atopcase_var.h Normal file
View File

@ -0,0 +1,142 @@
/*-
* SPDX-License-Identifier: BSD-2-Clause
*
* Copyright (c) 2021-2023 Val Packett <val@packett.cool>
* Copyright (c) 2023 Vladimir Kondratyev <wulf@FreeBSD.org>
*
* 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.
*/
#ifndef _ATOPCASE_VAR_H_
#define _ATOPCASE_VAR_H_
#include "opt_hid.h"
#include <sys/types.h>
#include <sys/bus.h>
#include <sys/taskqueue.h>
#include <contrib/dev/acpica/include/acpi.h>
#include <dev/acpica/acpivar.h>
#include <dev/backlight/backlight.h>
#include <dev/hid/hid.h>
struct atopcase_child {
device_t hidbus;
struct hid_device_info hw;
uint8_t device;
uint8_t name[80];
uint8_t rdesc[ATOPCASE_MSG_SIZE];
size_t rdesc_len;
hid_intr_t *intr_handler;
void *intr_ctx;
bool open;
};
struct atopcase_softc {
device_t sc_dev;
ACPI_HANDLE sc_handle;
int sc_gpe_bit;
int sc_irq_rid;
struct resource *sc_irq_res;
void *sc_irq_ih;
volatile unsigned int sc_intr_cnt;
struct timeout_task sc_task;
struct taskqueue *sc_tq;
bool sc_booted;
bool sc_wait_for_status;
uint8_t sc_hid[HID_PNP_ID_SIZE];
uint8_t sc_vendor[80];
uint8_t sc_product[80];
uint8_t sc_serial[80];
uint16_t sc_vid;
uint16_t sc_pid;
uint16_t sc_ver;
/*
* Writes are complex and async (i.e. 2 responses arrive via interrupt)
* and cannot be interleaved (no new writes until responses arrive).
* they are serialized with sc_write_sx lock.
*/
struct sx sc_write_sx;
/*
* SPI transfers must be separated by a small pause. As they can be
* initiated by both interrupts and users, do ATOPCASE_SPI_PAUSE()
* after each transfer and serialize them with sc_sx or sc_mtx locks
* depending on interupt source (GPE or PIC). Still use sc_write_sx
* lock while polling.
*/
struct sx sc_sx;
struct mtx sc_mtx;
struct atopcase_child sc_kb;
struct atopcase_child sc_tp;
struct cdev *sc_backlight;
uint32_t sc_backlight_level;
uint16_t sc_msg_len;
uint8_t sc_msg[ATOPCASE_MSG_SIZE];
struct atopcase_packet sc_buf;
struct atopcase_packet sc_junk;
};
#ifdef HID_DEBUG
enum atopcase_log_level {
ATOPCASE_LLEVEL_DISABLED = 0,
ATOPCASE_LLEVEL_INFO,
ATOPCASE_LLEVEL_DEBUG, /* for troubleshooting */
ATOPCASE_LLEVEL_TRACE, /* log every packet */
};
extern enum atopcase_log_level atopcase_debug;
#endif
int atopcase_receive_packet(struct atopcase_softc *);
int atopcase_init(struct atopcase_softc *);
int atopcase_destroy(struct atopcase_softc *sc);
int atopcase_intr(struct atopcase_softc *);
void atopcase_intr_setup(device_t, device_t, hid_intr_t, void *,
struct hid_rdesc_info *);
void atopcase_intr_unsetup(device_t, device_t);
int atopcase_intr_start(device_t, device_t);
int atopcase_intr_stop(device_t, device_t);
void atopcase_intr_poll(device_t, device_t);
int atopcase_get_rdesc(device_t, device_t, void *, hid_size_t);
int atopcase_set_report(device_t, device_t, const void *, hid_size_t, uint8_t,
uint8_t);
int atopcase_backlight_update_status(device_t, struct backlight_props *);
int atopcase_backlight_get_status(device_t, struct backlight_props *);
int atopcase_backlight_get_info(device_t, struct backlight_info *);
#endif /* _ATOPCASE_VAR_H_ */

1
sys/dev/hid/hidbus.c
View File

@ -973,6 +973,7 @@ driver_t hidbus_driver = {
MODULE_DEPEND(hidbus, hid, 1, 1, 1);
MODULE_VERSION(hidbus, 1);
DRIVER_MODULE(hidbus, atopcase, hidbus_driver, 0, 0);
DRIVER_MODULE(hidbus, hvhid, hidbus_driver, 0, 0);
DRIVER_MODULE(hidbus, iichid, hidbus_driver, 0, 0);
DRIVER_MODULE(hidbus, usbhid, hidbus_driver, 0, 0);

5
sys/modules/spi/Makefile
View File

@ -2,7 +2,12 @@
SUBDIR = \
../spigen \
at45d \
${_atopcase} \
mx25l \
spibus \
.if ${MACHINE_CPUARCH} == "i386" || ${MACHINE_CPUARCH} == "amd64"
_atopcase=atopcase
.endif
.include <bsd.subdir.mk>

7
sys/modules/spi/atopcase/Makefile Normal file
View File

@ -0,0 +1,7 @@
.PATH: ${SRCTOP}/sys/dev/atopcase
KMOD= atopcase
SRCS= atopcase.c atopcase_acpi.c
SRCS+= acpi_if.h backlight_if.h bus_if.h device_if.h hid_if.h opt_acpi.h \
opt_hid.h opt_spi.h spibus_if.h usbdevs.h
.include <bsd.kmod.mk>