This patch removes the defines TRUE and FALSE and just uses 0 or 1.
Signed-off-by: Kristen Carlson Accardi <kristen.c.accardi@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
//----------------------------------------------------------------------------
// HPC return codes
//----------------------------------------------------------------------------
-#define FALSE 0x00
-#define TRUE 0x01
#define HPC_ERROR 0xFF
//-----------------------------------------------------------------------------
}
flag = slot_cur->flag;
- slot_cur->flag = TRUE;
+ slot_cur->flag = 1;
- if (flag == TRUE) {
+ if (flag == 1) {
rc = validate(slot_cur, DISABLE);
/* checking if powered off already & valid slot # */
if (rc)
goto error_no_slot;
}
- tmp_slot->flag = TRUE;
+ tmp_slot->flag = 1;
tmp_slot->capabilities = hpc_ptr->slots[index].slot_cap;
if ((hpc_ptr->slots[index].slot_cap & EBDA_SLOT_133_MAX) == EBDA_SLOT_133_MAX)
#include "ibmphp.h"
-static int to_debug = FALSE;
+static int to_debug = 0;
#define debug_polling(fmt, arg...) do { if (to_debug) debug (fmt, arg); } while (0)
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
// macro utilities
//----------------------------------------------------------------------------
-// if bits 20,22,25,26,27,29,30 are OFF return TRUE
-#define HPC_I2CSTATUS_CHECK(s) ((u8)((s & 0x00000A76) ? FALSE : TRUE))
+// if bits 20,22,25,26,27,29,30 are OFF return 1
+#define HPC_I2CSTATUS_CHECK(s) ((u8)((s & 0x00000A76) ? 0 : 1))
//----------------------------------------------------------------------------
// global variables
mutex_init(&sem_hpcaccess);
init_MUTEX (&semOperations);
init_MUTEX_LOCKED (&sem_exit);
- to_debug = FALSE;
- ibmphp_shutdown = FALSE;
+ to_debug = 0;
+ ibmphp_shutdown = 0;
tid_poll = 0;
debug ("%s - Exit\n", __FUNCTION__);
// check controller is still not working on the command
//--------------------------------------------------------------------
timeout = CMD_COMPLETE_TOUT_SEC;
- done = FALSE;
+ done = 0;
while (!done) {
rc = hpc_wait_ctlr_notworking (HPC_CTLR_WORKING_TOUT, ctlr_ptr, wpg_bbar,
&status);
if (!rc) {
if (NEEDTOCHECK_CMDSTATUS (cmd)) {
if (CTLR_FINISHED (status) == HPC_CTLR_FINISHED_YES)
- done = TRUE;
+ done = 1;
} else
- done = TRUE;
+ done = 1;
}
if (!done) {
msleep(1000);
if (timeout < 1) {
- done = TRUE;
+ done = 1;
err ("%s - Error command complete timeout\n", __FUNCTION__);
rc = -EFAULT;
} else
void ibmphp_lock_operations (void)
{
down (&semOperations);
- to_debug = TRUE;
+ to_debug = 1;
}
/*----------------------------------------------------------------------
{
debug ("%s - Entry\n", __FUNCTION__);
up (&semOperations);
- to_debug = FALSE;
+ to_debug = 0;
debug ("%s - Exit\n", __FUNCTION__);
}
{
u8 status;
int rc = 0;
- u8 disable = FALSE;
- u8 update = FALSE;
+ u8 disable = 0;
+ u8 update = 0;
debug ("process_changeinstatus - Entry pslot[%p], poldslot[%p]\n", pslot, poldslot);
// bit 0 - HPC_SLOT_POWER
if ((pslot->status & 0x01) != (poldslot->status & 0x01))
- update = TRUE;
+ update = 1;
// bit 1 - HPC_SLOT_CONNECT
// ignore
// bit 2 - HPC_SLOT_ATTN
if ((pslot->status & 0x04) != (poldslot->status & 0x04))
- update = TRUE;
+ update = 1;
// bit 3 - HPC_SLOT_PRSNT2
// bit 4 - HPC_SLOT_PRSNT1
if (((pslot->status & 0x08) != (poldslot->status & 0x08))
|| ((pslot->status & 0x10) != (poldslot->status & 0x10)))
- update = TRUE;
+ update = 1;
// bit 5 - HPC_SLOT_PWRGD
if ((pslot->status & 0x20) != (poldslot->status & 0x20))
// OFF -> ON: ignore, ON -> OFF: disable slot
if ((poldslot->status & 0x20) && (SLOT_CONNECT (poldslot->status) == HPC_SLOT_CONNECTED) && (SLOT_PRESENT (poldslot->status)))
- disable = TRUE;
+ disable = 1;
// bit 6 - HPC_SLOT_BUS_SPEED
// ignore
// bit 7 - HPC_SLOT_LATCH
if ((pslot->status & 0x80) != (poldslot->status & 0x80)) {
- update = TRUE;
+ update = 1;
// OPEN -> CLOSE
if (pslot->status & 0x80) {
if (SLOT_PWRGD (pslot->status)) {
msleep(1000);
rc = ibmphp_hpc_readslot (pslot, READ_SLOTSTATUS, &status);
if (SLOT_PWRGD (status))
- update = TRUE;
+ update = 1;
else // overwrite power in pslot to OFF
pslot->status &= ~HPC_SLOT_POWER;
}
// CLOSE -> OPEN
else if ((SLOT_PWRGD (poldslot->status) == HPC_SLOT_PWRGD_GOOD)
&& (SLOT_CONNECT (poldslot->status) == HPC_SLOT_CONNECTED) && (SLOT_PRESENT (poldslot->status))) {
- disable = TRUE;
+ disable = 1;
}
// else - ignore
}
// bit 4 - HPC_SLOT_BLINK_ATTN
if ((pslot->ext_status & 0x08) != (poldslot->ext_status & 0x08))
- update = TRUE;
+ update = 1;
if (disable) {
debug ("process_changeinstatus - disable slot\n");
- pslot->flag = FALSE;
+ pslot->flag = 0;
rc = ibmphp_do_disable_slot (pslot);
}
{
debug ("%s - Entry\n", __FUNCTION__);
- ibmphp_shutdown = TRUE;
+ ibmphp_shutdown = 1;
debug ("before locking operations \n");
ibmphp_lock_operations ();
debug ("after locking operations \n");
u8 * pstatus)
{
int rc = 0;
- u8 done = FALSE;
+ u8 done = 0;
debug_polling ("hpc_wait_ctlr_notworking - Entry timeout[%d]\n", timeout);
*pstatus = ctrl_read (ctlr_ptr, wpg_bbar, WPG_CTLR_INDEX);
if (*pstatus == HPC_ERROR) {
rc = HPC_ERROR;
- done = TRUE;
+ done = 1;
}
if (CTLR_WORKING (*pstatus) == HPC_CTLR_WORKING_NO)
- done = TRUE;
+ done = 1;
if (!done) {
msleep(1000);
if (timeout < 1) {
- done = TRUE;
+ done = 1;
err ("HPCreadslot - Error ctlr timeout\n");
rc = HPC_ERROR;
} else
}
pci_bus_read_config_byte (ibmphp_pci_bus, devfn, PCI_SECONDARY_BUS, &sec_number);
- flag = FALSE;
+ flag = 0;
for (i = 0; i < 32; i++) {
if (func->devices[i]) {
newfunc = kzalloc(sizeof(*newfunc), GFP_KERNEL);
cleanup_count = 2;
goto error;
}
- flag = TRUE;
+ flag = 1;
}
}
cur_func->busno, device, function);
pci_bus_read_config_byte (ibmphp_pci_bus, devfn, PCI_SECONDARY_BUS, &sec_number);
debug ("after configuring bridge..., sec_number = %x\n", sec_number);
- flag = FALSE;
+ flag = 0;
for (i = 0; i < 32; i++) {
if (func->devices[i]) {
debug ("inside for loop, device is %x\n", i);
cleanup_count = 2;
goto error;
}
- flag = TRUE;
+ flag = 1;
}
}
pfmem[count]->devfunc = PCI_DEVFN(func->device,
func->function);
pfmem[count]->len = len[count];
- pfmem[count]->fromMem = FALSE;
+ pfmem[count]->fromMem = 0;
if (ibmphp_check_resource (pfmem[count], 0) == 0) {
ibmphp_add_resource (pfmem[count]);
func->pfmem[count] = pfmem[count];
debug ("there's no pfmem... going into mem.\n");
if (ibmphp_check_resource (mem_tmp, 0) == 0) {
ibmphp_add_resource (mem_tmp);
- pfmem[count]->fromMem = TRUE;
+ pfmem[count]->fromMem = 1;
pfmem[count]->rangeno = mem_tmp->rangeno;
pfmem[count]->start = mem_tmp->start;
pfmem[count]->end = mem_tmp->end;
u16 pfmem_base;
u32 bar[2];
u32 len[2];
- u8 flag_io = FALSE;
- u8 flag_mem = FALSE;
- u8 flag_pfmem = FALSE;
- u8 need_io_upper = FALSE;
- u8 need_pfmem_upper = FALSE;
+ u8 flag_io = 0;
+ u8 flag_mem = 0;
+ u8 flag_pfmem = 0;
+ u8 need_io_upper = 0;
+ u8 need_pfmem_upper = 0;
struct res_needed *amount_needed = NULL;
struct resource_node *io = NULL;
struct resource_node *bus_io[2] = {NULL, NULL};
bus_pfmem[count]->devfunc = PCI_DEVFN(func->device,
func->function);
bus_pfmem[count]->len = len[count];
- bus_pfmem[count]->fromMem = FALSE;
+ bus_pfmem[count]->fromMem = 0;
if (ibmphp_check_resource (bus_pfmem[count], 0) == 0) {
ibmphp_add_resource (bus_pfmem[count]);
func->pfmem[count] = bus_pfmem[count];
mem_tmp->len = bus_pfmem[count]->len;
if (ibmphp_check_resource (mem_tmp, 0) == 0) {
ibmphp_add_resource (mem_tmp);
- bus_pfmem[count]->fromMem = TRUE;
+ bus_pfmem[count]->fromMem = 1;
bus_pfmem[count]->rangeno = mem_tmp->rangeno;
ibmphp_add_pfmem_from_mem (bus_pfmem[count]);
func->pfmem[count] = bus_pfmem[count];
if (!amount_needed->io) {
debug ("it doesn't want IO?\n");
- flag_io = TRUE;
+ flag_io = 1;
} else {
debug ("it wants %x IO behind the bridge\n", amount_needed->io);
io = kzalloc(sizeof(*io), GFP_KERNEL);
if (ibmphp_check_resource (io, 1) == 0) {
debug ("were we able to add io\n");
ibmphp_add_resource (io);
- flag_io = TRUE;
+ flag_io = 1;
}
}
if (!amount_needed->mem) {
debug ("it doesn't want n.e.memory?\n");
- flag_mem = TRUE;
+ flag_mem = 1;
} else {
debug ("it wants %x memory behind the bridge\n", amount_needed->mem);
mem = kzalloc(sizeof(*mem), GFP_KERNEL);
mem->len = amount_needed->mem;
if (ibmphp_check_resource (mem, 1) == 0) {
ibmphp_add_resource (mem);
- flag_mem = TRUE;
+ flag_mem = 1;
debug ("were we able to add mem\n");
}
}
if (!amount_needed->pfmem) {
debug ("it doesn't want n.e.pfmem mem?\n");
- flag_pfmem = TRUE;
+ flag_pfmem = 1;
} else {
debug ("it wants %x pfmemory behind the bridge\n", amount_needed->pfmem);
pfmem = kzalloc(sizeof(*pfmem), GFP_KERNEL);
pfmem->busno = func->busno;
pfmem->devfunc = PCI_DEVFN(func->device, func->function);
pfmem->len = amount_needed->pfmem;
- pfmem->fromMem = FALSE;
+ pfmem->fromMem = 0;
if (ibmphp_check_resource (pfmem, 1) == 0) {
ibmphp_add_resource (pfmem);
- flag_pfmem = TRUE;
+ flag_pfmem = 1;
} else {
mem_tmp = kzalloc(sizeof(*mem_tmp), GFP_KERNEL);
if (!mem_tmp) {
mem_tmp->len = pfmem->len;
if (ibmphp_check_resource (mem_tmp, 1) == 0) {
ibmphp_add_resource (mem_tmp);
- pfmem->fromMem = TRUE;
+ pfmem->fromMem = 1;
pfmem->rangeno = mem_tmp->rangeno;
ibmphp_add_pfmem_from_mem (pfmem);
- flag_pfmem = TRUE;
+ flag_pfmem = 1;
}
}
}
if ((io_base & PCI_IO_RANGE_TYPE_MASK) == PCI_IO_RANGE_TYPE_32) {
debug ("io 32\n");
- need_io_upper = TRUE;
+ need_io_upper = 1;
}
if ((pfmem_base & PCI_PREF_RANGE_TYPE_MASK) == PCI_PREF_RANGE_TYPE_64) {
debug ("pfmem 64\n");
- need_pfmem_upper = TRUE;
+ need_pfmem_upper = 1;
}
if (bus->noIORanges) {
debug ("hdr_type behind the bridge is %x\n", hdr_type);
if (hdr_type & PCI_HEADER_TYPE_BRIDGE) {
err ("embedded bridges not supported for hot-plugging.\n");
- amount->not_correct = TRUE;
+ amount->not_correct = 1;
return amount;
}
if (class == PCI_CLASS_NOT_DEFINED_VGA) {
err ("The device %x is VGA compatible and as is not supported for hot plugging. "
"Please choose another device.\n", device);
- amount->not_correct = TRUE;
+ amount->not_correct = 1;
return amount;
} else if (class == PCI_CLASS_DISPLAY_VGA) {
err ("The device %x is not supported for hot plugging. "
"Please choose another device.\n", device);
- amount->not_correct = TRUE;
+ amount->not_correct = 1;
return amount;
}
} /* end for */
if (!howmany)
- amount->not_correct = TRUE;
+ amount->not_correct = 1;
else
- amount->not_correct = FALSE;
+ amount->not_correct = 0;
if ((amount->io) && (amount->io < IOBRIDGE))
amount->io = IOBRIDGE;
if ((amount->mem) && (amount->mem < MEMBRIDGE))
if (!new_pfmem)
return -ENOMEM;
new_pfmem->type = PFMEM;
- new_pfmem->fromMem = FALSE;
+ new_pfmem->fromMem = 0;
if (ibmphp_add_resource (new_pfmem) < 0) {
newbus = alloc_error_bus (curr, 0, 0);
if (!newbus)
static void update_resources (struct bus_node *bus_cur, int type, int rangeno)
{
struct resource_node *res = NULL;
- u8 eol = FALSE; /* end of list indicator */
+ u8 eol = 0; /* end of list indicator */
switch (type) {
case MEM:
else if (res->nextRange)
res = res->nextRange;
else {
- eol = TRUE;
+ eol = 1;
break;
}
}
int noranges = 0;
u32 tmp_start; /* this is to make sure start address is divisible by the length needed */
u32 tmp_divide;
- u8 flag = FALSE;
+ u8 flag = 0;
if (!res)
return -EINVAL;
if ((range->start % tmp_divide) == 0) {
/* just perfect, starting address is divisible by length */
- flag = TRUE;
+ flag = 1;
len_cur = len_tmp;
start_cur = range->start;
} else {
/* Needs adjusting */
tmp_start = range->start;
- flag = FALSE;
+ flag = 0;
while ((len_tmp = res_cur->start - 1 - tmp_start) >= res->len) {
if ((tmp_start % tmp_divide) == 0) {
- flag = TRUE;
+ flag = 1;
len_cur = len_tmp;
start_cur = tmp_start;
break;
if (((res_cur->end + 1) % tmp_divide) == 0) {
/* just perfect, starting address is divisible by length */
- flag = TRUE;
+ flag = 1;
len_cur = len_tmp;
start_cur = res_cur->end + 1;
} else {
/* Needs adjusting */
tmp_start = res_cur->end + 1;
- flag = FALSE;
+ flag = 0;
while ((len_tmp = range->end - tmp_start) >= res->len) {
if ((tmp_start % tmp_divide) == 0) {
- flag = TRUE;
+ flag = 1;
len_cur = len_tmp;
start_cur = tmp_start;
break;
if ((len_tmp < len_cur) || (len_cur == 0)) {
if ((range->start % tmp_divide) == 0) {
/* just perfect, starting address is divisible by length */
- flag = TRUE;
+ flag = 1;
len_cur = len_tmp;
start_cur = range->start;
} else {
/* Needs adjusting */
tmp_start = range->start;
- flag = FALSE;
+ flag = 0;
while ((len_tmp = res_cur->start - 1 - tmp_start) >= res->len) {
if ((tmp_start % tmp_divide) == 0) {
- flag = TRUE;
+ flag = 1;
len_cur = len_tmp;
start_cur = tmp_start;
break;
if ((len_tmp < len_cur) || (len_cur == 0)) {
if (((res_prev->end + 1) % tmp_divide) == 0) {
/* just perfect, starting address's divisible by length */
- flag = TRUE;
+ flag = 1;
len_cur = len_tmp;
start_cur = res_prev->end + 1;
} else {
/* Needs adjusting */
tmp_start = res_prev->end + 1;
- flag = FALSE;
+ flag = 0;
while ((len_tmp = res_cur->start - 1 - tmp_start) >= res->len) {
if ((tmp_start % tmp_divide) == 0) {
- flag = TRUE;
+ flag = 1;
len_cur = len_tmp;
start_cur = tmp_start;
break;
if ((len_tmp < len_cur) || (len_cur == 0)) {
if ((range->start % tmp_divide) == 0) {
/* just perfect, starting address's divisible by length */
- flag = TRUE;
+ flag = 1;
len_cur = len_tmp;
start_cur = range->start;
} else {
/* Needs adjusting */
tmp_start = range->start;
- flag = FALSE;
+ flag = 0;
while ((len_tmp = range->end - tmp_start) >= res->len) {
if ((tmp_start % tmp_divide) == 0) {
- flag = TRUE;
+ flag = 1;
len_cur = len_tmp;
start_cur = tmp_start;
break;
if ((len_tmp < len_cur) || (len_cur == 0)) {
if ((range->start % tmp_divide) == 0) {
/* just perfect, starting address's divisible by length */
- flag = TRUE;
+ flag = 1;
len_cur = len_tmp;
start_cur = range->start;
} else {
/* Needs adjusting */
tmp_start = range->start;
- flag = FALSE;
+ flag = 0;
while ((len_tmp = range->end - tmp_start) >= res->len) {
if ((tmp_start % tmp_divide) == 0) {
- flag = TRUE;
+ flag = 1;
len_cur = len_tmp;
start_cur = tmp_start;
break;
bus_cur = list_entry (tmp, struct bus_node, bus_list);
if ((!bus_cur->rangePFMem) && (bus_cur->firstPFMem)) {
for (pfmem_cur = bus_cur->firstPFMem, pfmem_prev = NULL; pfmem_cur; pfmem_prev = pfmem_cur, pfmem_cur = pfmem_cur->next) {
- pfmem_cur->fromMem = TRUE;
+ pfmem_cur->fromMem = 1;
if (pfmem_prev)
pfmem_prev->next = pfmem_cur->next;
else
pfmem->start = start_address;
pfmem->end = end_address + 0xfffff;
pfmem->len = pfmem->end - pfmem->start + 1;
- pfmem->fromMem = FALSE;
+ pfmem->fromMem = 0;
ibmphp_add_resource (pfmem);
}
projects / linux-2.6 / commitdiff