drivers/pci/hotplug/cpqphp_nvram.c

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