1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * DSA devlink handling 4 */ 5 6 #include <net/dsa.h> 7 #include <net/devlink.h> 8 9 #include "devlink.h" 10 11 static int dsa_devlink_info_get(struct devlink *dl, 12 struct devlink_info_req *req, 13 struct netlink_ext_ack *extack) 14 { 15 struct dsa_switch *ds = dsa_devlink_to_ds(dl); 16 17 if (ds->ops->devlink_info_get) 18 return ds->ops->devlink_info_get(ds, req, extack); 19 20 return -EOPNOTSUPP; 21 } 22 23 static int dsa_devlink_sb_pool_get(struct devlink *dl, 24 unsigned int sb_index, u16 pool_index, 25 struct devlink_sb_pool_info *pool_info) 26 { 27 struct dsa_switch *ds = dsa_devlink_to_ds(dl); 28 29 if (!ds->ops->devlink_sb_pool_get) 30 return -EOPNOTSUPP; 31 32 return ds->ops->devlink_sb_pool_get(ds, sb_index, pool_index, 33 pool_info); 34 } 35 36 static int dsa_devlink_sb_pool_set(struct devlink *dl, unsigned int sb_index, 37 u16 pool_index, u32 size, 38 enum devlink_sb_threshold_type threshold_type, 39 struct netlink_ext_ack *extack) 40 { 41 struct dsa_switch *ds = dsa_devlink_to_ds(dl); 42 43 if (!ds->ops->devlink_sb_pool_set) 44 return -EOPNOTSUPP; 45 46 return ds->ops->devlink_sb_pool_set(ds, sb_index, pool_index, size, 47 threshold_type, extack); 48 } 49 50 static int dsa_devlink_sb_port_pool_get(struct devlink_port *dlp, 51 unsigned int sb_index, u16 pool_index, 52 u32 *p_threshold) 53 { 54 struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp); 55 int port = dsa_devlink_port_to_port(dlp); 56 57 if (!ds->ops->devlink_sb_port_pool_get) 58 return -EOPNOTSUPP; 59 60 return ds->ops->devlink_sb_port_pool_get(ds, port, sb_index, 61 pool_index, p_threshold); 62 } 63 64 static int dsa_devlink_sb_port_pool_set(struct devlink_port *dlp, 65 unsigned int sb_index, u16 pool_index, 66 u32 threshold, 67 struct netlink_ext_ack *extack) 68 { 69 struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp); 70 int port = dsa_devlink_port_to_port(dlp); 71 72 if (!ds->ops->devlink_sb_port_pool_set) 73 return -EOPNOTSUPP; 74 75 return ds->ops->devlink_sb_port_pool_set(ds, port, sb_index, 76 pool_index, threshold, extack); 77 } 78 79 static int 80 dsa_devlink_sb_tc_pool_bind_get(struct devlink_port *dlp, 81 unsigned int sb_index, u16 tc_index, 82 enum devlink_sb_pool_type pool_type, 83 u16 *p_pool_index, u32 *p_threshold) 84 { 85 struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp); 86 int port = dsa_devlink_port_to_port(dlp); 87 88 if (!ds->ops->devlink_sb_tc_pool_bind_get) 89 return -EOPNOTSUPP; 90 91 return ds->ops->devlink_sb_tc_pool_bind_get(ds, port, sb_index, 92 tc_index, pool_type, 93 p_pool_index, p_threshold); 94 } 95 96 static int 97 dsa_devlink_sb_tc_pool_bind_set(struct devlink_port *dlp, 98 unsigned int sb_index, u16 tc_index, 99 enum devlink_sb_pool_type pool_type, 100 u16 pool_index, u32 threshold, 101 struct netlink_ext_ack *extack) 102 { 103 struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp); 104 int port = dsa_devlink_port_to_port(dlp); 105 106 if (!ds->ops->devlink_sb_tc_pool_bind_set) 107 return -EOPNOTSUPP; 108 109 return ds->ops->devlink_sb_tc_pool_bind_set(ds, port, sb_index, 110 tc_index, pool_type, 111 pool_index, threshold, 112 extack); 113 } 114 115 static int dsa_devlink_sb_occ_snapshot(struct devlink *dl, 116 unsigned int sb_index) 117 { 118 struct dsa_switch *ds = dsa_devlink_to_ds(dl); 119 120 if (!ds->ops->devlink_sb_occ_snapshot) 121 return -EOPNOTSUPP; 122 123 return ds->ops->devlink_sb_occ_snapshot(ds, sb_index); 124 } 125 126 static int dsa_devlink_sb_occ_max_clear(struct devlink *dl, 127 unsigned int sb_index) 128 { 129 struct dsa_switch *ds = dsa_devlink_to_ds(dl); 130 131 if (!ds->ops->devlink_sb_occ_max_clear) 132 return -EOPNOTSUPP; 133 134 return ds->ops->devlink_sb_occ_max_clear(ds, sb_index); 135 } 136 137 static int dsa_devlink_sb_occ_port_pool_get(struct devlink_port *dlp, 138 unsigned int sb_index, 139 u16 pool_index, u32 *p_cur, 140 u32 *p_max) 141 { 142 struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp); 143 int port = dsa_devlink_port_to_port(dlp); 144 145 if (!ds->ops->devlink_sb_occ_port_pool_get) 146 return -EOPNOTSUPP; 147 148 return ds->ops->devlink_sb_occ_port_pool_get(ds, port, sb_index, 149 pool_index, p_cur, p_max); 150 } 151 152 static int 153 dsa_devlink_sb_occ_tc_port_bind_get(struct devlink_port *dlp, 154 unsigned int sb_index, u16 tc_index, 155 enum devlink_sb_pool_type pool_type, 156 u32 *p_cur, u32 *p_max) 157 { 158 struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp); 159 int port = dsa_devlink_port_to_port(dlp); 160 161 if (!ds->ops->devlink_sb_occ_tc_port_bind_get) 162 return -EOPNOTSUPP; 163 164 return ds->ops->devlink_sb_occ_tc_port_bind_get(ds, port, 165 sb_index, tc_index, 166 pool_type, p_cur, 167 p_max); 168 } 169 170 static const struct devlink_ops dsa_devlink_ops = { 171 .info_get = dsa_devlink_info_get, 172 .sb_pool_get = dsa_devlink_sb_pool_get, 173 .sb_pool_set = dsa_devlink_sb_pool_set, 174 .sb_port_pool_get = dsa_devlink_sb_port_pool_get, 175 .sb_port_pool_set = dsa_devlink_sb_port_pool_set, 176 .sb_tc_pool_bind_get = dsa_devlink_sb_tc_pool_bind_get, 177 .sb_tc_pool_bind_set = dsa_devlink_sb_tc_pool_bind_set, 178 .sb_occ_snapshot = dsa_devlink_sb_occ_snapshot, 179 .sb_occ_max_clear = dsa_devlink_sb_occ_max_clear, 180 .sb_occ_port_pool_get = dsa_devlink_sb_occ_port_pool_get, 181 .sb_occ_tc_port_bind_get = dsa_devlink_sb_occ_tc_port_bind_get, 182 }; 183 184 int dsa_devlink_param_get(struct devlink *dl, u32 id, 185 struct devlink_param_gset_ctx *ctx) 186 { 187 struct dsa_switch *ds = dsa_devlink_to_ds(dl); 188 189 if (!ds->ops->devlink_param_get) 190 return -EOPNOTSUPP; 191 192 return ds->ops->devlink_param_get(ds, id, ctx); 193 } 194 EXPORT_SYMBOL_GPL(dsa_devlink_param_get); 195 196 int dsa_devlink_param_set(struct devlink *dl, u32 id, 197 struct devlink_param_gset_ctx *ctx, 198 struct netlink_ext_ack *extack) 199 { 200 struct dsa_switch *ds = dsa_devlink_to_ds(dl); 201 202 if (!ds->ops->devlink_param_set) 203 return -EOPNOTSUPP; 204 205 return ds->ops->devlink_param_set(ds, id, ctx); 206 } 207 EXPORT_SYMBOL_GPL(dsa_devlink_param_set); 208 209 int dsa_devlink_params_register(struct dsa_switch *ds, 210 const struct devlink_param *params, 211 size_t params_count) 212 { 213 return devlink_params_register(ds->devlink, params, params_count); 214 } 215 EXPORT_SYMBOL_GPL(dsa_devlink_params_register); 216 217 void dsa_devlink_params_unregister(struct dsa_switch *ds, 218 const struct devlink_param *params, 219 size_t params_count) 220 { 221 devlink_params_unregister(ds->devlink, params, params_count); 222 } 223 EXPORT_SYMBOL_GPL(dsa_devlink_params_unregister); 224 225 int dsa_devlink_resource_register(struct dsa_switch *ds, 226 const char *resource_name, 227 u64 resource_size, 228 u64 resource_id, 229 u64 parent_resource_id, 230 const struct devlink_resource_size_params *size_params) 231 { 232 return devlink_resource_register(ds->devlink, resource_name, 233 resource_size, resource_id, 234 parent_resource_id, 235 size_params); 236 } 237 EXPORT_SYMBOL_GPL(dsa_devlink_resource_register); 238 239 void dsa_devlink_resources_unregister(struct dsa_switch *ds) 240 { 241 devlink_resources_unregister(ds->devlink); 242 } 243 EXPORT_SYMBOL_GPL(dsa_devlink_resources_unregister); 244 245 void dsa_devlink_resource_occ_get_register(struct dsa_switch *ds, 246 u64 resource_id, 247 devlink_resource_occ_get_t *occ_get, 248 void *occ_get_priv) 249 { 250 return devlink_resource_occ_get_register(ds->devlink, resource_id, 251 occ_get, occ_get_priv); 252 } 253 EXPORT_SYMBOL_GPL(dsa_devlink_resource_occ_get_register); 254 255 void dsa_devlink_resource_occ_get_unregister(struct dsa_switch *ds, 256 u64 resource_id) 257 { 258 devlink_resource_occ_get_unregister(ds->devlink, resource_id); 259 } 260 EXPORT_SYMBOL_GPL(dsa_devlink_resource_occ_get_unregister); 261 262 struct devlink_region * 263 dsa_devlink_region_create(struct dsa_switch *ds, 264 const struct devlink_region_ops *ops, 265 u32 region_max_snapshots, u64 region_size) 266 { 267 return devlink_region_create(ds->devlink, ops, region_max_snapshots, 268 region_size); 269 } 270 EXPORT_SYMBOL_GPL(dsa_devlink_region_create); 271 272 struct devlink_region * 273 dsa_devlink_port_region_create(struct dsa_switch *ds, 274 int port, 275 const struct devlink_port_region_ops *ops, 276 u32 region_max_snapshots, u64 region_size) 277 { 278 struct dsa_port *dp = dsa_to_port(ds, port); 279 280 return devlink_port_region_create(&dp->devlink_port, ops, 281 region_max_snapshots, 282 region_size); 283 } 284 EXPORT_SYMBOL_GPL(dsa_devlink_port_region_create); 285 286 void dsa_devlink_region_destroy(struct devlink_region *region) 287 { 288 devlink_region_destroy(region); 289 } 290 EXPORT_SYMBOL_GPL(dsa_devlink_region_destroy); 291 292 int dsa_port_devlink_setup(struct dsa_port *dp) 293 { 294 struct devlink_port *dlp = &dp->devlink_port; 295 struct dsa_switch_tree *dst = dp->ds->dst; 296 struct devlink_port_attrs attrs = {}; 297 struct devlink *dl = dp->ds->devlink; 298 struct dsa_switch *ds = dp->ds; 299 const unsigned char *id; 300 unsigned char len; 301 int err; 302 303 memset(dlp, 0, sizeof(*dlp)); 304 devlink_port_init(dl, dlp); 305 306 if (ds->ops->port_setup) { 307 err = ds->ops->port_setup(ds, dp->index); 308 if (err) 309 return err; 310 } 311 312 id = (const unsigned char *)&dst->index; 313 len = sizeof(dst->index); 314 315 attrs.phys.port_number = dp->index; 316 memcpy(attrs.switch_id.id, id, len); 317 attrs.switch_id.id_len = len; 318 319 switch (dp->type) { 320 case DSA_PORT_TYPE_UNUSED: 321 attrs.flavour = DEVLINK_PORT_FLAVOUR_UNUSED; 322 break; 323 case DSA_PORT_TYPE_CPU: 324 attrs.flavour = DEVLINK_PORT_FLAVOUR_CPU; 325 break; 326 case DSA_PORT_TYPE_DSA: 327 attrs.flavour = DEVLINK_PORT_FLAVOUR_DSA; 328 break; 329 case DSA_PORT_TYPE_USER: 330 attrs.flavour = DEVLINK_PORT_FLAVOUR_PHYSICAL; 331 break; 332 } 333 334 devlink_port_attrs_set(dlp, &attrs); 335 err = devlink_port_register(dl, dlp, dp->index); 336 if (err) { 337 if (ds->ops->port_teardown) 338 ds->ops->port_teardown(ds, dp->index); 339 return err; 340 } 341 342 return 0; 343 } 344 345 void dsa_port_devlink_teardown(struct dsa_port *dp) 346 { 347 struct devlink_port *dlp = &dp->devlink_port; 348 struct dsa_switch *ds = dp->ds; 349 350 devlink_port_unregister(dlp); 351 352 if (ds->ops->port_teardown) 353 ds->ops->port_teardown(ds, dp->index); 354 355 devlink_port_fini(dlp); 356 } 357 358 void dsa_switch_devlink_register(struct dsa_switch *ds) 359 { 360 devlink_register(ds->devlink); 361 } 362 363 void dsa_switch_devlink_unregister(struct dsa_switch *ds) 364 { 365 devlink_unregister(ds->devlink); 366 } 367 368 int dsa_switch_devlink_alloc(struct dsa_switch *ds) 369 { 370 struct dsa_devlink_priv *dl_priv; 371 struct devlink *dl; 372 373 /* Add the switch to devlink before calling setup, so that setup can 374 * add dpipe tables 375 */ 376 dl = devlink_alloc(&dsa_devlink_ops, sizeof(*dl_priv), ds->dev); 377 if (!dl) 378 return -ENOMEM; 379 380 ds->devlink = dl; 381 382 dl_priv = devlink_priv(ds->devlink); 383 dl_priv->ds = ds; 384 385 return 0; 386 } 387 388 void dsa_switch_devlink_free(struct dsa_switch *ds) 389 { 390 devlink_free(ds->devlink); 391 ds->devlink = NULL; 392 } 393