Merge branch 'for-linus' of git://git.infradead.org/users/sameo/mfd-2.6
[linux-btrfs-devel.git] / drivers / platform / x86 / intel_rar_register.c
blobc8a6aed452778d489a53bb9a60c2a9af2ec72470
1 /*
2 * rar_register.c - An Intel Restricted Access Region register driver
4 * Copyright(c) 2009 Intel Corporation. All rights reserved.
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.
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.
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.
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
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.
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.
39 * 20090626 Mark Allyn <mark.a.allyn@intel.com>
40 * Initial publish
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>
50 /* === Lincroft Message Bus Interface === */
51 #define LNC_MCR_OFFSET 0xD0 /* Message Control Register */
52 #define LNC_MDR_OFFSET 0xD4 /* Message Data Register */
54 /* Message Opcodes */
55 #define LNC_MESSAGE_READ_OPCODE 0xD0
56 #define LNC_MESSAGE_WRITE_OPCODE 0xE0
58 /* Message Write Byte Enables */
59 #define LNC_MESSAGE_BYTE_WRITE_ENABLES 0xF
61 /* B-unit Port */
62 #define LNC_BUNIT_PORT 0x3
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
73 /* Moorestown supports three restricted access regions. */
74 #define MRST_NUM_RAR 3
76 /* RAR Bus Address Range */
77 struct rar_addr {
78 dma_addr_t low;
79 dma_addr_t high;
83 * We create one of these for each RAR
85 struct client {
86 int (*callback)(unsigned long data);
87 unsigned long driver_priv;
88 bool busy;
91 static DEFINE_MUTEX(rar_mutex);
92 static DEFINE_MUTEX(lnc_reg_mutex);
95 * One per RAR device (currently only one device)
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];
105 /* Current platforms have only one rar_device for 3 rar regions */
106 static struct rar_device my_rar_device;
109 * Abstract out multiple device support. Current platforms only
110 * have a single RAR device.
114 * alloc_rar_device - return a new RAR structure
116 * Return a new (but not yet ready) RAR device object
118 static struct rar_device *alloc_rar_device(void)
120 if (my_rar_device.allocated)
121 return NULL;
122 my_rar_device.allocated = 1;
123 return &my_rar_device;
127 * free_rar_device - free a RAR object
128 * @rar: the RAR device being freed
130 * Release a RAR object and any attached resources
132 static void free_rar_device(struct rar_device *rar)
134 pci_dev_put(rar->rar_dev);
135 rar->allocated = 0;
139 * _rar_to_device - return the device handling this RAR
140 * @rar: RAR number
141 * @off: returned offset
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.
146 static struct rar_device *_rar_to_device(int rar, int *off)
148 if (rar >= 0 && rar < MRST_NUM_RAR) {
149 *off = rar;
150 return &my_rar_device;
152 return NULL;
156 * rar_to_device - return the device handling this RAR
157 * @rar: RAR number
158 * @off: returned offset
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.
164 static struct rar_device *rar_to_device(int rar, int *off)
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;
173 * rar_to_client - return the client handling this RAR
174 * @rar: RAR number
176 * Return the client this RAR maps to if a mapping is known, otherwise
177 * returns NULL.
179 static struct client *rar_to_client(int rar)
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;
189 * rar_read_addr - retrieve a RAR mapping
190 * @pdev: PCI device for the RAR
191 * @offset: offset for message
192 * @addr: returned address
194 * Reads the address of a given RAR register. Returns 0 on success
195 * or an error code on failure.
197 static int rar_read_addr(struct pci_dev *pdev, int offset, dma_addr_t *addr)
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).
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
215 * Read (0xD0) and write (0xE0) opcodes are written to the
216 * control register when reading and writing to Lincroft
217 * registers, respectively.
219 * We're interested in registers found in the Lincroft
220 * B-unit. The B-unit port is 0x3.
222 * The six B-unit RAR register offsets we use are listed
223 * earlier in this file.
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.
229 * The MDR (message data register) format is the following:
230 * 1. [31:0]: Read/Write Data
232 * Data being read from this register is only available after
233 * writing the appropriate control message to the MCR
234 * register.
236 * Data being written to this register must be written before
237 * writing the appropriate control message to the MCR
238 * register.
241 int result;
242 u32 addr32;
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);
251 dev_dbg(&pdev->dev, "Offset for 'get' LNC MSG is %x\n", offset);
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.
261 mutex_lock(&lnc_reg_mutex);
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;
270 mutex_unlock(&lnc_reg_mutex);
271 return result;
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
280 * Sets the address of a given RAR register. Returns 0 on success
281 * or an error code on failure.
283 static int rar_set_addr(struct pci_dev *pdev,
284 int offset,
285 dma_addr_t addr)
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.
295 int result;
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);
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.
311 mutex_lock(&lnc_reg_mutex);
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);
319 mutex_unlock(&lnc_reg_mutex);
320 return result;
324 * rar_init_params - Initialize RAR parameters
325 * @rar: RAR device to initialise
327 * Initialize RAR parameters, such as bus addresses, etc. Returns 0
328 * on success, or an error code on failure.
330 static int init_rar_params(struct rar_device *rar)
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/... */
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.
342 for (i = 0; i < MRST_NUM_RAR; ++i) {
343 struct rar_addr *addr = &rar->rar_addr[i];
345 result = rar_read_addr(pdev, offset++, &addr->low);
346 if (result != 0)
347 return result;
349 result = rar_read_addr(pdev, offset++, &addr->high);
350 if (result != 0)
351 return result;
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.
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
365 addr->low &= (dma_addr_t)0xfffffc00u;
368 * Set bits 9:0 on uppser address if bits 31:10 are non
369 * zero; otherwize clear all bits
372 if ((addr->high & 0xfffffc00u) == 0)
373 addr->high = 0;
374 else
375 addr->high |= 0x3ffu;
377 /* Done accessing the device. */
379 if (result == 0) {
380 for (i = 0; i != MRST_NUM_RAR; ++i) {
382 * "BRAR" refers to the RAR registers in the
383 * Lincroft B-unit.
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);
391 return result;
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
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:
403 * The function returns a 0 upon success or an error if there is no RAR
404 * facility on this system.
406 int rar_get_address(int rar_index, dma_addr_t *start, dma_addr_t *end)
408 int idx;
409 struct rar_device *rar = rar_to_device(rar_index, &idx);
411 if (rar == NULL) {
412 WARN_ON(1);
413 return -ENODEV;
416 *start = rar->rar_addr[idx].low;
417 *end = rar->rar_addr[idx].high;
418 return 0;
420 EXPORT_SYMBOL(rar_get_address);
423 * rar_lock - lock a RAR register
424 * @rar_index: RAR to lock (0-2)
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.
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
432 int rar_lock(int rar_index)
434 struct rar_device *rar;
435 int result;
436 int idx;
437 dma_addr_t low, high;
439 rar = rar_to_device(rar_index, &idx);
441 if (rar == NULL) {
442 WARN_ON(1);
443 return -EINVAL;
446 low = rar->rar_addr[idx].low & 0xfffffc00u;
447 high = rar->rar_addr[idx].high & 0xfffffc00u;
450 * Only allow I/O from the graphics and Langwell;
451 * not from the x86 processor
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;
466 * Now program the register using the Lincroft message
467 * bus interface.
469 result = rar_set_addr(rar->rar_dev,
470 2 * idx, low);
472 if (result == 0)
473 result = rar_set_addr(rar->rar_dev,
474 2 * idx + 1, high);
476 return result;
478 EXPORT_SYMBOL(rar_lock);
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
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()
495 * This function return 0 on success or an error code on failure.
497 int register_rar(int num, int (*callback)(unsigned long data),
498 unsigned long data)
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;
506 mutex_lock(&rar_mutex);
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;
514 /* Is it claimed ? */
515 if (c->busy) {
516 retval = -EBUSY;
517 goto done;
519 c->busy = 1;
521 /* See if we have a handler for this RAR yet, if we do then fire it */
522 rar = rar_to_device(num, &idx);
524 if (rar) {
526 * if the driver already registered, then we can simply
527 * call the callback right now
529 (*callback)(data);
530 goto done;
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;
540 EXPORT_SYMBOL(register_rar);
543 * unregister_rar - release a RAR allocation
544 * @num: RAR number
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.
551 void unregister_rar(int num)
553 struct client *c;
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);
563 EXPORT_SYMBOL(unregister_rar);
566 * rar_callback - Process callbacks
567 * @rar: new RAR device
569 * Process the callbacks for a newly found RAR device.
572 static void rar_callback(struct rar_device *rar)
574 struct client *c = &rar->client[0];
575 int i;
577 mutex_lock(&rar_mutex);
579 rar->registered = 1; /* Ensure no more callbacks queue */
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;
586 c++;
588 mutex_unlock(&rar_mutex);
592 * rar_probe - PCI probe callback
593 * @dev: PCI device
594 * @id: matching entry in the match table
596 * A RAR device has been discovered. Initialise it and if successful
597 * process any pending callbacks that can now be completed.
599 static int rar_probe(struct pci_dev *dev, const struct pci_device_id *id)
601 int error;
602 struct rar_device *rar;
604 dev_dbg(&dev->dev, "PCI probe starting\n");
606 rar = alloc_rar_device();
607 if (rar == NULL)
608 return -EBUSY;
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;
618 /* Fill in the rar_device structure */
619 rar->rar_dev = pci_dev_get(dev);
620 pci_set_drvdata(dev, rar);
623 * Initialize the RAR parameters, which have to be retrieved
624 * via the message bus interface.
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;
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;
640 static DEFINE_PCI_DEVICE_TABLE(rar_pci_id_tbl) = {
641 { PCI_VDEVICE(INTEL, 0x4110) },
642 { 0 }
645 MODULE_DEVICE_TABLE(pci, rar_pci_id_tbl);
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 */
655 static int __init rar_init_handler(void)
657 return pci_register_driver(&rar_pci_driver);
660 static void __exit rar_exit_handler(void)
662 pci_unregister_driver(&rar_pci_driver);
665 module_init(rar_init_handler);
666 module_exit(rar_exit_handler);
668 MODULE_LICENSE("GPL");
669 MODULE_DESCRIPTION("Intel Restricted Access Region Register Driver");