mk-rootfs.sh

hc

2023-12-11 072de836f53be56a70cecf70b43ae43b7ce17376

 kernel/drivers/media/rc/ir-mce_kbd-decoder.c
..
..
@@ -1,18 +1,10 @@
1
+// SPDX-License-Identifier: GPL-2.0-only
1
2
 /* ir-mce_kbd-decoder.c - A decoder for the RC6-ish keyboard/mouse IR protocol
2
3
  * used by the Microsoft Remote Keyboard for Windows Media Center Edition,
3
4
  * referred to by Microsoft's Windows Media Center remote specification docs
4
5
  * as "an internal protocol called MCIR-2".
5
6
  *
6
7
  * Copyright (C) 2011 by Jarod Wilson <jarod@redhat.com>
7
- *
8
- * This program is free software; you can redistribute it and/or modify
9
- * it under the terms of the GNU General Public License as published by
10
- * the Free Software Foundation version 2 of the License.
11
- *
12
- * This program is distributed in the hope that it will be useful,
13
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
- * GNU General Public License for more details.
16
8
  */
17
9
 #include <linux/module.h>
18
10
 
..
..
@@ -29,7 +21,7 @@
29
21
  * input device for the remote, rather than the keyboard/mouse one.
30
22
  */
31
23
 
32
-#define MCIR2_UNIT		333333	/* ns */
24
+#define MCIR2_UNIT		333	/* us */
33
25
 #define MCIR2_HEADER_NBITS	5
34
26
 #define MCIR2_MOUSE_NBITS	29
35
27
 #define MCIR2_KEYBOARD_NBITS	32
..
..
@@ -129,13 +121,14 @@
129
121
 	if (time_is_before_eq_jiffies(raw->mce_kbd.rx_timeout.expires)) {
130
122
 		for (i = 0; i < 7; i++) {
131
123
 			maskcode = kbd_keycodes[MCIR2_MASK_KEYS_START + i];
132
-			input_report_key(raw->mce_kbd.idev, maskcode, 0);
124
+			input_report_key(raw->dev->input_dev, maskcode, 0);
133
125
 		}
134
126
 
135
127
 		for (i = 0; i < MCIR2_MASK_KEYS_START; i++)
136
-			input_report_key(raw->mce_kbd.idev, kbd_keycodes[i], 0);
128
+			input_report_key(raw->dev->input_dev, kbd_keycodes[i],
129
+					 0);
137
130
 
138
-		input_sync(raw->mce_kbd.idev);
131
+		input_sync(raw->dev->input_dev);
139
132
 	}
140
133
 	spin_unlock_irqrestore(&raw->mce_kbd.keylock, flags);
141
134
 }
..
..
@@ -154,7 +147,6 @@
154
147
 
155
148
 static void ir_mce_kbd_process_keyboard_data(struct rc_dev *dev, u32 scancode)
156
149
 {
157
-	struct mce_kbd_dec *data = &dev->raw->mce_kbd;
158
150
 	u8 keydata1  = (scancode >> 8) & 0xff;
159
151
 	u8 keydata2  = (scancode >> 16) & 0xff;
160
152
 	u8 shiftmask = scancode & 0xff;
..
..
@@ -170,23 +162,22 @@
170
162
 			keystate = 1;
171
163
 		else
172
164
 			keystate = 0;
173
-		input_report_key(data->idev, maskcode, keystate);
165
+		input_report_key(dev->input_dev, maskcode, keystate);
174
166
 	}
175
167
 
176
168
 	if (keydata1)
177
-		input_report_key(data->idev, kbd_keycodes[keydata1], 1);
169
+		input_report_key(dev->input_dev, kbd_keycodes[keydata1], 1);
178
170
 	if (keydata2)
179
-		input_report_key(data->idev, kbd_keycodes[keydata2], 1);
171
+		input_report_key(dev->input_dev, kbd_keycodes[keydata2], 1);
180
172
 
181
173
 	if (!keydata1 && !keydata2) {
182
174
 		for (i = 0; i < MCIR2_MASK_KEYS_START; i++)
183
-			input_report_key(data->idev, kbd_keycodes[i], 0);
175
+			input_report_key(dev->input_dev, kbd_keycodes[i], 0);
184
176
 	}
185
177
 }
186
178
 
187
179
 static void ir_mce_kbd_process_mouse_data(struct rc_dev *dev, u32 scancode)
188
180
 {
189
-	struct mce_kbd_dec *data = &dev->raw->mce_kbd;
190
181
 	/* raw mouse coordinates */
191
182
 	u8 xdata = (scancode >> 7) & 0x7f;
192
183
 	u8 ydata = (scancode >> 14) & 0x7f;
..
..
@@ -208,11 +199,11 @@
208
199
 	dev_dbg(&dev->dev, "mouse: x = %d, y = %d, btns = %s%s\n",
209
200
 		x, y, left ? "L" : "", right ? "R" : "");
210
201
 
211
-	input_report_rel(data->idev, REL_X, x);
212
-	input_report_rel(data->idev, REL_Y, y);
202
+	input_report_rel(dev->input_dev, REL_X, x);
203
+	input_report_rel(dev->input_dev, REL_Y, y);
213
204
 
214
-	input_report_key(data->idev, BTN_LEFT, left);
215
-	input_report_key(data->idev, BTN_RIGHT, right);
205
+	input_report_key(dev->input_dev, BTN_LEFT, left);
206
+	input_report_key(dev->input_dev, BTN_RIGHT, right);
216
207
 }
