1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Common/core components for the Surface System Aggregator Module (SSAM) HID 4 * transport driver. Provides support for integrated HID devices on Microsoft 5 * Surface models. 6 * 7 * Copyright (C) 2019-2021 Maximilian Luz <luzmaximilian@gmail.com> 8 */ 9 10 #include <asm/unaligned.h> 11 #include <linux/hid.h> 12 #include <linux/kernel.h> 13 #include <linux/module.h> 14 #include <linux/types.h> 15 #include <linux/usb/ch9.h> 16 17 #include <linux/surface_aggregator/controller.h> 18 19 #include "surface_hid_core.h" 20 21 22 /* -- Utility functions. ---------------------------------------------------- */ 23 24 static bool surface_hid_is_hot_removed(struct surface_hid_device *shid) 25 { 26 /* 27 * Non-ssam client devices, i.e. platform client devices, cannot be 28 * hot-removed. 29 */ 30 if (!is_ssam_device(shid->dev)) 31 return false; 32 33 return ssam_device_is_hot_removed(to_ssam_device(shid->dev)); 34 } 35 36 37 /* -- Device descriptor access. --------------------------------------------- */ 38 39 static int surface_hid_load_hid_descriptor(struct surface_hid_device *shid) 40 { 41 int status; 42 43 if (surface_hid_is_hot_removed(shid)) 44 return -ENODEV; 45 46 status = shid->ops.get_descriptor(shid, SURFACE_HID_DESC_HID, 47 (u8 *)&shid->hid_desc, sizeof(shid->hid_desc)); 48 if (status) 49 return status; 50 51 if (shid->hid_desc.desc_len != sizeof(shid->hid_desc)) { 52 dev_err(shid->dev, "unexpected HID descriptor length: got %u, expected %zu\n", 53 shid->hid_desc.desc_len, sizeof(shid->hid_desc)); 54 return -EPROTO; 55 } 56 57 if (shid->hid_desc.desc_type != HID_DT_HID) { 58 dev_err(shid->dev, "unexpected HID descriptor type: got %#04x, expected %#04x\n", 59 shid->hid_desc.desc_type, HID_DT_HID); 60 return -EPROTO; 61 } 62 63 if (shid->hid_desc.num_descriptors != 1) { 64 dev_err(shid->dev, "unexpected number of descriptors: got %u, expected 1\n", 65 shid->hid_desc.num_descriptors); 66 return -EPROTO; 67 } 68 69 if (shid->hid_desc.report_desc_type != HID_DT_REPORT) { 70 dev_err(shid->dev, "unexpected report descriptor type: got %#04x, expected %#04x\n", 71 shid->hid_desc.report_desc_type, HID_DT_REPORT); 72 return -EPROTO; 73 } 74 75 return 0; 76 } 77 78 static int surface_hid_load_device_attributes(struct surface_hid_device *shid) 79 { 80 int status; 81 82 if (surface_hid_is_hot_removed(shid)) 83 return -ENODEV; 84 85 status = shid->ops.get_descriptor(shid, SURFACE_HID_DESC_ATTRS, 86 (u8 *)&shid->attrs, sizeof(shid->attrs)); 87 if (status) 88 return status; 89 90 if (get_unaligned_le32(&shid->attrs.length) != sizeof(shid->attrs)) { 91 dev_err(shid->dev, "unexpected attribute length: got %u, expected %zu\n", 92 get_unaligned_le32(&shid->attrs.length), sizeof(shid->attrs)); 93 return -EPROTO; 94 } 95 96 return 0; 97 } 98 99 100 /* -- Transport driver (common). -------------------------------------------- */ 101 102 static int surface_hid_start(struct hid_device *hid) 103 { 104 struct surface_hid_device *shid = hid->driver_data; 105 106 return ssam_notifier_register(shid->ctrl, &shid->notif); 107 } 108 109 static void surface_hid_stop(struct hid_device *hid) 110 { 111 struct surface_hid_device *shid = hid->driver_data; 112 bool hot_removed; 113 114 /* 115 * Communication may fail for devices that have been hot-removed. This 116 * also includes unregistration of HID events, so we need to check this 117 * here. Only if the device has not been marked as hot-removed, we can 118 * safely disable events. 119 */ 120 hot_removed = surface_hid_is_hot_removed(shid); 121 122 /* Note: This call will log errors for us, so ignore them here. */ 123 __ssam_notifier_unregister(shid->ctrl, &shid->notif, !hot_removed); 124 } 125 126 static int surface_hid_open(struct hid_device *hid) 127 { 128 return 0; 129 } 130 131 static void surface_hid_close(struct hid_device *hid) 132 { 133 } 134 135 static int surface_hid_parse(struct hid_device *hid) 136 { 137 struct surface_hid_device *shid = hid->driver_data; 138 size_t len = get_unaligned_le16(&shid->hid_desc.report_desc_len); 139 u8 *buf; 140 int status; 141 142 if (surface_hid_is_hot_removed(shid)) 143 return -ENODEV; 144 145 buf = kzalloc(len, GFP_KERNEL); 146 if (!buf) 147 return -ENOMEM; 148 149 status = shid->ops.get_descriptor(shid, SURFACE_HID_DESC_REPORT, buf, len); 150 if (!status) 151 status = hid_parse_report(hid, buf, len); 152 153 kfree(buf); 154 return status; 155 } 156 157 static int surface_hid_raw_request(struct hid_device *hid, unsigned char reportnum, u8 *buf, 158 size_t len, unsigned char rtype, int reqtype) 159 { 160 struct surface_hid_device *shid = hid->driver_data; 161 162 if (surface_hid_is_hot_removed(shid)) 163 return -ENODEV; 164 165 if (rtype == HID_OUTPUT_REPORT && reqtype == HID_REQ_SET_REPORT) 166 return shid->ops.output_report(shid, reportnum, buf, len); 167 168 else if (rtype == HID_FEATURE_REPORT && reqtype == HID_REQ_GET_REPORT) 169 return shid->ops.get_feature_report(shid, reportnum, buf, len); 170 171 else if (rtype == HID_FEATURE_REPORT && reqtype == HID_REQ_SET_REPORT) 172 return shid->ops.set_feature_report(shid, reportnum, buf, len); 173 174 return -EIO; 175 } 176 177 static struct hid_ll_driver surface_hid_ll_driver = { 178 .start = surface_hid_start, 179 .stop = surface_hid_stop, 180 .open = surface_hid_open, 181 .close = surface_hid_close, 182 .parse = surface_hid_parse, 183 .raw_request = surface_hid_raw_request, 184 }; 185 186 187 /* -- Common device setup. -------------------------------------------------- */ 188 189 int surface_hid_device_add(struct surface_hid_device *shid) 190 { 191 int status; 192 193 status = surface_hid_load_hid_descriptor(shid); 194 if (status) 195 return status; 196 197 status = surface_hid_load_device_attributes(shid); 198 if (status) 199 return status; 200 201 shid->hid = hid_allocate_device(); 202 if (IS_ERR(shid->hid)) 203 return PTR_ERR(shid->hid); 204 205 shid->hid->dev.parent = shid->dev; 206 shid->hid->bus = BUS_HOST; 207 shid->hid->vendor = get_unaligned_le16(&shid->attrs.vendor); 208 shid->hid->product = get_unaligned_le16(&shid->attrs.product); 209 shid->hid->version = get_unaligned_le16(&shid->hid_desc.hid_version); 210 shid->hid->country = shid->hid_desc.country_code; 211 212 snprintf(shid->hid->name, sizeof(shid->hid->name), "Microsoft Surface %04X:%04X", 213 shid->hid->vendor, shid->hid->product); 214 215 strscpy(shid->hid->phys, dev_name(shid->dev), sizeof(shid->hid->phys)); 216 217 shid->hid->driver_data = shid; 218 shid->hid->ll_driver = &surface_hid_ll_driver; 219 220 status = hid_add_device(shid->hid); 221 if (status) 222 hid_destroy_device(shid->hid); 223 224 return status; 225 } 226 EXPORT_SYMBOL_GPL(surface_hid_device_add); 227 228 void surface_hid_device_destroy(struct surface_hid_device *shid) 229 { 230 hid_destroy_device(shid->hid); 231 } 232 EXPORT_SYMBOL_GPL(surface_hid_device_destroy); 233 234 235 /* -- PM ops. --------------------------------------------------------------- */ 236 237 #ifdef CONFIG_PM_SLEEP 238 239 static int surface_hid_suspend(struct device *dev) 240 { 241 struct surface_hid_device *d = dev_get_drvdata(dev); 242 243 return hid_driver_suspend(d->hid, PMSG_SUSPEND); 244 } 245 246 static int surface_hid_resume(struct device *dev) 247 { 248 struct surface_hid_device *d = dev_get_drvdata(dev); 249 250 return hid_driver_resume(d->hid); 251 } 252 253 static int surface_hid_freeze(struct device *dev) 254 { 255 struct surface_hid_device *d = dev_get_drvdata(dev); 256 257 return hid_driver_suspend(d->hid, PMSG_FREEZE); 258 } 259 260 static int surface_hid_poweroff(struct device *dev) 261 { 262 struct surface_hid_device *d = dev_get_drvdata(dev); 263 264 return hid_driver_suspend(d->hid, PMSG_HIBERNATE); 265 } 266 267 static int surface_hid_restore(struct device *dev) 268 { 269 struct surface_hid_device *d = dev_get_drvdata(dev); 270 271 return hid_driver_reset_resume(d->hid); 272 } 273 274 const struct dev_pm_ops surface_hid_pm_ops = { 275 .freeze = surface_hid_freeze, 276 .thaw = surface_hid_resume, 277 .suspend = surface_hid_suspend, 278 .resume = surface_hid_resume, 279 .poweroff = surface_hid_poweroff, 280 .restore = surface_hid_restore, 281 }; 282 EXPORT_SYMBOL_GPL(surface_hid_pm_ops); 283 284 #else /* CONFIG_PM_SLEEP */ 285 286 const struct dev_pm_ops surface_hid_pm_ops = { }; 287 EXPORT_SYMBOL_GPL(surface_hid_pm_ops); 288 289 #endif /* CONFIG_PM_SLEEP */ 290 291 MODULE_AUTHOR("Maximilian Luz <luzmaximilian@gmail.com>"); 292 MODULE_DESCRIPTION("HID transport driver core for Surface System Aggregator Module"); 293 MODULE_LICENSE("GPL"); 294