cpqphp_ctrl.c revision 00395410885cac96015850426bf697423a3ec9dc
11da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* 21da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Compaq Hot Plug Controller Driver 31da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 41da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Copyright (C) 1995,2001 Compaq Computer Corporation 51da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com) 61da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Copyright (C) 2001 IBM Corp. 71da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 81da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * All rights reserved. 91da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * This program is free software; you can redistribute it and/or modify 111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * it under the terms of the GNU General Public License as published by 121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * the Free Software Foundation; either version 2 of the License, or (at 131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * your option) any later version. 141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * This program is distributed in the hope that it will be useful, but 161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * WITHOUT ANY WARRANTY; without even the implied warranty of 171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or 181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * NON INFRINGEMENT. See the GNU General Public License for more 191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * details. 201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * You should have received a copy of the GNU General Public License 221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * along with this program; if not, write to the Free Software 231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Send feedback to <greg@kroah.com> 261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/module.h> 301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/kernel.h> 311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/types.h> 321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/slab.h> 331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/workqueue.h> 341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/interrupt.h> 351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/delay.h> 361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/wait.h> 371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/smp_lock.h> 381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/pci.h> 397a54f25cef6c763f16c9fd49ae382de162147873Greg Kroah-Hartman#include <linux/pci_hotplug.h> 40fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig#include <linux/kthread.h> 411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include "cpqphp.h" 421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic u32 configure_new_device(struct controller* ctrl, struct pci_func *func, 441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 behind_bridge, struct resource_lists *resources); 451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int configure_new_function(struct controller* ctrl, struct pci_func *func, 461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 behind_bridge, struct resource_lists *resources); 471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void interrupt_event_handler(struct controller *ctrl); 481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 50fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwigstatic struct task_struct *cpqhp_event_thread; 51fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwigstatic unsigned long pushbutton_pending; /* = 0 */ 521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* delay is in jiffies to wait for */ 541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void long_delay(int delay) 551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 56fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig /* 57fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig * XXX(hch): if someone is bored please convert all callers 58fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig * to call msleep_interruptible directly. They really want 59fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig * to specify timeouts in natural units and spend a lot of 60fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig * effort converting them to jiffies.. 611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds msleep_interruptible(jiffies_to_msecs(delay)); 631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* FIXME: The following line needs to be somewhere else... */ 671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define WRONG_BUS_FREQUENCY 0x07 681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic u8 handle_switch_change(u8 change, struct controller * ctrl) 691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int hp_slot; 711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 rc = 0; 721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u16 temp_word; 731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_func *func; 741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct event_info *taskInfo; 751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!change) 771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Switch Change */ 801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("cpqsbd: Switch interrupt received.\n"); 811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (hp_slot = 0; hp_slot < 6; hp_slot++) { 831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (change & (0x1L << hp_slot)) { 841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /********************************** 851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * this one changed. 861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds **********************************/ 871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func = cpqhp_slot_find(ctrl->bus, 881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (hp_slot + ctrl->slot_device_offset), 0); 891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* this is the structure that tells the worker thread 911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *what to do */ 921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds taskInfo = &(ctrl->event_queue[ctrl->next_event]); 931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ctrl->next_event = (ctrl->next_event + 1) % 10; 941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds taskInfo->hp_slot = hp_slot; 951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc++; 971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_word = ctrl->ctrl_int_comp >> 16; 991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->presence_save = (temp_word >> hp_slot) & 0x01; 1001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->presence_save |= (temp_word >> (hp_slot + 7)) & 0x02; 1011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (ctrl->ctrl_int_comp & (0x1L << hp_slot)) { 1031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /********************************** 1041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Switch opened 1051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds **********************************/ 1061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->switch_save = 0; 1081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds taskInfo->event_type = INT_SWITCH_OPEN; 1101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 1111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /********************************** 1121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Switch closed 1131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds **********************************/ 1141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->switch_save = 0x10; 1161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds taskInfo->event_type = INT_SWITCH_CLOSE; 1181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 1191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 1201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 1211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 1231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 1241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 1261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * cpqhp_find_slot: find the struct slot of given device 1271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @ctrl: scan lots of this controller 1281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @device: the device id to find 1291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 1301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic struct slot *cpqhp_find_slot(struct controller *ctrl, u8 device) 1311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 1321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct slot *slot = ctrl->slot; 1331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (slot && (slot->device != device)) { 1351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot = slot->next; 1361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 1371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return slot; 1391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 1401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic u8 handle_presence_change(u16 change, struct controller * ctrl) 1431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 1441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int hp_slot; 1451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 rc = 0; 1461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 temp_byte; 1471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u16 temp_word; 1481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_func *func; 1491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct event_info *taskInfo; 1501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct slot *p_slot; 1511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!change) 1531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 1541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /********************************** 1561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Presence Change 1571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds **********************************/ 1581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("cpqsbd: Presence/Notify input change.\n"); 1591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg(" Changed bits are 0x%4.4x\n", change ); 1601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (hp_slot = 0; hp_slot < 6; hp_slot++) { 1621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (change & (0x0101 << hp_slot)) { 1631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /********************************** 1641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * this one changed. 1651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds **********************************/ 1661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func = cpqhp_slot_find(ctrl->bus, 1671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (hp_slot + ctrl->slot_device_offset), 0); 1681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds taskInfo = &(ctrl->event_queue[ctrl->next_event]); 1701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ctrl->next_event = (ctrl->next_event + 1) % 10; 1711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds taskInfo->hp_slot = hp_slot; 1721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc++; 1741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot = cpqhp_find_slot(ctrl, hp_slot + (readb(ctrl->hpc_reg + SLOT_MASK) >> 4)); 1761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!p_slot) 1771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 1781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If the switch closed, must be a button 1801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * If not in button mode, nevermind */ 1811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (func->switch_save && (ctrl->push_button == 1)) { 1821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_word = ctrl->ctrl_int_comp >> 16; 1831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_byte = (temp_word >> hp_slot) & 0x01; 1841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_byte |= (temp_word >> (hp_slot + 7)) & 0x02; 1851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (temp_byte != func->presence_save) { 1871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /************************************** 1881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * button Pressed (doesn't do anything) 1891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds **************************************/ 1901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("hp_slot %d button pressed\n", hp_slot); 1911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds taskInfo->event_type = INT_BUTTON_PRESS; 1921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 1931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /********************************** 1941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * button Released - TAKE ACTION!!!! 1951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds **********************************/ 1961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("hp_slot %d button released\n", hp_slot); 1971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds taskInfo->event_type = INT_BUTTON_RELEASE; 1981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Cancel if we are still blinking */ 2001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((p_slot->state == BLINKINGON_STATE) 2011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds || (p_slot->state == BLINKINGOFF_STATE)) { 2021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds taskInfo->event_type = INT_BUTTON_CANCEL; 2031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("hp_slot %d button cancel\n", hp_slot); 2041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if ((p_slot->state == POWERON_STATE) 2051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds || (p_slot->state == POWEROFF_STATE)) { 2061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* info(msg_button_ignore, p_slot->number); */ 2071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds taskInfo->event_type = INT_BUTTON_IGNORE; 2081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("hp_slot %d button ignore\n", hp_slot); 2091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 2101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 2111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 2121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Switch is open, assume a presence change 2131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Save the presence state */ 2141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_word = ctrl->ctrl_int_comp >> 16; 2151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->presence_save = (temp_word >> hp_slot) & 0x01; 2161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->presence_save |= (temp_word >> (hp_slot + 7)) & 0x02; 2171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((!(ctrl->ctrl_int_comp & (0x010000 << hp_slot))) || 2191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (!(ctrl->ctrl_int_comp & (0x01000000 << hp_slot)))) { 2201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Present */ 2211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds taskInfo->event_type = INT_PRESENCE_ON; 2221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 2231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Not Present */ 2241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds taskInfo->event_type = INT_PRESENCE_OFF; 2251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 2261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 2271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 2281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 2291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 2311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 2321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic u8 handle_power_fault(u8 change, struct controller * ctrl) 2351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 2361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int hp_slot; 2371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 rc = 0; 2381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_func *func; 2391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct event_info *taskInfo; 2401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!change) 2421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 2431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /********************************** 2451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * power fault 2461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds **********************************/ 2471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds info("power fault interrupt\n"); 2491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (hp_slot = 0; hp_slot < 6; hp_slot++) { 2511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (change & (0x01 << hp_slot)) { 2521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /********************************** 2531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * this one changed. 2541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds **********************************/ 2551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func = cpqhp_slot_find(ctrl->bus, 2561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (hp_slot + ctrl->slot_device_offset), 0); 2571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds taskInfo = &(ctrl->event_queue[ctrl->next_event]); 2591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ctrl->next_event = (ctrl->next_event + 1) % 10; 2601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds taskInfo->hp_slot = hp_slot; 2611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc++; 2631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (ctrl->ctrl_int_comp & (0x00000100 << hp_slot)) { 2651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /********************************** 2661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * power fault Cleared 2671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds **********************************/ 2681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->status = 0x00; 2691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds taskInfo->event_type = INT_POWER_FAULT_CLEAR; 2711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 2721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /********************************** 2731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * power fault 2741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds **********************************/ 2751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds taskInfo->event_type = INT_POWER_FAULT; 2761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (ctrl->rev < 4) { 2781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds amber_LED_on (ctrl, hp_slot); 2791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds green_LED_off (ctrl, hp_slot); 2801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO (ctrl); 2811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* this is a fatal condition, we want 2831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * to crash the machine to protect from 2841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * data corruption. simulated_NMI 2851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * shouldn't ever return */ 2861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* FIXME 2871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds simulated_NMI(hp_slot, ctrl); */ 2881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* The following code causes a software 2901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * crash just in case simulated_NMI did 2911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * return */ 2921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /*FIXME 2931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic(msg_power_fault); */ 2941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 2951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* set power fault status for this board */ 2961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->status = 0xFF; 2971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds info("power fault bit %x set\n", hp_slot); 2981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 2991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 3001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 3011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 3021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 3041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 3051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 3081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * sort_by_size: sort nodes on the list by their length, smallest first. 3091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @head: list to sort 3101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 3111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 3121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int sort_by_size(struct pci_resource **head) 3131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 3141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *current_res; 3151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *next_res; 3161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int out_of_order = 1; 3171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!(*head)) 3191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 3201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!((*head)->next)) 3221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 3231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (out_of_order) { 3251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds out_of_order = 0; 3261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Special case for swapping list head */ 3281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (((*head)->next) && 3291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ((*head)->length > (*head)->next->length)) { 3301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds out_of_order++; 3311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds current_res = *head; 3321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *head = (*head)->next; 3331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds current_res->next = (*head)->next; 3341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (*head)->next = current_res; 3351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 3361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds current_res = *head; 3381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (current_res->next && current_res->next->next) { 3401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (current_res->next->length > current_res->next->next->length) { 3411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds out_of_order++; 3421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds next_res = current_res->next; 3431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds current_res->next = current_res->next->next; 3441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds current_res = current_res->next; 3451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds next_res->next = current_res->next; 3461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds current_res->next = next_res; 3471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else 3481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds current_res = current_res->next; 3491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 3501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } /* End of out_of_order loop */ 3511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 3531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 3541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 3571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * sort_by_max_size: sort nodes on the list by their length, largest first. 3581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @head: list to sort 3591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 3601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 3611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int sort_by_max_size(struct pci_resource **head) 3621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 3631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *current_res; 3641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *next_res; 3651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int out_of_order = 1; 3661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!(*head)) 3681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 3691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!((*head)->next)) 3711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 3721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (out_of_order) { 3741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds out_of_order = 0; 3751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Special case for swapping list head */ 3771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (((*head)->next) && 3781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ((*head)->length < (*head)->next->length)) { 3791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds out_of_order++; 3801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds current_res = *head; 3811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *head = (*head)->next; 3821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds current_res->next = (*head)->next; 3831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (*head)->next = current_res; 3841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 3851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds current_res = *head; 3871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (current_res->next && current_res->next->next) { 3891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (current_res->next->length < current_res->next->next->length) { 3901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds out_of_order++; 3911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds next_res = current_res->next; 3921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds current_res->next = current_res->next->next; 3931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds current_res = current_res->next; 3941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds next_res->next = current_res->next; 3951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds current_res->next = next_res; 3961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else 3971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds current_res = current_res->next; 3981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 3991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } /* End of out_of_order loop */ 4001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 4021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 4031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 4061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * do_pre_bridge_resource_split: find node of resources that are unused 4071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 4081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 4091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic struct pci_resource *do_pre_bridge_resource_split(struct pci_resource **head, 4101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource **orig_head, u32 alignment) 4111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 4121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *prevnode = NULL; 4131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *node; 4141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *split_node; 4151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 rc; 4161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 temp_dword; 4171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("do_pre_bridge_resource_split\n"); 4181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!(*head) || !(*orig_head)) 4201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 4211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = cpqhp_resource_sort_and_combine(head); 4231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 4251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 4261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((*head)->base != (*orig_head)->base) 4281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 4291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((*head)->length == (*orig_head)->length) 4311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 4321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If we got here, there the bridge requires some of the resource, but 4351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * we may be able to split some off of the front */ 4361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node = *head; 4381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (node->length & (alignment -1)) { 4401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* this one isn't an aligned length, so we'll make a new entry 4411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * and split it up. */ 4421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node = kmalloc(sizeof(*split_node), GFP_KERNEL); 4431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!split_node) 4451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 4461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_dword = (node->length | (alignment-1)) + 1 - alignment; 4481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->base = node->base; 4501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->length = temp_dword; 4511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->length -= temp_dword; 4531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->base += split_node->length; 4541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Put it in the list */ 4561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *head = split_node; 4571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->next = node; 4581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 4591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (node->length < alignment) 4611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 4621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Now unlink it */ 4641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (*head == node) { 4651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *head = node->next; 4661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 4671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds prevnode = *head; 4681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (prevnode->next != node) 4691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds prevnode = prevnode->next; 4701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds prevnode->next = node->next; 4721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 4731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->next = NULL; 4741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return node; 4761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 4771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 4801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * do_bridge_resource_split: find one node of resources that aren't in use 4811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 4821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 4831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic struct pci_resource *do_bridge_resource_split(struct pci_resource **head, u32 alignment) 4841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 4851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *prevnode = NULL; 4861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *node; 4871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 rc; 4881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 temp_dword; 4891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = cpqhp_resource_sort_and_combine(head); 4911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 4931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 4941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node = *head; 4961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (node->next) { 4981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds prevnode = node; 4991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node = node->next; 5001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree(prevnode); 5011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 5021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (node->length < alignment) 5041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto error; 5051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (node->base & (alignment - 1)) { 5071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Short circuit if adjusted size is too small */ 5081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_dword = (node->base | (alignment-1)) + 1; 5091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((node->length - (temp_dword - node->base)) < alignment) 5101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto error; 5111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->length -= (temp_dword - node->base); 5131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->base = temp_dword; 5141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 5151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (node->length & (alignment - 1)) 5171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* There's stuff in use after this node */ 5181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto error; 5191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return node; 5211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldserror: 5221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree(node); 5231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 5241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 5251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 5281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * get_io_resource: find first node of given size not in ISA aliasing window. 5291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @head: list to search 5301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @size: size of node to find, must be a power of two. 5311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 5321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Description: this function sorts the resource list by size and then returns 5331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * returns the first node of "size" length that is not in the ISA aliasing 5341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * window. If it finds a node larger than "size" it will split it up. 5351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 5361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 5371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic struct pci_resource *get_io_resource(struct pci_resource **head, u32 size) 5381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 5391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *prevnode; 5401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *node; 5411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *split_node; 5421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 temp_dword; 5431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!(*head)) 5451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 5461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ( cpqhp_resource_sort_and_combine(head) ) 5481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 5491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ( sort_by_size(head) ) 5511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 5521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (node = *head; node; node = node->next) { 5541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (node->length < size) 5551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 5561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (node->base & (size - 1)) { 5581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* this one isn't base aligned properly 5591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * so we'll make a new entry and split it up */ 5601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_dword = (node->base | (size-1)) + 1; 5611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Short circuit if adjusted size is too small */ 5631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((node->length - (temp_dword - node->base)) < size) 5641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 5651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node = kmalloc(sizeof(*split_node), GFP_KERNEL); 5671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!split_node) 5691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 5701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->base = node->base; 5721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->length = temp_dword - node->base; 5731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->base = temp_dword; 5741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->length -= split_node->length; 5751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Put it in the list */ 5771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->next = node->next; 5781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->next = split_node; 5791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } /* End of non-aligned base */ 5801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Don't need to check if too small since we already did */ 5821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (node->length > size) { 5831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* this one is longer than we need 5841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * so we'll make a new entry and split it up */ 5851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node = kmalloc(sizeof(*split_node), GFP_KERNEL); 5861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!split_node) 5881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 5891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->base = node->base + size; 5911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->length = node->length - size; 5921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->length = size; 5931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Put it in the list */ 5951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->next = node->next; 5961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->next = split_node; 5971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } /* End of too big on top end */ 5981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* For IO make sure it's not in the ISA aliasing space */ 6001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (node->base & 0x300L) 6011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 6021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If we got here, then it is the right size 6041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Now take it out of the list and break */ 6051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (*head == node) { 6061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *head = node->next; 6071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 6081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds prevnode = *head; 6091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (prevnode->next != node) 6101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds prevnode = prevnode->next; 6111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds prevnode->next = node->next; 6131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 6141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->next = NULL; 6151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 6161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 6171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return node; 6191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 6201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 6231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * get_max_resource: get largest node which has at least the given size. 6241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @head: the list to search the node in 6251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @size: the minimum size of the node to find 6261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 6271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Description: Gets the largest node that is at least "size" big from the 6281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * list pointed to by head. It aligns the node on top and bottom 6291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * to "size" alignment before returning it. 6301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 6311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic struct pci_resource *get_max_resource(struct pci_resource **head, u32 size) 6321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 6331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *max; 6341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *temp; 6351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *split_node; 6361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 temp_dword; 6371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (cpqhp_resource_sort_and_combine(head)) 6391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 6401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (sort_by_max_size(head)) 6421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 6431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (max = *head; max; max = max->next) { 6451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If not big enough we could probably just bail, 6461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * instead we'll continue to the next. */ 6471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (max->length < size) 6481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 6491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (max->base & (size - 1)) { 6511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* this one isn't base aligned properly 6521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * so we'll make a new entry and split it up */ 6531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_dword = (max->base | (size-1)) + 1; 6541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Short circuit if adjusted size is too small */ 6561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((max->length - (temp_dword - max->base)) < size) 6571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 6581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node = kmalloc(sizeof(*split_node), GFP_KERNEL); 6601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!split_node) 6621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 6631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->base = max->base; 6651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->length = temp_dword - max->base; 6661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds max->base = temp_dword; 6671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds max->length -= split_node->length; 6681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->next = max->next; 6701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds max->next = split_node; 6711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 6721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((max->base + max->length) & (size - 1)) { 6741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* this one isn't end aligned properly at the top 6751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * so we'll make a new entry and split it up */ 6761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node = kmalloc(sizeof(*split_node), GFP_KERNEL); 6771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!split_node) 6791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 6801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_dword = ((max->base + max->length) & ~(size - 1)); 6811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->base = temp_dword; 6821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->length = max->length + max->base 6831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds - split_node->base; 6841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds max->length -= split_node->length; 6851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->next = max->next; 6871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds max->next = split_node; 6881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 6891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Make sure it didn't shrink too much when we aligned it */ 6911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (max->length < size) 6921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 6931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Now take it out of the list */ 6951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp = *head; 6961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (temp == max) { 6971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *head = max->next; 6981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 6991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (temp && temp->next != max) { 7001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp = temp->next; 7011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 7021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp->next = max->next; 7041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 7051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds max->next = NULL; 7071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 7081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 7091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return max; 7111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 7121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 7151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * get_resource: find resource of given size and split up larger ones. 7161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @head: the list to search for resources 7171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @size: the size limit to use 7181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 7191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Description: This function sorts the resource list by size and then 7201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * returns the first node of "size" length. If it finds a node 7211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * larger than "size" it will split it up. 7221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 7231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * size must be a power of two. 7241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 7251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic struct pci_resource *get_resource(struct pci_resource **head, u32 size) 7261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 7271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *prevnode; 7281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *node; 7291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *split_node; 7301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 temp_dword; 7311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (cpqhp_resource_sort_and_combine(head)) 7331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 7341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (sort_by_size(head)) 7361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 7371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (node = *head; node; node = node->next) { 7391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("%s: req_size =%x node=%p, base=%x, length=%x\n", 7401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __FUNCTION__, size, node, node->base, node->length); 7411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (node->length < size) 7421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 7431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (node->base & (size - 1)) { 7451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("%s: not aligned\n", __FUNCTION__); 7461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* this one isn't base aligned properly 7471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * so we'll make a new entry and split it up */ 7481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_dword = (node->base | (size-1)) + 1; 7491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Short circuit if adjusted size is too small */ 7511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((node->length - (temp_dword - node->base)) < size) 7521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 7531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node = kmalloc(sizeof(*split_node), GFP_KERNEL); 7551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!split_node) 7571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 7581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->base = node->base; 7601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->length = temp_dword - node->base; 7611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->base = temp_dword; 7621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->length -= split_node->length; 7631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->next = node->next; 7651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->next = split_node; 7661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } /* End of non-aligned base */ 7671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Don't need to check if too small since we already did */ 7691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (node->length > size) { 7701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("%s: too big\n", __FUNCTION__); 7711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* this one is longer than we need 7721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * so we'll make a new entry and split it up */ 7731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node = kmalloc(sizeof(*split_node), GFP_KERNEL); 7741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!split_node) 7761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 7771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->base = node->base + size; 7791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->length = node->length - size; 7801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->length = size; 7811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Put it in the list */ 7831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->next = node->next; 7841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->next = split_node; 7851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } /* End of too big on top end */ 7861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("%s: got one!!!\n", __FUNCTION__); 7881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If we got here, then it is the right size 7891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Now take it out of the list */ 7901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (*head == node) { 7911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *head = node->next; 7921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 7931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds prevnode = *head; 7941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (prevnode->next != node) 7951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds prevnode = prevnode->next; 7961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds prevnode->next = node->next; 7981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 7991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->next = NULL; 8001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 8011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 8021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return node; 8031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 8041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 8071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * cpqhp_resource_sort_and_combine: sort nodes by base addresses and clean up. 8081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @head: the list to sort and clean up 8091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 8101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Description: Sorts all of the nodes in the list in ascending order by 8111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * their base addresses. Also does garbage collection by 8121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * combining adjacent nodes. 8131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 8141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * returns 0 if success 8151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 8161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsint cpqhp_resource_sort_and_combine(struct pci_resource **head) 8171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 8181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *node1; 8191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *node2; 8201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int out_of_order = 1; 8211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("%s: head = %p, *head = %p\n", __FUNCTION__, head, *head); 8231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!(*head)) 8251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 8261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("*head->next = %p\n",(*head)->next); 8281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!(*head)->next) 8301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; /* only one item on the list, already sorted! */ 8311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("*head->base = 0x%x\n",(*head)->base); 8331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("*head->next->base = 0x%x\n",(*head)->next->base); 8341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (out_of_order) { 8351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds out_of_order = 0; 8361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Special case for swapping list head */ 8381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (((*head)->next) && 8391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ((*head)->base > (*head)->next->base)) { 8401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node1 = *head; 8411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (*head) = (*head)->next; 8421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node1->next = (*head)->next; 8431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (*head)->next = node1; 8441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds out_of_order++; 8451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 8461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node1 = (*head); 8481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (node1->next && node1->next->next) { 8501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (node1->next->base > node1->next->next->base) { 8511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds out_of_order++; 8521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node2 = node1->next; 8531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node1->next = node1->next->next; 8541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node1 = node1->next; 8551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node2->next = node1->next; 8561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node1->next = node2; 8571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else 8581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node1 = node1->next; 8591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 8601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } /* End of out_of_order loop */ 8611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node1 = *head; 8631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (node1 && node1->next) { 8651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((node1->base + node1->length) == node1->next->base) { 8661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Combine */ 8671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("8..\n"); 8681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node1->length += node1->next->length; 8691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node2 = node1->next; 8701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node1->next = node1->next->next; 8711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree(node2); 8721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else 8731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node1 = node1->next; 8741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 8751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 8771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 8781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8807d12e780e003f93433d49ce78cfedf4b4c52adc5David Howellsirqreturn_t cpqhp_ctrl_intr(int IRQ, void *data) 8811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 8821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct controller *ctrl = data; 8831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 schedule_flag = 0; 8841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 reset; 8851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u16 misc; 8861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 Diff; 8871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 temp_dword; 8881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds misc = readw(ctrl->hpc_reg + MISC); 8911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /*************************************** 8921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Check to see if it was our interrupt 8931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ***************************************/ 8941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!(misc & 0x000C)) { 8951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return IRQ_NONE; 8961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 8971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (misc & 0x0004) { 8991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /********************************** 9001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Serial Output interrupt Pending 9011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds **********************************/ 9021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Clear the interrupt */ 9041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds misc |= 0x0004; 9051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writew(misc, ctrl->hpc_reg + MISC); 9061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Read to clear posted writes */ 9081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds misc = readw(ctrl->hpc_reg + MISC); 9091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg ("%s - waking up\n", __FUNCTION__); 9111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wake_up_interruptible(&ctrl->queue); 9121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 9131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (misc & 0x0008) { 9151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* General-interrupt-input interrupt Pending */ 9161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds Diff = readl(ctrl->hpc_reg + INT_INPUT_CLEAR) ^ ctrl->ctrl_int_comp; 9171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ctrl->ctrl_int_comp = readl(ctrl->hpc_reg + INT_INPUT_CLEAR); 9191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Clear the interrupt */ 9211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(Diff, ctrl->hpc_reg + INT_INPUT_CLEAR); 9221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Read it back to clear any posted writes */ 9241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_dword = readl(ctrl->hpc_reg + INT_INPUT_CLEAR); 9251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!Diff) 9271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Clear all interrupts */ 9281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(0xFFFFFFFF, ctrl->hpc_reg + INT_INPUT_CLEAR); 9291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds schedule_flag += handle_switch_change((u8)(Diff & 0xFFL), ctrl); 9311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds schedule_flag += handle_presence_change((u16)((Diff & 0xFFFF0000L) >> 16), ctrl); 9321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds schedule_flag += handle_power_fault((u8)((Diff & 0xFF00L) >> 8), ctrl); 9331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 9341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reset = readb(ctrl->hpc_reg + RESET_FREQ_MODE); 9361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (reset & 0x40) { 9371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Bus reset has completed */ 9381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reset &= 0xCF; 9391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writeb(reset, ctrl->hpc_reg + RESET_FREQ_MODE); 9401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reset = readb(ctrl->hpc_reg + RESET_FREQ_MODE); 9411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wake_up_interruptible(&ctrl->queue); 9421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 9431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (schedule_flag) { 945fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig wake_up_process(cpqhp_event_thread); 946fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig dbg("Waking even thread"); 9471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 9481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return IRQ_HANDLED; 9491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 9501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 9531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * cpqhp_slot_create - Creates a node and adds it to the proper bus. 9541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @busnumber - bus where new node is to be located 9551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 9561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Returns pointer to the new node or NULL if unsuccessful 9571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 9581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstruct pci_func *cpqhp_slot_create(u8 busnumber) 9591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 9601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_func *new_slot; 9611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_func *next; 9621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 96373a985a140cd0f1b17fa1438af0359d6b9b32b16Mariusz Kozlowski new_slot = kzalloc(sizeof(*new_slot), GFP_KERNEL); 9641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (new_slot == NULL) { 9651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* I'm not dead yet! 9661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * You will be. */ 9671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return new_slot; 9681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 9691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot->next = NULL; 9711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot->configured = 1; 9721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (cpqhp_slot_list[busnumber] == NULL) { 9741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_slot_list[busnumber] = new_slot; 9751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 9761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds next = cpqhp_slot_list[busnumber]; 9771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (next->next != NULL) 9781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds next = next->next; 9791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds next->next = new_slot; 9801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 9811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return new_slot; 9821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 9831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 9861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * slot_remove - Removes a node from the linked list of slots. 9871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @old_slot: slot to remove 9881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 9891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Returns 0 if successful, !0 otherwise. 9901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 9911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int slot_remove(struct pci_func * old_slot) 9921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 9931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_func *next; 9941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (old_slot == NULL) 9961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 9971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds next = cpqhp_slot_list[old_slot->bus]; 9991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (next == NULL) { 10011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 10021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 10031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (next == old_slot) { 10051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_slot_list[old_slot->bus] = old_slot->next; 10061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_destroy_board_resources(old_slot); 10071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree(old_slot); 10081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 10091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 10101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while ((next->next != old_slot) && (next->next != NULL)) { 10121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds next = next->next; 10131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 10141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (next->next == old_slot) { 10161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds next->next = old_slot->next; 10171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_destroy_board_resources(old_slot); 10181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree(old_slot); 10191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 10201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else 10211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 2; 10221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 10231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 10261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * bridge_slot_remove - Removes a node from the linked list of slots. 10271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @bridge: bridge to remove 10281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 10291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Returns 0 if successful, !0 otherwise. 10301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 10311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int bridge_slot_remove(struct pci_func *bridge) 10321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 10331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 subordinateBus, secondaryBus; 10341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 tempBus; 10351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_func *next; 10361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds secondaryBus = (bridge->config_space[0x06] >> 8) & 0xFF; 10381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds subordinateBus = (bridge->config_space[0x06] >> 16) & 0xFF; 10391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (tempBus = secondaryBus; tempBus <= subordinateBus; tempBus++) { 10411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds next = cpqhp_slot_list[tempBus]; 10421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (!slot_remove(next)) { 10441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds next = cpqhp_slot_list[tempBus]; 10451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 10461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 10471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds next = cpqhp_slot_list[bridge->bus]; 10491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (next == NULL) 10511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 10521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (next == bridge) { 10541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_slot_list[bridge->bus] = bridge->next; 10551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto out; 10561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 10571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while ((next->next != bridge) && (next->next != NULL)) 10591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds next = next->next; 10601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (next->next != bridge) 10621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 2; 10631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds next->next = bridge->next; 10641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsout: 10651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree(bridge); 10661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 10671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 10681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 10711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * cpqhp_slot_find - Looks for a node by bus, and device, multiple functions accessed 10721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @bus: bus to find 10731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @device: device to find 10741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @index: is 0 for first function found, 1 for the second... 10751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 10761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Returns pointer to the node if successful, %NULL otherwise. 10771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 10781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstruct pci_func *cpqhp_slot_find(u8 bus, u8 device, u8 index) 10791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 10801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int found = -1; 10811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_func *func; 10821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func = cpqhp_slot_list[bus]; 10841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((func == NULL) || ((func->device == device) && (index == 0))) 10861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return func; 10871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (func->device == device) 10891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds found++; 10901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (func->next != NULL) { 10921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func = func->next; 10931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (func->device == device) 10951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds found++; 10961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (found == index) 10981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return func; 10991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 11001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 11021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 11031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* DJZ: I don't think is_bridge will work as is. 11061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * FIXME */ 11071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int is_bridge(struct pci_func * func) 11081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 11091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check the header type */ 11101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (((func->config_space[0x03] >> 16) & 0xFF) == 0x01) 11111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 11121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 11131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 11141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 11151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 11181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * set_controller_speed - set the frequency and/or mode of a specific 11191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * controller segment. 11201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 11211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @ctrl: controller to change frequency/mode for. 11221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @adapter_speed: the speed of the adapter we want to match. 11231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @hp_slot: the slot number where the adapter is installed. 11241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 11251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Returns 0 if we successfully change frequency and/or mode to match the 11261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * adapter speed. 11271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 11281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 11291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic u8 set_controller_speed(struct controller *ctrl, u8 adapter_speed, u8 hp_slot) 11301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 11311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct slot *slot; 11321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 reg; 11331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 slot_power = readb(ctrl->hpc_reg + SLOT_POWER); 11341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u16 reg16; 11351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 leds = readl(ctrl->hpc_reg + LED_CONTROL); 11361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (ctrl->speed == adapter_speed) 11381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 11391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* We don't allow freq/mode changes if we find another adapter running 11411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * in another slot on this controller */ 11421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for(slot = ctrl->slot; slot; slot = slot->next) { 11431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (slot->device == (hp_slot + ctrl->slot_device_offset)) 11441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 11451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!slot->hotplug_slot && !slot->hotplug_slot->info) 11461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 11471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (slot->hotplug_slot->info->adapter_status == 0) 11481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 11491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If another adapter is running on the same segment but at a 11501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * lower speed/mode, we allow the new adapter to function at 11511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * this rate if supported */ 11521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (ctrl->speed < adapter_speed) 11531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 11541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 11561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 11571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If the controller doesn't support freq/mode changes and the 11591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * controller is running at a higher mode, we bail */ 11601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((ctrl->speed > adapter_speed) && (!ctrl->pcix_speed_capability)) 11611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 11621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* But we allow the adapter to run at a lower rate if possible */ 11641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((ctrl->speed < adapter_speed) && (!ctrl->pcix_speed_capability)) 11651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 11661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* We try to set the max speed supported by both the adapter and 11681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * controller */ 11691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (ctrl->speed_capability < adapter_speed) { 11701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (ctrl->speed == ctrl->speed_capability) 11711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 11721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds adapter_speed = ctrl->speed_capability; 11731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 11741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(0x0L, ctrl->hpc_reg + LED_CONTROL); 11761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writeb(0x00, ctrl->hpc_reg + SLOT_ENABLE); 11771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 11791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq(ctrl); 11801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (adapter_speed != PCI_SPEED_133MHz_PCIX) 11821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg = 0xF5; 11831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 11841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg = 0xF4; 11851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_write_config_byte(ctrl->pci_dev, 0x41, reg); 11861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg16 = readw(ctrl->hpc_reg + NEXT_CURR_FREQ); 11881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg16 &= ~0x000F; 11891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds switch(adapter_speed) { 11901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case(PCI_SPEED_133MHz_PCIX): 11911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg = 0x75; 11921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg16 |= 0xB; 11931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 11941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case(PCI_SPEED_100MHz_PCIX): 11951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg = 0x74; 11961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg16 |= 0xA; 11971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 11981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case(PCI_SPEED_66MHz_PCIX): 11991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg = 0x73; 12001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg16 |= 0x9; 12011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 12021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case(PCI_SPEED_66MHz): 12031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg = 0x73; 12041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg16 |= 0x1; 12051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 12061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds default: /* 33MHz PCI 2.2 */ 12071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg = 0x71; 12081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 12091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg16 |= 0xB << 12; 12121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writew(reg16, ctrl->hpc_reg + NEXT_CURR_FREQ); 12131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mdelay(5); 12151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Reenable interrupts */ 12171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(0, ctrl->hpc_reg + INT_MASK); 12181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_write_config_byte(ctrl->pci_dev, 0x41, reg); 12201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Restart state machine */ 12221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg = ~0xF; 12231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_read_config_byte(ctrl->pci_dev, 0x43, ®); 12241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_write_config_byte(ctrl->pci_dev, 0x43, reg); 12251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Only if mode change...*/ 12271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (((ctrl->speed == PCI_SPEED_66MHz) && (adapter_speed == PCI_SPEED_66MHz_PCIX)) || 12281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ((ctrl->speed == PCI_SPEED_66MHz_PCIX) && (adapter_speed == PCI_SPEED_66MHz))) 12291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 12301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq(ctrl); 12321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mdelay(1100); 12331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Restore LED/Slot state */ 12351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(leds, ctrl->hpc_reg + LED_CONTROL); 12361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writeb(slot_power, ctrl->hpc_reg + SLOT_ENABLE); 12371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 12391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq(ctrl); 12401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ctrl->speed = adapter_speed; 12421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot = cpqhp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset); 12431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds info("Successfully changed frequency/mode for adapter in slot %d\n", 12451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->number); 12461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 12471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 12481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* the following routines constitute the bulk of the 12501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hotplug controller logic 12511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 12521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 12551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * board_replaced - Called after a board has been replaced in the system. 12561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 12571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * This is only used if we don't have resources for hot add 12581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Turns power on for the board 12591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Checks to see if board is the same 12601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * If board is same, reconfigures it 12611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * If board isn't same, turns it back off. 12621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 12631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 12641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic u32 board_replaced(struct pci_func *func, struct controller *ctrl) 12651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 12661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 hp_slot; 12671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 temp_byte; 12681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 adapter_speed; 12691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 rc = 0; 12701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hp_slot = func->device - ctrl->slot_device_offset; 12721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (readl(ctrl->hpc_reg + INT_INPUT_CLEAR) & (0x01L << hp_slot)) { 12741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /********************************** 12751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * The switch is open. 12761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds **********************************/ 12771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = INTERLOCK_OPEN; 12781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if (is_slot_enabled (ctrl, hp_slot)) { 12791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /********************************** 12801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * The board is already on 12811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds **********************************/ 12821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = CARD_FUNCTIONING; 12831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 12846aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_lock(&ctrl->crit_sect); 12851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* turn on board without attaching to the bus */ 12871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds enable_slot_power (ctrl, hp_slot); 12881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 12901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 12921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 12931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Change bits in slot power register to force another shift out 12951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * NOTE: this is to work around the timer bug */ 12961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_byte = readb(ctrl->hpc_reg + SLOT_POWER); 12971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writeb(0x00, ctrl->hpc_reg + SLOT_POWER); 12981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writeb(temp_byte, ctrl->hpc_reg + SLOT_POWER); 12991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 13011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 13031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 13041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds adapter_speed = get_adapter_speed(ctrl, hp_slot); 13061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (ctrl->speed != adapter_speed) 13071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (set_controller_speed(ctrl, adapter_speed, hp_slot)) 13081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = WRONG_BUS_FREQUENCY; 13091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* turn off board without attaching to the bus */ 13111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds disable_slot_power (ctrl, hp_slot); 13121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 13141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 13161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 13171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13186aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_unlock(&ctrl->crit_sect); 13191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 13211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 13221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13236aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_lock(&ctrl->crit_sect); 13241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot_enable (ctrl, hp_slot); 13261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds green_LED_blink (ctrl, hp_slot); 13271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds amber_LED_off (ctrl, hp_slot); 13291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 13311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 13331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 13341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13356aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_unlock(&ctrl->crit_sect); 13361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for ~1 second because of hot plug spec */ 13381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds long_delay(1*HZ); 13391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check for a power fault */ 13411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (func->status == 0xFF) { 13421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* power fault occurred, but it was benign */ 13431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = POWER_FAILURE; 13441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->status = 0; 13451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else 13461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = cpqhp_valid_replace(ctrl, func); 13471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!rc) { 13491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* It must be the same board */ 13501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = cpqhp_configure_board(ctrl, func); 13521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13531305e9184a3de84f78dca102b293d21007bb6c49Adrian Bunk /* If configuration fails, turn it off 13541305e9184a3de84f78dca102b293d21007bb6c49Adrian Bunk * Get slot won't work for devices behind 13551305e9184a3de84f78dca102b293d21007bb6c49Adrian Bunk * bridges, but in this case it will always be 13561305e9184a3de84f78dca102b293d21007bb6c49Adrian Bunk * called for the "base" bus/dev/func of an 13571305e9184a3de84f78dca102b293d21007bb6c49Adrian Bunk * adapter. */ 13581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13596aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_lock(&ctrl->crit_sect); 13601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13611305e9184a3de84f78dca102b293d21007bb6c49Adrian Bunk amber_LED_on (ctrl, hp_slot); 13621305e9184a3de84f78dca102b293d21007bb6c49Adrian Bunk green_LED_off (ctrl, hp_slot); 13631305e9184a3de84f78dca102b293d21007bb6c49Adrian Bunk slot_disable (ctrl, hp_slot); 13641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 13661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 13681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 13691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13706aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_unlock(&ctrl->crit_sect); 13711305e9184a3de84f78dca102b293d21007bb6c49Adrian Bunk 13721305e9184a3de84f78dca102b293d21007bb6c49Adrian Bunk if (rc) 13731305e9184a3de84f78dca102b293d21007bb6c49Adrian Bunk return rc; 13741305e9184a3de84f78dca102b293d21007bb6c49Adrian Bunk else 13751305e9184a3de84f78dca102b293d21007bb6c49Adrian Bunk return 1; 13761305e9184a3de84f78dca102b293d21007bb6c49Adrian Bunk 13771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 13781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Something is wrong 13791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Get slot won't work for devices behind bridges, but 13811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * in this case it will always be called for the "base" 13821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * bus/dev/func of an adapter. */ 13831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13846aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_lock(&ctrl->crit_sect); 13851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds amber_LED_on (ctrl, hp_slot); 13871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds green_LED_off (ctrl, hp_slot); 13881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot_disable (ctrl, hp_slot); 13891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 13911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 13931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 13941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13956aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_unlock(&ctrl->crit_sect); 13961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 14001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 14021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 14051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * board_added - Called after a board has been added to the system. 14061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 14071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Turns power on for the board 14081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Configures board 14091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 14101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 14111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic u32 board_added(struct pci_func *func, struct controller *ctrl) 14121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 14131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 hp_slot; 14141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 temp_byte; 14151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 adapter_speed; 14161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int index; 14171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 temp_register = 0xFFFFFFFF; 14181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 rc = 0; 14191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_func *new_slot = NULL; 14201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct slot *p_slot; 14211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct resource_lists res_lists; 14221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hp_slot = func->device - ctrl->slot_device_offset; 14241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("%s: func->device, slot_offset, hp_slot = %d, %d ,%d\n", 14251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __FUNCTION__, func->device, ctrl->slot_device_offset, hp_slot); 14261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14276aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_lock(&ctrl->crit_sect); 14281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* turn on board without attaching to the bus */ 14301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds enable_slot_power(ctrl, hp_slot); 14311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 14331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 14351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 14361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Change bits in slot power register to force another shift out 14381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * NOTE: this is to work around the timer bug */ 14391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_byte = readb(ctrl->hpc_reg + SLOT_POWER); 14401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writeb(0x00, ctrl->hpc_reg + SLOT_POWER); 14411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writeb(temp_byte, ctrl->hpc_reg + SLOT_POWER); 14421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 14441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 14461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 14471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds adapter_speed = get_adapter_speed(ctrl, hp_slot); 14491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (ctrl->speed != adapter_speed) 14501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (set_controller_speed(ctrl, adapter_speed, hp_slot)) 14511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = WRONG_BUS_FREQUENCY; 14521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* turn off board without attaching to the bus */ 14541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds disable_slot_power (ctrl, hp_slot); 14551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 14571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 14591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq(ctrl); 14601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14616aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_unlock(&ctrl->crit_sect); 14621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 14641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 14651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot = cpqhp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset); 14671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* turn on board and blink green LED */ 14691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("%s: before down\n", __FUNCTION__); 14716aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_lock(&ctrl->crit_sect); 14721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("%s: after down\n", __FUNCTION__); 14731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("%s: before slot_enable\n", __FUNCTION__); 14751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot_enable (ctrl, hp_slot); 14761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("%s: before green_LED_blink\n", __FUNCTION__); 14781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds green_LED_blink (ctrl, hp_slot); 14791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("%s: before amber_LED_blink\n", __FUNCTION__); 14811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds amber_LED_off (ctrl, hp_slot); 14821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("%s: before set_SOGO\n", __FUNCTION__); 14841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 14851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 14871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("%s: before wait_for_ctrl_irq\n", __FUNCTION__); 14881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 14891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("%s: after wait_for_ctrl_irq\n", __FUNCTION__); 14901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("%s: before up\n", __FUNCTION__); 14926aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_unlock(&ctrl->crit_sect); 14931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("%s: after up\n", __FUNCTION__); 14941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for ~1 second because of hot plug spec */ 14961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("%s: before long_delay\n", __FUNCTION__); 14971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds long_delay(1*HZ); 14981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("%s: after long_delay\n", __FUNCTION__); 14991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("%s: func status = %x\n", __FUNCTION__, func->status); 15011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check for a power fault */ 15021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (func->status == 0xFF) { 15031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* power fault occurred, but it was benign */ 15041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_register = 0xFFFFFFFF; 15051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("%s: temp register set to %x by power fault\n", __FUNCTION__, temp_register); 15061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = POWER_FAILURE; 15071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->status = 0; 15081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 15091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Get vendor/device ID u32 */ 15101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ctrl->pci_bus->number = func->bus; 15111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_read_config_dword (ctrl->pci_bus, PCI_DEVFN(func->device, func->function), PCI_VENDOR_ID, &temp_register); 15121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("%s: pci_read_config_dword returns %d\n", __FUNCTION__, rc); 15131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("%s: temp_register is %x\n", __FUNCTION__, temp_register); 15141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc != 0) { 15161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Something's wrong here */ 15171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_register = 0xFFFFFFFF; 15181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("%s: temp register set to %x by error\n", __FUNCTION__, temp_register); 15191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Preset return code. It will be changed later if things go okay. */ 15211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = NO_ADAPTER_PRESENT; 15221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* All F's is an empty slot or an invalid board */ 15251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (temp_register != 0xFFFFFFFF) { /* Check for a board in the slot */ 15261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds res_lists.io_head = ctrl->io_head; 15271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds res_lists.mem_head = ctrl->mem_head; 15281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds res_lists.p_mem_head = ctrl->p_mem_head; 15291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds res_lists.bus_head = ctrl->bus_head; 15301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds res_lists.irqs = NULL; 15311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = configure_new_device(ctrl, func, 0, &res_lists); 15331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("%s: back from configure_new_device\n", __FUNCTION__); 15351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ctrl->io_head = res_lists.io_head; 15361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ctrl->mem_head = res_lists.mem_head; 15371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ctrl->p_mem_head = res_lists.p_mem_head; 15381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ctrl->bus_head = res_lists.bus_head; 15391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_resource_sort_and_combine(&(ctrl->mem_head)); 15411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_resource_sort_and_combine(&(ctrl->p_mem_head)); 15421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_resource_sort_and_combine(&(ctrl->io_head)); 15431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_resource_sort_and_combine(&(ctrl->bus_head)); 15441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) { 15466aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_lock(&ctrl->crit_sect); 15471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds amber_LED_on (ctrl, hp_slot); 15491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds green_LED_off (ctrl, hp_slot); 15501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot_disable (ctrl, hp_slot); 15511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 15531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 15551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 15561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15576aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_unlock(&ctrl->crit_sect); 15581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 15591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 15601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_save_slot_config(ctrl, func); 15611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->status = 0; 15651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->switch_save = 0x10; 15661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->is_a_board = 0x01; 15671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* next, we will instantiate the linux pci_dev structures (with 15691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * appropriate driver notification, if already present) */ 15701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("%s: configure linux pci_dev structure\n", __FUNCTION__); 15711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds index = 0; 15721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds do { 15731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot = cpqhp_slot_find(ctrl->bus, func->device, index++); 15741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (new_slot && !new_slot->pci_dev) { 15751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_configure_device(ctrl, new_slot); 15761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } while (new_slot); 15781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15796aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_lock(&ctrl->crit_sect); 15801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds green_LED_on (ctrl, hp_slot); 15821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 15841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 15861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 15871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15886aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_unlock(&ctrl->crit_sect); 15891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 15906aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_lock(&ctrl->crit_sect); 15911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds amber_LED_on (ctrl, hp_slot); 15931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds green_LED_off (ctrl, hp_slot); 15941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot_disable (ctrl, hp_slot); 15951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 15971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 15991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 16001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16016aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_unlock(&ctrl->crit_sect); 16021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 16041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 16061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 16071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 16101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * remove_board - Turns off slot and LED's 16111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 16121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 16131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic u32 remove_board(struct pci_func * func, u32 replace_flag, struct controller * ctrl) 16141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 16151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int index; 16161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 skip = 0; 16171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 device; 16181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 hp_slot; 16191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 temp_byte; 16201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 rc; 16211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct resource_lists res_lists; 16221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_func *temp_func; 16231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (cpqhp_unconfigure_device(func)) 16251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 16261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds device = func->device; 16281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hp_slot = func->device - ctrl->slot_device_offset; 16301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("In %s, hp_slot = %d\n", __FUNCTION__, hp_slot); 16311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* When we get here, it is safe to change base address registers. 16331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * We will attempt to save the base address register lengths */ 16341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (replace_flag || !ctrl->add_support) 16351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = cpqhp_save_base_addr_length(ctrl, func); 16361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (!func->bus_head && !func->mem_head && 16371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds !func->p_mem_head && !func->io_head) { 16381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Here we check to see if we've saved any of the board's 16391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * resources already. If so, we'll skip the attempt to 16401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * determine what's being used. */ 16411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds index = 0; 16421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_func = cpqhp_slot_find(func->bus, func->device, index++); 16431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (temp_func) { 16441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (temp_func->bus_head || temp_func->mem_head 16451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds || temp_func->p_mem_head || temp_func->io_head) { 16461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds skip = 1; 16471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 16481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_func = cpqhp_slot_find(temp_func->bus, temp_func->device, index++); 16501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!skip) 16531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = cpqhp_save_used_resources(ctrl, func); 16541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Change status to shutdown */ 16561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (func->is_a_board) 16571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->status = 0x01; 16581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->configured = 0; 16591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16606aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_lock(&ctrl->crit_sect); 16611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds green_LED_off (ctrl, hp_slot); 16631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot_disable (ctrl, hp_slot); 16641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 16661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* turn off SERR for slot */ 16681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_byte = readb(ctrl->hpc_reg + SLOT_SERR); 16691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_byte &= ~(0x01 << hp_slot); 16701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writeb(temp_byte, ctrl->hpc_reg + SLOT_SERR); 16711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 16731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 16741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16756aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_unlock(&ctrl->crit_sect); 16761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!replace_flag && ctrl->add_support) { 16781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (func) { 16791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds res_lists.io_head = ctrl->io_head; 16801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds res_lists.mem_head = ctrl->mem_head; 16811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds res_lists.p_mem_head = ctrl->p_mem_head; 16821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds res_lists.bus_head = ctrl->bus_head; 16831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_return_board_resources(func, &res_lists); 16851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ctrl->io_head = res_lists.io_head; 16871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ctrl->mem_head = res_lists.mem_head; 16881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ctrl->p_mem_head = res_lists.p_mem_head; 16891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ctrl->bus_head = res_lists.bus_head; 16901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_resource_sort_and_combine(&(ctrl->mem_head)); 16921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_resource_sort_and_combine(&(ctrl->p_mem_head)); 16931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_resource_sort_and_combine(&(ctrl->io_head)); 16941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_resource_sort_and_combine(&(ctrl->bus_head)); 16951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (is_bridge(func)) { 16971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bridge_slot_remove(func); 16981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else 16991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot_remove(func); 17001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func = cpqhp_slot_find(ctrl->bus, device, 0); 17021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Setup slot structure with entry for empty slot */ 17051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func = cpqhp_slot_create(ctrl->bus); 17061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (func == NULL) 17081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 17091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->bus = ctrl->bus; 17111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->device = device; 17121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->function = 0; 17131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->configured = 0; 17141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->switch_save = 0x10; 17151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->is_a_board = 0; 17161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->p_task_event = NULL; 17171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 17201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 17211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void pushbutton_helper_thread(unsigned long data) 17231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 17241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pushbutton_pending = data; 1725fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig wake_up_process(cpqhp_event_thread); 17261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 17271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* this is the main worker thread */ 17301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int event_thread(void* data) 17311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 17321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct controller *ctrl; 173360ac8f20feb0bba8caee63be3e7ca5801fe16d4cIngo Molnar 17341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (1) { 17351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("!!!!event_thread sleeping\n"); 1736fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig set_current_state(TASK_INTERRUPTIBLE); 1737fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig schedule(); 1738fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig 1739fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig if (kthread_should_stop()) 1740fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig break; 17411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Do stuff here */ 17421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pushbutton_pending) 17431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_pushbutton_thread(pushbutton_pending); 17441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 17451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (ctrl = cpqhp_ctrl_list; ctrl; ctrl=ctrl->next) 17461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds interrupt_event_handler(ctrl); 17471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("event_thread signals exit\n"); 17491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 17501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 17511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsint cpqhp_event_start_thread(void) 17531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 1754fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig cpqhp_event_thread = kthread_run(event_thread, NULL, "phpd_event"); 1755fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig if (IS_ERR(cpqhp_event_thread)) { 17561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds err ("Can't start up our event thread\n"); 1757fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig return PTR_ERR(cpqhp_event_thread); 17581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 1759fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig 17601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 17611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 17621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsvoid cpqhp_event_stop_thread(void) 17651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 1766fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig kthread_stop(cpqhp_event_thread); 17671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 17681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int update_slot_info(struct controller *ctrl, struct slot *slot) 17711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 17721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct hotplug_slot_info *info; 17731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int result; 17741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds info = kmalloc(sizeof(*info), GFP_KERNEL); 17761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!info) 17771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return -ENOMEM; 17781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds info->power_status = get_slot_enabled(ctrl, slot); 17801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds info->attention_status = cpq_get_attention_status(ctrl, slot); 17811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds info->latch_status = cpq_get_latch_status(ctrl, slot); 17821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds info->adapter_status = get_presence_status(ctrl, slot); 17831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds result = pci_hp_change_slot_info(slot->hotplug_slot, info); 17841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree (info); 17851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return result; 17861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 17871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void interrupt_event_handler(struct controller *ctrl) 17891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 17901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int loop = 0; 17911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int change = 1; 17921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_func *func; 17931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 hp_slot; 17941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct slot *p_slot; 17951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (change) { 17971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds change = 0; 17981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (loop = 0; loop < 10; loop++) { 18001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* dbg("loop %d\n", loop); */ 18011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (ctrl->event_queue[loop].event_type != 0) { 18021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hp_slot = ctrl->event_queue[loop].hp_slot; 18031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func = cpqhp_slot_find(ctrl->bus, (hp_slot + ctrl->slot_device_offset), 0); 18051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!func) 18061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 18071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot = cpqhp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset); 18091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!p_slot) 18101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 18111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("hp_slot %d, func %p, p_slot %p\n", 18131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hp_slot, func, p_slot); 18141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (ctrl->event_queue[loop].event_type == INT_BUTTON_PRESS) { 18161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("button pressed\n"); 18171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if (ctrl->event_queue[loop].event_type == 18181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds INT_BUTTON_CANCEL) { 18191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("button cancel\n"); 18201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds del_timer(&p_slot->task_event); 18211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18226aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_lock(&ctrl->crit_sect); 18231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (p_slot->state == BLINKINGOFF_STATE) { 18251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* slot is on */ 18261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("turn on green LED\n"); 18271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds green_LED_on (ctrl, hp_slot); 18281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if (p_slot->state == BLINKINGON_STATE) { 18291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* slot is off */ 18301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("turn off green LED\n"); 18311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds green_LED_off (ctrl, hp_slot); 18321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 18331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds info(msg_button_cancel, p_slot->number); 18351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot->state = STATIC_STATE; 18371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds amber_LED_off (ctrl, hp_slot); 18391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 18411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 18431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 18441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18456aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_unlock(&ctrl->crit_sect); 18461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 18471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /*** button Released (No action on press...) */ 18481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (ctrl->event_queue[loop].event_type == INT_BUTTON_RELEASE) { 18491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("button release\n"); 18501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (is_slot_enabled (ctrl, hp_slot)) { 18521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("slot is on\n"); 18531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot->state = BLINKINGOFF_STATE; 18541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds info(msg_button_off, p_slot->number); 18551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 18561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("slot is off\n"); 18571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot->state = BLINKINGON_STATE; 18581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds info(msg_button_on, p_slot->number); 18591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 18606aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_lock(&ctrl->crit_sect); 18611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("blink green LED and turn off amber\n"); 18631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds amber_LED_off (ctrl, hp_slot); 18651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds green_LED_blink (ctrl, hp_slot); 18661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 18681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 18701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 18711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18726aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_unlock(&ctrl->crit_sect); 18731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds init_timer(&p_slot->task_event); 18741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot->hp_slot = hp_slot; 18751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot->ctrl = ctrl; 18761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* p_slot->physical_slot = physical_slot; */ 18771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot->task_event.expires = jiffies + 5 * HZ; /* 5 second delay */ 18781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot->task_event.function = pushbutton_helper_thread; 18791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot->task_event.data = (u32) p_slot; 18801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("add_timer p_slot = %p\n", p_slot); 18821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds add_timer(&p_slot->task_event); 18831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 18841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /***********POWER FAULT */ 18851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (ctrl->event_queue[loop].event_type == INT_POWER_FAULT) { 18861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("power fault\n"); 18871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 18881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* refresh notification */ 18891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (p_slot) 18901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds update_slot_info(ctrl, p_slot); 18911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 18921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ctrl->event_queue[loop].event_type = 0; 18941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds change = 1; 18961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 18971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } /* End of FOR loop */ 18981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 18991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 19011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 19021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 19051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * cpqhp_pushbutton_thread 19061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 19071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Scheduled procedure to handle blocking stuff for the pushbuttons 19081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Handles all pending events and exits. 19091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 19101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 19111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsvoid cpqhp_pushbutton_thread(unsigned long slot) 19121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 19131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 hp_slot; 19141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 device; 19151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_func *func; 19161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct slot *p_slot = (struct slot *) slot; 19171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct controller *ctrl = (struct controller *) p_slot->ctrl; 19181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pushbutton_pending = 0; 19201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hp_slot = p_slot->hp_slot; 19211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds device = p_slot->device; 19231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (is_slot_enabled(ctrl, hp_slot)) { 19251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot->state = POWEROFF_STATE; 19261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* power Down board */ 19271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func = cpqhp_slot_find(p_slot->bus, p_slot->device, 0); 19281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("In power_down_board, func = %p, ctrl = %p\n", func, ctrl); 19291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!func) { 19301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("Error! func NULL in %s\n", __FUNCTION__); 19311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return ; 19321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 19331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 193400395410885cac96015850426bf697423a3ec9dcAdrian Bunk if (cpqhp_process_SS(ctrl, func) != 0) { 193500395410885cac96015850426bf697423a3ec9dcAdrian Bunk amber_LED_on(ctrl, hp_slot); 193600395410885cac96015850426bf697423a3ec9dcAdrian Bunk green_LED_on(ctrl, hp_slot); 19371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 193800395410885cac96015850426bf697423a3ec9dcAdrian Bunk set_SOGO(ctrl); 193900395410885cac96015850426bf697423a3ec9dcAdrian Bunk 194000395410885cac96015850426bf697423a3ec9dcAdrian Bunk /* Wait for SOBS to be unset */ 194100395410885cac96015850426bf697423a3ec9dcAdrian Bunk wait_for_ctrl_irq(ctrl); 19421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 19431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot->state = STATIC_STATE; 19451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 19461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot->state = POWERON_STATE; 19471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* slot is off */ 19481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func = cpqhp_slot_find(p_slot->bus, p_slot->device, 0); 19501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("In add_board, func = %p, ctrl = %p\n", func, ctrl); 19511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!func) { 19521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("Error! func NULL in %s\n", __FUNCTION__); 19531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return ; 19541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 19551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (func != NULL && ctrl != NULL) { 19571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (cpqhp_process_SI(ctrl, func) != 0) { 19581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds amber_LED_on(ctrl, hp_slot); 19591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds green_LED_off(ctrl, hp_slot); 19601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 19621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 19641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 19651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 19661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 19671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot->state = STATIC_STATE; 19691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 19701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 19721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 19731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsint cpqhp_process_SI(struct controller *ctrl, struct pci_func *func) 19761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 19771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 device, hp_slot; 19781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u16 temp_word; 19791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 tempdword; 19801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int rc; 19811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct slot* p_slot; 19821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int physical_slot = 0; 19831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tempdword = 0; 19851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds device = func->device; 19871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hp_slot = device - ctrl->slot_device_offset; 19881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot = cpqhp_find_slot(ctrl, device); 19891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (p_slot) 19901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds physical_slot = p_slot->number; 19911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check to see if the interlock is closed */ 19931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tempdword = readl(ctrl->hpc_reg + INT_INPUT_CLEAR); 19941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (tempdword & (0x01 << hp_slot)) { 19961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 19971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 19981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (func->is_a_board) { 20001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = board_replaced(func, ctrl); 20011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 20021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* add board */ 20031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot_remove(func); 20041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func = cpqhp_slot_create(ctrl->bus); 20061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (func == NULL) 20071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 20081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->bus = ctrl->bus; 20101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->device = device; 20111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->function = 0; 20121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->configured = 0; 20131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->is_a_board = 1; 20141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* We have to save the presence info for these slots */ 20161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_word = ctrl->ctrl_int_comp >> 16; 20171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->presence_save = (temp_word >> hp_slot) & 0x01; 20181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->presence_save |= (temp_word >> (hp_slot + 7)) & 0x02; 20191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (ctrl->ctrl_int_comp & (0x1L << hp_slot)) { 20211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->switch_save = 0; 20221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 20231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->switch_save = 0x10; 20241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 20251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = board_added(func, ctrl); 20271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) { 20281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (is_bridge(func)) { 20291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bridge_slot_remove(func); 20301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else 20311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot_remove(func); 20321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Setup slot structure with entry for empty slot */ 20341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func = cpqhp_slot_create(ctrl->bus); 20351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (func == NULL) 20371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 20381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->bus = ctrl->bus; 20401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->device = device; 20411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->function = 0; 20421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->configured = 0; 20431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->is_a_board = 0; 20441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* We have to save the presence info for these slots */ 20461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_word = ctrl->ctrl_int_comp >> 16; 20471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->presence_save = (temp_word >> hp_slot) & 0x01; 20481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->presence_save |= 20491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (temp_word >> (hp_slot + 7)) & 0x02; 20501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (ctrl->ctrl_int_comp & (0x1L << hp_slot)) { 20521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->switch_save = 0; 20531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 20541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->switch_save = 0x10; 20551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 20561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 20571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 20581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) { 20601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("%s: rc = %d\n", __FUNCTION__, rc); 20611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 20621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (p_slot) 20641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds update_slot_info(ctrl, p_slot); 20651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 20671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 20681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsint cpqhp_process_SS(struct controller *ctrl, struct pci_func *func) 20711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 20721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 device, class_code, header_type, BCR; 20731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 index = 0; 20741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 replace_flag; 20751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 rc = 0; 20761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int devfn; 20771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct slot* p_slot; 20781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_bus *pci_bus = ctrl->pci_bus; 20791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int physical_slot=0; 20801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds device = func->device; 20821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func = cpqhp_slot_find(ctrl->bus, device, index++); 20831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot = cpqhp_find_slot(ctrl, device); 20841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (p_slot) { 20851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds physical_slot = p_slot->number; 20861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 20871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Make sure there are no video controllers here */ 20891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (func && !rc) { 20901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_bus->number = func->bus; 20911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds devfn = PCI_DEVFN(func->device, func->function); 20921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check the Class Code */ 20941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_read_config_byte (pci_bus, devfn, 0x0B, &class_code); 20951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 20961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 20971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (class_code == PCI_BASE_CLASS_DISPLAY) { 20991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Display/Video adapter (not supported) */ 21001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = REMOVE_NOT_SUPPORTED; 21011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 21021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* See if it's a bridge */ 21031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_read_config_byte (pci_bus, devfn, PCI_HEADER_TYPE, &header_type); 21041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 21051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 21061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If it's a bridge, check the VGA Enable bit */ 21081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((header_type & 0x7F) == PCI_HEADER_TYPE_BRIDGE) { 21091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_read_config_byte (pci_bus, devfn, PCI_BRIDGE_CONTROL, &BCR); 21101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 21111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 21121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If the VGA Enable bit is set, remove isn't 21141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * supported */ 21151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (BCR & PCI_BRIDGE_CTL_VGA) { 21161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = REMOVE_NOT_SUPPORTED; 21171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 21181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 21191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 21201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func = cpqhp_slot_find(ctrl->bus, device, index++); 21221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 21231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func = cpqhp_slot_find(ctrl->bus, device, 0); 21251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((func != NULL) && !rc) { 21261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* FIXME: Replace flag should be passed into process_SS */ 21271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds replace_flag = !(ctrl->add_support); 21281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = remove_board(func, replace_flag, ctrl); 21291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if (!rc) { 21301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = 1; 21311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 21321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (p_slot) 21341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds update_slot_info(ctrl, p_slot); 21351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 21371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 21381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 21401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * switch_leds: switch the leds, go from one site to the other. 21411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @ctrl: controller to use 21421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @num_of_slots: number of slots to use 21431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @direction: 1 to start from the left side, 0 to start right. 21441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 21451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void switch_leds(struct controller *ctrl, const int num_of_slots, 21461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 *work_LED, const int direction) 21471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 21481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int loop; 21491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (loop = 0; loop < num_of_slots; loop++) { 21511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (direction) 21521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *work_LED = *work_LED >> 1; 21531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 21541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *work_LED = *work_LED << 1; 21551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(*work_LED, ctrl->hpc_reg + LED_CONTROL); 21561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 21581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOGO interrupt */ 21601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq(ctrl); 21611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Get ready for next iteration */ 21631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds long_delay((2*HZ)/10); 21641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 21651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 21661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 21681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * hardware_test - runs hardware tests 21691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 21701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * For hot plug ctrl folks to play with. 21711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * test_num is the number written to the "test" file in sysfs 21721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 21731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 21741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsint cpqhp_hardware_test(struct controller *ctrl, int test_num) 21751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 21761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 save_LED; 21771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 work_LED; 21781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int loop; 21791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int num_of_slots; 21801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds num_of_slots = readb(ctrl->hpc_reg + SLOT_MASK) & 0x0f; 21821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds switch (test_num) { 21841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 1: 21851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Do stuff here! */ 21861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Do that funky LED thing */ 21881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* so we can restore them later */ 21891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds save_LED = readl(ctrl->hpc_reg + LED_CONTROL); 21901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds work_LED = 0x01010101; 21911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds switch_leds(ctrl, num_of_slots, &work_LED, 0); 21921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds switch_leds(ctrl, num_of_slots, &work_LED, 1); 21931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds switch_leds(ctrl, num_of_slots, &work_LED, 0); 21941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds switch_leds(ctrl, num_of_slots, &work_LED, 1); 21951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds work_LED = 0x01010000; 21971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(work_LED, ctrl->hpc_reg + LED_CONTROL); 21981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds switch_leds(ctrl, num_of_slots, &work_LED, 0); 21991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds switch_leds(ctrl, num_of_slots, &work_LED, 1); 22001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds work_LED = 0x00000101; 22011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(work_LED, ctrl->hpc_reg + LED_CONTROL); 22021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds switch_leds(ctrl, num_of_slots, &work_LED, 0); 22031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds switch_leds(ctrl, num_of_slots, &work_LED, 1); 22041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 22051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds work_LED = 0x01010000; 22061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(work_LED, ctrl->hpc_reg + LED_CONTROL); 22071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (loop = 0; loop < num_of_slots; loop++) { 22081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 22091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 22101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOGO interrupt */ 22111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 22121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 22131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Get ready for next iteration */ 22141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds long_delay((3*HZ)/10); 22151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds work_LED = work_LED >> 16; 22161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(work_LED, ctrl->hpc_reg + LED_CONTROL); 22171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 22181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 22191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 22201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOGO interrupt */ 22211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 22221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 22231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Get ready for next iteration */ 22241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds long_delay((3*HZ)/10); 22251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds work_LED = work_LED << 16; 22261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(work_LED, ctrl->hpc_reg + LED_CONTROL); 22271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds work_LED = work_LED << 1; 22281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(work_LED, ctrl->hpc_reg + LED_CONTROL); 22291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 22301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 22311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* put it back the way it was */ 22321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(save_LED, ctrl->hpc_reg + LED_CONTROL); 22331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 22341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 22351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 22361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 22371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 22381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 22391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 2: 22401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Do other stuff here! */ 22411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 22421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 3: 22431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* and more... */ 22441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 22451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 22461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 22471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 22481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 22491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 22501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 22511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * configure_new_device - Configures the PCI header information of one board. 22521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 22531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @ctrl: pointer to controller structure 22541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @func: pointer to function structure 22551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @behind_bridge: 1 if this is a recursive call, 0 if not 22561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @resources: pointer to set of resource lists 22571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 22581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Returns 0 if success 22591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 22601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 22611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic u32 configure_new_device(struct controller * ctrl, struct pci_func * func, 22621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 behind_bridge, struct resource_lists * resources) 22631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 22641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 temp_byte, function, max_functions, stop_it; 22651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int rc; 22661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 ID; 22671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_func *new_slot; 22681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int index; 22691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 22701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot = func; 22711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 22721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("%s\n", __FUNCTION__); 22731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check for Multi-function device */ 22741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ctrl->pci_bus->number = func->bus; 22751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_read_config_byte (ctrl->pci_bus, PCI_DEVFN(func->device, func->function), 0x0E, &temp_byte); 22761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) { 22771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("%s: rc = %d\n", __FUNCTION__, rc); 22781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 22791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 22801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 22811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (temp_byte & 0x80) /* Multi-function device */ 22821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds max_functions = 8; 22831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 22841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds max_functions = 1; 22851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 22861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds function = 0; 22871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 22881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds do { 22891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = configure_new_function(ctrl, new_slot, behind_bridge, resources); 22901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 22911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) { 22921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("configure_new_function failed %d\n",rc); 22931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds index = 0; 22941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 22951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (new_slot) { 22961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot = cpqhp_slot_find(new_slot->bus, new_slot->device, index++); 22971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 22981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (new_slot) 22991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_return_board_resources(new_slot, resources); 23001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 23011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 23031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 23041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds function++; 23061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds stop_it = 0; 23081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* The following loop skips to the next present function 23101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * and creates a board structure */ 23111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while ((function < max_functions) && (!stop_it)) { 23131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_bus_read_config_dword (ctrl->pci_bus, PCI_DEVFN(func->device, function), 0x00, &ID); 23141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (ID == 0xFFFFFFFF) { /* There's nothing there. */ 23161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds function++; 23171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { /* There's something there */ 23181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Setup slot structure. */ 23191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot = cpqhp_slot_create(func->bus); 23201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (new_slot == NULL) 23221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 23231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot->bus = func->bus; 23251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot->device = func->device; 23261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot->function = function; 23271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot->is_a_board = 1; 23281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot->status = 0; 23291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds stop_it++; 23311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 23321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 23331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } while (function < max_functions); 23351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("returning from configure_new_device\n"); 23361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 23381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 23391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* 23421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds Configuration logic that involves the hotplug data structures and 23431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds their bookkeeping 23441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 23451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 23481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * configure_new_function - Configures the PCI header information of one device 23491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 23501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @ctrl: pointer to controller structure 23511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @func: pointer to function structure 23521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @behind_bridge: 1 if this is a recursive call, 0 if not 23531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @resources: pointer to set of resource lists 23541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 23551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Calls itself recursively for bridged devices. 23561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Returns 0 if success 23571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 23581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 23591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int configure_new_function(struct controller *ctrl, struct pci_func *func, 23601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 behind_bridge, 23611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct resource_lists *resources) 23621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 23631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int cloop; 23641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 IRQ = 0; 23651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 temp_byte; 23661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 device; 23671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 class_code; 23681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u16 command; 23691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u16 temp_word; 23701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 temp_dword; 23711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 rc; 23721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 temp_register; 23731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 base; 23741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 ID; 23751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int devfn; 23761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *mem_node; 23771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *p_mem_node; 23781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *io_node; 23791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *bus_node; 23801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *hold_mem_node; 23811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *hold_p_mem_node; 23821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *hold_IO_node; 23831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *hold_bus_node; 23841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct irq_mapping irqs; 23851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_func *new_slot; 23861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_bus *pci_bus; 23871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct resource_lists temp_resources; 23881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_bus = ctrl->pci_bus; 23901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_bus->number = func->bus; 23911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds devfn = PCI_DEVFN(func->device, func->function); 23921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check for Bridge */ 23941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_read_config_byte(pci_bus, devfn, PCI_HEADER_TYPE, &temp_byte); 23951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 23961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 23971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((temp_byte & 0x7F) == PCI_HEADER_TYPE_BRIDGE) { /* PCI-PCI Bridge */ 23991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* set Primary bus */ 24001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("set Primary bus = %d\n", func->bus); 24011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_PRIMARY_BUS, func->bus); 24021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 24031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 24041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 24051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* find range of busses to use */ 24061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("find ranges of buses to use\n"); 24071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bus_node = get_max_resource(&(resources->bus_head), 1); 24081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 24091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If we don't have any busses to allocate, we can't continue */ 24101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!bus_node) 24111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return -ENOMEM; 24121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 24131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* set Secondary bus */ 24141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_byte = bus_node->base; 24151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("set Secondary bus = %d\n", bus_node->base); 24161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_SECONDARY_BUS, temp_byte); 24171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 24181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 24191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 24201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* set subordinate bus */ 24211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_byte = bus_node->base + bus_node->length - 1; 24221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("set subordinate bus = %d\n", bus_node->base + bus_node->length - 1); 24231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_SUBORDINATE_BUS, temp_byte); 24241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 24251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 24261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 24271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* set subordinate Latency Timer and base Latency Timer */ 24281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_byte = 0x40; 24291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_SEC_LATENCY_TIMER, temp_byte); 24301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 24311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 24321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_LATENCY_TIMER, temp_byte); 24331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 24341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 24351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 24361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* set Cache Line size */ 24371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_byte = 0x08; 24381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_CACHE_LINE_SIZE, temp_byte); 24391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 24401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 24411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 24421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Setup the IO, memory, and prefetchable windows */ 24431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds io_node = get_max_resource(&(resources->io_head), 0x1000); 24441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!io_node) 24451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return -ENOMEM; 24461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mem_node = get_max_resource(&(resources->mem_head), 0x100000); 24471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!mem_node) 24481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return -ENOMEM; 24491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_mem_node = get_max_resource(&(resources->p_mem_head), 0x100000); 24501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!p_mem_node) 24511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return -ENOMEM; 24521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("Setup the IO, memory, and prefetchable windows\n"); 24531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("io_node\n"); 24541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("(base, len, next) (%x, %x, %p)\n", io_node->base, 24551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds io_node->length, io_node->next); 24561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("mem_node\n"); 24571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("(base, len, next) (%x, %x, %p)\n", mem_node->base, 24581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mem_node->length, mem_node->next); 24591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("p_mem_node\n"); 24601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("(base, len, next) (%x, %x, %p)\n", p_mem_node->base, 24611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_mem_node->length, p_mem_node->next); 24621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 24631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* set up the IRQ info */ 24641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!resources->irqs) { 24651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds irqs.barber_pole = 0; 24661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds irqs.interrupt[0] = 0; 24671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds irqs.interrupt[1] = 0; 24681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds irqs.interrupt[2] = 0; 24691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds irqs.interrupt[3] = 0; 24701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds irqs.valid_INT = 0; 24711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 24721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds irqs.barber_pole = resources->irqs->barber_pole; 24731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds irqs.interrupt[0] = resources->irqs->interrupt[0]; 24741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds irqs.interrupt[1] = resources->irqs->interrupt[1]; 24751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds irqs.interrupt[2] = resources->irqs->interrupt[2]; 24761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds irqs.interrupt[3] = resources->irqs->interrupt[3]; 24771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds irqs.valid_INT = resources->irqs->valid_INT; 24781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 24791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 24801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* set up resource lists that are now aligned on top and bottom 24811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * for anything behind the bridge. */ 24821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_resources.bus_head = bus_node; 24831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_resources.io_head = io_node; 24841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_resources.mem_head = mem_node; 24851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_resources.p_mem_head = p_mem_node; 24861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_resources.irqs = &irqs; 24871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 24881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Make copies of the nodes we are going to pass down so that 24891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * if there is a problem,we can just use these to free resources */ 24901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_bus_node = kmalloc(sizeof(*hold_bus_node), GFP_KERNEL); 24911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_IO_node = kmalloc(sizeof(*hold_IO_node), GFP_KERNEL); 24921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_mem_node = kmalloc(sizeof(*hold_mem_node), GFP_KERNEL); 24931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_p_mem_node = kmalloc(sizeof(*hold_p_mem_node), GFP_KERNEL); 24941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 24951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!hold_bus_node || !hold_IO_node || !hold_mem_node || !hold_p_mem_node) { 24961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree(hold_bus_node); 24971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree(hold_IO_node); 24981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree(hold_mem_node); 24991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree(hold_p_mem_node); 25001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 25021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 25031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds memcpy(hold_bus_node, bus_node, sizeof(struct pci_resource)); 25051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bus_node->base += 1; 25071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bus_node->length -= 1; 25081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bus_node->next = NULL; 25091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If we have IO resources copy them and fill in the bridge's 25111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * IO range registers */ 25121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (io_node) { 25131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds memcpy(hold_IO_node, io_node, sizeof(struct pci_resource)); 25141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds io_node->next = NULL; 25151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* set IO base and Limit registers */ 25171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_byte = io_node->base >> 8; 25181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_IO_BASE, temp_byte); 25191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_byte = (io_node->base + io_node->length - 1) >> 8; 25211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_IO_LIMIT, temp_byte); 25221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 25231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree(hold_IO_node); 25241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_IO_node = NULL; 25251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 25261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If we have memory resources copy them and fill in the 25281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * bridge's memory range registers. Otherwise, fill in the 25291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * range registers with values that disable them. */ 25301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (mem_node) { 25311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds memcpy(hold_mem_node, mem_node, sizeof(struct pci_resource)); 25321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mem_node->next = NULL; 25331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* set Mem base and Limit registers */ 25351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_word = mem_node->base >> 16; 25361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_word(pci_bus, devfn, PCI_MEMORY_BASE, temp_word); 25371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_word = (mem_node->base + mem_node->length - 1) >> 16; 25391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_word(pci_bus, devfn, PCI_MEMORY_LIMIT, temp_word); 25401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 25411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_word = 0xFFFF; 25421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_word(pci_bus, devfn, PCI_MEMORY_BASE, temp_word); 25431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_word = 0x0000; 25451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_word(pci_bus, devfn, PCI_MEMORY_LIMIT, temp_word); 25461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree(hold_mem_node); 25481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_mem_node = NULL; 25491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 25501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25512555f7bdd3b0db47f6e1d7bb887981654e2261b3Adrian Bunk memcpy(hold_p_mem_node, p_mem_node, sizeof(struct pci_resource)); 25522555f7bdd3b0db47f6e1d7bb887981654e2261b3Adrian Bunk p_mem_node->next = NULL; 25531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25542555f7bdd3b0db47f6e1d7bb887981654e2261b3Adrian Bunk /* set Pre Mem base and Limit registers */ 25552555f7bdd3b0db47f6e1d7bb887981654e2261b3Adrian Bunk temp_word = p_mem_node->base >> 16; 25562555f7bdd3b0db47f6e1d7bb887981654e2261b3Adrian Bunk rc = pci_bus_write_config_word (pci_bus, devfn, PCI_PREF_MEMORY_BASE, temp_word); 25571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25582555f7bdd3b0db47f6e1d7bb887981654e2261b3Adrian Bunk temp_word = (p_mem_node->base + p_mem_node->length - 1) >> 16; 25592555f7bdd3b0db47f6e1d7bb887981654e2261b3Adrian Bunk rc = pci_bus_write_config_word (pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, temp_word); 25601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Adjust this to compensate for extra adjustment in first loop */ 25621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds irqs.barber_pole--; 25631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = 0; 25651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Here we actually find the devices and configure them */ 25671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (device = 0; (device <= 0x1F) && !rc; device++) { 25681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds irqs.barber_pole = (irqs.barber_pole + 1) & 0x03; 25691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ID = 0xFFFFFFFF; 25711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_bus->number = hold_bus_node->base; 25721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_bus_read_config_dword (pci_bus, PCI_DEVFN(device, 0), 0x00, &ID); 25731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_bus->number = func->bus; 25741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (ID != 0xFFFFFFFF) { /* device present */ 25761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Setup slot structure. */ 25771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot = cpqhp_slot_create(hold_bus_node->base); 25781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (new_slot == NULL) { 25801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = -ENOMEM; 25811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 25821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 25831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot->bus = hold_bus_node->base; 25851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot->device = device; 25861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot->function = 0; 25871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot->is_a_board = 1; 25881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot->status = 0; 25891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = configure_new_device(ctrl, new_slot, 1, &temp_resources); 25911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("configure_new_device rc=0x%x\n",rc); 25921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } /* End of IF (device in slot?) */ 25931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } /* End of FOR loop */ 25941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 25961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto free_and_out; 25971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* save the interrupt routing information */ 25981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (resources->irqs) { 25991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds resources->irqs->interrupt[0] = irqs.interrupt[0]; 26001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds resources->irqs->interrupt[1] = irqs.interrupt[1]; 26011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds resources->irqs->interrupt[2] = irqs.interrupt[2]; 26021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds resources->irqs->interrupt[3] = irqs.interrupt[3]; 26031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds resources->irqs->valid_INT = irqs.valid_INT; 26041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if (!behind_bridge) { 26051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* We need to hook up the interrupts here */ 26061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (cloop = 0; cloop < 4; cloop++) { 26071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (irqs.valid_INT & (0x01 << cloop)) { 26081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = cpqhp_set_irq(func->bus, func->device, 26091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 0x0A + cloop, irqs.interrupt[cloop]); 26101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 26111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto free_and_out; 26121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 26131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } /* end of for loop */ 26141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 26151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Return unused bus resources 26161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * First use the temporary node to store information for 26171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * the board */ 26181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (hold_bus_node && bus_node && temp_resources.bus_head) { 26191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_bus_node->length = bus_node->base - hold_bus_node->base; 26201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 26211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_bus_node->next = func->bus_head; 26221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->bus_head = hold_bus_node; 26231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 26241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_byte = temp_resources.bus_head->base - 1; 26251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 26261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* set subordinate bus */ 26271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_byte (pci_bus, devfn, PCI_SUBORDINATE_BUS, temp_byte); 26281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 26291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (temp_resources.bus_head->length == 0) { 26301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree(temp_resources.bus_head); 26311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_resources.bus_head = NULL; 26321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 26331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return_resource(&(resources->bus_head), temp_resources.bus_head); 26341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 26351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 26361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 26371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If we have IO space available and there is some left, 26381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * return the unused portion */ 26391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (hold_IO_node && temp_resources.io_head) { 26401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds io_node = do_pre_bridge_resource_split(&(temp_resources.io_head), 26411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds &hold_IO_node, 0x1000); 26421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 26431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check if we were able to split something off */ 26441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (io_node) { 26451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_IO_node->base = io_node->base + io_node->length; 26461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 26471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_byte = (hold_IO_node->base) >> 8; 26481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_word (pci_bus, devfn, PCI_IO_BASE, temp_byte); 26491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 26501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return_resource(&(resources->io_head), io_node); 26511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 26521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 26531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds io_node = do_bridge_resource_split(&(temp_resources.io_head), 0x1000); 26541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 26551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check if we were able to split something off */ 26561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (io_node) { 26571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* First use the temporary node to store 26581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * information for the board */ 26591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_IO_node->length = io_node->base - hold_IO_node->base; 26601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 26611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If we used any, add it to the board's list */ 26621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (hold_IO_node->length) { 26631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_IO_node->next = func->io_head; 26641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->io_head = hold_IO_node; 26651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 26661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_byte = (io_node->base - 1) >> 8; 26671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_byte (pci_bus, devfn, PCI_IO_LIMIT, temp_byte); 26681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 26691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return_resource(&(resources->io_head), io_node); 26701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 26711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* it doesn't need any IO */ 26721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_word = 0x0000; 26731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_word (pci_bus, devfn, PCI_IO_LIMIT, temp_word); 26741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 26751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return_resource(&(resources->io_head), io_node); 26761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree(hold_IO_node); 26771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 26781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 26791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* it used most of the range */ 26801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_IO_node->next = func->io_head; 26811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->io_head = hold_IO_node; 26821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 26831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if (hold_IO_node) { 26841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* it used the whole range */ 26851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_IO_node->next = func->io_head; 26861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->io_head = hold_IO_node; 26871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 26881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If we have memory space available and there is some left, 26891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * return the unused portion */ 26901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (hold_mem_node && temp_resources.mem_head) { 26911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mem_node = do_pre_bridge_resource_split(&(temp_resources. mem_head), 26921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds &hold_mem_node, 0x100000); 26931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 26941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check if we were able to split something off */ 26951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (mem_node) { 26961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_mem_node->base = mem_node->base + mem_node->length; 26971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 26981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_word = (hold_mem_node->base) >> 16; 26991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_word (pci_bus, devfn, PCI_MEMORY_BASE, temp_word); 27001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return_resource(&(resources->mem_head), mem_node); 27021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 27031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mem_node = do_bridge_resource_split(&(temp_resources.mem_head), 0x100000); 27051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check if we were able to split something off */ 27071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (mem_node) { 27081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* First use the temporary node to store 27091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * information for the board */ 27101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_mem_node->length = mem_node->base - hold_mem_node->base; 27111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (hold_mem_node->length) { 27131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_mem_node->next = func->mem_head; 27141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->mem_head = hold_mem_node; 27151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* configure end address */ 27171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_word = (mem_node->base - 1) >> 16; 27181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_word (pci_bus, devfn, PCI_MEMORY_LIMIT, temp_word); 27191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Return unused resources to the pool */ 27211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return_resource(&(resources->mem_head), mem_node); 27221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 27231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* it doesn't need any Mem */ 27241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_word = 0x0000; 27251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_word (pci_bus, devfn, PCI_MEMORY_LIMIT, temp_word); 27261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return_resource(&(resources->mem_head), mem_node); 27281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree(hold_mem_node); 27291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 27301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 27311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* it used most of the range */ 27321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_mem_node->next = func->mem_head; 27331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->mem_head = hold_mem_node; 27341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 27351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if (hold_mem_node) { 27361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* it used the whole range */ 27371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_mem_node->next = func->mem_head; 27381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->mem_head = hold_mem_node; 27391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 27401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If we have prefetchable memory space available and there 27411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * is some left at the end, return the unused portion */ 27421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (hold_p_mem_node && temp_resources.p_mem_head) { 27431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_mem_node = do_pre_bridge_resource_split(&(temp_resources.p_mem_head), 27441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds &hold_p_mem_node, 0x100000); 27451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check if we were able to split something off */ 27471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (p_mem_node) { 27481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_p_mem_node->base = p_mem_node->base + p_mem_node->length; 27491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_word = (hold_p_mem_node->base) >> 16; 27511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_word (pci_bus, devfn, PCI_PREF_MEMORY_BASE, temp_word); 27521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return_resource(&(resources->p_mem_head), p_mem_node); 27541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 27551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_mem_node = do_bridge_resource_split(&(temp_resources.p_mem_head), 0x100000); 27571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check if we were able to split something off */ 27591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (p_mem_node) { 27601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* First use the temporary node to store 27611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * information for the board */ 27621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_p_mem_node->length = p_mem_node->base - hold_p_mem_node->base; 27631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If we used any, add it to the board's list */ 27651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (hold_p_mem_node->length) { 27661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_p_mem_node->next = func->p_mem_head; 27671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->p_mem_head = hold_p_mem_node; 27681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_word = (p_mem_node->base - 1) >> 16; 27701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_word (pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, temp_word); 27711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return_resource(&(resources->p_mem_head), p_mem_node); 27731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 27741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* it doesn't need any PMem */ 27751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_word = 0x0000; 27761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_word (pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, temp_word); 27771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return_resource(&(resources->p_mem_head), p_mem_node); 27791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree(hold_p_mem_node); 27801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 27811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 27821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* it used the most of the range */ 27831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_p_mem_node->next = func->p_mem_head; 27841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->p_mem_head = hold_p_mem_node; 27851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 27861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if (hold_p_mem_node) { 27871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* it used the whole range */ 27881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_p_mem_node->next = func->p_mem_head; 27891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->p_mem_head = hold_p_mem_node; 27901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 27911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* We should be configuring an IRQ and the bridge's base address 27921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * registers if it needs them. Although we have never seen such 27931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * a device */ 27941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* enable card */ 27961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds command = 0x0157; /* = PCI_COMMAND_IO | 27971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * PCI_COMMAND_MEMORY | 27981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * PCI_COMMAND_MASTER | 27991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * PCI_COMMAND_INVALIDATE | 28001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * PCI_COMMAND_PARITY | 28011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * PCI_COMMAND_SERR */ 28021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_word (pci_bus, devfn, PCI_COMMAND, command); 28031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* set Bridge Control Register */ 28051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds command = 0x07; /* = PCI_BRIDGE_CTL_PARITY | 28061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * PCI_BRIDGE_CTL_SERR | 28071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * PCI_BRIDGE_CTL_NO_ISA */ 28081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_word (pci_bus, devfn, PCI_BRIDGE_CONTROL, command); 28091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if ((temp_byte & 0x7F) == PCI_HEADER_TYPE_NORMAL) { 28101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Standard device */ 28111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_read_config_byte (pci_bus, devfn, 0x0B, &class_code); 28121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (class_code == PCI_BASE_CLASS_DISPLAY) { 28141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Display (video) adapter (not supported) */ 28151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return DEVICE_TYPE_NOT_SUPPORTED; 28161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 28171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Figure out IO and memory needs */ 28181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (cloop = 0x10; cloop <= 0x24; cloop += 4) { 28191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_register = 0xFFFFFFFF; 28201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("CND: bus=%d, devfn=%d, offset=%d\n", pci_bus->number, devfn, cloop); 28221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_dword (pci_bus, devfn, cloop, temp_register); 28231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_read_config_dword (pci_bus, devfn, cloop, &temp_register); 28251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("CND: base = 0x%x\n", temp_register); 28261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (temp_register) { /* If this register is implemented */ 28281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((temp_register & 0x03L) == 0x01) { 28291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Map IO */ 28301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* set base = amount of IO space */ 28321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds base = temp_register & 0xFFFFFFFC; 28331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds base = ~base + 1; 28341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("CND: length = 0x%x\n", base); 28361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds io_node = get_io_resource(&(resources->io_head), base); 28371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("Got io_node start = %8.8x, length = %8.8x next (%p)\n", 28381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds io_node->base, io_node->length, io_node->next); 28391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("func (%p) io_head (%p)\n", func, func->io_head); 28401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* allocate the resource to the board */ 28421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (io_node) { 28431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds base = io_node->base; 28441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds io_node->next = func->io_head; 28461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->io_head = io_node; 28471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else 28481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return -ENOMEM; 28491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if ((temp_register & 0x0BL) == 0x08) { 28501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Map prefetchable memory */ 28511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds base = temp_register & 0xFFFFFFF0; 28521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds base = ~base + 1; 28531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("CND: length = 0x%x\n", base); 28551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_mem_node = get_resource(&(resources->p_mem_head), base); 28561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* allocate the resource to the board */ 28581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (p_mem_node) { 28591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds base = p_mem_node->base; 28601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_mem_node->next = func->p_mem_head; 28621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->p_mem_head = p_mem_node; 28631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else 28641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return -ENOMEM; 28651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if ((temp_register & 0x0BL) == 0x00) { 28661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Map memory */ 28671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds base = temp_register & 0xFFFFFFF0; 28681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds base = ~base + 1; 28691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("CND: length = 0x%x\n", base); 28711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mem_node = get_resource(&(resources->mem_head), base); 28721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* allocate the resource to the board */ 28741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (mem_node) { 28751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds base = mem_node->base; 28761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mem_node->next = func->mem_head; 28781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->mem_head = mem_node; 28791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else 28801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return -ENOMEM; 28811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if ((temp_register & 0x0BL) == 0x04) { 28821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Map memory */ 28831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds base = temp_register & 0xFFFFFFF0; 28841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds base = ~base + 1; 28851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("CND: length = 0x%x\n", base); 28871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mem_node = get_resource(&(resources->mem_head), base); 28881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* allocate the resource to the board */ 28901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (mem_node) { 28911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds base = mem_node->base; 28921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mem_node->next = func->mem_head; 28941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->mem_head = mem_node; 28951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else 28961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return -ENOMEM; 28971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if ((temp_register & 0x0BL) == 0x06) { 28981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Those bits are reserved, we can't handle this */ 28991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 29001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 29011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Requesting space below 1M */ 29021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NOT_ENOUGH_RESOURCES; 29031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 29041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 29051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_dword(pci_bus, devfn, cloop, base); 29061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 29071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check for 64-bit base */ 29081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((temp_register & 0x07L) == 0x04) { 29091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cloop += 4; 29101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 29111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Upper 32 bits of address always zero 29121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * on today's systems */ 29131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* FIXME this is probably not true on 29141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Alpha and ia64??? */ 29151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds base = 0; 29161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_dword(pci_bus, devfn, cloop, base); 29171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 29181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 29191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } /* End of base register loop */ 29201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (cpqhp_legacy_mode) { 29211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Figure out which interrupt pin this function uses */ 29221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_read_config_byte (pci_bus, devfn, 29231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds PCI_INTERRUPT_PIN, &temp_byte); 29241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 29251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If this function needs an interrupt and we are behind 29261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * a bridge and the pin is tied to something that's 29271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * alread mapped, set this one the same */ 29281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (temp_byte && resources->irqs && 29291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (resources->irqs->valid_INT & 29301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (0x01 << ((temp_byte + resources->irqs->barber_pole - 1) & 0x03)))) { 29311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* We have to share with something already set up */ 29321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds IRQ = resources->irqs->interrupt[(temp_byte + 29331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds resources->irqs->barber_pole - 1) & 0x03]; 29341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 29351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Program IRQ based on card type */ 29361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_read_config_byte (pci_bus, devfn, 0x0B, &class_code); 29371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 29381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (class_code == PCI_BASE_CLASS_STORAGE) { 29391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds IRQ = cpqhp_disk_irq; 29401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 29411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds IRQ = cpqhp_nic_irq; 29421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 29431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 29441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 29451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* IRQ Line */ 29461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_byte (pci_bus, devfn, PCI_INTERRUPT_LINE, IRQ); 29471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 29481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 29491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!behind_bridge) { 29501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = cpqhp_set_irq(func->bus, func->device, temp_byte + 0x09, IRQ); 29511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 29521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 29531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 29541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* TBD - this code may also belong in the other clause 29551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * of this If statement */ 29561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds resources->irqs->interrupt[(temp_byte + resources->irqs->barber_pole - 1) & 0x03] = IRQ; 29571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds resources->irqs->valid_INT |= 0x01 << (temp_byte + resources->irqs->barber_pole - 1) & 0x03; 29581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 29591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 29601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Latency Timer */ 29611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_byte = 0x40; 29621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_byte(pci_bus, devfn, 29631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds PCI_LATENCY_TIMER, temp_byte); 29641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 29651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Cache Line size */ 29661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_byte = 0x08; 29671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_byte(pci_bus, devfn, 29681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds PCI_CACHE_LINE_SIZE, temp_byte); 29691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 29701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* disable ROM base Address */ 29711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_dword = 0x00L; 29721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_word(pci_bus, devfn, 29731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds PCI_ROM_ADDRESS, temp_dword); 29741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 29751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* enable card */ 29761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_word = 0x0157; /* = PCI_COMMAND_IO | 29771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * PCI_COMMAND_MEMORY | 29781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * PCI_COMMAND_MASTER | 29791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * PCI_COMMAND_INVALIDATE | 29801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * PCI_COMMAND_PARITY | 29811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * PCI_COMMAND_SERR */ 29821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_word (pci_bus, devfn, 29831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds PCI_COMMAND, temp_word); 29841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { /* End of Not-A-Bridge else */ 29851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* It's some strange type of PCI adapter (Cardbus?) */ 29861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return DEVICE_TYPE_NOT_SUPPORTED; 29871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 29881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 29891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->configured = 1; 29901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 29911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 29921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsfree_and_out: 29931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_destroy_resource_list (&temp_resources); 29941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 29951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return_resource(&(resources-> bus_head), hold_bus_node); 29961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return_resource(&(resources-> io_head), hold_IO_node); 29971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return_resource(&(resources-> mem_head), hold_mem_node); 29981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return_resource(&(resources-> p_mem_head), hold_p_mem_node); 29991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 30001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 3001