Skip to content

Commit

Permalink
Merge branch 'for-6.8/intel-ish' into for-linus
Browse files Browse the repository at this point in the history 
- power management improvement for EHL OOB wakeup in intel-ish (Kai-Heng Feng)
- generic intel-ish code cleanups (Even Xu)
  • Loading branch information
Jiri Kosina committed Jan 8, 2024
2 parents ff18ab5 + 0e63dd2 commit f60c352
Show file tree
Hide file tree
Showing 6 changed files with 232 additions and 220 deletions.
67 changes: 15 additions & 52 deletions drivers/hid/intel-ish-hid/ipc/pci-ish.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -119,50 +119,6 @@ static inline bool ish_should_leave_d0i3(struct pci_dev *pdev)
return !pm_resume_via_firmware() || pdev->device == CHV_DEVICE_ID;
}

static int enable_gpe(struct device *dev)
{
#ifdef CONFIG_ACPI
acpi_status acpi_sts;
struct acpi_device *adev;
struct acpi_device_wakeup *wakeup;

adev = ACPI_COMPANION(dev);
if (!adev) {
dev_err(dev, "get acpi handle failed\n");
return -ENODEV;
}
wakeup = &adev->wakeup;

/*
* Call acpi_disable_gpe(), so that reference count
* gpe_event_info->runtime_count doesn't overflow.
* When gpe_event_info->runtime_count = 0, the call
* to acpi_disable_gpe() simply return.
*/
acpi_disable_gpe(wakeup->gpe_device, wakeup->gpe_number);

acpi_sts = acpi_enable_gpe(wakeup->gpe_device, wakeup->gpe_number);
if (ACPI_FAILURE(acpi_sts)) {
dev_err(dev, "enable ose_gpe failed\n");
return -EIO;
}

return 0;
#else
return -ENODEV;
#endif
}

static void enable_pme_wake(struct pci_dev *pdev)
{
if ((pci_pme_capable(pdev, PCI_D0) ||
pci_pme_capable(pdev, PCI_D3hot) ||
pci_pme_capable(pdev, PCI_D3cold)) && !enable_gpe(&pdev->dev)) {
pci_pme_active(pdev, true);
dev_dbg(&pdev->dev, "ish ipc driver pme wake enabled\n");
}
}

/**
* ish_probe() - PCI driver probe callback
* @pdev: pci device
Expand Down Expand Up @@ -233,7 +189,7 @@ static int ish_probe(struct pci_dev *pdev, const struct pci_device_id *ent)

/* Enable PME for EHL */
if (pdev->device == EHL_Ax_DEVICE_ID)
enable_pme_wake(pdev);
device_init_wakeup(dev, true);

ret = ish_init(ishtp);
if (ret)
Expand All @@ -256,6 +212,19 @@ static void ish_remove(struct pci_dev *pdev)
ish_device_disable(ishtp_dev);
}


/**
* ish_shutdown() - PCI driver shutdown callback
* @pdev: pci device
*
* This function sets up wakeup for S5
*/
static void ish_shutdown(struct pci_dev *pdev)
{
if (pdev->device == EHL_Ax_DEVICE_ID)
pci_prepare_to_sleep(pdev);
}

static struct device __maybe_unused *ish_resume_device;

/* 50ms to get resume response */
Expand Down Expand Up @@ -378,13 +347,6 @@ static int __maybe_unused ish_resume(struct device *device)
struct pci_dev *pdev = to_pci_dev(device);
struct ishtp_device *dev = pci_get_drvdata(pdev);

/* add this to finish power flow for EHL */
if (dev->pdev->device == EHL_Ax_DEVICE_ID) {
pci_set_power_state(pdev, PCI_D0);
enable_pme_wake(pdev);
dev_dbg(dev->devc, "set power state to D0 for ehl\n");
}

ish_resume_device = device;
dev->resume_flag = 1;

Expand All @@ -400,6 +362,7 @@ static struct pci_driver ish_driver = {
.id_table = ish_pci_tbl,
.probe = ish_probe,
.remove = ish_remove,
.shutdown = ish_shutdown,
.driver.pm = &ish_pm_ops,
};

