net/mlx5: FPGA, Abort FPGA init if the device reports no QP capability
[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; SBU %06x:%04x version %d\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                        MLX5_CAP_FPGA(fdev->mdev, ieee_vendor_id),
169                        MLX5_CAP_FPGA(fdev->mdev, sandbox_product_id),
170                        MLX5_CAP_FPGA(fdev->mdev, sandbox_product_version));
171
172         max_num_qps = MLX5_CAP_FPGA(mdev, shell_caps.max_num_qps);
173         if (!max_num_qps) {
174                 mlx5_fpga_err(fdev, "FPGA reports 0 QPs in SHELL_CAPS\n");
175                 err = -ENOTSUPP;
176                 goto out;
177         }
178
179         err = mlx5_core_reserve_gids(mdev, max_num_qps);
180         if (err)
181                 goto out;
182
183         err = mlx5_fpga_conn_device_init(fdev);
184         if (err)
185                 goto err_rsvd_gid;
186
187         if (fdev->last_oper_image == MLX5_FPGA_IMAGE_USER) {
188                 err = mlx5_fpga_device_brb(fdev);
189                 if (err)
190                         goto err_conn_init;
191         }
192
193         goto out;
194
195 err_conn_init:
196         mlx5_fpga_conn_device_cleanup(fdev);
197
198 err_rsvd_gid:
199         mlx5_core_unreserve_gids(mdev, max_num_qps);
200 out:
201         spin_lock_irqsave(&fdev->state_lock, flags);
202         fdev->state = err ? MLX5_FPGA_STATUS_FAILURE : MLX5_FPGA_STATUS_SUCCESS;
203         spin_unlock_irqrestore(&fdev->state_lock, flags);
204         return err;
205 }
206
207 int mlx5_fpga_init(struct mlx5_core_dev *mdev)
208 {
209         struct mlx5_fpga_device *fdev = NULL;
210
211         if (!MLX5_CAP_GEN(mdev, fpga)) {
212                 mlx5_core_dbg(mdev, "FPGA capability not present\n");
213                 return 0;
214         }
215
216         mlx5_core_dbg(mdev, "Initializing FPGA\n");
217
218         fdev = mlx5_fpga_device_alloc();
219         if (!fdev)
220                 return -ENOMEM;
221
222         fdev->mdev = mdev;
223         mdev->fpga = fdev;
224
225         return 0;
226 }
227
228 void mlx5_fpga_device_stop(struct mlx5_core_dev *mdev)
229 {
230         struct mlx5_fpga_device *fdev = mdev->fpga;
231         unsigned int max_num_qps;
232         unsigned long flags;
233         int err;
234
235         if (!fdev)
236                 return;
237
238         spin_lock_irqsave(&fdev->state_lock, flags);
239         if (fdev->state != MLX5_FPGA_STATUS_SUCCESS) {
240                 spin_unlock_irqrestore(&fdev->state_lock, flags);
241                 return;
242         }
243         fdev->state = MLX5_FPGA_STATUS_NONE;
244         spin_unlock_irqrestore(&fdev->state_lock, flags);
245
246         if (fdev->last_oper_image == MLX5_FPGA_IMAGE_USER) {
247                 err = mlx5_fpga_ctrl_op(mdev, MLX5_FPGA_CTRL_OPERATION_SANDBOX_BYPASS_ON);
248                 if (err)
249                         mlx5_fpga_err(fdev, "Failed to re-set SBU bypass on: %d\n",
250                                       err);
251         }
252
253         mlx5_fpga_conn_device_cleanup(fdev);
254         max_num_qps = MLX5_CAP_FPGA(mdev, shell_caps.max_num_qps);
255         mlx5_core_unreserve_gids(mdev, max_num_qps);
256 }
257
258 void mlx5_fpga_cleanup(struct mlx5_core_dev *mdev)
259 {
260         struct mlx5_fpga_device *fdev = mdev->fpga;
261
262         mlx5_fpga_device_stop(mdev);
263         kfree(fdev);
264         mdev->fpga = NULL;
265 }
266
267 static const char *mlx5_fpga_syndrome_to_string(u8 syndrome)
268 {
269         if (syndrome < ARRAY_SIZE(mlx5_fpga_error_strings))
270                 return mlx5_fpga_error_strings[syndrome];
271         return "Unknown";
272 }
273
274 void mlx5_fpga_event(struct mlx5_core_dev *mdev, u8 event, void *data)
275 {
276         struct mlx5_fpga_device *fdev = mdev->fpga;
277         const char *event_name;
278         bool teardown = false;
279         unsigned long flags;
280         u8 syndrome;
281
282         if (event != MLX5_EVENT_TYPE_FPGA_ERROR) {
283                 mlx5_fpga_warn_ratelimited(fdev, "Unexpected event %u\n",
284                                            event);
285                 return;
286         }
287
288         syndrome = MLX5_GET(fpga_error_event, data, syndrome);
289         event_name = mlx5_fpga_syndrome_to_string(syndrome);
290
291         spin_lock_irqsave(&fdev->state_lock, flags);
292         switch (fdev->state) {
293         case MLX5_FPGA_STATUS_SUCCESS:
294                 mlx5_fpga_warn(fdev, "Error %u: %s\n", syndrome, event_name);
295                 teardown = true;
296                 break;
297         default:
298                 mlx5_fpga_warn_ratelimited(fdev, "Unexpected error event %u: %s\n",
299                                            syndrome, event_name);
300         }
301         spin_unlock_irqrestore(&fdev->state_lock, flags);
302         /* We tear-down the card's interfaces and functionality because
303          * the FPGA bump-on-the-wire is misbehaving and we lose ability
304          * to communicate with the network. User may still be able to
305          * recover by re-programming or debugging the FPGA
306          */
307         if (teardown)
308                 mlx5_trigger_health_work(fdev->mdev);
309 }