wmi_ab.c

  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 * This driver implements the WMI AB device found on TUXEDO notebooks with board
  4 * vendor NB04.
  5 *
  6 * Copyright (C) 2024-2025 Werner Sembach <wse@tuxedocomputers.com>
  7 */
  8
  9#include <linux/dmi.h>
 10#include <linux/hid.h>
 11#include <linux/minmax.h>
 12#include <linux/module.h>
 13#include <linux/wmi.h>
 14
 15#include "wmi_util.h"
 16
 17static const struct wmi_device_id tuxedo_nb04_wmi_ab_device_ids[] = {
 18	{ .guid_string = "80C9BAA6-AC48-4538-9234-9F81A55E7C85" },
 19	{ }
 20};
 21MODULE_DEVICE_TABLE(wmi, tuxedo_nb04_wmi_ab_device_ids);
 22
 23enum {
 24	LAMP_ARRAY_ATTRIBUTES_REPORT_ID		= 0x01,
 25	LAMP_ATTRIBUTES_REQUEST_REPORT_ID	= 0x02,
 26	LAMP_ATTRIBUTES_RESPONSE_REPORT_ID	= 0x03,
 27	LAMP_MULTI_UPDATE_REPORT_ID		= 0x04,
 28	LAMP_RANGE_UPDATE_REPORT_ID		= 0x05,
 29	LAMP_ARRAY_CONTROL_REPORT_ID		= 0x06,
 30};
 31
 32static u8 tux_report_descriptor[327] = {
 33	0x05, 0x59,			// Usage Page (Lighting and Illumination)
 34	0x09, 0x01,			// Usage (Lamp Array)
 35	0xa1, 0x01,			// Collection (Application)
 36	0x85, LAMP_ARRAY_ATTRIBUTES_REPORT_ID, //  Report ID (1)
 37	0x09, 0x02,			//  Usage (Lamp Array Attributes Report)
 38	0xa1, 0x02,			//  Collection (Logical)
 39	0x09, 0x03,			//   Usage (Lamp Count)
 40	0x15, 0x00,			//   Logical Minimum (0)
 41	0x27, 0xff, 0xff, 0x00, 0x00,	//   Logical Maximum (65535)
 42	0x75, 0x10,			//   Report Size (16)
 43	0x95, 0x01,			//   Report Count (1)
 44	0xb1, 0x03,			//   Feature (Cnst,Var,Abs)
 45	0x09, 0x04,			//   Usage (Bounding Box Width In Micrometers)
 46	0x09, 0x05,			//   Usage (Bounding Box Height In Micrometers)
 47	0x09, 0x06,			//   Usage (Bounding Box Depth In Micrometers)
 48	0x09, 0x07,			//   Usage (Lamp Array Kind)
 49	0x09, 0x08,			//   Usage (Min Update Interval In Microseconds)
 50	0x15, 0x00,			//   Logical Minimum (0)
 51	0x27, 0xff, 0xff, 0xff, 0x7f,	//   Logical Maximum (2147483647)
 52	0x75, 0x20,			//   Report Size (32)
 53	0x95, 0x05,			//   Report Count (5)
 54	0xb1, 0x03,			//   Feature (Cnst,Var,Abs)
 55	0xc0,				//  End Collection
 56	0x85, LAMP_ATTRIBUTES_REQUEST_REPORT_ID, //  Report ID (2)
 57	0x09, 0x20,			//  Usage (Lamp Attributes Request Report)
 58	0xa1, 0x02,			//  Collection (Logical)
 59	0x09, 0x21,			//   Usage (Lamp Id)
 60	0x15, 0x00,			//   Logical Minimum (0)
 61	0x27, 0xff, 0xff, 0x00, 0x00,	//   Logical Maximum (65535)
 62	0x75, 0x10,			//   Report Size (16)
 63	0x95, 0x01,			//   Report Count (1)
 64	0xb1, 0x02,			//   Feature (Data,Var,Abs)
 65	0xc0,				//  End Collection
 66	0x85, LAMP_ATTRIBUTES_RESPONSE_REPORT_ID, //  Report ID (3)
 67	0x09, 0x22,			//  Usage (Lamp Attributes Response Report)
 68	0xa1, 0x02,			//  Collection (Logical)
 69	0x09, 0x21,			//   Usage (Lamp Id)
 70	0x15, 0x00,			//   Logical Minimum (0)
 71	0x27, 0xff, 0xff, 0x00, 0x00,	//   Logical Maximum (65535)
 72	0x75, 0x10,			//   Report Size (16)
 73	0x95, 0x01,			//   Report Count (1)
 74	0xb1, 0x02,			//   Feature (Data,Var,Abs)
 75	0x09, 0x23,			//   Usage (Position X In Micrometers)
 76	0x09, 0x24,			//   Usage (Position Y In Micrometers)
 77	0x09, 0x25,			//   Usage (Position Z In Micrometers)
 78	0x09, 0x27,			//   Usage (Update Latency In Microseconds)
 79	0x09, 0x26,			//   Usage (Lamp Purposes)
 80	0x15, 0x00,			//   Logical Minimum (0)
 81	0x27, 0xff, 0xff, 0xff, 0x7f,	//   Logical Maximum (2147483647)
 82	0x75, 0x20,			//   Report Size (32)
 83	0x95, 0x05,			//   Report Count (5)
 84	0xb1, 0x02,			//   Feature (Data,Var,Abs)
 85	0x09, 0x28,			//   Usage (Red Level Count)
 86	0x09, 0x29,			//   Usage (Green Level Count)
 87	0x09, 0x2a,			//   Usage (Blue Level Count)
 88	0x09, 0x2b,			//   Usage (Intensity Level Count)
 89	0x09, 0x2c,			//   Usage (Is Programmable)
 90	0x09, 0x2d,			//   Usage (Input Binding)
 91	0x15, 0x00,			//   Logical Minimum (0)
 92	0x26, 0xff, 0x00,		//   Logical Maximum (255)
 93	0x75, 0x08,			//   Report Size (8)
 94	0x95, 0x06,			//   Report Count (6)
 95	0xb1, 0x02,			//   Feature (Data,Var,Abs)
 96	0xc0,				//  End Collection
 97	0x85, LAMP_MULTI_UPDATE_REPORT_ID, //  Report ID (4)
 98	0x09, 0x50,			//  Usage (Lamp Multi Update Report)
 99	0xa1, 0x02,			//  Collection (Logical)
100	0x09, 0x03,			//   Usage (Lamp Count)
101	0x09, 0x55,			//   Usage (Lamp Update Flags)
102	0x15, 0x00,			//   Logical Minimum (0)
103	0x25, 0x08,			//   Logical Maximum (8)
104	0x75, 0x08,			//   Report Size (8)
105	0x95, 0x02,			//   Report Count (2)
106	0xb1, 0x02,			//   Feature (Data,Var,Abs)
107	0x09, 0x21,			//   Usage (Lamp Id)
108	0x15, 0x00,			//   Logical Minimum (0)
109	0x27, 0xff, 0xff, 0x00, 0x00,	//   Logical Maximum (65535)
110	0x75, 0x10,			//   Report Size (16)
111	0x95, 0x08,			//   Report Count (8)
112	0xb1, 0x02,			//   Feature (Data,Var,Abs)
113	0x09, 0x51,			//   Usage (Red Update Channel)
114	0x09, 0x52,			//   Usage (Green Update Channel)
115	0x09, 0x53,			//   Usage (Blue Update Channel)
116	0x09, 0x54,			//   Usage (Intensity Update Channel)
117	0x09, 0x51,			//   Usage (Red Update Channel)
118	0x09, 0x52,			//   Usage (Green Update Channel)
119	0x09, 0x53,			//   Usage (Blue Update Channel)
120	0x09, 0x54,			//   Usage (Intensity Update Channel)
121	0x09, 0x51,			//   Usage (Red Update Channel)
122	0x09, 0x52,			//   Usage (Green Update Channel)
123	0x09, 0x53,			//   Usage (Blue Update Channel)
124	0x09, 0x54,			//   Usage (Intensity Update Channel)
125	0x09, 0x51,			//   Usage (Red Update Channel)
126	0x09, 0x52,			//   Usage (Green Update Channel)
127	0x09, 0x53,			//   Usage (Blue Update Channel)
128	0x09, 0x54,			//   Usage (Intensity Update Channel)
129	0x09, 0x51,			//   Usage (Red Update Channel)
130	0x09, 0x52,			//   Usage (Green Update Channel)
131	0x09, 0x53,			//   Usage (Blue Update Channel)
132	0x09, 0x54,			//   Usage (Intensity Update Channel)
133	0x09, 0x51,			//   Usage (Red Update Channel)
134	0x09, 0x52,			//   Usage (Green Update Channel)
135	0x09, 0x53,			//   Usage (Blue Update Channel)
136	0x09, 0x54,			//   Usage (Intensity Update Channel)
137	0x09, 0x51,			//   Usage (Red Update Channel)
138	0x09, 0x52,			//   Usage (Green Update Channel)
139	0x09, 0x53,			//   Usage (Blue Update Channel)
140	0x09, 0x54,			//   Usage (Intensity Update Channel)
141	0x09, 0x51,			//   Usage (Red Update Channel)
142	0x09, 0x52,			//   Usage (Green Update Channel)
143	0x09, 0x53,			//   Usage (Blue Update Channel)
144	0x09, 0x54,			//   Usage (Intensity Update Channel)
145	0x15, 0x00,			//   Logical Minimum (0)
146	0x26, 0xff, 0x00,		//   Logical Maximum (255)
147	0x75, 0x08,			//   Report Size (8)
148	0x95, 0x20,			//   Report Count (32)
149	0xb1, 0x02,			//   Feature (Data,Var,Abs)
150	0xc0,				//  End Collection
151	0x85, LAMP_RANGE_UPDATE_REPORT_ID, //  Report ID (5)
152	0x09, 0x60,			//  Usage (Lamp Range Update Report)
153	0xa1, 0x02,			//  Collection (Logical)
154	0x09, 0x55,			//   Usage (Lamp Update Flags)
155	0x15, 0x00,			//   Logical Minimum (0)
156	0x25, 0x08,			//   Logical Maximum (8)
157	0x75, 0x08,			//   Report Size (8)
158	0x95, 0x01,			//   Report Count (1)
159	0xb1, 0x02,			//   Feature (Data,Var,Abs)
160	0x09, 0x61,			//   Usage (Lamp Id Start)
161	0x09, 0x62,			//   Usage (Lamp Id End)
162	0x15, 0x00,			//   Logical Minimum (0)
163	0x27, 0xff, 0xff, 0x00, 0x00,	//   Logical Maximum (65535)
164	0x75, 0x10,			//   Report Size (16)
165	0x95, 0x02,			//   Report Count (2)
166	0xb1, 0x02,			//   Feature (Data,Var,Abs)
167	0x09, 0x51,			//   Usage (Red Update Channel)
168	0x09, 0x52,			//   Usage (Green Update Channel)
169	0x09, 0x53,			//   Usage (Blue Update Channel)
170	0x09, 0x54,			//   Usage (Intensity Update Channel)
171	0x15, 0x00,			//   Logical Minimum (0)
172	0x26, 0xff, 0x00,		//   Logical Maximum (255)
173	0x75, 0x08,			//   Report Size (8)
174	0x95, 0x04,			//   Report Count (4)
175	0xb1, 0x02,			//   Feature (Data,Var,Abs)
176	0xc0,				//  End Collection
177	0x85, LAMP_ARRAY_CONTROL_REPORT_ID, //  Report ID (6)
178	0x09, 0x70,			//  Usage (Lamp Array Control Report)
179	0xa1, 0x02,			//  Collection (Logical)
180	0x09, 0x71,			//   Usage (Autonomous Mode)
181	0x15, 0x00,			//   Logical Minimum (0)
182	0x25, 0x01,			//   Logical Maximum (1)
183	0x75, 0x08,			//   Report Size (8)
184	0x95, 0x01,			//   Report Count (1)
185	0xb1, 0x02,			//   Feature (Data,Var,Abs)
186	0xc0,				//  End Collection
187	0xc0				// End Collection
188};
189
190struct tux_kbl_map_entry_t {
191	u8 code;
192	struct {
193		u32 x;
194		u32 y;
195		u32 z;
196	} pos;
197};
198
199static const struct tux_kbl_map_entry_t sirius_16_ansii_kbl_map[] = {
200	{ 0x29, {  25000,  53000, 5000 } },
201	{ 0x3a, {  41700,  53000, 5000 } },
202	{ 0x3b, {  58400,  53000, 5000 } },
203	{ 0x3c, {  75100,  53000, 5000 } },
204	{ 0x3d, {  91800,  53000, 5000 } },
205	{ 0x3e, { 108500,  53000, 5000 } },
206	{ 0x3f, { 125200,  53000, 5000 } },
207	{ 0x40, { 141900,  53000, 5000 } },
208	{ 0x41, { 158600,  53000, 5000 } },
209	{ 0x42, { 175300,  53000, 5000 } },
210	{ 0x43, { 192000,  53000, 5000 } },
211	{ 0x44, { 208700,  53000, 5000 } },
212	{ 0x45, { 225400,  53000, 5000 } },
213	{ 0xf1, { 242100,  53000, 5000 } },
214	{ 0x46, { 258800,  53000, 5000 } },
215	{ 0x4c, { 275500,  53000, 5000 } },
216	{ 0x4a, { 294500,  53000, 5000 } },
217	{ 0x4d, { 311200,  53000, 5000 } },
218	{ 0x4b, { 327900,  53000, 5000 } },
219	{ 0x4e, { 344600,  53000, 5000 } },
220	{ 0x35, {  24500,  67500, 5250 } },
221	{ 0x1e, {  42500,  67500, 5250 } },
222	{ 0x1f, {  61000,  67500, 5250 } },
223	{ 0x20, {  79500,  67500, 5250 } },
224	{ 0x21, {  98000,  67500, 5250 } },
225	{ 0x22, { 116500,  67500, 5250 } },
226	{ 0x23, { 135000,  67500, 5250 } },
227	{ 0x24, { 153500,  67500, 5250 } },
228	{ 0x25, { 172000,  67500, 5250 } },
229	{ 0x26, { 190500,  67500, 5250 } },
230	{ 0x27, { 209000,  67500, 5250 } },
231	{ 0x2d, { 227500,  67500, 5250 } },
232	{ 0x2e, { 246000,  67500, 5250 } },
233	{ 0x2a, { 269500,  67500, 5250 } },
234	{ 0x53, { 294500,  67500, 5250 } },
235	{ 0x55, { 311200,  67500, 5250 } },
236	{ 0x54, { 327900,  67500, 5250 } },
237	{ 0x56, { 344600,  67500, 5250 } },
238	{ 0x2b, {  31000,  85500, 5500 } },
239	{ 0x14, {  51500,  85500, 5500 } },
240	{ 0x1a, {  70000,  85500, 5500 } },
241	{ 0x08, {  88500,  85500, 5500 } },
242	{ 0x15, { 107000,  85500, 5500 } },
243	{ 0x17, { 125500,  85500, 5500 } },
244	{ 0x1c, { 144000,  85500, 5500 } },
245	{ 0x18, { 162500,  85500, 5500 } },
246	{ 0x0c, { 181000,  85500, 5500 } },
247	{ 0x12, { 199500,  85500, 5500 } },
248	{ 0x13, { 218000,  85500, 5500 } },
249	{ 0x2f, { 236500,  85500, 5500 } },
250	{ 0x30, { 255000,  85500, 5500 } },
251	{ 0x31, { 273500,  85500, 5500 } },
252	{ 0x5f, { 294500,  85500, 5500 } },
253	{ 0x60, { 311200,  85500, 5500 } },
254	{ 0x61, { 327900,  85500, 5500 } },
255	{ 0x39, {  33000, 103500, 5750 } },
256	{ 0x04, {  57000, 103500, 5750 } },
257	{ 0x16, {  75500, 103500, 5750 } },
258	{ 0x07, {  94000, 103500, 5750 } },
259	{ 0x09, { 112500, 103500, 5750 } },
260	{ 0x0a, { 131000, 103500, 5750 } },
261	{ 0x0b, { 149500, 103500, 5750 } },
262	{ 0x0d, { 168000, 103500, 5750 } },
263	{ 0x0e, { 186500, 103500, 5750 } },
264	{ 0x0f, { 205000, 103500, 5750 } },
265	{ 0x33, { 223500, 103500, 5750 } },
266	{ 0x34, { 242000, 103500, 5750 } },
267	{ 0x28, { 267500, 103500, 5750 } },
268	{ 0x5c, { 294500, 103500, 5750 } },
269	{ 0x5d, { 311200, 103500, 5750 } },
270	{ 0x5e, { 327900, 103500, 5750 } },
271	{ 0x57, { 344600,  94500, 5625 } },
272	{ 0xe1, {  37000, 121500, 6000 } },
273	{ 0x1d, {  66000, 121500, 6000 } },
274	{ 0x1b, {  84500, 121500, 6000 } },
275	{ 0x06, { 103000, 121500, 6000 } },
276	{ 0x19, { 121500, 121500, 6000 } },
277	{ 0x05, { 140000, 121500, 6000 } },
278	{ 0x11, { 158500, 121500, 6000 } },
279	{ 0x10, { 177000, 121500, 6000 } },
280	{ 0x36, { 195500, 121500, 6000 } },
281	{ 0x37, { 214000, 121500, 6000 } },
282	{ 0x38, { 232500, 121500, 6000 } },
283	{ 0xe5, { 251500, 121500, 6000 } },
284	{ 0x52, { 273500, 129000, 6125 } },
285	{ 0x59, { 294500, 121500, 6000 } },
286	{ 0x5a, { 311200, 121500, 6000 } },
287	{ 0x5b, { 327900, 121500, 6000 } },
288	{ 0xe0, {  28000, 139500, 6250 } },
289	{ 0xfe, {  47500, 139500, 6250 } },
290	{ 0xe3, {  66000, 139500, 6250 } },
291	{ 0xe2, {  84500, 139500, 6250 } },
292	{ 0x2c, { 140000, 139500, 6250 } },
293	{ 0xe6, { 195500, 139500, 6250 } },
294	{ 0x65, { 214000, 139500, 6250 } },
295	{ 0xe4, { 234000, 139500, 6250 } },
296	{ 0x50, { 255000, 147000, 6375 } },
297	{ 0x51, { 273500, 147000, 6375 } },
298	{ 0x4f, { 292000, 147000, 6375 } },
299	{ 0x62, { 311200, 139500, 6250 } },
300	{ 0x63, { 327900, 139500, 6250 } },
301	{ 0x58, { 344600, 130500, 6125 } },
302};
303
304static const struct tux_kbl_map_entry_t sirius_16_iso_kbl_map[] = {
305	{ 0x29, {  25000,  53000, 5000 } },
306	{ 0x3a, {  41700,  53000, 5000 } },
307	{ 0x3b, {  58400,  53000, 5000 } },
308	{ 0x3c, {  75100,  53000, 5000 } },
309	{ 0x3d, {  91800,  53000, 5000 } },
310	{ 0x3e, { 108500,  53000, 5000 } },
311	{ 0x3f, { 125200,  53000, 5000 } },
312	{ 0x40, { 141900,  53000, 5000 } },
313	{ 0x41, { 158600,  53000, 5000 } },
314	{ 0x42, { 175300,  53000, 5000 } },
315	{ 0x43, { 192000,  53000, 5000 } },
316	{ 0x44, { 208700,  53000, 5000 } },
317	{ 0x45, { 225400,  53000, 5000 } },
318	{ 0xf1, { 242100,  53000, 5000 } },
319	{ 0x46, { 258800,  53000, 5000 } },
320	{ 0x4c, { 275500,  53000, 5000 } },
321	{ 0x4a, { 294500,  53000, 5000 } },
322	{ 0x4d, { 311200,  53000, 5000 } },
323	{ 0x4b, { 327900,  53000, 5000 } },
324	{ 0x4e, { 344600,  53000, 5000 } },
325	{ 0x35, {  24500,  67500, 5250 } },
326	{ 0x1e, {  42500,  67500, 5250 } },
327	{ 0x1f, {  61000,  67500, 5250 } },
328	{ 0x20, {  79500,  67500, 5250 } },
329	{ 0x21, {  98000,  67500, 5250 } },
330	{ 0x22, { 116500,  67500, 5250 } },
331	{ 0x23, { 135000,  67500, 5250 } },
332	{ 0x24, { 153500,  67500, 5250 } },
333	{ 0x25, { 172000,  67500, 5250 } },
334	{ 0x26, { 190500,  67500, 5250 } },
335	{ 0x27, { 209000,  67500, 5250 } },
336	{ 0x2d, { 227500,  67500, 5250 } },
337	{ 0x2e, { 246000,  67500, 5250 } },
338	{ 0x2a, { 269500,  67500, 5250 } },
339	{ 0x53, { 294500,  67500, 5250 } },
340	{ 0x55, { 311200,  67500, 5250 } },
341	{ 0x54, { 327900,  67500, 5250 } },
342	{ 0x56, { 344600,  67500, 5250 } },
343	{ 0x2b, {  31000,  85500, 5500 } },
344	{ 0x14, {  51500,  85500, 5500 } },
345	{ 0x1a, {  70000,  85500, 5500 } },
346	{ 0x08, {  88500,  85500, 5500 } },
347	{ 0x15, { 107000,  85500, 5500 } },
348	{ 0x17, { 125500,  85500, 5500 } },
349	{ 0x1c, { 144000,  85500, 5500 } },
350	{ 0x18, { 162500,  85500, 5500 } },
351	{ 0x0c, { 181000,  85500, 5500 } },
352	{ 0x12, { 199500,  85500, 5500 } },
353	{ 0x13, { 218000,  85500, 5500 } },
354	{ 0x2f, { 234500,  85500, 5500 } },
355	{ 0x30, { 251000,  85500, 5500 } },
356	{ 0x5f, { 294500,  85500, 5500 } },
357	{ 0x60, { 311200,  85500, 5500 } },
358	{ 0x61, { 327900,  85500, 5500 } },
359	{ 0x39, {  33000, 103500, 5750 } },
360	{ 0x04, {  57000, 103500, 5750 } },
361	{ 0x16, {  75500, 103500, 5750 } },
362	{ 0x07, {  94000, 103500, 5750 } },
363	{ 0x09, { 112500, 103500, 5750 } },
364	{ 0x0a, { 131000, 103500, 5750 } },
365	{ 0x0b, { 149500, 103500, 5750 } },
366	{ 0x0d, { 168000, 103500, 5750 } },
367	{ 0x0e, { 186500, 103500, 5750 } },
368	{ 0x0f, { 205000, 103500, 5750 } },
369	{ 0x33, { 223500, 103500, 5750 } },
370	{ 0x34, { 240000, 103500, 5750 } },
371	{ 0x32, { 256500, 103500, 5750 } },
372	{ 0x28, { 271500,  94500, 5750 } },
373	{ 0x5c, { 294500, 103500, 5750 } },
374	{ 0x5d, { 311200, 103500, 5750 } },
375	{ 0x5e, { 327900, 103500, 5750 } },
376	{ 0x57, { 344600,  94500, 5625 } },
377	{ 0xe1, {  28000, 121500, 6000 } },
378	{ 0x64, {  47500, 121500, 6000 } },
379	{ 0x1d, {  66000, 121500, 6000 } },
380	{ 0x1b, {  84500, 121500, 6000 } },
381	{ 0x06, { 103000, 121500, 6000 } },
382	{ 0x19, { 121500, 121500, 6000 } },
383	{ 0x05, { 140000, 121500, 6000 } },
384	{ 0x11, { 158500, 121500, 6000 } },
385	{ 0x10, { 177000, 121500, 6000 } },
386	{ 0x36, { 195500, 121500, 6000 } },
387	{ 0x37, { 214000, 121500, 6000 } },
388	{ 0x38, { 232500, 121500, 6000 } },
389	{ 0xe5, { 251500, 121500, 6000 } },
390	{ 0x52, { 273500, 129000, 6125 } },
391	{ 0x59, { 294500, 121500, 6000 } },
392	{ 0x5a, { 311200, 121500, 6000 } },
393	{ 0x5b, { 327900, 121500, 6000 } },
394	{ 0xe0, {  28000, 139500, 6250 } },
395	{ 0xfe, {  47500, 139500, 6250 } },
396	{ 0xe3, {  66000, 139500, 6250 } },
397	{ 0xe2, {  84500, 139500, 6250 } },
398	{ 0x2c, { 140000, 139500, 6250 } },
399	{ 0xe6, { 195500, 139500, 6250 } },
400	{ 0x65, { 214000, 139500, 6250 } },
401	{ 0xe4, { 234000, 139500, 6250 } },
402	{ 0x50, { 255000, 147000, 6375 } },
403	{ 0x51, { 273500, 147000, 6375 } },
404	{ 0x4f, { 292000, 147000, 6375 } },
405	{ 0x62, { 311200, 139500, 6250 } },
406	{ 0x63, { 327900, 139500, 6250 } },
407	{ 0x58, { 344600, 130500, 6125 } },
408};
409
410struct tux_driver_data_t {
411	struct hid_device *hdev;
412};
413
414struct tux_hdev_driver_data_t {
415	u8 lamp_count;
416	const struct tux_kbl_map_entry_t *kbl_map;
417	u8 next_lamp_id;
418	union tux_wmi_xx_496in_80out_in_t next_kbl_set_multiple_keys_in;
419};
420
421static int tux_ll_start(struct hid_device *hdev)
422{
423	struct wmi_device *wdev = to_wmi_device(hdev->dev.parent);
424	struct tux_hdev_driver_data_t *driver_data;
425	union tux_wmi_xx_8in_80out_out_t out;
426	union tux_wmi_xx_8in_80out_in_t in;
427	u8 keyboard_type;
428	int ret;
429
430	driver_data = devm_kzalloc(&hdev->dev, sizeof(*driver_data), GFP_KERNEL);
431	if (!driver_data)
432		return -ENOMEM;
433
434	in.get_device_status_in.device_type = TUX_GET_DEVICE_STATUS_DEVICE_ID_KEYBOARD;
435	ret = tux_wmi_xx_8in_80out(wdev, TUX_GET_DEVICE_STATUS, &in, &out);
436	if (ret)
437		return ret;
438
439	keyboard_type = out.get_device_status_out.keyboard_physical_layout;
440	if (keyboard_type == TUX_GET_DEVICE_STATUS_KEYBOARD_LAYOUT_ANSII) {
441		driver_data->lamp_count = ARRAY_SIZE(sirius_16_ansii_kbl_map);
442		driver_data->kbl_map = sirius_16_ansii_kbl_map;
443	} else if (keyboard_type == TUX_GET_DEVICE_STATUS_KEYBOARD_LAYOUT_ISO) {
444		driver_data->lamp_count = ARRAY_SIZE(sirius_16_iso_kbl_map);
445		driver_data->kbl_map = sirius_16_iso_kbl_map;
446	} else {
447		return -EINVAL;
448	}
449	driver_data->next_lamp_id = 0;
450
451	dev_set_drvdata(&hdev->dev, driver_data);
452
453	return ret;
454}
455
456static void tux_ll_stop(struct hid_device *hdev __always_unused)
457{
458}
459
460static int tux_ll_open(struct hid_device *hdev __always_unused)
461{
462	return 0;
463}
464
465static void tux_ll_close(struct hid_device *hdev __always_unused)
466{
467}
468
469static int tux_ll_parse(struct hid_device *hdev)
470{
471	return hid_parse_report(hdev, tux_report_descriptor,
472				sizeof(tux_report_descriptor));
473}
474
475struct __packed lamp_array_attributes_report_t {
476	const u8 report_id;
477	u16 lamp_count;
478	u32 bounding_box_width_in_micrometers;
479	u32 bounding_box_height_in_micrometers;
480	u32 bounding_box_depth_in_micrometers;
481	u32 lamp_array_kind;
482	u32 min_update_interval_in_microseconds;
483};
484
485static int handle_lamp_array_attributes_report(struct hid_device *hdev,
486					       struct lamp_array_attributes_report_t *rep)
487{
488	struct tux_hdev_driver_data_t *driver_data = dev_get_drvdata(&hdev->dev);
489
490	rep->lamp_count = driver_data->lamp_count;
491	rep->bounding_box_width_in_micrometers = 368000;
492	rep->bounding_box_height_in_micrometers = 266000;
493	rep->bounding_box_depth_in_micrometers = 30000;
494	/*
495	 * LampArrayKindKeyboard, see "26.2.1 LampArrayKind Values" of
496	 * "HID Usage Tables v1.5"
497	 */
498	rep->lamp_array_kind = 1;
499	// Some guessed value for interval microseconds
500	rep->min_update_interval_in_microseconds = 500;
501
502	return sizeof(*rep);
503}
504
505struct __packed lamp_attributes_request_report_t {
506	const u8 report_id;
507	u16 lamp_id;
508};
509
510static int handle_lamp_attributes_request_report(struct hid_device *hdev,
511						 struct lamp_attributes_request_report_t *rep)
512{
513	struct tux_hdev_driver_data_t *driver_data = dev_get_drvdata(&hdev->dev);
514
515	if (rep->lamp_id < driver_data->lamp_count)
516		driver_data->next_lamp_id = rep->lamp_id;
517	else
518		driver_data->next_lamp_id = 0;
519
520	return sizeof(*rep);
521}
522
523struct __packed lamp_attributes_response_report_t {
524	const u8 report_id;
525	u16 lamp_id;
526	u32 position_x_in_micrometers;
527	u32 position_y_in_micrometers;
528	u32 position_z_in_micrometers;
529	u32 update_latency_in_microseconds;
530	u32 lamp_purpose;
531	u8 red_level_count;
532	u8 green_level_count;
533	u8 blue_level_count;
534	u8 intensity_level_count;
535	u8 is_programmable;
536	u8 input_binding;
537};
538
539static int handle_lamp_attributes_response_report(struct hid_device *hdev,
540						  struct lamp_attributes_response_report_t *rep)
541{
542	struct tux_hdev_driver_data_t *driver_data = dev_get_drvdata(&hdev->dev);
543	u16 lamp_id = driver_data->next_lamp_id;
544
545	rep->lamp_id = lamp_id;
546	// Some guessed value for latency microseconds
547	rep->update_latency_in_microseconds = 100;
548	/*
549	 * LampPurposeControl, see "26.3.1 LampPurposes Flags" of
550	 * "HID Usage Tables v1.5"
551	 */
552	rep->lamp_purpose = 1;
553	rep->red_level_count = 0xff;
554	rep->green_level_count = 0xff;
555	rep->blue_level_count = 0xff;
556	rep->intensity_level_count = 0xff;
557	rep->is_programmable = 1;
558
559	if (driver_data->kbl_map[lamp_id].code <= 0xe8) {
560		rep->input_binding = driver_data->kbl_map[lamp_id].code;
561	} else {
562		/*
563		 * Everything bigger is reserved/undefined, see
564		 * "10 Keyboard/Keypad Page (0x07)" of "HID Usage Tables v1.5"
565		 * and should return 0, see "26.8.3 Lamp Attributes" of the same
566		 * document.
567		 */
568		rep->input_binding = 0;
569	}
570	rep->position_x_in_micrometers = driver_data->kbl_map[lamp_id].pos.x;
571	rep->position_y_in_micrometers = driver_data->kbl_map[lamp_id].pos.y;
572	rep->position_z_in_micrometers = driver_data->kbl_map[lamp_id].pos.z;
573
574	driver_data->next_lamp_id = (driver_data->next_lamp_id + 1) % driver_data->lamp_count;
575
576	return sizeof(*rep);
577}
578
579#define LAMP_UPDATE_FLAGS_LAMP_UPDATE_COMPLETE	BIT(0)
580
581struct __packed lamp_rgbi_tuple_t {
582	u8 red;
583	u8 green;
584	u8 blue;
585	u8 intensity;
586};
587
588#define LAMP_MULTI_UPDATE_REPORT_LAMP_COUNT_MAX	8
589
590struct __packed lamp_multi_update_report_t {
591	const u8 report_id;
592	u8 lamp_count;
593	u8 lamp_update_flags;
594	u16 lamp_id[LAMP_MULTI_UPDATE_REPORT_LAMP_COUNT_MAX];
595	struct lamp_rgbi_tuple_t update_channels[LAMP_MULTI_UPDATE_REPORT_LAMP_COUNT_MAX];
596};
597
598static int handle_lamp_multi_update_report(struct hid_device *hdev,
599					   struct lamp_multi_update_report_t *rep)
600{
601	struct tux_hdev_driver_data_t *driver_data = dev_get_drvdata(&hdev->dev);
602	union tux_wmi_xx_496in_80out_in_t *next = &driver_data->next_kbl_set_multiple_keys_in;
603	struct tux_kbl_set_multiple_keys_in_rgb_config_t *rgb_configs_j;
604	struct wmi_device *wdev = to_wmi_device(hdev->dev.parent);
605	union tux_wmi_xx_496in_80out_out_t out;
606	u8 key_id, key_id_j, intensity_i, red_i, green_i, blue_i;
607	int ret;
608
609	/*
610	 * Catching misformatted lamp_multi_update_report and fail silently
611	 * according to "HID Usage Tables v1.5"
612	 */
613	for (unsigned int i = 0; i < rep->lamp_count; ++i) {
614		if (rep->lamp_id[i] > driver_data->lamp_count) {
615			hid_dbg(hdev, "Out of bounds lamp_id in lamp_multi_update_report. Skipping whole report!\n");
616			return sizeof(*rep);
617		}
618
619		for (unsigned int j = i + 1; j < rep->lamp_count; ++j) {
620			if (rep->lamp_id[i] == rep->lamp_id[j]) {
621				hid_dbg(hdev, "Duplicate lamp_id in lamp_multi_update_report. Skipping whole report!\n");
622				return sizeof(*rep);
623			}
624		}
625	}
626
627	for (unsigned int i = 0; i < rep->lamp_count; ++i) {
628		key_id = driver_data->kbl_map[rep->lamp_id[i]].code;
629
630		for (unsigned int j = 0;
631		     j < TUX_KBL_SET_MULTIPLE_KEYS_LIGHTING_SETTINGS_COUNT_MAX;
632		     ++j) {
633			rgb_configs_j = &next->kbl_set_multiple_keys_in.rgb_configs[j];
634			key_id_j = rgb_configs_j->key_id;
635			if (key_id_j != 0x00 && key_id_j != key_id)
636				continue;
637
638			if (key_id_j == 0x00)
639				next->kbl_set_multiple_keys_in.rgb_configs_cnt =
640					j + 1;
641			rgb_configs_j->key_id = key_id;
642			/*
643			 * While this driver respects update_channel.intensity
644			 * according to "HID Usage Tables v1.5" also on RGB
645			 * leds, the Microsoft MacroPad reference implementation
646			 * (https://github.com/microsoft/RP2040MacropadHidSample
647			 * 1d6c3ad) does not and ignores it. If it turns out
648			 * that Windows writes intensity = 0 for RGB leds
649			 * instead of intensity = 255, this driver should also
650			 * ignore the update_channel.intensity.
651			 */
652			intensity_i = rep->update_channels[i].intensity;
653			red_i = rep->update_channels[i].red;
654			green_i = rep->update_channels[i].green;
655			blue_i = rep->update_channels[i].blue;
656			rgb_configs_j->red = red_i * intensity_i / 0xff;
657			rgb_configs_j->green = green_i * intensity_i / 0xff;
658			rgb_configs_j->blue = blue_i * intensity_i / 0xff;
659
660			break;
661		}
662	}
663
664	if (rep->lamp_update_flags & LAMP_UPDATE_FLAGS_LAMP_UPDATE_COMPLETE) {
665		ret = tux_wmi_xx_496in_80out(wdev, TUX_KBL_SET_MULTIPLE_KEYS,
666					     next, &out);
667		memset(next, 0, sizeof(*next));
668		if (ret)
669			return ret;
670	}
671
672	return sizeof(*rep);
673}
674
675struct __packed lamp_range_update_report_t {
676	const u8 report_id;
677	u8 lamp_update_flags;
678	u16 lamp_id_start;
679	u16 lamp_id_end;
680	struct lamp_rgbi_tuple_t update_channel;
681};
682
683static int handle_lamp_range_update_report(struct hid_device *hdev,
684					   struct lamp_range_update_report_t *rep)
685{
686	struct tux_hdev_driver_data_t *driver_data = dev_get_drvdata(&hdev->dev);
687	struct lamp_multi_update_report_t lamp_multi_update_report = {
688		.report_id = LAMP_MULTI_UPDATE_REPORT_ID,
689	};
690	struct lamp_rgbi_tuple_t *update_channels_j;
691	int ret;
692
693	/*
694	 * Catching misformatted lamp_range_update_report and fail silently
695	 * according to "HID Usage Tables v1.5"
696	 */
697	if (rep->lamp_id_start > rep->lamp_id_end) {
698		hid_dbg(hdev, "lamp_id_start > lamp_id_end in lamp_range_update_report. Skipping whole report!\n");
699		return sizeof(*rep);
700	}
701
702	if (rep->lamp_id_end > driver_data->lamp_count - 1) {
703		hid_dbg(hdev, "Out of bounds lamp_id_end in lamp_range_update_report. Skipping whole report!\n");
704		return sizeof(*rep);
705	}
706
707	/*
708	 * Break handle_lamp_range_update_report call down to multiple
709	 * handle_lamp_multi_update_report calls to easily ensure that mixing
710	 * handle_lamp_range_update_report and handle_lamp_multi_update_report
711	 * does not break things.
712	 */
713	for (unsigned int i = rep->lamp_id_start; i < rep->lamp_id_end + 1;
714	     i = i + LAMP_MULTI_UPDATE_REPORT_LAMP_COUNT_MAX) {
715		lamp_multi_update_report.lamp_count =
716			min(rep->lamp_id_end + 1 - i,
717			    LAMP_MULTI_UPDATE_REPORT_LAMP_COUNT_MAX);
718		lamp_multi_update_report.lamp_update_flags =
719			i + LAMP_MULTI_UPDATE_REPORT_LAMP_COUNT_MAX >=
720			rep->lamp_id_end + 1 ?
721				LAMP_UPDATE_FLAGS_LAMP_UPDATE_COMPLETE : 0;
722
723		for (unsigned int j = 0; j < lamp_multi_update_report.lamp_count; ++j) {
724			lamp_multi_update_report.lamp_id[j] = i + j;
725			update_channels_j =
726				&lamp_multi_update_report.update_channels[j];
727			update_channels_j->red = rep->update_channel.red;
728			update_channels_j->green = rep->update_channel.green;
729			update_channels_j->blue = rep->update_channel.blue;
730			update_channels_j->intensity = rep->update_channel.intensity;
731		}
732
733		ret = handle_lamp_multi_update_report(hdev, &lamp_multi_update_report);
734		if (ret < 0)
735			return ret;
736		if (ret != sizeof(lamp_multi_update_report))
737			return -EIO;
738	}
739
740	return sizeof(*rep);
741}
742
743struct __packed lamp_array_control_report_t {
744	const u8 report_id;
745	u8 autonomous_mode;
746};
747
748static int handle_lamp_array_control_report(struct hid_device *hdev __always_unused,
749					    struct lamp_array_control_report_t *rep)
750{
751	/*
752	 * The keyboards firmware doesn't have any built in controls and the
753	 * built in effects are not implemented so this is a NOOP.
754	 * According to the HID Documentation (HID Usage Tables v1.5) this
755	 * function is optional and can be removed from the HID Report
756	 * Descriptor, but it should first be confirmed that userspace respects
757	 * this possibility too. The Microsoft MacroPad reference implementation
758	 * (https://github.com/microsoft/RP2040MacropadHidSample 1d6c3ad)
759	 * already deviates from the spec at another point, see
760	 * handle_lamp_*_update_report.
761	 */
762
763	return sizeof(*rep);
764}
765
766static int tux_ll_raw_request(struct hid_device *hdev, u8 reportnum, u8 *buf,
767			      size_t len, unsigned char rtype, int reqtype)
768{
769	if (rtype != HID_FEATURE_REPORT)
770		return -EINVAL;
771
772	switch (reqtype) {
773	case HID_REQ_GET_REPORT:
774		switch (reportnum) {
775		case LAMP_ARRAY_ATTRIBUTES_REPORT_ID:
776			if (len != sizeof(struct lamp_array_attributes_report_t))
777				return -EINVAL;
778			return handle_lamp_array_attributes_report(hdev,
779				(struct lamp_array_attributes_report_t *)buf);
780		case LAMP_ATTRIBUTES_RESPONSE_REPORT_ID:
781			if (len != sizeof(struct lamp_attributes_response_report_t))
782				return -EINVAL;
783			return handle_lamp_attributes_response_report(hdev,
784				(struct lamp_attributes_response_report_t *)buf);
785		}
786		break;
787	case HID_REQ_SET_REPORT:
788		switch (reportnum) {
789		case LAMP_ATTRIBUTES_REQUEST_REPORT_ID:
790			if (len != sizeof(struct lamp_attributes_request_report_t))
791				return -EINVAL;
792			return handle_lamp_attributes_request_report(hdev,
793				(struct lamp_attributes_request_report_t *)buf);
794		case LAMP_MULTI_UPDATE_REPORT_ID:
795			if (len != sizeof(struct lamp_multi_update_report_t))
796				return -EINVAL;
797			return handle_lamp_multi_update_report(hdev,
798				(struct lamp_multi_update_report_t *)buf);
799		case LAMP_RANGE_UPDATE_REPORT_ID:
800			if (len != sizeof(struct lamp_range_update_report_t))
801				return -EINVAL;
802			return handle_lamp_range_update_report(hdev,
803				(struct lamp_range_update_report_t *)buf);
804		case LAMP_ARRAY_CONTROL_REPORT_ID:
805			if (len != sizeof(struct lamp_array_control_report_t))
806				return -EINVAL;
807			return handle_lamp_array_control_report(hdev,
808				(struct lamp_array_control_report_t *)buf);
809		}
810		break;
811	}
812
813	return -EINVAL;
814}
815
816static const struct hid_ll_driver tux_ll_driver = {
817	.start = &tux_ll_start,
818	.stop = &tux_ll_stop,
819	.open = &tux_ll_open,
820	.close = &tux_ll_close,
821	.parse = &tux_ll_parse,
822	.raw_request = &tux_ll_raw_request,
823};
824
825static int tux_virt_lamparray_add_device(struct wmi_device *wdev,
826					 struct hid_device **hdev_out)
827{
828	struct hid_device *hdev;
829	int ret;
830
831	dev_dbg(&wdev->dev, "Adding TUXEDO NB04 Virtual LampArray device.\n");
832
833	hdev = hid_allocate_device();
834	if (IS_ERR(hdev))
835		return PTR_ERR(hdev);
836	*hdev_out = hdev;
837
838	strscpy(hdev->name, "TUXEDO NB04 RGB Lighting", sizeof(hdev->name));
839
840	hdev->ll_driver = &tux_ll_driver;
841	hdev->bus = BUS_VIRTUAL;
842	hdev->vendor = 0x21ba;
843	hdev->product = 0x0400;
844	hdev->dev.parent = &wdev->dev;
845
846	ret = hid_add_device(hdev);
847	if (ret)
848		hid_destroy_device(hdev);
849	return ret;
850}
851
852static int tux_probe(struct wmi_device *wdev, const void *context __always_unused)
853{
854	struct tux_driver_data_t *driver_data;
855
856	driver_data = devm_kzalloc(&wdev->dev, sizeof(*driver_data), GFP_KERNEL);
857	if (!driver_data)
858		return -ENOMEM;
859
860	dev_set_drvdata(&wdev->dev, driver_data);
861
862	return tux_virt_lamparray_add_device(wdev, &driver_data->hdev);
863}
864
865static void tux_remove(struct wmi_device *wdev)
866{
867	struct tux_driver_data_t *driver_data = dev_get_drvdata(&wdev->dev);
868
869	hid_destroy_device(driver_data->hdev);
870}
871
872static struct wmi_driver tuxedo_nb04_wmi_tux_driver = {
873	.driver = {
874		.name = "tuxedo_nb04_wmi_ab",
875		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
876	},
877	.id_table = tuxedo_nb04_wmi_ab_device_ids,
878	.probe = tux_probe,
879	.remove = tux_remove,
880	.no_singleton = true,
881};
882
883/*
884 * We don't know if the WMI API is stable and how unique the GUID is for this
885 * ODM. To be on the safe side we therefore only run this driver on tested
886 * devices defined by this list.
887 */
888static const struct dmi_system_id tested_devices_dmi_table[] __initconst = {
889	{
890		// TUXEDO Sirius 16 Gen1
891		.matches = {
892			DMI_EXACT_MATCH(DMI_SYS_VENDOR, "TUXEDO"),
893			DMI_EXACT_MATCH(DMI_BOARD_NAME, "APX958"),
894		},
895	},
896	{
897		// TUXEDO Sirius 16 Gen2
898		.matches = {
899			DMI_EXACT_MATCH(DMI_SYS_VENDOR, "TUXEDO"),
900			DMI_EXACT_MATCH(DMI_BOARD_NAME, "AHP958"),
901		},
902	},
903	{ }
904};
905
906static int __init tuxedo_nb04_wmi_tux_init(void)
907{
908	if (!dmi_check_system(tested_devices_dmi_table))
909		return -ENODEV;
910
911	return wmi_driver_register(&tuxedo_nb04_wmi_tux_driver);
912}
913module_init(tuxedo_nb04_wmi_tux_init);
914
915static void __exit tuxedo_nb04_wmi_tux_exit(void)
916{
917	return wmi_driver_unregister(&tuxedo_nb04_wmi_tux_driver);
918}
919module_exit(tuxedo_nb04_wmi_tux_exit);
920
921MODULE_DESCRIPTION("Virtual HID LampArray interface for TUXEDO NB04 devices");
922MODULE_AUTHOR("Werner Sembach <wse@tuxedocomputers.com>");
923MODULE_LICENSE("GPL");