drivers/misc/habanalabs/common/habanalabs_drv.c

   1 // SPDX-License-Identifier: GPL-2.0
   2
   3 /*
   4  * Copyright 2016-2019 HabanaLabs, Ltd.
   5  * All Rights Reserved.
   6  *
   7  */
   8
   9 #define pr_fmt(fmt)             "habanalabs: " fmt
  10
  11 #include "habanalabs.h"
  12
  13 #include <linux/pci.h>
  14 #include <linux/aer.h>
  15 #include <linux/module.h>
  16
  17 #define HL_DRIVER_AUTHOR        "HabanaLabs Kernel Driver Team"
  18
  19 #define HL_DRIVER_DESC          "Driver for HabanaLabs's AI Accelerators"
  20
  21 MODULE_AUTHOR(HL_DRIVER_AUTHOR);
  22 MODULE_DESCRIPTION(HL_DRIVER_DESC);
  23 MODULE_LICENSE("GPL v2");
  24
  25 static int hl_major;
  26 static struct class *hl_class;
  27 static DEFINE_IDR(hl_devs_idr);
  28 static DEFINE_MUTEX(hl_devs_idr_lock);
  29
  30 static int timeout_locked = 30;
  31 static int reset_on_lockup = 1;
  32 static int memory_scrub;
  33 static ulong boot_error_status_mask = ULONG_MAX;
  34
  35 module_param(timeout_locked, int, 0444);
  36 MODULE_PARM_DESC(timeout_locked,
  37         "Device lockup timeout in seconds (0 = disabled, default 30s)");
  38
  39 module_param(reset_on_lockup, int, 0444);
  40 MODULE_PARM_DESC(reset_on_lockup,
  41         "Do device reset on lockup (0 = no, 1 = yes, default yes)");
  42
  43 module_param(memory_scrub, int, 0444);
  44 MODULE_PARM_DESC(memory_scrub,
  45         "Scrub device memory in various states (0 = no, 1 = yes, default no)");
  46
  47 module_param(boot_error_status_mask, ulong, 0444);
  48 MODULE_PARM_DESC(boot_error_status_mask,
  49         "Mask of the error status during device CPU boot (If bitX is cleared then error X is masked. Default all 1's)");
  50
  51 #define PCI_VENDOR_ID_HABANALABS        0x1da3
  52
  53 #define PCI_IDS_GOYA                    0x0001
  54 #define PCI_IDS_GAUDI                   0x1000
  55 #define PCI_IDS_GAUDI_SEC               0x1010
  56
  57 static const struct pci_device_id ids[] = {
  58         { PCI_DEVICE(PCI_VENDOR_ID_HABANALABS, PCI_IDS_GOYA), },
  59         { PCI_DEVICE(PCI_VENDOR_ID_HABANALABS, PCI_IDS_GAUDI), },
  60         { PCI_DEVICE(PCI_VENDOR_ID_HABANALABS, PCI_IDS_GAUDI_SEC), },
  61         { 0, }
  62 };
  63 MODULE_DEVICE_TABLE(pci, ids);
  64
  65 /*
  66  * get_asic_type - translate device id to asic type
  67  *
  68  * @device: id of the PCI device
  69  *
  70  * Translate device id to asic type.
  71  * In case of unidentified device, return -1
  72  */
  73 static enum hl_asic_type get_asic_type(u16 device)
  74 {
  75         enum hl_asic_type asic_type;
  76
  77         switch (device) {
  78         case PCI_IDS_GOYA:
  79                 asic_type = ASIC_GOYA;
  80                 break;
  81         case PCI_IDS_GAUDI:
  82                 asic_type = ASIC_GAUDI;
  83                 break;
  84         case PCI_IDS_GAUDI_SEC:
  85                 asic_type = ASIC_GAUDI_SEC;
  86                 break;
  87         default:
  88                 asic_type = ASIC_INVALID;
  89                 break;
  90         }
  91
  92         return asic_type;
  93 }
  94
  95 static bool is_asic_secured(enum hl_asic_type asic_type)
  96 {
  97         switch (asic_type) {
  98         case ASIC_GAUDI_SEC:
  99                 return true;
 100         default:
 101                 return false;
 102         }
 103 }
 104
 105 /*
 106  * hl_device_open - open function for habanalabs device
 107  *
 108  * @inode: pointer to inode structure
 109  * @filp: pointer to file structure
 110  *
 111  * Called when process opens an habanalabs device.
 112  */
 113 int hl_device_open(struct inode *inode, struct file *filp)
 114 {
 115         enum hl_device_status status;
 116         struct hl_device *hdev;
 117         struct hl_fpriv *hpriv;
 118         int rc;
 119
 120         mutex_lock(&hl_devs_idr_lock);
 121         hdev = idr_find(&hl_devs_idr, iminor(inode));
 122         mutex_unlock(&hl_devs_idr_lock);
 123
 124         if (!hdev) {
 125                 pr_err("Couldn't find device %d:%d\n",
 126                         imajor(inode), iminor(inode));
 127                 return -ENXIO;
 128         }
 129
 130         hpriv = kzalloc(sizeof(*hpriv), GFP_KERNEL);
 131         if (!hpriv)
 132                 return -ENOMEM;
 133
 134         hpriv->hdev = hdev;
 135         filp->private_data = hpriv;
 136         hpriv->filp = filp;
 137         mutex_init(&hpriv->restore_phase_mutex);
 138         kref_init(&hpriv->refcount);
 139         nonseekable_open(inode, filp);
 140
 141         hl_cb_mgr_init(&hpriv->cb_mgr);
 142         hl_ctx_mgr_init(&hpriv->ctx_mgr);
 143
 144         hpriv->taskpid = find_get_pid(current->pid);
 145
 146         mutex_lock(&hdev->fpriv_list_lock);
 147
 148         if (!hl_device_operational(hdev, &status)) {
 149                 dev_err_ratelimited(hdev->dev,
 150                         "Can't open %s because it is %s\n",
 151                         dev_name(hdev->dev), hdev->status[status]);
 152                 rc = -EPERM;
 153                 goto out_err;
 154         }
 155
 156         if (hdev->in_debug) {
 157                 dev_err_ratelimited(hdev->dev,
 158                         "Can't open %s because it is being debugged by another user\n",
 159                         dev_name(hdev->dev));
 160                 rc = -EPERM;
 161                 goto out_err;
 162         }
 163
 164         if (hdev->compute_ctx) {
 165                 dev_dbg_ratelimited(hdev->dev,
 166                         "Can't open %s because another user is working on it\n",
 167                         dev_name(hdev->dev));
 168                 rc = -EBUSY;
 169                 goto out_err;
 170         }
 171
 172         rc = hl_ctx_create(hdev, hpriv);
 173         if (rc) {
 174                 dev_err(hdev->dev, "Failed to create context %d\n", rc);
 175                 goto out_err;
 176         }
 177
 178         /* Device is IDLE at this point so it is legal to change PLLs.
 179          * There is no need to check anything because if the PLL is
 180          * already HIGH, the set function will return without doing
 181          * anything
 182          */
 183         hl_device_set_frequency(hdev, PLL_HIGH);
 184
 185         list_add(&hpriv->dev_node, &hdev->fpriv_list);
 186         mutex_unlock(&hdev->fpriv_list_lock);
 187
 188         hl_debugfs_add_file(hpriv);
 189
 190         hdev->open_counter++;
 191         hdev->last_successful_open_jif = jiffies;
 192
 193         return 0;
 194
 195 out_err:
 196         mutex_unlock(&hdev->fpriv_list_lock);
 197
 198         hl_cb_mgr_fini(hpriv->hdev, &hpriv->cb_mgr);
 199         hl_ctx_mgr_fini(hpriv->hdev, &hpriv->ctx_mgr);
 200         filp->private_data = NULL;
 201         mutex_destroy(&hpriv->restore_phase_mutex);
 202         put_pid(hpriv->taskpid);
 203
 204         kfree(hpriv);
 205
 206         return rc;
 207 }
 208
 209 int hl_device_open_ctrl(struct inode *inode, struct file *filp)
 210 {
 211         struct hl_device *hdev;
 212         struct hl_fpriv *hpriv;
 213         int rc;
 214
 215         mutex_lock(&hl_devs_idr_lock);
 216         hdev = idr_find(&hl_devs_idr, iminor(inode));
 217         mutex_unlock(&hl_devs_idr_lock);
 218
 219         if (!hdev) {
 220                 pr_err("Couldn't find device %d:%d\n",
 221                         imajor(inode), iminor(inode));
 222                 return -ENXIO;
 223         }
 224
 225         hpriv = kzalloc(sizeof(*hpriv), GFP_KERNEL);
 226         if (!hpriv)
 227                 return -ENOMEM;
 228
 229         mutex_lock(&hdev->fpriv_list_lock);
 230
 231         if (!hl_device_operational(hdev, NULL)) {
 232                 dev_err_ratelimited(hdev->dev_ctrl,
 233                         "Can't open %s because it is disabled or in reset\n",
 234                         dev_name(hdev->dev_ctrl));
 235                 rc = -EPERM;
 236                 goto out_err;
 237         }
 238
 239         list_add(&hpriv->dev_node, &hdev->fpriv_list);
 240         mutex_unlock(&hdev->fpriv_list_lock);
 241
 242         hpriv->hdev = hdev;
 243         filp->private_data = hpriv;
 244         hpriv->filp = filp;
 245         hpriv->is_control = true;
 246         nonseekable_open(inode, filp);
 247
 248         hpriv->taskpid = find_get_pid(current->pid);
 249
 250         return 0;
 251
 252 out_err:
 253         mutex_unlock(&hdev->fpriv_list_lock);
 254         kfree(hpriv);
 255         return rc;
 256 }
 257
 258 static void set_driver_behavior_per_device(struct hl_device *hdev)
 259 {
 260         hdev->fw_components = FW_TYPE_ALL_TYPES;
 261         hdev->cpu_queues_enable = 1;
 262         hdev->heartbeat = 1;
 263         hdev->mmu_enable = 1;
 264         hdev->clock_gating_mask = ULONG_MAX;
 265         hdev->sram_scrambler_enable = 1;
 266         hdev->dram_scrambler_enable = 1;
 267         hdev->bmc_enable = 1;
 268         hdev->hard_reset_on_fw_events = 1;
 269         hdev->reset_on_preboot_fail = 1;
 270         hdev->reset_if_device_not_idle = 1;
 271
 272         hdev->reset_pcilink = 0;
 273         hdev->axi_drain = 0;
 274 }
 275
 276 /*
 277  * create_hdev - create habanalabs device instance
 278  *
 279  * @dev: will hold the pointer to the new habanalabs device structure
 280  * @pdev: pointer to the pci device
 281  * @asic_type: in case of simulator device, which device is it
 282  * @minor: in case of simulator device, the minor of the device
 283  *
 284  * Allocate memory for habanalabs device and initialize basic fields
 285  * Identify the ASIC type
 286  * Allocate ID (minor) for the device (only for real devices)
 287  */
 288 int create_hdev(struct hl_device **dev, struct pci_dev *pdev,
 289                 enum hl_asic_type asic_type, int minor)
 290 {
 291         struct hl_device *hdev;
 292         int rc, main_id, ctrl_id = 0;
 293
 294         *dev = NULL;
 295
 296         hdev = kzalloc(sizeof(*hdev), GFP_KERNEL);
 297         if (!hdev)
 298                 return -ENOMEM;
 299
 300         /* First, we must find out which ASIC are we handling. This is needed
 301          * to configure the behavior of the driver (kernel parameters)
 302          */
 303         if (pdev) {
 304                 hdev->asic_type = get_asic_type(pdev->device);
 305                 if (hdev->asic_type == ASIC_INVALID) {
 306                         dev_err(&pdev->dev, "Unsupported ASIC\n");
 307                         rc = -ENODEV;
 308                         goto free_hdev;
 309                 }
 310         } else {
 311                 hdev->asic_type = asic_type;
 312         }
 313
 314         if (pdev)
 315                 hdev->asic_prop.fw_security_enabled =
 316                                         is_asic_secured(hdev->asic_type);
 317         else
 318                 hdev->asic_prop.fw_security_enabled = false;
 319
 320         /* Assign status description string */
 321         strncpy(hdev->status[HL_DEVICE_STATUS_MALFUNCTION],
 322                                         "disabled", HL_STR_MAX);
 323         strncpy(hdev->status[HL_DEVICE_STATUS_IN_RESET],
 324                                         "in reset", HL_STR_MAX);
 325         strncpy(hdev->status[HL_DEVICE_STATUS_NEEDS_RESET],
 326                                         "needs reset", HL_STR_MAX);
 327
 328         hdev->major = hl_major;
 329         hdev->reset_on_lockup = reset_on_lockup;
 330         hdev->memory_scrub = memory_scrub;
 331         hdev->boot_error_status_mask = boot_error_status_mask;
 332         hdev->stop_on_err = true;
 333
 334         hdev->pldm = 0;
 335
 336         set_driver_behavior_per_device(hdev);
 337
 338         hdev->curr_reset_cause = HL_RESET_CAUSE_UNKNOWN;
 339
 340         if (timeout_locked)
 341                 hdev->timeout_jiffies = msecs_to_jiffies(timeout_locked * 1000);
 342         else
 343                 hdev->timeout_jiffies = MAX_SCHEDULE_TIMEOUT;
 344
 345         hdev->disabled = true;
 346         hdev->pdev = pdev; /* can be NULL in case of simulator device */
 347
 348         /* Set default DMA mask to 32 bits */
 349         hdev->dma_mask = 32;
 350
 351         mutex_lock(&hl_devs_idr_lock);
 352
 353         /* Always save 2 numbers, 1 for main device and 1 for control.
 354          * They must be consecutive
 355          */
 356         main_id = idr_alloc(&hl_devs_idr, hdev, 0, HL_MAX_MINORS,
 357                                 GFP_KERNEL);
 358
 359         if (main_id >= 0)
 360                 ctrl_id = idr_alloc(&hl_devs_idr, hdev, main_id + 1,
 361                                         main_id + 2, GFP_KERNEL);
 362
 363         mutex_unlock(&hl_devs_idr_lock);
 364
 365         if ((main_id < 0) || (ctrl_id < 0)) {
 366                 if ((main_id == -ENOSPC) || (ctrl_id == -ENOSPC))
 367                         pr_err("too many devices in the system\n");
 368
 369                 if (main_id >= 0) {
 370                         mutex_lock(&hl_devs_idr_lock);
 371                         idr_remove(&hl_devs_idr, main_id);
 372                         mutex_unlock(&hl_devs_idr_lock);
 373                 }
 374
 375                 rc = -EBUSY;
 376                 goto free_hdev;
 377         }
 378
 379         hdev->id = main_id;
 380         hdev->id_control = ctrl_id;
 381
 382         *dev = hdev;
 383
 384         return 0;
 385
 386 free_hdev:
 387         kfree(hdev);
 388         return rc;
 389 }
 390
 391 /*
 392  * destroy_hdev - destroy habanalabs device instance
 393  *
 394  * @dev: pointer to the habanalabs device structure
 395  *
 396  */
 397 void destroy_hdev(struct hl_device *hdev)
 398 {
 399         /* Remove device from the device list */
 400         mutex_lock(&hl_devs_idr_lock);
 401         idr_remove(&hl_devs_idr, hdev->id);
 402         idr_remove(&hl_devs_idr, hdev->id_control);
 403         mutex_unlock(&hl_devs_idr_lock);
 404
 405         kfree(hdev);
 406 }
 407
 408 static int hl_pmops_suspend(struct device *dev)
 409 {
 410         struct hl_device *hdev = dev_get_drvdata(dev);
 411
 412         pr_debug("Going to suspend PCI device\n");
 413
 414         if (!hdev) {
 415                 pr_err("device pointer is NULL in suspend\n");
 416                 return 0;
 417         }
 418
 419         return hl_device_suspend(hdev);
 420 }
 421
 422 static int hl_pmops_resume(struct device *dev)
 423 {
 424         struct hl_device *hdev = dev_get_drvdata(dev);
 425
 426         pr_debug("Going to resume PCI device\n");
 427
 428         if (!hdev) {
 429                 pr_err("device pointer is NULL in resume\n");
 430                 return 0;
 431         }
 432
 433         return hl_device_resume(hdev);
 434 }
 435
 436 /*
 437  * hl_pci_probe - probe PCI habanalabs devices
 438  *
 439  * @pdev: pointer to pci device
 440  * @id: pointer to pci device id structure
 441  *
 442  * Standard PCI probe function for habanalabs device.
 443  * Create a new habanalabs device and initialize it according to the
 444  * device's type
 445  */
 446 static int hl_pci_probe(struct pci_dev *pdev,
 447                                 const struct pci_device_id *id)
 448 {
 449         struct hl_device *hdev;
 450         int rc;
 451
 452         dev_info(&pdev->dev, HL_NAME
 453                  " device found [%04x:%04x] (rev %x)\n",
 454                  (int)pdev->vendor, (int)pdev->device, (int)pdev->revision);
 455
 456         rc = create_hdev(&hdev, pdev, ASIC_INVALID, -1);
 457         if (rc)
 458                 return rc;
 459
 460         pci_set_drvdata(pdev, hdev);
 461
 462         pci_enable_pcie_error_reporting(pdev);
 463
 464         rc = hl_device_init(hdev, hl_class);
 465         if (rc) {
 466                 dev_err(&pdev->dev, "Fatal error during habanalabs device init\n");
 467                 rc = -ENODEV;
 468                 goto disable_device;
 469         }
 470
 471         return 0;
 472
 473 disable_device:
 474         pci_disable_pcie_error_reporting(pdev);
 475         pci_set_drvdata(pdev, NULL);
 476         destroy_hdev(hdev);
 477
 478         return rc;
 479 }
 480
 481 /*
 482  * hl_pci_remove - remove PCI habanalabs devices
 483  *
 484  * @pdev: pointer to pci device
 485  *
 486  * Standard PCI remove function for habanalabs device
 487  */
 488 static void hl_pci_remove(struct pci_dev *pdev)
 489 {
 490         struct hl_device *hdev;
 491
 492         hdev = pci_get_drvdata(pdev);
 493         if (!hdev)
 494                 return;
 495
 496         hl_device_fini(hdev);
 497         pci_disable_pcie_error_reporting(pdev);
 498         pci_set_drvdata(pdev, NULL);
 499         destroy_hdev(hdev);
 500 }
 501
 502 /**
 503  * hl_pci_err_detected - a PCI bus error detected on this device
 504  *
 505  * @pdev: pointer to pci device
 506  * @state: PCI error type
 507  *
 508  * Called by the PCI subsystem whenever a non-correctable
 509  * PCI bus error is detected
 510  */
 511 static pci_ers_result_t
 512 hl_pci_err_detected(struct pci_dev *pdev, pci_channel_state_t state)
 513 {
 514         struct hl_device *hdev = pci_get_drvdata(pdev);
 515         enum pci_ers_result result;
 516
 517         switch (state) {
 518         case pci_channel_io_normal:
 519                 return PCI_ERS_RESULT_CAN_RECOVER;
 520
 521         case pci_channel_io_frozen:
 522                 dev_warn(hdev->dev, "frozen state error detected\n");
 523                 result = PCI_ERS_RESULT_NEED_RESET;
 524                 break;
 525
 526         case pci_channel_io_perm_failure:
 527                 dev_warn(hdev->dev, "failure state error detected\n");
 528                 result = PCI_ERS_RESULT_DISCONNECT;
 529                 break;
 530
 531         default:
 532                 result = PCI_ERS_RESULT_NONE;
 533         }
 534
 535         hdev->asic_funcs->halt_engines(hdev, true);
 536
 537         return result;
 538 }
 539
 540 /**
 541  * hl_pci_err_resume - resume after a PCI slot reset
 542  *
 543  * @pdev: pointer to pci device
 544  *
 545  */
 546 static void hl_pci_err_resume(struct pci_dev *pdev)
 547 {
 548         struct hl_device *hdev = pci_get_drvdata(pdev);
 549
 550         dev_warn(hdev->dev, "Resuming device after PCI slot reset\n");
 551         hl_device_resume(hdev);
 552 }
 553
 554 /**
 555  * hl_pci_err_slot_reset - a PCI slot reset has just happened
 556  *
 557  * @pdev: pointer to pci device
 558  *
 559  * Determine if the driver can recover from the PCI slot reset
 560  */
 561 static pci_ers_result_t hl_pci_err_slot_reset(struct pci_dev *pdev)
 562 {
 563         return PCI_ERS_RESULT_RECOVERED;
 564 }
 565
 566 static const struct dev_pm_ops hl_pm_ops = {
 567         .suspend = hl_pmops_suspend,
 568         .resume = hl_pmops_resume,
 569 };
 570
 571 static const struct pci_error_handlers hl_pci_err_handler = {
 572         .error_detected = hl_pci_err_detected,
 573         .slot_reset = hl_pci_err_slot_reset,
 574         .resume = hl_pci_err_resume,
 575 };
 576
 577 static struct pci_driver hl_pci_driver = {
 578         .name = HL_NAME,
 579         .id_table = ids,
 580         .probe = hl_pci_probe,
 581         .remove = hl_pci_remove,
 582         .shutdown = hl_pci_remove,
 583         .driver = {
 584                 .name = HL_NAME,
 585                 .pm = &hl_pm_ops,
 586                 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
 587         },
 588         .err_handler = &hl_pci_err_handler,
 589 };
 590
 591 /*
 592  * hl_init - Initialize the habanalabs kernel driver
 593  */
 594 static int __init hl_init(void)
 595 {
 596         int rc;
 597         dev_t dev;
 598
 599         pr_info("loading driver\n");
 600
 601         rc = alloc_chrdev_region(&dev, 0, HL_MAX_MINORS, HL_NAME);
 602         if (rc < 0) {
 603                 pr_err("unable to get major\n");
 604                 return rc;
 605         }
 606
 607         hl_major = MAJOR(dev);
 608
 609         hl_class = class_create(THIS_MODULE, HL_NAME);
 610         if (IS_ERR(hl_class)) {
 611                 pr_err("failed to allocate class\n");
 612                 rc = PTR_ERR(hl_class);
 613                 goto remove_major;
 614         }
 615
 616         hl_debugfs_init();
 617
 618         rc = pci_register_driver(&hl_pci_driver);
 619         if (rc) {
 620                 pr_err("failed to register pci device\n");
 621                 goto remove_debugfs;
 622         }
 623
 624         pr_debug("driver loaded\n");
 625
 626         return 0;
 627
 628 remove_debugfs:
 629         hl_debugfs_fini();
 630         class_destroy(hl_class);
 631 remove_major:
 632         unregister_chrdev_region(MKDEV(hl_major, 0), HL_MAX_MINORS);
 633         return rc;
 634 }
 635
 636 /*
 637  * hl_exit - Release all resources of the habanalabs kernel driver
 638  */
 639 static void __exit hl_exit(void)
 640 {
 641         pci_unregister_driver(&hl_pci_driver);
 642
 643         /*
 644          * Removing debugfs must be after all devices or simulator devices
 645          * have been removed because otherwise we get a bug in the
 646          * debugfs module for referencing NULL objects
 647          */
 648         hl_debugfs_fini();
 649
 650         class_destroy(hl_class);
 651         unregister_chrdev_region(MKDEV(hl_major, 0), HL_MAX_MINORS);
 652
 653         idr_destroy(&hl_devs_idr);
 654
 655         pr_debug("driver removed\n");
 656 }
 657
 658 module_init(hl_init);
 659 module_exit(hl_exit);