net/mlx5: FPGA, Add device name
[sfrench/cifs-2.6.git] / drivers / net / ethernet / mellanox / mlx5 / core / fpga / core.c
1 /*
2  * Copyright (c) 2017, Mellanox Technologies. All rights reserved.
3  *
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:
9  *
10  *     Redistribution and use in source and binary forms, with or
11  *     without modification, are permitted provided that the following
12  *     conditions are met:
13  *
14  *      - Redistributions of source code must retain the above
15  *        copyright notice, this list of conditions and the following
16  *        disclaimer.
17  *
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.
22  *
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
30  * SOFTWARE.
31  */
32
33 #include <linux/module.h>
34 #include <linux/etherdevice.h>
35 #include <linux/mlx5/driver.h>
36
37 #include "mlx5_core.h"
38 #include "lib/mlx5.h"
39 #include "fpga/core.h"
40 #include "fpga/conn.h"
41
42 static const char *const mlx5_fpga_error_strings[] = {
43         "Null Syndrome",
44         "Corrupted DDR",
45         "Flash Timeout",
46         "Internal Link Error",
47         "Watchdog HW Failure",
48         "I2C Failure",
49         "Image Changed",
50         "Temperature Critical",
51 };
52
53 static struct mlx5_fpga_device *mlx5_fpga_device_alloc(void)
54 {
55         struct mlx5_fpga_device *fdev = NULL;
56
57         fdev = kzalloc(sizeof(*fdev), GFP_KERNEL);
58         if (!fdev)
59                 return NULL;
60
61         spin_lock_init(&fdev->state_lock);
62         fdev->state = MLX5_FPGA_STATUS_NONE;
63         return fdev;
64 }
65
66 static const char *mlx5_fpga_image_name(enum mlx5_fpga_image image)
67 {
68         switch (image) {
69         case MLX5_FPGA_IMAGE_USER:
70                 return "user";
71         case MLX5_FPGA_IMAGE_FACTORY:
72                 return "factory";
73         default:
74                 return "unknown";
75         }
76 }
77
78 static const char *mlx5_fpga_device_name(u32 device)
79 {
80         switch (device) {
81         case MLX5_FPGA_DEVICE_KU040:
82                 return "ku040";
83         case MLX5_FPGA_DEVICE_KU060:
84                 return "ku060";
85         case MLX5_FPGA_DEVICE_KU060_2:
86                 return "ku060_2";
87         case MLX5_FPGA_DEVICE_UNKNOWN:
88         default:
89                 return "unknown";
90         }
91 }
92
93 static int mlx5_fpga_device_load_check(struct mlx5_fpga_device *fdev)
94 {
95         struct mlx5_fpga_query query;
96         int err;
97
98         err = mlx5_fpga_query(fdev->mdev, &query);
99         if (err) {
100                 mlx5_fpga_err(fdev, "Failed to query status: %d\n", err);
101                 return err;
102         }
103
104         fdev->last_admin_image = query.admin_image;
105         fdev->last_oper_image = query.oper_image;
106
107         mlx5_fpga_dbg(fdev, "Status %u; Admin image %u; Oper image %u\n",
108                       query.status, query.admin_image, query.oper_image);
109
110         if (query.status != MLX5_FPGA_STATUS_SUCCESS) {
111                 mlx5_fpga_err(fdev, "%s image failed to load; status %u\n",
112                               mlx5_fpga_image_name(fdev->last_oper_image),
113                               query.status);
114                 return -EIO;
115         }
116
117         return 0;
118 }
119
120 static int mlx5_fpga_device_brb(struct mlx5_fpga_device *fdev)
121 {
122         int err;
123         struct mlx5_core_dev *mdev = fdev->mdev;
124
125         err = mlx5_fpga_ctrl_op(mdev, MLX5_FPGA_CTRL_OPERATION_SANDBOX_BYPASS_ON);
126         if (err) {
127                 mlx5_fpga_err(fdev, "Failed to set bypass on: %d\n", err);
128                 return err;
129         }
130         err = mlx5_fpga_ctrl_op(mdev, MLX5_FPGA_CTRL_OPERATION_RESET_SANDBOX);
131         if (err) {
132                 mlx5_fpga_err(fdev, "Failed to reset SBU: %d\n", err);
133                 return err;
134         }
135         err = mlx5_fpga_ctrl_op(mdev, MLX5_FPGA_CTRL_OPERATION_SANDBOX_BYPASS_OFF);
136         if (err) {
137                 mlx5_fpga_err(fdev, "Failed to set bypass off: %d\n", err);
138                 return err;
139         }
140         return 0;
141 }
142
143 int mlx5_fpga_device_start(struct mlx5_core_dev *mdev)
144 {
145         struct mlx5_fpga_device *fdev = mdev->fpga;
146         unsigned int max_num_qps;
147         unsigned long flags;
148         u32 fpga_device_id;
149         int err;
150
151         if (!fdev)
152                 return 0;
153
154         err = mlx5_fpga_device_load_check(fdev);
155         if (err)
156                 goto out;
157
158         err = mlx5_fpga_caps(fdev->mdev);
159         if (err)
160                 goto out;
161
162         fpga_device_id = MLX5_CAP_FPGA(fdev->mdev, fpga_device);
163         mlx5_fpga_info(fdev, "%s:%u; %s image, version %u\n",
164                        mlx5_fpga_device_name(fpga_device_id),
165                        fpga_device_id,
166                        mlx5_fpga_image_name(fdev->last_oper_image),
167                        MLX5_CAP_FPGA(fdev->mdev, image_version));
168
169         max_num_qps = MLX5_CAP_FPGA(mdev, shell_caps.max_num_qps);
170         err = mlx5_core_reserve_gids(mdev, max_num_qps);
171         if (err)
172                 goto out;
173
174         err = mlx5_fpga_conn_device_init(fdev);
175         if (err)
176                 goto err_rsvd_gid;
177
178         if (fdev->last_oper_image == MLX5_FPGA_IMAGE_USER) {
179                 err = mlx5_fpga_device_brb(fdev);
180                 if (err)
181                         goto err_conn_init;
182         }
183
184         goto out;
185
186 err_conn_init:
187         mlx5_fpga_conn_device_cleanup(fdev);
188
189 err_rsvd_gid:
190         mlx5_core_unreserve_gids(mdev, max_num_qps);
191 out:
192         spin_lock_irqsave(&fdev->state_lock, flags);
193         fdev->state = err ? MLX5_FPGA_STATUS_FAILURE : MLX5_FPGA_STATUS_SUCCESS;
194         spin_unlock_irqrestore(&fdev->state_lock, flags);
195         return err;
196 }
197
198 int mlx5_fpga_init(struct mlx5_core_dev *mdev)
199 {
200         struct mlx5_fpga_device *fdev = NULL;
201
202         if (!MLX5_CAP_GEN(mdev, fpga)) {
203                 mlx5_core_dbg(mdev, "FPGA capability not present\n");
204                 return 0;
205         }
206
207         mlx5_core_dbg(mdev, "Initializing FPGA\n");
208
209         fdev = mlx5_fpga_device_alloc();
210         if (!fdev)
211                 return -ENOMEM;
212
213         fdev->mdev = mdev;
214         mdev->fpga = fdev;
215
216         return 0;
217 }
218
219 void mlx5_fpga_device_stop(struct mlx5_core_dev *mdev)
220 {
221         struct mlx5_fpga_device *fdev = mdev->fpga;
222         unsigned int max_num_qps;
223         unsigned long flags;
224         int err;
225
226         if (!fdev)
227                 return;
228
229         spin_lock_irqsave(&fdev->state_lock, flags);
230         if (fdev->state != MLX5_FPGA_STATUS_SUCCESS) {
231                 spin_unlock_irqrestore(&fdev->state_lock, flags);
232                 return;
233         }
234         fdev->state = MLX5_FPGA_STATUS_NONE;
235         spin_unlock_irqrestore(&fdev->state_lock, flags);
236
237         if (fdev->last_oper_image == MLX5_FPGA_IMAGE_USER) {
238                 err = mlx5_fpga_ctrl_op(mdev, MLX5_FPGA_CTRL_OPERATION_SANDBOX_BYPASS_ON);
239                 if (err)
240                         mlx5_fpga_err(fdev, "Failed to re-set SBU bypass on: %d\n",
241                                       err);
242         }
243
244         mlx5_fpga_conn_device_cleanup(fdev);
245         max_num_qps = MLX5_CAP_FPGA(mdev, shell_caps.max_num_qps);
246         mlx5_core_unreserve_gids(mdev, max_num_qps);
247 }
248
249 void mlx5_fpga_cleanup(struct mlx5_core_dev *mdev)
250 {
251         struct mlx5_fpga_device *fdev = mdev->fpga;
252
253         mlx5_fpga_device_stop(mdev);
254         kfree(fdev);
255         mdev->fpga = NULL;
256 }
257
258 static const char *mlx5_fpga_syndrome_to_string(u8 syndrome)
259 {
260         if (syndrome < ARRAY_SIZE(mlx5_fpga_error_strings))
261                 return mlx5_fpga_error_strings[syndrome];
262         return "Unknown";
263 }
264
265 void mlx5_fpga_event(struct mlx5_core_dev *mdev, u8 event, void *data)
266 {
267         struct mlx5_fpga_device *fdev = mdev->fpga;
268         const char *event_name;
269         bool teardown = false;
270         unsigned long flags;
271         u8 syndrome;
272
273         if (event != MLX5_EVENT_TYPE_FPGA_ERROR) {
274                 mlx5_fpga_warn_ratelimited(fdev, "Unexpected event %u\n",
275                                            event);
276                 return;
277         }
278
279         syndrome = MLX5_GET(fpga_error_event, data, syndrome);
280         event_name = mlx5_fpga_syndrome_to_string(syndrome);
281
282         spin_lock_irqsave(&fdev->state_lock, flags);
283         switch (fdev->state) {
284         case MLX5_FPGA_STATUS_SUCCESS:
285                 mlx5_fpga_warn(fdev, "Error %u: %s\n", syndrome, event_name);
286                 teardown = true;
287                 break;
288         default:
289                 mlx5_fpga_warn_ratelimited(fdev, "Unexpected error event %u: %s\n",
290                                            syndrome, event_name);
291         }
292         spin_unlock_irqrestore(&fdev->state_lock, flags);
293         /* We tear-down the card's interfaces and functionality because
294          * the FPGA bump-on-the-wire is misbehaving and we lose ability
295          * to communicate with the network. User may still be able to
296          * recover by re-programming or debugging the FPGA
297          */
298         if (teardown)
299                 mlx5_trigger_health_work(fdev->mdev);
300 }