Expand Down
60 changes: 12 additions & 48 deletions drivers/hid/intel-ish-hid/ishtp-fw-loader.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -840,43 +840,22 @@ static void load_fw_from_host_handler(struct work_struct *work)
*
* Return: 0 for success, negative error code for failure
*/
static int loader_init(struct ishtp_cl *loader_ishtp_cl, int reset)
static int loader_init(struct ishtp_cl *loader_ishtp_cl, bool reset)
{
int rv;
struct ishtp_fw_client *fw_client;
struct ishtp_cl_data *client_data =
ishtp_get_client_data(loader_ishtp_cl);

dev_dbg(cl_data_to_dev(client_data), "reset flag: %d\n", reset);

rv = ishtp_cl_link(loader_ishtp_cl);
if (rv < 0) {
dev_err(cl_data_to_dev(client_data), "ishtp_cl_link failed\n");
return rv;
}

/* Connect to firmware client */
ishtp_set_tx_ring_size(loader_ishtp_cl, LOADER_CL_TX_RING_SIZE);
ishtp_set_rx_ring_size(loader_ishtp_cl, LOADER_CL_RX_RING_SIZE);

fw_client =
ishtp_fw_cl_get_client(ishtp_get_ishtp_device(loader_ishtp_cl),
&loader_ishtp_id_table[0].guid);
if (!fw_client) {
dev_err(cl_data_to_dev(client_data),
"ISH client uuid not found\n");
rv = -ENOENT;
goto err_cl_unlink;
}

ishtp_cl_set_fw_client_id(loader_ishtp_cl,
ishtp_get_fw_client_id(fw_client));
ishtp_set_connection_state(loader_ishtp_cl, ISHTP_CL_CONNECTING);

rv = ishtp_cl_connect(loader_ishtp_cl);
rv = ishtp_cl_establish_connection(loader_ishtp_cl,
&loader_ishtp_id_table[0].guid,
LOADER_CL_TX_RING_SIZE,
LOADER_CL_RX_RING_SIZE,
reset);
if (rv < 0) {
dev_err(cl_data_to_dev(client_data), "Client connect fail\n");
goto err_cl_unlink;
goto err_cl_disconnect;
}

dev_dbg(cl_data_to_dev(client_data), "Client connected\n");
Expand All @@ -885,17 +864,14 @@ static int loader_init(struct ishtp_cl *loader_ishtp_cl, int reset)

return 0;

err_cl_unlink:
ishtp_cl_unlink(loader_ishtp_cl);
err_cl_disconnect:
ishtp_cl_destroy_connection(loader_ishtp_cl, reset);
return rv;
}

