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 * $FreeBSD$ 33 */ 34 35 #include <sys/param.h> 36 #include <sys/systm.h> 37 #include <sys/conf.h> 38 #include <dev/mlx5/mlx5io.h> 39 #include <dev/mlx5/mlx5_fpga_tools/tools_char.h> 40 41 #define CHUNK_SIZE (128 * 1024) 42 43 struct tools_context { 44 struct mlx5_fpga_tools_dev *tdev; 45 enum mlx5_fpga_access_type access_type; 46 }; 47 48 static void 49 tools_char_ctx_dtor(void *data) 50 { 51 52 free(data, M_DEVBUF); 53 } 54 55 static int 56 tools_char_open(struct cdev *dev, int oflags, int devtype, struct thread *td) 57 { 58 struct tools_context *context; 59 60 context = malloc(sizeof(*context), M_DEVBUF, M_WAITOK); 61 context->tdev = dev->si_drv1; 62 context->access_type = MLX5_FPGA_ACCESS_TYPE_DONTCARE; 63 devfs_set_cdevpriv(context, tools_char_ctx_dtor); 64 return (0); 65 } 66 67 static int 68 mem_read(struct mlx5_fpga_tools_dev *tdev, void *buf, size_t count, 69 u64 address, enum mlx5_fpga_access_type access_type, size_t *retcnt) 70 { 71 int ret; 72 73 ret = sx_xlock_sig(&tdev->lock); 74 if (ret != 0) 75 return (ret); 76 ret = mlx5_fpga_mem_read(tdev->fdev, count, address, buf, access_type); 77 sx_xunlock(&tdev->lock); 78 if (ret < 0) { 79 dev_dbg(mlx5_fpga_dev(tdev->fdev), 80 "Failed to read %zu bytes at address 0x%jx: %d\n", 81 count, (uintmax_t)address, ret); 82 return (-ret); 83 } 84 *retcnt = ret; 85 return (0); 86 } 87 88 static int 89 mem_write(struct mlx5_fpga_tools_dev *tdev, void *buf, size_t count, 90 u64 address, enum mlx5_fpga_access_type access_type, size_t *retcnt) 91 { 92 int ret; 93 94 ret = sx_xlock_sig(&tdev->lock); 95 if (ret != 0) 96 return (ret); 97 ret = mlx5_fpga_mem_write(tdev->fdev, count, address, buf, access_type); 98 sx_xunlock(&tdev->lock); 99 if (ret < 0) { 100 dev_dbg(mlx5_fpga_dev(tdev->fdev), 101 "Failed to write %zu bytes at address 0x%jx: %d\n", 102 count, (uintmax_t)address, ret); 103 return (-ret); 104 } 105 *retcnt = ret; 106 return (0); 107 } 108 109 static void 110 tools_char_llseek(struct tools_context *context, struct uio *uio, ssize_t *len) 111 { 112 uint64_t fbase, fsize; 113 size_t llen; 114 115 llen = uio->uio_resid; 116 if (llen < 1) { 117 *len = 0; 118 return; 119 } 120 if (llen > CHUNK_SIZE) 121 llen = CHUNK_SIZE; 122 fbase = mlx5_fpga_ddr_base_get(context->tdev->fdev); 123 fsize = mlx5_fpga_ddr_size_get(context->tdev->fdev); 124 if (uio->uio_offset > fbase) 125 *len = 0; 126 else if (uio->uio_offset + *len > fbase + fsize) 127 *len = fbase + fsize - uio->uio_offset; 128 else 129 *len = llen; 130 } 131 132 static int 133 tools_char_read(struct cdev *dev, struct uio *uio, int ioflag) 134 { 135 struct tools_context *context; 136 void *kbuf; 137 size_t len, len1; 138 int ret; 139 140 ret = devfs_get_cdevpriv((void **)&context); 141 if (ret != 0) 142 return (ret); 143 dev_dbg(mlx5_fpga_dev(context->tdev->fdev), 144 "tools char device reading %zu bytes at 0x%jx\n", uio->uio_resid, 145 (uintmax_t)uio->uio_offset); 146 147 tools_char_llseek(context, uio, &len); 148 if (len == 0) 149 return (0); 150 151 kbuf = malloc(len, M_DEVBUF, M_WAITOK); 152 ret = mem_read(context->tdev, kbuf, len, uio->uio_offset, 153 context->access_type, &len1); 154 if (ret == 0) 155 ret = uiomove(kbuf, len1, uio); 156 free(kbuf, M_DEVBUF); 157 return (ret); 158 } 159 160 static int 161 tools_char_write(struct cdev *dev, struct uio *uio, int ioflag) 162 { 163 struct tools_context *context; 164 void *kbuf; 165 off_t of; 166 size_t len, len1; 167 int ret; 168 169 ret = devfs_get_cdevpriv((void **)&context); 170 if (ret != 0) 171 return (ret); 172 dev_dbg(mlx5_fpga_dev(context->tdev->fdev), 173 "tools char device reading %zu bytes at 0x%jx\n", uio->uio_resid, 174 (uintmax_t)uio->uio_offset); 175 176 tools_char_llseek(context, uio, &len); 177 if (len == 0) 178 return (0); 179 180 kbuf = malloc(len, M_DEVBUF, M_WAITOK); 181 len1 = uio->uio_resid; 182 of = uio->uio_offset; 183 184 ret = uiomove(kbuf, len, uio); 185 if (ret == 0) { 186 len1 -= uio->uio_resid; 187 ret = mem_write(context->tdev, kbuf, len, of, 188 context->access_type, &len1); 189 } 190 free(kbuf, M_DEVBUF); 191 return (ret); 192 } 193 194 CTASSERT(MLX5_FPGA_CAP_ARR_SZ == MLX5_ST_SZ_DW(fpga_cap)); 195 196 static int 197 tools_char_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag, 198 struct thread *td) 199 { 200 struct tools_context *context; 201 struct mlx5_fpga_device *fdev; 202 struct mlx5_fpga_query query; 203 u32 fpga_cap[MLX5_ST_SZ_DW(fpga_cap)] = {0}; 204 int arg, err; 205 206 err = devfs_get_cdevpriv((void **)&context); 207 if (err != 0) 208 return (err); 209 fdev = context->tdev->fdev; 210 if (fdev == NULL) 211 return (ENXIO); 212 213 switch (cmd) { 214 case MLX5_FPGA_ACCESS_TYPE: 215 arg = *(int *)data; 216 if (arg > MLX5_FPGA_ACCESS_TYPE_MAX) { 217 dev_err(mlx5_fpga_dev(fdev), 218 "unknown access type %u\n", arg); 219 err = EINVAL; 220 break; 221 } 222 context->access_type = arg; 223 break; 224 case MLX5_FPGA_LOAD: 225 arg = *(int *)data; 226 if (arg > MLX5_FPGA_IMAGE_MAX) { 227 dev_err(mlx5_fpga_dev(fdev), 228 "unknown image type %u\n", arg); 229 err = EINVAL; 230 break; 231 } 232 err = mlx5_fpga_device_reload(fdev, arg); 233 break; 234 case MLX5_FPGA_RESET: 235 err = mlx5_fpga_device_reload(fdev, MLX5_FPGA_IMAGE_MAX + 1); 236 break; 237 case MLX5_FPGA_IMAGE_SEL: 238 arg = *(int *)data; 239 if (arg > MLX5_FPGA_IMAGE_MAX) { 240 dev_err(mlx5_fpga_dev(fdev), 241 "unknown image type %u\n", arg); 242 err = EINVAL; 243 break; 244 } 245 err = mlx5_fpga_flash_select(fdev, arg); 246 break; 247 case MLX5_FPGA_QUERY: 248 mlx5_fpga_device_query(fdev, &query); 249 bcopy(&query, data, sizeof(query)); 250 err = 0; 251 break; 252 case MLX5_FPGA_CAP: 253 mlx5_fpga_get_cap(fdev, fpga_cap); 254 bcopy(&fpga_cap, data, sizeof(fpga_cap)); 255 err = 0; 256 break; 257 default: 258 dev_err(mlx5_fpga_dev(fdev), 259 "unknown ioctl command %#08lx\n", cmd); 260 err = ENOTTY; 261 } 262 return (err); 263 } 264 265 static struct cdevsw mlx5_tools_char_cdevsw = { 266 .d_version = D_VERSION, 267 .d_name = "mlx5_tools_char", 268 .d_open = tools_char_open, 269 .d_read = tools_char_read, 270 .d_write = tools_char_write, 271 .d_ioctl = tools_char_ioctl, 272 }; 273 274 int 275 mlx5_fpga_tools_char_add_one(struct mlx5_fpga_tools_dev *tdev) 276 { 277 struct make_dev_args mda; 278 struct cdev *cd; 279 device_t bdev; 280 int ret; 281 282 make_dev_args_init(&mda); 283 mda.mda_flags = MAKEDEV_WAITOK | MAKEDEV_CHECKNAME; 284 mda.mda_devsw = &mlx5_tools_char_cdevsw; 285 mda.mda_uid = UID_ROOT; 286 mda.mda_gid = GID_OPERATOR; 287 mda.mda_mode = 0660; 288 mda.mda_si_drv1 = tdev; 289 bdev = mlx5_fpga_dev(tdev->fdev)->bsddev; 290 ret = make_dev_s(&mda, &cd, 291 "%04x:%02x:%02x.%x" MLX5_FPGA_TOOLS_NAME_SUFFIX, 292 pci_get_domain(bdev), pci_get_bus(bdev), pci_get_slot(bdev), 293 pci_get_function(bdev)); 294 if (ret != 0) { 295 tdev->char_device = NULL; 296 dev_err(mlx5_fpga_dev(tdev->fdev), 297 "Failed to create a char device: %d\n", ret); 298 return (-ret); 299 } 300 tdev->char_device = cd; 301 302 dev_dbg(mlx5_fpga_dev(tdev->fdev), "tools char device %s created\n", 303 cd->si_name); 304 return (0); 305 } 306 307 void mlx5_fpga_tools_char_remove_one(struct mlx5_fpga_tools_dev *tdev) 308 { 309 310 dev_err(mlx5_fpga_dev(tdev->fdev), "tools char device %s destroyed\n", 311 ((struct cdev *)(tdev->char_device))->si_name); 312 destroy_dev((struct cdev *)(tdev->char_device)); 313 } 314 315 int 316 mlx5_fpga_tools_char_init(void) 317 { 318 319 return (0); 320 } 321 322 void 323 mlx5_fpga_tools_char_deinit(void) 324 { 325 } 326