sys/dev/smartpqi/smartpqi_ioctl.c

   1 /*-
   2  * Copyright 2016-2021 Microchip Technology, Inc. and/or its subsidiaries.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  14  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  16  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  17  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  18  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  19  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  20  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  21  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  22  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  23  * SUCH DAMAGE.
  24  */
  25
  26 /* $FreeBSD$ */
  27
  28 /*
  29  * Management interface for smartpqi driver
  30  */
  31
  32 #include "smartpqi_includes.h"
  33
  34 /*
  35  * Wrapper function to copy to user from kernel
  36  */
  37 int
  38 os_copy_to_user(struct pqisrc_softstate *softs, void *dest_buf,
  39                 void *src_buf, int size, int mode)
  40 {
  41         return(copyout(src_buf, dest_buf, size));
  42 }
  43
  44 /*
  45  * Wrapper function to copy from user to kernel
  46  */
  47 int
  48 os_copy_from_user(struct pqisrc_softstate *softs, void *dest_buf,
  49                 void *src_buf, int size, int mode)
  50 {
  51         return(copyin(src_buf, dest_buf, size));
  52 }
  53
  54 /*
  55  * Device open function for ioctl entry
  56  */
  57 static int
  58 smartpqi_open(struct cdev *cdev, int flags, int devtype,
  59                 struct thread *td)
  60 {
  61         return BSD_SUCCESS;
  62 }
  63
  64 /*
  65  * Device close function for ioctl entry
  66  */
  67 static int
  68 smartpqi_close(struct cdev *cdev, int flags, int devtype,
  69                 struct thread *td)
  70 {
  71         return BSD_SUCCESS;
  72 }
  73
  74 /*
  75  * ioctl for getting driver info
  76  */
  77 static void
  78 smartpqi_get_driver_info_ioctl(caddr_t udata, struct cdev *cdev)
  79 {
  80         struct pqisrc_softstate *softs = cdev->si_drv1;
  81         pdriver_info driver_info = (pdriver_info)udata;
  82
  83         DBG_FUNC("IN udata = %p cdev = %p\n", udata, cdev);
  84
  85         driver_info->major_version = PQISRC_OS_VERSION;
  86         driver_info->minor_version = PQISRC_FEATURE_VERSION;
  87         driver_info->release_version = PQISRC_PATCH_VERSION;
  88         driver_info->build_revision = PQISRC_BUILD_VERSION;
  89         driver_info->max_targets = PQI_MAX_DEVICES - 1;
  90         driver_info->max_io = softs->max_io_for_scsi_ml;
  91         driver_info->max_transfer_length = softs->pqi_cap.max_transfer_size;
  92
  93         DBG_FUNC("OUT\n");
  94 }
  95
  96 /*
  97  * ioctl for getting controller info
  98  */
  99 static void
 100 smartpqi_get_pci_info_ioctl(caddr_t udata, struct cdev *cdev)
 101 {
 102         struct pqisrc_softstate *softs = cdev->si_drv1;
 103         device_t dev = softs->os_specific.pqi_dev;
 104         pqi_pci_info_t *pci_info = (pqi_pci_info_t *)udata;
 105         uint32_t sub_vendor = 0;
 106         uint32_t sub_device = 0;
 107         uint32_t vendor = 0;
 108         uint32_t device = 0;
 109
 110         DBG_FUNC("IN udata = %p cdev = %p\n", udata, cdev);
 111
 112         pci_info->bus = pci_get_bus(dev);
 113         pci_info->dev_fn = pci_get_function(dev);
 114         pci_info->domain = pci_get_domain(dev);
 115         sub_vendor = pci_read_config(dev, PCIR_SUBVEND_0, 2);
 116         sub_device = pci_read_config(dev, PCIR_SUBDEV_0, 2);
 117         pci_info->board_id = ((sub_device << 16) & 0xffff0000) | sub_vendor;
 118         vendor = pci_get_vendor(dev);
 119         device =  pci_get_device(dev);
 120         pci_info->chip_id = ((device << 16) & 0xffff0000) | vendor;
 121         DBG_FUNC("OUT\n");
 122 }
 123
 124 static inline int
 125 pqi_status_to_bsd_ioctl_status(int pqi_status)
 126 {
 127         if (PQI_STATUS_SUCCESS == pqi_status)
 128                 return BSD_SUCCESS;
 129         else
 130                 return EIO;
 131 }
 132
 133 /*
 134  * ioctl entry point for user
 135  */
 136 static int
 137 smartpqi_ioctl(struct cdev *cdev, u_long cmd, caddr_t udata,
 138                 int flags, struct thread *td)
 139 {
 140         int bsd_status, pqi_status;
 141         struct pqisrc_softstate *softs = cdev->si_drv1;
 142
 143         DBG_FUNC("IN cmd = 0x%lx udata = %p cdev = %p\n", cmd, udata, cdev);
 144
 145         if (!udata) {
 146                 DBG_ERR("udata is null !!\n");
 147                 return EINVAL;
 148         }
 149
 150         if (pqisrc_ctrl_offline(softs)){
 151                 return ENOTTY;
 152         }
 153
 154         switch (cmd) {
 155                 case CCISS_GETDRIVVER:
 156                         smartpqi_get_driver_info_ioctl(udata, cdev);
 157                         bsd_status = BSD_SUCCESS;
 158                         break;
 159                 case CCISS_GETPCIINFO:
 160                         smartpqi_get_pci_info_ioctl(udata, cdev);
 161                         bsd_status = BSD_SUCCESS;
 162                         break;
 163                 case SMARTPQI_PASS_THRU:
 164                 case CCISS_PASSTHRU:
 165                         pqi_status = pqisrc_passthru_ioctl(softs, udata, 0);
 166                         bsd_status = pqi_status_to_bsd_ioctl_status(pqi_status);
 167                         break;
 168                 case CCISS_REGNEWD:
 169                         pqi_status = pqisrc_scan_devices(softs);
 170                         bsd_status = pqi_status_to_bsd_ioctl_status(pqi_status);
 171                         break;
 172                 default:
 173                         DBG_WARN( "!IOCTL cmd 0x%lx not supported\n", cmd);
 174                         bsd_status = ENOTTY;
 175                         break;
 176         }
 177
 178         DBG_FUNC("OUT error = %d\n", bsd_status);
 179         return bsd_status;
 180 }
 181
 182 static struct cdevsw smartpqi_cdevsw =
 183 {
 184         .d_version = D_VERSION,
 185         .d_open    = smartpqi_open,
 186         .d_close   = smartpqi_close,
 187         .d_ioctl   = smartpqi_ioctl,
 188         .d_name    = "smartpqi",
 189 };
 190
 191 /*
 192  * Function to create device node for ioctl
 193  */
 194 int
 195 create_char_dev(struct pqisrc_softstate *softs, int card_index)
 196 {
 197         int error = BSD_SUCCESS;
 198
 199         DBG_FUNC("IN idx = %d\n", card_index);
 200
 201         softs->os_specific.cdev = make_dev(&smartpqi_cdevsw, card_index,
 202                                 UID_ROOT, GID_OPERATOR, 0640,
 203                                 "smartpqi%u", card_index);
 204         if(softs->os_specific.cdev) {
 205                 softs->os_specific.cdev->si_drv1 = softs;
 206         } else {
 207                 error = ENXIO;
 208         }
 209
 210         DBG_FUNC("OUT error = %d\n", error);
 211
 212         return error;
 213 }
 214
 215 /*
 216  * Function to destroy device node for ioctl
 217  */
 218 void
 219 destroy_char_dev(struct pqisrc_softstate *softs)
 220 {
 221         DBG_FUNC("IN\n");
 222         if (softs->os_specific.cdev) {
 223                 destroy_dev(softs->os_specific.cdev);
 224                 softs->os_specific.cdev = NULL;
 225         }
 226         DBG_FUNC("OUT\n");
 227 }
 228
 229 /*
 230  * Function used to send passthru commands to adapter
 231  * to support management tools. For eg. ssacli, sscon.
 232  */
 233 int
 234 pqisrc_passthru_ioctl(struct pqisrc_softstate *softs, void *arg, int mode)
 235 {
 236         int ret = PQI_STATUS_SUCCESS;
 237         char *drv_buf = NULL;
 238         uint32_t tag = 0;
 239         IOCTL_Command_struct *iocommand = (IOCTL_Command_struct *)arg;
 240         dma_mem_t ioctl_dma_buf;
 241         pqisrc_raid_req_t request;
 242         raid_path_error_info_elem_t error_info;
 243         ib_queue_t *ib_q = &softs->op_raid_ib_q[PQI_DEFAULT_IB_QUEUE];
 244         ob_queue_t *ob_q = &softs->op_ob_q[PQI_DEFAULT_IB_QUEUE];
 245         rcb_t *rcb = NULL;
 246
 247         memset(&request, 0, sizeof(request));
 248         memset(&error_info, 0, sizeof(error_info));
 249
 250         DBG_FUNC("IN");
 251
 252         if (pqisrc_ctrl_offline(softs))
 253                 return PQI_STATUS_FAILURE;
 254
 255         if (!arg)
 256                 return (PQI_STATUS_FAILURE);
 257
 258         if (iocommand->buf_size < 1 &&
 259                 iocommand->Request.Type.Direction != PQIIOCTL_NONE)
 260                 return PQI_STATUS_FAILURE;
 261         if (iocommand->Request.CDBLen > sizeof(request.cdb))
 262                 return PQI_STATUS_FAILURE;
 263
 264         switch (iocommand->Request.Type.Direction) {
 265                 case PQIIOCTL_NONE:
 266                 case PQIIOCTL_WRITE:
 267                 case PQIIOCTL_READ:
 268                 case PQIIOCTL_BIDIRECTIONAL:
 269                         break;
 270                 default:
 271                         return PQI_STATUS_FAILURE;
 272         }
 273
 274         if (iocommand->buf_size > 0) {
 275                 memset(&ioctl_dma_buf, 0, sizeof(struct dma_mem));
 276                 ioctl_dma_buf.tag = "Ioctl_PassthruCmd_Buffer";
 277                 ioctl_dma_buf.size = iocommand->buf_size;
 278                 ioctl_dma_buf.align = PQISRC_DEFAULT_DMA_ALIGN;
 279                 /* allocate memory */
 280                 ret = os_dma_mem_alloc(softs, &ioctl_dma_buf);
 281                 if (ret) {
 282                         DBG_ERR("Failed to Allocate dma mem for Ioctl PassthruCmd Buffer : %d\n", ret);
 283                         ret = PQI_STATUS_FAILURE;
 284                         goto out;
 285                 }
 286
 287                 DBG_INFO("ioctl_dma_buf.dma_addr  = %p\n",(void*)ioctl_dma_buf.dma_addr);
 288                 DBG_INFO("ioctl_dma_buf.virt_addr = %p\n",(void*)ioctl_dma_buf.virt_addr);
 289
 290                 drv_buf = (char *)ioctl_dma_buf.virt_addr;
 291                 if (iocommand->Request.Type.Direction & PQIIOCTL_WRITE) {
 292                         if ((ret = os_copy_from_user(softs, (void *)drv_buf,
 293                                         (void *)iocommand->buf,
 294                                         iocommand->buf_size, mode)) != 0) {
 295                                 ret = PQI_STATUS_FAILURE;
 296                                 goto free_mem;
 297                         }
 298                 }
 299         }
 300
 301         request.header.iu_type = PQI_IU_TYPE_RAID_PATH_IO_REQUEST;
 302         request.header.iu_length = offsetof(pqisrc_raid_req_t, sg_descriptors[1]) -
 303                                                                         PQI_REQUEST_HEADER_LENGTH;
 304         memcpy(request.lun_number, iocommand->LUN_info.LunAddrBytes,
 305                 sizeof(request.lun_number));
 306         memcpy(request.cdb, iocommand->Request.CDB, iocommand->Request.CDBLen);
 307         request.additional_cdb_bytes_usage = PQI_ADDITIONAL_CDB_BYTES_0;
 308
 309         switch (iocommand->Request.Type.Direction) {
 310         case PQIIOCTL_NONE:
 311                 request.data_direction = SOP_DATA_DIR_NONE;
 312                 break;
 313         case PQIIOCTL_WRITE:
 314                 request.data_direction = SOP_DATA_DIR_FROM_DEVICE;
 315                 break;
 316         case PQIIOCTL_READ:
 317                 request.data_direction = SOP_DATA_DIR_TO_DEVICE;
 318                 break;
 319         case PQIIOCTL_BIDIRECTIONAL:
 320                 request.data_direction = SOP_DATA_DIR_BIDIRECTIONAL;
 321                 break;
 322         }
 323
 324         request.task_attribute = SOP_TASK_ATTRIBUTE_SIMPLE;
 325         if (iocommand->buf_size > 0) {
 326                 request.buffer_length = iocommand->buf_size;
 327                 request.sg_descriptors[0].addr = ioctl_dma_buf.dma_addr;
 328                 request.sg_descriptors[0].len = iocommand->buf_size;
 329                 request.sg_descriptors[0].flags =  SG_FLAG_LAST;
 330         }
 331         tag = pqisrc_get_tag(&softs->taglist);
 332         if (INVALID_ELEM == tag) {
 333                 DBG_ERR("Tag not available\n");
 334                 ret = PQI_STATUS_FAILURE;
 335                 goto free_mem;
 336         }
 337         request.request_id = tag;
 338         request.response_queue_id = ob_q->q_id;
 339         request.error_index = request.request_id;
 340         if (softs->timeout_in_passthrough) {
 341                 request.timeout_in_sec = iocommand->Request.Timeout;
 342         }
 343
 344         rcb = &softs->rcb[tag];
 345         rcb->success_cmp_callback = pqisrc_process_internal_raid_response_success;
 346         rcb->error_cmp_callback = pqisrc_process_internal_raid_response_error;
 347         rcb->tag = tag;
 348         rcb->req_pending = true;
 349         /* Submit Command */
 350         ret = pqisrc_submit_cmnd(softs, ib_q, &request);
 351         if (ret != PQI_STATUS_SUCCESS) {
 352                 DBG_ERR("Unable to submit command\n");
 353                 goto err_out;
 354         }
 355
 356         ret = pqisrc_wait_on_condition(softs, rcb,
 357                         PQISRC_PASSTHROUGH_CMD_TIMEOUT);
 358         if (ret != PQI_STATUS_SUCCESS) {
 359                 DBG_ERR("Passthru IOCTL cmd timed out !!\n");
 360                 goto err_out;
 361         }
 362
 363         memset(&iocommand->error_info, 0, sizeof(iocommand->error_info));
 364
 365
 366         if (rcb->status) {
 367                 size_t sense_data_length;
 368
 369                 memcpy(&error_info, rcb->error_info, sizeof(error_info));
 370                 iocommand->error_info.ScsiStatus = error_info.status;
 371                 sense_data_length = error_info.sense_data_len;
 372
 373                 if (!sense_data_length)
 374                         sense_data_length = error_info.resp_data_len;
 375
 376                 if (sense_data_length &&
 377                         (sense_data_length > sizeof(error_info.data)))
 378                                 sense_data_length = sizeof(error_info.data);
 379
 380                 if (sense_data_length) {
 381                         if (sense_data_length >
 382                                 sizeof(iocommand->error_info.SenseInfo))
 383                                 sense_data_length =
 384                                         sizeof(iocommand->error_info.SenseInfo);
 385                         memcpy (iocommand->error_info.SenseInfo,
 386                                         error_info.data, sense_data_length);
 387                         iocommand->error_info.SenseLen = sense_data_length;
 388                 }
 389
 390                 if (error_info.data_out_result ==
 391                                 PQI_RAID_DATA_IN_OUT_UNDERFLOW){
 392                         rcb->status = REQUEST_SUCCESS;
 393                 }
 394         }
 395
 396         if (rcb->status == REQUEST_SUCCESS && iocommand->buf_size > 0 &&
 397                 (iocommand->Request.Type.Direction & PQIIOCTL_READ)) {
 398
 399                 if ((ret = os_copy_to_user(softs, (void*)iocommand->buf,
 400                         (void*)drv_buf, iocommand->buf_size, mode)) != 0) {
 401                                 DBG_ERR("Failed to copy the response\n");
 402                                 goto err_out;
 403                 }
 404         }
 405
 406         os_reset_rcb(rcb);
 407         pqisrc_put_tag(&softs->taglist, request.request_id);
 408         if (iocommand->buf_size > 0)
 409                         os_dma_mem_free(softs,&ioctl_dma_buf);
 410
 411         DBG_FUNC("OUT\n");
 412         return ret;
 413 err_out:
 414         os_reset_rcb(rcb);
 415         pqisrc_put_tag(&softs->taglist, request.request_id);
 416
 417 free_mem:
 418         if (iocommand->buf_size > 0)
 419                 os_dma_mem_free(softs, &ioctl_dma_buf);
 420
 421 out:
 422         DBG_FUNC("Failed OUT\n");
 423         return PQI_STATUS_FAILURE;
 424 }