mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/chenhuacai/linux-loongson
synced 2025-09-03 17:51:23 +00:00
246570cd35
As the HID wDescriptorLength is explicitly marked as little endian it
should be converted to host endian before being used.
Fixes: ac558015df ("ASoC: SDCA: add a HID device for HIDE entity")
Reported-by: kernel test robot <lkp@intel.com>
Closes: https://lore.kernel.org/oe-kbuild-all/202507221024.M18hWD6q-lkp@intel.com/
Signed-off-by: Charles Keepax <ckeepax@opensource.cirrus.com>
Link: https://patch.msgid.link/20250722114705.2816910-1-ckeepax@opensource.cirrus.com
Signed-off-by: Mark Brown <broonie@kernel.org>
128 lines
2.7 KiB
C
128 lines
2.7 KiB
C
// SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
|
|
|
|
/*
|
|
* The MIPI SDCA specification is available for public downloads at
|
|
* https://www.mipi.org/mipi-sdca-v1-0-download
|
|
*/
|
|
|
|
#include <linux/acpi.h>
|
|
#include <linux/byteorder/generic.h>
|
|
#include <linux/cleanup.h>
|
|
#include <linux/device.h>
|
|
#include <linux/dev_printk.h>
|
|
#include <linux/module.h>
|
|
#include <linux/property.h>
|
|
#include <linux/soundwire/sdw.h>
|
|
#include <linux/types.h>
|
|
#include <sound/sdca.h>
|
|
#include <sound/sdca_function.h>
|
|
#include <sound/sdca_hid.h>
|
|
|
|
static int sdwhid_parse(struct hid_device *hid)
|
|
{
|
|
struct sdca_entity *entity = hid->driver_data;
|
|
unsigned int rsize;
|
|
int ret;
|
|
|
|
rsize = le16_to_cpu(entity->hide.hid_desc.rpt_desc.wDescriptorLength);
|
|
|
|
if (!rsize || rsize > HID_MAX_DESCRIPTOR_SIZE) {
|
|
dev_err(&hid->dev, "invalid size of report descriptor (%u)\n", rsize);
|
|
return -EINVAL;
|
|
}
|
|
|
|
ret = hid_parse_report(hid, entity->hide.hid_report_desc, rsize);
|
|
|
|
if (!ret)
|
|
return 0;
|
|
|
|
dev_err(&hid->dev, "parsing report descriptor failed\n");
|
|
return ret;
|
|
}
|
|
|
|
static int sdwhid_start(struct hid_device *hid)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static void sdwhid_stop(struct hid_device *hid)
|
|
{
|
|
}
|
|
|
|
static int sdwhid_raw_request(struct hid_device *hid, unsigned char reportnum,
|
|
__u8 *buf, size_t len, unsigned char rtype, int reqtype)
|
|
{
|
|
switch (reqtype) {
|
|
case HID_REQ_GET_REPORT:
|
|
/* not implemented yet */
|
|
return 0;
|
|
case HID_REQ_SET_REPORT:
|
|
/* not implemented yet */
|
|
return 0;
|
|
default:
|
|
return -EIO;
|
|
}
|
|
}
|
|
|
|
static int sdwhid_open(struct hid_device *hid)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static void sdwhid_close(struct hid_device *hid)
|
|
{
|
|
}
|
|
|
|
static const struct hid_ll_driver sdw_hid_driver = {
|
|
.parse = sdwhid_parse,
|
|
.start = sdwhid_start,
|
|
.stop = sdwhid_stop,
|
|
.open = sdwhid_open,
|
|
.close = sdwhid_close,
|
|
.raw_request = sdwhid_raw_request,
|
|
};
|
|
|
|
int sdca_add_hid_device(struct device *dev, struct sdca_entity *entity)
|
|
{
|
|
struct sdw_bus *bus;
|
|
struct hid_device *hid;
|
|
struct sdw_slave *slave = dev_to_sdw_dev(dev);
|
|
int ret;
|
|
|
|
bus = slave->bus;
|
|
|
|
hid = hid_allocate_device();
|
|
if (IS_ERR(hid))
|
|
return PTR_ERR(hid);
|
|
|
|
hid->ll_driver = &sdw_hid_driver;
|
|
|
|
hid->dev.parent = dev;
|
|
hid->bus = BUS_SDW;
|
|
hid->version = le16_to_cpu(entity->hide.hid_desc.bcdHID);
|
|
|
|
snprintf(hid->name, sizeof(hid->name),
|
|
"HID sdw:%01x:%01x:%04x:%04x:%02x",
|
|
bus->controller_id, bus->link_id, slave->id.mfg_id,
|
|
slave->id.part_id, slave->id.class_id);
|
|
|
|
snprintf(hid->phys, sizeof(hid->phys), "%s", dev->bus->name);
|
|
|
|
hid->driver_data = entity;
|
|
|
|
ret = hid_add_device(hid);
|
|
if (ret && ret != -ENODEV) {
|
|
dev_err(dev, "can't add hid device: %d\n", ret);
|
|
hid_destroy_device(hid);
|
|
return ret;
|
|
}
|
|
|
|
entity->hide.hid = hid;
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_NS(sdca_add_hid_device, "SND_SOC_SDCA");
|
|
|
|
MODULE_LICENSE("Dual BSD/GPL");
|
|
MODULE_DESCRIPTION("SDCA HID library");
|