1 /* 2 * Compaq Hot Plug Controller Driver 3 * 4 * Copyright (C) 1995,2001 Compaq Computer Corporation 5 * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com) 6 * Copyright (C) 2001 IBM Corp. 7 * 8 * All rights reserved. 9 * 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. 14 * 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 19 * details. 20 * 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. 24 * 25 * Send feedback to <greg@kroah.com> 26 * 27 */ 28 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> 38 #include "cpqphp.h" 39 #include "cpqphp_nvram.h" 40 41 42 #define ROM_INT15_PHY_ADDR 0x0FF859 43 #define READ_EV 0xD8A4 44 #define WRITE_EV 0xD8A5 45 46 struct register_foo { 47 union { 48 unsigned long lword; /* eax */ 49 unsigned short word; /* ax */ 50 51 struct { 52 unsigned char low; /* al */ 53 unsigned char high; /* ah */ 54 } byte; 55 } data; 56 57 unsigned char opcode; /* see below */ 58 unsigned long length; /* if the reg. is a pointer, how much data */ 59 } __attribute__ ((packed)); 60 61 struct all_reg { 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)); 70 71 72 struct ev_hrt_header { 73 u8 Version; 74 u8 num_of_ctrl; 75 u8 next; 76 }; 77 78 struct ev_hrt_ctrl { 79 u8 bus; 80 u8 device; 81 u8 function; 82 u8 mem_avail; 83 u8 p_mem_avail; 84 u8 io_avail; 85 u8 bus_avail; 86 u8 next; 87 }; 88 89 90 static u8 evbuffer_init; 91 static u8 evbuffer_length; 92 static u8 evbuffer[1024]; 93 94 static void __iomem *compaq_int15_entry_point; 95 96 /* lock for ordering int15_bios_call() */ 97 static spinlock_t int15_lock; 98 99 100 /* This is a series of function that deals with 101 * setting & getting the hotplug resource table in some environment variable. 102 */ 103 104 /* 105 * We really shouldn't be doing this unless there is a _very_ good reason to!!! 106 * greg k-h 107 */ 108 109 110 static u32 add_byte(u32 **p_buffer, u8 value, u32 *used, u32 *avail) 111 { 112 u8 **tByte; 113 114 if ((*used + 1) > *avail) 115 return(1); 116 117 *((u8*)*p_buffer) = value; 118 tByte = (u8**)p_buffer; 119 (*tByte)++; 120 *used+=1; 121 return(0); 122 } 123 124 125 static u32 add_dword(u32 **p_buffer, u32 value, u32 *used, u32 *avail) 126 { 127 if ((*used + 4) > *avail) 128 return(1); 129 130 **p_buffer = value; 131 (*p_buffer)++; 132 *used+=4; 133 return(0); 134 } 135 136 137 /* 138 * check_for_compaq_ROM 139 * 140 * this routine verifies that the ROM OEM string is 'COMPAQ' 141 * 142 * returns 0 for non-Compaq ROM, 1 for Compaq ROM 143 */ 144 static int check_for_compaq_ROM (void __iomem *rom_start) 145 { 146 u8 temp1, temp2, temp3, temp4, temp5, temp6; 147 int result = 0; 148 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') && 156 (temp2 == 'O') && 157 (temp3 == 'M') && 158 (temp4 == 'P') && 159 (temp5 == 'A') && 160 (temp6 == 'Q')) { 161 result = 1; 162 } 163 dbg ("%s - returned %d\n", __func__, result); 164 return result; 165 } 166 167 168 static u32 access_EV (u16 operation, u8 *ev_name, u8 *buffer, u32 *buf_size) 169 { 170 unsigned long flags; 171 int op = operation; 172 int ret_val; 173 174 if (!compaq_int15_entry_point) 175 return -ENODEV; 176 177 spin_lock_irqsave(&int15_lock, flags); 178 __asm__ ( 179 "xorl %%ebx,%%ebx\n" \ 180 "xorl %%edx,%%edx\n" \ 181 "pushf\n" \ 182 "push %%cs\n" \ 183 "cli\n" \ 184 "call *%6\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) 188 : "%ebx", "%edx"); 189 spin_unlock_irqrestore(&int15_lock, flags); 190 191 return((ret_val & 0xFF00) >> 8); 192 } 193 194 195 /* 196 * load_HRT 197 * 198 * Read the hot plug Resource Table from NVRAM 199 */ 200 static int load_HRT (void __iomem *rom_start) 201 { 202 u32 available; 203 u32 temp_dword; 204 u8 temp_byte = 0xFF; 205 u32 rc; 206 207 if (!check_for_compaq_ROM(rom_start)) 208 return -ENODEV; 209 210 available = 1024; 211 212 /* Now load the EV */ 213 temp_dword = available; 214 215 rc = access_EV(READ_EV, "CQTHPS", evbuffer, &temp_dword); 216 217 evbuffer_length = temp_dword; 218 219 /* We're maintaining the resource lists so write FF to invalidate old 220 * info 221 */ 222 temp_dword = 1; 223 224 rc = access_EV(WRITE_EV, "CQTHPS", &temp_byte, &temp_dword); 225 226 return rc; 227 } 228 229 230 /* 231 * store_HRT 232 * 233 * Save the hot plug Resource Table in NVRAM 234 */ 235 static u32 store_HRT (void __iomem *rom_start) 236 { 237 u32 *buffer; 238 u32 *pFill; 239 u32 usedbytes; 240 u32 available; 241 u32 temp_dword; 242 u32 rc; 243 u8 loop; 244 u8 numCtrl = 0; 245 struct controller *ctrl; 246 struct pci_resource *resNode; 247 struct ev_hrt_header *p_EV_header; 248 struct ev_hrt_ctrl *p_ev_ctrl; 249 250 available = 1024; 251 252 if (!check_for_compaq_ROM(rom_start)) 253 return(1); 254 255 buffer = (u32*) evbuffer; 256 257 if (!buffer) 258 return(1); 259 260 pFill = buffer; 261 usedbytes = 0; 262 263 p_EV_header = (struct ev_hrt_header *) pFill; 264 265 ctrl = cpqhp_ctrl_list; 266 267 /* The revision of this structure */ 268 rc = add_byte(&pFill, 1 + ctrl->push_flag, &usedbytes, &available); 269 if (rc) 270 return(rc); 271 272 /* The number of controllers */ 273 rc = add_byte(&pFill, 1, &usedbytes, &available); 274 if (rc) 275 return(rc); 276 277 while (ctrl) { 278 p_ev_ctrl = (struct ev_hrt_ctrl *) pFill; 279 280 numCtrl++; 281 282 /* The bus number */ 283 rc = add_byte(&pFill, ctrl->bus, &usedbytes, &available); 284 if (rc) 285 return(rc); 286 287 /* The device Number */ 288 rc = add_byte(&pFill, PCI_SLOT(ctrl->pci_dev->devfn), &usedbytes, &available); 289 if (rc) 290 return(rc); 291 292 /* The function Number */ 293 rc = add_byte(&pFill, PCI_FUNC(ctrl->pci_dev->devfn), &usedbytes, &available); 294 if (rc) 295 return(rc); 296 297 /* Skip the number of available entries */ 298 rc = add_dword(&pFill, 0, &usedbytes, &available); 299 if (rc) 300 return(rc); 301 302 /* Figure out memory Available */ 303 304 resNode = ctrl->mem_head; 305 306 loop = 0; 307 308 while (resNode) { 309 loop ++; 310 311 /* base */ 312 rc = add_dword(&pFill, resNode->base, &usedbytes, &available); 313 if (rc) 314 return(rc); 315 316 /* length */ 317 rc = add_dword(&pFill, resNode->length, &usedbytes, &available); 318 if (rc) 319 return(rc); 320 321 resNode = resNode->next; 322 } 323 324 /* Fill in the number of entries */ 325 p_ev_ctrl->mem_avail = loop; 326 327 /* Figure out prefetchable memory Available */ 328 329 resNode = ctrl->p_mem_head; 330 331 loop = 0; 332 333 while (resNode) { 334 loop ++; 335 336 /* base */ 337 rc = add_dword(&pFill, resNode->base, &usedbytes, &available); 338 if (rc) 339 return(rc); 340 341 /* length */ 342 rc = add_dword(&pFill, resNode->length, &usedbytes, &available); 343 if (rc) 344 return(rc); 345 346 resNode = resNode->next; 347 } 348 349 /* Fill in the number of entries */ 350 p_ev_ctrl->p_mem_avail = loop; 351 352 /* Figure out IO Available */ 353 354 resNode = ctrl->io_head; 355 356 loop = 0; 357 358 while (resNode) { 359 loop ++; 360 361 /* base */ 362 rc = add_dword(&pFill, resNode->base, &usedbytes, &available); 363 if (rc) 364 return(rc); 365 366 /* length */ 367 rc = add_dword(&pFill, resNode->length, &usedbytes, &available); 368 if (rc) 369 return(rc); 370 371 resNode = resNode->next; 372 } 373 374 /* Fill in the number of entries */ 375 p_ev_ctrl->io_avail = loop; 376 377 /* Figure out bus Available */ 378 379 resNode = ctrl->bus_head; 380 381 loop = 0; 382 383 while (resNode) { 384 loop ++; 385 386 /* base */ 387 rc = add_dword(&pFill, resNode->base, &usedbytes, &available); 388 if (rc) 389 return(rc); 390 391 /* length */ 392 rc = add_dword(&pFill, resNode->length, &usedbytes, &available); 393 if (rc) 394 return(rc); 395 396 resNode = resNode->next; 397 } 398 399 /* Fill in the number of entries */ 400 p_ev_ctrl->bus_avail = loop; 401 402 ctrl = ctrl->next; 403 } 404 405 p_EV_header->num_of_ctrl = numCtrl; 406 407 /* Now store the EV */ 408 409 temp_dword = usedbytes; 410 411 rc = access_EV(WRITE_EV, "CQTHPS", (u8*) buffer, &temp_dword); 412 413 dbg("usedbytes = 0x%x, length = 0x%x\n", usedbytes, temp_dword); 414 415 evbuffer_length = temp_dword; 416 417 if (rc) { 418 err(msg_unable_to_save); 419 return(1); 420 } 421 422 return(0); 423 } 424 425 426 void compaq_nvram_init (void __iomem *rom_start) 427 { 428 if (rom_start) 429 compaq_int15_entry_point = (rom_start + ROM_INT15_PHY_ADDR - ROM_PHY_ADDR); 430 431 dbg("int15 entry = %p\n", compaq_int15_entry_point); 432 433 /* initialize our int15 lock */ 434 spin_lock_init(&int15_lock); 435 } 436 437 438 int compaq_nvram_load (void __iomem *rom_start, struct controller *ctrl) 439 { 440 u8 bus, device, function; 441 u8 nummem, numpmem, numio, numbus; 442 u32 rc; 443 u8 *p_byte; 444 struct pci_resource *mem_node; 445 struct pci_resource *p_mem_node; 446 struct pci_resource *io_node; 447 struct pci_resource *bus_node; 448 struct ev_hrt_ctrl *p_ev_ctrl; 449 struct ev_hrt_header *p_EV_header; 450 451 if (!evbuffer_init) { 452 /* Read the resource list information in from NVRAM */ 453 if (load_HRT(rom_start)) 454 memset (evbuffer, 0, 1024); 455 456 evbuffer_init = 1; 457 } 458 459 /* If we saved information in NVRAM, use it now */ 460 p_EV_header = (struct ev_hrt_header *) evbuffer; 461 462 /* The following code is for systems where version 1.0 of this 463 * driver has been loaded, but doesn't support the hardware. 464 * In that case, the driver would incorrectly store something 465 * in NVRAM. 466 */ 467 if ((p_EV_header->Version == 2) || 468 ((p_EV_header->Version == 1) && !ctrl->push_flag)) { 469 p_byte = &(p_EV_header->next); 470 471 p_ev_ctrl = (struct ev_hrt_ctrl *) &(p_EV_header->next); 472 473 p_byte += 3; 474 475 if (p_byte > ((u8*)p_EV_header + evbuffer_length)) 476 return 2; 477 478 bus = p_ev_ctrl->bus; 479 device = p_ev_ctrl->device; 480 function = p_ev_ctrl->function; 481 482 while ((bus != ctrl->bus) || 483 (device != PCI_SLOT(ctrl->pci_dev->devfn)) || 484 (function != PCI_FUNC(ctrl->pci_dev->devfn))) { 485 nummem = p_ev_ctrl->mem_avail; 486 numpmem = p_ev_ctrl->p_mem_avail; 487 numio = p_ev_ctrl->io_avail; 488 numbus = p_ev_ctrl->bus_avail; 489 490 p_byte += 4; 491 492 if (p_byte > ((u8*)p_EV_header + evbuffer_length)) 493 return 2; 494 495 /* Skip forward to the next entry */ 496 p_byte += (nummem + numpmem + numio + numbus) * 8; 497 498 if (p_byte > ((u8*)p_EV_header + evbuffer_length)) 499 return 2; 500 501 p_ev_ctrl = (struct ev_hrt_ctrl *) p_byte; 502 503 p_byte += 3; 504 505 if (p_byte > ((u8*)p_EV_header + evbuffer_length)) 506 return 2; 507 508 bus = p_ev_ctrl->bus; 509 device = p_ev_ctrl->device; 510 function = p_ev_ctrl->function; 511 } 512 513 nummem = p_ev_ctrl->mem_avail; 514 numpmem = p_ev_ctrl->p_mem_avail; 515 numio = p_ev_ctrl->io_avail; 516 numbus = p_ev_ctrl->bus_avail; 517 518 p_byte += 4; 519 520 if (p_byte > ((u8*)p_EV_header + evbuffer_length)) 521 return 2; 522 523 while (nummem--) { 524 mem_node = kmalloc(sizeof(struct pci_resource), GFP_KERNEL); 525 526 if (!mem_node) 527 break; 528 529 mem_node->base = *(u32*)p_byte; 530 dbg("mem base = %8.8x\n",mem_node->base); 531 p_byte += 4; 532 533 if (p_byte > ((u8*)p_EV_header + evbuffer_length)) { 534 kfree(mem_node); 535 return 2; 536 } 537 538 mem_node->length = *(u32*)p_byte; 539 dbg("mem length = %8.8x\n",mem_node->length); 540 p_byte += 4; 541 542 if (p_byte > ((u8*)p_EV_header + evbuffer_length)) { 543 kfree(mem_node); 544 return 2; 545 } 546 547 mem_node->next = ctrl->mem_head; 548 ctrl->mem_head = mem_node; 549 } 550 551 while (numpmem--) { 552 p_mem_node = kmalloc(sizeof(struct pci_resource), GFP_KERNEL); 553 554 if (!p_mem_node) 555 break; 556 557 p_mem_node->base = *(u32*)p_byte; 558 dbg("pre-mem base = %8.8x\n",p_mem_node->base); 559 p_byte += 4; 560 561 if (p_byte > ((u8*)p_EV_header + evbuffer_length)) { 562 kfree(p_mem_node); 563 return 2; 564 } 565 566 p_mem_node->length = *(u32*)p_byte; 567 dbg("pre-mem length = %8.8x\n",p_mem_node->length); 568 p_byte += 4; 569 570 if (p_byte > ((u8*)p_EV_header + evbuffer_length)) { 571 kfree(p_mem_node); 572 return 2; 573 } 574 575 p_mem_node->next = ctrl->p_mem_head; 576 ctrl->p_mem_head = p_mem_node; 577 } 578 579 while (numio--) { 580 io_node = kmalloc(sizeof(struct pci_resource), GFP_KERNEL); 581 582 if (!io_node) 583 break; 584 585 io_node->base = *(u32*)p_byte; 586 dbg("io base = %8.8x\n",io_node->base); 587 p_byte += 4; 588 589 if (p_byte > ((u8*)p_EV_header + evbuffer_length)) { 590 kfree(io_node); 591 return 2; 592 } 593 594 io_node->length = *(u32*)p_byte; 595 dbg("io length = %8.8x\n",io_node->length); 596 p_byte += 4; 597 598 if (p_byte > ((u8*)p_EV_header + evbuffer_length)) { 599 kfree(io_node); 600 return 2; 601 } 602 603 io_node->next = ctrl->io_head; 604 ctrl->io_head = io_node; 605 } 606 607 while (numbus--) { 608 bus_node = kmalloc(sizeof(struct pci_resource), GFP_KERNEL); 609 610 if (!bus_node) 611 break; 612 613 bus_node->base = *(u32*)p_byte; 614 p_byte += 4; 615 616 if (p_byte > ((u8*)p_EV_header + evbuffer_length)) { 617 kfree(bus_node); 618 return 2; 619 } 620 621 bus_node->length = *(u32*)p_byte; 622 p_byte += 4; 623 624 if (p_byte > ((u8*)p_EV_header + evbuffer_length)) { 625 kfree(bus_node); 626 return 2; 627 } 628 629 bus_node->next = ctrl->bus_head; 630 ctrl->bus_head = bus_node; 631 } 632 633 /* If all of the following fail, we don't have any resources for 634 * hot plug add 635 */ 636 rc = 1; 637 rc &= cpqhp_resource_sort_and_combine(&(ctrl->mem_head)); 638 rc &= cpqhp_resource_sort_and_combine(&(ctrl->p_mem_head)); 639 rc &= cpqhp_resource_sort_and_combine(&(ctrl->io_head)); 640 rc &= cpqhp_resource_sort_and_combine(&(ctrl->bus_head)); 641 642 if (rc) 643 return(rc); 644 } else { 645 if ((evbuffer[0] != 0) && (!ctrl->push_flag)) 646 return 1; 647 } 648 649 return 0; 650 } 651 652 653 int compaq_nvram_store (void __iomem *rom_start) 654 { 655 int rc = 1; 656 657 if (rom_start == NULL) 658 return -ENODEV; 659 660 if (evbuffer_init) { 661 rc = store_HRT(rom_start); 662 if (rc) 663 err(msg_unable_to_save); 664 } 665 return rc; 666 } 667 668