diff options
Diffstat (limited to 'meta-moblin/packages/linux/linux-moblin-2.6.33.2/linux-2.6.34-moorestown-rar-handler-driver-3.1.patch')
| -rw-r--r-- | meta-moblin/packages/linux/linux-moblin-2.6.33.2/linux-2.6.34-moorestown-rar-handler-driver-3.1.patch | 2531 |
1 files changed, 2531 insertions, 0 deletions
diff --git a/meta-moblin/packages/linux/linux-moblin-2.6.33.2/linux-2.6.34-moorestown-rar-handler-driver-3.1.patch b/meta-moblin/packages/linux/linux-moblin-2.6.33.2/linux-2.6.34-moorestown-rar-handler-driver-3.1.patch new file mode 100644 index 000000000..a1a0fd61a --- /dev/null +++ b/meta-moblin/packages/linux/linux-moblin-2.6.33.2/linux-2.6.34-moorestown-rar-handler-driver-3.1.patch @@ -0,0 +1,2531 @@ +Index: linux-2.6.33/drivers/staging/Kconfig +=================================================================== +--- linux-2.6.33.orig/drivers/staging/Kconfig ++++ linux-2.6.33/drivers/staging/Kconfig +@@ -141,5 +141,7 @@ source "drivers/staging/netwave/Kconfig" + + source "drivers/staging/sm7xx/Kconfig" + ++source "drivers/staging/rar_register/Kconfig" ++ + endif # !STAGING_EXCLUDE_BUILD + endif # STAGING +Index: linux-2.6.33/drivers/staging/Makefile +=================================================================== +--- linux-2.6.33.orig/drivers/staging/Makefile ++++ linux-2.6.33/drivers/staging/Makefile +@@ -38,7 +38,7 @@ obj-$(CONFIG_VT6656) += vt6656/ + obj-$(CONFIG_FB_UDL) += udlfb/ + obj-$(CONFIG_HYPERV) += hv/ + obj-$(CONFIG_VME_BUS) += vme/ +-obj-$(CONFIG_RAR_REGISTER) += rar/ ++obj-$(CONFIG_RAR_DRIVER) += rar/ + obj-$(CONFIG_DX_SEP) += sep/ + obj-$(CONFIG_IIO) += iio/ + obj-$(CONFIG_RAMZSWAP) += ramzswap/ +@@ -52,3 +52,4 @@ obj-$(CONFIG_WAVELAN) += wavelan/ + obj-$(CONFIG_PCMCIA_WAVELAN) += wavelan/ + obj-$(CONFIG_PCMCIA_NETWAVE) += netwave/ + obj-$(CONFIG_FB_SM7XX) += sm7xx/ ++obj-$(CONFIG_RAR_REGISTER) += rar_register/ +Index: linux-2.6.33/drivers/staging/rar_register/Kconfig +=================================================================== +--- /dev/null ++++ linux-2.6.33/drivers/staging/rar_register/Kconfig +@@ -0,0 +1,14 @@ ++# ++# Serial device configuration ++# ++ ++menu "RAR Register Driver" ++ ++config RAR_REGISTER ++ tristate "Intel Restricted Access Region Register Driver" ++ default n ++ ---help--- ++ This driver allows other kernel drivers access to the ++ contents of the restricted access region registers. ++ ++endmenu +Index: linux-2.6.33/drivers/staging/rar_register/Makefile +=================================================================== +--- /dev/null ++++ linux-2.6.33/drivers/staging/rar_register/Makefile +@@ -0,0 +1,3 @@ ++EXTRA_CFLAGS += -DLITTLE__ENDIAN ++obj-$(CONFIG_RAR_REGISTER) += rar_register.o ++rar_register_driver-objs := rar_register.o +Index: linux-2.6.33/drivers/staging/rar_register/rar_register.c +=================================================================== +--- /dev/null ++++ linux-2.6.33/drivers/staging/rar_register/rar_register.c +@@ -0,0 +1,669 @@ ++/* ++ * rar_register.c - An Intel Restricted Access Region register driver ++ * ++ * Copyright(c) 2009 Intel Corporation. All rights reserved. ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU General Public License as ++ * published by the Free Software Foundation; either version 2 of the ++ * License, or (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA ++ * 02111-1307, USA. ++ * ++ * ------------------------------------------------------------------- ++ * ++ * 20090806 Ossama Othman <ossama.othman@intel.com> ++ * Return zero high address if upper 22 bits is zero. ++ * Cleaned up checkpatch errors. ++ * Clarified that driver is dealing with bus addresses. ++ * ++ * 20090702 Ossama Othman <ossama.othman@intel.com> ++ * Removed unnecessary include directives ++ * Cleaned up spinlocks. ++ * Cleaned up logging. ++ * Improved invalid parameter checks. ++ * Fixed and simplified RAR address retrieval and RAR locking ++ * code. ++ * ++ * 20090626 Mark Allyn <mark.a.allyn@intel.com> ++ * Initial publish ++ */ ++ ++#include <linux/rar/rar_register.h> ++#include <linux/rar/memrar.h> ++ ++#include <linux/module.h> ++#include <linux/pci.h> ++#include <linux/spinlock.h> ++#include <linux/device.h> ++#include <linux/kernel.h> ++ ++ ++/* PCI vendor id for controller */ ++#define VENDOR_ID 0x8086 ++ ++/* PCI device id for controller */ ++#define DEVICE_ID 0x4110 ++ ++ ++/* === Lincroft Message Bus Interface === */ ++/* Message Control Register */ ++#define LNC_MCR_OFFSET 0xD0 ++ ++/* Message Data Register */ ++#define LNC_MDR_OFFSET 0xD4 ++ ++/* Message Opcodes */ ++#define LNC_MESSAGE_READ_OPCODE 0xD0 ++#define LNC_MESSAGE_WRITE_OPCODE 0xE0 ++ ++/* Message Write Byte Enables */ ++#define LNC_MESSAGE_BYTE_WRITE_ENABLES 0xF ++ ++/* B-unit Port */ ++#define LNC_BUNIT_PORT 0x3 ++ ++/* === Lincroft B-Unit Registers - Programmed by IA32 firmware === */ ++#define LNC_BRAR0L 0x10 ++#define LNC_BRAR0H 0x11 ++#define LNC_BRAR1L 0x12 ++#define LNC_BRAR1H 0x13 ++ ++/* Reserved for SeP */ ++#define LNC_BRAR2L 0x14 ++#define LNC_BRAR2H 0x15 ++ ++/* Moorestown supports three restricted access regions. */ ++#define MRST_NUM_RAR 3 ++ ++ ++/* RAR Bus Address Range */ ++struct RAR_address_range { ++ u32 low; ++ u32 high; ++}; ++ ++/* Structure containing low and high RAR register offsets. */ ++struct RAR_offsets { ++ u32 low; /* Register offset for low RAR bus address. */ ++ u32 high; /* Register offset for high RAR bus address. */ ++}; ++ ++struct RAR_client { ++ int (*client_callback)(void *client_data); ++ void *customer_data; ++ int client_called; ++ }; ++ ++DEFINE_SPINLOCK(rar_spinlock_lock); ++DEFINE_SPINLOCK(lnc_reg_lock); ++ ++struct RAR_device { ++ unsigned long rar_flags; ++ unsigned long lnc_reg_flags; ++ struct RAR_offsets rar_offsets[MRST_NUM_RAR]; ++ struct RAR_address_range rar_addr[MRST_NUM_RAR]; ++ struct pci_dev *rar_dev; ++ u32 registered; ++ }; ++ ++/* this platform has only one rar_device for 3 rar regions */ ++struct RAR_device my_rar_device; ++ ++/* flag to indicatew whether or not this driver is registered; ++ * this is for the entire driver and not just a device */ ++int driver_registered; ++ ++/* this data is for handling requests from other drivers which arrive ++ * prior to this driver initializing ++ */ ++ ++struct RAR_client clients[MRST_NUM_RAR]; ++int num_clients; ++ ++/* prototype for init */ ++static int __init rar_init_handler(void); ++static void __exit rar_exit_handler(void); ++ ++const struct pci_device_id rar_pci_id_tbl[] = { ++ { PCI_DEVICE(VENDOR_ID, DEVICE_ID) }, ++ { 0 } ++}; ++ ++MODULE_DEVICE_TABLE(pci, rar_pci_id_tbl); ++ ++/* ++ * Function that is activated on the succesful probe of the RAR ++ * device (Moorestown host controller). ++ */ ++static int rar_probe(struct pci_dev *dev, const struct pci_device_id *id); ++ ++/* field for registering driver to PCI device */ ++static struct pci_driver rar_pci_driver = { ++ .name = "rar_register", ++ .id_table = rar_pci_id_tbl, ++ .probe = rar_probe ++}; ++ ++const struct pci_device_id *my_id_table = rar_pci_id_tbl; ++ ++/* ++ * This function is used to retrieved RAR info using the Lincroft ++ * message bus interface. ++ */ ++static int memrar_get_rar_addr(struct pci_dev *pdev, ++ int offset, ++ u32 *addr) ++{ ++ /* ++ * ======== The Lincroft Message Bus Interface ======== ++ * Lincroft registers may be obtained from the PCI ++ * (the Host Bridge) using the Lincroft Message Bus ++ * Interface. That message bus interface is generally ++ * comprised of two registers: a control register (MCR, 0xDO) ++ * and a data register (MDR, 0xD4). ++ * ++ * The MCR (message control register) format is the following: ++ * 1. [31:24]: Opcode ++ * 2. [23:16]: Port ++ * 3. [15:8]: Register Offset ++ * 4. [7:4]: Byte Enables (use 0xF to set all of these bits ++ * to 1) ++ * 5. [3:0]: reserved ++ * ++ * Read (0xD0) and write (0xE0) opcodes are written to the ++ * control register when reading and writing to Lincroft ++ * registers, respectively. ++ * ++ * We're interested in registers found in the Lincroft ++ * B-unit. The B-unit port is 0x3. ++ * ++ * The six B-unit RAR register offsets we use are listed ++ * earlier in this file. ++ * ++ * Lastly writing to the MCR register requires the "Byte ++ * enables" bits to be set to 1. This may be achieved by ++ * writing 0xF at bit 4. ++ * ++ * The MDR (message data register) format is the following: ++ * 1. [31:0]: Read/Write Data ++ * ++ * Data being read from this register is only available after ++ * writing the appropriate control message to the MCR ++ * register. ++ * ++ * Data being written to this register must be written before ++ * writing the appropriate control message to the MCR ++ * register. ++ */ ++ ++ int result; ++ ++ /* Construct control message */ ++ u32 const message = ++ (LNC_MESSAGE_READ_OPCODE << 24) ++ | (LNC_BUNIT_PORT << 16) ++ | (offset << 8) ++ | (LNC_MESSAGE_BYTE_WRITE_ENABLES << 4); ++ ++ dev_dbg(&pdev->dev, "Offset for 'get' LNC MSG is %x\n", offset); ++ ++ if (addr == 0) { ++ WARN_ON(1); ++ return -EINVAL; ++ } ++ ++ spin_lock_irqsave(&lnc_reg_lock, my_rar_device.lnc_reg_flags); ++ ++ /* Send the control message */ ++ result = pci_write_config_dword(pdev, ++ LNC_MCR_OFFSET, ++ message); ++ ++ dev_dbg(&pdev->dev, ++ "Result from send ctl register is %x\n", ++ result); ++ ++ if (!result) { ++ result = pci_read_config_dword(pdev, ++ LNC_MDR_OFFSET, ++ addr); ++ ++ dev_dbg(&pdev->dev, ++ "Result from read data register is %x\n", ++ result); ++ ++ dev_dbg(&pdev->dev, ++ "Value read from data register is %x\n", ++ *addr); ++ } ++ ++ spin_unlock_irqrestore(&lnc_reg_lock, my_rar_device.lnc_reg_flags); ++ ++ return result; ++} ++ ++static int memrar_set_rar_addr(struct pci_dev *pdev, ++ int offset, ++ u32 addr) ++{ ++ /* ++ * Data being written to this register must be written before ++ * writing the appropriate control message to the MCR ++ * register. ++ * ++ * @note See memrar_get_rar_addr() for a description of the ++ * message bus interface being used here. ++ */ ++ ++ int result = 0; ++ ++ /* Construct control message */ ++ u32 const message = ++ (LNC_MESSAGE_WRITE_OPCODE << 24) ++ | (LNC_BUNIT_PORT << 16) ++ | (offset << 8) ++ | (LNC_MESSAGE_BYTE_WRITE_ENABLES << 4); ++ ++ if (addr == 0) { ++ WARN_ON(1); ++ return -EINVAL; ++ } ++ ++ spin_lock_irqsave(&lnc_reg_lock, my_rar_device.lnc_reg_flags); ++ ++ dev_dbg(&pdev->dev, ++ "Offset for 'set' LNC MSG is %x\n", offset); ++ ++ /* Send the control message */ ++ result = pci_write_config_dword(pdev, ++ LNC_MDR_OFFSET, ++ addr); ++ ++ dev_dbg(&pdev->dev, ++ "Result from write data register is %x\n", ++ result); ++ ++ if (!result) { ++ dev_dbg(&pdev->dev, ++ "Value written to data register is %x\n", ++ addr); ++ ++ result = pci_write_config_dword(pdev, ++ LNC_MCR_OFFSET, ++ message); ++ ++ dev_dbg(&pdev->dev, ++ "Result from send ctl register is %x\n", ++ result); ++ } ++ ++ spin_unlock_irqrestore(&lnc_reg_lock, my_rar_device.lnc_reg_flags); ++ ++ return result; ++} ++ ++/* ++ * Initialize RAR parameters, such as bus addresses, etc. ++ */ ++static int memrar_init_rar_params(struct pci_dev *pdev) ++{ ++ struct RAR_offsets const *end = my_rar_device.rar_offsets ++ + MRST_NUM_RAR; ++ struct RAR_offsets const *i; ++ struct pci_dev *my_pdev; ++ unsigned int n = 0; ++ int result = 0; ++ ++ /* Retrieve RAR start and end bus addresses. */ ++ ++ /* ++ * Access the RAR registers through the Lincroft Message Bus ++ * Interface on PCI device: 00:00.0 Host bridge. ++ */ ++ ++ /* struct pci_dev *pdev = pci_get_bus_and_slot(0, PCI_DEVFN(0,0)); */ ++ ++ my_pdev = pci_dev_get(pdev); ++ ++ if (my_pdev == NULL) { ++ WARN_ON(1); ++ return -ENODEV; ++ } ++ ++ for (i = my_rar_device.rar_offsets; i != end; ++i, ++n) { ++ if (memrar_get_rar_addr(my_pdev, ++ i->low, ++ &(my_rar_device.rar_addr[n].low)) != 0 ++ || memrar_get_rar_addr(my_pdev, ++ i->high, ++ &(my_rar_device.rar_addr[n].high)) ++ != 0) { ++ result = -1; ++ break; ++ } ++ ++ /* ++ * Only the upper 22 bits of the RAR addresses are ++ * stored in their corresponding RAR registers so we ++ * must set the lower 10 bits accordingly. ++ * ++ * The low address has its lower 10 bits cleared, and ++ * the high address has all its lower 10 bits set, ++ * e.g.: ++ * ++ * low = 0x2ffffc00 ++ * high = 0x3fffffff ++ * ++ * This is not arbitrary, and is actually how RAR ++ * addressing/configuration works. ++ */ ++ my_rar_device.rar_addr[n].low &= 0xfffffc00u; ++ ++ /* ++ * Set bits 9:0 if the 1 KiB aligned (the upper 22 ++ * bits) high address is non-zero. ++ * ++ * Otherwise set all bits to zero since that indicates ++ * no RAR address is configured. ++ */ ++ if ((my_rar_device.rar_addr[n].high & 0xfffffc00u) == 0) ++ my_rar_device.rar_addr[n].high = 0; ++ else ++ my_rar_device.rar_addr[n].high |= 0x3ffu; ++ } ++ ++ /* Done accessing the device. */ ++ /* pci_dev_put(pdev); */ ++ ++ if (result == 0) { ++ size_t z; ++ for (z = 0; z != MRST_NUM_RAR; ++z) { ++ /* ++ * "BRAR" refers to the RAR registers in the ++ * Lincroft B-unit. ++ */ ++ dev_info(&pdev->dev, ++ "BRAR[%u] bus address range = " ++ "[0x%08x, 0x%08x]\n", ++ z, ++ my_rar_device.rar_addr[z].low, ++ my_rar_device.rar_addr[z].high); ++ } ++ } ++ ++ return result; ++} ++ ++/* ++ * This function registers the driver with the device subsystem ( ++ * either PCI, USB, etc). ++*/ ++static int __init rar_init_handler(void) ++{ ++ return pci_register_driver(&rar_pci_driver); ++} ++ ++static void __exit rar_exit_handler(void) ++{ ++ pci_unregister_driver(&rar_pci_driver); ++} ++ ++module_init(rar_init_handler); ++module_exit(rar_exit_handler); ++ ++MODULE_LICENSE("GPL"); ++MODULE_DESCRIPTION("Intel Restricted Access Region Register Driver"); ++ ++/* ++ * Function that is activaed on the succesful probe of the RAR device ++ * (Moorestown host controller). ++ */ ++int rar_probe(struct pci_dev *dev, const struct pci_device_id *id) ++{ ++ int error; ++ int counter; ++ ++ dev_dbg(&dev->dev, ++ "PCI probe starting\n"); ++ ++ /* enable the device */ ++ error = pci_enable_device(dev); ++ if (error) { ++ dev_err(&dev->dev, ++ "Error enabling RAR register PCI device\n"); ++ goto end_function; ++ } ++ ++ /* we have only one device; fill in the rar_device structure */ ++ my_rar_device.rar_dev = dev; ++ my_rar_device.rar_flags = 0; ++ my_rar_device.lnc_reg_flags = 0; ++ my_rar_device.rar_offsets[0].low = LNC_BRAR0L; ++ my_rar_device.rar_offsets[0].high = LNC_BRAR0H; ++ my_rar_device.rar_offsets[1].low = LNC_BRAR1L; ++ my_rar_device.rar_offsets[1].high = LNC_BRAR1H; ++ my_rar_device.rar_offsets[2].low = LNC_BRAR2L; ++ my_rar_device.rar_offsets[2].high = LNC_BRAR2H; ++ my_rar_device.registered = 1; ++ ++ /* ++ * Initialize the RAR parameters, which have to be retrieved */ ++ /* via the message bus interface. ++ */ ++ error = memrar_init_rar_params(dev); ++ if (error) { ++ pci_disable_device(dev); ++ ++ dev_err(&dev->dev, ++ "Error retrieving RAR addresses\n"); ++ ++ goto end_function; ++ } ++ ++ driver_registered = 1; ++ ++ /* now call anyone who has registered (using callbacks) */ ++ for (counter = 0; counter < num_clients; counter += 1) { ++ if (!clients[counter].client_called) { ++ error = (*clients[counter].client_callback)( ++ clients[counter].customer_data); ++ clients[counter].client_called = 1; ++ dev_dbg(&my_rar_device.rar_dev->dev, ++ "Callback called for %d\n", ++ counter); ++ } ++ } ++ ++end_function: ++ ++ return error; ++} ++ ++ ++/* ++ * The rar_get_address function is used by other device drivers ++ * to obtain RAR address information on a RAR. It takes three ++ * parameters: ++ * ++ * int rar_index ++ * The rar_index is an index to the rar for which you wish to retrieve ++ * the address information. ++ * Values can be 0,1, or 2. ++ * ++ * The function returns a 0 upon success or a -1 if there is no RAR ++ * facility on this system. ++ */ ++int rar_get_address(int rar_index, ++ u32 *start_address, ++ u32 *end_address) ++{ ++ int result = -ENODEV; ++ ++ if (my_rar_device.registered) { ++ if (start_address == 0 ++ || end_address == 0 ++ || rar_index >= MRST_NUM_RAR ++ || rar_index < 0) { ++ result = -EINVAL; ++ } else { ++ *start_address = my_rar_device.rar_addr[rar_index].low; ++ *end_address = my_rar_device.rar_addr[rar_index].high; ++ result = 0; ++ } ++ } ++ ++ return result; ++} ++EXPORT_SYMBOL(rar_get_address); ++ ++/* ++ * The rar_lock function is ued by other device drivers to lock an RAR. ++ * once an RAR is locked, it stays locked until the next system reboot. ++ * The function takes one parameter: ++ * ++ * int rar_index ++ * The rar_index is an index to the rar that you want to lock. ++ * Values can be 0,1, or 2. ++ * ++ * The function returns a 0 upon success or a -1 if there is no RAR ++ * facility on this system. ++ */ ++int rar_lock(int rar_index) ++{ ++ int result = -ENODEV; ++ ++ if (rar_index >= MRST_NUM_RAR || rar_index < 0) { ++ result = -EINVAL; ++ goto exit_rar_lock; ++ } ++ ++ spin_lock_irqsave(&rar_spinlock_lock, my_rar_device.rar_flags); ++ ++ if (my_rar_device.registered) { ++ ++ u32 low; ++ u32 high; ++ ++ /* ++ * Clear bits 4:0 in low register to lock. ++ * Clear bits 8,4:0 in high register to lock. ++ * ++ * The rest of the lower 10 bits in both registers are ++ * unused so we might as well clear them all. ++ */ ++ if (rar_index == RAR_TYPE_VIDEO) { ++ low = my_rar_device.rar_addr[rar_index].low & ++ 0xfffffc00u; ++ high = my_rar_device.rar_addr[rar_index].high & ++ 0xfffffc00u; ++ low |= 0x00000009; ++ high |= 0x00000015; ++ } ++ ++ else if (rar_index == RAR_TYPE_AUDIO) { ++ low = my_rar_device.rar_addr[rar_index].low & ++ 0xfffffc00u; ++ high = my_rar_device.rar_addr[rar_index].high & ++ 0xfffffc00u; ++ low |= 0x00000008; ++ high |= 0x00000018; ++ } ++ ++ else { ++ low = my_rar_device.rar_addr[rar_index].low & ++ 0xfffffc00u; ++ high = my_rar_device.rar_addr[rar_index].high & ++ 0xfffffc00u; ++ high |= 0x00000018; ++ } ++ ++ /* ++ * Now program the register using the Lincroft message ++ * bus interface. ++ */ ++ result = memrar_set_rar_addr(my_rar_device.rar_dev, ++ my_rar_device.rar_offsets[rar_index].low, ++ low); ++ ++ if (result == 0) ++ result = memrar_set_rar_addr( ++ my_rar_device.rar_dev, ++ my_rar_device.rar_offsets[rar_index].high, ++ high); ++ } ++ ++ spin_unlock_irqrestore(&rar_spinlock_lock, my_rar_device.rar_flags); ++ ++exit_rar_lock: ++ ++ return result; ++} ++EXPORT_SYMBOL(rar_lock); ++ ++/* The register_rar function is to used by other device drivers ++ * to ensure that this driver is ready. As we cannot be sure of ++ * the compile/execute order of dirvers in ther kernel, it is ++ * best to give this driver a callback function to call when ++ * it is ready to give out addresses. The callback function ++ * would have those steps that continue the initialization of ++ * a driver that do require a valid RAR address. One of those ++ * steps would be to call get_rar_address() ++ * This function return 0 on success an -1 on failure. ++ */ ++int register_rar(int (*callback)(void *yourparameter), void *yourparameter) ++{ ++ ++ int result; ++ ++ result = 0; ++ ++ if (driver_registered) { ++ ++ /* if the driver already registered, then we can simply ++ call the callback right now */ ++ ++ result = (*callback)(yourparameter); ++ if (result) { ++ dev_dbg(&my_rar_device.rar_dev->dev, ++ "Immediate Callback failed: %x\n", ++ result); ++ } else { ++ dev_dbg(&my_rar_device.rar_dev->dev, ++ "Immediate Callback ran okay\n"); ++ } ++ ++ return result; ++ } ++ ++ else if (num_clients >= MRST_NUM_RAR) { ++ return -ENODEV; ++ } ++ ++ else { ++ ++ clients[num_clients].client_callback = callback; ++ clients[num_clients].customer_data = yourparameter; ++ clients[num_clients].client_called = 0; ++ num_clients += 1; ++ dev_dbg(&my_rar_device.rar_dev->dev, "Callback registered\n"); ++ } ++ ++return result; ++ ++} ++EXPORT_SYMBOL(register_rar); ++ ++/* ++ Local Variables: ++ c-file-style: "linux" ++ End: ++*/ +Index: linux-2.6.33/include/linux/rar/memrar.h +=================================================================== +--- /dev/null ++++ linux-2.6.33/include/linux/rar/memrar.h +@@ -0,0 +1,172 @@ ++/* ++ * RAR Handler (/dev/memrar) internal driver API. ++ * Copyright (C) 2009 Intel Corporation. All rights reserved. ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of version 2 of the GNU General ++ * Public License as published by the Free Software Foundation. ++ * ++ * This program is distributed in the hope that it will be ++ * useful, but WITHOUT ANY WARRANTY; without even the implied ++ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR ++ * PURPOSE. See the GNU General Public License for more details. ++ * You should have received a copy of the GNU General Public ++ * License along with this program; if not, write to the Free ++ * Software Foundation, Inc., 59 Temple Place - Suite 330, ++ * Boston, MA 02111-1307, USA. ++ * The full GNU General Public License is included in this ++ * distribution in the file called COPYING. ++ */ ++ ++ ++#ifndef _MEMRAR_H ++#define _MEMRAR_H ++ ++#include <linux/ioctl.h> ++#include <linux/types.h> ++ ++ ++/* ++ * Constants that specify different kinds of RAR regions that could be ++ * set up. ++ */ ++static __u32 const RAR_TYPE_VIDEO; /* 0 */ ++static __u32 const RAR_TYPE_AUDIO = 1; ++static __u32 const RAR_TYPE_IMAGE = 2; ++static __u32 const RAR_TYPE_DATA = 3; ++ ++/* ++ * @struct RAR_stat ++ * ++ * @brief This structure is used for @c RAR_HANDLER_STAT ioctl and for ++ * @c RAR_get_stat() user space wrapper function. ++ */ ++struct RAR_stat { ++ /* Type of RAR memory (e.g., audio vs. video) */ ++ __u32 type; ++ ++ /* ++ * Total size of RAR memory region. ++ */ ++ __u32 capacity; ++ ++ /* Size of the largest reservable block. */ ++ __u32 largest_block_size; ++}; ++ ++ ++/* ++ * @struct RAR_block_info ++ * ++ * @brief The argument for the @c RAR_HANDLER_RESERVE @c ioctl. ++ * ++ */ ++struct RAR_block_info { ++ /* Type of RAR memory (e.g., audio vs. video) */ ++ __u32 type; ++ ++ /* Requested size of a block to be reserved in RAR. */ ++ __u32 size; ++ ++ /* Handle that can be used to refer to reserved block. */ ++ __u32 handle; ++}; ++ ++/* ++ * @struct RAR_buffer ++ * ++ * Structure that contains all information related to a given block of ++ * memory in RAR. It is generally only used when retrieving bus ++ * addresses. ++ * ++ * @note This structure is used only by RAR-enabled drivers, and is ++ * not intended to be exposed to the user space. ++ */ ++struct RAR_buffer { ++ /* Structure containing base RAR buffer information */ ++ struct RAR_block_info info; ++ ++ /* Buffer bus address */ ++ __u32 bus_address; ++}; ++ ++ ++#define RAR_IOCTL_BASE 0xE0 ++ ++/* Reserve RAR block. */ ++#define RAR_HANDLER_RESERVE _IOWR(RAR_IOCTL_BASE, 0x00, struct RAR_block_info) ++ ++/* Release previously reserved RAR block. */ ++#define RAR_HANDLER_RELEASE _IOW(RAR_IOCTL_BASE, 0x01, __u32) ++ ++/* Get RAR stats. */ ++#define RAR_HANDLER_STAT _IOWR(RAR_IOCTL_BASE, 0x02, struct RAR_stat) ++ ++ ++/* -------------------------------------------------------------- */ ++/* Kernel Side RAR Handler Interface */ ++/* -------------------------------------------------------------- */ ++ ++/* ++ * @function rar_reserve ++ * ++ * @brief Reserve RAR buffers. ++ * ++ * This function will reserve buffers in the restricted access regions ++ * of given types. ++ * ++ * @return Number of successfully reserved buffers. ++ * Successful buffer reservations will have the corresponding ++ * @c bus_address field set to a non-zero value in the ++ * given @a buffers vector. ++ */ ++extern size_t rar_reserve(struct RAR_buffer *buffers, ++ size_t count); ++ ++/* ++ * @function rar_release ++ * ++ * @brief Release RAR buffers retrieved through call to ++ * @c rar_reserve() or @c rar_handle_to_bus(). ++ * ++ * This function will release RAR buffers that were retrieved through ++ * a call to @c rar_reserve() or @c rar_handle_to_bus() by ++ * decrementing the reference count. The RAR buffer will be reclaimed ++ * when the reference count drops to zero. ++ * ++ * @return Number of successfully released buffers. ++ * Successful releases will have their handle field set to ++ * zero in the given @a buffers vector. ++ */ ++extern size_t rar_release(struct RAR_buffer *buffers, ++ size_t count); ++ ++/* ++ * @function rar_handle_to_bus ++ * ++ * @brief Convert a vector of RAR handles to bus addresses. ++ * ++ * This function will retrieve the RAR buffer bus addresses, type and ++ * size corresponding to the RAR handles provided in the @a buffers ++ * vector. ++ * ++ * @return Number of successfully converted buffers. ++ * The bus address will be set to @c 0 for unrecognized ++ * handles. ++ * ++ * @note The reference count for each corresponding buffer in RAR will ++ * be incremented. Call @c rar_release() when done with the ++ * buffers. ++ */ ++extern size_t rar_handle_to_bus(struct RAR_buffer *buffers, ++ size_t count); ++ ++ ++#endif /* _MEMRAR_H */ ++ ++ ++/* ++ Local Variables: ++ c-file-style: "linux" ++ End: ++*/ +Index: linux-2.6.33/include/linux/rar/rar_register.h +=================================================================== +--- /dev/null ++++ linux-2.6.33/include/linux/rar/rar_register.h +@@ -0,0 +1,79 @@ ++/* ++ * Copyright (C) 2008, 2009 Intel Corporation. All rights reserved. ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of version 2 of the GNU General ++ * Public License as published by the Free Software Foundation. ++ * ++ * This program is distributed in the hope that it will be ++ * useful, but WITHOUT ANY WARRANTY; without even the implied ++ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR ++ * PURPOSE. See the GNU General Public License for more details. ++ * You should have received a copy of the GNU General Public ++ * License along with this program; if not, write to the Free ++ * Software Foundation, Inc., 59 Temple Place - Suite 330, ++ * Boston, MA 02111-1307, USA. ++ * The full GNU General Public License is included in this ++ * distribution in the file called COPYING. ++ */ ++ ++ ++#ifndef _RAR_REGISTER_H ++#define _RAR_REGISTER_H ++ ++# include <linux/types.h> ++ ++/* The register_rar function is to used by other device drivers ++ * to ensure that this driver is ready. As we cannot be sure of ++ * the compile/execute order of dirvers in ther kernel, it is ++ * best to give this driver a callback function to call when ++ * it is ready to give out addresses. The callback function ++ * would have those steps that continue the initialization of ++ * a driver that do require a valid RAR address. One of those ++ * steps would be to call get_rar_address() ++ * This function return 0 on success an -1 on failure. ++ */ ++int register_rar(int (*callback)(void *yourparameter), void *yourparameter); ++ ++/* The get_rar_address function is used by other device drivers ++ * to obtain RAR address information on a RAR. It takes two ++ * parameter: ++ * ++ * int rar_index ++ * The rar_index is an index to the rar for which you wish to retrieve ++ * the address information. ++ * Values can be 0,1, or 2. ++ * ++ * struct RAR_address_struct is a pointer to a place to which the function ++ * can return the address structure for the RAR. ++ * ++ * The function returns a 0 upon success or a -1 if there is no RAR ++ * facility on this system. ++ */ ++int rar_get_address(int rar_index, ++ u32 *start_address, ++ u32 *end_address); ++ ++ ++/* The lock_rar function is ued by other device drivers to lock an RAR. ++ * once an RAR is locked, it stays locked until the next system reboot. ++ * The function takes one parameter: ++ * ++ * int rar_index ++ * The rar_index is an index to the rar that you want to lock. ++ * Values can be 0,1, or 2. ++ * ++ * The function returns a 0 upon success or a -1 if there is no RAR ++ * facility on this system. ++ */ ++int rar_lock(int rar_index); ++ ++ ++#endif /* _RAR_REGISTER_H */ ++ ++ ++/* ++ Local Variables: ++ c-file-style: "linux" ++ End: ++*/ +Index: linux-2.6.33/drivers/misc/Kconfig +=================================================================== +--- linux-2.6.33.orig/drivers/misc/Kconfig ++++ linux-2.6.33/drivers/misc/Kconfig +@@ -249,6 +249,17 @@ config SGI_GRU_DEBUG + This option enables addition debugging code for the SGI GRU driver. If + you are unsure, say N. + ++config MRST_RAR_HANDLER ++ tristate "RAR handler driver for Intel Moorestown platform" ++ depends on X86 ++ select RAR_REGISTER ++ ---help--- ++ This driver provides a memory management interface to ++ restricted access regions available in the Intel Moorestown ++ platform. ++ ++ If unsure, say N. ++ + config MRST_VIB + tristate "vibrator driver for Intel Moorestown platform" + help +Index: linux-2.6.33/drivers/misc/Makefile +=================================================================== +--- linux-2.6.33.orig/drivers/misc/Makefile ++++ linux-2.6.33/drivers/misc/Makefile +@@ -22,6 +22,8 @@ obj-$(CONFIG_CS5535_MFGPT) += cs5535-mfg + obj-$(CONFIG_HP_ILO) += hpilo.o + obj-$(CONFIG_MRST) += intel_mrst.o + obj-$(CONFIG_ISL29003) += isl29003.o ++obj-$(CONFIG_MRST_RAR_HANDLER) += memrar.o ++memrar-y := memrar_allocator.o memrar_handler.o + obj-$(CONFIG_MRST_VIB) += mrst_vib.o + obj-$(CONFIG_EP93XX_PWM) += ep93xx_pwm.o + obj-$(CONFIG_DS1682) += ds1682.o +Index: linux-2.6.33/drivers/misc/memrar_allocator.c +=================================================================== +--- /dev/null ++++ linux-2.6.33/drivers/misc/memrar_allocator.c +@@ -0,0 +1,374 @@ ++/* ++ * memrar_allocator 0.2: An allocator for Intel RAR. ++ * ++ * Copyright (C) 2009 Intel Corporation. All rights reserved. ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of version 2 of the GNU General ++ * Public License as published by the Free Software Foundation. ++ * ++ * This program is distributed in the hope that it will be ++ * useful, but WITHOUT ANY WARRANTY; without even the implied ++ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR ++ * PURPOSE. See the GNU General Public License for more details. ++ * You should have received a copy of the GNU General Public ++ * License along with this program; if not, write to the Free ++ * Software Foundation, Inc., 59 Temple Place - Suite 330, ++ * Boston, MA 02111-1307, USA. ++ * The full GNU General Public License is included in this ++ * distribution in the file called COPYING. ++ * ++ * ++ * ------------------------------------------------------------------ ++ * ++ * This simple allocator implementation provides a ++ * malloc()/free()-like interface for reserving space within a ++ * previously reserved block of memory. It is not specific to ++ * any hardware, nor is it coupled with the lower level paging ++ * mechanism. ++ * ++ * The primary goal of this implementation is to provide a means ++ * to partition an arbitrary block of memory without actually ++ * accessing the memory or incurring any hardware side-effects ++ * (e.g. paging). It is, in effect, a bookkeeping mechanism for ++ * buffers. ++ */ ++ ++ ++#include "memrar_allocator.h" ++#include <linux/slab.h> ++#include <linux/bug.h> ++#include <linux/kernel.h> ++ ++ ++struct memrar_allocator *memrar_create_allocator(unsigned long base, ++ size_t capacity, ++ size_t block_size) ++{ ++ struct memrar_allocator *allocator = NULL; ++ struct memrar_free_list *first_node = NULL; ++ ++ /* ++ * Make sure the base address is aligned on a block_size ++ * boundary. ++ * ++ * @todo Is this necessary? ++ */ ++ /* base = ALIGN(base, block_size); */ ++ ++ /* Validate parameters. ++ * ++ * Make sure we can allocate the entire memory allocator ++ * space. Zero capacity or block size are obviously invalid. ++ */ ++ if (base == 0 ++ || capacity == 0 ++ || block_size == 0 ++ || ULONG_MAX - capacity < base ++ || capacity < block_size) ++ return allocator; ++ ++ /* ++ * There isn't much point in creating a memory allocator that ++ * is only capable of holding one block but we'll allow it, ++ * and issue a diagnostic. ++ */ ++ WARN(capacity < block_size * 2, ++ "memrar: Only one block available to allocator.\n"); ++ ++ allocator = kmalloc(sizeof(*allocator), GFP_KERNEL); ++ ++ if (allocator == NULL) ++ return allocator; ++ ++ mutex_init(&allocator->lock); ++ allocator->base = base; ++ ++ /* Round the capacity down to a multiple of block_size. */ ++ allocator->capacity = (capacity / block_size) * block_size; ++ ++ allocator->block_size = block_size; ++ ++ allocator->largest_free_area = allocator->capacity; ++ ++ /* Initialize the handle and free lists. */ ++ INIT_LIST_HEAD(&allocator->handle_list.list); ++ INIT_LIST_HEAD(&allocator->free_list.list); ++ ++ first_node = kmalloc(sizeof(*first_node), GFP_KERNEL); ++ if (first_node == NULL) { ++ kfree(allocator); ++ allocator = NULL; ++ } else { ++ /* Full range of blocks is available. */ ++ first_node->begin = base; ++ first_node->end = base + allocator->capacity; ++ list_add(&first_node->list, ++ &allocator->free_list.list); ++ } ++ ++ return allocator; ++} ++ ++void memrar_destroy_allocator(struct memrar_allocator *allocator) ++{ ++ /* ++ * Assume that the memory allocator lock isn't held at this ++ * point in time. Caller must ensure that. ++ */ ++ ++ struct memrar_free_list *pos; ++ struct memrar_free_list *n; ++ ++ if (allocator == NULL) ++ return; ++ ++ mutex_lock(&allocator->lock); ++ ++ /* Reclaim free list resources. */ ++ list_for_each_entry_safe(pos, ++ n, ++ &allocator->free_list.list, ++ list) { ++ list_del(&pos->list); ++ kfree(pos); ++ } ++ ++ mutex_unlock(&allocator->lock); ++ ++ kfree(allocator); ++} ++ ++unsigned long memrar_allocator_alloc(struct memrar_allocator *allocator, ++ size_t size) ++{ ++ struct memrar_free_list *pos = NULL; ++ ++ size_t num_blocks; ++ unsigned long reserved_bytes; ++ ++ /* ++ * Address of allocated buffer. We assume that zero is not a ++ * valid address. ++ */ ++ unsigned long addr = 0; ++ ++ if (allocator == NULL || size == 0) ++ return addr; ++ ++ /* Reserve enough blocks to hold the amount of bytes requested. */ ++ num_blocks = DIV_ROUND_UP(size, allocator->block_size); ++ ++ reserved_bytes = num_blocks * allocator->block_size; ++ ++ mutex_lock(&allocator->lock); ++ ++ if (reserved_bytes > allocator->largest_free_area) { ++ mutex_unlock(&allocator->lock); ++ return addr; ++ } ++ ++ /* ++ * Iterate through the free list to find a suitably sized ++ * range of free contiguous memory blocks. ++ */ ++ list_for_each_entry(pos, &allocator->free_list.list, list) { ++ size_t const curr_size = pos->end - pos->begin; ++ ++ if (curr_size >= reserved_bytes) { ++ struct memrar_handle *handle = NULL; ++ struct memrar_handle_list * const new_node = ++ kmalloc(sizeof(*new_node), GFP_KERNEL); ++ ++ if (new_node == NULL) ++ break; ++ ++ list_add(&new_node->list, ++ &allocator->handle_list.list); ++ ++ handle = &new_node->handle; ++ handle->end = pos->end; ++ pos->end -= reserved_bytes; ++ handle->begin = pos->end; ++ addr = handle->begin; ++ ++ if (curr_size == allocator->largest_free_area) ++ allocator->largest_free_area -= ++ reserved_bytes; ++ ++ break; ++ } ++ } ++ ++ mutex_unlock(&allocator->lock); ++ ++ return addr; ++} ++ ++long memrar_allocator_free(struct memrar_allocator *allocator, ++ unsigned long addr) ++{ ++ struct list_head *pos = NULL; ++ struct list_head *tmp = NULL; ++ struct memrar_handle_list *handles = NULL; ++ struct memrar_handle *handle = NULL; ++ struct memrar_free_list *new_node = NULL; ++ int result = -ENOMEM; ++ ++ if (allocator == NULL) ++ return -EINVAL; ++ ++ if (addr == 0) ++ return 0; /* Ignore free(0). */ ++ ++ mutex_lock(&allocator->lock); ++ ++ /* Find the corresponding handle. */ ++ list_for_each_entry(handles, ++ &allocator->handle_list.list, ++ list) { ++ if (handles->handle.begin == addr) { ++ handle = &handles->handle; ++ break; ++ } ++ } ++ ++ /* No such buffer created by this allocator. */ ++ if (handle == NULL) { ++ mutex_unlock(&allocator->lock); ++ return -EFAULT; ++ } ++ ++ /* ++ * Coalesce adjacent chunks of memory if possible. ++ * ++ * @note This isn't full blown coalescing since we're only ++ * coalescing at most three chunks of memory. ++ */ ++ list_for_each_safe(pos, tmp, &allocator->free_list.list) { ++ /* @todo O(n) performance. Optimize. */ ++ ++ struct memrar_free_list * const chunk = ++ list_entry(pos, ++ struct memrar_free_list, ++ list); ++ ++ struct memrar_free_list * const next = ++ list_entry(pos->next, ++ struct memrar_free_list, ++ list); ++ ++ /* Extend size of existing free adjacent chunk. */ ++ if (chunk->end == handle->begin) { ++ /* ++ * Chunk "less than" than the one we're ++ * freeing is adjacent. ++ */ ++ ++ unsigned long new_chunk_size; ++ ++ chunk->end = handle->end; ++ ++ /* ++ * Now check if next free chunk is adjacent to ++ * the current extended free chunk. ++ */ ++ if (pos != pos->next ++ && chunk->end == next->begin) { ++ chunk->end = next->end; ++ list_del(pos->next); ++ kfree(next); ++ } ++ ++ new_chunk_size = chunk->end - chunk->begin; ++ ++ if (new_chunk_size > allocator->largest_free_area) ++ allocator->largest_free_area = ++ new_chunk_size; ++ ++ result = 0; ++ goto exit_memrar_free; ++ } else if (chunk->begin == handle->end) { ++ /* ++ * Chunk "greater than" than the one we're ++ * freeing is adjacent. ++ */ ++ ++ unsigned long new_chunk_size; ++ ++ chunk->begin = handle->begin; ++ ++ /* ++ * Now check if next free chunk is adjacent to ++ * the current extended free chunk. ++ */ ++ if (pos != pos->next ++ && chunk->begin == next->end) { ++ chunk->begin = next->begin; ++ list_del(pos->next); ++ kfree(next); ++ } ++ ++ new_chunk_size = chunk->end - chunk->begin; ++ ++ if (new_chunk_size > allocator->largest_free_area) ++ allocator->largest_free_area = ++ new_chunk_size; ++ ++ result = 0; ++ goto exit_memrar_free; ++ } ++ } ++ ++ /* ++ * Memory being freed is not adjacent to existing free areas ++ * of memory in the allocator. Add a new item to the free list. ++ * ++ * @todo Allocate this free_list node when the buffer itself ++ * is allocated to avoid a potential problem where a new ++ * node cannot be allocated due to lack of available ++ * kernel memory. We can then free this node in the ++ * above coalescing code node if it isn't needed. ++ * ++ * @todo While making this change would address potential ++ * memory allocation failure, it would also ++ * unfortunately reduce performance of buffer allocation ++ * provided by this allocator. ++ */ ++ new_node = kmalloc(sizeof(*new_node), GFP_KERNEL); ++ if (new_node != NULL) { ++ unsigned long new_chunk_size; ++ ++ new_node->begin = handle->begin; ++ new_node->end = handle->end; ++ list_add(&new_node->list, ++ &allocator->free_list.list); ++ ++ new_chunk_size = handle->end - handle->begin; ++ ++ if (new_chunk_size > allocator->largest_free_area) ++ allocator->largest_free_area = ++ new_chunk_size; ++ ++ result = 0; ++ } ++ ++exit_memrar_free: ++ ++ if (result == 0) ++ list_del(&handles->list); ++ ++ mutex_unlock(&allocator->lock); ++ ++ kfree(handles); ++ ++ return result; ++} ++ ++ ++ ++/* ++ Local Variables: ++ c-file-style: "linux" ++ End: ++*/ +Index: linux-2.6.33/drivers/misc/memrar_allocator.h +=================================================================== +--- /dev/null ++++ linux-2.6.33/drivers/misc/memrar_allocator.h +@@ -0,0 +1,165 @@ ++/* ++ * Copyright (C) 2009 Intel Corporation. All rights reserved. ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of version 2 of the GNU General ++ * Public License as published by the Free Software Foundation. ++ * ++ * This program is distributed in the hope that it will be ++ * useful, but WITHOUT ANY WARRANTY; without even the implied ++ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR ++ * PURPOSE. See the GNU General Public License for more details. ++ * You should have received a copy of the GNU General Public ++ * License along with this program; if not, write to the Free ++ * Software Foundation, Inc., 59 Temple Place - Suite 330, ++ * Boston, MA 02111-1307, USA. ++ * The full GNU General Public License is included in this ++ * distribution in the file called COPYING. ++ */ ++ ++#ifndef MEMRAR_ALLOCATOR_H ++#define MEMRAR_ALLOCATOR_H ++ ++ ++#include <linux/mutex.h> ++#include <linux/list.h> ++#include <linux/types.h> ++#include <linux/kernel.h> ++ ++/* ++ * @struct memrar_free_list ++ * ++ * @brief List of available areas of memory. ++ */ ++struct memrar_free_list { ++ /* Linked list of free memory allocator blocks. */ ++ struct list_head list; ++ ++ /* Beginning of available address range. */ ++ unsigned long begin; ++ ++ /* ++ * End of available address range, one past the end, ++ * i.e. [begin, end). ++ */ ++ unsigned long end; ++}; ++ ++struct memrar_allocator; ++ ++/* Structure that describes a chunk memory reserved by the allocator. */ ++struct memrar_handle { ++ /* Beginning of available address range. */ ++ unsigned long begin; ++ ++ /* ++ * End of available address range, one past the end, ++ * i.e. [begin, end). ++ */ ++ unsigned long end; ++}; ++ ++/* ++ * @struct memrar_handle_list ++ * ++ * @brief List of handles corresponding to allocated blocks of memory. ++ */ ++struct memrar_handle_list { ++ /* Linked list of handles corresponding to allocated blocks. */ ++ struct list_head list; ++ ++ /* Handle for the allocated block of memory. */ ++ struct memrar_handle handle; ++}; ++ ++/* ++ * @struct memrar_allocator ++ * ++ * @brief Encapsulation of the memory allocator state. ++ * ++ * This structure contains all memory allocator state, including the ++ * base address, capacity, free list, lock, etc. ++ */ ++struct memrar_allocator { ++ /* ++ * Lock used to synchronize access to the memory allocator ++ * state. ++ */ ++ struct mutex lock; ++ ++ /* Base (start) address of the memory allocator. */ ++ unsigned long base; ++ ++ /* Size of the memory allocator in bytes. */ ++ size_t capacity; ++ ++ /* ++ * The size in bytes of individual blocks within the memory ++ * allocator. ++ */ ++ size_t block_size; ++ ++ /* Largest free area of memory in the allocator in bytes. */ ++ size_t largest_free_area; ++ ++ /* List of handles for allocated blocks of memory. */ ++ struct memrar_handle_list handle_list; ++ ++ /* List of free address ranges. */ ++ struct memrar_free_list free_list; ++}; ++ ++/* ++ * @function memrar_create_allocator ++ * ++ * @brief Create a memory allocator. ++ * ++ * Create a memory allocator with the given capacity and block size. ++ * The capacity will be reduced to be a multiple of the block size, if ++ * necessary. ++ * ++ * @param base Address at which the memory allocator begins. ++ * @param capacity Desired size of the memory allocator. This value ++ * must be larger than the block_size, ideally more ++ * than twice as large since there wouldn't be much ++ * point in using a memory allocator otherwise. ++ * @param block_size The size of individual blocks within the memory ++ * allocator. This value must smaller than the ++ * capacity. ++ * @return An instance of the memory allocator, if creation succeeds. ++ * @return Zero if creation fails. Failure may occur if not enough ++ * kernel memory exists to create the memrar_allocator ++ * instance itself, or if the capacity and block_size ++ * arguments are not compatible or make sense. ++ */ ++struct memrar_allocator *memrar_create_allocator(unsigned long base, ++ size_t capacity, ++ size_t block_size); ++ ++/* ++ * Reclaim resources held by the memory allocator. The caller must ++ * explicitly free all memory reserved by memrar_allocator_alloc() ++ * prior to calling this function. Otherwise leaks will occur. ++ */ ++void memrar_destroy_allocator(struct memrar_allocator *allocator); ++ ++/* ++ * Reserve chunk of memory of given size in the memory allocator. ++ */ ++unsigned long memrar_allocator_alloc(struct memrar_allocator *allocator, ++ size_t size); ++ ++/* ++ * Reserve chunk of memory of given size in the memory allocator. ++ */ ++long memrar_allocator_free(struct memrar_allocator *allocator, ++ unsigned long handle); ++ ++#endif /* MEMRAR_ALLOCATOR_H */ ++ ++ ++/* ++ Local Variables: ++ c-file-style: "linux" ++ End: ++*/ +Index: linux-2.6.33/drivers/misc/memrar_handler.c +=================================================================== +--- /dev/null ++++ linux-2.6.33/drivers/misc/memrar_handler.c +@@ -0,0 +1,929 @@ ++/* ++ * memrar_handler 1.0: An Intel restricted access region handler device ++ * ++ * Copyright (C) 2009 Intel Corporation. All rights reserved. ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of version 2 of the GNU General ++ * Public License as published by the Free Software Foundation. ++ * ++ * This program is distributed in the hope that it will be ++ * useful, but WITHOUT ANY WARRANTY; without even the implied ++ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR ++ * PURPOSE. See the GNU General Public License for more details. ++ * You should have received a copy of the GNU General Public ++ * License along with this program; if not, write to the Free ++ * Software Foundation, Inc., 59 Temple Place - Suite 330, ++ * Boston, MA 02111-1307, USA. ++ * The full GNU General Public License is included in this ++ * distribution in the file called COPYING. ++ * ++ * ------------------------------------------------------------------- ++ * ++ * Moorestown restricted access regions (RAR) provide isolated ++ * areas of main memory that are only acceessible by authorized ++ * devices. ++ * ++ * The Intel Moorestown RAR handler module exposes a kernel space ++ * RAR memory management mechanism. It is essentially a ++ * RAR-specific allocator. ++ * ++ * Besides providing RAR buffer management, the RAR handler also ++ * behaves in many ways like an OS virtual memory manager. For ++ * example, the RAR "handles" created by the RAR handler are ++ * analogous to user space virtual addresses. ++ * ++ * RAR memory itself is never accessed directly by the RAR ++ * handler. ++ * ++ * ------------------------------------------------------------------- ++ * ++ * TODO ++ * ++ * 1. Split user space interface from core/kernel code, e.g.: ++ * memrar_handler.c -> memrar_core.c, memrar_user.c ++ * ++ * 2. Convert API documentation to Kerneldoc. ++ * ++ * 3. Move memrar_allocator.* to kernel lib' directory since it ++ * is HW neutral. ++ * a. Alternatively, use lib/genalloc.c instead. ++ * b. A kernel port of Doug Lea's malloc() implementation may ++ * also be an option. ++ */ ++ ++#include <linux/miscdevice.h> ++#include <linux/fs.h> ++#include <linux/slab.h> ++#include <linux/kref.h> ++#include <linux/mutex.h> ++#include <linux/kernel.h> ++#include <linux/uaccess.h> ++#include <linux/mm.h> ++#include <linux/ioport.h> ++#include <linux/io.h> ++ ++#include <linux/rar/rar_register.h> ++#include <linux/rar/memrar.h> ++ ++#include "memrar_allocator.h" ++ ++ ++#define MEMRAR_VER "1.0" ++ ++/* ++ * Moorestown supports three restricted access regions. ++ * ++ * We only care about the first two, video and audio. The third, ++ * reserved for Chaabi and the P-unit, will be handled by their ++ * respective drivers. ++ */ ++#define MRST_NUM_RAR 2 ++ ++/* ---------------- -------------------- ------------------- */ ++ ++/* ++ * List structure that keeps track of all RAR buffers. ++ */ ++struct memrar_buffer_info { ++ /* Linked list of memrar_buffer_info objects. */ ++ struct list_head list; ++ ++ /* Core RAR buffer information. */ ++ struct RAR_buffer buffer; ++ ++ /* Reference count */ ++ struct kref refcount; ++ ++ /* ++ * File handle corresponding to process that reserved the ++ * block of memory in RAR. This will be zero for buffers ++ * allocated by other drivers instead of by a user space ++ * process. ++ */ ++ struct file *owner; ++}; ++ ++/* ++ * Structure that describes that characteristics of a given RAR. ++ */ ++struct memrar_rar_info { ++ /* Base bus address of the RAR. */ ++ unsigned long base; ++ ++ /* Length of the RAR. */ ++ unsigned long length; ++ ++ /* Virtual address of RAR mapped into kernel. */ ++ void __iomem *iobase; ++ ++ /* ++ * Allocator associated with the RAR. ++ * ++ * @note The allocator "capacity" may be smaller than the RAR ++ * length if the length is not a multiple of the ++ * configured allocator block size. ++ */ ++ struct memrar_allocator *allocator; ++ ++ /* ++ * Table that keeps track of all reserved RAR buffers. ++ */ ++ struct memrar_buffer_info buffers; ++ ++ /* ++ * Lock used to synchronize access to RAR-specific data ++ * structures. ++ */ ++ struct mutex lock; ++}; ++ ++/* ++ * Array of RAR characteristics. ++ */ ++static struct memrar_rar_info memrars[MRST_NUM_RAR]; ++ ++ ++/* ---------------- -------------------- ------------------- */ ++ ++/* Validate RAR type. */ ++static inline int memrar_is_valid_rar_type(u32 type) ++{ ++ return type == RAR_TYPE_VIDEO || type == RAR_TYPE_AUDIO; ++} ++ ++/* Check if an address/handle falls with the given RAR memory range. */ ++static inline int memrar_handle_in_range(struct memrar_rar_info *rar, ++ u32 vaddr) ++{ ++ unsigned long const iobase = (unsigned long) (rar->iobase); ++ return (vaddr >= iobase && vaddr < iobase + rar->length); ++} ++ ++/* Retrieve RAR information associated with the given handle. */ ++static struct memrar_rar_info *memrar_get_rar_info(u32 vaddr) ++{ ++ int i; ++ for (i = 0; i < MRST_NUM_RAR; ++i) { ++ struct memrar_rar_info * const rar = &memrars[i]; ++ if (memrar_handle_in_range(rar, vaddr)) ++ return rar; ++ } ++ ++ return NULL; ++} ++ ++/* ++ * Retrieve bus address from given handle. ++ * ++ * @return Address corresponding to given handle. Zero if handle ++ * is invalid. ++ */ ++static unsigned long memrar_get_bus_address( ++ struct memrar_rar_info *rar, ++ u32 vaddr) ++{ ++ unsigned long const iobase = (unsigned long) (rar->iobase); ++ ++ if (!memrar_handle_in_range(rar, vaddr)) ++ return 0; ++ ++ /* ++ * An assumption is made that the virtual address offset is ++ * the same as the bus address offset, at least based on the ++ * way this driver is implemented. For example, vaddr + 2 == ++ * baddr + 2. ++ * ++ * @todo Is that a valid assumption? ++ */ ++ return rar->base + (vaddr - iobase); ++} ++ ++/* ++ * Retrieve physical address from given handle. ++ * ++ * @return Address corresponding to given handle. Zero if handle ++ * is invalid. ++ */ ++static unsigned long memrar_get_physical_address( ++ struct memrar_rar_info *rar, ++ u32 vaddr) ++{ ++ /* ++ * @todo This assumes that the bus address and physical ++ * address are the same. That is true for Moorestown ++ * but not necessarily on other platforms. This ++ * deficiency should be addressed at some point. ++ */ ++ return memrar_get_bus_address(rar, vaddr); ++} ++ ++/* ++ * Core block release code. ++ * ++ * @note This code removes the node from a list. Make sure any list ++ * iteration is performed using list_for_each_safe(). ++ */ ++static void memrar_release_block_i(struct kref *ref) ++{ ++ /* ++ * Last reference is being released. Remove from the table, ++ * and reclaim resources. ++ */ ++ ++ struct memrar_buffer_info * const node = ++ container_of(ref, struct memrar_buffer_info, refcount); ++ ++ struct RAR_block_info * const user_info = ++ &node->buffer.info; ++ ++ struct memrar_allocator * const allocator = ++ memrars[user_info->type].allocator; ++ ++ list_del(&node->list); ++ ++ memrar_allocator_free(allocator, user_info->handle); ++ ++ kfree(node); ++} ++ ++/* ++ * Initialize RAR parameters, such as bus addresses, etc. ++ */ ++static int memrar_init_rar_resources(char const *devname) ++{ ++ /* ---- Sanity Checks ---- ++ * 1. RAR bus addresses in both Lincroft and Langwell RAR ++ * registers should be the same. ++ * 2. Secure device ID in Langwell RAR registers should be set ++ * appropriately, i.e. only LPE DMA for the audio RAR, and ++ * security for the other Langwell based RAR register. The ++ * video RAR is not accessed from the Langwell side, ++ * meaning its corresponding Langwell RAR should only be ++ * accessible by the security engine. ++ * 3. Audio and video RAR register and RAR access should be ++ * locked. If not, lock them. Except for debugging ++ * purposes, there is no reason for them to be unlocked. ++ * ++ * @todo Should the RAR handler driver even be aware of audio ++ * and video RAR settings? ++ */ ++ ++ /* ++ * RAR buffer block size. ++ * ++ * We choose it to be the size of a page to simplify the ++ * /dev/memrar mmap() implementation and usage. Otherwise ++ * paging is not involved once an RAR is locked down. ++ */ ++ static size_t const RAR_BLOCK_SIZE = PAGE_SIZE; ++ ++ int z; ++ int found_rar = 0; ++ ++ BUG_ON(MRST_NUM_RAR != ARRAY_SIZE(memrars)); ++ ++ for (z = 0; z != MRST_NUM_RAR; ++z) { ++ u32 low, high; ++ struct memrar_rar_info * const rar = &memrars[z]; ++ ++ BUG_ON(!memrar_is_valid_rar_type(z)); ++ ++ mutex_init(&rar->lock); ++ ++ /* ++ * Initialize the process table before we reach any ++ * code that exit on failure since the finalization ++ * code requires an initialized list. ++ */ ++ INIT_LIST_HEAD(&rar->buffers.list); ++ ++ if (rar_get_address(z, &low, &high) != 0) { ++ /* No RAR is available. */ ++ break; ++ } else if (low == 0 || high == 0) { ++ /* ++ * We don't immediately break out of the loop ++ * since the next type of RAR may be enabled. ++ */ ++ rar->base = 0; ++ rar->length = 0; ++ rar->iobase = NULL; ++ rar->allocator = NULL; ++ continue; ++ } ++ ++ /* ++ * @todo Verify that LNC and LNW RAR register contents ++ * addresses, security, etc are compatible and ++ * consistent). ++ */ ++ ++ rar->length = high - low + 1; ++ ++ /* Claim RAR memory as our own. */ ++ if (request_mem_region(low, rar->length, devname) == NULL) { ++ rar->length = 0; ++ ++ pr_err("%s: Unable to claim RAR[%d] memory.\n", ++ devname, ++ z); ++ pr_err("%s: RAR[%d] disabled.\n", devname, z); ++ ++ /* ++ * Rather than break out of the loop by ++ * returning -EBUSY, for example, we may be ++ * able to claim memory of the next RAR region ++ * as our own. ++ */ ++ continue; ++ } ++ ++ rar->base = low; ++ ++ /* ++ * Now map it into the kernel address space. ++ * ++ * Note that the RAR memory may only be accessed by IA ++ * when debugging. Otherwise attempts to access the ++ * RAR memory when it is locked down will result in ++ * behavior similar to writing to /dev/null and ++ * reading from /dev/zero. This behavior is enforced ++ * by the hardware. Even if we don't access the ++ * memory, mapping it into the kernel provides us with ++ * a convenient RAR handle to physical address mapping. ++ */ ++ rar->iobase = ioremap_nocache(rar->base, rar->length); ++ if (rar->iobase == NULL) { ++ pr_err("%s: Unable to map RAR memory.\n", ++ devname); ++ return -ENOMEM; ++ } ++ ++ /* Initialize corresponding memory allocator. */ ++ rar->allocator = memrar_create_allocator( ++ (unsigned long) rar->iobase, ++ rar->length, ++ RAR_BLOCK_SIZE); ++ if (rar->allocator == NULL) ++ return -1; ++ ++ /* ++ * ------------------------------------------------- ++ * Make sure all RARs handled by us are locked down. ++ * ------------------------------------------------- ++ */ ++ ++ /* Enable RAR protection on the Lincroft side. */ ++ if (0) { ++ /* @todo Enable once LNW A2 is widely available. */ ++ rar_lock(z); ++ } else { ++ pr_warning("%s: LNC RAR[%d] no lock sanity check.\n", ++ devname, ++ z); ++ } ++ ++ /* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ */ ++ /* |||||||||||||||||||||||||||||||||||||||||||||||||| */ ++ ++ /* ++ * Enable RAR protection on the Langwell side. ++ * ++ * Ideally Langwell side RAR protection should already ++ * have been enabled by the OEM in the SMIP header but ++ * we perform a sanity check, just in case. ++ * ++ * @todo Set appropriate "lock"/"valid" bits in LNW ++ * {LOW,UP}RAR[12] SCCB registers **and** LNW ++ * {LOW,UP}RAR[01] cDMI registers only if a ++ * suitable SDID (i.e. for security or LPE DMA) ++ * is set. ++ */ ++ pr_warning("%s: LNW RAR[%d] no lock sanity check.\n", ++ devname, ++ z); ++ ++ ++ pr_info("%s: BRAR[%d]\n" ++ "\tlow address: 0x%x\n" ++ "\thigh address: 0x%x\n" ++ "\tsize : %u KiB\n", ++ devname, ++ z, ++ low, ++ high, ++ rar->allocator->capacity / 1024); ++ ++ found_rar = 1; ++ } ++ ++ if (!found_rar) { ++ /* ++ * No RAR support. Don't bother continuing. ++ * ++ * Note that this is not a failure. ++ */ ++ pr_info("%s: No Moorestown RAR support available.\n", ++ devname); ++ return -ENODEV; ++ } ++ ++ return 0; ++} ++ ++/* ++ * Finalize RAR resources. ++ */ ++static void memrar_fini_rar_resources(void) ++{ ++ int z; ++ struct memrar_buffer_info *pos; ++ struct memrar_buffer_info *tmp; ++ ++ /* ++ * @todo Do we need to hold a lock at this point in time? ++ * (module initialization failure or exit?) ++ */ ++ ++ for (z = MRST_NUM_RAR; z-- != 0; ) { ++ struct memrar_rar_info * const rar = &memrars[z]; ++ ++ /* Clean up remaining resources. */ ++ ++ list_for_each_entry_safe(pos, ++ tmp, ++ &rar->buffers.list, ++ list) { ++ kref_put(&pos->refcount, memrar_release_block_i); ++ } ++ ++ memrar_destroy_allocator(rar->allocator); ++ rar->allocator = NULL; ++ ++ iounmap(rar->iobase); ++ rar->iobase = NULL; ++ ++ release_mem_region(rar->base, rar->length); ++ rar->base = 0; ++ ++ rar->length = 0; ++ } ++} ++ ++static long memrar_reserve_block(struct RAR_buffer *request, ++ struct file *filp) ++{ ++ struct RAR_block_info * const rinfo = &request->info; ++ struct RAR_buffer *buffer; ++ struct memrar_buffer_info *buffer_info; ++ u32 handle; ++ struct memrar_rar_info *rar = NULL; ++ ++ /* Prevent array overflow. */ ++ if (!memrar_is_valid_rar_type(rinfo->type)) ++ return -EINVAL; ++ ++ rar = &memrars[rinfo->type]; ++ ++ /* Reserve memory in RAR. */ ++ handle = memrar_allocator_alloc(rar->allocator, rinfo->size); ++ if (handle == 0) ++ return -ENOMEM; ++ ++ buffer_info = kmalloc(sizeof(*buffer_info), GFP_KERNEL); ++ ++ if (buffer_info == NULL) { ++ memrar_allocator_free(rar->allocator, handle); ++ return -ENOMEM; ++ } ++ ++ buffer = &buffer_info->buffer; ++ buffer->info.type = rinfo->type; ++ buffer->info.size = rinfo->size; ++ ++ /* Memory handle corresponding to the bus address. */ ++ buffer->info.handle = handle; ++ buffer->bus_address = memrar_get_bus_address(rar, handle); ++ ++ /* ++ * Keep track of owner so that we can later cleanup if ++ * necessary. ++ */ ++ buffer_info->owner = filp; ++ ++ kref_init(&buffer_info->refcount); ++ ++ mutex_lock(&rar->lock); ++ list_add(&buffer_info->list, &rar->buffers.list); ++ mutex_unlock(&rar->lock); ++ ++ rinfo->handle = buffer->info.handle; ++ request->bus_address = buffer->bus_address; ++ ++ return 0; ++} ++ ++static long memrar_release_block(u32 addr) ++{ ++ struct memrar_buffer_info *pos; ++ struct memrar_buffer_info *tmp; ++ struct memrar_rar_info * const rar = memrar_get_rar_info(addr); ++ long result = -EINVAL; ++ ++ if (rar == NULL) ++ return -EFAULT; ++ ++ mutex_lock(&rar->lock); ++ ++ /* ++ * Iterate through the buffer list to find the corresponding ++ * buffer to be released. ++ */ ++ list_for_each_entry_safe(pos, ++ tmp, ++ &rar->buffers.list, ++ list) { ++ if (addr == pos->buffer.info.handle ++ && memrar_is_valid_rar_type(pos->buffer.info.type)) { ++ kref_put(&pos->refcount, memrar_release_block_i); ++ result = 0; ++ break; ++ } ++ } ++ ++ mutex_unlock(&rar->lock); ++ ++ return result; ++} ++ ++static long memrar_get_stat(struct RAR_stat *r) ++{ ++ long result = -EINVAL; ++ ++ if (likely(r != NULL) && memrar_is_valid_rar_type(r->type)) { ++ struct memrar_allocator * const allocator = ++ memrars[r->type].allocator; ++ ++ BUG_ON(allocator == NULL); ++ ++ /* ++ * Allocator capacity doesn't change over time. No ++ * need to synchronize. ++ */ ++ r->capacity = allocator->capacity; ++ ++ mutex_lock(&allocator->lock); ++ ++ r->largest_block_size = allocator->largest_free_area; ++ ++ mutex_unlock(&allocator->lock); ++ ++ result = 0; ++ } ++ ++ return result; ++} ++ ++static long memrar_ioctl(struct file *filp, ++ unsigned int cmd, ++ unsigned long arg) ++{ ++ void __user *argp = (void __user *)arg; ++ long result = 0; ++ ++ struct RAR_buffer buffer; ++ struct RAR_block_info * const request = &buffer.info; ++ struct RAR_stat rar_info; ++ u32 rar_handle; ++ ++ switch (cmd) { ++ case RAR_HANDLER_RESERVE: ++ if (copy_from_user(request, ++ argp, ++ sizeof(*request))) ++ return -EFAULT; ++ ++ result = memrar_reserve_block(&buffer, filp); ++ if (result != 0) ++ return result; ++ ++ return copy_to_user(argp, request, sizeof(*request)); ++ ++ case RAR_HANDLER_RELEASE: ++ if (copy_from_user(&rar_handle, ++ argp, ++ sizeof(rar_handle))) ++ return -EFAULT; ++ ++ return memrar_release_block(rar_handle); ++ ++ case RAR_HANDLER_STAT: ++ if (copy_from_user(&rar_info, ++ argp, ++ sizeof(rar_info))) ++ return -EFAULT; ++ ++ /* ++ * Populate the RAR_stat structure based on the RAR ++ * type given by the user ++ */ ++ if (memrar_get_stat(&rar_info) != 0) ++ return -EINVAL; ++ ++ /* ++ * @todo Do we need to verify destination pointer ++ * "argp" is non-zero? Is that already done by ++ * copy_to_user()? ++ */ ++ return copy_to_user(argp, ++ &rar_info, ++ sizeof(rar_info)) ? -EFAULT : 0; ++ ++ default: ++ return -ENOTTY; ++ } ++ ++ return 0; ++} ++ ++static int memrar_mmap(struct file *filp, struct vm_area_struct *vma) ++{ ++ size_t const size = vma->vm_end - vma->vm_start; ++ ++ /* Users pass the RAR handle as the mmap() offset parameter. */ ++ unsigned long const handle = vma->vm_pgoff << PAGE_SHIFT; ++ ++ struct memrar_rar_info * const rar = memrar_get_rar_info(handle); ++ ++ unsigned long pfn; ++ ++ /* Invalid RAR handle or size passed to mmap(). */ ++ if (rar == NULL ++ || handle == 0 ++ || size > (handle - (unsigned long) rar->iobase)) ++ return -EINVAL; ++ ++ /* ++ * Retrieve physical address corresponding to the RAR handle, ++ * and convert it to a page frame. ++ */ ++ pfn = memrar_get_physical_address(rar, handle) >> PAGE_SHIFT; ++ ++ ++ pr_debug("memrar: mapping RAR range [0x%lx, 0x%lx) into user space.\n", ++ handle, ++ handle + size); ++ ++ /* ++ * Map RAR memory into user space. This is really only useful ++ * for debugging purposes since the memory won't be ++ * accesssible, i.e. reads return zero and writes are ignired, ++ * when it is locked down. ++ */ ++ if (remap_pfn_range(vma, ++ vma->vm_start, ++ pfn, ++ size, ++ vma->vm_page_prot)) ++ return -EAGAIN; ++ ++ /* vma->vm_ops = &memrar_mem_ops; */ ++ ++ return 0; ++} ++ ++static int memrar_open(struct inode *inode, struct file *filp) ++{ ++ /* Nothing to do yet. */ ++ ++ return 0; ++} ++ ++static int memrar_release(struct inode *inode, struct file *filp) ++{ ++ /* Free all regions associated with the given file handle. */ ++ ++ struct memrar_buffer_info *pos; ++ struct memrar_buffer_info *tmp; ++ int z; ++ ++ for (z = 0; z != MRST_NUM_RAR; ++z) { ++ struct memrar_rar_info * const rar = &memrars[z]; ++ ++ mutex_lock(&rar->lock); ++ ++ list_for_each_entry_safe(pos, ++ tmp, ++ &rar->buffers.list, ++ list) { ++ if (filp == pos->owner) ++ kref_put(&pos->refcount, ++ memrar_release_block_i); ++ } ++ ++ mutex_unlock(&rar->lock); ++ } ++ ++ return 0; ++} ++ ++/* ++ * @note This function is part of the kernel space memrar driver API. ++ */ ++size_t rar_reserve(struct RAR_buffer *buffers, size_t count) ++{ ++ struct RAR_buffer * const end = ++ (buffers == NULL ? buffers : buffers + count); ++ struct RAR_buffer *i; ++ ++ size_t reserve_count = 0; ++ ++ for (i = buffers; i != end; ++i) { ++ if (memrar_reserve_block(i, NULL) == 0) ++ ++reserve_count; ++ else ++ i->bus_address = 0; ++ } ++ ++ return reserve_count; ++} ++EXPORT_SYMBOL(rar_reserve); ++ ++/* ++ * @note This function is part of the kernel space memrar driver API. ++ */ ++size_t rar_release(struct RAR_buffer *buffers, size_t count) ++{ ++ struct RAR_buffer * const end = ++ (buffers == NULL ? buffers : buffers + count); ++ struct RAR_buffer *i; ++ ++ size_t release_count = 0; ++ ++ for (i = buffers; i != end; ++i) { ++ u32 * const handle = &i->info.handle; ++ if (memrar_release_block(*handle) == 0) { ++ /* ++ * @todo We assume we should do this each time ++ * the ref count is decremented. Should ++ * we instead only do this when the ref ++ * count has dropped to zero, and the ++ * buffer has been completely ++ * released/unmapped? ++ */ ++ *handle = 0; ++ ++release_count; ++ } ++ } ++ ++ return release_count; ++} ++EXPORT_SYMBOL(rar_release); ++ ++/* ++ * @note This function is part of the kernel space driver API. ++ */ ++size_t rar_handle_to_bus(struct RAR_buffer *buffers, size_t count) ++{ ++ struct RAR_buffer * const end = ++ (buffers == NULL ? buffers : buffers + count); ++ struct RAR_buffer *i; ++ struct memrar_buffer_info *pos; ++ ++ size_t conversion_count = 0; ++ ++ /* ++ * Find all bus addresses corresponding to the given handles. ++ * ++ * @todo Not liking this nested loop. Optimize. ++ */ ++ for (i = buffers; i != end; ++i) { ++ struct memrar_rar_info * const rar = ++ memrar_get_rar_info(i->info.handle); ++ ++ /* ++ * Check if we have a bogus handle, and then continue ++ * with remaining buffers. ++ */ ++ if (rar == NULL) { ++ i->bus_address = 0; ++ continue; ++ } ++ ++ mutex_lock(&rar->lock); ++ ++ list_for_each_entry(pos, &rar->buffers.list, list) { ++ struct RAR_block_info * const user_info = ++ &pos->buffer.info; ++ ++ if (i->info.handle >= user_info->handle ++ && i->info.handle < (user_info->handle ++ + user_info->size)) { ++ u32 const offset = ++ i->info.handle - user_info->handle; ++ ++ i->info.type = user_info->type; ++ i->info.size = user_info->size - offset; ++ i->bus_address = ++ pos->buffer.bus_address ++ + offset; ++ ++ /* Increment the reference count. */ ++ kref_get(&pos->refcount); ++ ++ ++conversion_count; ++ break; ++ } else { ++ i->bus_address = 0; ++ } ++ } ++ ++ mutex_unlock(&rar->lock); ++ } ++ ++ return conversion_count; ++} ++EXPORT_SYMBOL(rar_handle_to_bus); ++ ++static const struct file_operations memrar_fops = { ++ .owner = THIS_MODULE, ++ .unlocked_ioctl = memrar_ioctl, ++ .mmap = memrar_mmap, ++ .open = memrar_open, ++ .release = memrar_release, ++}; ++ ++static struct miscdevice memrar_miscdev = { ++ .minor = MISC_DYNAMIC_MINOR, /* dynamic allocation */ ++ .name = "memrar", /* /dev/memrar */ ++ .fops = &memrar_fops ++}; ++ ++static char const banner[] __initdata = ++ KERN_INFO ++ "Intel RAR Handler: " MEMRAR_VER " initialized.\n"; ++ ++static int __init memrar_init(void) ++{ ++ int result = 0; ++ ++ printk(banner); ++ ++ /* ++ * We initialize the RAR parameters early on so that we can ++ * discontinue memrar device initialization and registration ++ * if suitably configured RARs are not available. ++ */ ++ result = memrar_init_rar_resources(memrar_miscdev.name); ++ ++ if (result != 0) ++ return result; ++ ++ result = misc_register(&memrar_miscdev); ++ ++ if (result != 0) { ++ pr_err("%s: misc_register() failed.\n", ++ memrar_miscdev.name); ++ ++ /* Clean up resources previously reserved. */ ++ memrar_fini_rar_resources(); ++ } ++ ++ return result; ++} ++ ++static void __exit memrar_exit(void) ++{ ++ memrar_fini_rar_resources(); ++ ++ misc_deregister(&memrar_miscdev); ++} ++ ++#ifndef MODULE ++/* ++ * The RAR handler must be initialized after the RAR register driver. ++ * Otherwise the RAR handler will always assume no RAR support ++ * exists. ++ */ ++late_initcall_sync(memrar_init); ++#else ++module_init(memrar_init); ++#endif /* MODULE */ ++ ++module_exit(memrar_exit); ++ ++ ++MODULE_AUTHOR("Ossama Othman <ossama.othman@intel.com>"); ++MODULE_DESCRIPTION("Intel Restricted Access Region Handler"); ++MODULE_LICENSE("GPL"); ++MODULE_ALIAS_MISCDEV(MISC_DYNAMIC_MINOR); ++MODULE_VERSION(MEMRAR_VER); ++ ++ ++ ++/* ++ Local Variables: ++ c-file-style: "linux" ++ End: ++*/ +Index: linux-2.6.33/drivers/staging/rar/Kconfig +=================================================================== +--- linux-2.6.33.orig/drivers/staging/rar/Kconfig ++++ linux-2.6.33/drivers/staging/rar/Kconfig +@@ -6,7 +6,7 @@ menu "RAR Register Driver" + # + # Restricted Access Register Manager + # +-config RAR_REGISTER ++config RAR_DRIVER + tristate "Restricted Access Region Register Driver" + default n + ---help--- +Index: linux-2.6.33/drivers/staging/rar/Makefile +=================================================================== +--- linux-2.6.33.orig/drivers/staging/rar/Makefile ++++ linux-2.6.33/drivers/staging/rar/Makefile +@@ -1,2 +1,2 @@ + EXTRA_CFLAGS += -DLITTLE__ENDIAN +-obj-$(CONFIG_RAR_REGISTER) += rar_driver.o ++obj-$(CONFIG_RAR_DRIVER) += rar_driver.o |