Merge tag 'percpu-for-6.6' of git://git.kernel.org/pub/scm/linux/kernel/git/dennis...
[platform/kernel/linux-starfive.git] / net / ethtool / coalesce.c
1 // SPDX-License-Identifier: GPL-2.0-only
2
3 #include "netlink.h"
4 #include "common.h"
5
6 struct coalesce_req_info {
7         struct ethnl_req_info           base;
8 };
9
10 struct coalesce_reply_data {
11         struct ethnl_reply_data         base;
12         struct ethtool_coalesce         coalesce;
13         struct kernel_ethtool_coalesce  kernel_coalesce;
14         u32                             supported_params;
15 };
16
17 #define COALESCE_REPDATA(__reply_base) \
18         container_of(__reply_base, struct coalesce_reply_data, base)
19
20 #define __SUPPORTED_OFFSET ETHTOOL_A_COALESCE_RX_USECS
21 static u32 attr_to_mask(unsigned int attr_type)
22 {
23         return BIT(attr_type - __SUPPORTED_OFFSET);
24 }
25
26 /* build time check that indices in ethtool_ops::supported_coalesce_params
27  * match corresponding attribute types with an offset
28  */
29 #define __CHECK_SUPPORTED_OFFSET(x) \
30         static_assert((ETHTOOL_ ## x) == \
31                       BIT((ETHTOOL_A_ ## x) - __SUPPORTED_OFFSET))
32 __CHECK_SUPPORTED_OFFSET(COALESCE_RX_USECS);
33 __CHECK_SUPPORTED_OFFSET(COALESCE_RX_MAX_FRAMES);
34 __CHECK_SUPPORTED_OFFSET(COALESCE_RX_USECS_IRQ);
35 __CHECK_SUPPORTED_OFFSET(COALESCE_RX_MAX_FRAMES_IRQ);
36 __CHECK_SUPPORTED_OFFSET(COALESCE_TX_USECS);
37 __CHECK_SUPPORTED_OFFSET(COALESCE_TX_MAX_FRAMES);
38 __CHECK_SUPPORTED_OFFSET(COALESCE_TX_USECS_IRQ);
39 __CHECK_SUPPORTED_OFFSET(COALESCE_TX_MAX_FRAMES_IRQ);
40 __CHECK_SUPPORTED_OFFSET(COALESCE_STATS_BLOCK_USECS);
41 __CHECK_SUPPORTED_OFFSET(COALESCE_USE_ADAPTIVE_RX);
42 __CHECK_SUPPORTED_OFFSET(COALESCE_USE_ADAPTIVE_TX);
43 __CHECK_SUPPORTED_OFFSET(COALESCE_PKT_RATE_LOW);
44 __CHECK_SUPPORTED_OFFSET(COALESCE_RX_USECS_LOW);
45 __CHECK_SUPPORTED_OFFSET(COALESCE_RX_MAX_FRAMES_LOW);
46 __CHECK_SUPPORTED_OFFSET(COALESCE_TX_USECS_LOW);
47 __CHECK_SUPPORTED_OFFSET(COALESCE_TX_MAX_FRAMES_LOW);
48 __CHECK_SUPPORTED_OFFSET(COALESCE_PKT_RATE_HIGH);
49 __CHECK_SUPPORTED_OFFSET(COALESCE_RX_USECS_HIGH);
50 __CHECK_SUPPORTED_OFFSET(COALESCE_RX_MAX_FRAMES_HIGH);
51 __CHECK_SUPPORTED_OFFSET(COALESCE_TX_USECS_HIGH);
52 __CHECK_SUPPORTED_OFFSET(COALESCE_TX_MAX_FRAMES_HIGH);
53 __CHECK_SUPPORTED_OFFSET(COALESCE_RATE_SAMPLE_INTERVAL);
54
55 const struct nla_policy ethnl_coalesce_get_policy[] = {
56         [ETHTOOL_A_COALESCE_HEADER]             =
57                 NLA_POLICY_NESTED(ethnl_header_policy),
58 };
59
60 static int coalesce_prepare_data(const struct ethnl_req_info *req_base,
61                                  struct ethnl_reply_data *reply_base,
62                                  const struct genl_info *info)
63 {
64         struct coalesce_reply_data *data = COALESCE_REPDATA(reply_base);
65         struct net_device *dev = reply_base->dev;
66         int ret;
67
68         if (!dev->ethtool_ops->get_coalesce)
69                 return -EOPNOTSUPP;
70         data->supported_params = dev->ethtool_ops->supported_coalesce_params;
71         ret = ethnl_ops_begin(dev);
72         if (ret < 0)
73                 return ret;
74         ret = dev->ethtool_ops->get_coalesce(dev, &data->coalesce,
75                                              &data->kernel_coalesce,
76                                              info->extack);
77         ethnl_ops_complete(dev);
78
79         return ret;
80 }
81
82 static int coalesce_reply_size(const struct ethnl_req_info *req_base,
83                                const struct ethnl_reply_data *reply_base)
84 {
85         return nla_total_size(sizeof(u32)) +    /* _RX_USECS */
86                nla_total_size(sizeof(u32)) +    /* _RX_MAX_FRAMES */
87                nla_total_size(sizeof(u32)) +    /* _RX_USECS_IRQ */
88                nla_total_size(sizeof(u32)) +    /* _RX_MAX_FRAMES_IRQ */
89                nla_total_size(sizeof(u32)) +    /* _TX_USECS */
90                nla_total_size(sizeof(u32)) +    /* _TX_MAX_FRAMES */
91                nla_total_size(sizeof(u32)) +    /* _TX_USECS_IRQ */
92                nla_total_size(sizeof(u32)) +    /* _TX_MAX_FRAMES_IRQ */
93                nla_total_size(sizeof(u32)) +    /* _STATS_BLOCK_USECS */
94                nla_total_size(sizeof(u8)) +     /* _USE_ADAPTIVE_RX */
95                nla_total_size(sizeof(u8)) +     /* _USE_ADAPTIVE_TX */
96                nla_total_size(sizeof(u32)) +    /* _PKT_RATE_LOW */
97                nla_total_size(sizeof(u32)) +    /* _RX_USECS_LOW */
98                nla_total_size(sizeof(u32)) +    /* _RX_MAX_FRAMES_LOW */
99                nla_total_size(sizeof(u32)) +    /* _TX_USECS_LOW */
100                nla_total_size(sizeof(u32)) +    /* _TX_MAX_FRAMES_LOW */
101                nla_total_size(sizeof(u32)) +    /* _PKT_RATE_HIGH */
102                nla_total_size(sizeof(u32)) +    /* _RX_USECS_HIGH */
103                nla_total_size(sizeof(u32)) +    /* _RX_MAX_FRAMES_HIGH */
104                nla_total_size(sizeof(u32)) +    /* _TX_USECS_HIGH */
105                nla_total_size(sizeof(u32)) +    /* _TX_MAX_FRAMES_HIGH */
106                nla_total_size(sizeof(u32)) +    /* _RATE_SAMPLE_INTERVAL */
107                nla_total_size(sizeof(u8)) +     /* _USE_CQE_MODE_TX */
108                nla_total_size(sizeof(u8)) +     /* _USE_CQE_MODE_RX */
109                nla_total_size(sizeof(u32)) +    /* _TX_AGGR_MAX_BYTES */
110                nla_total_size(sizeof(u32)) +    /* _TX_AGGR_MAX_FRAMES */
111                nla_total_size(sizeof(u32));     /* _TX_AGGR_TIME_USECS */
112 }
113
114 static bool coalesce_put_u32(struct sk_buff *skb, u16 attr_type, u32 val,
115                              u32 supported_params)
116 {
117         if (!val && !(supported_params & attr_to_mask(attr_type)))
118                 return false;
119         return nla_put_u32(skb, attr_type, val);
120 }
121
122 static bool coalesce_put_bool(struct sk_buff *skb, u16 attr_type, u32 val,
123                               u32 supported_params)
124 {
125         if (!val && !(supported_params & attr_to_mask(attr_type)))
126                 return false;
127         return nla_put_u8(skb, attr_type, !!val);
128 }
129
130 static int coalesce_fill_reply(struct sk_buff *skb,
131                                const struct ethnl_req_info *req_base,
132                                const struct ethnl_reply_data *reply_base)
133 {
134         const struct coalesce_reply_data *data = COALESCE_REPDATA(reply_base);
135         const struct kernel_ethtool_coalesce *kcoal = &data->kernel_coalesce;
136         const struct ethtool_coalesce *coal = &data->coalesce;
137         u32 supported = data->supported_params;
138
139         if (coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_USECS,
140                              coal->rx_coalesce_usecs, supported) ||
141             coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_MAX_FRAMES,
142                              coal->rx_max_coalesced_frames, supported) ||
143             coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_USECS_IRQ,
144                              coal->rx_coalesce_usecs_irq, supported) ||
145             coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_MAX_FRAMES_IRQ,
146                              coal->rx_max_coalesced_frames_irq, supported) ||
147             coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_USECS,
148                              coal->tx_coalesce_usecs, supported) ||
149             coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_MAX_FRAMES,
150                              coal->tx_max_coalesced_frames, supported) ||
151             coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_USECS_IRQ,
152                              coal->tx_coalesce_usecs_irq, supported) ||
153             coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_MAX_FRAMES_IRQ,
154                              coal->tx_max_coalesced_frames_irq, supported) ||
155             coalesce_put_u32(skb, ETHTOOL_A_COALESCE_STATS_BLOCK_USECS,
156                              coal->stats_block_coalesce_usecs, supported) ||
157             coalesce_put_bool(skb, ETHTOOL_A_COALESCE_USE_ADAPTIVE_RX,
158                               coal->use_adaptive_rx_coalesce, supported) ||
159             coalesce_put_bool(skb, ETHTOOL_A_COALESCE_USE_ADAPTIVE_TX,
160                               coal->use_adaptive_tx_coalesce, supported) ||
161             coalesce_put_u32(skb, ETHTOOL_A_COALESCE_PKT_RATE_LOW,
162                              coal->pkt_rate_low, supported) ||
163             coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_USECS_LOW,
164                              coal->rx_coalesce_usecs_low, supported) ||
165             coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_MAX_FRAMES_LOW,
166                              coal->rx_max_coalesced_frames_low, supported) ||
167             coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_USECS_LOW,
168                              coal->tx_coalesce_usecs_low, supported) ||
169             coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_MAX_FRAMES_LOW,
170                              coal->tx_max_coalesced_frames_low, supported) ||
171             coalesce_put_u32(skb, ETHTOOL_A_COALESCE_PKT_RATE_HIGH,
172                              coal->pkt_rate_high, supported) ||
173             coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_USECS_HIGH,
174                              coal->rx_coalesce_usecs_high, supported) ||
175             coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_MAX_FRAMES_HIGH,
176                              coal->rx_max_coalesced_frames_high, supported) ||
177             coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_USECS_HIGH,
178                              coal->tx_coalesce_usecs_high, supported) ||
179             coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_MAX_FRAMES_HIGH,
180                              coal->tx_max_coalesced_frames_high, supported) ||
181             coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RATE_SAMPLE_INTERVAL,
182                              coal->rate_sample_interval, supported) ||
183             coalesce_put_bool(skb, ETHTOOL_A_COALESCE_USE_CQE_MODE_TX,
184                               kcoal->use_cqe_mode_tx, supported) ||
185             coalesce_put_bool(skb, ETHTOOL_A_COALESCE_USE_CQE_MODE_RX,
186                               kcoal->use_cqe_mode_rx, supported) ||
187             coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_AGGR_MAX_BYTES,
188                              kcoal->tx_aggr_max_bytes, supported) ||
189             coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_AGGR_MAX_FRAMES,
190                              kcoal->tx_aggr_max_frames, supported) ||
191             coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_AGGR_TIME_USECS,
192                              kcoal->tx_aggr_time_usecs, supported))
193                 return -EMSGSIZE;
194
195         return 0;
196 }
197
198 /* COALESCE_SET */
199
200 const struct nla_policy ethnl_coalesce_set_policy[] = {
201         [ETHTOOL_A_COALESCE_HEADER]             =
202                 NLA_POLICY_NESTED(ethnl_header_policy),
203         [ETHTOOL_A_COALESCE_RX_USECS]           = { .type = NLA_U32 },
204         [ETHTOOL_A_COALESCE_RX_MAX_FRAMES]      = { .type = NLA_U32 },
205         [ETHTOOL_A_COALESCE_RX_USECS_IRQ]       = { .type = NLA_U32 },
206         [ETHTOOL_A_COALESCE_RX_MAX_FRAMES_IRQ]  = { .type = NLA_U32 },
207         [ETHTOOL_A_COALESCE_TX_USECS]           = { .type = NLA_U32 },
208         [ETHTOOL_A_COALESCE_TX_MAX_FRAMES]      = { .type = NLA_U32 },
209         [ETHTOOL_A_COALESCE_TX_USECS_IRQ]       = { .type = NLA_U32 },
210         [ETHTOOL_A_COALESCE_TX_MAX_FRAMES_IRQ]  = { .type = NLA_U32 },
211         [ETHTOOL_A_COALESCE_STATS_BLOCK_USECS]  = { .type = NLA_U32 },
212         [ETHTOOL_A_COALESCE_USE_ADAPTIVE_RX]    = { .type = NLA_U8 },
213         [ETHTOOL_A_COALESCE_USE_ADAPTIVE_TX]    = { .type = NLA_U8 },
214         [ETHTOOL_A_COALESCE_PKT_RATE_LOW]       = { .type = NLA_U32 },
215         [ETHTOOL_A_COALESCE_RX_USECS_LOW]       = { .type = NLA_U32 },
216         [ETHTOOL_A_COALESCE_RX_MAX_FRAMES_LOW]  = { .type = NLA_U32 },
217         [ETHTOOL_A_COALESCE_TX_USECS_LOW]       = { .type = NLA_U32 },
218         [ETHTOOL_A_COALESCE_TX_MAX_FRAMES_LOW]  = { .type = NLA_U32 },
219         [ETHTOOL_A_COALESCE_PKT_RATE_HIGH]      = { .type = NLA_U32 },
220         [ETHTOOL_A_COALESCE_RX_USECS_HIGH]      = { .type = NLA_U32 },
221         [ETHTOOL_A_COALESCE_RX_MAX_FRAMES_HIGH] = { .type = NLA_U32 },
222         [ETHTOOL_A_COALESCE_TX_USECS_HIGH]      = { .type = NLA_U32 },
223         [ETHTOOL_A_COALESCE_TX_MAX_FRAMES_HIGH] = { .type = NLA_U32 },
224         [ETHTOOL_A_COALESCE_RATE_SAMPLE_INTERVAL] = { .type = NLA_U32 },
225         [ETHTOOL_A_COALESCE_USE_CQE_MODE_TX]    = NLA_POLICY_MAX(NLA_U8, 1),
226         [ETHTOOL_A_COALESCE_USE_CQE_MODE_RX]    = NLA_POLICY_MAX(NLA_U8, 1),
227         [ETHTOOL_A_COALESCE_TX_AGGR_MAX_BYTES] = { .type = NLA_U32 },
228         [ETHTOOL_A_COALESCE_TX_AGGR_MAX_FRAMES] = { .type = NLA_U32 },
229         [ETHTOOL_A_COALESCE_TX_AGGR_TIME_USECS] = { .type = NLA_U32 },
230 };
231
232 static int
233 ethnl_set_coalesce_validate(struct ethnl_req_info *req_info,
234                             struct genl_info *info)
235 {
236         const struct ethtool_ops *ops = req_info->dev->ethtool_ops;
237         struct nlattr **tb = info->attrs;
238         u32 supported_params;
239         u16 a;
240
241         if (!ops->get_coalesce || !ops->set_coalesce)
242                 return -EOPNOTSUPP;
243
244         /* make sure that only supported parameters are present */
245         supported_params = ops->supported_coalesce_params;
246         for (a = ETHTOOL_A_COALESCE_RX_USECS; a < __ETHTOOL_A_COALESCE_CNT; a++)
247                 if (tb[a] && !(supported_params & attr_to_mask(a))) {
248                         NL_SET_ERR_MSG_ATTR(info->extack, tb[a],
249                                             "cannot modify an unsupported parameter");
250                         return -EINVAL;
251                 }
252
253         return 1;
254 }
255
256 static int
257 __ethnl_set_coalesce(struct ethnl_req_info *req_info, struct genl_info *info,
258                      bool *dual_change)
259 {
260         struct kernel_ethtool_coalesce kernel_coalesce = {};
261         struct net_device *dev = req_info->dev;
262         struct ethtool_coalesce coalesce = {};
263         bool mod_mode = false, mod = false;
264         struct nlattr **tb = info->attrs;
265         int ret;
266
267         ret = dev->ethtool_ops->get_coalesce(dev, &coalesce, &kernel_coalesce,
268                                              info->extack);
269         if (ret < 0)
270                 return ret;
271
272         /* Update values */
273         ethnl_update_u32(&coalesce.rx_coalesce_usecs,
274                          tb[ETHTOOL_A_COALESCE_RX_USECS], &mod);
275         ethnl_update_u32(&coalesce.rx_max_coalesced_frames,
276                          tb[ETHTOOL_A_COALESCE_RX_MAX_FRAMES], &mod);
277         ethnl_update_u32(&coalesce.rx_coalesce_usecs_irq,
278                          tb[ETHTOOL_A_COALESCE_RX_USECS_IRQ], &mod);
279         ethnl_update_u32(&coalesce.rx_max_coalesced_frames_irq,
280                          tb[ETHTOOL_A_COALESCE_RX_MAX_FRAMES_IRQ], &mod);
281         ethnl_update_u32(&coalesce.tx_coalesce_usecs,
282                          tb[ETHTOOL_A_COALESCE_TX_USECS], &mod);
283         ethnl_update_u32(&coalesce.tx_max_coalesced_frames,
284                          tb[ETHTOOL_A_COALESCE_TX_MAX_FRAMES], &mod);
285         ethnl_update_u32(&coalesce.tx_coalesce_usecs_irq,
286                          tb[ETHTOOL_A_COALESCE_TX_USECS_IRQ], &mod);
287         ethnl_update_u32(&coalesce.tx_max_coalesced_frames_irq,
288                          tb[ETHTOOL_A_COALESCE_TX_MAX_FRAMES_IRQ], &mod);
289         ethnl_update_u32(&coalesce.stats_block_coalesce_usecs,
290                          tb[ETHTOOL_A_COALESCE_STATS_BLOCK_USECS], &mod);
291         ethnl_update_u32(&coalesce.pkt_rate_low,
292                          tb[ETHTOOL_A_COALESCE_PKT_RATE_LOW], &mod);
293         ethnl_update_u32(&coalesce.rx_coalesce_usecs_low,
294                          tb[ETHTOOL_A_COALESCE_RX_USECS_LOW], &mod);
295         ethnl_update_u32(&coalesce.rx_max_coalesced_frames_low,
296                          tb[ETHTOOL_A_COALESCE_RX_MAX_FRAMES_LOW], &mod);
297         ethnl_update_u32(&coalesce.tx_coalesce_usecs_low,
298                          tb[ETHTOOL_A_COALESCE_TX_USECS_LOW], &mod);
299         ethnl_update_u32(&coalesce.tx_max_coalesced_frames_low,
300                          tb[ETHTOOL_A_COALESCE_TX_MAX_FRAMES_LOW], &mod);
301         ethnl_update_u32(&coalesce.pkt_rate_high,
302                          tb[ETHTOOL_A_COALESCE_PKT_RATE_HIGH], &mod);
303         ethnl_update_u32(&coalesce.rx_coalesce_usecs_high,
304                          tb[ETHTOOL_A_COALESCE_RX_USECS_HIGH], &mod);
305         ethnl_update_u32(&coalesce.rx_max_coalesced_frames_high,
306                          tb[ETHTOOL_A_COALESCE_RX_MAX_FRAMES_HIGH], &mod);
307         ethnl_update_u32(&coalesce.tx_coalesce_usecs_high,
308                          tb[ETHTOOL_A_COALESCE_TX_USECS_HIGH], &mod);
309         ethnl_update_u32(&coalesce.tx_max_coalesced_frames_high,
310                          tb[ETHTOOL_A_COALESCE_TX_MAX_FRAMES_HIGH], &mod);
311         ethnl_update_u32(&coalesce.rate_sample_interval,
312                          tb[ETHTOOL_A_COALESCE_RATE_SAMPLE_INTERVAL], &mod);
313         ethnl_update_u32(&kernel_coalesce.tx_aggr_max_bytes,
314                          tb[ETHTOOL_A_COALESCE_TX_AGGR_MAX_BYTES], &mod);
315         ethnl_update_u32(&kernel_coalesce.tx_aggr_max_frames,
316                          tb[ETHTOOL_A_COALESCE_TX_AGGR_MAX_FRAMES], &mod);
317         ethnl_update_u32(&kernel_coalesce.tx_aggr_time_usecs,
318                          tb[ETHTOOL_A_COALESCE_TX_AGGR_TIME_USECS], &mod);
319
320         /* Update operation modes */
321         ethnl_update_bool32(&coalesce.use_adaptive_rx_coalesce,
322                             tb[ETHTOOL_A_COALESCE_USE_ADAPTIVE_RX], &mod_mode);
323         ethnl_update_bool32(&coalesce.use_adaptive_tx_coalesce,
324                             tb[ETHTOOL_A_COALESCE_USE_ADAPTIVE_TX], &mod_mode);
325         ethnl_update_u8(&kernel_coalesce.use_cqe_mode_tx,
326                         tb[ETHTOOL_A_COALESCE_USE_CQE_MODE_TX], &mod_mode);
327         ethnl_update_u8(&kernel_coalesce.use_cqe_mode_rx,
328                         tb[ETHTOOL_A_COALESCE_USE_CQE_MODE_RX], &mod_mode);
329
330         *dual_change = mod && mod_mode;
331         if (!mod && !mod_mode)
332                 return 0;
333
334         ret = dev->ethtool_ops->set_coalesce(dev, &coalesce, &kernel_coalesce,
335                                              info->extack);
336         return ret < 0 ? ret : 1;
337 }
338
339 static int
340 ethnl_set_coalesce(struct ethnl_req_info *req_info, struct genl_info *info)
341 {
342         bool dual_change;
343         int err, ret;
344
345         /* SET_COALESCE may change operation mode and parameters in one call.
346          * Changing operation mode may cause the driver to reset the parameter
347          * values, and therefore ignore user input (driver does not know which
348          * parameters come from user and which are echoed back from ->get).
349          * To not complicate the drivers if user tries to change both the mode
350          * and parameters at once - call the driver twice.
351          */
352         err = __ethnl_set_coalesce(req_info, info, &dual_change);
353         if (err < 0)
354                 return err;
355         ret = err;
356
357         if (ret && dual_change) {
358                 err = __ethnl_set_coalesce(req_info, info, &dual_change);
359                 if (err < 0)
360                         return err;
361         }
362         return ret;
363 }
364
365 const struct ethnl_request_ops ethnl_coalesce_request_ops = {
366         .request_cmd            = ETHTOOL_MSG_COALESCE_GET,
367         .reply_cmd              = ETHTOOL_MSG_COALESCE_GET_REPLY,
368         .hdr_attr               = ETHTOOL_A_COALESCE_HEADER,
369         .req_info_size          = sizeof(struct coalesce_req_info),
370         .reply_data_size        = sizeof(struct coalesce_reply_data),
371
372         .prepare_data           = coalesce_prepare_data,
373         .reply_size             = coalesce_reply_size,
374         .fill_reply             = coalesce_fill_reply,
375
376         .set_validate           = ethnl_set_coalesce_validate,
377         .set                    = ethnl_set_coalesce,
378         .set_ntf_cmd            = ETHTOOL_MSG_COALESCE_NTF,
379 };