2 * Copyright (c) 2013-2016, Mellanox Technologies. All rights reserved.
4 * This software is available to you under a choice of one of two
5 * licenses. You may choose to be licensed under the terms of the GNU
6 * General Public License (GPL) Version 2, available from the file
7 * COPYING in the main directory of this source tree, or the
8 * OpenIB.org BSD license below:
10 * Redistribution and use in source and binary forms, with or
11 * without modification, are permitted provided that the following
14 * - Redistributions of source code must retain the above
15 * copyright notice, this list of conditions and the following
18 * - Redistributions in binary form must reproduce the above
19 * copyright notice, this list of conditions and the following
20 * disclaimer in the documentation and/or other materials
21 * provided with the distribution.
23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
33 #include <linux/kernel.h>
34 #include <linux/module.h>
35 #include <linux/mlx5/driver.h>
36 #include <linux/mlx5/cmd.h>
37 #include "mlx5_core.h"
39 /* Finds an entry where we can register the given rate
40 * If the rate already exists, return the entry where it is registered,
41 * otherwise return the first available entry.
42 * If the table is full, return NULL
44 static struct mlx5_rl_entry
*find_rl_entry(struct mlx5_rl_table
*table
,
47 struct mlx5_rl_entry
*ret_entry
= NULL
;
48 bool empty_found
= false;
51 for (i
= 0; i
< table
->max_size
; i
++) {
52 if (table
->rl_entry
[i
].rate
== rate
)
53 return &table
->rl_entry
[i
];
54 if (!empty_found
&& !table
->rl_entry
[i
].rate
) {
56 ret_entry
= &table
->rl_entry
[i
];
63 static int mlx5_set_rate_limit_cmd(struct mlx5_core_dev
*dev
,
66 u32 in
[MLX5_ST_SZ_DW(set_rate_limit_in
)] = {0};
67 u32 out
[MLX5_ST_SZ_DW(set_rate_limit_out
)] = {0};
69 MLX5_SET(set_rate_limit_in
, in
, opcode
,
70 MLX5_CMD_OP_SET_RATE_LIMIT
);
71 MLX5_SET(set_rate_limit_in
, in
, rate_limit_index
, index
);
72 MLX5_SET(set_rate_limit_in
, in
, rate_limit
, rate
);
73 return mlx5_cmd_exec(dev
, in
, sizeof(in
), out
, sizeof(out
));
76 bool mlx5_rl_is_in_range(struct mlx5_core_dev
*dev
, u32 rate
)
78 struct mlx5_rl_table
*table
= &dev
->priv
.rl_table
;
80 return (rate
<= table
->max_rate
&& rate
>= table
->min_rate
);
82 EXPORT_SYMBOL(mlx5_rl_is_in_range
);
84 int mlx5_rl_add_rate(struct mlx5_core_dev
*dev
, u32 rate
, u16
*index
)
86 struct mlx5_rl_table
*table
= &dev
->priv
.rl_table
;
87 struct mlx5_rl_entry
*entry
;
90 mutex_lock(&table
->rl_lock
);
92 if (!rate
|| !mlx5_rl_is_in_range(dev
, rate
)) {
93 mlx5_core_err(dev
, "Invalid rate: %u, should be %u to %u\n",
94 rate
, table
->min_rate
, table
->max_rate
);
99 entry
= find_rl_entry(table
, rate
);
101 mlx5_core_err(dev
, "Max number of %u rates reached\n",
106 if (entry
->refcount
) {
107 /* rate already configured */
111 err
= mlx5_set_rate_limit_cmd(dev
, rate
, entry
->index
);
113 mlx5_core_err(dev
, "Failed configuring rate: %u (%d)\n",
120 *index
= entry
->index
;
123 mutex_unlock(&table
->rl_lock
);
126 EXPORT_SYMBOL(mlx5_rl_add_rate
);
128 void mlx5_rl_remove_rate(struct mlx5_core_dev
*dev
, u32 rate
)
130 struct mlx5_rl_table
*table
= &dev
->priv
.rl_table
;
131 struct mlx5_rl_entry
*entry
= NULL
;
133 /* 0 is a reserved value for unlimited rate */
137 mutex_lock(&table
->rl_lock
);
138 entry
= find_rl_entry(table
, rate
);
139 if (!entry
|| !entry
->refcount
) {
140 mlx5_core_warn(dev
, "Rate %u is not configured\n", rate
);
145 if (!entry
->refcount
) {
146 /* need to remove rate */
147 mlx5_set_rate_limit_cmd(dev
, 0, entry
->index
);
152 mutex_unlock(&table
->rl_lock
);
154 EXPORT_SYMBOL(mlx5_rl_remove_rate
);
156 int mlx5_init_rl_table(struct mlx5_core_dev
*dev
)
158 struct mlx5_rl_table
*table
= &dev
->priv
.rl_table
;
161 mutex_init(&table
->rl_lock
);
162 if (!MLX5_CAP_GEN(dev
, qos
) || !MLX5_CAP_QOS(dev
, packet_pacing
)) {
167 /* First entry is reserved for unlimited rate */
168 table
->max_size
= MLX5_CAP_QOS(dev
, packet_pacing_rate_table_size
) - 1;
169 table
->max_rate
= MLX5_CAP_QOS(dev
, packet_pacing_max_rate
);
170 table
->min_rate
= MLX5_CAP_QOS(dev
, packet_pacing_min_rate
);
172 table
->rl_entry
= kcalloc(table
->max_size
, sizeof(struct mlx5_rl_entry
),
174 if (!table
->rl_entry
)
177 /* The index represents the index in HW rate limit table
178 * Index 0 is reserved for unlimited rate
180 for (i
= 0; i
< table
->max_size
; i
++)
181 table
->rl_entry
[i
].index
= i
+ 1;
183 /* Index 0 is reserved */
184 mlx5_core_info(dev
, "Rate limit: %u rates are supported, range: %uMbps to %uMbps\n",
186 table
->min_rate
>> 10,
187 table
->max_rate
>> 10);
192 void mlx5_cleanup_rl_table(struct mlx5_core_dev
*dev
)
194 struct mlx5_rl_table
*table
= &dev
->priv
.rl_table
;
197 /* Clear all configured rates */
198 for (i
= 0; i
< table
->max_size
; i
++)
199 if (table
->rl_entry
[i
].rate
)
200 mlx5_set_rate_limit_cmd(dev
, 0,
201 table
->rl_entry
[i
].index
);
203 kfree(dev
->priv
.rl_table
.rl_entry
);