Skip to content

Commit 4e7be68

Browse files
author
Jiri Kosina
committed
Merge branch 'for-4.20/i2c-hid' into for-linus
- general cleanups of hid-i2c driver - SPIODEV device descriptor fixes
2 parents a600ffe + 9ee3e06 commit 4e7be68

File tree

13 files changed

+627
-117
lines changed

13 files changed

+627
-117
lines changed

‎drivers/hid/i2c-hid/Makefile

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -3,3 +3,6 @@
33
#
44

55
obj-$(CONFIG_I2C_HID) += i2c-hid.o
6+
7+
i2c-hid-objs = i2c-hid-core.o
8+
i2c-hid-$(CONFIG_DMI) += i2c-hid-dmi-quirks.o

‎drivers/hid/i2c-hid/i2c-hid.c renamed to ‎drivers/hid/i2c-hid/i2c-hid-core.c

Lines changed: 40 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -43,6 +43,7 @@
4343
#include <linux/platform_data/i2c-hid.h>
4444

4545
#include "../hid-ids.h"
46+
#include "i2c-hid.h"
4647

4748
/* quirks to control the device */
4849
#define I2C_HID_QUIRK_SET_PWR_WAKEUP_DEV BIT(0)
@@ -668,6 +669,7 @@ static int i2c_hid_parse(struct hid_device *hid)
668669
char *rdesc;
669670
int ret;
670671
int tries = 3;
672+
char *use_override;
671673

672674
i2c_hid_dbg(ihid, "entering %s\n", __func__);
673675

@@ -686,26 +688,37 @@ static int i2c_hid_parse(struct hid_device *hid)
686688
if (ret)
687689
return ret;
688690

689-
rdesc = kzalloc(rsize, GFP_KERNEL);
691+
use_override = i2c_hid_get_dmi_hid_report_desc_override(client->name,
692+
&rsize);
690693

