Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Input: cypress_ps2 - use u8 when dealing with byte data
When dealing with byte data use u8 instead of unsigned char or int.
Stop layering error handling in cypress_ps2_sendbyte() and simply
pass on error code from ps2_sendbyte().
Additionally use u8 instead of unisgned char throughout the code.
Link: https://lore.kernel.org/r/20240628224728.2180126-5-dmitry.torokhov@gmail.com
Signed-off-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>
+33
-43
+33
-43
drivers/input/mouse/cypress_ps2.c
+33
-43
drivers/input/mouse/cypress_ps2.c
···
32
32
cytp->pkt_size = n;
33
33
}
34
34
35
-
static const unsigned char cytp_rate[] = {10, 20, 40, 60, 100, 200};
36
-
static const unsigned char cytp_resolution[] = {0x00, 0x01, 0x02, 0x03};
35
+
static const u8 cytp_rate[] = {10, 20, 40, 60, 100, 200};
36
+
static const u8 cytp_resolution[] = {0x00, 0x01, 0x02, 0x03};
37
37
38
-
static int cypress_ps2_sendbyte(struct psmouse *psmouse, int value)
38
+
static int cypress_ps2_sendbyte(struct psmouse *psmouse, u8 cmd)
39
39
{
40
40
struct ps2dev *ps2dev = &psmouse->ps2dev;
41
41
int error;
42
42
43
-
error = ps2_sendbyte(ps2dev, value & 0xff, CYTP_CMD_TIMEOUT);
43
+
error = ps2_sendbyte(ps2dev, cmd, CYTP_CMD_TIMEOUT);
44
44
if (error) {
45
45
psmouse_dbg(psmouse,
46
46
"sending command 0x%02x failed, resp 0x%02x, error %d\n",
47
-
value & 0xff, ps2dev->nak, error);
47
+
cmd, ps2dev->nak, error);
48
48
return error;
49
49
}
50
50
51
51
#ifdef CYTP_DEBUG_VERBOSE
52
-
psmouse_dbg(psmouse, "sending command 0x%02x succeeded, resp 0xfa\n",
53
-
value & 0xff);
52
+
psmouse_dbg(psmouse, "sending command 0x%02x succeeded\n", cmd);
54
53
#endif
55
54
56
55
return 0;
57
56
}
58
57
59
-
static int cypress_ps2_ext_cmd(struct psmouse *psmouse, unsigned short cmd,
60
-
unsigned char data)
58
+
static int cypress_ps2_ext_cmd(struct psmouse *psmouse, u8 prefix, u8 nibble)
61
59
{
62
60
struct ps2dev *ps2dev = &psmouse->ps2dev;
63
61
int tries = CYTP_PS2_CMD_TRIES;
···
69
71
* If sending the command fails, send recovery command
70
72
* to make the device return to the ready state.
71
73
*/
72
-
rc = cypress_ps2_sendbyte(psmouse, cmd & 0xff);
74
+
rc = cypress_ps2_sendbyte(psmouse, prefix);
73
75
if (rc == -EAGAIN) {
74
76
rc = cypress_ps2_sendbyte(psmouse, 0x00);
75
77
if (rc == -EAGAIN)
···
77
79
}
78
80
79
81
if (!rc) {
80
-
rc = cypress_ps2_sendbyte(psmouse, data);
82
+
rc = cypress_ps2_sendbyte(psmouse, nibble);
81
83
if (rc == -EAGAIN)
82
-
rc = cypress_ps2_sendbyte(psmouse, data);
84
+
rc = cypress_ps2_sendbyte(psmouse, nibble);
83
85
84
86
if (!rc)
85
87
break;
···
92
94
}
93
95
94
96
static int cypress_ps2_read_cmd_status(struct psmouse *psmouse,
95
-
unsigned char cmd,
96
-
unsigned char *param)
97
+
u8 cmd, u8 *param)
97
98
{
98
99
struct ps2dev *ps2dev = &psmouse->ps2dev;
99
100
enum psmouse_state old_state;
···
108
111
pktsize = (cmd == CYTP_CMD_READ_TP_METRICS) ? 8 : 3;
109
112
memset(param, 0, pktsize);
110
113
111
-
rc = cypress_ps2_sendbyte(psmouse, 0xe9);
114
+
rc = cypress_ps2_sendbyte(psmouse, PSMOUSE_CMD_GETINFO & 0xff);
112
115
if (rc)
113
116
goto out;
114
117
···
133
136
return rc;
134
137
}
135
138
136
-
static bool cypress_verify_cmd_state(struct psmouse *psmouse,
137
-
unsigned char cmd, unsigned char *param)
139
+
static bool cypress_verify_cmd_state(struct psmouse *psmouse, u8 cmd, u8* param)
138
140
{
139
141
bool rate_match = false;
140
142
bool resolution_match = false;
···
163
167
return false;
164
168
}
165
169
166
-
static int cypress_send_ext_cmd(struct psmouse *psmouse, unsigned char cmd,
167
-
unsigned char *param)
170
+
static int cypress_send_ext_cmd(struct psmouse *psmouse, u8 cmd, u8 *param)
168
171
{
172
+
u8 cmd_prefix = PSMOUSE_CMD_SETRES & 0xff;
169
173
int tries = CYTP_PS2_CMD_TRIES;
170
-
int rc;
174
+
int error;
171
175
172
176
psmouse_dbg(psmouse, "send extension cmd 0x%02x, [%d %d %d %d]\n",
173
177
cmd, DECODE_CMD_AA(cmd), DECODE_CMD_BB(cmd),
174
178
DECODE_CMD_CC(cmd), DECODE_CMD_DD(cmd));
175
179
176
180
do {
177
-
cypress_ps2_ext_cmd(psmouse,
178
-
PSMOUSE_CMD_SETRES, DECODE_CMD_DD(cmd));
179
-
cypress_ps2_ext_cmd(psmouse,
180
-
PSMOUSE_CMD_SETRES, DECODE_CMD_CC(cmd));
181
-
cypress_ps2_ext_cmd(psmouse,
182
-
PSMOUSE_CMD_SETRES, DECODE_CMD_BB(cmd));
183
-
cypress_ps2_ext_cmd(psmouse,
184
-
PSMOUSE_CMD_SETRES, DECODE_CMD_AA(cmd));
181
+
cypress_ps2_ext_cmd(psmouse, cmd_prefix, DECODE_CMD_DD(cmd));
182
+
cypress_ps2_ext_cmd(psmouse, cmd_prefix, DECODE_CMD_CC(cmd));
183
+
cypress_ps2_ext_cmd(psmouse, cmd_prefix, DECODE_CMD_BB(cmd));
184
+
cypress_ps2_ext_cmd(psmouse, cmd_prefix, DECODE_CMD_AA(cmd));
185
185
186
-
rc = cypress_ps2_read_cmd_status(psmouse, cmd, param);
187
-
if (rc)
188
-
continue;
189
-
190
-
if (cypress_verify_cmd_state(psmouse, cmd, param))
186
+
error = cypress_ps2_read_cmd_status(psmouse, cmd, param);
187
+
if (!error && cypress_verify_cmd_state(psmouse, cmd, param))
191
188
return 0;
192
189
193
190
} while (--tries > 0);
···
190
201
191
202
int cypress_detect(struct psmouse *psmouse, bool set_properties)
192
203
{
193
-
unsigned char param[3];
204
+
u8 param[3];
194
205
195
206
if (cypress_send_ext_cmd(psmouse, CYTP_CMD_READ_CYPRESS_ID, param))
196
207
return -ENODEV;
···
210
221
static int cypress_read_fw_version(struct psmouse *psmouse)
211
222
{
212
223
struct cytp_data *cytp = psmouse->private;
213
-
unsigned char param[3];
224
+
u8 param[3];
214
225
215
226
if (cypress_send_ext_cmd(psmouse, CYTP_CMD_READ_CYPRESS_ID, param))
216
227
return -ENODEV;
···
239
250
static int cypress_read_tp_metrics(struct psmouse *psmouse)
240
251
{
241
252
struct cytp_data *cytp = psmouse->private;
242
-
unsigned char param[8];
253
+
u8 param[8];
243
254
244
255
/* set default values for tp metrics. */
245
256
cytp->tp_width = CYTP_DEFAULT_WIDTH;
···
327
338
static int cypress_set_absolute_mode(struct psmouse *psmouse)
328
339
{
329
340
struct cytp_data *cytp = psmouse->private;
330
-
unsigned char param[3];
341
+
u8 param[3];
331
342
int error;
332
343
333
344
error = cypress_send_ext_cmd(psmouse, CYTP_CMD_ABS_WITH_PRESSURE_MODE,
···
407
418
return 0;
408
419
}
409
420
410
-
static int cypress_get_finger_count(unsigned char header_byte)
421
+
static int cypress_get_finger_count(u8 header_byte)
411
422
{
412
-
unsigned char bits6_7;
423
+
u8 bits6_7;
413
424
int finger_count;
414
425
415
426
bits6_7 = header_byte >> 6;
···
434
445
435
446
436
447
static int cypress_parse_packet(struct psmouse *psmouse,
437
-
struct cytp_data *cytp, struct cytp_report_data *report_data)
448
+
struct cytp_data *cytp,
449
+
struct cytp_report_data *report_data)
438
450
{
439
-
unsigned char *packet = psmouse->packet;
440
-
unsigned char header_byte = packet[0];
451
+
u8 *packet = psmouse->packet;
452
+
u8 header_byte = packet[0];
441
453
442
454
memset(report_data, 0, sizeof(struct cytp_report_data));
443
455
···
553
563
{
554
564
int contact_cnt;
555
565
int index = psmouse->pktcnt - 1;
556
-
unsigned char *packet = psmouse->packet;
566
+
u8 *packet = psmouse->packet;
557
567
struct cytp_data *cytp = psmouse->private;
558
568
559
569
if (index < 0 || index > cytp->pkt_size)