217
208
 
218
209
 /**
..
..
@@ -240,7 +231,7 @@
240
231
 
241
232
 again:
242
233
 	dev_dbg(&dev->dev, "started at state %i (%uus %s)\n",
243
-		data->state, TO_US(ev.duration), TO_STR(ev.pulse));
234
+		data->state, ev.duration, TO_STR(ev.pulse));
244
235
 
245
236
 	if (!geq_margin(ev.duration, MCIR2_UNIT, MCIR2_UNIT / 2))
246
237
 		return 0;
..
..
@@ -329,7 +320,7 @@
329
320
 				data->body);
330
321
 			spin_lock(&data->keylock);
331
322
 			if (scancode) {
332
-				delay = nsecs_to_jiffies(dev->timeout) +
323
+				delay = usecs_to_jiffies(dev->timeout) +
333
324
 					msecs_to_jiffies(100);
334
325
 				mod_timer(&data->rx_timeout, jiffies + delay);
335
326
 			} else {
..
..
@@ -353,16 +344,16 @@
353
344
 		}
354
345
 
355
346
 		lsc.scancode = scancode;
356
-		ir_lirc_scancode_event(dev, &lsc);
347
+		lirc_scancode_event(dev, &lsc);
357
348
 		data->state = STATE_INACTIVE;
358
-		input_event(data->idev, EV_MSC, MSC_SCAN, scancode);
359
-		input_sync(data->idev);
349
+		input_event(dev->input_dev, EV_MSC, MSC_SCAN, scancode);
350
+		input_sync(dev->input_dev);
360
351
 		return 0;
361
352
 	}
362
353
 
363
354
 out:
364
355
 	dev_dbg(&dev->dev, "failed at state %i (%uus %s)\n",
365
-		data->state, TO_US(ev.duration), TO_STR(ev.pulse));
356
+		data->state, ev.duration, TO_STR(ev.pulse));
366
357
 	data->state = STATE_INACTIVE;
367
358
 	return -EINVAL;
368
359
 }
..
..
@@ -370,55 +361,9 @@
370
361
 static int ir_mce_kbd_register(struct rc_dev *dev)
371
362
 {
372
363
 	struct mce_kbd_dec *mce_kbd = &dev->raw->mce_kbd;
373
-	struct input_dev *idev;
374
-	int i, ret;
375
-
376
-	idev = input_allocate_device();
377
-	if (!idev)
378
-		return -ENOMEM;
379
-
380
-	snprintf(mce_kbd->name, sizeof(mce_kbd->name),
381
-		 "MCE IR Keyboard/Mouse (%s)", dev->driver_name);
382
-	strlcat(mce_kbd->phys, "/input0", sizeof(mce_kbd->phys));
383
-
384
-	idev->name = mce_kbd->name;
385
-	idev->phys = mce_kbd->phys;
386
-
387
-	/* Keyboard bits */
388
-	set_bit(EV_KEY, idev->evbit);
389
-	set_bit(EV_REP, idev->evbit);
390
-	for (i = 0; i < sizeof(kbd_keycodes); i++)
391
-		set_bit(kbd_keycodes[i], idev->keybit);
392
-
393
-	/* Mouse bits */
394
-	set_bit(EV_REL, idev->evbit);
395
-	set_bit(REL_X, idev->relbit);
396
-	set_bit(REL_Y, idev->relbit);
397
-	set_bit(BTN_LEFT, idev->keybit);
398
-	set_bit(BTN_RIGHT, idev->keybit);
399
-
400
-	/* Report scancodes too */
401
-	set_bit(EV_MSC, idev->evbit);
402
-	set_bit(MSC_SCAN, idev->mscbit);
403
364
 
404
365
 	timer_setup(&mce_kbd->rx_timeout, mce_kbd_rx_timeout, 0);
405
366
 	spin_lock_init(&mce_kbd->keylock);
406
-
407
-	input_set_drvdata(idev, mce_kbd);
408
-
409
-#if 0
410
-	/* Adding this reference means two input devices are associated with
411
-	 * this rc-core device, which ir-keytable doesn't cope with yet */
412
-	idev->dev.parent = &dev->dev;
413
-#endif
414
-
415
-	ret = input_register_device(idev);
416
-	if (ret < 0) {
417
-		input_free_device(idev);
418
-		return -EIO;
419
-	}
420
-
421
-	mce_kbd->idev = idev;
422
367
 
423
368
 	return 0;
424
369
 }
..
..
@@ -426,10 +371,8 @@
426
371
 static int ir_mce_kbd_unregister(struct rc_dev *dev)
427
372
 {
428
373
 	struct mce_kbd_dec *mce_kbd = &dev->raw->mce_kbd;
429
-	struct input_dev *idev = mce_kbd->idev;
430
374
 
431
375
 	del_timer_sync(&mce_kbd->rx_timeout);
432
-	input_unregister_device(idev);
433
376
 
434
377
 	return 0;
435
378
 }