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
)];
67 u32 out
[MLX5_ST_SZ_DW(set_rate_limit_out
)];
69 memset(in
, 0, sizeof(in
));
70 memset(out
, 0, sizeof(out
));
72 MLX5_SET(set_rate_limit_in
, in
, opcode
,
73 MLX5_CMD_OP_SET_RATE_LIMIT
);
74 MLX5_SET(set_rate_limit_in
, in
, rate_limit_index
, index
);
75 MLX5_SET(set_rate_limit_in
, in
, rate_limit
, rate
);
77 return mlx5_cmd_exec_check_status(dev
, in
, sizeof(in
),
81 bool mlx5_rl_is_in_range(struct mlx5_core_dev
*dev
, u32 rate
)
83 struct mlx5_rl_table
*table
= &dev
->priv
.rl_table
;
85 return (rate
<= table
->max_rate
&& rate
>= table
->min_rate
);
87 EXPORT_SYMBOL(mlx5_rl_is_in_range
);
89 int mlx5_rl_add_rate(struct mlx5_core_dev
*dev
, u32 rate
, u16
*index
)
91 struct mlx5_rl_table
*table
= &dev
->priv
.rl_table
;
92 struct mlx5_rl_entry
*entry
;
95 mutex_lock(&table
->rl_lock
);
97 if (!rate
|| !mlx5_rl_is_in_range(dev
, rate
)) {
98 mlx5_core_err(dev
, "Invalid rate: %u, should be %u to %u\n",
99 rate
, table
->min_rate
, table
->max_rate
);
104 entry
= find_rl_entry(table
, rate
);
106 mlx5_core_err(dev
, "Max number of %u rates reached\n",
111 if (entry
->refcount
) {
112 /* rate already configured */
116 err
= mlx5_set_rate_limit_cmd(dev
, rate
, entry
->index
);
118 mlx5_core_err(dev
, "Failed configuring rate: %u (%d)\n",
125 *index
= entry
->index
;
128 mutex_unlock(&table
->rl_lock
);
131 EXPORT_SYMBOL(mlx5_rl_add_rate
);
133 void mlx5_rl_remove_rate(struct mlx5_core_dev
*dev
, u32 rate
)
135 struct mlx5_rl_table
*table
= &dev
->priv
.rl_table
;
136 struct mlx5_rl_entry
*entry
= NULL
;
138 /* 0 is a reserved value for unlimited rate */
142 mutex_lock(&table
->rl_lock
);
143 entry
= find_rl_entry(table
, rate
);
144 if (!entry
|| !entry
->refcount
) {
145 mlx5_core_warn(dev
, "Rate %u is not configured\n", rate
);
150 if (!entry
->refcount
) {
151 /* need to remove rate */
152 mlx5_set_rate_limit_cmd(dev
, 0, entry
->index
);
157 mutex_unlock(&table
->rl_lock
);
159 EXPORT_SYMBOL(mlx5_rl_remove_rate
);
161 int mlx5_init_rl_table(struct mlx5_core_dev
*dev
)
163 struct mlx5_rl_table
*table
= &dev
->priv
.rl_table
;
166 mutex_init(&table
->rl_lock
);
167 if (!MLX5_CAP_GEN(dev
, qos
) || !MLX5_CAP_QOS(dev
, packet_pacing
)) {
172 /* First entry is reserved for unlimited rate */
173 table
->max_size
= MLX5_CAP_QOS(dev
, packet_pacing_rate_table_size
) - 1;
174 table
->max_rate
= MLX5_CAP_QOS(dev
, packet_pacing_max_rate
);
175 table
->min_rate
= MLX5_CAP_QOS(dev
, packet_pacing_min_rate
);
177 table
->rl_entry
= kcalloc(table
->max_size
, sizeof(struct mlx5_rl_entry
),
179 if (!table
->rl_entry
)
182 /* The index represents the index in HW rate limit table
183 * Index 0 is reserved for unlimited rate
185 for (i
= 0; i
< table
->max_size
; i
++)
186 table
->rl_entry
[i
].index
= i
+ 1;
188 /* Index 0 is reserved */
189 mlx5_core_info(dev
, "Rate limit: %u rates are supported, range: %uMbps to %uMbps\n",
191 table
->min_rate
>> 10,
192 table
->max_rate
>> 10);
197 void mlx5_cleanup_rl_table(struct mlx5_core_dev
*dev
)
199 struct mlx5_rl_table
*table
= &dev
->priv
.rl_table
;
202 /* Clear all configured rates */
203 for (i
= 0; i
< table
->max_size
; i
++)
204 if (table
->rl_entry
[i
].rate
)
205 mlx5_set_rate_limit_cmd(dev
, 0,
206 table
->rl_entry
[i
].index
);
208 kfree(dev
->priv
.rl_table
.rl_entry
);