Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
usb: typec: tcpci: use GENMASK() for TCPC_ROLE_CTRL_CC[12]
All this open-coded shifting and masking is quite hard to read, in
particular the if-statement in tcpci_apply_rc().
Declare TCPC_ROLE_CTRL_CC[12] using GENMASK() which allows using
FIELD_GET() and FIELD_PREP() to arguably make the code more legible.
Signed-off-by: André Draszik <andre.draszik@linaro.org>
Reviewed-by: Heikki Krogerus <heikki.krogerus@linux.intel.com>
Link: https://lore.kernel.org/r/20240710-tcpc-cleanup-v1-4-0ec1f41f4263@linaro.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
authored by
André Draszik
and committed by
Greg Kroah-Hartman
83b254c1
f523aa6d
+43
-52
+3
-2
drivers/usb/typec/anx7411.c
+3
-2
drivers/usb/typec/anx7411.c
···
6
6
* Copyright(c) 2022, Analogix Semiconductor. All rights reserved.
7
7
*
8
8
*/
9
+
#include <linux/bitfield.h>
9
10
#include <linux/gpio/consumer.h>
10
11
#include <linux/i2c.h>
11
12
#include <linux/interrupt.h>
···
885
884
OCM_RESET);
886
885
ret |= anx7411_reg_write(ctx->tcpc_client, ANALOG_CTRL_10, 0x80);
887
886
/* Set TCPC to RD and DRP enable */
888
-
cc1 = TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC1_SHIFT;
889
-
cc2 = TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC2_SHIFT;
887
+
cc1 = FIELD_PREP(TCPC_ROLE_CTRL_CC1, TCPC_ROLE_CTRL_CC_RD);
888
+
cc2 = FIELD_PREP(TCPC_ROLE_CTRL_CC2, TCPC_ROLE_CTRL_CC_RD);
890
889
ret |= anx7411_reg_write(ctx->tcpc_client, TCPC_ROLE_CTRL,
891
890
TCPC_ROLE_CTRL_DRP | cc1 | cc2);
892
891
+33
-40
drivers/usb/typec/tcpm/tcpci.c
+33
-40
drivers/usb/typec/tcpm/tcpci.c
···
104
104
105
105
switch (cc) {
106
106
case TYPEC_CC_RA:
107
-
reg = (TCPC_ROLE_CTRL_CC_RA << TCPC_ROLE_CTRL_CC1_SHIFT) |
108
-
(TCPC_ROLE_CTRL_CC_RA << TCPC_ROLE_CTRL_CC2_SHIFT);
107
+
reg = (FIELD_PREP(TCPC_ROLE_CTRL_CC1, TCPC_ROLE_CTRL_CC_RA)
108
+
| FIELD_PREP(TCPC_ROLE_CTRL_CC2, TCPC_ROLE_CTRL_CC_RA));
109
109
break;
110
110
case TYPEC_CC_RD:
111
-
reg = (TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC1_SHIFT) |
112
-
(TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC2_SHIFT);
111
+
reg = (FIELD_PREP(TCPC_ROLE_CTRL_CC1, TCPC_ROLE_CTRL_CC_RD)
112
+
| FIELD_PREP(TCPC_ROLE_CTRL_CC2, TCPC_ROLE_CTRL_CC_RD));
113
113
break;
114
114
case TYPEC_CC_RP_DEF:
115
-
reg = (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC1_SHIFT) |
116
-
(TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC2_SHIFT) |
117
-
(TCPC_ROLE_CTRL_RP_VAL_DEF <<
118
-
TCPC_ROLE_CTRL_RP_VAL_SHIFT);
115
+
reg = (FIELD_PREP(TCPC_ROLE_CTRL_CC1, TCPC_ROLE_CTRL_CC_RP)
116
+
| FIELD_PREP(TCPC_ROLE_CTRL_CC2, TCPC_ROLE_CTRL_CC_RP)
117
+
| (TCPC_ROLE_CTRL_RP_VAL_DEF << TCPC_ROLE_CTRL_RP_VAL_SHIFT));
119
118
break;
120
119
case TYPEC_CC_RP_1_5:
121
-
reg = (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC1_SHIFT) |
122
-
(TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC2_SHIFT) |
123
-
(TCPC_ROLE_CTRL_RP_VAL_1_5 <<
124
-
TCPC_ROLE_CTRL_RP_VAL_SHIFT);
120
+
reg = (FIELD_PREP(TCPC_ROLE_CTRL_CC1, TCPC_ROLE_CTRL_CC_RP)
121
+
| FIELD_PREP(TCPC_ROLE_CTRL_CC2, TCPC_ROLE_CTRL_CC_RP)
122
+
| (TCPC_ROLE_CTRL_RP_VAL_1_5 << TCPC_ROLE_CTRL_RP_VAL_SHIFT));
125
123
break;
126
124
case TYPEC_CC_RP_3_0:
127
-
reg = (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC1_SHIFT) |
128
-
(TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC2_SHIFT) |
129
-
(TCPC_ROLE_CTRL_RP_VAL_3_0 <<
130
-
TCPC_ROLE_CTRL_RP_VAL_SHIFT);
125
+
reg = (FIELD_PREP(TCPC_ROLE_CTRL_CC1, TCPC_ROLE_CTRL_CC_RP)
126
+
| FIELD_PREP(TCPC_ROLE_CTRL_CC2, TCPC_ROLE_CTRL_CC_RP)
127
+
| (TCPC_ROLE_CTRL_RP_VAL_3_0 << TCPC_ROLE_CTRL_RP_VAL_SHIFT));
131
128
break;
132
129
case TYPEC_CC_OPEN:
133
130
default:
134
-
reg = (TCPC_ROLE_CTRL_CC_OPEN << TCPC_ROLE_CTRL_CC1_SHIFT) |
135
-
(TCPC_ROLE_CTRL_CC_OPEN << TCPC_ROLE_CTRL_CC2_SHIFT);
131
+
reg = (FIELD_PREP(TCPC_ROLE_CTRL_CC1, TCPC_ROLE_CTRL_CC_OPEN)
132
+
| FIELD_PREP(TCPC_ROLE_CTRL_CC2, TCPC_ROLE_CTRL_CC_OPEN));
136
133
break;
137
134
}
138
135
139
136
if (vconn_pres) {
140
137
if (polarity == TYPEC_POLARITY_CC2) {
141
-
reg &= ~(TCPC_ROLE_CTRL_CC1_MASK << TCPC_ROLE_CTRL_CC1_SHIFT);
142
-
reg |= (TCPC_ROLE_CTRL_CC_OPEN << TCPC_ROLE_CTRL_CC1_SHIFT);
138
+
reg &= ~TCPC_ROLE_CTRL_CC1;
139
+
reg |= FIELD_PREP(TCPC_ROLE_CTRL_CC1, TCPC_ROLE_CTRL_CC_OPEN);
143
140
} else {
144
-
reg &= ~(TCPC_ROLE_CTRL_CC2_MASK << TCPC_ROLE_CTRL_CC2_SHIFT);
145
-
reg |= (TCPC_ROLE_CTRL_CC_OPEN << TCPC_ROLE_CTRL_CC2_SHIFT);
141
+
reg &= ~TCPC_ROLE_CTRL_CC2;
142
+
reg |= FIELD_PREP(TCPC_ROLE_CTRL_CC2, TCPC_ROLE_CTRL_CC_OPEN);
146
143
}
147
144
}
148
145
···
165
168
* APPLY_RC state is when ROLE_CONTROL.CC1 != ROLE_CONTROL.CC2 and vbus autodischarge on
166
169
* disconnect is disabled. Bail out when ROLE_CONTROL.CC1 != ROLE_CONTROL.CC2.
167
170
*/
168
-
if (((reg & (TCPC_ROLE_CTRL_CC2_MASK << TCPC_ROLE_CTRL_CC2_SHIFT)) >>
169
-
TCPC_ROLE_CTRL_CC2_SHIFT) !=
170
-
((reg & (TCPC_ROLE_CTRL_CC1_MASK << TCPC_ROLE_CTRL_CC1_SHIFT)) >>
171
-
TCPC_ROLE_CTRL_CC1_SHIFT))
171
+
if (FIELD_GET(TCPC_ROLE_CTRL_CC2, reg) != FIELD_GET(TCPC_ROLE_CTRL_CC1, reg))
172
172
return 0;
173
173
174
174
return regmap_update_bits(tcpci->regmap, TCPC_ROLE_CTRL, polarity == TYPEC_POLARITY_CC1 ?
175
-
TCPC_ROLE_CTRL_CC2_MASK << TCPC_ROLE_CTRL_CC2_SHIFT :
176
-
TCPC_ROLE_CTRL_CC1_MASK << TCPC_ROLE_CTRL_CC1_SHIFT,
175
+
TCPC_ROLE_CTRL_CC2 : TCPC_ROLE_CTRL_CC1,
177
176
TCPC_ROLE_CTRL_CC_OPEN);
178
177
}
179
178
···
208
215
}
209
216
210
217
if (cc == TYPEC_CC_RD)
211
-
reg |= (TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC1_SHIFT) |
212
-
(TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC2_SHIFT);
218
+
reg |= (FIELD_PREP(TCPC_ROLE_CTRL_CC1, TCPC_ROLE_CTRL_CC_RD)
219
+
| FIELD_PREP(TCPC_ROLE_CTRL_CC2, TCPC_ROLE_CTRL_CC_RD));
213
220
else
214
-
reg |= (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC1_SHIFT) |
215
-
(TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC2_SHIFT);
221
+
reg |= (FIELD_PREP(TCPC_ROLE_CTRL_CC1, TCPC_ROLE_CTRL_CC_RP)
222
+
| FIELD_PREP(TCPC_ROLE_CTRL_CC2, TCPC_ROLE_CTRL_CC_RP));
216
223
ret = regmap_write(tcpci->regmap, TCPC_ROLE_CTRL, reg);
217
224
if (ret < 0)
218
225
return ret;
···
274
281
reg = reg & ~TCPC_ROLE_CTRL_DRP;
275
282
276
283
if (polarity == TYPEC_POLARITY_CC2) {
277
-
reg &= ~(TCPC_ROLE_CTRL_CC2_MASK << TCPC_ROLE_CTRL_CC2_SHIFT);
284
+
reg &= ~TCPC_ROLE_CTRL_CC2;
278
285
/* Local port is source */
279
286
if (cc2 == TYPEC_CC_RD)
280
287
/* Role control would have the Rp setting when DRP was enabled */
281
-
reg |= TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC2_SHIFT;
288
+
reg |= FIELD_PREP(TCPC_ROLE_CTRL_CC2, TCPC_ROLE_CTRL_CC_RP);
282
289
else
283
-
reg |= TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC2_SHIFT;
290
+
reg |= FIELD_PREP(TCPC_ROLE_CTRL_CC2, TCPC_ROLE_CTRL_CC_RD);
284
291
} else {
285
-
reg &= ~(TCPC_ROLE_CTRL_CC1_MASK << TCPC_ROLE_CTRL_CC1_SHIFT);
292
+
reg &= ~TCPC_ROLE_CTRL_CC1;
286
293
/* Local port is source */
287
294
if (cc1 == TYPEC_CC_RD)
288
295
/* Role control would have the Rp setting when DRP was enabled */
289
-
reg |= TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC1_SHIFT;
296
+
reg |= FIELD_PREP(TCPC_ROLE_CTRL_CC1, TCPC_ROLE_CTRL_CC_RP);
290
297
else
291
-
reg |= TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC1_SHIFT;
298
+
reg |= FIELD_PREP(TCPC_ROLE_CTRL_CC1, TCPC_ROLE_CTRL_CC_RD);
292
299
}
293
300
}
294
301
295
302
if (polarity == TYPEC_POLARITY_CC2)
296
-
reg |= TCPC_ROLE_CTRL_CC_OPEN << TCPC_ROLE_CTRL_CC1_SHIFT;
303
+
reg |= FIELD_PREP(TCPC_ROLE_CTRL_CC1, TCPC_ROLE_CTRL_CC_OPEN);
297
304
else
298
-
reg |= TCPC_ROLE_CTRL_CC_OPEN << TCPC_ROLE_CTRL_CC2_SHIFT;
305
+
reg |= FIELD_PREP(TCPC_ROLE_CTRL_CC2, TCPC_ROLE_CTRL_CC_OPEN);
299
306
ret = regmap_write(tcpci->regmap, TCPC_ROLE_CTRL, reg);
300
307
if (ret < 0)
301
308
return ret;
+4
-4
drivers/usb/typec/tcpm/tcpci_rt1711h.c
+4
-4
drivers/usb/typec/tcpm/tcpci_rt1711h.c
···
246
246
}
247
247
248
248
if (cc == TYPEC_CC_RD)
249
-
reg |= (TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC1_SHIFT) |
250
-
(TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC2_SHIFT);
249
+
reg |= (FIELD_PREP(TCPC_ROLE_CTRL_CC1, TCPC_ROLE_CTRL_CC_RD)
250
+
| FIELD_PREP(TCPC_ROLE_CTRL_CC2, TCPC_ROLE_CTRL_CC_RD));
251
251
else
252
-
reg |= (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC1_SHIFT) |
253
-
(TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC2_SHIFT);
252
+
reg |= (FIELD_PREP(TCPC_ROLE_CTRL_CC1, TCPC_ROLE_CTRL_CC_RP)
253
+
| FIELD_PREP(TCPC_ROLE_CTRL_CC2, TCPC_ROLE_CTRL_CC_RP));
254
254
255
255
ret = rt1711h_write8(chip, TCPC_ROLE_CTRL, reg);
256
256
if (ret < 0)
+3
-6
include/linux/usb/tcpci.h
+3
-6
include/linux/usb/tcpci.h
···
68
68
#define TCPC_ROLE_CTRL_RP_VAL_DEF 0x0
69
69
#define TCPC_ROLE_CTRL_RP_VAL_1_5 0x1
70
70
#define TCPC_ROLE_CTRL_RP_VAL_3_0 0x2
71
-
#define TCPC_ROLE_CTRL_CC2_SHIFT 2
72
-
#define TCPC_ROLE_CTRL_CC2_MASK 0x3
73
-
#define TCPC_ROLE_CTRL_CC1_SHIFT 0
74
-
#define TCPC_ROLE_CTRL_CC1_MASK 0x3
71
+
#define TCPC_ROLE_CTRL_CC2 GENMASK(3, 2)
72
+
#define TCPC_ROLE_CTRL_CC1 GENMASK(1, 0)
75
73
#define TCPC_ROLE_CTRL_CC_RA 0x0
76
74
#define TCPC_ROLE_CTRL_CC_RP 0x1
77
75
#define TCPC_ROLE_CTRL_CC_RD 0x2
···
174
176
175
177
#define tcpc_presenting_rd(reg, cc) \
176
178
(!(TCPC_ROLE_CTRL_DRP & (reg)) && \
177
-
(((reg) & (TCPC_ROLE_CTRL_## cc ##_MASK << TCPC_ROLE_CTRL_## cc ##_SHIFT)) == \
178
-
(TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_## cc ##_SHIFT)))
179
+
FIELD_GET(TCPC_ROLE_CTRL_## cc, reg) == TCPC_ROLE_CTRL_CC_RD)
179
180
180
181
struct tcpci;
181
182