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/pci.h> 387a54f25cef6c763f16c9fd49ae382de162147873Greg Kroah-Hartman#include <linux/pci_hotplug.h> 39fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig#include <linux/kthread.h> 401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include "cpqphp.h" 411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic u32 configure_new_device(struct controller* ctrl, struct pci_func *func, 431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 behind_bridge, struct resource_lists *resources); 441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int configure_new_function(struct controller* ctrl, struct pci_func *func, 451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 behind_bridge, struct resource_lists *resources); 461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void interrupt_event_handler(struct controller *ctrl); 471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 49fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwigstatic struct task_struct *cpqhp_event_thread; 50fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwigstatic unsigned long pushbutton_pending; /* = 0 */ 511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* delay is in jiffies to wait for */ 531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void long_delay(int delay) 541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 55fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig /* 56fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig * XXX(hch): if someone is bored please convert all callers 57fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig * to call msleep_interruptible directly. They really want 58fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig * to specify timeouts in natural units and spend a lot of 59fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig * effort converting them to jiffies.. 601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds msleep_interruptible(jiffies_to_msecs(delay)); 621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* FIXME: The following line needs to be somewhere else... */ 661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define WRONG_BUS_FREQUENCY 0x07 671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic u8 handle_switch_change(u8 change, struct controller * ctrl) 681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int hp_slot; 701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 rc = 0; 711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u16 temp_word; 721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_func *func; 731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct event_info *taskInfo; 741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!change) 761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Switch Change */ 791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("cpqsbd: Switch interrupt received.\n"); 801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (hp_slot = 0; hp_slot < 6; hp_slot++) { 821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (change & (0x1L << hp_slot)) { 83427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang /* 841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * this one changed. 85427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func = cpqhp_slot_find(ctrl->bus, 871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (hp_slot + ctrl->slot_device_offset), 0); 881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* this is the structure that tells the worker thread 90427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang * what to do 91427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 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)) { 103427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang /* 1041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Switch opened 105427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 1061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->switch_save = 0; 1081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds taskInfo->event_type = INT_SWITCH_OPEN; 1101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 111427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang /* 1121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Switch closed 113427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 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/** 12626e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * 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 1341d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang while (slot && (slot->device != device)) 1351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot = slot->next; 1361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return slot; 1381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 1391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic u8 handle_presence_change(u16 change, struct controller * ctrl) 1421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 1431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int hp_slot; 1441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 rc = 0; 1451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 temp_byte; 1461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u16 temp_word; 1471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_func *func; 1481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct event_info *taskInfo; 1491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct slot *p_slot; 1501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!change) 1521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 1531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 154427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang /* 1551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Presence Change 156427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 1571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("cpqsbd: Presence/Notify input change.\n"); 1581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg(" Changed bits are 0x%4.4x\n", change ); 1591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (hp_slot = 0; hp_slot < 6; hp_slot++) { 1611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (change & (0x0101 << hp_slot)) { 162427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang /* 1631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * this one changed. 164427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 1651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func = cpqhp_slot_find(ctrl->bus, 1661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (hp_slot + ctrl->slot_device_offset), 0); 1671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds taskInfo = &(ctrl->event_queue[ctrl->next_event]); 1691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ctrl->next_event = (ctrl->next_event + 1) % 10; 1701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds taskInfo->hp_slot = hp_slot; 1711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc++; 1731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot = cpqhp_find_slot(ctrl, hp_slot + (readb(ctrl->hpc_reg + SLOT_MASK) >> 4)); 1751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!p_slot) 1761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 1771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If the switch closed, must be a button 179427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang * If not in button mode, nevermind 180427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 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) { 187427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang /* 1881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * button Pressed (doesn't do anything) 189427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 1901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("hp_slot %d button pressed\n", hp_slot); 1911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds taskInfo->event_type = INT_BUTTON_PRESS; 1921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 193427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang /* 1941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * button Released - TAKE ACTION!!!! 195427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 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 213427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang * Save the presence state 214427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 2151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_word = ctrl->ctrl_int_comp >> 16; 2161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->presence_save = (temp_word >> hp_slot) & 0x01; 2171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->presence_save |= (temp_word >> (hp_slot + 7)) & 0x02; 2181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((!(ctrl->ctrl_int_comp & (0x010000 << hp_slot))) || 2201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (!(ctrl->ctrl_int_comp & (0x01000000 << hp_slot)))) { 2211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Present */ 2221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds taskInfo->event_type = INT_PRESENCE_ON; 2231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 2241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Not Present */ 2251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds taskInfo->event_type = INT_PRESENCE_OFF; 2261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 2271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 2281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 2291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 2301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 2321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 2331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic u8 handle_power_fault(u8 change, struct controller * ctrl) 2361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 2371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int hp_slot; 2381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 rc = 0; 2391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_func *func; 2401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct event_info *taskInfo; 2411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!change) 2431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 2441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 245427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang /* 2461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * power fault 247427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 2481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds info("power fault interrupt\n"); 2501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (hp_slot = 0; hp_slot < 6; hp_slot++) { 2521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (change & (0x01 << hp_slot)) { 253427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang /* 2541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * this one changed. 255427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 2561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func = cpqhp_slot_find(ctrl->bus, 2571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (hp_slot + ctrl->slot_device_offset), 0); 2581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds taskInfo = &(ctrl->event_queue[ctrl->next_event]); 2601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ctrl->next_event = (ctrl->next_event + 1) % 10; 2611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds taskInfo->hp_slot = hp_slot; 2621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc++; 2641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (ctrl->ctrl_int_comp & (0x00000100 << hp_slot)) { 266427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang /* 2671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * power fault Cleared 268427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 2691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->status = 0x00; 2701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds taskInfo->event_type = INT_POWER_FAULT_CLEAR; 2721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 273427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang /* 2741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * power fault 275427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 2761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds taskInfo->event_type = INT_POWER_FAULT; 2771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (ctrl->rev < 4) { 2791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds amber_LED_on (ctrl, hp_slot); 2801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds green_LED_off (ctrl, hp_slot); 2811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO (ctrl); 2821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* this is a fatal condition, we want 2841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * to crash the machine to protect from 2851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * data corruption. simulated_NMI 2861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * shouldn't ever return */ 2871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* FIXME 2881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds simulated_NMI(hp_slot, ctrl); */ 2891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* The following code causes a software 2911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * crash just in case simulated_NMI did 2921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * return */ 2931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /*FIXME 2941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic(msg_power_fault); */ 2951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 2961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* set power fault status for this board */ 2971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->status = 0xFF; 2981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds info("power fault bit %x set\n", hp_slot); 2991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 3001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 3011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 3021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 3031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 3051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 3061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 30926e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * sort_by_size - sort nodes on the list by their length, smallest first. 3101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @head: list to sort 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/** 35726e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * sort_by_max_size - sort nodes on the list by their length, largest first. 3581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @head: list to sort 3591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 3601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int sort_by_max_size(struct pci_resource **head) 3611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 3621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *current_res; 3631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *next_res; 3641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int out_of_order = 1; 3651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!(*head)) 3671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 3681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!((*head)->next)) 3701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 3711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (out_of_order) { 3731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds out_of_order = 0; 3741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Special case for swapping list head */ 3761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (((*head)->next) && 3771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ((*head)->length < (*head)->next->length)) { 3781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds out_of_order++; 3791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds current_res = *head; 3801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *head = (*head)->next; 3811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds current_res->next = (*head)->next; 3821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (*head)->next = current_res; 3831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 3841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds current_res = *head; 3861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (current_res->next && current_res->next->next) { 3881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (current_res->next->length < current_res->next->next->length) { 3891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds out_of_order++; 3901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds next_res = current_res->next; 3911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds current_res->next = current_res->next->next; 3921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds current_res = current_res->next; 3931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds next_res->next = current_res->next; 3941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds current_res->next = next_res; 3951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else 3961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds current_res = current_res->next; 3971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 3981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } /* End of out_of_order loop */ 3991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 4011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 4021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 40526e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * do_pre_bridge_resource_split - find node of resources that are unused 40626e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * @head: new list head 40726e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * @orig_head: original list head 40826e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * @alignment: max node size (?) 4091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 4101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic struct pci_resource *do_pre_bridge_resource_split(struct pci_resource **head, 4111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource **orig_head, u32 alignment) 4121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 4131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *prevnode = NULL; 4141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *node; 4151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *split_node; 4161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 rc; 4171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 temp_dword; 4181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("do_pre_bridge_resource_split\n"); 4191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!(*head) || !(*orig_head)) 4211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 4221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = cpqhp_resource_sort_and_combine(head); 4241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 4261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 4271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((*head)->base != (*orig_head)->base) 4291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 4301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((*head)->length == (*orig_head)->length) 4321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 4331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If we got here, there the bridge requires some of the resource, but 436427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang * we may be able to split some off of the front 437427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 4381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node = *head; 4401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (node->length & (alignment -1)) { 4421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* this one isn't an aligned length, so we'll make a new entry 443427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang * and split it up. 444427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 4451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node = kmalloc(sizeof(*split_node), GFP_KERNEL); 4461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!split_node) 4481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 4491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_dword = (node->length | (alignment-1)) + 1 - alignment; 4511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->base = node->base; 4531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->length = temp_dword; 4541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->length -= temp_dword; 4561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->base += split_node->length; 4571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Put it in the list */ 4591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *head = split_node; 4601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->next = node; 4611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 4621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (node->length < alignment) 4641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 4651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Now unlink it */ 4671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (*head == node) { 4681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *head = node->next; 4691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 4701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds prevnode = *head; 4711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (prevnode->next != node) 4721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds prevnode = prevnode->next; 4731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds prevnode->next = node->next; 4751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 4761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->next = NULL; 4771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return node; 4791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 4801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 48326e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * do_bridge_resource_split - find one node of resources that aren't in use 48426e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * @head: list head 48526e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * @alignment: max node size (?) 4861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 4871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic struct pci_resource *do_bridge_resource_split(struct pci_resource **head, u32 alignment) 4881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 4891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *prevnode = NULL; 4901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *node; 4911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 rc; 4921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 temp_dword; 4931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = cpqhp_resource_sort_and_combine(head); 4951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 4971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 4981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node = *head; 5001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (node->next) { 5021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds prevnode = node; 5031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node = node->next; 5041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree(prevnode); 5051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 5061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (node->length < alignment) 5081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto error; 5091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (node->base & (alignment - 1)) { 5111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Short circuit if adjusted size is too small */ 5121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_dword = (node->base | (alignment-1)) + 1; 5131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((node->length - (temp_dword - node->base)) < alignment) 5141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto error; 5151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->length -= (temp_dword - node->base); 5171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->base = temp_dword; 5181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 5191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (node->length & (alignment - 1)) 5211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* There's stuff in use after this node */ 5221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto error; 5231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return node; 5251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldserror: 5261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree(node); 5271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 5281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 5291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 53226e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * get_io_resource - find first node of given size not in ISA aliasing window. 5331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @head: list to search 5341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @size: size of node to find, must be a power of two. 5351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 53626e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * Description: This function sorts the resource list by size and then returns 5371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * returns the first node of "size" length that is not in the ISA aliasing 5381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * window. If it finds a node larger than "size" it will split it up. 5391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 5401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic struct pci_resource *get_io_resource(struct pci_resource **head, u32 size) 5411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 5421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *prevnode; 5431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *node; 5441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *split_node; 5451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 temp_dword; 5461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!(*head)) 5481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 5491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5501d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang if (cpqhp_resource_sort_and_combine(head)) 5511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 5521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5531d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang if (sort_by_size(head)) 5541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 5551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (node = *head; node; node = node->next) { 5571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (node->length < size) 5581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 5591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (node->base & (size - 1)) { 5611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* this one isn't base aligned properly 562427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang * so we'll make a new entry and split it up 563427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 5641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_dword = (node->base | (size-1)) + 1; 5651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Short circuit if adjusted size is too small */ 5671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((node->length - (temp_dword - node->base)) < size) 5681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 5691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node = kmalloc(sizeof(*split_node), GFP_KERNEL); 5711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!split_node) 5731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 5741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->base = node->base; 5761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->length = temp_dword - node->base; 5771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->base = temp_dword; 5781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->length -= split_node->length; 5791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Put it in the list */ 5811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->next = node->next; 5821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->next = split_node; 5831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } /* End of non-aligned base */ 5841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Don't need to check if too small since we already did */ 5861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (node->length > size) { 5871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* this one is longer than we need 588427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang * so we'll make a new entry and split it up 589427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 5901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node = kmalloc(sizeof(*split_node), GFP_KERNEL); 5911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!split_node) 5931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 5941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->base = node->base + size; 5961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->length = node->length - size; 5971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->length = size; 5981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Put it in the list */ 6001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->next = node->next; 6011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->next = split_node; 6021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } /* End of too big on top end */ 6031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* For IO make sure it's not in the ISA aliasing space */ 6051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (node->base & 0x300L) 6061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 6071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If we got here, then it is the right size 609427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang * Now take it out of the list and break 610427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 6111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (*head == node) { 6121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *head = node->next; 6131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 6141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds prevnode = *head; 6151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (prevnode->next != node) 6161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds prevnode = prevnode->next; 6171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds prevnode->next = node->next; 6191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 6201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->next = NULL; 6211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 6221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 6231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return node; 6251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 6261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 62926e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * get_max_resource - get largest node which has at least the given size. 6301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @head: the list to search the node in 6311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @size: the minimum size of the node to find 6321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 6331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Description: Gets the largest node that is at least "size" big from the 6341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * list pointed to by head. It aligns the node on top and bottom 6351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * to "size" alignment before returning it. 6361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 6371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic struct pci_resource *get_max_resource(struct pci_resource **head, u32 size) 6381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 6391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *max; 6401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *temp; 6411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *split_node; 6421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 temp_dword; 6431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (cpqhp_resource_sort_and_combine(head)) 6451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 6461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (sort_by_max_size(head)) 6481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 6491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (max = *head; max; max = max->next) { 651861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang /* If not big enough we could probably just bail, 652427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang * instead we'll continue to the next. 653427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 6541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (max->length < size) 6551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 6561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (max->base & (size - 1)) { 6581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* this one isn't base aligned properly 659427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang * so we'll make a new entry and split it up 660427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 6611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_dword = (max->base | (size-1)) + 1; 6621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Short circuit if adjusted size is too small */ 6641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((max->length - (temp_dword - max->base)) < size) 6651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 6661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node = kmalloc(sizeof(*split_node), GFP_KERNEL); 6681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!split_node) 6701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 6711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->base = max->base; 6731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->length = temp_dword - max->base; 6741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds max->base = temp_dword; 6751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds max->length -= split_node->length; 6761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->next = max->next; 6781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds max->next = split_node; 6791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 6801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((max->base + max->length) & (size - 1)) { 6821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* this one isn't end aligned properly at the top 683427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang * so we'll make a new entry and split it up 684427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 6851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node = kmalloc(sizeof(*split_node), GFP_KERNEL); 6861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!split_node) 6881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 6891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_dword = ((max->base + max->length) & ~(size - 1)); 6901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->base = temp_dword; 6911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->length = max->length + max->base 6921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds - split_node->base; 6931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds max->length -= split_node->length; 6941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->next = max->next; 6961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds max->next = split_node; 6971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 6981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Make sure it didn't shrink too much when we aligned it */ 7001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (max->length < size) 7011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 7021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Now take it out of the list */ 7041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp = *head; 7051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (temp == max) { 7061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *head = max->next; 7071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 7081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (temp && temp->next != max) { 7091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp = temp->next; 7101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 7111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp->next = max->next; 7131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 7141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds max->next = NULL; 7161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 7171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 7181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return max; 7201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 7211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 72426e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * get_resource - find resource of given size and split up larger ones. 7251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @head: the list to search for resources 7261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @size: the size limit to use 7271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 7281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Description: This function sorts the resource list by size and then 7291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * returns the first node of "size" length. If it finds a node 7301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * larger than "size" it will split it up. 7311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 7321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * size must be a power of two. 7331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 7341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic struct pci_resource *get_resource(struct pci_resource **head, u32 size) 7351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 7361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *prevnode; 7371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *node; 7381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *split_node; 7391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 temp_dword; 7401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (cpqhp_resource_sort_and_combine(head)) 7421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 7431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (sort_by_size(head)) 7451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 7461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (node = *head; node; node = node->next) { 7481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("%s: req_size =%x node=%p, base=%x, length=%x\n", 74966bef8c059015ba2b36bb5759080336feb01e680Harvey Harrison __func__, size, node, node->base, node->length); 7501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (node->length < size) 7511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 7521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (node->base & (size - 1)) { 75466bef8c059015ba2b36bb5759080336feb01e680Harvey Harrison dbg("%s: not aligned\n", __func__); 7551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* this one isn't base aligned properly 756427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang * so we'll make a new entry and split it up 757427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 7581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_dword = (node->base | (size-1)) + 1; 7591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Short circuit if adjusted size is too small */ 7611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((node->length - (temp_dword - node->base)) < size) 7621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 7631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node = kmalloc(sizeof(*split_node), GFP_KERNEL); 7651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!split_node) 7671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 7681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->base = node->base; 7701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->length = temp_dword - node->base; 7711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->base = temp_dword; 7721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->length -= split_node->length; 7731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->next = node->next; 7751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->next = split_node; 7761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } /* End of non-aligned base */ 7771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Don't need to check if too small since we already did */ 7791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (node->length > size) { 78066bef8c059015ba2b36bb5759080336feb01e680Harvey Harrison dbg("%s: too big\n", __func__); 7811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* this one is longer than we need 782427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang * so we'll make a new entry and split it up 783427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 7841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node = kmalloc(sizeof(*split_node), GFP_KERNEL); 7851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!split_node) 7871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 7881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->base = node->base + size; 7901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->length = node->length - size; 7911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->length = size; 7921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Put it in the list */ 7941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds split_node->next = node->next; 7951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->next = split_node; 7961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } /* End of too big on top end */ 7971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 79866bef8c059015ba2b36bb5759080336feb01e680Harvey Harrison dbg("%s: got one!!!\n", __func__); 7991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If we got here, then it is the right size 8001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Now take it out of the list */ 8011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (*head == node) { 8021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *head = node->next; 8031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 8041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds prevnode = *head; 8051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (prevnode->next != node) 8061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds prevnode = prevnode->next; 8071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds prevnode->next = node->next; 8091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 8101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node->next = NULL; 8111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 8121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 8131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return node; 8141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 8151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 81826e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * cpqhp_resource_sort_and_combine - sort nodes by base addresses and clean up 8191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @head: the list to sort and clean up 8201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 8211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Description: Sorts all of the nodes in the list in ascending order by 8221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * their base addresses. Also does garbage collection by 8231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * combining adjacent nodes. 8241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 82526e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * Returns %0 if success. 8261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 8271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsint cpqhp_resource_sort_and_combine(struct pci_resource **head) 8281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 8291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *node1; 8301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *node2; 8311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int out_of_order = 1; 8321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 83366bef8c059015ba2b36bb5759080336feb01e680Harvey Harrison dbg("%s: head = %p, *head = %p\n", __func__, head, *head); 8341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!(*head)) 8361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 8371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("*head->next = %p\n",(*head)->next); 8391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!(*head)->next) 8411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; /* only one item on the list, already sorted! */ 8421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("*head->base = 0x%x\n",(*head)->base); 8441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("*head->next->base = 0x%x\n",(*head)->next->base); 8451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (out_of_order) { 8461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds out_of_order = 0; 8471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Special case for swapping list head */ 8491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (((*head)->next) && 8501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ((*head)->base > (*head)->next->base)) { 8511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node1 = *head; 8521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (*head) = (*head)->next; 8531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node1->next = (*head)->next; 8541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (*head)->next = node1; 8551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds out_of_order++; 8561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 8571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node1 = (*head); 8591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (node1->next && node1->next->next) { 8611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (node1->next->base > node1->next->next->base) { 8621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds out_of_order++; 8631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node2 = node1->next; 8641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node1->next = node1->next->next; 8651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node1 = node1->next; 8661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node2->next = node1->next; 8671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node1->next = node2; 8681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else 8691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node1 = node1->next; 8701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 8711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } /* End of out_of_order loop */ 8721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node1 = *head; 8741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (node1 && node1->next) { 8761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((node1->base + node1->length) == node1->next->base) { 8771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Combine */ 8781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("8..\n"); 8791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node1->length += node1->next->length; 8801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node2 = node1->next; 8811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node1->next = node1->next->next; 8821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree(node2); 8831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else 8841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds node1 = node1->next; 8851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 8861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 8881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 8891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8917d12e780e003f93433d49ce78cfedf4b4c52adc5David Howellsirqreturn_t cpqhp_ctrl_intr(int IRQ, void *data) 8921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 8931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct controller *ctrl = data; 8941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 schedule_flag = 0; 8951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 reset; 8961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u16 misc; 8971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 Diff; 8981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 temp_dword; 8991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 900861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang 9011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds misc = readw(ctrl->hpc_reg + MISC); 902427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang /* 9031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Check to see if it was our interrupt 904427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 9051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!(misc & 0x000C)) { 9061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return IRQ_NONE; 9071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 9081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (misc & 0x0004) { 910427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang /* 9111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Serial Output interrupt Pending 912427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 9131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Clear the interrupt */ 9151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds misc |= 0x0004; 9161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writew(misc, ctrl->hpc_reg + MISC); 9171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Read to clear posted writes */ 9191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds misc = readw(ctrl->hpc_reg + MISC); 9201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 92166bef8c059015ba2b36bb5759080336feb01e680Harvey Harrison dbg ("%s - waking up\n", __func__); 9221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wake_up_interruptible(&ctrl->queue); 9231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 9241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (misc & 0x0008) { 9261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* General-interrupt-input interrupt Pending */ 9271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds Diff = readl(ctrl->hpc_reg + INT_INPUT_CLEAR) ^ ctrl->ctrl_int_comp; 9281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ctrl->ctrl_int_comp = readl(ctrl->hpc_reg + INT_INPUT_CLEAR); 9301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Clear the interrupt */ 9321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(Diff, ctrl->hpc_reg + INT_INPUT_CLEAR); 9331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Read it back to clear any posted writes */ 9351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_dword = readl(ctrl->hpc_reg + INT_INPUT_CLEAR); 9361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!Diff) 9381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Clear all interrupts */ 9391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(0xFFFFFFFF, ctrl->hpc_reg + INT_INPUT_CLEAR); 9401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds schedule_flag += handle_switch_change((u8)(Diff & 0xFFL), ctrl); 9421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds schedule_flag += handle_presence_change((u16)((Diff & 0xFFFF0000L) >> 16), ctrl); 9431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds schedule_flag += handle_power_fault((u8)((Diff & 0xFF00L) >> 8), ctrl); 9441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 9451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reset = readb(ctrl->hpc_reg + RESET_FREQ_MODE); 9471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (reset & 0x40) { 9481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Bus reset has completed */ 9491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reset &= 0xCF; 9501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writeb(reset, ctrl->hpc_reg + RESET_FREQ_MODE); 9511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reset = readb(ctrl->hpc_reg + RESET_FREQ_MODE); 9521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wake_up_interruptible(&ctrl->queue); 9531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 9541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (schedule_flag) { 956fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig wake_up_process(cpqhp_event_thread); 957fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig dbg("Waking even thread"); 9581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 9591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return IRQ_HANDLED; 9601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 9611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 9641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * cpqhp_slot_create - Creates a node and adds it to the proper bus. 96526e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * @busnumber: bus where new node is to be located 9661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 96726e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * Returns pointer to the new node or %NULL if unsuccessful. 9681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 9691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstruct pci_func *cpqhp_slot_create(u8 busnumber) 9701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 9711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_func *new_slot; 9721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_func *next; 9731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 97473a985a140cd0f1b17fa1438af0359d6b9b32b16Mariusz Kozlowski new_slot = kzalloc(sizeof(*new_slot), GFP_KERNEL); 9751d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang if (new_slot == NULL) 9761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return new_slot; 9771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot->next = NULL; 9791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot->configured = 1; 9801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (cpqhp_slot_list[busnumber] == NULL) { 9821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_slot_list[busnumber] = new_slot; 9831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 9841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds next = cpqhp_slot_list[busnumber]; 9851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (next->next != NULL) 9861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds next = next->next; 9871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds next->next = new_slot; 9881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 9891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return new_slot; 9901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 9911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 9941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * slot_remove - Removes a node from the linked list of slots. 9951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @old_slot: slot to remove 9961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 99726e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * Returns %0 if successful, !0 otherwise. 9981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 9991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int slot_remove(struct pci_func * old_slot) 10001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 10011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_func *next; 10021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (old_slot == NULL) 10041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 10051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds next = cpqhp_slot_list[old_slot->bus]; 10071d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang if (next == NULL) 10081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 10091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (next == old_slot) { 10111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_slot_list[old_slot->bus] = old_slot->next; 10121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_destroy_board_resources(old_slot); 10131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree(old_slot); 10141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 10151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 10161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10171d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang while ((next->next != old_slot) && (next->next != NULL)) 10181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds next = next->next; 10191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (next->next == old_slot) { 10211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds next->next = old_slot->next; 10221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_destroy_board_resources(old_slot); 10231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree(old_slot); 10241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 10251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else 10261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 2; 10271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 10281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 10311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * bridge_slot_remove - Removes a node from the linked list of slots. 10321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @bridge: bridge to remove 10331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 103426e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * Returns %0 if successful, !0 otherwise. 10351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 10361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int bridge_slot_remove(struct pci_func *bridge) 10371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 10381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 subordinateBus, secondaryBus; 10391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 tempBus; 10401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_func *next; 10411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds secondaryBus = (bridge->config_space[0x06] >> 8) & 0xFF; 10431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds subordinateBus = (bridge->config_space[0x06] >> 16) & 0xFF; 10441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (tempBus = secondaryBus; tempBus <= subordinateBus; tempBus++) { 10461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds next = cpqhp_slot_list[tempBus]; 10471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10481d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang while (!slot_remove(next)) 10491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds next = cpqhp_slot_list[tempBus]; 10501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 10511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds next = cpqhp_slot_list[bridge->bus]; 10531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (next == NULL) 10551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 10561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (next == bridge) { 10581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_slot_list[bridge->bus] = bridge->next; 10591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto out; 10601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 10611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while ((next->next != bridge) && (next->next != NULL)) 10631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds next = next->next; 10641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (next->next != bridge) 10661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 2; 10671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds next->next = bridge->next; 10681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsout: 10691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree(bridge); 10701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 10711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 10721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 10751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * cpqhp_slot_find - Looks for a node by bus, and device, multiple functions accessed 10761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @bus: bus to find 10771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @device: device to find 107826e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * @index: is %0 for first function found, %1 for the second... 10791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 10801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Returns pointer to the node if successful, %NULL otherwise. 10811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 10821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstruct pci_func *cpqhp_slot_find(u8 bus, u8 device, u8 index) 10831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 10841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int found = -1; 10851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_func *func; 10861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func = cpqhp_slot_list[bus]; 10881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((func == NULL) || ((func->device == device) && (index == 0))) 10901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return func; 10911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (func->device == device) 10931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds found++; 10941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (func->next != NULL) { 10961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func = func->next; 10971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (func->device == device) 10991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds found++; 11001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (found == index) 11021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return func; 11031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 11041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 11061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 11071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* DJZ: I don't think is_bridge will work as is. 11101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * FIXME */ 11111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int is_bridge(struct pci_func * func) 11121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 11131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check the header type */ 11141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (((func->config_space[0x03] >> 16) & 0xFF) == 0x01) 11151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 11161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 11171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 11181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 11191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 112226e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * set_controller_speed - set the frequency and/or mode of a specific controller segment. 11231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @ctrl: controller to change frequency/mode for. 11241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @adapter_speed: the speed of the adapter we want to match. 11251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @hp_slot: the slot number where the adapter is installed. 11261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 112726e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * Returns %0 if we successfully change frequency and/or mode to match the 11281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * adapter speed. 11291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 11301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic u8 set_controller_speed(struct controller *ctrl, u8 adapter_speed, u8 hp_slot) 11311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 11321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct slot *slot; 11333749c51ac6c1560aa1cb1520066bed84c6f8152aMatthew Wilcox struct pci_bus *bus = ctrl->pci_bus; 11341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 reg; 11351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 slot_power = readb(ctrl->hpc_reg + SLOT_POWER); 11361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u16 reg16; 11371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 leds = readl(ctrl->hpc_reg + LED_CONTROL); 1138861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang 11393749c51ac6c1560aa1cb1520066bed84c6f8152aMatthew Wilcox if (bus->cur_bus_speed == adapter_speed) 11401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 1141861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang 11421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* We don't allow freq/mode changes if we find another adapter running 1143427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang * in another slot on this controller 1144427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 11451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for(slot = ctrl->slot; slot; slot = slot->next) { 1146861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang if (slot->device == (hp_slot + ctrl->slot_device_offset)) 11471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 114805a34f51ba451c65773ad6f1acf4cc089cc474d8Julia Lawall if (!slot->hotplug_slot || !slot->hotplug_slot->info) 11491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 1150861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang if (slot->hotplug_slot->info->adapter_status == 0) 11511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 11521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If another adapter is running on the same segment but at a 11531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * lower speed/mode, we allow the new adapter to function at 1154427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang * this rate if supported 1155427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 11563749c51ac6c1560aa1cb1520066bed84c6f8152aMatthew Wilcox if (bus->cur_bus_speed < adapter_speed) 11571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 11581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 11601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 1161861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang 11621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If the controller doesn't support freq/mode changes and the 1163427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang * controller is running at a higher mode, we bail 1164427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 11653749c51ac6c1560aa1cb1520066bed84c6f8152aMatthew Wilcox if ((bus->cur_bus_speed > adapter_speed) && (!ctrl->pcix_speed_capability)) 11661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 1167861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang 11681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* But we allow the adapter to run at a lower rate if possible */ 11693749c51ac6c1560aa1cb1520066bed84c6f8152aMatthew Wilcox if ((bus->cur_bus_speed < adapter_speed) && (!ctrl->pcix_speed_capability)) 11701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 11711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* We try to set the max speed supported by both the adapter and 1173427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang * controller 1174427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 11753749c51ac6c1560aa1cb1520066bed84c6f8152aMatthew Wilcox if (bus->max_bus_speed < adapter_speed) { 11763749c51ac6c1560aa1cb1520066bed84c6f8152aMatthew Wilcox if (bus->cur_bus_speed == bus->max_bus_speed) 11771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 11783749c51ac6c1560aa1cb1520066bed84c6f8152aMatthew Wilcox adapter_speed = bus->max_bus_speed; 11791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 11801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(0x0L, ctrl->hpc_reg + LED_CONTROL); 11821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writeb(0x00, ctrl->hpc_reg + SLOT_ENABLE); 1183861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang 1184861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang set_SOGO(ctrl); 11851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq(ctrl); 1186861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang 11871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (adapter_speed != PCI_SPEED_133MHz_PCIX) 11881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg = 0xF5; 11891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 1190861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang reg = 0xF4; 11911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_write_config_byte(ctrl->pci_dev, 0x41, reg); 1192861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang 11931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg16 = readw(ctrl->hpc_reg + NEXT_CURR_FREQ); 11941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg16 &= ~0x000F; 11951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds switch(adapter_speed) { 1196861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang case(PCI_SPEED_133MHz_PCIX): 11971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg = 0x75; 1198861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang reg16 |= 0xB; 11991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 12001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case(PCI_SPEED_100MHz_PCIX): 12011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg = 0x74; 12021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg16 |= 0xA; 12031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 12041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case(PCI_SPEED_66MHz_PCIX): 12051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg = 0x73; 12061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg16 |= 0x9; 12071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 12081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case(PCI_SPEED_66MHz): 12091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg = 0x73; 12101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg16 |= 0x1; 12111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 12121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds default: /* 33MHz PCI 2.2 */ 12131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg = 0x71; 12141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 1215861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang 12161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg16 |= 0xB << 12; 12181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writew(reg16, ctrl->hpc_reg + NEXT_CURR_FREQ); 1219861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang 1220861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang mdelay(5); 1221861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang 12221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Reenable interrupts */ 12231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(0, ctrl->hpc_reg + INT_MASK); 12241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1225861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang pci_write_config_byte(ctrl->pci_dev, 0x41, reg); 1226861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang 12271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Restart state machine */ 12281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg = ~0xF; 12291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_read_config_byte(ctrl->pci_dev, 0x43, ®); 12301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_write_config_byte(ctrl->pci_dev, 0x43, reg); 1231861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang 12321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Only if mode change...*/ 12333749c51ac6c1560aa1cb1520066bed84c6f8152aMatthew Wilcox if (((bus->cur_bus_speed == PCI_SPEED_66MHz) && (adapter_speed == PCI_SPEED_66MHz_PCIX)) || 12343749c51ac6c1560aa1cb1520066bed84c6f8152aMatthew Wilcox ((bus->cur_bus_speed == PCI_SPEED_66MHz_PCIX) && (adapter_speed == PCI_SPEED_66MHz))) 12351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 1236861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang 12371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq(ctrl); 12381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mdelay(1100); 1239861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang 12401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Restore LED/Slot state */ 12411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(leds, ctrl->hpc_reg + LED_CONTROL); 12421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writeb(slot_power, ctrl->hpc_reg + SLOT_ENABLE); 1243861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang 12441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 12451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq(ctrl); 12461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12473749c51ac6c1560aa1cb1520066bed84c6f8152aMatthew Wilcox bus->cur_bus_speed = adapter_speed; 12481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot = cpqhp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset); 12491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1250861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang info("Successfully changed frequency/mode for adapter in slot %d\n", 12511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->number); 12521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 12531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 12541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1255861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang/* the following routines constitute the bulk of the 1256427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang * hotplug controller logic 12571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 12581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 12611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * board_replaced - Called after a board has been replaced in the system. 126226e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * @func: PCI device/function information 126326e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * @ctrl: hotplug controller 12641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 126526e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * This is only used if we don't have resources for hot add. 126626e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * Turns power on for the board. 126726e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * Checks to see if board is the same. 126826e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * If board is same, reconfigures it. 12691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * If board isn't same, turns it back off. 12701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 12711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic u32 board_replaced(struct pci_func *func, struct controller *ctrl) 12721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 12733749c51ac6c1560aa1cb1520066bed84c6f8152aMatthew Wilcox struct pci_bus *bus = ctrl->pci_bus; 12741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 hp_slot; 12751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 temp_byte; 12761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 adapter_speed; 12771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 rc = 0; 12781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hp_slot = func->device - ctrl->slot_device_offset; 12801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12811d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang /* 12821d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang * The switch is open. 12831d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang */ 12841d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang if (readl(ctrl->hpc_reg + INT_INPUT_CLEAR) & (0x01L << hp_slot)) 12851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = INTERLOCK_OPEN; 12861d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang /* 12871d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang * The board is already on 12881d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang */ 12891d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang else if (is_slot_enabled (ctrl, hp_slot)) 12901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = CARD_FUNCTIONING; 12911d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang else { 12926aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_lock(&ctrl->crit_sect); 12931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* turn on board without attaching to the bus */ 12951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds enable_slot_power (ctrl, hp_slot); 12961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 12981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 13001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 13011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Change bits in slot power register to force another shift out 13031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * NOTE: this is to work around the timer bug */ 13041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_byte = readb(ctrl->hpc_reg + SLOT_POWER); 13051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writeb(0x00, ctrl->hpc_reg + SLOT_POWER); 13061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writeb(temp_byte, ctrl->hpc_reg + SLOT_POWER); 13071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 13091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 13111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 1312861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang 13131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds adapter_speed = get_adapter_speed(ctrl, hp_slot); 13143749c51ac6c1560aa1cb1520066bed84c6f8152aMatthew Wilcox if (bus->cur_bus_speed != adapter_speed) 13151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (set_controller_speed(ctrl, adapter_speed, hp_slot)) 13161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = WRONG_BUS_FREQUENCY; 13171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* turn off board without attaching to the bus */ 13191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds disable_slot_power (ctrl, hp_slot); 13201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 13221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 13241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 13251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13266aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_unlock(&ctrl->crit_sect); 13271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 13291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 13301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13316aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_lock(&ctrl->crit_sect); 13321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot_enable (ctrl, hp_slot); 13341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds green_LED_blink (ctrl, hp_slot); 13351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds amber_LED_off (ctrl, hp_slot); 13371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 13391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 13411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 13421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13436aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_unlock(&ctrl->crit_sect); 13441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for ~1 second because of hot plug spec */ 13461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds long_delay(1*HZ); 13471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check for a power fault */ 13491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (func->status == 0xFF) { 13501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* power fault occurred, but it was benign */ 13511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = POWER_FAILURE; 13521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->status = 0; 13531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else 13541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = cpqhp_valid_replace(ctrl, func); 13551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!rc) { 13571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* It must be the same board */ 13581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = cpqhp_configure_board(ctrl, func); 13601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13611305e9184a3de84f78dca102b293d21007bb6c49Adrian Bunk /* If configuration fails, turn it off 13621305e9184a3de84f78dca102b293d21007bb6c49Adrian Bunk * Get slot won't work for devices behind 13631305e9184a3de84f78dca102b293d21007bb6c49Adrian Bunk * bridges, but in this case it will always be 13641305e9184a3de84f78dca102b293d21007bb6c49Adrian Bunk * called for the "base" bus/dev/func of an 1365427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang * adapter. 1366427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 13671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13686aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_lock(&ctrl->crit_sect); 13691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13701305e9184a3de84f78dca102b293d21007bb6c49Adrian Bunk amber_LED_on (ctrl, hp_slot); 13711305e9184a3de84f78dca102b293d21007bb6c49Adrian Bunk green_LED_off (ctrl, hp_slot); 13721305e9184a3de84f78dca102b293d21007bb6c49Adrian Bunk slot_disable (ctrl, hp_slot); 13731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 13751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 13771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 13781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13796aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_unlock(&ctrl->crit_sect); 13801305e9184a3de84f78dca102b293d21007bb6c49Adrian Bunk 13811305e9184a3de84f78dca102b293d21007bb6c49Adrian Bunk if (rc) 13821305e9184a3de84f78dca102b293d21007bb6c49Adrian Bunk return rc; 13831305e9184a3de84f78dca102b293d21007bb6c49Adrian Bunk else 13841305e9184a3de84f78dca102b293d21007bb6c49Adrian Bunk return 1; 13851305e9184a3de84f78dca102b293d21007bb6c49Adrian Bunk 13861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 13871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Something is wrong 13881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Get slot won't work for devices behind bridges, but 13901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * in this case it will always be called for the "base" 1391427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang * bus/dev/func of an adapter. 1392427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 13931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13946aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_lock(&ctrl->crit_sect); 13951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds amber_LED_on (ctrl, hp_slot); 13971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds green_LED_off (ctrl, hp_slot); 13981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot_disable (ctrl, hp_slot); 13991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 14011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 14031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 14041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14056aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_unlock(&ctrl->crit_sect); 14061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 14101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 14121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 14151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * board_added - Called after a board has been added to the system. 141626e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * @func: PCI device/function info 141726e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * @ctrl: hotplug controller 14181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 141926e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * Turns power on for the board. 142026e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * Configures board. 14211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 14221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic u32 board_added(struct pci_func *func, struct controller *ctrl) 14231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 14241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 hp_slot; 14251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 temp_byte; 14261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 adapter_speed; 14271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int index; 14281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 temp_register = 0xFFFFFFFF; 14291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 rc = 0; 14301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_func *new_slot = NULL; 14313749c51ac6c1560aa1cb1520066bed84c6f8152aMatthew Wilcox struct pci_bus *bus = ctrl->pci_bus; 14321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct slot *p_slot; 14331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct resource_lists res_lists; 14341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hp_slot = func->device - ctrl->slot_device_offset; 14361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("%s: func->device, slot_offset, hp_slot = %d, %d ,%d\n", 143766bef8c059015ba2b36bb5759080336feb01e680Harvey Harrison __func__, func->device, ctrl->slot_device_offset, hp_slot); 14381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14396aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_lock(&ctrl->crit_sect); 14401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* turn on board without attaching to the bus */ 14421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds enable_slot_power(ctrl, hp_slot); 14431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 14451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 14471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 14481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Change bits in slot power register to force another shift out 1450427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang * NOTE: this is to work around the timer bug 1451427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 14521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_byte = readb(ctrl->hpc_reg + SLOT_POWER); 14531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writeb(0x00, ctrl->hpc_reg + SLOT_POWER); 14541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writeb(temp_byte, ctrl->hpc_reg + SLOT_POWER); 14551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 14571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 14591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 1460861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang 14611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds adapter_speed = get_adapter_speed(ctrl, hp_slot); 14623749c51ac6c1560aa1cb1520066bed84c6f8152aMatthew Wilcox if (bus->cur_bus_speed != adapter_speed) 14631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (set_controller_speed(ctrl, adapter_speed, hp_slot)) 14641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = WRONG_BUS_FREQUENCY; 1465861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang 14661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* turn off board without attaching to the bus */ 14671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds disable_slot_power (ctrl, hp_slot); 14681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 14701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 14721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq(ctrl); 14731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14746aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_unlock(&ctrl->crit_sect); 14751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 14771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 1478861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang 14791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot = cpqhp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset); 14801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* turn on board and blink green LED */ 14821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 148366bef8c059015ba2b36bb5759080336feb01e680Harvey Harrison dbg("%s: before down\n", __func__); 14846aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_lock(&ctrl->crit_sect); 148566bef8c059015ba2b36bb5759080336feb01e680Harvey Harrison dbg("%s: after down\n", __func__); 14861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 148766bef8c059015ba2b36bb5759080336feb01e680Harvey Harrison dbg("%s: before slot_enable\n", __func__); 14881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot_enable (ctrl, hp_slot); 14891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 149066bef8c059015ba2b36bb5759080336feb01e680Harvey Harrison dbg("%s: before green_LED_blink\n", __func__); 14911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds green_LED_blink (ctrl, hp_slot); 14921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 149366bef8c059015ba2b36bb5759080336feb01e680Harvey Harrison dbg("%s: before amber_LED_blink\n", __func__); 14941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds amber_LED_off (ctrl, hp_slot); 14951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 149666bef8c059015ba2b36bb5759080336feb01e680Harvey Harrison dbg("%s: before set_SOGO\n", __func__); 14971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 14981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 150066bef8c059015ba2b36bb5759080336feb01e680Harvey Harrison dbg("%s: before wait_for_ctrl_irq\n", __func__); 15011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 150266bef8c059015ba2b36bb5759080336feb01e680Harvey Harrison dbg("%s: after wait_for_ctrl_irq\n", __func__); 15031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 150466bef8c059015ba2b36bb5759080336feb01e680Harvey Harrison dbg("%s: before up\n", __func__); 15056aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_unlock(&ctrl->crit_sect); 150666bef8c059015ba2b36bb5759080336feb01e680Harvey Harrison dbg("%s: after up\n", __func__); 15071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for ~1 second because of hot plug spec */ 150966bef8c059015ba2b36bb5759080336feb01e680Harvey Harrison dbg("%s: before long_delay\n", __func__); 15101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds long_delay(1*HZ); 151166bef8c059015ba2b36bb5759080336feb01e680Harvey Harrison dbg("%s: after long_delay\n", __func__); 15121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 151366bef8c059015ba2b36bb5759080336feb01e680Harvey Harrison dbg("%s: func status = %x\n", __func__, func->status); 15141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check for a power fault */ 15151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (func->status == 0xFF) { 15161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* power fault occurred, but it was benign */ 15171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_register = 0xFFFFFFFF; 151866bef8c059015ba2b36bb5759080336feb01e680Harvey Harrison dbg("%s: temp register set to %x by power fault\n", __func__, temp_register); 15191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = POWER_FAILURE; 15201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->status = 0; 15211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 15221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Get vendor/device ID u32 */ 15231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ctrl->pci_bus->number = func->bus; 15241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_read_config_dword (ctrl->pci_bus, PCI_DEVFN(func->device, func->function), PCI_VENDOR_ID, &temp_register); 152566bef8c059015ba2b36bb5759080336feb01e680Harvey Harrison dbg("%s: pci_read_config_dword returns %d\n", __func__, rc); 152666bef8c059015ba2b36bb5759080336feb01e680Harvey Harrison dbg("%s: temp_register is %x\n", __func__, temp_register); 15271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc != 0) { 15291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Something's wrong here */ 15301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_register = 0xFFFFFFFF; 153166bef8c059015ba2b36bb5759080336feb01e680Harvey Harrison dbg("%s: temp register set to %x by error\n", __func__, temp_register); 15321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Preset return code. It will be changed later if things go okay. */ 15341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = NO_ADAPTER_PRESENT; 15351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* All F's is an empty slot or an invalid board */ 15381d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang if (temp_register != 0xFFFFFFFF) { 15391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds res_lists.io_head = ctrl->io_head; 15401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds res_lists.mem_head = ctrl->mem_head; 15411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds res_lists.p_mem_head = ctrl->p_mem_head; 15421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds res_lists.bus_head = ctrl->bus_head; 15431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds res_lists.irqs = NULL; 15441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = configure_new_device(ctrl, func, 0, &res_lists); 15461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 154766bef8c059015ba2b36bb5759080336feb01e680Harvey Harrison dbg("%s: back from configure_new_device\n", __func__); 15481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ctrl->io_head = res_lists.io_head; 15491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ctrl->mem_head = res_lists.mem_head; 15501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ctrl->p_mem_head = res_lists.p_mem_head; 15511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ctrl->bus_head = res_lists.bus_head; 15521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_resource_sort_and_combine(&(ctrl->mem_head)); 15541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_resource_sort_and_combine(&(ctrl->p_mem_head)); 15551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_resource_sort_and_combine(&(ctrl->io_head)); 15561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_resource_sort_and_combine(&(ctrl->bus_head)); 15571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) { 15596aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_lock(&ctrl->crit_sect); 15601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds amber_LED_on (ctrl, hp_slot); 15621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds green_LED_off (ctrl, hp_slot); 15631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot_disable (ctrl, hp_slot); 15641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 15661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 15681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 15691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15706aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_unlock(&ctrl->crit_sect); 15711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 15721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 15731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_save_slot_config(ctrl, func); 15741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->status = 0; 15781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->switch_save = 0x10; 15791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->is_a_board = 0x01; 15801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* next, we will instantiate the linux pci_dev structures (with 15821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * appropriate driver notification, if already present) */ 158366bef8c059015ba2b36bb5759080336feb01e680Harvey Harrison dbg("%s: configure linux pci_dev structure\n", __func__); 15841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds index = 0; 15851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds do { 15861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot = cpqhp_slot_find(ctrl->bus, func->device, index++); 15871d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang if (new_slot && !new_slot->pci_dev) 15881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_configure_device(ctrl, new_slot); 15891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } while (new_slot); 15901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15916aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_lock(&ctrl->crit_sect); 15921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds green_LED_on (ctrl, hp_slot); 15941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 15961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 15981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 15991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16006aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_unlock(&ctrl->crit_sect); 16011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 16026aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_lock(&ctrl->crit_sect); 16031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds amber_LED_on (ctrl, hp_slot); 16051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds green_LED_off (ctrl, hp_slot); 16061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot_disable (ctrl, hp_slot); 16071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 16091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 16111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 16121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16136aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_unlock(&ctrl->crit_sect); 16141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 16161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 16181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 16191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 162226e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * remove_board - Turns off slot and LEDs 162326e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * @func: PCI device/function info 162426e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * @replace_flag: whether replacing or adding a new device 162526e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * @ctrl: target controller 16261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 16271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic u32 remove_board(struct pci_func * func, u32 replace_flag, struct controller * ctrl) 16281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 16291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int index; 16301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 skip = 0; 16311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 device; 16321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 hp_slot; 16331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 temp_byte; 16341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 rc; 16351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct resource_lists res_lists; 16361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_func *temp_func; 16371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (cpqhp_unconfigure_device(func)) 16391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 16401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds device = func->device; 16421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hp_slot = func->device - ctrl->slot_device_offset; 164466bef8c059015ba2b36bb5759080336feb01e680Harvey Harrison dbg("In %s, hp_slot = %d\n", __func__, hp_slot); 16451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* When we get here, it is safe to change base address registers. 16471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * We will attempt to save the base address register lengths */ 16481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (replace_flag || !ctrl->add_support) 16491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = cpqhp_save_base_addr_length(ctrl, func); 16501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (!func->bus_head && !func->mem_head && 16511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds !func->p_mem_head && !func->io_head) { 16521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Here we check to see if we've saved any of the board's 16531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * resources already. If so, we'll skip the attempt to 16541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * determine what's being used. */ 16551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds index = 0; 16561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_func = cpqhp_slot_find(func->bus, func->device, index++); 16571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (temp_func) { 16581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (temp_func->bus_head || temp_func->mem_head 16591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds || temp_func->p_mem_head || temp_func->io_head) { 16601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds skip = 1; 16611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 16621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_func = cpqhp_slot_find(temp_func->bus, temp_func->device, index++); 16641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!skip) 16671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = cpqhp_save_used_resources(ctrl, func); 16681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Change status to shutdown */ 16701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (func->is_a_board) 16711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->status = 0x01; 16721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->configured = 0; 16731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16746aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_lock(&ctrl->crit_sect); 16751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds green_LED_off (ctrl, hp_slot); 16771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot_disable (ctrl, hp_slot); 16781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 16801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* turn off SERR for slot */ 16821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_byte = readb(ctrl->hpc_reg + SLOT_SERR); 16831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_byte &= ~(0x01 << hp_slot); 16841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writeb(temp_byte, ctrl->hpc_reg + SLOT_SERR); 16851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 16871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 16881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16896aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_unlock(&ctrl->crit_sect); 16901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!replace_flag && ctrl->add_support) { 16921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (func) { 16931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds res_lists.io_head = ctrl->io_head; 16941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds res_lists.mem_head = ctrl->mem_head; 16951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds res_lists.p_mem_head = ctrl->p_mem_head; 16961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds res_lists.bus_head = ctrl->bus_head; 16971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_return_board_resources(func, &res_lists); 16991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ctrl->io_head = res_lists.io_head; 17011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ctrl->mem_head = res_lists.mem_head; 17021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ctrl->p_mem_head = res_lists.p_mem_head; 17031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ctrl->bus_head = res_lists.bus_head; 17041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_resource_sort_and_combine(&(ctrl->mem_head)); 17061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_resource_sort_and_combine(&(ctrl->p_mem_head)); 17071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_resource_sort_and_combine(&(ctrl->io_head)); 17081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_resource_sort_and_combine(&(ctrl->bus_head)); 17091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (is_bridge(func)) { 17111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bridge_slot_remove(func); 17121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else 17131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot_remove(func); 17141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func = cpqhp_slot_find(ctrl->bus, device, 0); 17161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Setup slot structure with entry for empty slot */ 17191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func = cpqhp_slot_create(ctrl->bus); 17201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (func == NULL) 17221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 17231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->bus = ctrl->bus; 17251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->device = device; 17261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->function = 0; 17271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->configured = 0; 17281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->switch_save = 0x10; 17291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->is_a_board = 0; 17301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->p_task_event = NULL; 17311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 17341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 17351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void pushbutton_helper_thread(unsigned long data) 17371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 17381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pushbutton_pending = data; 1739fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig wake_up_process(cpqhp_event_thread); 17401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 17411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* this is the main worker thread */ 17441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int event_thread(void* data) 17451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 17461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct controller *ctrl; 174760ac8f20feb0bba8caee63be3e7ca5801fe16d4cIngo Molnar 17481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (1) { 17491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("!!!!event_thread sleeping\n"); 1750fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig set_current_state(TASK_INTERRUPTIBLE); 1751fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig schedule(); 1752fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig 1753fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig if (kthread_should_stop()) 1754fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig break; 17551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Do stuff here */ 17561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pushbutton_pending) 17571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_pushbutton_thread(pushbutton_pending); 17581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 17591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (ctrl = cpqhp_ctrl_list; ctrl; ctrl=ctrl->next) 17601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds interrupt_event_handler(ctrl); 17611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("event_thread signals exit\n"); 17631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 17641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 17651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsint cpqhp_event_start_thread(void) 17671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 1768fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig cpqhp_event_thread = kthread_run(event_thread, NULL, "phpd_event"); 1769fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig if (IS_ERR(cpqhp_event_thread)) { 17701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds err ("Can't start up our event thread\n"); 1771fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig return PTR_ERR(cpqhp_event_thread); 17721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 1773fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig 17741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 17751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 17761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsvoid cpqhp_event_stop_thread(void) 17791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 1780fa007d8bebc5d812a445c48664b5bcad81f1351cChristoph Hellwig kthread_stop(cpqhp_event_thread); 17811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 17821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int update_slot_info(struct controller *ctrl, struct slot *slot) 17851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 17861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct hotplug_slot_info *info; 17871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int result; 17881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds info = kmalloc(sizeof(*info), GFP_KERNEL); 17901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!info) 17911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return -ENOMEM; 17921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds info->power_status = get_slot_enabled(ctrl, slot); 17941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds info->attention_status = cpq_get_attention_status(ctrl, slot); 17951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds info->latch_status = cpq_get_latch_status(ctrl, slot); 17961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds info->adapter_status = get_presence_status(ctrl, slot); 17971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds result = pci_hp_change_slot_info(slot->hotplug_slot, info); 17981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree (info); 17991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return result; 18001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 18011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void interrupt_event_handler(struct controller *ctrl) 18031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 18041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int loop = 0; 18051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int change = 1; 18061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_func *func; 18071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 hp_slot; 18081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct slot *p_slot; 18091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (change) { 18111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds change = 0; 18121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (loop = 0; loop < 10; loop++) { 18141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* dbg("loop %d\n", loop); */ 18151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (ctrl->event_queue[loop].event_type != 0) { 18161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hp_slot = ctrl->event_queue[loop].hp_slot; 18171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func = cpqhp_slot_find(ctrl->bus, (hp_slot + ctrl->slot_device_offset), 0); 18191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!func) 18201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 18211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot = cpqhp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset); 18231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!p_slot) 18241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 18251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("hp_slot %d, func %p, p_slot %p\n", 18271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hp_slot, func, p_slot); 18281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (ctrl->event_queue[loop].event_type == INT_BUTTON_PRESS) { 18301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("button pressed\n"); 18311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if (ctrl->event_queue[loop].event_type == 18321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds INT_BUTTON_CANCEL) { 18331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("button cancel\n"); 18341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds del_timer(&p_slot->task_event); 18351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18366aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_lock(&ctrl->crit_sect); 18371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (p_slot->state == BLINKINGOFF_STATE) { 18391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* slot is on */ 18401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("turn on green LED\n"); 18411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds green_LED_on (ctrl, hp_slot); 18421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if (p_slot->state == BLINKINGON_STATE) { 18431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* slot is off */ 18441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("turn off green LED\n"); 18451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds green_LED_off (ctrl, hp_slot); 18461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 18471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds info(msg_button_cancel, p_slot->number); 18491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot->state = STATIC_STATE; 18511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds amber_LED_off (ctrl, hp_slot); 18531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 18551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 18571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 18581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18596aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_unlock(&ctrl->crit_sect); 18601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 18611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /*** button Released (No action on press...) */ 18621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (ctrl->event_queue[loop].event_type == INT_BUTTON_RELEASE) { 18631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("button release\n"); 18641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (is_slot_enabled (ctrl, hp_slot)) { 18661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("slot is on\n"); 18671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot->state = BLINKINGOFF_STATE; 18681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds info(msg_button_off, p_slot->number); 18691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 18701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("slot is off\n"); 18711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot->state = BLINKINGON_STATE; 18721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds info(msg_button_on, p_slot->number); 18731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 18746aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_lock(&ctrl->crit_sect); 1875861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang 18761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("blink green LED and turn off amber\n"); 1877861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang 18781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds amber_LED_off (ctrl, hp_slot); 18791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds green_LED_blink (ctrl, hp_slot); 1880861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang 18811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 18821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 18841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 18851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18866aa4cdd07139ba4d5b89139b0070d795cc4dea88Ingo Molnar mutex_unlock(&ctrl->crit_sect); 18871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds init_timer(&p_slot->task_event); 18881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot->hp_slot = hp_slot; 18891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot->ctrl = ctrl; 18901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* p_slot->physical_slot = physical_slot; */ 18911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot->task_event.expires = jiffies + 5 * HZ; /* 5 second delay */ 18921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot->task_event.function = pushbutton_helper_thread; 18931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot->task_event.data = (u32) p_slot; 18941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("add_timer p_slot = %p\n", p_slot); 18961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds add_timer(&p_slot->task_event); 18971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 18981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /***********POWER FAULT */ 18991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (ctrl->event_queue[loop].event_type == INT_POWER_FAULT) { 19001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("power fault\n"); 19011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 19021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* refresh notification */ 19031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (p_slot) 19041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds update_slot_info(ctrl, p_slot); 19051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 19061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ctrl->event_queue[loop].event_type = 0; 19081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds change = 1; 19101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 19111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } /* End of FOR loop */ 19121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 19131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 19151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 19161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 191926e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * cpqhp_pushbutton_thread - handle pushbutton events 192026e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * @slot: target slot (struct) 19211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 192226e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * Scheduled procedure to handle blocking stuff for the pushbuttons. 19231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Handles all pending events and exits. 19241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 19251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsvoid cpqhp_pushbutton_thread(unsigned long slot) 19261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 19271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 hp_slot; 19281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 device; 19291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_func *func; 19301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct slot *p_slot = (struct slot *) slot; 19311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct controller *ctrl = (struct controller *) p_slot->ctrl; 19321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pushbutton_pending = 0; 19341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hp_slot = p_slot->hp_slot; 19351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds device = p_slot->device; 19371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (is_slot_enabled(ctrl, hp_slot)) { 19391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot->state = POWEROFF_STATE; 19401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* power Down board */ 19411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func = cpqhp_slot_find(p_slot->bus, p_slot->device, 0); 19421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("In power_down_board, func = %p, ctrl = %p\n", func, ctrl); 19431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!func) { 194466bef8c059015ba2b36bb5759080336feb01e680Harvey Harrison dbg("Error! func NULL in %s\n", __func__); 19451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return ; 19461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 19471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 194800395410885cac96015850426bf697423a3ec9dcAdrian Bunk if (cpqhp_process_SS(ctrl, func) != 0) { 194900395410885cac96015850426bf697423a3ec9dcAdrian Bunk amber_LED_on(ctrl, hp_slot); 195000395410885cac96015850426bf697423a3ec9dcAdrian Bunk green_LED_on(ctrl, hp_slot); 19511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 195200395410885cac96015850426bf697423a3ec9dcAdrian Bunk set_SOGO(ctrl); 195300395410885cac96015850426bf697423a3ec9dcAdrian Bunk 195400395410885cac96015850426bf697423a3ec9dcAdrian Bunk /* Wait for SOBS to be unset */ 195500395410885cac96015850426bf697423a3ec9dcAdrian Bunk wait_for_ctrl_irq(ctrl); 19561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 19571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot->state = STATIC_STATE; 19591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 19601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot->state = POWERON_STATE; 19611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* slot is off */ 19621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func = cpqhp_slot_find(p_slot->bus, p_slot->device, 0); 19641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("In add_board, func = %p, ctrl = %p\n", func, ctrl); 19651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!func) { 196666bef8c059015ba2b36bb5759080336feb01e680Harvey Harrison dbg("Error! func NULL in %s\n", __func__); 19671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return ; 19681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 19691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1970b8d9cb2a2226118fd71f657c80b06b670a653022Julia Lawall if (ctrl != NULL) { 19711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (cpqhp_process_SI(ctrl, func) != 0) { 19721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds amber_LED_on(ctrl, hp_slot); 19731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds green_LED_off(ctrl, hp_slot); 1974861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang 19751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 19761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOBS to be unset */ 19781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq (ctrl); 19791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 19801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 19811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot->state = STATIC_STATE; 19831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 19841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 19861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 19871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsint cpqhp_process_SI(struct controller *ctrl, struct pci_func *func) 19901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 19911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 device, hp_slot; 19921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u16 temp_word; 19931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 tempdword; 19941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int rc; 19951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct slot* p_slot; 19961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int physical_slot = 0; 19971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tempdword = 0; 19991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds device = func->device; 20011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hp_slot = device - ctrl->slot_device_offset; 20021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot = cpqhp_find_slot(ctrl, device); 20031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (p_slot) 20041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds physical_slot = p_slot->number; 20051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check to see if the interlock is closed */ 20071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tempdword = readl(ctrl->hpc_reg + INT_INPUT_CLEAR); 20081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (tempdword & (0x01 << hp_slot)) { 20101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 20111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 20121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (func->is_a_board) { 20141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = board_replaced(func, ctrl); 20151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 20161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* add board */ 20171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot_remove(func); 20181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func = cpqhp_slot_create(ctrl->bus); 20201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (func == NULL) 20211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 20221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->bus = ctrl->bus; 20241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->device = device; 20251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->function = 0; 20261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->configured = 0; 20271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->is_a_board = 1; 20281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* We have to save the presence info for these slots */ 20301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_word = ctrl->ctrl_int_comp >> 16; 20311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->presence_save = (temp_word >> hp_slot) & 0x01; 20321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->presence_save |= (temp_word >> (hp_slot + 7)) & 0x02; 20331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (ctrl->ctrl_int_comp & (0x1L << hp_slot)) { 20351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->switch_save = 0; 20361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 20371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->switch_save = 0x10; 20381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 20391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = board_added(func, ctrl); 20411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) { 20421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (is_bridge(func)) { 20431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bridge_slot_remove(func); 20441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else 20451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot_remove(func); 20461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Setup slot structure with entry for empty slot */ 20481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func = cpqhp_slot_create(ctrl->bus); 20491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (func == NULL) 20511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 20521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->bus = ctrl->bus; 20541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->device = device; 20551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->function = 0; 20561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->configured = 0; 20571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->is_a_board = 0; 20581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* We have to save the presence info for these slots */ 20601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_word = ctrl->ctrl_int_comp >> 16; 20611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->presence_save = (temp_word >> hp_slot) & 0x01; 20621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->presence_save |= 20631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (temp_word >> (hp_slot + 7)) & 0x02; 20641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (ctrl->ctrl_int_comp & (0x1L << hp_slot)) { 20661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->switch_save = 0; 20671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 20681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->switch_save = 0x10; 20691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 20701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 20711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 20721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) { 207466bef8c059015ba2b36bb5759080336feb01e680Harvey Harrison dbg("%s: rc = %d\n", __func__, rc); 20751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 20761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (p_slot) 20781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds update_slot_info(ctrl, p_slot); 20791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 20811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 20821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsint cpqhp_process_SS(struct controller *ctrl, struct pci_func *func) 20851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 20861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 device, class_code, header_type, BCR; 20871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 index = 0; 20881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 replace_flag; 20891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 rc = 0; 20901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int devfn; 20911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct slot* p_slot; 20921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_bus *pci_bus = ctrl->pci_bus; 20931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int physical_slot=0; 20941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2095861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang device = func->device; 20961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func = cpqhp_slot_find(ctrl->bus, device, index++); 20971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_slot = cpqhp_find_slot(ctrl, device); 20981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (p_slot) { 20991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds physical_slot = p_slot->number; 21001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 21011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Make sure there are no video controllers here */ 21031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (func && !rc) { 21041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_bus->number = func->bus; 21051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds devfn = PCI_DEVFN(func->device, func->function); 21061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check the Class Code */ 21081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_read_config_byte (pci_bus, devfn, 0x0B, &class_code); 21091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 21101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 21111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (class_code == PCI_BASE_CLASS_DISPLAY) { 21131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Display/Video adapter (not supported) */ 21141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = REMOVE_NOT_SUPPORTED; 21151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 21161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* See if it's a bridge */ 21171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_read_config_byte (pci_bus, devfn, PCI_HEADER_TYPE, &header_type); 21181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 21191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 21201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If it's a bridge, check the VGA Enable bit */ 21221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((header_type & 0x7F) == PCI_HEADER_TYPE_BRIDGE) { 21231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_read_config_byte (pci_bus, devfn, PCI_BRIDGE_CONTROL, &BCR); 21241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 21251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 21261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If the VGA Enable bit is set, remove isn't 21281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * supported */ 21291d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang if (BCR & PCI_BRIDGE_CTL_VGA) 21301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = REMOVE_NOT_SUPPORTED; 21311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 21321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 21331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func = cpqhp_slot_find(ctrl->bus, device, index++); 21351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 21361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func = cpqhp_slot_find(ctrl->bus, device, 0); 21381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((func != NULL) && !rc) { 21391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* FIXME: Replace flag should be passed into process_SS */ 21401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds replace_flag = !(ctrl->add_support); 21411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = remove_board(func, replace_flag, ctrl); 21421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if (!rc) { 21431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = 1; 21441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 21451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (p_slot) 21471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds update_slot_info(ctrl, p_slot); 21481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 21501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 21511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 215326e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * switch_leds - switch the leds, go from one site to the other. 21541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @ctrl: controller to use 21551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @num_of_slots: number of slots to use 215626e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * @work_LED: LED control value 21571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @direction: 1 to start from the left side, 0 to start right. 21581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 21591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void switch_leds(struct controller *ctrl, const int num_of_slots, 21601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 *work_LED, const int direction) 21611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 21621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int loop; 21631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (loop = 0; loop < num_of_slots; loop++) { 21651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (direction) 21661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *work_LED = *work_LED >> 1; 21671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 21681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *work_LED = *work_LED << 1; 21691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(*work_LED, ctrl->hpc_reg + LED_CONTROL); 21701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_SOGO(ctrl); 21721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Wait for SOGO interrupt */ 21741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_ctrl_irq(ctrl); 21751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Get ready for next iteration */ 21771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds long_delay((2*HZ)/10); 21781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 21791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 21801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 218226e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * cpqhp_hardware_test - runs hardware tests 218326e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * @ctrl: target controller 218426e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * @test_num: the number written to the "test" file in sysfs. 21851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 21861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * For hot plug ctrl folks to play with. 21871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 21881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsint cpqhp_hardware_test(struct controller *ctrl, int test_num) 21891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 21901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 save_LED; 21911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 work_LED; 21921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int loop; 21931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int num_of_slots; 21941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds num_of_slots = readb(ctrl->hpc_reg + SLOT_MASK) & 0x0f; 21961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds switch (test_num) { 21981d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang case 1: 21991d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang /* Do stuff here! */ 22001d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang 22011d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang /* Do that funky LED thing */ 22021d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang /* so we can restore them later */ 22031d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang save_LED = readl(ctrl->hpc_reg + LED_CONTROL); 22041d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang work_LED = 0x01010101; 22051d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang switch_leds(ctrl, num_of_slots, &work_LED, 0); 22061d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang switch_leds(ctrl, num_of_slots, &work_LED, 1); 22071d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang switch_leds(ctrl, num_of_slots, &work_LED, 0); 22081d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang switch_leds(ctrl, num_of_slots, &work_LED, 1); 22091d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang 22101d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang work_LED = 0x01010000; 22111d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang writel(work_LED, ctrl->hpc_reg + LED_CONTROL); 22121d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang switch_leds(ctrl, num_of_slots, &work_LED, 0); 22131d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang switch_leds(ctrl, num_of_slots, &work_LED, 1); 22141d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang work_LED = 0x00000101; 22151d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang writel(work_LED, ctrl->hpc_reg + LED_CONTROL); 22161d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang switch_leds(ctrl, num_of_slots, &work_LED, 0); 22171d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang switch_leds(ctrl, num_of_slots, &work_LED, 1); 22181d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang 22191d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang work_LED = 0x01010000; 22201d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang writel(work_LED, ctrl->hpc_reg + LED_CONTROL); 22211d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang for (loop = 0; loop < num_of_slots; loop++) { 22221d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang set_SOGO(ctrl); 22231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 22241d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang /* Wait for SOGO interrupt */ 22251d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang wait_for_ctrl_irq (ctrl); 22261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 22271d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang /* Get ready for next iteration */ 22281d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang long_delay((3*HZ)/10); 22291d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang work_LED = work_LED >> 16; 22301d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang writel(work_LED, ctrl->hpc_reg + LED_CONTROL); 2231861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang 22321d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang set_SOGO(ctrl); 22331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 22341d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang /* Wait for SOGO interrupt */ 22351d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang wait_for_ctrl_irq (ctrl); 22361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 22371d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang /* Get ready for next iteration */ 22381d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang long_delay((3*HZ)/10); 22391d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang work_LED = work_LED << 16; 22401d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang writel(work_LED, ctrl->hpc_reg + LED_CONTROL); 22411d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang work_LED = work_LED << 1; 22421d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang writel(work_LED, ctrl->hpc_reg + LED_CONTROL); 22431d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang } 22441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 22451d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang /* put it back the way it was */ 22461d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang writel(save_LED, ctrl->hpc_reg + LED_CONTROL); 22471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 22481d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang set_SOGO(ctrl); 22491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 22501d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang /* Wait for SOBS to be unset */ 22511d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang wait_for_ctrl_irq (ctrl); 22521d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang break; 22531d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang case 2: 22541d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang /* Do other stuff here! */ 22551d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang break; 22561d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang case 3: 22571d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang /* and more... */ 22581d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang break; 22591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 22601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 22611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 22621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 22631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 22641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 22651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * configure_new_device - Configures the PCI header information of one board. 22661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @ctrl: pointer to controller structure 22671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @func: pointer to function structure 22681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @behind_bridge: 1 if this is a recursive call, 0 if not 22691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @resources: pointer to set of resource lists 22701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 227126e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * Returns 0 if success. 22721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 22731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic u32 configure_new_device(struct controller * ctrl, struct pci_func * func, 22741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 behind_bridge, struct resource_lists * resources) 22751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 22761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 temp_byte, function, max_functions, stop_it; 22771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int rc; 22781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 ID; 22791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_func *new_slot; 22801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int index; 22811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 22821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot = func; 22831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 228466bef8c059015ba2b36bb5759080336feb01e680Harvey Harrison dbg("%s\n", __func__); 22851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check for Multi-function device */ 22861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ctrl->pci_bus->number = func->bus; 22871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_read_config_byte (ctrl->pci_bus, PCI_DEVFN(func->device, func->function), 0x0E, &temp_byte); 22881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) { 228966bef8c059015ba2b36bb5759080336feb01e680Harvey Harrison dbg("%s: rc = %d\n", __func__, rc); 22901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 22911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 22921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 22931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (temp_byte & 0x80) /* Multi-function device */ 22941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds max_functions = 8; 22951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 22961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds max_functions = 1; 22971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 22981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds function = 0; 22991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds do { 23011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = configure_new_function(ctrl, new_slot, behind_bridge, resources); 23021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) { 23041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("configure_new_function failed %d\n",rc); 23051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds index = 0; 23061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (new_slot) { 23081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot = cpqhp_slot_find(new_slot->bus, new_slot->device, index++); 23091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (new_slot) 23111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_return_board_resources(new_slot, resources); 23121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 23131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 23151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 23161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds function++; 23181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds stop_it = 0; 23201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* The following loop skips to the next present function 23221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * and creates a board structure */ 23231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while ((function < max_functions) && (!stop_it)) { 23251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_bus_read_config_dword (ctrl->pci_bus, PCI_DEVFN(func->device, function), 0x00, &ID); 23261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23271d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang if (ID == 0xFFFFFFFF) { 23281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds function++; 23291d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang } else { 23301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Setup slot structure. */ 23311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot = cpqhp_slot_create(func->bus); 23321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (new_slot == NULL) 23341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 23351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot->bus = func->bus; 23371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot->device = func->device; 23381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot->function = function; 23391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot->is_a_board = 1; 23401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot->status = 0; 23411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds stop_it++; 23431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 23441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 23451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } while (function < max_functions); 23471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("returning from configure_new_device\n"); 23481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 23501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 23511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* 23541d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang * Configuration logic that involves the hotplug data structures and 23551d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang * their bookkeeping 23561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 23571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 23601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * configure_new_function - Configures the PCI header information of one device 23611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @ctrl: pointer to controller structure 23621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @func: pointer to function structure 23631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @behind_bridge: 1 if this is a recursive call, 0 if not 23641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @resources: pointer to set of resource lists 23651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 23661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Calls itself recursively for bridged devices. 236726e6c66e47fe7f69ef6ddb078e312204a1f17823Randy Dunlap * Returns 0 if success. 23681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 23691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int configure_new_function(struct controller *ctrl, struct pci_func *func, 23701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 behind_bridge, 23711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct resource_lists *resources) 23721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 23731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int cloop; 23741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 IRQ = 0; 23751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 temp_byte; 23761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 device; 23771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 class_code; 23781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u16 command; 23791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u16 temp_word; 23801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 temp_dword; 23811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 rc; 23821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 temp_register; 23831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 base; 23841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 ID; 23851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int devfn; 23861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *mem_node; 23871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *p_mem_node; 23881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *io_node; 23891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *bus_node; 23901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *hold_mem_node; 23911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *hold_p_mem_node; 23921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *hold_IO_node; 23931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_resource *hold_bus_node; 23941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct irq_mapping irqs; 23951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_func *new_slot; 23961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_bus *pci_bus; 23971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct resource_lists temp_resources; 23981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 23991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_bus = ctrl->pci_bus; 24001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_bus->number = func->bus; 24011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds devfn = PCI_DEVFN(func->device, func->function); 24021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 24031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check for Bridge */ 24041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_read_config_byte(pci_bus, devfn, PCI_HEADER_TYPE, &temp_byte); 24051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 24061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 24071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 24081d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang if ((temp_byte & 0x7F) == PCI_HEADER_TYPE_BRIDGE) { 24091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* set Primary bus */ 24101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("set Primary bus = %d\n", func->bus); 24111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_PRIMARY_BUS, func->bus); 24121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 24131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 24141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 24151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* find range of busses to use */ 24161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("find ranges of buses to use\n"); 24171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bus_node = get_max_resource(&(resources->bus_head), 1); 24181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 24191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If we don't have any busses to allocate, we can't continue */ 24201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!bus_node) 24211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return -ENOMEM; 24221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 24231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* set Secondary bus */ 24241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_byte = bus_node->base; 24251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("set Secondary bus = %d\n", bus_node->base); 24261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_SECONDARY_BUS, temp_byte); 24271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 24281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 24291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 24301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* set subordinate bus */ 24311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_byte = bus_node->base + bus_node->length - 1; 24321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("set subordinate bus = %d\n", bus_node->base + bus_node->length - 1); 24331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_SUBORDINATE_BUS, temp_byte); 24341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 24351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 24361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 24371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* set subordinate Latency Timer and base Latency Timer */ 24381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_byte = 0x40; 24391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_SEC_LATENCY_TIMER, temp_byte); 24401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 24411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 24421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_LATENCY_TIMER, temp_byte); 24431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 24441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 24451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 24461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* set Cache Line size */ 24471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_byte = 0x08; 24481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_CACHE_LINE_SIZE, temp_byte); 24491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 24501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 24511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 24521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Setup the IO, memory, and prefetchable windows */ 24531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds io_node = get_max_resource(&(resources->io_head), 0x1000); 24541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!io_node) 24551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return -ENOMEM; 24561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mem_node = get_max_resource(&(resources->mem_head), 0x100000); 24571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!mem_node) 24581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return -ENOMEM; 24591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_mem_node = get_max_resource(&(resources->p_mem_head), 0x100000); 24601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!p_mem_node) 24611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return -ENOMEM; 24621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("Setup the IO, memory, and prefetchable windows\n"); 24631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("io_node\n"); 24641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("(base, len, next) (%x, %x, %p)\n", io_node->base, 24651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds io_node->length, io_node->next); 24661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("mem_node\n"); 24671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("(base, len, next) (%x, %x, %p)\n", mem_node->base, 24681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mem_node->length, mem_node->next); 24691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("p_mem_node\n"); 24701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("(base, len, next) (%x, %x, %p)\n", p_mem_node->base, 24711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_mem_node->length, p_mem_node->next); 24721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 24731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* set up the IRQ info */ 24741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!resources->irqs) { 24751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds irqs.barber_pole = 0; 24761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds irqs.interrupt[0] = 0; 24771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds irqs.interrupt[1] = 0; 24781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds irqs.interrupt[2] = 0; 24791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds irqs.interrupt[3] = 0; 24801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds irqs.valid_INT = 0; 24811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 24821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds irqs.barber_pole = resources->irqs->barber_pole; 24831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds irqs.interrupt[0] = resources->irqs->interrupt[0]; 24841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds irqs.interrupt[1] = resources->irqs->interrupt[1]; 24851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds irqs.interrupt[2] = resources->irqs->interrupt[2]; 24861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds irqs.interrupt[3] = resources->irqs->interrupt[3]; 24871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds irqs.valid_INT = resources->irqs->valid_INT; 24881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 24891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 24901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* set up resource lists that are now aligned on top and bottom 24911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * for anything behind the bridge. */ 24921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_resources.bus_head = bus_node; 24931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_resources.io_head = io_node; 24941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_resources.mem_head = mem_node; 24951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_resources.p_mem_head = p_mem_node; 24961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_resources.irqs = &irqs; 24971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 24981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Make copies of the nodes we are going to pass down so that 2499427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang * if there is a problem,we can just use these to free resources 2500427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 25011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_bus_node = kmalloc(sizeof(*hold_bus_node), GFP_KERNEL); 25021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_IO_node = kmalloc(sizeof(*hold_IO_node), GFP_KERNEL); 25031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_mem_node = kmalloc(sizeof(*hold_mem_node), GFP_KERNEL); 25041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_p_mem_node = kmalloc(sizeof(*hold_p_mem_node), GFP_KERNEL); 25051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!hold_bus_node || !hold_IO_node || !hold_mem_node || !hold_p_mem_node) { 25071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree(hold_bus_node); 25081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree(hold_IO_node); 25091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree(hold_mem_node); 25101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree(hold_p_mem_node); 25111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 25131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 25141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds memcpy(hold_bus_node, bus_node, sizeof(struct pci_resource)); 25161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bus_node->base += 1; 25181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bus_node->length -= 1; 25191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bus_node->next = NULL; 25201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If we have IO resources copy them and fill in the bridge's 25221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * IO range registers */ 25231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (io_node) { 25241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds memcpy(hold_IO_node, io_node, sizeof(struct pci_resource)); 25251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds io_node->next = NULL; 25261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* set IO base and Limit registers */ 25281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_byte = io_node->base >> 8; 25291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_IO_BASE, temp_byte); 25301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_byte = (io_node->base + io_node->length - 1) >> 8; 25321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_IO_LIMIT, temp_byte); 25331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 25341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree(hold_IO_node); 25351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_IO_node = NULL; 25361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 25371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If we have memory resources copy them and fill in the 25391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * bridge's memory range registers. Otherwise, fill in the 25401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * range registers with values that disable them. */ 25411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (mem_node) { 25421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds memcpy(hold_mem_node, mem_node, sizeof(struct pci_resource)); 25431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mem_node->next = NULL; 25441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* set Mem base and Limit registers */ 25461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_word = mem_node->base >> 16; 25471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_word(pci_bus, devfn, PCI_MEMORY_BASE, temp_word); 25481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_word = (mem_node->base + mem_node->length - 1) >> 16; 25501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_word(pci_bus, devfn, PCI_MEMORY_LIMIT, temp_word); 25511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 25521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_word = 0xFFFF; 25531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_word(pci_bus, devfn, PCI_MEMORY_BASE, temp_word); 25541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_word = 0x0000; 25561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_word(pci_bus, devfn, PCI_MEMORY_LIMIT, temp_word); 25571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree(hold_mem_node); 25591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_mem_node = NULL; 25601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 25611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25622555f7bdd3b0db47f6e1d7bb887981654e2261b3Adrian Bunk memcpy(hold_p_mem_node, p_mem_node, sizeof(struct pci_resource)); 25632555f7bdd3b0db47f6e1d7bb887981654e2261b3Adrian Bunk p_mem_node->next = NULL; 25641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25652555f7bdd3b0db47f6e1d7bb887981654e2261b3Adrian Bunk /* set Pre Mem base and Limit registers */ 25662555f7bdd3b0db47f6e1d7bb887981654e2261b3Adrian Bunk temp_word = p_mem_node->base >> 16; 25672555f7bdd3b0db47f6e1d7bb887981654e2261b3Adrian Bunk rc = pci_bus_write_config_word (pci_bus, devfn, PCI_PREF_MEMORY_BASE, temp_word); 25681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25692555f7bdd3b0db47f6e1d7bb887981654e2261b3Adrian Bunk temp_word = (p_mem_node->base + p_mem_node->length - 1) >> 16; 25702555f7bdd3b0db47f6e1d7bb887981654e2261b3Adrian Bunk rc = pci_bus_write_config_word (pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, temp_word); 25711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2572427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang /* Adjust this to compensate for extra adjustment in first loop 2573427438c61b0083a60bb953cb36cfdc5841f0bb03Alex Chiang */ 25741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds irqs.barber_pole--; 25751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = 0; 25771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Here we actually find the devices and configure them */ 25791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (device = 0; (device <= 0x1F) && !rc; device++) { 25801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds irqs.barber_pole = (irqs.barber_pole + 1) & 0x03; 25811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ID = 0xFFFFFFFF; 25831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_bus->number = hold_bus_node->base; 25841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_bus_read_config_dword (pci_bus, PCI_DEVFN(device, 0), 0x00, &ID); 25851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_bus->number = func->bus; 25861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (ID != 0xFFFFFFFF) { /* device present */ 25881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Setup slot structure. */ 25891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot = cpqhp_slot_create(hold_bus_node->base); 25901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (new_slot == NULL) { 25921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = -ENOMEM; 25931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 25941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 25951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 25961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot->bus = hold_bus_node->base; 25971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot->device = device; 25981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot->function = 0; 25991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot->is_a_board = 1; 26001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_slot->status = 0; 26011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 26021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = configure_new_device(ctrl, new_slot, 1, &temp_resources); 26031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("configure_new_device rc=0x%x\n",rc); 26041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } /* End of IF (device in slot?) */ 26051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } /* End of FOR loop */ 26061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 26071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 26081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto free_and_out; 26091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* save the interrupt routing information */ 26101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (resources->irqs) { 26111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds resources->irqs->interrupt[0] = irqs.interrupt[0]; 26121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds resources->irqs->interrupt[1] = irqs.interrupt[1]; 26131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds resources->irqs->interrupt[2] = irqs.interrupt[2]; 26141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds resources->irqs->interrupt[3] = irqs.interrupt[3]; 26151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds resources->irqs->valid_INT = irqs.valid_INT; 26161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if (!behind_bridge) { 26171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* We need to hook up the interrupts here */ 26181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (cloop = 0; cloop < 4; cloop++) { 26191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (irqs.valid_INT & (0x01 << cloop)) { 26201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = cpqhp_set_irq(func->bus, func->device, 262198d3333a13029ab07ca1d1bfb9bfa138ea76c3c0Bjorn Helgaas cloop + 1, irqs.interrupt[cloop]); 26221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 26231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto free_and_out; 26241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 26251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } /* end of for loop */ 26261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 26271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Return unused bus resources 26281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * First use the temporary node to store information for 26291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * the board */ 26301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (hold_bus_node && bus_node && temp_resources.bus_head) { 26311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_bus_node->length = bus_node->base - hold_bus_node->base; 26321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 26331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_bus_node->next = func->bus_head; 26341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->bus_head = hold_bus_node; 26351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 26361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_byte = temp_resources.bus_head->base - 1; 26371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 26381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* set subordinate bus */ 26391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_byte (pci_bus, devfn, PCI_SUBORDINATE_BUS, temp_byte); 26401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 26411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (temp_resources.bus_head->length == 0) { 26421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree(temp_resources.bus_head); 26431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_resources.bus_head = NULL; 26441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 26451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return_resource(&(resources->bus_head), temp_resources.bus_head); 26461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 26471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 26481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 26491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If we have IO space available and there is some left, 26501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * return the unused portion */ 26511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (hold_IO_node && temp_resources.io_head) { 26521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds io_node = do_pre_bridge_resource_split(&(temp_resources.io_head), 26531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds &hold_IO_node, 0x1000); 26541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 26551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check if we were able to split something off */ 26561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (io_node) { 26571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_IO_node->base = io_node->base + io_node->length; 26581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 26591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_byte = (hold_IO_node->base) >> 8; 26601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_word (pci_bus, devfn, PCI_IO_BASE, temp_byte); 26611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 26621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return_resource(&(resources->io_head), io_node); 26631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 26641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 26651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds io_node = do_bridge_resource_split(&(temp_resources.io_head), 0x1000); 26661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 26671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check if we were able to split something off */ 26681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (io_node) { 26691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* First use the temporary node to store 26701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * information for the board */ 26711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_IO_node->length = io_node->base - hold_IO_node->base; 26721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 26731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If we used any, add it to the board's list */ 26741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (hold_IO_node->length) { 26751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_IO_node->next = func->io_head; 26761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->io_head = hold_IO_node; 26771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 26781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_byte = (io_node->base - 1) >> 8; 26791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_byte (pci_bus, devfn, PCI_IO_LIMIT, temp_byte); 26801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 26811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return_resource(&(resources->io_head), io_node); 26821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 26831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* it doesn't need any IO */ 26841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_word = 0x0000; 26851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_word (pci_bus, devfn, PCI_IO_LIMIT, temp_word); 26861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 26871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return_resource(&(resources->io_head), io_node); 26881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree(hold_IO_node); 26891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 26901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 26911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* it used most of the range */ 26921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_IO_node->next = func->io_head; 26931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->io_head = hold_IO_node; 26941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 26951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if (hold_IO_node) { 26961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* it used the whole range */ 26971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_IO_node->next = func->io_head; 26981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->io_head = hold_IO_node; 26991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 27001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If we have memory space available and there is some left, 27011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * return the unused portion */ 27021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (hold_mem_node && temp_resources.mem_head) { 27031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mem_node = do_pre_bridge_resource_split(&(temp_resources. mem_head), 27041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds &hold_mem_node, 0x100000); 27051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check if we were able to split something off */ 27071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (mem_node) { 27081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_mem_node->base = mem_node->base + mem_node->length; 27091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_word = (hold_mem_node->base) >> 16; 27111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_word (pci_bus, devfn, PCI_MEMORY_BASE, temp_word); 27121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return_resource(&(resources->mem_head), mem_node); 27141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 27151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mem_node = do_bridge_resource_split(&(temp_resources.mem_head), 0x100000); 27171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check if we were able to split something off */ 27191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (mem_node) { 27201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* First use the temporary node to store 27211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * information for the board */ 27221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_mem_node->length = mem_node->base - hold_mem_node->base; 27231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (hold_mem_node->length) { 27251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_mem_node->next = func->mem_head; 27261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->mem_head = hold_mem_node; 27271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* configure end address */ 27291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_word = (mem_node->base - 1) >> 16; 27301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_word (pci_bus, devfn, PCI_MEMORY_LIMIT, temp_word); 27311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Return unused resources to the pool */ 27331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return_resource(&(resources->mem_head), mem_node); 27341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 27351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* it doesn't need any Mem */ 27361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_word = 0x0000; 27371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_word (pci_bus, devfn, PCI_MEMORY_LIMIT, temp_word); 27381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return_resource(&(resources->mem_head), mem_node); 27401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree(hold_mem_node); 27411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 27421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 27431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* it used most of the range */ 27441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_mem_node->next = func->mem_head; 27451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->mem_head = hold_mem_node; 27461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 27471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if (hold_mem_node) { 27481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* it used the whole range */ 27491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_mem_node->next = func->mem_head; 27501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->mem_head = hold_mem_node; 27511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 27521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If we have prefetchable memory space available and there 27531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * is some left at the end, return the unused portion */ 27541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (hold_p_mem_node && temp_resources.p_mem_head) { 27551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_mem_node = do_pre_bridge_resource_split(&(temp_resources.p_mem_head), 27561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds &hold_p_mem_node, 0x100000); 27571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check if we were able to split something off */ 27591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (p_mem_node) { 27601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_p_mem_node->base = p_mem_node->base + p_mem_node->length; 27611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_word = (hold_p_mem_node->base) >> 16; 27631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_word (pci_bus, devfn, PCI_PREF_MEMORY_BASE, temp_word); 27641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return_resource(&(resources->p_mem_head), p_mem_node); 27661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 27671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_mem_node = do_bridge_resource_split(&(temp_resources.p_mem_head), 0x100000); 27691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check if we were able to split something off */ 27711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (p_mem_node) { 27721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* First use the temporary node to store 27731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * information for the board */ 27741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_p_mem_node->length = p_mem_node->base - hold_p_mem_node->base; 27751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If we used any, add it to the board's list */ 27771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (hold_p_mem_node->length) { 27781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_p_mem_node->next = func->p_mem_head; 27791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->p_mem_head = hold_p_mem_node; 27801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_word = (p_mem_node->base - 1) >> 16; 27821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_word (pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, temp_word); 27831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return_resource(&(resources->p_mem_head), p_mem_node); 27851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 27861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* it doesn't need any PMem */ 27871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_word = 0x0000; 27881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_word (pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, temp_word); 27891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 27901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return_resource(&(resources->p_mem_head), p_mem_node); 27911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree(hold_p_mem_node); 27921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 27931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 27941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* it used the most of the range */ 27951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_p_mem_node->next = func->p_mem_head; 27961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->p_mem_head = hold_p_mem_node; 27971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 27981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if (hold_p_mem_node) { 27991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* it used the whole range */ 28001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hold_p_mem_node->next = func->p_mem_head; 28011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->p_mem_head = hold_p_mem_node; 28021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 28031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* We should be configuring an IRQ and the bridge's base address 28041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * registers if it needs them. Although we have never seen such 28051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * a device */ 28061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* enable card */ 28081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds command = 0x0157; /* = PCI_COMMAND_IO | 28091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * PCI_COMMAND_MEMORY | 28101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * PCI_COMMAND_MASTER | 28111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * PCI_COMMAND_INVALIDATE | 28121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * PCI_COMMAND_PARITY | 28131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * PCI_COMMAND_SERR */ 28141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_word (pci_bus, devfn, PCI_COMMAND, command); 28151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* set Bridge Control Register */ 28171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds command = 0x07; /* = PCI_BRIDGE_CTL_PARITY | 28181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * PCI_BRIDGE_CTL_SERR | 28191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * PCI_BRIDGE_CTL_NO_ISA */ 28201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_word (pci_bus, devfn, PCI_BRIDGE_CONTROL, command); 28211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if ((temp_byte & 0x7F) == PCI_HEADER_TYPE_NORMAL) { 28221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Standard device */ 28231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_read_config_byte (pci_bus, devfn, 0x0B, &class_code); 28241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (class_code == PCI_BASE_CLASS_DISPLAY) { 28261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Display (video) adapter (not supported) */ 28271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return DEVICE_TYPE_NOT_SUPPORTED; 28281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 28291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Figure out IO and memory needs */ 28301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (cloop = 0x10; cloop <= 0x24; cloop += 4) { 28311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_register = 0xFFFFFFFF; 28321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("CND: bus=%d, devfn=%d, offset=%d\n", pci_bus->number, devfn, cloop); 28341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_dword (pci_bus, devfn, cloop, temp_register); 28351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_read_config_dword (pci_bus, devfn, cloop, &temp_register); 28371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("CND: base = 0x%x\n", temp_register); 28381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (temp_register) { /* If this register is implemented */ 28401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((temp_register & 0x03L) == 0x01) { 28411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Map IO */ 28421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* set base = amount of IO space */ 28441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds base = temp_register & 0xFFFFFFFC; 28451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds base = ~base + 1; 28461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("CND: length = 0x%x\n", base); 28481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds io_node = get_io_resource(&(resources->io_head), base); 28491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("Got io_node start = %8.8x, length = %8.8x next (%p)\n", 28501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds io_node->base, io_node->length, io_node->next); 28511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("func (%p) io_head (%p)\n", func, func->io_head); 28521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* allocate the resource to the board */ 28541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (io_node) { 28551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds base = io_node->base; 28561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds io_node->next = func->io_head; 28581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->io_head = io_node; 28591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else 28601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return -ENOMEM; 28611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if ((temp_register & 0x0BL) == 0x08) { 28621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Map prefetchable memory */ 28631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds base = temp_register & 0xFFFFFFF0; 28641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds base = ~base + 1; 28651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("CND: length = 0x%x\n", base); 28671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_mem_node = get_resource(&(resources->p_mem_head), base); 28681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* allocate the resource to the board */ 28701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (p_mem_node) { 28711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds base = p_mem_node->base; 28721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p_mem_node->next = func->p_mem_head; 28741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->p_mem_head = p_mem_node; 28751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else 28761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return -ENOMEM; 28771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if ((temp_register & 0x0BL) == 0x00) { 28781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Map memory */ 28791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds base = temp_register & 0xFFFFFFF0; 28801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds base = ~base + 1; 28811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("CND: length = 0x%x\n", base); 28831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mem_node = get_resource(&(resources->mem_head), base); 28841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* allocate the resource to the board */ 28861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (mem_node) { 28871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds base = mem_node->base; 28881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mem_node->next = func->mem_head; 28901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->mem_head = mem_node; 28911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else 28921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return -ENOMEM; 28931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if ((temp_register & 0x0BL) == 0x04) { 28941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Map memory */ 28951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds base = temp_register & 0xFFFFFFF0; 28961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds base = ~base + 1; 28971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 28981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dbg("CND: length = 0x%x\n", base); 28991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mem_node = get_resource(&(resources->mem_head), base); 29001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 29011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* allocate the resource to the board */ 29021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (mem_node) { 29031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds base = mem_node->base; 29041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 29051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mem_node->next = func->mem_head; 29061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->mem_head = mem_node; 29071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else 29081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return -ENOMEM; 29091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if ((temp_register & 0x0BL) == 0x06) { 29101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Those bits are reserved, we can't handle this */ 29111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 29121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 29131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Requesting space below 1M */ 29141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NOT_ENOUGH_RESOURCES; 29151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 29161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 29171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_dword(pci_bus, devfn, cloop, base); 29181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 29191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check for 64-bit base */ 29201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((temp_register & 0x07L) == 0x04) { 29211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cloop += 4; 29221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 29231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Upper 32 bits of address always zero 29241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * on today's systems */ 29251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* FIXME this is probably not true on 29261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Alpha and ia64??? */ 29271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds base = 0; 29281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_dword(pci_bus, devfn, cloop, base); 29291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 29301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 29311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } /* End of base register loop */ 29321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (cpqhp_legacy_mode) { 29331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Figure out which interrupt pin this function uses */ 2934861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang rc = pci_bus_read_config_byte (pci_bus, devfn, 29351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds PCI_INTERRUPT_PIN, &temp_byte); 29361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 29371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If this function needs an interrupt and we are behind 29381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * a bridge and the pin is tied to something that's 29391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * alread mapped, set this one the same */ 2940861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang if (temp_byte && resources->irqs && 2941861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang (resources->irqs->valid_INT & 29421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (0x01 << ((temp_byte + resources->irqs->barber_pole - 1) & 0x03)))) { 29431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* We have to share with something already set up */ 2944861fefbf550d41e7a4f44584f3ec35977fa08bf1Alex Chiang IRQ = resources->irqs->interrupt[(temp_byte + 29451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds resources->irqs->barber_pole - 1) & 0x03]; 29461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 29471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Program IRQ based on card type */ 29481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_read_config_byte (pci_bus, devfn, 0x0B, &class_code); 29491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 29501d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang if (class_code == PCI_BASE_CLASS_STORAGE) 29511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds IRQ = cpqhp_disk_irq; 29521d3ecf1376bf22be57c6138e7cdf425c6027b115Alex Chiang else 29531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds IRQ = cpqhp_nic_irq; 29541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 29551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 29561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* IRQ Line */ 29571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_byte (pci_bus, devfn, PCI_INTERRUPT_LINE, IRQ); 29581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 29591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 29601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!behind_bridge) { 296198d3333a13029ab07ca1d1bfb9bfa138ea76c3c0Bjorn Helgaas rc = cpqhp_set_irq(func->bus, func->device, temp_byte, IRQ); 29621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rc) 29631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 29641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 29651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* TBD - this code may also belong in the other clause 29661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * of this If statement */ 29671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds resources->irqs->interrupt[(temp_byte + resources->irqs->barber_pole - 1) & 0x03] = IRQ; 29681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds resources->irqs->valid_INT |= 0x01 << (temp_byte + resources->irqs->barber_pole - 1) & 0x03; 29691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 29701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 29711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Latency Timer */ 29721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_byte = 0x40; 29731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_byte(pci_bus, devfn, 29741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds PCI_LATENCY_TIMER, temp_byte); 29751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 29761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Cache Line size */ 29771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_byte = 0x08; 29781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_byte(pci_bus, devfn, 29791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds PCI_CACHE_LINE_SIZE, temp_byte); 29801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 29811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* disable ROM base Address */ 29821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_dword = 0x00L; 29831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_word(pci_bus, devfn, 29841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds PCI_ROM_ADDRESS, temp_dword); 29851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 29861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* enable card */ 29871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds temp_word = 0x0157; /* = PCI_COMMAND_IO | 29881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * PCI_COMMAND_MEMORY | 29891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * PCI_COMMAND_MASTER | 29901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * PCI_COMMAND_INVALIDATE | 29911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * PCI_COMMAND_PARITY | 29921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * PCI_COMMAND_SERR */ 29931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = pci_bus_write_config_word (pci_bus, devfn, 29941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds PCI_COMMAND, temp_word); 29951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { /* End of Not-A-Bridge else */ 29961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* It's some strange type of PCI adapter (Cardbus?) */ 29971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return DEVICE_TYPE_NOT_SUPPORTED; 29981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 29991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 30001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds func->configured = 1; 30011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 30021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 30031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsfree_and_out: 30041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpqhp_destroy_resource_list (&temp_resources); 30051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 30061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return_resource(&(resources-> bus_head), hold_bus_node); 30071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return_resource(&(resources-> io_head), hold_IO_node); 30081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return_resource(&(resources-> mem_head), hold_mem_node); 30091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return_resource(&(resources-> p_mem_head), hold_p_mem_node); 30101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 30111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 3012