691-
if (!rdesc) {
692-
dbg_hid("couldn't allocate rdesc memory\n");
693-
return -ENOMEM;
694-
}
695-
696-
i2c_hid_dbg(ihid, "asking HID report descriptor\n");
697-
698-
ret = i2c_hid_command(client, &hid_report_descr_cmd, rdesc, rsize);
699-
if (ret) {
700-
hid_err(hid, "reading report descriptor failed\n");
701-
kfree(rdesc);
702-
return -EIO;
694+
if (use_override) {
695+
rdesc = use_override;
696+
i2c_hid_dbg(ihid, "Using a HID report descriptor override\n");
697+
} else {
698+
rdesc = kzalloc(rsize, GFP_KERNEL);
699+
700+
if (!rdesc) {
701+
dbg_hid("couldn't allocate rdesc memory\n");
702+
return -ENOMEM;
703+
}
704+
705+
i2c_hid_dbg(ihid, "asking HID report descriptor\n");
706+
707+
ret = i2c_hid_command(client, &hid_report_descr_cmd,
708+
rdesc, rsize);
709+
if (ret) {
710+
hid_err(hid, "reading report descriptor failed\n");
711+
kfree(rdesc);
712+
return -EIO;
713+
}
703714
}
704715

705716
i2c_hid_dbg(ihid, "Report Descriptor: %*ph\n", rsize, rdesc);
706717

707718
ret = hid_parse_report(hid, rdesc, rsize);
708-
kfree(rdesc);
719+
if (!use_override)
720+
kfree(rdesc);
721+
709722
if (ret) {
710723
dbg_hid("parsing report descriptor failed\n");
711724
return ret;
@@ -832,12 +845,19 @@ static int i2c_hid_fetch_hid_descriptor(struct i2c_hid *ihid)
832845
int ret;
833846

834847
/* i2c hid fetch using a fixed descriptor size (30 bytes) */
835-
i2c_hid_dbg(ihid, "Fetching the HID descriptor\n");
836-
ret = i2c_hid_command(client, &hid_descr_cmd, ihid->hdesc_buffer,
837-
sizeof(struct i2c_hid_desc));
838-
if (ret) {
839-
dev_err(&client->dev, "hid_descr_cmd failed\n");
840-
return -ENODEV;
848+
if (i2c_hid_get_dmi_i2c_hid_desc_override(client->name)) {
849+
i2c_hid_dbg(ihid, "Using a HID descriptor override\n");
850+
ihid->hdesc =
851+
*i2c_hid_get_dmi_i2c_hid_desc_override(client->name);
852+
} else {
853+
i2c_hid_dbg(ihid, "Fetching the HID descriptor\n");
854+
ret = i2c_hid_command(client, &hid_descr_cmd,
855+
ihid->hdesc_buffer,
856+
sizeof(struct i2c_hid_desc));
857+
if (ret) {
858+
dev_err(&client->dev, "hid_descr_cmd failed\n");
859+
return -ENODEV;
860+
}
841861
}
842862

843863
/* Validate the length of HID descriptor, the 4 first bytes:

‎drivers/hid/i2c-hid/i2c-hid-dmi-quirks.c

Lines changed: 376 additions & 0 deletions
Large diffs are not rendered by default.

‎drivers/hid/i2c-hid/i2c-hid.h

Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
/* SPDX-License-Identifier: GPL-2.0+ */
2+
3+
#ifndef I2C_HID_H
4+
#define I2C_HID_H
5+
6+
7+
#ifdef CONFIG_DMI
8+
struct i2c_hid_desc *i2c_hid_get_dmi_i2c_hid_desc_override(uint8_t *i2c_name);
9+
char *i2c_hid_get_dmi_hid_report_desc_override(uint8_t *i2c_name,
10+
unsigned int *size);
11+
#else
12+
static inline struct i2c_hid_desc
13+
*i2c_hid_get_dmi_i2c_hid_desc_override(uint8_t *i2c_name)
14+
{ return NULL; }
15+
static inline char *i2c_hid_get_dmi_hid_report_desc_override(uint8_t *i2c_name,
16+
unsigned int *size)
17+
{ return NULL; }
18+
#endif
19+
20+
#endif

‎drivers/hid/intel-ish-hid/ipc/ipc.c

Lines changed: 14 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -280,14 +280,14 @@ static int write_ipc_from_queue(struct ishtp_device *dev)
280280
* if tx send list is empty - return 0;
281281
* may happen, as RX_COMPLETE handler doesn't check list emptiness.
282282
*/
283-
if (list_empty(&dev->wr_processing_list_head.link)) {
283+
if (list_empty(&dev->wr_processing_list)) {
284284
spin_unlock_irqrestore(&dev->wr_processing_spinlock, flags);
285285
out_ipc_locked = 0;
286286
return 0;
287287
}
288288

289-
ipc_link = list_entry(dev->wr_processing_list_head.link.next,
290-
struct wr_msg_ctl_info, link);
289+
ipc_link = list_first_entry(&dev->wr_processing_list,
290+
struct wr_msg_ctl_info, link);
291291
/* first 4 bytes of the data is the doorbell value (IPC header) */
292292
length = ipc_link->length - sizeof(uint32_t);
293293
doorbell_val = *(uint32_t *)ipc_link->inline_data;
@@ -338,7 +338,7 @@ static int write_ipc_from_queue(struct ishtp_device *dev)
338338
ipc_send_compl = ipc_link->ipc_send_compl;
339339
ipc_send_compl_prm = ipc_link->ipc_send_compl_prm;
340340
list_del_init(&ipc_link->link);
341-
list_add_tail(&ipc_link->link, &dev->wr_free_list_head.link);
341+
list_add(&ipc_link->link, &dev->wr_free_list);
342342
spin_unlock_irqrestore(&dev->wr_processing_spinlock, flags);
343343

344344
/*
@@ -372,26 +372,26 @@ static int write_ipc_to_queue(struct ishtp_device *dev,
372372
unsigned char *msg, int length)
373373
{
374374
struct wr_msg_ctl_info *ipc_link;
375-
unsigned long flags;
375+
unsigned long flags;
376376

377377
if (length > IPC_FULL_MSG_SIZE)
378378
return -EMSGSIZE;
379379

380380
spin_lock_irqsave(&dev->wr_processing_spinlock, flags);
381-
if (list_empty(&dev->wr_free_list_head.link)) {
381+
if (list_empty(&dev->wr_free_list)) {
382382
spin_unlock_irqrestore(&dev->wr_processing_spinlock, flags);
383383
return -ENOMEM;
384384
}
385-
ipc_link = list_entry(dev->wr_free_list_head.link.next,
386-
struct wr_msg_ctl_info, link);
385+
ipc_link = list_first_entry(&dev->wr_free_list,
386+
struct wr_msg_ctl_info, link);
387387
list_del_init(&ipc_link->link);
388388

389389
ipc_link->ipc_send_compl = ipc_send_compl;
390390
ipc_link->ipc_send_compl_prm = ipc_send_compl_prm;
391391
ipc_link->length = length;
392392
memcpy(ipc_link->inline_data, msg, length);
393393

394-
list_add_tail(&ipc_link->link, &dev->wr_processing_list_head.link);
394+
list_add_tail(&ipc_link->link, &dev->wr_processing_list);
395395
spin_unlock_irqrestore(&dev->wr_processing_spinlock, flags);
396396

397397
write_ipc_from_queue(dev);
@@ -487,17 +487,13 @@ static int ish_fw_reset_handler(struct ishtp_device *dev)
487487
{
488488
uint32_t reset_id;
489489
unsigned long flags;
490-
struct wr_msg_ctl_info *processing, *next;
491490

492491
/* Read reset ID */
493492
reset_id = ish_reg_read(dev, IPC_REG_ISH2HOST_MSG) & 0xFFFF;
494493

495494
/* Clear IPC output queue */
496495
spin_lock_irqsave(&dev->wr_processing_spinlock, flags);
497-
list_for_each_entry_safe(processing, next,
498-
&dev->wr_processing_list_head.link, link) {
499-
list_move_tail(&processing->link, &dev->wr_free_list_head.link);
500-
}
496+
list_splice_init(&dev->wr_processing_list, &dev->wr_free_list);
501497
spin_unlock_irqrestore(&dev->wr_processing_spinlock, flags);
502498

503499
/* ISHTP notification in IPC_RESET */
@@ -921,9 +917,9 @@ struct ishtp_device *ish_dev_init(struct pci_dev *pdev)
921917
spin_lock_init(&dev->out_ipc_spinlock);
922918

923919
/* Init IPC processing and free lists */
924-
INIT_LIST_HEAD(&dev->wr_processing_list_head.link);
925-
INIT_LIST_HEAD(&dev->wr_free_list_head.link);
926-
for (i = 0; i < IPC_TX_FIFO_SIZE; ++i) {
920+
INIT_LIST_HEAD(&dev->wr_processing_list);
921+
INIT_LIST_HEAD(&dev->wr_free_list);
922+
for (i = 0; i < IPC_TX_FIFO_SIZE; i++) {
927923
struct wr_msg_ctl_info *tx_buf;
928924

929925
tx_buf = devm_kzalloc(&pdev->dev,
@@ -939,7 +935,7 @@ struct ishtp_device *ish_dev_init(struct pci_dev *pdev)
939935
i);
940936
break;
941937
}
942-
list_add_tail(&tx_buf->link, &dev->wr_free_list_head.link);
938+
list_add_tail(&tx_buf->link, &dev->wr_free_list);
943939
}
944940

945941
dev->ops = &ish_hw_ops;

‎drivers/hid/intel-ish-hid/ipc/pci-ish.c

Lines changed: 24 additions & 51 deletions
Original file line numberDiff line numberDiff line change
@@ -115,84 +115,64 @@ static const struct pci_device_id ish_invalid_pci_ids[] = {
115115
*/
116116
static int ish_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
117117
{
118-
struct ishtp_device *dev;
118+
int ret;
119119
struct ish_hw *hw;
120-
int ret;
120+
struct ishtp_device *ishtp;
121+
struct device *dev = &pdev->dev;
121122

122123
/* Check for invalid platforms for ISH support */
123124
if (pci_dev_present(ish_invalid_pci_ids))
124125
return -ENODEV;
125126

126127
/* enable pci dev */
127-
ret = pci_enable_device(pdev);
128+
ret = pcim_enable_device(pdev);
128129
if (ret) {
129-
dev_err(&pdev->dev, "ISH: Failed to enable PCI device\n");
130+
dev_err(dev, "ISH: Failed to enable PCI device\n");
130131
return ret;
131132
}
132133

133134
/* set PCI host mastering */
134135
pci_set_master(pdev);
135136

136137
/* pci request regions for ISH driver */
137-
ret = pci_request_regions(pdev, KBUILD_MODNAME);
138+
ret = pcim_iomap_regions(pdev, 1 << 0, KBUILD_MODNAME);
138139
if (ret) {
139-
dev_err(&pdev->dev, "ISH: Failed to get PCI regions\n");
140-
goto disable_device;
140+
dev_err(dev, "ISH: Failed to get PCI regions\n");
141+
return ret;
141142
}
142143

143144
/* allocates and initializes the ISH dev structure */
144-
dev = ish_dev_init(pdev);
145-
if (!dev) {
145+
ishtp = ish_dev_init(pdev);
146+
if (!ishtp) {
146147
ret = -ENOMEM;
147-
goto release_regions;
148+
return ret;
148149
}
149-
hw = to_ish_hw(dev);
150-
dev->print_log = ish_event_tracer;
150+
hw = to_ish_hw(ishtp);
151+
ishtp->print_log = ish_event_tracer;
151152

152153
/* mapping IO device memory */
153-
hw->mem_addr = pci_iomap(pdev, 0, 0);
154-
if (!hw->mem_addr) {
155-
dev_err(&pdev->dev, "ISH: mapping I/O range failure\n");
156-
ret = -ENOMEM;
157-
goto free_device;
158-
}
159-
160-
dev->pdev = pdev;
161-
154+
hw->mem_addr = pcim_iomap_table(pdev)[0];
155+
ishtp->pdev = pdev;
162156
pdev->dev_flags |= PCI_DEV_FLAGS_NO_D3;
163157

164158
/* request and enable interrupt */
165-
ret = request_irq(pdev->irq, ish_irq_handler, IRQF_SHARED,
166-
KBUILD_MODNAME, dev);
159+
ret = devm_request_irq(dev, pdev->irq, ish_irq_handler,
160+
IRQF_SHARED, KBUILD_MODNAME, ishtp);
167161
if (ret) {
168-
dev_err(&pdev->dev, "ISH: request IRQ failure (%d)\n",
169-
pdev->irq);
170-
goto free_device;
162+
dev_err(dev, "ISH: request IRQ %d failed\n", pdev->irq);
163+
return ret;
171164
}
172165

173-
dev_set_drvdata(dev->devc, dev);
166+
dev_set_drvdata(ishtp->devc, ishtp);
174167

175-
init_waitqueue_head(&dev->suspend_wait);
176-
init_waitqueue_head(&dev->resume_wait);
168+
init_waitqueue_head(&ishtp->suspend_wait);
169+
init_waitqueue_head(&ishtp->resume_wait);
177170

178-
ret = ish_init(dev);
171+
ret = ish_init(ishtp);
179172
if (ret)
180-
goto free_irq;
173+
return ret;
181174

182175
return 0;
183-
184-
free_irq:
185-
free_irq(pdev->irq, dev);
186-
free_device:
187-
pci_iounmap(pdev, hw->mem_addr);
188-
release_regions:
189-
pci_release_regions(pdev);
190-
disable_device:
191-
pci_clear_master(pdev);
192-
pci_disable_device(pdev);
193-
dev_err(&pdev->dev, "ISH: PCI driver initialization failed.\n");
194-
195-
return ret;
196176
}
197177

198178
/**
@@ -204,16 +184,9 @@ static int ish_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
204184
static void ish_remove(struct pci_dev *pdev)
205185
{
206186
struct ishtp_device *ishtp_dev = pci_get_drvdata(pdev);
207-
struct ish_hw *hw = to_ish_hw(ishtp_dev);
208187

209188
ishtp_bus_remove_all_clients(ishtp_dev, false);
210189
ish_device_disable(ishtp_dev);
211-
212-
free_irq(pdev->irq, ishtp_dev);
213-
pci_iounmap(pdev, hw->mem_addr);
214-
pci_release_regions(pdev);
215-
pci_clear_master(pdev);
216-
pci_disable_device(pdev);
217190
}
218191

219192
static struct device __maybe_unused *ish_resume_device;

0 commit comments

Comments
 (0)