tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge tag 'for-linus-2024060801' of git://git.kernel.org/pub/scm/linux/kernel/git/hid/hid

Pull HID fixes from Benjamin Tissoires:

- fix potential read out of bounds in hid-asus (Andrew Ballance)

- fix endian-conversion on little endian systems in intel-ish-hid (Arnd
Bergmann)

- A couple of new input event codes (Aseda Aboagye)

- errors handling fixes in hid-nvidia-shield (Chen Ni), hid-nintendo
(Christophe JAILLET), hid-logitech-dj (José Expósito)

- current leakage fix while the device is in suspend on a i2c-hid
laptop (Johan Hovold)

- other assorted smaller fixes and device ID / quirk entry additions

* tag 'for-linus-2024060801' of git://git.kernel.org/pub/scm/linux/kernel/git/hid/hid:
HID: Ignore battery for ELAN touchscreens 2F2C and 4116
HID: i2c-hid: elan: fix reset suspend current leakage
dt-bindings: HID: i2c-hid: elan: add 'no-reset-on-power-off' property
dt-bindings: HID: i2c-hid: elan: add Elan eKTH5015M
dt-bindings: HID: i2c-hid: add dedicated Ilitek ILI2901 schema
input: Add support for "Do Not Disturb"
input: Add event code for accessibility key
hid: asus: asus_report_fixup: fix potential read out of bounds
HID: logitech-hidpp: add missing MODULE_DESCRIPTION() macro
HID: intel-ish-hid: fix endian-conversion
HID: nintendo: Fix an error handling path in nintendo_hid_probe()
HID: logitech-dj: Fix memory leak in logi_dj_recv_switch_to_dj_mode()
HID: core: remove unnecessary WARN_ON() in implement()
HID: nvidia-shield: Add missing check for input_ff_create_memless
HID: intel-ish-hid: Fix build error for COMPILE_TEST

Linus Torvalds 061d1af7 329f70c5

