2 * Compaq Hot Plug Controller Driver
4 * Copyright (C) 1995,2001 Compaq Computer Corporation
5 * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
6 * Copyright (C) 2001 IBM Corp.
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or (at
13 * your option) any later version.
15 * This program is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
18 * NON INFRINGEMENT. See the GNU General Public License for more
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 * Send feedback to <greg@kroah.com>
29 #include <linux/module.h>
30 #include <linux/kernel.h>
31 #include <linux/types.h>
32 #include <linux/proc_fs.h>
33 #include <linux/slab.h>
34 #include <linux/workqueue.h>
35 #include <linux/pci.h>
36 #include <linux/pci_hotplug.h>
37 #include <asm/uaccess.h>
39 #include "cpqphp_nvram.h"
42 #define ROM_INT15_PHY_ADDR 0x0FF859
43 #define READ_EV 0xD8A4
44 #define WRITE_EV 0xD8A5
48 unsigned long lword; /* eax */
49 unsigned short word; /* ax */
52 unsigned char low; /* al */
53 unsigned char high; /* ah */
57 unsigned char opcode; /* see below */
58 unsigned long length; /* if the reg. is a pointer, how much data */
59 } __attribute__ ((packed));
62 struct register_foo eax_reg;
63 struct register_foo ebx_reg;
64 struct register_foo ecx_reg;
65 struct register_foo edx_reg;
66 struct register_foo edi_reg;
67 struct register_foo esi_reg;
68 struct register_foo eflags_reg;
69 } __attribute__ ((packed));
72 struct ev_hrt_header {
90 static u8 evbuffer_init;
91 static u8 evbuffer_length;
92 static u8 evbuffer[1024];
94 static void __iomem *compaq_int15_entry_point;
96 /* lock for ordering int15_bios_call() */
97 static spinlock_t int15_lock;
100 /* This is a series of function that deals with
101 * setting & getting the hotplug resource table in some environment variable.
105 * We really shouldn't be doing this unless there is a _very_ good reason to!!!
110 static u32 add_byte(u32 **p_buffer, u8 value, u32 *used, u32 *avail)
114 if ((*used + 1) > *avail)
117 *((u8*)*p_buffer) = value;
118 tByte = (u8**)p_buffer;
125 static u32 add_dword(u32 **p_buffer, u32 value, u32 *used, u32 *avail)
127 if ((*used + 4) > *avail)
138 * check_for_compaq_ROM
140 * this routine verifies that the ROM OEM string is 'COMPAQ'
142 * returns 0 for non-Compaq ROM, 1 for Compaq ROM
144 static int check_for_compaq_ROM (void __iomem *rom_start)
146 u8 temp1, temp2, temp3, temp4, temp5, temp6;
149 temp1 = readb(rom_start + 0xffea + 0);
150 temp2 = readb(rom_start + 0xffea + 1);
151 temp3 = readb(rom_start + 0xffea + 2);
152 temp4 = readb(rom_start + 0xffea + 3);
153 temp5 = readb(rom_start + 0xffea + 4);
154 temp6 = readb(rom_start + 0xffea + 5);
155 if ((temp1 == 'C') &&
163 dbg ("%s - returned %d\n", __func__, result);
168 static u32 access_EV (u16 operation, u8 *ev_name, u8 *buffer, u32 *buf_size)
174 if (!compaq_int15_entry_point)
177 spin_lock_irqsave(&int15_lock, flags);
179 "xorl %%ebx,%%ebx\n" \
180 "xorl %%edx,%%edx\n" \
185 : "=c" (*buf_size), "=a" (ret_val)
186 : "a" (op), "c" (*buf_size), "S" (ev_name),
187 "D" (buffer), "m" (compaq_int15_entry_point)
189 spin_unlock_irqrestore(&int15_lock, flags);
191 return((ret_val & 0xFF00) >> 8);
198 * Read the hot plug Resource Table from NVRAM
200 static int load_HRT (void __iomem *rom_start)
207 if (!check_for_compaq_ROM(rom_start)) {
213 /* Now load the EV */
214 temp_dword = available;
216 rc = access_EV(READ_EV, "CQTHPS", evbuffer, &temp_dword);
218 evbuffer_length = temp_dword;
220 /* We're maintaining the resource lists so write FF to invalidate old
225 rc = access_EV(WRITE_EV, "CQTHPS", &temp_byte, &temp_dword);
234 * Save the hot plug Resource Table in NVRAM
236 static u32 store_HRT (void __iomem *rom_start)
246 struct controller *ctrl;
247 struct pci_resource *resNode;
248 struct ev_hrt_header *p_EV_header;
249 struct ev_hrt_ctrl *p_ev_ctrl;
253 if (!check_for_compaq_ROM(rom_start)) {
257 buffer = (u32*) evbuffer;
265 p_EV_header = (struct ev_hrt_header *) pFill;
267 ctrl = cpqhp_ctrl_list;
269 /* The revision of this structure */
270 rc = add_byte(&pFill, 1 + ctrl->push_flag, &usedbytes, &available);
274 /* The number of controllers */
275 rc = add_byte(&pFill, 1, &usedbytes, &available);
280 p_ev_ctrl = (struct ev_hrt_ctrl *) pFill;
285 rc = add_byte(&pFill, ctrl->bus, &usedbytes, &available);
289 /* The device Number */
290 rc = add_byte(&pFill, PCI_SLOT(ctrl->pci_dev->devfn), &usedbytes, &available);
294 /* The function Number */
295 rc = add_byte(&pFill, PCI_FUNC(ctrl->pci_dev->devfn), &usedbytes, &available);
299 /* Skip the number of available entries */
300 rc = add_dword(&pFill, 0, &usedbytes, &available);
304 /* Figure out memory Available */
306 resNode = ctrl->mem_head;
314 rc = add_dword(&pFill, resNode->base, &usedbytes, &available);
319 rc = add_dword(&pFill, resNode->length, &usedbytes, &available);
323 resNode = resNode->next;
326 /* Fill in the number of entries */
327 p_ev_ctrl->mem_avail = loop;
329 /* Figure out prefetchable memory Available */
331 resNode = ctrl->p_mem_head;
339 rc = add_dword(&pFill, resNode->base, &usedbytes, &available);
344 rc = add_dword(&pFill, resNode->length, &usedbytes, &available);
348 resNode = resNode->next;
351 /* Fill in the number of entries */
352 p_ev_ctrl->p_mem_avail = loop;
354 /* Figure out IO Available */
356 resNode = ctrl->io_head;
364 rc = add_dword(&pFill, resNode->base, &usedbytes, &available);
369 rc = add_dword(&pFill, resNode->length, &usedbytes, &available);
373 resNode = resNode->next;
376 /* Fill in the number of entries */
377 p_ev_ctrl->io_avail = loop;
379 /* Figure out bus Available */
381 resNode = ctrl->bus_head;
389 rc = add_dword(&pFill, resNode->base, &usedbytes, &available);
394 rc = add_dword(&pFill, resNode->length, &usedbytes, &available);
398 resNode = resNode->next;
401 /* Fill in the number of entries */
402 p_ev_ctrl->bus_avail = loop;
407 p_EV_header->num_of_ctrl = numCtrl;
409 /* Now store the EV */
411 temp_dword = usedbytes;
413 rc = access_EV(WRITE_EV, "CQTHPS", (u8*) buffer, &temp_dword);
415 dbg("usedbytes = 0x%x, length = 0x%x\n", usedbytes, temp_dword);
417 evbuffer_length = temp_dword;
420 err(msg_unable_to_save);
428 void compaq_nvram_init (void __iomem *rom_start)
431 compaq_int15_entry_point = (rom_start + ROM_INT15_PHY_ADDR - ROM_PHY_ADDR);
433 dbg("int15 entry = %p\n", compaq_int15_entry_point);
435 /* initialize our int15 lock */
436 spin_lock_init(&int15_lock);
440 int compaq_nvram_load (void __iomem *rom_start, struct controller *ctrl)
442 u8 bus, device, function;
443 u8 nummem, numpmem, numio, numbus;
446 struct pci_resource *mem_node;
447 struct pci_resource *p_mem_node;
448 struct pci_resource *io_node;
449 struct pci_resource *bus_node;
450 struct ev_hrt_ctrl *p_ev_ctrl;
451 struct ev_hrt_header *p_EV_header;
453 if (!evbuffer_init) {
454 /* Read the resource list information in from NVRAM */
455 if (load_HRT(rom_start))
456 memset (evbuffer, 0, 1024);
461 /* If we saved information in NVRAM, use it now */
462 p_EV_header = (struct ev_hrt_header *) evbuffer;
464 /* The following code is for systems where version 1.0 of this
465 * driver has been loaded, but doesn't support the hardware.
466 * In that case, the driver would incorrectly store something
469 if ((p_EV_header->Version == 2) ||
470 ((p_EV_header->Version == 1) && !ctrl->push_flag)) {
471 p_byte = &(p_EV_header->next);
473 p_ev_ctrl = (struct ev_hrt_ctrl *) &(p_EV_header->next);
477 if (p_byte > ((u8*)p_EV_header + evbuffer_length))
480 bus = p_ev_ctrl->bus;
481 device = p_ev_ctrl->device;
482 function = p_ev_ctrl->function;
484 while ((bus != ctrl->bus) ||
485 (device != PCI_SLOT(ctrl->pci_dev->devfn)) ||
486 (function != PCI_FUNC(ctrl->pci_dev->devfn))) {
487 nummem = p_ev_ctrl->mem_avail;
488 numpmem = p_ev_ctrl->p_mem_avail;
489 numio = p_ev_ctrl->io_avail;
490 numbus = p_ev_ctrl->bus_avail;
494 if (p_byte > ((u8*)p_EV_header + evbuffer_length))
497 /* Skip forward to the next entry */
498 p_byte += (nummem + numpmem + numio + numbus) * 8;
500 if (p_byte > ((u8*)p_EV_header + evbuffer_length))
503 p_ev_ctrl = (struct ev_hrt_ctrl *) p_byte;
507 if (p_byte > ((u8*)p_EV_header + evbuffer_length))
510 bus = p_ev_ctrl->bus;
511 device = p_ev_ctrl->device;
512 function = p_ev_ctrl->function;
515 nummem = p_ev_ctrl->mem_avail;
516 numpmem = p_ev_ctrl->p_mem_avail;
517 numio = p_ev_ctrl->io_avail;
518 numbus = p_ev_ctrl->bus_avail;
522 if (p_byte > ((u8*)p_EV_header + evbuffer_length))
526 mem_node = kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
531 mem_node->base = *(u32*)p_byte;
532 dbg("mem base = %8.8x\n",mem_node->base);
535 if (p_byte > ((u8*)p_EV_header + evbuffer_length)) {
540 mem_node->length = *(u32*)p_byte;
541 dbg("mem length = %8.8x\n",mem_node->length);
544 if (p_byte > ((u8*)p_EV_header + evbuffer_length)) {
549 mem_node->next = ctrl->mem_head;
550 ctrl->mem_head = mem_node;
554 p_mem_node = kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
559 p_mem_node->base = *(u32*)p_byte;
560 dbg("pre-mem base = %8.8x\n",p_mem_node->base);
563 if (p_byte > ((u8*)p_EV_header + evbuffer_length)) {
568 p_mem_node->length = *(u32*)p_byte;
569 dbg("pre-mem length = %8.8x\n",p_mem_node->length);
572 if (p_byte > ((u8*)p_EV_header + evbuffer_length)) {
577 p_mem_node->next = ctrl->p_mem_head;
578 ctrl->p_mem_head = p_mem_node;
582 io_node = kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
587 io_node->base = *(u32*)p_byte;
588 dbg("io base = %8.8x\n",io_node->base);
591 if (p_byte > ((u8*)p_EV_header + evbuffer_length)) {
596 io_node->length = *(u32*)p_byte;
597 dbg("io length = %8.8x\n",io_node->length);
600 if (p_byte > ((u8*)p_EV_header + evbuffer_length)) {
605 io_node->next = ctrl->io_head;
606 ctrl->io_head = io_node;
610 bus_node = kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
615 bus_node->base = *(u32*)p_byte;
618 if (p_byte > ((u8*)p_EV_header + evbuffer_length)) {
623 bus_node->length = *(u32*)p_byte;
626 if (p_byte > ((u8*)p_EV_header + evbuffer_length)) {
631 bus_node->next = ctrl->bus_head;
632 ctrl->bus_head = bus_node;
635 /* If all of the following fail, we don't have any resources for
639 rc &= cpqhp_resource_sort_and_combine(&(ctrl->mem_head));
640 rc &= cpqhp_resource_sort_and_combine(&(ctrl->p_mem_head));
641 rc &= cpqhp_resource_sort_and_combine(&(ctrl->io_head));
642 rc &= cpqhp_resource_sort_and_combine(&(ctrl->bus_head));
647 if ((evbuffer[0] != 0) && (!ctrl->push_flag))
655 int compaq_nvram_store (void __iomem *rom_start)
659 if (rom_start == NULL)
663 rc = store_HRT(rom_start);
665 err(msg_unable_to_save);