static unsigned int
 get_host_devfn(acpi_handle device_handle, acpi_handle rootbus_handle)
 {
-       unsigned long adr;
+       unsigned long long adr;
        acpi_handle child;
        unsigned int devfn;
        int function;
 static acpi_status
 find_matching_device(acpi_handle handle, u32 lvl, void *context, void **rv)
 {
-       unsigned long bbn = -1;
-       unsigned long adr;
+       unsigned long long bbn = -1;
+       unsigned long long adr;
        acpi_handle parent = NULL;
        acpi_status status;
        unsigned int devfn;
        unsigned int host_devfn;
        struct sn_pcidev_match pcidev_match;
        acpi_handle rootbus_handle;
-       unsigned long segment;
+       unsigned long long segment;
        acpi_status status;
 
        rootbus_handle = PCI_CONTROLLER(dev)->acpi_handle;
 
        struct power_supply charger;
 #endif
        struct acpi_device * device;
-       unsigned long state;
+       unsigned long long state;
 };
 
 #define to_acpi_ac(x) container_of(x, struct acpi_ac, charger);
 
 
 static int acpi_memory_check_device(struct acpi_memory_device *mem_device)
 {
-       unsigned long current_status;
-
+       unsigned long long current_status;
 
        /* Get device present/absent information from the _STA */
        if (ACPI_FAILURE(acpi_evaluate_integer(mem_device->device->handle, "_STA",
        acpi_status status;
        struct acpi_object_list arg_list;
        union acpi_object arg;
-       unsigned long current_status;
+       unsigned long long current_status;
 
 
        /* Issue the _EJ0 command */
 
                        /* That's what the AML code does */
                        lcd = out_obj.integer.value >> 8;
        } else if (hotk->model == F3Sa) {
-               unsigned long tmp;
+               unsigned long long tmp;
                union acpi_object param;
                struct acpi_object_list input;
                acpi_status status;
 
  */
 static int bay_present(struct bay *bay)
 {
-       unsigned long sta;
+       unsigned long long sta;
        acpi_status status;
 
        if (bay) {
 
 int acpi_bus_get_status(struct acpi_device *device)
 {
        acpi_status status = AE_OK;
-       unsigned long sta = 0;
+       unsigned long long sta = 0;
 
 
        if (!device)
        int result = 0;
        acpi_status status = 0;
        struct acpi_device *device = NULL;
-       unsigned long psc = 0;
+       unsigned long long psc = 0;
 
 
        result = acpi_bus_get_device(handle, &device);
 
 {
        struct acpi_button *button = seq->private;
        acpi_status status;
-       unsigned long state;
+       unsigned long long state;
 
        if (!button || !button->device)
                return 0;
    -------------------------------------------------------------------------- */
 static int acpi_lid_send_state(struct acpi_button *button)
 {
-       unsigned long state;
+       unsigned long long state;
        acpi_status status;
 
        status = acpi_evaluate_integer(button->device->handle, "_LID", NULL,
 
 {
        acpi_handle temp;
        acpi_status status;
-       unsigned long sta;
+       unsigned long long sta;
 
 
        status = acpi_get_handle(handle, "_STA", &temp);
 
  */
 static int dock_present(struct dock_station *ds)
 {
-       unsigned long sta;
+       unsigned long long sta;
        acpi_status status;
 
        if (ds) {
 static ssize_t show_dock_uid(struct device *dev,
                             struct device_attribute *attr, char *buf)
 {
-       unsigned long lbuf;
+       unsigned long long lbuf;
        acpi_status status = acpi_evaluate_integer(dock_station->handle,
                                        "_UID", NULL, &lbuf);
        if (ACPI_FAILURE(status))
            return 0;
 
-       return snprintf(buf, PAGE_SIZE, "%lx\n", lbuf);
+       return snprintf(buf, PAGE_SIZE, "%llx\n", lbuf);
 }
 static DEVICE_ATTR(uid, S_IRUGO, show_dock_uid, NULL);
 
 
 ec_parse_device(acpi_handle handle, u32 Level, void *context, void **retval)
 {
        acpi_status status;
+       unsigned long long tmp;
 
        struct acpi_ec *ec = context;
        status = acpi_walk_resources(handle, METHOD_NAME__CRS,
 
        /* Get GPE bit assignment (EC events). */
        /* TODO: Add support for _GPE returning a package */
-       status = acpi_evaluate_integer(handle, "_GPE", NULL, &ec->gpe);
+       status = acpi_evaluate_integer(handle, "_GPE", NULL, &tmp);
        if (ACPI_FAILURE(status))
                return status;
+       ec->gpe = tmp;
        /* Use the global lock for all EC transactions? */
-       acpi_evaluate_integer(handle, "_GLK", NULL, &ec->global_lock);
+       acpi_evaluate_integer(handle, "_GLK", NULL, &tmp);
+       ec->global_lock = tmp;
        ec->handle = handle;
        return AE_CTRL_TERMINATE;
 }
 
 
 int acpi_get_pxm(acpi_handle h)
 {
-       unsigned long pxm;
+       unsigned long long pxm;
        acpi_status status;
        acpi_handle handle;
        acpi_handle phandle = h;
 
        acpi_handle handle;
        struct acpi_pci_id *pci_id = *id;
        acpi_status status;
-       unsigned long temp;
+       unsigned long long temp;
        acpi_object_type type;
 
        acpi_get_parent(chandle, &handle);
                if ((ACPI_FAILURE(status)) || (type != ACPI_TYPE_DEVICE))
                        return;
 
-               status =
-                   acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL,
+               status = acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL,
                                          &temp);
                if (ACPI_SUCCESS(status)) {
                        u32 val;
 
        struct acpi_pci_root *root = NULL;
        struct acpi_pci_root *tmp;
        acpi_status status = AE_OK;
-       unsigned long value = 0;
+       unsigned long long value = 0;
        acpi_handle handle = NULL;
        struct acpi_device *child;
 
 
 };
 
 static int
-check_slot(acpi_handle handle, unsigned long *sun)
+check_slot(acpi_handle handle, unsigned long long *sun)
 {
        int device = -1;
-       unsigned long adr, sta;
+       unsigned long long adr, sta;
        acpi_status status;
        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 
 register_slot(acpi_handle handle, u32 lvl, void *context, void **rv)
 {
        int device;
-       unsigned long sun;
+       unsigned long long sun;
        char name[SLOT_NAME_SIZE];
        struct acpi_pci_slot *slot;
        struct pci_slot *pci_slot;
 walk_p2p_bridge(acpi_handle handle, u32 lvl, void *context, void **rv)
 {
        int device, function;
-       unsigned long adr;
+       unsigned long long adr;
        acpi_status status;
        acpi_handle dummy_handle;
        acpi_walk_callback user_function;
 walk_root_bridge(acpi_handle handle, acpi_walk_callback user_function)
 {
        int seg, bus;
-       unsigned long tmp;
+       unsigned long long tmp;
        acpi_status status;
        acpi_handle dummy_handle;
        struct pci_bus *pci_bus;
 
 static int acpi_power_get_state(struct acpi_power_resource *resource, int *state)
 {
        acpi_status status = AE_OK;
-       unsigned long sta = 0;
+       unsigned long long sta = 0;
 
 
        if (!resource || !state)
 
 
        /* Check if it is a Device with HID and UID */
        if (has_uid) {
-               unsigned long value;
+               unsigned long long value;
                status = acpi_evaluate_integer(pr->handle, METHOD_NAME__UID,
                                                NULL, &value);
                if (ACPI_FAILURE(status)) {
 static int is_processor_present(acpi_handle handle)
 {
        acpi_status status;
-       unsigned long sta = 0;
+       unsigned long long sta = 0;
 
 
        status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
 
 static int acpi_processor_get_platform_limit(struct acpi_processor *pr)
 {
        acpi_status status = 0;
-       unsigned long ppc = 0;
+       unsigned long long ppc = 0;
 
 
        if (!pr)
 
 static int acpi_processor_get_platform_limit(struct acpi_processor *pr)
 {
        acpi_status status = 0;
-       unsigned long tpc = 0;
+       unsigned long long tpc = 0;
 
        if (!pr)
                return -EINVAL;
 
 static int acpi_smbus_hc_add(struct acpi_device *device)
 {
        int status;
-       unsigned long val;
+       unsigned long long val;
        struct acpi_smb_hc *hc;
 
        if (!device)
 
        acpi_handle handle = DEVICE_ACPI_HANDLE(dev);
        struct acpi_device *adev;
        char acpi_method[] = "_SxD";
-       unsigned long d_min, d_max;
+       unsigned long long d_min, d_max;
 
        if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &adev))) {
                printk(KERN_DEBUG "ACPI handle has no context!\n");
 
 static int acpi_thermal_get_temperature(struct acpi_thermal *tz)
 {
        acpi_status status = AE_OK;
-
+       unsigned long long tmp;
 
        if (!tz)
                return -EINVAL;
 
        tz->last_temperature = tz->temperature;
 
-       status =
-           acpi_evaluate_integer(tz->device->handle, "_TMP", NULL, &tz->temperature);
+       status = acpi_evaluate_integer(tz->device->handle, "_TMP", NULL, &tmp);
        if (ACPI_FAILURE(status))
                return -ENODEV;
 
+       tz->temperature = tmp;
        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Temperature is %lu dK\n",
                          tz->temperature));
 
 static int acpi_thermal_get_polling_frequency(struct acpi_thermal *tz)
 {
        acpi_status status = AE_OK;
-
+       unsigned long long tmp;
 
        if (!tz)
                return -EINVAL;
 
-       status =
-           acpi_evaluate_integer(tz->device->handle, "_TZP", NULL,
-                                 &tz->polling_frequency);
+       status = acpi_evaluate_integer(tz->device->handle, "_TZP", NULL, &tmp);
        if (ACPI_FAILURE(status))
                return -ENODEV;
 
+       tz->polling_frequency = tmp;
        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Polling frequency is %lu dS\n",
                          tz->polling_frequency));
 
 static int acpi_thermal_trips_update(struct acpi_thermal *tz, int flag)
 {
        acpi_status status = AE_OK;
+       unsigned long long tmp;
        struct acpi_handle_list devices;
        int valid = 0;
        int i;
        /* Critical Shutdown (required) */
        if (flag & ACPI_TRIPS_CRITICAL) {
                status = acpi_evaluate_integer(tz->device->handle,
-                               "_CRT", NULL, &tz->trips.critical.temperature);
+                               "_CRT", NULL, &tmp);
+               tz->trips.critical.temperature = tmp;
                /*
                 * Treat freezing temperatures as invalid as well; some
                 * BIOSes return really low values and cause reboots at startup.
        /* Critical Sleep (optional) */
        if (flag & ACPI_TRIPS_HOT) {
                status = acpi_evaluate_integer(tz->device->handle,
-                               "_HOT", NULL, &tz->trips.hot.temperature);
+                               "_HOT", NULL, &tmp);
                if (ACPI_FAILURE(status)) {
                        tz->trips.hot.flags.valid = 0;
                        ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                                        "No hot threshold\n"));
                } else {
+                       tz->trips.hot.temperature = tmp;
                        tz->trips.hot.flags.valid = 1;
                        ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                                        "Found hot threshold [%lu]\n",
                if (psv == -1) {
                        status = AE_SUPPORT;
                } else if (psv > 0) {
-                       tz->trips.passive.temperature = CELSIUS_TO_KELVIN(psv);
+                       tmp = CELSIUS_TO_KELVIN(psv);
                        status = AE_OK;
                } else {
                        status = acpi_evaluate_integer(tz->device->handle,
-                               "_PSV", NULL, &tz->trips.passive.temperature);
+                               "_PSV", NULL, &tmp);
                }
 
                if (ACPI_FAILURE(status))
                        tz->trips.passive.flags.valid = 0;
                else {
+                       tz->trips.passive.temperature = tmp;
                        tz->trips.passive.flags.valid = 1;
                        if (flag == ACPI_TRIPS_INIT) {
                                status = acpi_evaluate_integer(
                                                tz->device->handle, "_TC1",
-                                               NULL, &tz->trips.passive.tc1);
+                                               NULL, &tmp);
                                if (ACPI_FAILURE(status))
                                        tz->trips.passive.flags.valid = 0;
+                               else
+                                       tz->trips.passive.tc1 = tmp;
                                status = acpi_evaluate_integer(
                                                tz->device->handle, "_TC2",
-                                               NULL, &tz->trips.passive.tc2);
+                                               NULL, &tmp);
                                if (ACPI_FAILURE(status))
                                        tz->trips.passive.flags.valid = 0;
+                               else
+                                       tz->trips.passive.tc2 = tmp;
                                status = acpi_evaluate_integer(
                                                tz->device->handle, "_TSP",
-                                               NULL, &tz->trips.passive.tsp);
+                                               NULL, &tmp);
                                if (ACPI_FAILURE(status))
                                        tz->trips.passive.flags.valid = 0;
+                               else
+                                       tz->trips.passive.tsp = tmp;
                        }
                }
        }
 
                if (flag & ACPI_TRIPS_ACTIVE) {
                        status = acpi_evaluate_integer(tz->device->handle,
-                               name, NULL, &tz->trips.active[i].temperature);
+                                                       name, NULL, &tmp);
                        if (ACPI_FAILURE(status)) {
                                tz->trips.active[i].flags.valid = 0;
                                if (i == 0)
                                                tz->trips.active[i - 2].temperature :
                                                CELSIUS_TO_KELVIN(act));
                                break;
-                       } else
+                       } else {
+                               tz->trips.active[i].temperature = tmp;
                                tz->trips.active[i].flags.valid = 1;
+                       }
                }
 
                name[2] = 'L';
 
 acpi_status
 acpi_evaluate_integer(acpi_handle handle,
                      acpi_string pathname,
-                     struct acpi_object_list *arguments, unsigned long *data)
+                     struct acpi_object_list *arguments, unsigned long long *data)
 {
        acpi_status status = AE_OK;
        union acpi_object *element;
        *data = element->integer.value;
        kfree(element);
 
-       ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Return value [%lu]\n", *data));
+       ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Return value [%llu]\n", *data));
 
        return AE_OK;
 }
 
                        int level);
 static int acpi_video_device_lcd_get_level_current(
                        struct acpi_video_device *device,
-                       unsigned long *level);
+                       unsigned long long *level);
 static int acpi_video_get_next_level(struct acpi_video_device *device,
                                     u32 level_current, u32 event);
 static void acpi_video_switch_brightness(struct acpi_video_device *device,
                                         int event);
 static int acpi_video_device_get_state(struct acpi_video_device *device,
-                           unsigned long *state);
+                           unsigned long long *state);
 static int acpi_video_output_get(struct output_device *od);
 static int acpi_video_device_set_state(struct acpi_video_device *device, int state);
 
 /*backlight device sysfs support*/
 static int acpi_video_get_brightness(struct backlight_device *bd)
 {
-       unsigned long cur_level;
+       unsigned long long cur_level;
        int i;
        struct acpi_video_device *vd =
                (struct acpi_video_device *)bl_get_data(bd);
 /*video output device sysfs support*/
 static int acpi_video_output_get(struct output_device *od)
 {
-       unsigned long state;
+       unsigned long long state;
        struct acpi_video_device *vd =
                (struct acpi_video_device *)dev_get_drvdata(&od->dev);
        acpi_video_device_get_state(vd, &state);
 {
        struct acpi_device *device = cdev->devdata;
        struct acpi_video_device *video = acpi_driver_data(device);
-       unsigned long level;
+       unsigned long long level;
        int state;
 
        acpi_video_device_lcd_get_level_current(video, &level);
 /* device */
 
 static int
-acpi_video_device_query(struct acpi_video_device *device, unsigned long *state)
+acpi_video_device_query(struct acpi_video_device *device, unsigned long long *state)
 {
        int status;
 
 
 static int
 acpi_video_device_get_state(struct acpi_video_device *device,
-                           unsigned long *state)
+                           unsigned long long *state)
 {
        int status;
 
        int status;
        union acpi_object arg0 = { ACPI_TYPE_INTEGER };
        struct acpi_object_list args = { 1, &arg0 };
-       unsigned long ret;
+       unsigned long long ret;
 
 
        arg0.integer.value = state;
 
 static int
 acpi_video_device_lcd_get_level_current(struct acpi_video_device *device,
-                                       unsigned long *level)
+                                       unsigned long long *level)
 {
        if (device->cap._BQC)
                return acpi_evaluate_integer(device->dev->handle, "_BQC", NULL,
 acpi_video_bus_set_POST(struct acpi_video_bus *video, unsigned long option)
 {
        int status;
-       unsigned long tmp;
+       unsigned long long tmp;
        union acpi_object arg0 = { ACPI_TYPE_INTEGER };
        struct acpi_object_list args = { 1, &arg0 };
 
 }
 
 static int
-acpi_video_bus_get_POST(struct acpi_video_bus *video, unsigned long *id)
+acpi_video_bus_get_POST(struct acpi_video_bus *video, unsigned long long *id)
 {
        int status;
 
 
 static int
 acpi_video_bus_POST_options(struct acpi_video_bus *video,
-                           unsigned long *options)
+                           unsigned long long *options)
 {
        int status;
 
 {
        int status;
        struct acpi_video_device *dev = seq->private;
-       unsigned long state;
+       unsigned long long state;
 
 
        if (!dev)
        status = acpi_video_device_get_state(dev, &state);
        seq_printf(seq, "state:     ");
        if (ACPI_SUCCESS(status))
-               seq_printf(seq, "0x%02lx\n", state);
+               seq_printf(seq, "0x%02llx\n", state);
        else
                seq_printf(seq, "<not supported>\n");
 
        status = acpi_video_device_query(dev, &state);
        seq_printf(seq, "query:     ");
        if (ACPI_SUCCESS(status))
-               seq_printf(seq, "0x%02lx\n", state);
+               seq_printf(seq, "0x%02llx\n", state);
        else
                seq_printf(seq, "<not supported>\n");
 
 static int acpi_video_bus_POST_info_seq_show(struct seq_file *seq, void *offset)
 {
        struct acpi_video_bus *video = seq->private;
-       unsigned long options;
+       unsigned long long options;
        int status;
 
 
                        printk(KERN_WARNING PREFIX
                               "This indicates a BIOS bug. Please contact the manufacturer.\n");
                }
-               printk("%lx\n", options);
+               printk("%llx\n", options);
                seq_printf(seq, "can POST: <integrated video>");
                if (options & 2)
                        seq_printf(seq, " <PCI video>");
 {
        struct acpi_video_bus *video = seq->private;
        int status;
-       unsigned long id;
+       unsigned long long id;
 
 
        if (!video)
        struct seq_file *m = file->private_data;
        struct acpi_video_bus *video = m->private;
        char str[12] = { 0 };
-       unsigned long opt, options;
+       unsigned long long opt, options;
 
 
        if (!video || count + 1 > sizeof str)
 acpi_video_bus_get_one_device(struct acpi_device *device,
                              struct acpi_video_bus *video)
 {
-       unsigned long device_id;
+       unsigned long long device_id;
        int status;
        struct acpi_video_device *data;
        struct acpi_video_device_attrib* attribute;
 static void
 acpi_video_switch_brightness(struct acpi_video_device *device, int event)
 {
-       unsigned long level_current, level_next;
+       unsigned long long level_current, level_next;
        if (!device->brightness)
                return;
        acpi_video_device_lcd_get_level_current(device, &level_current);
 
        int wait = 0;
        unsigned long flags;
        acpi_handle handle, tmphandle;
-       unsigned long sta;
+       unsigned long long sta;
        acpi_status status;
 
        if (dev) {
 
 
 static int read_wireless_status(int mask)
 {
-       ulong status;
+       unsigned long long status;
        acpi_status rv = AE_OK;
 
        if (!wireless_status_handle)
 
 static int read_gps_status(void)
 {
-       ulong status;
+       unsigned long long status;
        acpi_status rv = AE_OK;
 
        rv = acpi_evaluate_integer(gps_status_handle, NULL, NULL, &status);
 
 static int read_brightness(struct backlight_device *bd)
 {
-       ulong value;
+       unsigned long long value;
        acpi_status rv = AE_OK;
 
        rv = acpi_evaluate_integer(brightness_get_handle, NULL, NULL, &value);
                          struct device_attribute *attr, char *page)
 {
        int len = 0;
-       ulong temp;
+       unsigned long long temp;
        char buf[16];           //enough for all info
        acpi_status rv = AE_OK;
 
 
 static int read_display(void)
 {
-       ulong value = 0;
+       unsigned long long value = 0;
        acpi_status rv = AE_OK;
 
        /* In most of the case, we know how to set the display, but sometime
 {
        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
        union acpi_object *model = NULL;
-       ulong bsts_result, hwrs_result;
+       unsigned long long bsts_result, hwrs_result;
        char *string = NULL;
        acpi_status status;
 
 
 static int read_acpi_int(acpi_handle handle, const char *method, int *val)
 {
        acpi_status status;
-       ulong result;
+       unsigned long long result;
 
        status = acpi_evaluate_integer(handle, (char *)method, NULL, &result);
        if (ACPI_FAILURE(status)) {
 
 
 static int get_lcd_level(void)
 {
-       unsigned long state = 0;
+       unsigned long long state = 0;
        acpi_status status = AE_OK;
 
        vdbg_printk(FUJLAPTOP_DBG_TRACE, "get lcd level via GBLL\n");
 
 static int get_max_brightness(void)
 {
-       unsigned long state = 0;
+       unsigned long long state = 0;
        acpi_status status = AE_OK;
 
        vdbg_printk(FUJLAPTOP_DBG_TRACE, "get max lcd level via RBLL\n");
 
 static int get_lcd_level_alt(void)
 {
-       unsigned long state = 0;
+       unsigned long long state = 0;
        acpi_status status = AE_OK;
 
        vdbg_printk(FUJLAPTOP_DBG_TRACE, "get lcd level via GBLS\n");
 
 static int get_irb(void)
 {
-       unsigned long state = 0;
+       unsigned long long state = 0;
        acpi_status status = AE_OK;
 
        vdbg_printk(FUJLAPTOP_DBG_TRACE, "Get irb\n");
 
 {
        struct acpi_device *device = cdev->devdata;
        acpi_handle handle = device->handle;
-       unsigned long value;
+       unsigned long long value;
        struct acpi_object_list arg_list;
        union acpi_object arg;
        acpi_status status = AE_OK;
 {
        struct acpi_device *device = cdev->devdata;
        acpi_handle handle = device->handle;
-       unsigned long value;
+       unsigned long long value;
        struct acpi_object_list arg_list;
        union acpi_object arg;
        acpi_status status = AE_OK;
        struct acpi_object_list arg_list;
        union acpi_object arg;
        acpi_status status;
-       int temp;
+       unsigned long long temp;
        unsigned long max_state;
 
        if (memory_get_int_max_bandwidth(cdev, &max_state))
 
        status =
            acpi_evaluate_integer(handle, MEMORY_SET_BANDWIDTH, &arg_list,
-                                 (unsigned long *)&temp);
+                                 &temp);
 
        printk(KERN_INFO
               "Bandwidth value was %d: status is %d\n", state, status);
  * @auxtype : AUX0/AUX1
  * @buf: syfs buffer
  */
-static int sensor_get_auxtrip(acpi_handle handle, int index, int *value)
+static int sensor_get_auxtrip(acpi_handle handle, int index,
+                                                       unsigned long long *value)
 {
        acpi_status status;
 
                return -EINVAL;
 
        status = acpi_evaluate_integer(handle, index ? GET_AUX1 : GET_AUX0,
-                                      NULL, (unsigned long *)value);
+                                      NULL, value);
        if (ACPI_FAILURE(status))
                return -EIO;
 
        struct acpi_object_list args = {
                1, &arg
        };
-       int temp;
+       unsigned long long temp;
 
        if (index != 0 && index != 1)
                return -EINVAL;
 
        status = acpi_evaluate_integer(handle, index ? GET_AUX0 : GET_AUX1,
-                                      NULL, (unsigned long *)&temp);
+                                      NULL, &temp);
        if (ACPI_FAILURE(status))
                return -EIO;
        if ((index && value < temp) || (!index && value > temp))
 
        arg.integer.value = value;
        status = acpi_evaluate_integer(handle, index ? SET_AUX1 : SET_AUX0,
-                                      &args, (unsigned long *)&temp);
+                                      &args, &temp);
        if (ACPI_FAILURE(status))
                return -EIO;
 
                         struct device_attribute *dev_attr, char *buf)
 {
        struct intel_menlow_attribute *attr = to_intel_menlow_attr(dev_attr);
-       int value;
+       unsigned long long value;
        int result;
 
        result = sensor_get_auxtrip(attr->handle, 0, &value);
                         struct device_attribute *dev_attr, char *buf)
 {
        struct intel_menlow_attribute *attr = to_intel_menlow_attr(dev_attr);
-       int value;
+       unsigned long long value;
        int result;
 
        result = sensor_get_auxtrip(attr->handle, 1, &value);
                                 struct device_attribute *attr, char *buf)
 {
        acpi_status status;
-       unsigned long bios_enabled;
+       unsigned long long bios_enabled;
 
        status = acpi_evaluate_integer(NULL, BIOS_ENABLED, NULL, &bios_enabled);
        if (ACPI_FAILURE(status))
 {
        int result = -ENODEV;
        acpi_status status;
-       unsigned long enable;
+       unsigned long long enable;
 
        if (acpi_disabled)
                return result;
 
        struct acpiphp_func *newfunc;
        acpi_handle tmp;
        acpi_status status = AE_OK;
-       unsigned long adr, sun;
+       unsigned long long adr, sun;
        int device, function, retval;
 
        status = acpi_evaluate_integer(handle, "_ADR", NULL, &adr);
 {
        acpi_status status;
        acpi_handle dummy_handle;
-       unsigned long tmp;
+       unsigned long long tmp;
        int device, function;
        struct pci_dev *dev;
        struct pci_bus *pci_bus = context;
 static int add_bridge(acpi_handle handle)
 {
        acpi_status status;
-       unsigned long tmp;
+       unsigned long long tmp;
        int seg, bus;
        acpi_handle dummy_handle;
        struct pci_bus *pci_bus;
 {
        acpi_status status;
        int result = -1;
-       unsigned long gsb;
+       unsigned long long gsb;
        struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
        union acpi_object *obj;
        void *table;
 ioapic_add(acpi_handle handle, u32 lvl, void *context, void **rv)
 {
        acpi_status status;
-       unsigned long sta;
+       unsigned long long sta;
        acpi_handle tmp;
        struct pci_dev *pdev;
        u32 gsi_base;
 ioapic_remove(acpi_handle handle, u32 lvl, void *context, void **rv)
 {
        acpi_status status;
-       unsigned long sta;
+       unsigned long long sta;
        acpi_handle tmp;
        u32 gsi_base;
        struct acpiphp_ioapic *pos, *n, *ioapic = NULL;
 static unsigned int get_slot_status(struct acpiphp_slot *slot)
 {
        acpi_status status;
-       unsigned long sta = 0;
+       unsigned long long sta = 0;
        u32 dvid;
        struct list_head *l;
        struct acpiphp_func *func;
 
        union acpi_object args[2]; 
        struct acpi_object_list params = { .pointer = args, .count = 2 };
        acpi_status stat; 
-       unsigned long rc;
+       unsigned long long rc;
        union apci_descriptor *ibm_slot;
 
        ibm_slot = ibm_slot_from_id(hpslot_to_sun(slot));
 
        /*
         * Add the slot's devices to the ACPI infrastructure */
        if (SN_ACPI_BASE_SUPPORT() && ssdt) {
-               unsigned long adr;
+               unsigned long long adr;
                struct acpi_device *pdevice;
                struct acpi_device *device;
                acpi_handle phandle;
        /* free the ACPI resources for the slot */
        if (SN_ACPI_BASE_SUPPORT() &&
             PCI_CONTROLLER(slot->pci_bus)->acpi_handle) {
-               unsigned long adr;
+               unsigned long long adr;
                struct acpi_device *device;
                acpi_handle phandle;
                acpi_handle chandle = NULL;
 
 acpi_status
 acpi_evaluate_integer(acpi_handle handle,
                      acpi_string pathname,
-                     struct acpi_object_list *arguments, unsigned long *data);
+                     struct acpi_object_list *arguments, unsigned long long *data);
 acpi_status
 acpi_evaluate_reference(acpi_handle handle,
                        acpi_string pathname,