static void loader_deinit(struct ishtp_cl *loader_ishtp_cl)
{
ishtp_set_connection_state(loader_ishtp_cl, ISHTP_CL_DISCONNECTING);
ishtp_cl_disconnect(loader_ishtp_cl);
ishtp_cl_unlink(loader_ishtp_cl);
ishtp_cl_flush_queues(loader_ishtp_cl);
ishtp_cl_destroy_connection(loader_ishtp_cl, false);

/* Disband and free all Tx and Rx client-level rings */
ishtp_cl_free(loader_ishtp_cl);
Expand All @@ -914,19 +890,7 @@ static void reset_handler(struct work_struct *work)
loader_ishtp_cl = client_data->loader_ishtp_cl;
cl_device = client_data->cl_device;

/* Unlink, flush queues & start again */
ishtp_cl_unlink(loader_ishtp_cl);
ishtp_cl_flush_queues(loader_ishtp_cl);
ishtp_cl_free(loader_ishtp_cl);

loader_ishtp_cl = ishtp_cl_allocate(cl_device);
if (!loader_ishtp_cl)
return;

ishtp_set_drvdata(cl_device, loader_ishtp_cl);
ishtp_set_client_data(loader_ishtp_cl, client_data);
client_data->loader_ishtp_cl = loader_ishtp_cl;
client_data->cl_device = cl_device;
ishtp_cl_destroy_connection(loader_ishtp_cl, true);

rv = loader_init(loader_ishtp_cl, 1);
if (rv < 0) {
Expand Down Expand Up @@ -974,7 +938,7 @@ static int loader_ishtp_cl_probe(struct ishtp_cl_device *cl_device)
INIT_WORK(&client_data->work_fw_load,
load_fw_from_host_handler);

rv = loader_init(loader_ishtp_cl, 0);
rv = loader_init(loader_ishtp_cl, false);
if (rv < 0) {
ishtp_cl_free(loader_ishtp_cl);
return rv;
Expand Down
63 changes: 13 additions & 50 deletions drivers/hid/intel-ish-hid/ishtp-hid-client.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -639,47 +639,26 @@ static int ishtp_get_report_descriptor(struct ishtp_cl *hid_ishtp_cl,
*
* Return: 0 on success, non zero on error
*/
static int hid_ishtp_cl_init(struct ishtp_cl *hid_ishtp_cl, int reset)
static int hid_ishtp_cl_init(struct ishtp_cl *hid_ishtp_cl, bool reset)
{
struct ishtp_device *dev;
struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
struct ishtp_fw_client *fw_client;
int i;
int rv;

dev_dbg(cl_data_to_dev(client_data), "%s\n", __func__);
hid_ishtp_trace(client_data, "%s reset flag: %d\n", __func__, reset);

rv = ishtp_cl_link(hid_ishtp_cl);
if (rv) {
dev_err(cl_data_to_dev(client_data),
"ishtp_cl_link failed\n");
return -ENOMEM;
}

client_data->init_done = 0;

dev = ishtp_get_ishtp_device(hid_ishtp_cl);

/* Connect to FW client */
ishtp_set_tx_ring_size(hid_ishtp_cl, HID_CL_TX_RING_SIZE);
ishtp_set_rx_ring_size(hid_ishtp_cl, HID_CL_RX_RING_SIZE);

fw_client = ishtp_fw_cl_get_client(dev, &hid_ishtp_id_table[0].guid);
if (!fw_client) {
dev_err(cl_data_to_dev(client_data),
"ish client uuid not found\n");
return -ENOENT;
}
ishtp_cl_set_fw_client_id(hid_ishtp_cl,
ishtp_get_fw_client_id(fw_client));
ishtp_set_connection_state(hid_ishtp_cl, ISHTP_CL_CONNECTING);

rv = ishtp_cl_connect(hid_ishtp_cl);
rv = ishtp_cl_establish_connection(hid_ishtp_cl,
&hid_ishtp_id_table[0].guid,
HID_CL_TX_RING_SIZE,
HID_CL_RX_RING_SIZE,
reset);
if (rv) {
dev_err(cl_data_to_dev(client_data),
"client connect fail\n");
goto err_cl_unlink;
goto err_cl_disconnect;
}

hid_ishtp_trace(client_data, "%s client connected\n", __func__);
Expand Down Expand Up @@ -723,10 +702,7 @@ static int hid_ishtp_cl_init(struct ishtp_cl *hid_ishtp_cl, int reset)
return 0;

err_cl_disconnect:
ishtp_set_connection_state(hid_ishtp_cl, ISHTP_CL_DISCONNECTING);
ishtp_cl_disconnect(hid_ishtp_cl);
err_cl_unlink:
ishtp_cl_unlink(hid_ishtp_cl);
ishtp_cl_destroy_connection(hid_ishtp_cl, reset);
return rv;
}

Expand All @@ -738,8 +714,7 @@ static int hid_ishtp_cl_init(struct ishtp_cl *hid_ishtp_cl, int reset)
*/
static void hid_ishtp_cl_deinit(struct ishtp_cl *hid_ishtp_cl)
{
ishtp_cl_unlink(hid_ishtp_cl);
ishtp_cl_flush_queues(hid_ishtp_cl);
ishtp_cl_destroy_connection(hid_ishtp_cl, false);

/* disband and free all Tx and Rx client-level rings */
ishtp_cl_free(hid_ishtp_cl);
Expand All @@ -749,33 +724,23 @@ static void hid_ishtp_cl_reset_handler(struct work_struct *work)
{
struct ishtp_cl_data *client_data;
struct ishtp_cl *hid_ishtp_cl;
struct ishtp_cl_device *cl_device;
int retry;
int rv;

client_data = container_of(work, struct ishtp_cl_data, work);

hid_ishtp_cl = client_data->hid_ishtp_cl;
cl_device = client_data->cl_device;

hid_ishtp_trace(client_data, "%s hid_ishtp_cl %p\n", __func__,
hid_ishtp_cl);
dev_dbg(ishtp_device(client_data->cl_device), "%s\n", __func__);

hid_ishtp_cl_deinit(hid_ishtp_cl);

hid_ishtp_cl = ishtp_cl_allocate(cl_device);
if (!hid_ishtp_cl)
return;

ishtp_set_drvdata(cl_device, hid_ishtp_cl);
ishtp_set_client_data(hid_ishtp_cl, client_data);
client_data->hid_ishtp_cl = hid_ishtp_cl;
ishtp_cl_destroy_connection(hid_ishtp_cl, true);

client_data->num_hid_devices = 0;

for (retry = 0; retry < 3; ++retry) {
rv = hid_ishtp_cl_init(hid_ishtp_cl, 1);
rv = hid_ishtp_cl_init(hid_ishtp_cl, true);
if (!rv)
break;
dev_err(cl_data_to_dev(client_data), "Retry reset init\n");
Expand Down Expand Up @@ -841,7 +806,7 @@ static int hid_ishtp_cl_probe(struct ishtp_cl_device *cl_device)

ishtp_hid_print_trace = ishtp_trace_callback(cl_device);

rv = hid_ishtp_cl_init(hid_ishtp_cl, 0);
rv = hid_ishtp_cl_init(hid_ishtp_cl, false);
if (rv) {
ishtp_cl_free(hid_ishtp_cl);
return rv;
Expand All @@ -868,11 +833,9 @@ static void hid_ishtp_cl_remove(struct ishtp_cl_device *cl_device)
hid_ishtp_cl);

dev_dbg(ishtp_device(cl_device), "%s\n", __func__);
ishtp_set_connection_state(hid_ishtp_cl, ISHTP_CL_DISCONNECTING);
ishtp_cl_disconnect(hid_ishtp_cl);
hid_ishtp_cl_deinit(hid_ishtp_cl);
ishtp_put_device(cl_device);
ishtp_hid_remove(client_data);
hid_ishtp_cl_deinit(hid_ishtp_cl);

hid_ishtp_cl = NULL;

Expand Down
Loading

0 comments on commit f60c352

Please sign in to comment.