+221 -72
+14 -5
Documentation/devicetree/bindings/input/elan,ekth6915.yaml
··· 18 18 19 19 properties: 20 20 compatible: 21 - enum: 22 - - elan,ekth6915 23 - - ilitek,ili2901 21 + oneOf: 22 + - items: 23 + - enum: 24 + - elan,ekth5015m 25 + - const: elan,ekth6915 26 + - const: elan,ekth6915 24 27 25 28 reg: 26 29 const: 0x10 ··· 35 32 36 33 reset-gpios: 37 34 description: Reset GPIO; not all touchscreens using eKTH6915 hook this up. 35 + 36 + no-reset-on-power-off: 37 + type: boolean 38 + description: 39 + Reset line is wired so that it can (and should) be left deasserted when 40 + the power supply is off. 38 41 39 42 vcc33-supply: 40 43 description: The 3.3V supply to the touchscreen. ··· 67 58 #address-cells = <1>; 68 59 #size-cells = <0>; 69 60 70 - ap_ts: touchscreen@10 { 71 - compatible = "elan,ekth6915"; 61 + touchscreen@10 { 62 + compatible = "elan,ekth5015m", "elan,ekth6915"; 72 63 reg = <0x10>; 73 64 74 65 interrupt-parent = <&tlmm>;
+66
Documentation/devicetree/bindings/input/ilitek,ili2901.yaml
··· 1 + # SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) 2 + %YAML 1.2 3 + --- 4 + $id: http://devicetree.org/schemas/input/ilitek,ili2901.yaml# 5 + $schema: http://devicetree.org/meta-schemas/core.yaml# 6 + 7 + title: Ilitek ILI2901 touchscreen controller 8 + 9 + maintainers: 10 + - Jiri Kosina <jkosina@suse.com> 11 + 12 + description: 13 + Supports the Ilitek ILI2901 touchscreen controller. 14 + This touchscreen controller uses the i2c-hid protocol with a reset GPIO. 15 + 16 + allOf: 17 + - $ref: /schemas/input/touchscreen/touchscreen.yaml# 18 + 19 + properties: 20 + compatible: 21 + enum: 22 + - ilitek,ili2901 23 + 24 + reg: 25 + maxItems: 1 26 + 27 + interrupts: 28 + maxItems: 1 29 + 30 + panel: true 31 + 32 + reset-gpios: 33 + maxItems: 1 34 + 35 + vcc33-supply: true 36 + 37 + vccio-supply: true 38 + 39 + required: 40 + - compatible 41 + - reg 42 + - interrupts 43 + - vcc33-supply 44 + 45 + additionalProperties: false 46 + 47 + examples: 48 + - | 49 + #include <dt-bindings/gpio/gpio.h> 50 + #include <dt-bindings/interrupt-controller/irq.h> 51 + 52 + i2c { 53 + #address-cells = <1>; 54 + #size-cells = <0>; 55 + 56 + touchscreen@41 { 57 + compatible = "ilitek,ili2901"; 58 + reg = <0x41>; 59 + 60 + interrupt-parent = <&tlmm>; 61 + interrupts = <9 IRQ_TYPE_LEVEL_LOW>; 62 + 63 + reset-gpios = <&tlmm 8 GPIO_ACTIVE_LOW>; 64 + vcc33-supply = <&pp3300_ts>; 65 + }; 66 + };
+2 -2
drivers/hid/hid-asus.c
··· 1204 1204 } 1205 1205 1206 1206 /* match many more n-key devices */ 1207 - if (drvdata->quirks & QUIRK_ROG_NKEY_KEYBOARD) { 1208 - for (int i = 0; i < *rsize + 1; i++) { 1207 + if (drvdata->quirks & QUIRK_ROG_NKEY_KEYBOARD && *rsize > 15) { 1208 + for (int i = 0; i < *rsize - 15; i++) { 1209 1209 /* offset to the count from 0x5a report part always 14 */ 1210 1210 if (rdesc[i] == 0x85 && rdesc[i + 1] == 0x5a && 1211 1211 rdesc[i + 14] == 0x95 && rdesc[i + 15] == 0x05) {
-1
drivers/hid/hid-core.c
··· 1448 1448 hid_warn(hid, 1449 1449 "%s() called with too large value %d (n: %d)! (%s)\n", 1450 1450 __func__, value, n, current->comm); 1451 - WARN_ON(1); 1452 1451 value &= m; 1453 1452 } 1454 1453 }
+2
drivers/hid/hid-debug.c
··· 3366 3366 [KEY_CAMERA_ACCESS_ENABLE] = "CameraAccessEnable", 3367 3367 [KEY_CAMERA_ACCESS_DISABLE] = "CameraAccessDisable", 3368 3368 [KEY_CAMERA_ACCESS_TOGGLE] = "CameraAccessToggle", 3369 + [KEY_ACCESSIBILITY] = "Accessibility", 3370 + [KEY_DO_NOT_DISTURB] = "DoNotDisturb", 3369 3371 [KEY_DICTATE] = "Dictate", 3370 3372 [KEY_MICMUTE] = "MicrophoneMute", 3371 3373 [KEY_BRIGHTNESS_MIN] = "BrightnessMin",
+2
drivers/hid/hid-ids.h
··· 423 423 #define I2C_DEVICE_ID_HP_SPECTRE_X360_13_AW0020NG 0x29DF 424 424 #define I2C_DEVICE_ID_ASUS_TP420IA_TOUCHSCREEN 0x2BC8 425 425 #define I2C_DEVICE_ID_ASUS_GV301RA_TOUCHSCREEN 0x2C82 426 + #define I2C_DEVICE_ID_ASUS_UX3402_TOUCHSCREEN 0x2F2C 427 + #define I2C_DEVICE_ID_ASUS_UX6404_TOUCHSCREEN 0x4116 426 428 #define USB_DEVICE_ID_ASUS_UX550VE_TOUCHSCREEN 0x2544 427 429 #define USB_DEVICE_ID_ASUS_UX550_TOUCHSCREEN 0x2706 428 430 #define I2C_DEVICE_ID_SURFACE_GO_TOUCHSCREEN 0x261A
+13
drivers/hid/hid-input.c
··· 377 377 HID_BATTERY_QUIRK_IGNORE }, 378 378 { HID_I2C_DEVICE(USB_VENDOR_ID_ELAN, I2C_DEVICE_ID_ASUS_GV301RA_TOUCHSCREEN), 379 379 HID_BATTERY_QUIRK_IGNORE }, 380 + { HID_I2C_DEVICE(USB_VENDOR_ID_ELAN, I2C_DEVICE_ID_ASUS_UX3402_TOUCHSCREEN), 381 + HID_BATTERY_QUIRK_IGNORE }, 382 + { HID_I2C_DEVICE(USB_VENDOR_ID_ELAN, I2C_DEVICE_ID_ASUS_UX6404_TOUCHSCREEN), 383 + HID_BATTERY_QUIRK_IGNORE }, 380 384 { HID_USB_DEVICE(USB_VENDOR_ID_ELAN, USB_DEVICE_ID_ASUS_UX550_TOUCHSCREEN), 381 385 HID_BATTERY_QUIRK_IGNORE }, 382 386 { HID_USB_DEVICE(USB_VENDOR_ID_ELAN, USB_DEVICE_ID_ASUS_UX550VE_TOUCHSCREEN), ··· 837 833 break; 838 834 } 839 835 836 + if ((usage->hid & 0xf0) == 0x90) { /* SystemControl*/ 837 + switch (usage->hid & 0xf) { 838 + case 0xb: map_key_clear(KEY_DO_NOT_DISTURB); break; 839 + default: goto ignore; 840 + } 841 + break; 842 + } 843 + 840 844 if ((usage->hid & 0xf0) == 0xa0) { /* SystemControl */ 841 845 switch (usage->hid & 0xf) { 842 846 case 0x9: map_key_clear(KEY_MICMUTE); break; 847 + case 0xa: map_key_clear(KEY_ACCESSIBILITY); break; 843 848 default: goto ignore; 844 849 } 845 850 break;
+3 -1
drivers/hid/hid-logitech-dj.c
··· 1284 1284 */ 1285 1285 msleep(50); 1286 1286 1287 - if (retval) 1287 + if (retval) { 1288 + kfree(dj_report); 1288 1289 return retval; 1290 + } 1289 1291 } 1290 1292 1291 1293 /*
+1
drivers/hid/hid-logitech-hidpp.c
··· 27 27 #include "usbhid/usbhid.h" 28 28 #include "hid-ids.h" 29 29 30 + MODULE_DESCRIPTION("Support for Logitech devices relying on the HID++ specification"); 30 31 MODULE_LICENSE("GPL"); 31 32 MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>"); 32 33 MODULE_AUTHOR("Nestor Lopez Casado <nlopezcasad@logitech.com>");
+4 -2
drivers/hid/hid-nintendo.c
··· 2725 2725 ret = joycon_power_supply_create(ctlr); 2726 2726 if (ret) { 2727 2727 hid_err(hdev, "Failed to create power_supply; ret=%d\n", ret); 2728 - goto err_close; 2728 + goto err_ida; 2729 2729 } 2730 2730 2731 2731 ret = joycon_input_create(ctlr); 2732 2732 if (ret) { 2733 2733 hid_err(hdev, "Failed to create input device; ret=%d\n", ret); 2734 - goto err_close; 2734 + goto err_ida; 2735 2735 } 2736 2736 2737 2737 ctlr->ctlr_state = JOYCON_CTLR_STATE_READ; ··· 2739 2739 hid_dbg(hdev, "probe - success\n"); 2740 2740 return 0; 2741 2741 2742 + err_ida: 2743 + ida_free(&nintendo_player_id_allocator, ctlr->player_id); 2742 2744 err_close: 2743 2745 hid_hw_close(hdev); 2744 2746 err_stop:
+3 -1
drivers/hid/hid-nvidia-shield.c
··· 283 283 return haptics; 284 284 285 285 input_set_capability(haptics, EV_FF, FF_RUMBLE); 286 - input_ff_create_memless(haptics, NULL, play_effect); 286 + ret = input_ff_create_memless(haptics, NULL, play_effect); 287 + if (ret) 288 + goto err; 287 289 288 290 ret = input_register_device(haptics); 289 291 if (ret)
+47 -12
drivers/hid/i2c-hid/i2c-hid-of-elan.c
··· 31 31 struct regulator *vcc33; 32 32 struct regulator *vccio; 33 33 struct gpio_desc *reset_gpio; 34 + bool no_reset_on_power_off; 34 35 const struct elan_i2c_hid_chip_data *chip_data; 35 36 }; 36 37 ··· 41 40 container_of(ops, struct i2c_hid_of_elan, ops); 42 41 int ret; 43 42 43 + gpiod_set_value_cansleep(ihid_elan->reset_gpio, 1); 44 + 44 45 if (ihid_elan->vcc33) { 45 46 ret = regulator_enable(ihid_elan->vcc33); 46 47 if (ret) 47 - return ret; 48 + goto err_deassert_reset; 48 49 } 49 50 50 51 ret = regulator_enable(ihid_elan->vccio); 51 - if (ret) { 52 - regulator_disable(ihid_elan->vcc33); 53 - return ret; 54 - } 52 + if (ret) 53 + goto err_disable_vcc33; 55 54 56 55 if (ihid_elan->chip_data->post_power_delay_ms) 57 56 msleep(ihid_elan->chip_data->post_power_delay_ms); ··· 61 60 msleep(ihid_elan->chip_data->post_gpio_reset_on_delay_ms); 62 61 63 62 return 0; 63 + 64 + err_disable_vcc33: 65 + if (ihid_elan->vcc33) 66 + regulator_disable(ihid_elan->vcc33); 67 + err_deassert_reset: 68 + if (ihid_elan->no_reset_on_power_off) 69 + gpiod_set_value_cansleep(ihid_elan->reset_gpio, 0); 70 + 71 + return ret; 64 72 } 65 73 66 74 static void elan_i2c_hid_power_down(struct i2chid_ops *ops) ··· 77 67 struct i2c_hid_of_elan *ihid_elan = 78 68 container_of(ops, struct i2c_hid_of_elan, ops); 79 69 80 - gpiod_set_value_cansleep(ihid_elan->reset_gpio, 1); 70 + /* 71 + * Do not assert reset when the hardware allows for it to remain 72 + * deasserted regardless of the state of the (shared) power supply to 73 + * avoid wasting power when the supply is left on. 74 + */ 75 + if (!ihid_elan->no_reset_on_power_off) 76 + gpiod_set_value_cansleep(ihid_elan->reset_gpio, 1); 77 + 81 78 if (ihid_elan->chip_data->post_gpio_reset_off_delay_ms) 82 79 msleep(ihid_elan->chip_data->post_gpio_reset_off_delay_ms); 83 80 ··· 96 79 static int i2c_hid_of_elan_probe(struct i2c_client *client) 97 80 { 98 81 struct i2c_hid_of_elan *ihid_elan; 82 + int ret; 99 83 100 84 ihid_elan = devm_kzalloc(&client->dev, sizeof(*ihid_elan), GFP_KERNEL); 101 85 if (!ihid_elan) ··· 111 93 if (IS_ERR(ihid_elan->reset_gpio)) 112 94 return PTR_ERR(ihid_elan->reset_gpio); 113 95 96 + ihid_elan->no_reset_on_power_off = of_property_read_bool(client->dev.of_node, 97 + "no-reset-on-power-off"); 98 + 114 99 ihid_elan->vccio = devm_regulator_get(&client->dev, "vccio"); 115 - if (IS_ERR(ihid_elan->vccio)) 116 - return PTR_ERR(ihid_elan->vccio); 100 + if (IS_ERR(ihid_elan->vccio)) { 101 + ret = PTR_ERR(ihid_elan->vccio); 102 + goto err_deassert_reset; 103 + } 117 104 118 105 ihid_elan->chip_data = device_get_match_data(&client->dev); 119 106 120 107 if (ihid_elan->chip_data->main_supply_name) { 121 108 ihid_elan->vcc33 = devm_regulator_get(&client->dev, 122 109 ihid_elan->chip_data->main_supply_name); 123 - if (IS_ERR(ihid_elan->vcc33)) 124 - return PTR_ERR(ihid_elan->vcc33); 110 + if (IS_ERR(ihid_elan->vcc33)) { 111 + ret = PTR_ERR(ihid_elan->vcc33); 112 + goto err_deassert_reset; 113 + } 125 114 } 126 115 127 - return i2c_hid_core_probe(client, &ihid_elan->ops, 128 - ihid_elan->chip_data->hid_descriptor_address, 0); 116 + ret = i2c_hid_core_probe(client, &ihid_elan->ops, 117 + ihid_elan->chip_data->hid_descriptor_address, 0); 118 + if (ret) 119 + goto err_deassert_reset; 120 + 121 + return 0; 122 + 123 + err_deassert_reset: 124 + if (ihid_elan->no_reset_on_power_off) 125 + gpiod_set_value_cansleep(ihid_elan->reset_gpio, 0); 126 + 127 + return ret; 129 128 } 130 129 131 130 static const struct elan_i2c_hid_chip_data elan_ekth6915_chip_data = {
+44 -35
drivers/hid/intel-ish-hid/ishtp/loader.c
··· 84 84 static int loader_xfer_cmd(struct ishtp_device *dev, void *req, int req_len, 85 85 void *resp, int resp_len) 86 86 { 87 - struct loader_msg_header *req_hdr = req; 88 - struct loader_msg_header *resp_hdr = resp; 87 + union loader_msg_header req_hdr; 88 + union loader_msg_header resp_hdr; 89 89 struct device *devc = dev->devc; 90 90 int rv; 91 91 ··· 93 93 dev->fw_loader_rx_size = resp_len; 94 94 95 95 rv = loader_write_message(dev, req, req_len); 96 + req_hdr.val32 = le32_to_cpup(req); 97 + 96 98 if (rv < 0) { 97 - dev_err(devc, "write cmd %u failed:%d\n", req_hdr->command, rv); 99 + dev_err(devc, "write cmd %u failed:%d\n", req_hdr.command, rv); 98 100 return rv; 99 101 } 100 102 101 103 /* Wait the ACK */ 102 104 wait_event_interruptible_timeout(dev->wait_loader_recvd_msg, dev->fw_loader_received, 103 105 ISHTP_LOADER_TIMEOUT); 106 + resp_hdr.val32 = le32_to_cpup(resp); 104 107 dev->fw_loader_rx_size = 0; 105 108 dev->fw_loader_rx_buf = NULL; 106 109 if (!dev->fw_loader_received) { 107 - dev_err(devc, "wait response of cmd %u timeout\n", req_hdr->command); 110 + dev_err(devc, "wait response of cmd %u timeout\n", req_hdr.command); 108 111 return -ETIMEDOUT; 109 112 } 110 113 111 - if (!resp_hdr->is_response) { 112 - dev_err(devc, "not a response for %u\n", req_hdr->command); 114 + if (!resp_hdr.is_response) { 115 + dev_err(devc, "not a response for %u\n", req_hdr.command); 113 116 return -EBADMSG; 114 117 } 115 118 116 - if (req_hdr->command != resp_hdr->command) { 117 - dev_err(devc, "unexpected cmd response %u:%u\n", req_hdr->command, 118 - resp_hdr->command); 119 + if (req_hdr.command != resp_hdr.command) { 120 + dev_err(devc, "unexpected cmd response %u:%u\n", req_hdr.command, 121 + resp_hdr.command); 119 122 return -EBADMSG; 120 123 } 121 124 122 - if (resp_hdr->status) { 123 - dev_err(devc, "cmd %u failed %u\n", req_hdr->command, resp_hdr->status); 125 + if (resp_hdr.status) { 126 + dev_err(devc, "cmd %u failed %u\n", req_hdr.command, resp_hdr.status); 124 127 return -EIO; 125 128 } 126 129 ··· 141 138 struct loader_xfer_dma_fragment *fragment, 142 139 void **dma_bufs, u32 fragment_size) 143 140 { 141 + dma_addr_t dma_addr; 144 142 int i; 145 143 146 144 for (i = 0; i < FRAGMENT_MAX_NUM; i++) { 147 145 if (dma_bufs[i]) { 148 - dma_free_coherent(dev->devc, fragment_size, dma_bufs[i], 149 - fragment->fragment_tbl[i].ddr_adrs); 146 + dma_addr = le64_to_cpu(fragment->fragment_tbl[i].ddr_adrs); 147 + dma_free_coherent(dev->devc, fragment_size, dma_bufs[i], dma_addr); 150 148 dma_bufs[i] = NULL; 151 149 } 152 150 } ··· 160 156 * @fragment: The ISHTP firmware fragment descriptor 161 157 * @dma_bufs: The array of DMA fragment buffers 162 158 * @fragment_size: The size of a single DMA fragment 159 + * @fragment_count: Number of fragments 163 160 * 164 161 * Return: 0 on success, negative error code on failure 165 162 */ 166 163 static int prepare_dma_bufs(struct ishtp_device *dev, 167 164 const struct firmware *ish_fw, 168 165 struct loader_xfer_dma_fragment *fragment, 169 - void **dma_bufs, u32 fragment_size) 166 + void **dma_bufs, u32 fragment_size, u32 fragment_count) 170 167 { 168 + dma_addr_t dma_addr; 171 169 u32 offset = 0; 170 + u32 length; 172 171 int i; 173 172 174 - for (i = 0; i < fragment->fragment_cnt && offset < ish_fw->size; i++) { 175 - dma_bufs[i] = dma_alloc_coherent(dev->devc, fragment_size, 176 - &fragment->fragment_tbl[i].ddr_adrs, GFP_KERNEL); 173 + for (i = 0; i < fragment_count && offset < ish_fw->size; i++) { 174 + dma_bufs[i] = dma_alloc_coherent(dev->devc, fragment_size, &dma_addr, GFP_KERNEL); 177 175 if (!dma_bufs[i]) 178 176 return -ENOMEM; 179 177 180 - fragment->fragment_tbl[i].length = clamp(ish_fw->size - offset, 0, fragment_size); 181 - fragment->fragment_tbl[i].fw_off = offset; 182 - memcpy(dma_bufs[i], ish_fw->data + offset, fragment->fragment_tbl[i].length); 178 + fragment->fragment_tbl[i].ddr_adrs = cpu_to_le64(dma_addr); 179 + length = clamp(ish_fw->size - offset, 0, fragment_size); 180 + fragment->fragment_tbl[i].length = cpu_to_le32(length); 181 + fragment->fragment_tbl[i].fw_off = cpu_to_le32(offset); 182 + memcpy(dma_bufs[i], ish_fw->data + offset, length); 183 183 clflush_cache_range(dma_bufs[i], fragment_size); 184 184 185 - offset += fragment->fragment_tbl[i].length; 185 + offset += length; 186 186 } 187 187 188 188 return 0; ··· 214 206 { 215 207 DEFINE_RAW_FLEX(struct loader_xfer_dma_fragment, fragment, fragment_tbl, FRAGMENT_MAX_NUM); 216 208 struct ishtp_device *dev = container_of(work, struct ishtp_device, work_fw_loader); 217 - struct loader_xfer_query query = { 218 - .header.command = LOADER_CMD_XFER_QUERY, 219 - }; 220 - struct loader_start start = { 221 - .header.command = LOADER_CMD_START, 222 - }; 209 + union loader_msg_header query_hdr = { .command = LOADER_CMD_XFER_QUERY, }; 210 + union loader_msg_header start_hdr = { .command = LOADER_CMD_START, }; 211 + union loader_msg_header fragment_hdr = { .command = LOADER_CMD_XFER_FRAGMENT, }; 212 + struct loader_xfer_query query = { .header = cpu_to_le32(query_hdr.val32), }; 213 + struct loader_start start = { .header = cpu_to_le32(start_hdr.val32), }; 223 214 union loader_recv_message recv_msg; 224 215 char *filename = dev->driver_data->fw_filename; 225 216 const struct firmware *ish_fw; 226 217 void *dma_bufs[FRAGMENT_MAX_NUM] = {}; 227 218 u32 fragment_size; 219 + u32 fragment_count; 228 220 int retry = ISHTP_LOADER_RETRY_TIMES; 229 221 int rv; 230 222 ··· 234 226 return; 235 227 } 236 228 237 - fragment->fragment.header.command = LOADER_CMD_XFER_FRAGMENT; 238 - fragment->fragment.xfer_mode = LOADER_XFER_MODE_DMA; 239 - fragment->fragment.is_last = 1; 240 - fragment->fragment.size = ish_fw->size; 229 + fragment->fragment.header = cpu_to_le32(fragment_hdr.val32); 230 + fragment->fragment.xfer_mode = cpu_to_le32(LOADER_XFER_MODE_DMA); 231 + fragment->fragment.is_last = cpu_to_le32(1); 232 + fragment->fragment.size = cpu_to_le32(ish_fw->size); 241 233 /* Calculate the size of a single DMA fragment */ 242 234 fragment_size = PFN_ALIGN(DIV_ROUND_UP(ish_fw->size, FRAGMENT_MAX_NUM)); 243 235 /* Calculate the count of DMA fragments */ 244 - fragment->fragment_cnt = DIV_ROUND_UP(ish_fw->size, fragment_size); 236 + fragment_count = DIV_ROUND_UP(ish_fw->size, fragment_size); 237 + fragment->fragment_cnt = cpu_to_le32(fragment_count); 245 238 246 - rv = prepare_dma_bufs(dev, ish_fw, fragment, dma_bufs, fragment_size); 239 + rv = prepare_dma_bufs(dev, ish_fw, fragment, dma_bufs, fragment_size, fragment_count); 247 240 if (rv) { 248 241 dev_err(dev->devc, "prepare DMA buffer failed.\n"); 249 242 goto out; 250 243 } 251 244 252 245 do { 253 - query.image_size = ish_fw->size; 246 + query.image_size = cpu_to_le32(ish_fw->size); 254 247 rv = loader_xfer_cmd(dev, &query, sizeof(query), recv_msg.raw_data, 255 248 sizeof(struct loader_xfer_query_ack)); 256 249 if (rv) ··· 264 255 recv_msg.query_ack.version_build); 265 256 266 257 rv = loader_xfer_cmd(dev, fragment, 267 - struct_size(fragment, fragment_tbl, fragment->fragment_cnt), 258 + struct_size(fragment, fragment_tbl, fragment_count), 268 259 recv_msg.raw_data, sizeof(struct loader_xfer_fragment_ack)); 269 260 if (rv) 270 261 continue; /* try again if failed */
+18 -13
drivers/hid/intel-ish-hid/ishtp/loader.h
··· 30 30 #define LOADER_XFER_MODE_DMA BIT(0) 31 31 32 32 /** 33 - * struct loader_msg_header - ISHTP firmware loader message header 33 + * union loader_msg_header - ISHTP firmware loader message header 34 34 * @command: Command type 35 35 * @is_response: Indicates if the message is a response 36 36 * @has_next: Indicates if there is a next message 37 37 * @reserved: Reserved for future use 38 38 * @status: Status of the message 39 + * @val32: entire header as a 32-bit value 39 40 */ 40 - struct loader_msg_header { 41 - __le32 command:7; 42 - __le32 is_response:1; 43 - __le32 has_next:1; 44 - __le32 reserved:15; 45 - __le32 status:8; 41 + union loader_msg_header { 42 + struct { 43 + __u32 command:7; 44 + __u32 is_response:1; 45 + __u32 has_next:1; 46 + __u32 reserved:15; 47 + __u32 status:8; 48 + }; 49 + __u32 val32; 46 50 }; 47 51 48 52 /** ··· 55 51 * @image_size: Size of the image 56 52 */ 57 53 struct loader_xfer_query { 58 - struct loader_msg_header header; 54 + __le32 header; 59 55 __le32 image_size; 60 56 }; 61 57 ··· 107 103 * @capability: Loader capability 108 104 */ 109 105 struct loader_xfer_query_ack { 110 - struct loader_msg_header header; 106 + __le32 header; 111 107 __le16 version_major; 112 108 __le16 version_minor; 113 109 __le16 version_hotfix; ··· 126 122 * @is_last: Is last 127 123 */ 128 124 struct loader_xfer_fragment { 129 - struct loader_msg_header header; 125 + __le32 header; 130 126 __le32 xfer_mode; 131 127 __le32 offset; 132 128 __le32 size; ··· 138 134 * @header: Header of the message 139 135 */ 140 136 struct loader_xfer_fragment_ack { 141 - struct loader_msg_header header; 137 + __le32 header; 142 138 }; 143 139 144 140 /** ··· 174 170 * @header: Header of the message 175 171 */ 176 172 struct loader_start { 177 - struct loader_msg_header header; 173 + __le32 header; 178 174 }; 179 175 180 176 /** ··· 182 178 * @header: Header of the message 183 179 */ 184 180 struct loader_start_ack { 185 - struct loader_msg_header header; 181 + __le32 header; 186 182 }; 187 183 188 184 union loader_recv_message { 185 + __le32 header; 189 186 struct loader_xfer_query_ack query_ack; 190 187 struct loader_xfer_fragment_ack fragment_ack; 191 188 struct loader_start_ack start_ack;
+2
include/uapi/linux/input-event-codes.h
··· 618 618 #define KEY_CAMERA_ACCESS_ENABLE 0x24b /* Enables programmatic access to camera devices. (HUTRR72) */ 619 619 #define KEY_CAMERA_ACCESS_DISABLE 0x24c /* Disables programmatic access to camera devices. (HUTRR72) */ 620 620 #define KEY_CAMERA_ACCESS_TOGGLE 0x24d /* Toggles the current state of the camera access control. (HUTRR72) */ 621 + #define KEY_ACCESSIBILITY 0x24e /* Toggles the system bound accessibility UI/command (HUTRR116) */ 622 + #define KEY_DO_NOT_DISTURB 0x24f /* Toggles the system-wide "Do Not Disturb" control (HUTRR94)*/ 621 623 622 624 #define KEY_BRIGHTNESS_MIN 0x250 /* Set Brightness to Minimum */ 623 625 #define KEY_BRIGHTNESS_MAX 0x251 /* Set Brightness to Maximum */