drivers/staging/rar_register/rar_register.c

   1 #include <linux/init.h>
   2 #include <linux/module.h>
   3 #include <linux/fs.h>
   4 #include <linux/cdev.h>
   5 #include <linux/kdev_t.h>
   6 #include <linux/semaphore.h>
   7 #include <linux/mm.h>
   8 #include <linux/poll.h>
   9 #include <linux/wait.h>
  10 #include <linux/ioctl.h>
  11 #include <linux/ioport.h>
  12 #include <linux/io.h>
  13 #include <linux/interrupt.h>
  14 #include <linux/pagemap.h>
  15 #include <linux/pci.h>
  16 #include <linux/firmware.h>
  17 #include <linux/sched.h>
  18 #include "rar_register.h"
  19
  20 /* The following defines are for the IPC process to retrieve RAR in */
  21
  22 /* === Lincroft Message Bus Interface === */
  23 /* Message Control Register */
  24 #define LNC_MCR_OFFSET 0xD0
  25
  26 /* Message Data Register */
  27 #define LNC_MDR_OFFSET 0xD4
  28
  29 /* Message Opcodes */
  30 #define LNC_MESSAGE_READ_OPCODE  0xD0
  31 #define LNC_MESSAGE_WRITE_OPCODE 0xE0
  32
  33 /* Message Write Byte Enables */
  34 #define LNC_MESSAGE_BYTE_WRITE_ENABLES 0xF
  35
  36 /* B-unit Port */
  37 #define LNC_BUNIT_PORT 0x3
  38
  39 /* === Lincroft B-Unit Registers - Programmed by IA32 firmware === */
  40 #define LNC_BRAR0L  0x10
  41 #define LNC_BRAR0H  0x11
  42 #define LNC_BRAR1L  0x12
  43 #define LNC_BRAR1H  0x13
  44
  45 /* Reserved for SeP */
  46 #define LNC_BRAR2L  0x14
  47 #define LNC_BRAR2H  0x15
  48
  49
  50 /* This structure is only used during module initialization. */
  51 struct RAR_offsets {
  52         int low; /* Register offset for low RAR physical address. */
  53         int high; /* Register offset for high RAR physical address. */
  54 };
  55
  56 struct pci_dev *rar_dev;
  57 static uint32_t registered;
  58
  59 /* Moorestown supports three restricted access regions. */
  60 #define MRST_NUM_RAR 3
  61
  62 struct RAR_address_struct rar_addr[MRST_NUM_RAR];
  63
  64 /* prototype for init */
  65 static int __init rar_init_handler(void);
  66 static void __exit rar_exit_handler(void);
  67
  68 /*
  69   function that is activated on the successfull probe of the RAR device
  70 */
  71 static int __devinit rar_probe(struct pci_dev *pdev,
  72                                const struct pci_device_id *ent);
  73
  74 static const struct pci_device_id rar_pci_id_tbl[] = {
  75         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x4110) },
  76         { 0 }
  77 };
  78
  79 MODULE_DEVICE_TABLE(pci, rar_pci_id_tbl);
  80
  81 /* field for registering driver to PCI device */
  82 static struct pci_driver rar_pci_driver = {
  83         .name = "rar_driver",
  84         .id_table = rar_pci_id_tbl,
  85         .probe = rar_probe
  86 };
  87
  88 /* This function is used to retrieved RAR info using the IPC message
  89    bus interface */
  90 static int memrar_get_rar_addr(struct pci_dev *pdev,
  91                                int offset,
  92                                u32 *addr)
  93 {
  94         /*
  95          * ======== The Lincroft Message Bus Interface ========
  96          * Lincroft registers may be obtained from the PCI
  97          * (the Host Bridge) using the Lincroft Message Bus
  98          * Interface.  That message bus interface is generally
  99          * comprised of two registers: a control register (MCR, 0xDO)
 100          * and a data register (MDR, 0xD4).
 101          *
 102          * The MCR (message control register) format is the following:
 103          *   1.  [31:24]: Opcode
 104          *   2.  [23:16]: Port
 105          *   3.  [15:8]: Register Offset
 106          *   4.  [7:4]: Byte Enables (use 0xF to set all of these bits
 107          *              to 1)
 108          *   5.  [3:0]: reserved
 109          *
 110          *  Read (0xD0) and write (0xE0) opcodes are written to the
 111          *  control register when reading and writing to Lincroft
 112          *  registers, respectively.
 113          *
 114          *  We're interested in registers found in the Lincroft
 115          *  B-unit.  The B-unit port is 0x3.
 116          *
 117          *  The six B-unit RAR register offsets we use are listed
 118          *  earlier in this file.
 119          *
 120          *  Lastly writing to the MCR register requires the "Byte
 121          *  enables" bits to be set to 1.  This may be achieved by
 122          *  writing 0xF at bit 4.
 123          *
 124          * The MDR (message data register) format is the following:
 125          *   1. [31:0]: Read/Write Data
 126          *
 127          *  Data being read from this register is only available after
 128          *  writing the appropriate control message to the MCR
 129          *  register.
 130          *
 131          *  Data being written to this register must be written before
 132          *  writing the appropriate control message to the MCR
 133          *  register.
 134          */
 135
 136         int result = 0; /* result */
 137         /* Construct control message */
 138         u32 const message =
 139                (LNC_MESSAGE_READ_OPCODE << 24)
 140                | (LNC_BUNIT_PORT << 16)
 141                | (offset << 8)
 142                | (LNC_MESSAGE_BYTE_WRITE_ENABLES << 4);
 143
 144         printk(KERN_WARNING "rar- offset to LNC MSG is %x\n", offset);
 145
 146         if (addr == 0)
 147                 return -EINVAL;
 148
 149         /* Send the control message */
 150         result = pci_write_config_dword(pdev,
 151                                         LNC_MCR_OFFSET,
 152                                         message);
 153
 154         printk(KERN_WARNING "rar- result from send ctl register is %x\n",
 155                result);
 156
 157         if (!result)
 158                 result = pci_read_config_dword(pdev,
 159                                                LNC_MDR_OFFSET,
 160                                                addr);
 161
 162         printk(KERN_WARNING "rar- result from read data register is %x\n",
 163                result);
 164
 165         printk(KERN_WARNING "rar- value read from data register is %x\n",
 166                *addr);
 167
 168         if (result)
 169                 return -1;
 170         else
 171                 return 0;
 172 }
 173
 174 static int memrar_set_rar_addr(struct pci_dev *pdev,
 175                                int offset,
 176                                u32 addr)
 177 {
 178         /*
 179          * ======== The Lincroft Message Bus Interface ========
 180          * Lincroft registers may be obtained from the PCI
 181          * (the Host Bridge) using the Lincroft Message Bus
 182          * Interface.  That message bus interface is generally
 183          * comprised of two registers: a control register (MCR, 0xDO)
 184          * and a data register (MDR, 0xD4).
 185          *
 186          * The MCR (message control register) format is the following:
 187          *   1.  [31:24]: Opcode
 188          *   2.  [23:16]: Port
 189          *   3.  [15:8]: Register Offset
 190          *   4.  [7:4]: Byte Enables (use 0xF to set all of these bits
 191          *              to 1)
 192          *   5.  [3:0]: reserved
 193          *
 194          *  Read (0xD0) and write (0xE0) opcodes are written to the
 195          *  control register when reading and writing to Lincroft
 196          *  registers, respectively.
 197          *
 198          *  We're interested in registers found in the Lincroft
 199          *  B-unit.  The B-unit port is 0x3.
 200          *
 201          *  The six B-unit RAR register offsets we use are listed
 202          *  earlier in this file.
 203          *
 204          *  Lastly writing to the MCR register requires the "Byte
 205          *  enables" bits to be set to 1.  This may be achieved by
 206          *  writing 0xF at bit 4.
 207          *
 208          * The MDR (message data register) format is the following:
 209          *   1. [31:0]: Read/Write Data
 210          *
 211          *  Data being read from this register is only available after
 212          *  writing the appropriate control message to the MCR
 213          *  register.
 214          *
 215          *  Data being written to this register must be written before
 216          *  writing the appropriate control message to the MCR
 217          *  register.
 218          */
 219
 220         int result = 0; /* result */
 221
 222         /* Construct control message */
 223         u32 const message =
 224                (LNC_MESSAGE_WRITE_OPCODE << 24)
 225                | (LNC_BUNIT_PORT << 16)
 226                | (offset << 8)
 227                | (LNC_MESSAGE_BYTE_WRITE_ENABLES << 4);
 228
 229         printk(KERN_WARNING "rar- offset to LNC MSG is %x\n", offset);
 230
 231         if (addr == 0)
 232                 return -EINVAL;
 233
 234         /* Send the control message */
 235         result = pci_write_config_dword(pdev,
 236                                         LNC_MDR_OFFSET,
 237                                         addr);
 238
 239         printk(KERN_WARNING "rar- result from send ctl register is %x\n",
 240                result);
 241
 242         if (!result)
 243                 result = pci_write_config_dword(pdev,
 244                                                 LNC_MCR_OFFSET,
 245                                                 message);
 246
 247         printk(KERN_WARNING "rar- result from write data register is %x\n",
 248                result);
 249
 250         printk(KERN_WARNING "rar- value read to data register is %x\n",
 251                addr);
 252
 253         if (result)
 254                 return -1;
 255         else
 256                 return 0;
 257 }
 258
 259 /*
 260
 261  * Initialize RAR parameters, such as physical addresses, etc.
 262
 263  */
 264 static int memrar_init_rar_params(struct pci_dev *pdev)
 265 {
 266         struct RAR_offsets const offsets[] = {
 267                { LNC_BRAR0L, LNC_BRAR0H },
 268                { LNC_BRAR1L, LNC_BRAR1H },
 269                { LNC_BRAR2L, LNC_BRAR2H }
 270         };
 271
 272         size_t const num_offsets = sizeof(offsets) / sizeof(offsets[0]);
 273         struct RAR_offsets const *end = offsets + num_offsets;
 274         struct RAR_offsets const *i;
 275         unsigned int n = 0;
 276         int result = 0;
 277
 278         /* Retrieve RAR start and end physical addresses. */
 279
 280         /*
 281          * Access the RAR registers through the Lincroft Message Bus
 282          * Interface on PCI device: 00:00.0 Host bridge.
 283          */
 284
 285         /* struct pci_dev *pdev = pci_get_bus_and_slot(0, PCI_DEVFN(0,0)); */
 286
 287         if (pdev == NULL)
 288                 return -ENODEV;
 289
 290         for (i = offsets; i != end; ++i, ++n) {
 291                 if (memrar_get_rar_addr(pdev,
 292                                         (*i).low,
 293                                         &(rar_addr[n].low)) != 0
 294                     || memrar_get_rar_addr(pdev,
 295                                            (*i).high,
 296                                            &(rar_addr[n].high)) != 0) {
 297                         result = -1;
 298                         break;
 299                 }
 300         }
 301
 302         /* Done accessing the device. */
 303         /* pci_dev_put(pdev); */
 304
 305         if (result == 0) {
 306                 if (1) {
 307                         size_t z;
 308                         for (z = 0; z != MRST_NUM_RAR; ++z) {
 309                                 printk(KERN_WARNING
 310                                        "rar - BRAR[%Zd] physical address low\n"
 311                                        "\tlow:  0x%08x\n"
 312                                        "\thigh: 0x%08x\n",
 313                                        z,
 314                                        rar_addr[z].low,
 315                                        rar_addr[z].high);
 316                         }
 317                 }
 318         }
 319
 320         return result;
 321 }
 322
 323 /*
 324   function that is activated on the successfull probe of the RAR device
 325 */
 326 static int __devinit rar_probe(struct pci_dev *pdev,
 327                                const struct pci_device_id *ent)
 328 {
 329         /* error */
 330         int error;
 331
 332         /*------------------------
 333         CODE
 334         ---------------------------*/
 335
 336         DEBUG_PRINT_0(RAR_DEBUG_LEVEL_EXTENDED,
 337           "Rar pci probe starting\n");
 338         error = 0;
 339
 340         /* enable the device */
 341         error = pci_enable_device(pdev);
 342         if (error) {
 343                 DEBUG_PRINT_0(RAR_DEBUG_LEVEL_EXTENDED,
 344                   "error enabling pci device\n");
 345                 goto end_function;
 346         }
 347
 348         rar_dev = pdev;
 349         registered = 1;
 350
 351         /* Initialize the RAR parameters, which have to be retrieved */
 352         /* via the message bus service */
 353         error = memrar_init_rar_params(rar_dev);
 354
 355         if (error) {
 356                 DEBUG_PRINT_0(RAR_DEBUG_LEVEL_EXTENDED,
 357                   "error getting RAR addresses device\n");
 358                 registered = 0;
 359                 goto end_function;
 360                 }
 361
 362 end_function:
 363
 364         return error;
 365 }
 366
 367 /*
 368   this function registers the driver to
 369   the device subsystem (either PCI, USB, etc)
 370 */
 371 static int __init rar_init_handler(void)
 372 {
 373         return pci_register_driver(&rar_pci_driver);
 374 }
 375
 376 static void __exit rar_exit_handler(void)
 377 {
 378         pci_unregister_driver(&rar_pci_driver);
 379 }
 380
 381 module_init(rar_init_handler);
 382 module_exit(rar_exit_handler);
 383
 384 MODULE_LICENSE("GPL");
 385
 386
 387 /* The get_rar_address function is used by other device drivers
 388  * to obtain RAR address information on a RAR. It takes two
 389  * parameter:
 390  *
 391  * int rar_index
 392  * The rar_index is an index to the rar for which you wish to retrieve
 393  * the address information.
 394  * Values can be 0,1, or 2.
 395  *
 396  * struct RAR_address_struct is a pointer to a place to which the function
 397  * can return the address structure for the RAR.
 398  *
 399  * The function returns a 0 upon success or a -1 if there is no RAR
 400  * facility on this system.
 401  */
 402 int get_rar_address(int rar_index, struct RAR_address_struct *addresses)
 403 {
 404         if (registered && (rar_index < 3) && (rar_index >= 0)) {
 405                 *addresses = rar_addr[rar_index];
 406                 /* strip off lock bit information  */
 407                 addresses->low = addresses->low & 0xfffffff0;
 408                 addresses->high = addresses->high & 0xfffffff0;
 409                 return 0;
 410         } else
 411                 return -ENODEV;
 412 }
 413 EXPORT_SYMBOL(get_rar_address);
 414
 415 /* The lock_rar function is used by other device drivers to lock an RAR.
 416  * once an RAR is locked, it stays locked until the next system reboot.
 417  * The function takes one parameter:
 418  *
 419  * int rar_index
 420  * The rar_index is an index to the rar that you want to lock.
 421  * Values can be 0,1, or 2.
 422  *
 423  * The function returns a 0 upon success or a -1 if there is no RAR
 424  * facility on this system.
 425  */
 426 int lock_rar(int rar_index)
 427 {
 428         u32 working_addr;
 429         int result;
 430
 431         if (registered && (rar_index < 3) && (rar_index >= 0)) {
 432                 /* first make sure that lock bits are clear (this does lock) */
 433                 working_addr = rar_addr[rar_index].low & 0xfffffff0;
 434
 435                 /* now send that value to the register using the IPC */
 436                 result = memrar_set_rar_addr(rar_dev, rar_index, working_addr);
 437                 return result;
 438         } else
 439                 return -ENODEV;
 440 }