drivers/platform/x86/intel_rar_register.c

   1 /*
   2  *  rar_register.c - An Intel Restricted Access Region register driver
   3  *
   4  *  Copyright(c) 2009 Intel Corporation. All rights reserved.
   5  *
   6  *  This program is free software; you can redistribute it and/or
   7  *  modify it under the terms of the GNU General Public License as
   8  *  published by the Free Software Foundation; either version 2 of the
   9  *  License, or (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  *  General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  19  *  02111-1307, USA.
  20  *
  21  * -------------------------------------------------------------------
  22  *  20091204 Mark Allyn <mark.a.allyn@intel.com>
  23  *           Ossama Othman <ossama.othman@intel.com>
  24  *      Cleanup per feedback from Alan Cox and Arjan Van De Ven
  25  *
  26  *  20090806 Ossama Othman <ossama.othman@intel.com>
  27  *      Return zero high address if upper 22 bits is zero.
  28  *      Cleaned up checkpatch errors.
  29  *      Clarified that driver is dealing with bus addresses.
  30  *
  31  *  20090702 Ossama Othman <ossama.othman@intel.com>
  32  *      Removed unnecessary include directives
  33  *      Cleaned up spinlocks.
  34  *      Cleaned up logging.
  35  *      Improved invalid parameter checks.
  36  *      Fixed and simplified RAR address retrieval and RAR locking
  37  *      code.
  38  *
  39  *  20090626 Mark Allyn <mark.a.allyn@intel.com>
  40  *      Initial publish
  41  */
  42
  43 #include <linux/module.h>
  44 #include <linux/pci.h>
  45 #include <linux/spinlock.h>
  46 #include <linux/device.h>
  47 #include <linux/kernel.h>
  48 #include <linux/rar_register.h>
  49
  50 /* === Lincroft Message Bus Interface === */
  51 #define LNC_MCR_OFFSET          0xD0    /* Message Control Register */
  52 #define LNC_MDR_OFFSET          0xD4    /* Message Data Register */
  53
  54 /* Message Opcodes */
  55 #define LNC_MESSAGE_READ_OPCODE 0xD0
  56 #define LNC_MESSAGE_WRITE_OPCODE 0xE0
  57
  58 /* Message Write Byte Enables */
  59 #define LNC_MESSAGE_BYTE_WRITE_ENABLES  0xF
  60
  61 /* B-unit Port */
  62 #define LNC_BUNIT_PORT  0x3
  63
  64 /* === Lincroft B-Unit Registers - Programmed by IA32 firmware === */
  65 #define LNC_BRAR0L      0x10
  66 #define LNC_BRAR0H      0x11
  67 #define LNC_BRAR1L      0x12
  68 #define LNC_BRAR1H      0x13
  69 /* Reserved for SeP */
  70 #define LNC_BRAR2L      0x14
  71 #define LNC_BRAR2H      0x15
  72
  73 /* Moorestown supports three restricted access regions. */
  74 #define MRST_NUM_RAR 3
  75
  76 /* RAR Bus Address Range */
  77 struct rar_addr {
  78         dma_addr_t low;
  79         dma_addr_t high;
  80 };
  81
  82 /*
  83  *      We create one of these for each RAR
  84  */
  85 struct client {
  86         int (*callback)(unsigned long data);
  87         unsigned long driver_priv;
  88         bool busy;
  89 };
  90
  91 static DEFINE_MUTEX(rar_mutex);
  92 static DEFINE_MUTEX(lnc_reg_mutex);
  93
  94 /*
  95  *      One per RAR device (currently only one device)
  96  */
  97 struct rar_device {
  98         struct rar_addr rar_addr[MRST_NUM_RAR];
  99         struct pci_dev *rar_dev;
 100         bool registered;
 101         bool allocated;
 102         struct client client[MRST_NUM_RAR];
 103 };
 104
 105 /* Current platforms have only one rar_device for 3 rar regions */
 106 static struct rar_device my_rar_device;
 107
 108 /*
 109  *      Abstract out multiple device support. Current platforms only
 110  *      have a single RAR device.
 111  */
 112
 113 /**
 114  *      alloc_rar_device        -       return a new RAR structure
 115  *
 116  *      Return a new (but not yet ready) RAR device object
 117  */
 118 static struct rar_device *alloc_rar_device(void)
 119 {
 120         if (my_rar_device.allocated)
 121                 return NULL;
 122         my_rar_device.allocated = 1;
 123         return &my_rar_device;
 124 }
 125
 126 /**
 127  *      free_rar_device         -       free a RAR object
 128  *      @rar: the RAR device being freed
 129  *
 130  *      Release a RAR object and any attached resources
 131  */
 132 static void free_rar_device(struct rar_device *rar)
 133 {
 134         pci_dev_put(rar->rar_dev);
 135         rar->allocated = 0;
 136 }
 137
 138 /**
 139  *      _rar_to_device          -       return the device handling this RAR
 140  *      @rar: RAR number
 141  *      @off: returned offset
 142  *
 143  *      Internal helper for looking up RAR devices. This and alloc are the
 144  *      two functions that need touching to go to multiple RAR devices.
 145  */
 146 static struct rar_device *_rar_to_device(int rar, int *off)
 147 {
 148         if (rar >= 0 && rar < MRST_NUM_RAR) {
 149                 *off = rar;
 150                 return &my_rar_device;
 151         }
 152         return NULL;
 153 }
 154
 155 /**
 156  *      rar_to_device           -       return the device handling this RAR
 157  *      @rar: RAR number
 158  *      @off: returned offset
 159  *
 160  *      Return the device this RAR maps to if one is present, otherwise
 161  *      returns NULL. Reports the offset relative to the base of this
 162  *      RAR device in off.
 163  */
 164 static struct rar_device *rar_to_device(int rar, int *off)
 165 {
 166         struct rar_device *rar_dev = _rar_to_device(rar, off);
 167         if (rar_dev == NULL || !rar_dev->registered)
 168                 return NULL;
 169         return rar_dev;
 170 }
 171
 172 /**
 173  *      rar_to_client           -       return the client handling this RAR
 174  *      @rar: RAR number
 175  *
 176  *      Return the client this RAR maps to if a mapping is known, otherwise
 177  *      returns NULL.
 178  */
 179 static struct client *rar_to_client(int rar)
 180 {
 181         int idx;
 182         struct rar_device *r = _rar_to_device(rar, &idx);
 183         if (r != NULL)
 184                 return &r->client[idx];
 185         return NULL;
 186 }
 187
 188 /**
 189  *      rar_read_addr           -       retrieve a RAR mapping
 190  *      @pdev: PCI device for the RAR
 191  *      @offset: offset for message
 192  *      @addr: returned address
 193  *
 194  *      Reads the address of a given RAR register. Returns 0 on success
 195  *      or an error code on failure.
 196  */
 197 static int rar_read_addr(struct pci_dev *pdev, int offset, dma_addr_t *addr)
 198 {
 199         /*
 200          * ======== The Lincroft Message Bus Interface ========
 201          * Lincroft registers may be obtained via PCI from
 202          * the host bridge using the Lincroft Message Bus
 203          * Interface.  That message bus interface is generally
 204          * comprised of two registers: a control register (MCR, 0xDO)
 205          * and a data register (MDR, 0xD4).
 206          *
 207          * The MCR (message control register) format is the following:
 208          *   1.  [31:24]: Opcode
 209          *   2.  [23:16]: Port
 210          *   3.  [15:8]: Register Offset
 211          *   4.  [7:4]: Byte Enables (use 0xF to set all of these bits
 212          *              to 1)
 213          *   5.  [3:0]: reserved
 214          *
 215          *  Read (0xD0) and write (0xE0) opcodes are written to the
 216          *  control register when reading and writing to Lincroft
 217          *  registers, respectively.
 218          *
 219          *  We're interested in registers found in the Lincroft
 220          *  B-unit.  The B-unit port is 0x3.
 221          *
 222          *  The six B-unit RAR register offsets we use are listed
 223          *  earlier in this file.
 224          *
 225          *  Lastly writing to the MCR register requires the "Byte
 226          *  enables" bits to be set to 1.  This may be achieved by
 227          *  writing 0xF at bit 4.
 228          *
 229          * The MDR (message data register) format is the following:
 230          *   1. [31:0]: Read/Write Data
 231          *
 232          *  Data being read from this register is only available after
 233          *  writing the appropriate control message to the MCR
 234          *  register.
 235          *
 236          *  Data being written to this register must be written before
 237          *  writing the appropriate control message to the MCR
 238          *  register.
 239         */
 240
 241         int result;
 242         u32 addr32;
 243
 244         /* Construct control message */
 245         u32 const message =
 246                  (LNC_MESSAGE_READ_OPCODE << 24)
 247                  | (LNC_BUNIT_PORT << 16)
 248                  | (offset << 8)
 249                  | (LNC_MESSAGE_BYTE_WRITE_ENABLES << 4);
 250
 251         dev_dbg(&pdev->dev, "Offset for 'get' LNC MSG is %x\n", offset);
 252
 253         /*
 254         * We synchronize access to the Lincroft MCR and MDR registers
 255         * until BOTH the command is issued through the MCR register
 256         * and the corresponding data is read from the MDR register.
 257         * Otherwise a race condition would exist between accesses to
 258         * both registers.
 259         */
 260
 261         mutex_lock(&lnc_reg_mutex);
 262
 263         /* Send the control message */
 264         result = pci_write_config_dword(pdev, LNC_MCR_OFFSET, message);
 265         if (!result) {
 266                 /* Read back the address as a 32bit value */
 267                 result = pci_read_config_dword(pdev, LNC_MDR_OFFSET, &addr32);
 268                 *addr = (dma_addr_t)addr32;
 269         }
 270         mutex_unlock(&lnc_reg_mutex);
 271         return result;
 272 }
 273
 274 /**
 275  *      rar_set_addr            -       Set a RAR mapping
 276  *      @pdev: PCI device for the RAR
 277  *      @offset: offset for message
 278  *      @addr: address to set
 279  *
 280  *      Sets the address of a given RAR register. Returns 0 on success
 281  *      or an error code on failure.
 282  */
 283 static int rar_set_addr(struct pci_dev *pdev,
 284         int offset,
 285         dma_addr_t addr)
 286 {
 287         /*
 288         * Data being written to this register must be written before
 289         * writing the appropriate control message to the MCR
 290         * register.
 291         * See rar_get_addrs() for a description of the
 292         * message bus interface being used here.
 293         */
 294
 295         int result;
 296
 297         /* Construct control message */
 298         u32 const message = (LNC_MESSAGE_WRITE_OPCODE << 24)
 299                 | (LNC_BUNIT_PORT << 16)
 300                 | (offset << 8)
 301                 | (LNC_MESSAGE_BYTE_WRITE_ENABLES << 4);
 302
 303         /*
 304         * We synchronize access to the Lincroft MCR and MDR registers
 305         * until BOTH the command is issued through the MCR register
 306         * and the corresponding data is read from the MDR register.
 307         * Otherwise a race condition would exist between accesses to
 308         * both registers.
 309         */
 310
 311         mutex_lock(&lnc_reg_mutex);
 312
 313         /* Send the control message */
 314         result = pci_write_config_dword(pdev, LNC_MDR_OFFSET, addr);
 315         if (!result)
 316                 /* And address */
 317                 result = pci_write_config_dword(pdev, LNC_MCR_OFFSET, message);
 318
 319         mutex_unlock(&lnc_reg_mutex);
 320         return result;
 321 }
 322
 323 /*
 324  *      rar_init_params         -       Initialize RAR parameters
 325  *      @rar: RAR device to initialise
 326  *
 327  *      Initialize RAR parameters, such as bus addresses, etc. Returns 0
 328  *      on success, or an error code on failure.
 329  */
 330 static int init_rar_params(struct rar_device *rar)
 331 {
 332         struct pci_dev *pdev = rar->rar_dev;
 333         unsigned int i;
 334         int result = 0;
 335         int offset = 0x10;      /* RAR 0 to 2 in order low/high/low/high/... */
 336
 337         /* Retrieve RAR start and end bus addresses.
 338         * Access the RAR registers through the Lincroft Message Bus
 339         * Interface on PCI device: 00:00.0 Host bridge.
 340         */
 341
 342         for (i = 0; i < MRST_NUM_RAR; ++i) {
 343                 struct rar_addr *addr = &rar->rar_addr[i];
 344
 345                 result = rar_read_addr(pdev, offset++, &addr->low);
 346                 if (result != 0)
 347                         return result;
 348
 349                 result = rar_read_addr(pdev, offset++, &addr->high);
 350                 if (result != 0)
 351                         return result;
 352
 353
 354                 /*
 355                 * Only the upper 22 bits of the RAR addresses are
 356                 * stored in their corresponding RAR registers so we
 357                 * must set the lower 10 bits accordingly.
 358
 359                 * The low address has its lower 10 bits cleared, and
 360                 * the high address has all its lower 10 bits set,
 361                 * e.g.:
 362                 * low = 0x2ffffc00
 363                 */
 364
 365                 addr->low &= (dma_addr_t)0xfffffc00u;
 366
 367                 /*
 368                 * Set bits 9:0 on uppser address if bits 31:10 are non
 369                 * zero; otherwize clear all bits
 370                 */
 371
 372                 if ((addr->high & 0xfffffc00u) == 0)
 373                         addr->high = 0;
 374                 else
 375                         addr->high |= 0x3ffu;
 376         }
 377         /* Done accessing the device. */
 378
 379         if (result == 0) {
 380                 for (i = 0; i != MRST_NUM_RAR; ++i) {
 381                         /*
 382                         * "BRAR" refers to the RAR registers in the
 383                         * Lincroft B-unit.
 384                         */
 385                         dev_info(&pdev->dev, "BRAR[%u] bus address range = "
 386                           "[%lx, %lx]\n", i,
 387                           (unsigned long)rar->rar_addr[i].low,
 388                           (unsigned long)rar->rar_addr[i].high);
 389                 }
 390         }
 391         return result;
 392 }
 393
 394 /**
 395  *      rar_get_address         -       get the bus address in a RAR
 396  *      @start: return value of start address of block
 397  *      @end: return value of end address of block
 398  *
 399  *      The rar_get_address function is used by other device drivers
 400  *      to obtain RAR address information on a RAR. It takes three
 401  *      parameters:
 402  *
 403  *      The function returns a 0 upon success or an error if there is no RAR
 404  *      facility on this system.
 405  */
 406 int rar_get_address(int rar_index, dma_addr_t *start, dma_addr_t *end)
 407 {
 408         int idx;
 409         struct rar_device *rar = rar_to_device(rar_index, &idx);
 410
 411         if (rar == NULL) {
 412                 WARN_ON(1);
 413                 return -ENODEV;
 414         }
 415
 416         *start = rar->rar_addr[idx].low;
 417         *end = rar->rar_addr[idx].high;
 418         return 0;
 419 }
 420 EXPORT_SYMBOL(rar_get_address);
 421
 422 /**
 423  *      rar_lock        -       lock a RAR register
 424  *      @rar_index: RAR to lock (0-2)
 425  *
 426  *      The rar_lock function is ued by other device drivers to lock an RAR.
 427  *      once a RAR is locked, it stays locked until the next system reboot.
 428  *
 429  *      The function returns a 0 upon success or an error if there is no RAR
 430  *      facility on this system, or the locking fails
 431  */
 432 int rar_lock(int rar_index)
 433 {
 434         struct rar_device *rar;
 435         int result;
 436         int idx;
 437         dma_addr_t low, high;
 438
 439         rar = rar_to_device(rar_index, &idx);
 440
 441         if (rar == NULL) {
 442                 WARN_ON(1);
 443                 return -EINVAL;
 444         }
 445
 446         low = rar->rar_addr[idx].low & 0xfffffc00u;
 447         high = rar->rar_addr[idx].high & 0xfffffc00u;
 448
 449         /*
 450         * Only allow I/O from the graphics and Langwell;
 451         * not from the x86 processor
 452         */
 453
 454         if (rar_index == RAR_TYPE_VIDEO) {
 455                 low |= 0x00000009;
 456                 high |= 0x00000015;
 457         } else if (rar_index == RAR_TYPE_AUDIO) {
 458                 /* Only allow I/O from Langwell; nothing from x86 */
 459                 low |= 0x00000008;
 460                 high |= 0x00000018;
 461         } else
 462                 /* Read-only from all agents */
 463                 high |= 0x00000018;
 464
 465         /*
 466         * Now program the register using the Lincroft message
 467         * bus interface.
 468         */
 469         result = rar_set_addr(rar->rar_dev,
 470                                 2 * idx, low);
 471
 472         if (result == 0)
 473                 result = rar_set_addr(rar->rar_dev,
 474                                 2 * idx + 1, high);
 475
 476         return result;
 477 }
 478 EXPORT_SYMBOL(rar_lock);
 479
 480 /**
 481  *      register_rar            -       register a RAR handler
 482  *      @num: RAR we wish to register for
 483  *      @callback: function to call when RAR support is available
 484  *      @data: data to pass to this function
 485  *
 486  *      The register_rar function is to used by other device drivers
 487  *      to ensure that this driver is ready. As we cannot be sure of
 488  *      the compile/execute order of drivers in the kernel, it is
 489  *      best to give this driver a callback function to call when
 490  *      it is ready to give out addresses. The callback function
 491  *      would have those steps that continue the initialization of
 492  *      a driver that do require a valid RAR address. One of those
 493  *      steps would be to call rar_get_address()
 494  *
 495  *      This function return 0 on success or an error code on failure.
 496  */
 497 int register_rar(int num, int (*callback)(unsigned long data),
 498                                                         unsigned long data)
 499 {
 500         /* For now we hardcode a single RAR device */
 501         struct rar_device *rar;
 502         struct client *c;
 503         int idx;
 504         int retval = 0;
 505
 506         mutex_lock(&rar_mutex);
 507
 508         /* Do we have a client mapping for this RAR number ? */
 509         c = rar_to_client(num);
 510         if (c == NULL) {
 511                 retval = -ERANGE;
 512                 goto done;
 513         }
 514         /* Is it claimed ? */
 515         if (c->busy) {
 516                 retval = -EBUSY;
 517                 goto done;
 518         }
 519         c->busy = 1;
 520
 521         /* See if we have a handler for this RAR yet, if we do then fire it */
 522         rar = rar_to_device(num, &idx);
 523
 524         if (rar) {
 525                 /*
 526                 * if the driver already registered, then we can simply
 527                 * call the callback right now
 528                 */
 529                 (*callback)(data);
 530                 goto done;
 531         }
 532
 533         /* Arrange to be called back when the hardware is found */
 534         c->callback = callback;
 535         c->driver_priv = data;
 536 done:
 537         mutex_unlock(&rar_mutex);
 538         return retval;
 539 }
 540 EXPORT_SYMBOL(register_rar);
 541
 542 /**
 543  *      unregister_rar  -       release a RAR allocation
 544  *      @num: RAR number
 545  *
 546  *      Releases a RAR allocation, or pending allocation. If a callback is
 547  *      pending then this function will either complete before the unregister
 548  *      returns or not at all.
 549  */
 550
 551 void unregister_rar(int num)
 552 {
 553         struct client *c;
 554
 555         mutex_lock(&rar_mutex);
 556         c = rar_to_client(num);
 557         if (c == NULL || !c->busy)
 558                 WARN_ON(1);
 559         else
 560                 c->busy = 0;
 561         mutex_unlock(&rar_mutex);
 562 }
 563 EXPORT_SYMBOL(unregister_rar);
 564
 565 /**
 566  *      rar_callback            -       Process callbacks
 567  *      @rar: new RAR device
 568  *
 569  *      Process the callbacks for a newly found RAR device.
 570  */
 571
 572 static void rar_callback(struct rar_device *rar)
 573 {
 574         struct client *c = &rar->client[0];
 575         int i;
 576
 577         mutex_lock(&rar_mutex);
 578
 579         rar->registered = 1;    /* Ensure no more callbacks queue */
 580
 581         for (i = 0; i < MRST_NUM_RAR; i++) {
 582                 if (c->callback && c->busy) {
 583                         c->callback(c->driver_priv);
 584                         c->callback = NULL;
 585                 }
 586                 c++;
 587         }
 588         mutex_unlock(&rar_mutex);
 589 }
 590
 591 /**
 592  *      rar_probe               -       PCI probe callback
 593  *      @dev: PCI device
 594  *      @id: matching entry in the match table
 595  *
 596  *      A RAR device has been discovered. Initialise it and if successful
 597  *      process any pending callbacks that can now be completed.
 598  */
 599 static int rar_probe(struct pci_dev *dev, const struct pci_device_id *id)
 600 {
 601         int error;
 602         struct rar_device *rar;
 603
 604         dev_dbg(&dev->dev, "PCI probe starting\n");
 605
 606         rar = alloc_rar_device();
 607         if (rar == NULL)
 608                 return -EBUSY;
 609
 610         /* Enable the device */
 611         error = pci_enable_device(dev);
 612         if (error) {
 613                 dev_err(&dev->dev,
 614                         "Error enabling RAR register PCI device\n");
 615                 goto end_function;
 616         }
 617
 618         /* Fill in the rar_device structure */
 619         rar->rar_dev = pci_dev_get(dev);
 620         pci_set_drvdata(dev, rar);
 621
 622         /*
 623          * Initialize the RAR parameters, which have to be retrieved
 624          * via the message bus interface.
 625          */
 626         error = init_rar_params(rar);
 627         if (error) {
 628                 pci_disable_device(dev);
 629                 dev_err(&dev->dev, "Error retrieving RAR addresses\n");
 630                 goto end_function;
 631         }
 632         /* now call anyone who has registered (using callbacks) */
 633         rar_callback(rar);
 634         return 0;
 635 end_function:
 636         free_rar_device(rar);
 637         return error;
 638 }
 639
 640 static DEFINE_PCI_DEVICE_TABLE(rar_pci_id_tbl) = {
 641         { PCI_VDEVICE(INTEL, 0x4110) },
 642         { 0 }
 643 };
 644
 645 MODULE_DEVICE_TABLE(pci, rar_pci_id_tbl);
 646
 647 /* field for registering driver to PCI device */
 648 static struct pci_driver rar_pci_driver = {
 649         .name = "rar_register_driver",
 650         .id_table = rar_pci_id_tbl,
 651         .probe = rar_probe,
 652         /* Cannot be unplugged - no remove */
 653 };
 654
 655 static int __init rar_init_handler(void)
 656 {
 657         return pci_register_driver(&rar_pci_driver);
 658 }
 659
 660 static void __exit rar_exit_handler(void)
 661 {
 662         pci_unregister_driver(&rar_pci_driver);
 663 }
 664
 665 module_init(rar_init_handler);
 666 module_exit(rar_exit_handler);
 667
 668 MODULE_LICENSE("GPL");
 669 MODULE_DESCRIPTION("Intel Restricted Access Region Register Driver");