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 = get_task_pid(current, PIDTYPE_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         hl_cb_mgr_fini(hpriv->hdev, &hpriv->cb_mgr);
 198         hl_ctx_mgr_fini(hpriv->hdev, &hpriv->ctx_mgr);
 199         filp->private_data = NULL;
 200         mutex_destroy(&hpriv->restore_phase_mutex);
 201         put_pid(hpriv->taskpid);
 202
 203         kfree(hpriv);
 204
 205         return rc;
 206 }
 207
 208 int hl_device_open_ctrl(struct inode *inode, struct file *filp)
 209 {
 210         struct hl_device *hdev;
 211         struct hl_fpriv *hpriv;
 212         int rc;
 213
 214         mutex_lock(&hl_devs_idr_lock);
 215         hdev = idr_find(&hl_devs_idr, iminor(inode));
 216         mutex_unlock(&hl_devs_idr_lock);
 217
 218         if (!hdev) {
 219                 pr_err("Couldn't find device %d:%d\n",
 220                         imajor(inode), iminor(inode));
 221                 return -ENXIO;
 222         }
 223
 224         hpriv = kzalloc(sizeof(*hpriv), GFP_KERNEL);
 225         if (!hpriv)
 226                 return -ENOMEM;
 227
 228         mutex_lock(&hdev->fpriv_list_lock);
 229
 230         if (!hl_device_operational(hdev, NULL)) {
 231                 dev_err_ratelimited(hdev->dev_ctrl,
 232                         "Can't open %s because it is disabled or in reset\n",
 233                         dev_name(hdev->dev_ctrl));
 234                 rc = -EPERM;
 235                 goto out_err;
 236         }
 237
 238         list_add(&hpriv->dev_node, &hdev->fpriv_list);
 239         mutex_unlock(&hdev->fpriv_list_lock);
 240
 241         hpriv->hdev = hdev;
 242         filp->private_data = hpriv;
 243         hpriv->filp = filp;
 244         hpriv->is_control = true;
 245         nonseekable_open(inode, filp);
 246
 247         hpriv->taskpid = find_get_pid(current->pid);
 248
 249         return 0;
 250
 251 out_err:
 252         mutex_unlock(&hdev->fpriv_list_lock);
 253         kfree(hpriv);
 254         return rc;
 255 }
 256
 257 static void set_driver_behavior_per_device(struct hl_device *hdev)
 258 {
 259         hdev->fw_components = FW_TYPE_ALL_TYPES;
 260         hdev->cpu_queues_enable = 1;
 261         hdev->heartbeat = 1;
 262         hdev->mmu_enable = 1;
 263         hdev->clock_gating_mask = ULONG_MAX;
 264         hdev->sram_scrambler_enable = 1;
 265         hdev->dram_scrambler_enable = 1;
 266         hdev->bmc_enable = 1;
 267         hdev->hard_reset_on_fw_events = 1;
 268         hdev->reset_on_preboot_fail = 1;
 269         hdev->reset_if_device_not_idle = 1;
 270
 271         hdev->reset_pcilink = 0;
 272         hdev->axi_drain = 0;
 273 }
 274
 275 /*
 276  * create_hdev - create habanalabs device instance
 277  *
 278  * @dev: will hold the pointer to the new habanalabs device structure
 279  * @pdev: pointer to the pci device
 280  * @asic_type: in case of simulator device, which device is it
 281  * @minor: in case of simulator device, the minor of the device
 282  *
 283  * Allocate memory for habanalabs device and initialize basic fields
 284  * Identify the ASIC type
 285  * Allocate ID (minor) for the device (only for real devices)
 286  */
 287 int create_hdev(struct hl_device **dev, struct pci_dev *pdev,
 288                 enum hl_asic_type asic_type, int minor)
 289 {
 290         struct hl_device *hdev;
 291         int rc, main_id, ctrl_id = 0;
 292
 293         *dev = NULL;
 294
 295         hdev = kzalloc(sizeof(*hdev), GFP_KERNEL);
 296         if (!hdev)
 297                 return -ENOMEM;
 298
 299         /* First, we must find out which ASIC are we handling. This is needed
 300          * to configure the behavior of the driver (kernel parameters)
 301          */
 302         if (pdev) {
 303                 hdev->asic_type = get_asic_type(pdev->device);
 304                 if (hdev->asic_type == ASIC_INVALID) {
 305                         dev_err(&pdev->dev, "Unsupported ASIC\n");
 306                         rc = -ENODEV;
 307                         goto free_hdev;
 308                 }
 309         } else {
 310                 hdev->asic_type = asic_type;
 311         }
 312
 313         if (pdev)
 314                 hdev->asic_prop.fw_security_enabled =
 315                                         is_asic_secured(hdev->asic_type);
 316         else
 317                 hdev->asic_prop.fw_security_enabled = false;
 318
 319         /* Assign status description string */
 320         strncpy(hdev->status[HL_DEVICE_STATUS_MALFUNCTION],
 321                                         "disabled", HL_STR_MAX);
 322         strncpy(hdev->status[HL_DEVICE_STATUS_IN_RESET],
 323                                         "in reset", HL_STR_MAX);
 324         strncpy(hdev->status[HL_DEVICE_STATUS_NEEDS_RESET],
 325                                         "needs reset", HL_STR_MAX);
 326
 327         hdev->major = hl_major;
 328         hdev->reset_on_lockup = reset_on_lockup;
 329         hdev->memory_scrub = memory_scrub;
 330         hdev->boot_error_status_mask = boot_error_status_mask;
 331         hdev->stop_on_err = true;
 332
 333         hdev->pldm = 0;
 334
 335         set_driver_behavior_per_device(hdev);
 336
 337         hdev->curr_reset_cause = HL_RESET_CAUSE_UNKNOWN;
 338
 339         if (timeout_locked)
 340                 hdev->timeout_jiffies = msecs_to_jiffies(timeout_locked * 1000);
 341         else
 342                 hdev->timeout_jiffies = MAX_SCHEDULE_TIMEOUT;
 343
 344         hdev->disabled = true;
 345         hdev->pdev = pdev; /* can be NULL in case of simulator device */
 346
 347         /* Set default DMA mask to 32 bits */
 348         hdev->dma_mask = 32;
 349
 350         mutex_lock(&hl_devs_idr_lock);
 351
 352         /* Always save 2 numbers, 1 for main device and 1 for control.
 353          * They must be consecutive
 354          */
 355         main_id = idr_alloc(&hl_devs_idr, hdev, 0, HL_MAX_MINORS,
 356                                 GFP_KERNEL);
 357
 358         if (main_id >= 0)
 359                 ctrl_id = idr_alloc(&hl_devs_idr, hdev, main_id + 1,
 360                                         main_id + 2, GFP_KERNEL);
 361
 362         mutex_unlock(&hl_devs_idr_lock);
 363
 364         if ((main_id < 0) || (ctrl_id < 0)) {
 365                 if ((main_id == -ENOSPC) || (ctrl_id == -ENOSPC))
 366                         pr_err("too many devices in the system\n");
 367
 368                 if (main_id >= 0) {
 369                         mutex_lock(&hl_devs_idr_lock);
 370                         idr_remove(&hl_devs_idr, main_id);
 371                         mutex_unlock(&hl_devs_idr_lock);
 372                 }
 373
 374                 rc = -EBUSY;
 375                 goto free_hdev;
 376         }
 377
 378         hdev->id = main_id;
 379         hdev->id_control = ctrl_id;
 380
 381         *dev = hdev;
 382
 383         return 0;
 384
 385 free_hdev:
 386         kfree(hdev);
 387         return rc;
 388 }
 389
 390 /*
 391  * destroy_hdev - destroy habanalabs device instance
 392  *
 393  * @dev: pointer to the habanalabs device structure
 394  *
 395  */
 396 void destroy_hdev(struct hl_device *hdev)
 397 {
 398         /* Remove device from the device list */
 399         mutex_lock(&hl_devs_idr_lock);
 400         idr_remove(&hl_devs_idr, hdev->id);
 401         idr_remove(&hl_devs_idr, hdev->id_control);
 402         mutex_unlock(&hl_devs_idr_lock);
 403
 404         kfree(hdev);
 405 }
 406
 407 static int hl_pmops_suspend(struct device *dev)
 408 {
 409         struct hl_device *hdev = dev_get_drvdata(dev);
 410
 411         pr_debug("Going to suspend PCI device\n");
 412
 413         if (!hdev) {
 414                 pr_err("device pointer is NULL in suspend\n");
 415                 return 0;
 416         }
 417
 418         return hl_device_suspend(hdev);
 419 }
 420
 421 static int hl_pmops_resume(struct device *dev)
 422 {
 423         struct hl_device *hdev = dev_get_drvdata(dev);
 424
 425         pr_debug("Going to resume PCI device\n");
 426
 427         if (!hdev) {
 428                 pr_err("device pointer is NULL in resume\n");
 429                 return 0;
 430         }
 431
 432         return hl_device_resume(hdev);
 433 }
 434
 435 /*
 436  * hl_pci_probe - probe PCI habanalabs devices
 437  *
 438  * @pdev: pointer to pci device
 439  * @id: pointer to pci device id structure
 440  *
 441  * Standard PCI probe function for habanalabs device.
 442  * Create a new habanalabs device and initialize it according to the
 443  * device's type
 444  */
 445 static int hl_pci_probe(struct pci_dev *pdev,
 446                                 const struct pci_device_id *id)
 447 {
 448         struct hl_device *hdev;
 449         int rc;
 450
 451         dev_info(&pdev->dev, HL_NAME
 452                  " device found [%04x:%04x] (rev %x)\n",
 453                  (int)pdev->vendor, (int)pdev->device, (int)pdev->revision);
 454
 455         rc = create_hdev(&hdev, pdev, ASIC_INVALID, -1);
 456         if (rc)
 457                 return rc;
 458
 459         pci_set_drvdata(pdev, hdev);
 460
 461         pci_enable_pcie_error_reporting(pdev);
 462
 463         rc = hl_device_init(hdev, hl_class);
 464         if (rc) {
 465                 dev_err(&pdev->dev, "Fatal error during habanalabs device init\n");
 466                 rc = -ENODEV;
 467                 goto disable_device;
 468         }
 469
 470         return 0;
 471
 472 disable_device:
 473         pci_disable_pcie_error_reporting(pdev);
 474         pci_set_drvdata(pdev, NULL);
 475         destroy_hdev(hdev);
 476
 477         return rc;
 478 }
 479
 480 /*
 481  * hl_pci_remove - remove PCI habanalabs devices
 482  *
 483  * @pdev: pointer to pci device
 484  *
 485  * Standard PCI remove function for habanalabs device
 486  */
 487 static void hl_pci_remove(struct pci_dev *pdev)
 488 {
 489         struct hl_device *hdev;
 490
 491         hdev = pci_get_drvdata(pdev);
 492         if (!hdev)
 493                 return;
 494
 495         hl_device_fini(hdev);
 496         pci_disable_pcie_error_reporting(pdev);
 497         pci_set_drvdata(pdev, NULL);
 498         destroy_hdev(hdev);
 499 }
 500
 501 /**
 502  * hl_pci_err_detected - a PCI bus error detected on this device
 503  *
 504  * @pdev: pointer to pci device
 505  * @state: PCI error type
 506  *
 507  * Called by the PCI subsystem whenever a non-correctable
 508  * PCI bus error is detected
 509  */
 510 static pci_ers_result_t
 511 hl_pci_err_detected(struct pci_dev *pdev, pci_channel_state_t state)
 512 {
 513         struct hl_device *hdev = pci_get_drvdata(pdev);
 514         enum pci_ers_result result;
 515
 516         switch (state) {
 517         case pci_channel_io_normal:
 518                 return PCI_ERS_RESULT_CAN_RECOVER;
 519
 520         case pci_channel_io_frozen:
 521                 dev_warn(hdev->dev, "frozen state error detected\n");
 522                 result = PCI_ERS_RESULT_NEED_RESET;
 523                 break;
 524
 525         case pci_channel_io_perm_failure:
 526                 dev_warn(hdev->dev, "failure state error detected\n");
 527                 result = PCI_ERS_RESULT_DISCONNECT;
 528                 break;
 529
 530         default:
 531                 result = PCI_ERS_RESULT_NONE;
 532         }
 533
 534         hdev->asic_funcs->halt_engines(hdev, true);
 535
 536         return result;
 537 }
 538
 539 /**
 540  * hl_pci_err_resume - resume after a PCI slot reset
 541  *
 542  * @pdev: pointer to pci device
 543  *
 544  */
 545 static void hl_pci_err_resume(struct pci_dev *pdev)
 546 {
 547         struct hl_device *hdev = pci_get_drvdata(pdev);
 548
 549         dev_warn(hdev->dev, "Resuming device after PCI slot reset\n");
 550         hl_device_resume(hdev);
 551 }
 552
 553 /**
 554  * hl_pci_err_slot_reset - a PCI slot reset has just happened
 555  *
 556  * @pdev: pointer to pci device
 557  *
 558  * Determine if the driver can recover from the PCI slot reset
 559  */
 560 static pci_ers_result_t hl_pci_err_slot_reset(struct pci_dev *pdev)
 561 {
 562         return PCI_ERS_RESULT_RECOVERED;
 563 }
 564
 565 static const struct dev_pm_ops hl_pm_ops = {
 566         .suspend = hl_pmops_suspend,
 567         .resume = hl_pmops_resume,
 568 };
 569
 570 static const struct pci_error_handlers hl_pci_err_handler = {
 571         .error_detected = hl_pci_err_detected,
 572         .slot_reset = hl_pci_err_slot_reset,
 573         .resume = hl_pci_err_resume,
 574 };
 575
 576 static struct pci_driver hl_pci_driver = {
 577         .name = HL_NAME,
 578         .id_table = ids,
 579         .probe = hl_pci_probe,
 580         .remove = hl_pci_remove,
 581         .shutdown = hl_pci_remove,
 582         .driver = {
 583                 .name = HL_NAME,
 584                 .pm = &hl_pm_ops,
 585                 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
 586         },
 587         .err_handler = &hl_pci_err_handler,
 588 };
 589
 590 /*
 591  * hl_init - Initialize the habanalabs kernel driver
 592  */
 593 static int __init hl_init(void)
 594 {
 595         int rc;
 596         dev_t dev;
 597
 598         pr_info("loading driver\n");
 599
 600         rc = alloc_chrdev_region(&dev, 0, HL_MAX_MINORS, HL_NAME);
 601         if (rc < 0) {
 602                 pr_err("unable to get major\n");
 603                 return rc;
 604         }
 605
 606         hl_major = MAJOR(dev);
 607
 608         hl_class = class_create(THIS_MODULE, HL_NAME);
 609         if (IS_ERR(hl_class)) {
 610                 pr_err("failed to allocate class\n");
 611                 rc = PTR_ERR(hl_class);
 612                 goto remove_major;
 613         }
 614
 615         hl_debugfs_init();
 616
 617         rc = pci_register_driver(&hl_pci_driver);
 618         if (rc) {
 619                 pr_err("failed to register pci device\n");
 620                 goto remove_debugfs;
 621         }
 622
 623         pr_debug("driver loaded\n");
 624
 625         return 0;
 626
 627 remove_debugfs:
 628         hl_debugfs_fini();
 629         class_destroy(hl_class);
 630 remove_major:
 631         unregister_chrdev_region(MKDEV(hl_major, 0), HL_MAX_MINORS);
 632         return rc;
 633 }
 634
 635 /*
 636  * hl_exit - Release all resources of the habanalabs kernel driver
 637  */
 638 static void __exit hl_exit(void)
 639 {
 640         pci_unregister_driver(&hl_pci_driver);
 641
 642         /*
 643          * Removing debugfs must be after all devices or simulator devices
 644          * have been removed because otherwise we get a bug in the
 645          * debugfs module for referencing NULL objects
 646          */
 647         hl_debugfs_fini();
 648
 649         class_destroy(hl_class);
 650         unregister_chrdev_region(MKDEV(hl_major, 0), HL_MAX_MINORS);
 651
 652         idr_destroy(&hl_devs_idr);
 653
 654         pr_debug("driver removed\n");
 655 }
 656
 657 module_init(hl_init);
 658 module_exit(hl_exit);