parisc: Fix Invalid wait context warning in firmware wrapperfor-next-next

Use raw_spinlock functions to avoid this warning:

 =============================
 [ BUG: Invalid wait context ]
 6.7.0-rc3-64bit+ #1032 Tainted: G        W
 -----------------------------
 swapper/0/0 is trying to lock:
 0000000041c1b250 (pdc_lock){....}-{3:3}, at: pdc_iodc_print+0x64/0x180
 other info that might help us debug this:
 context-{2:2}
 3 locks held by swapper/0/0:
  #0: 0000000041c22060 (console_lock){....}-{0:0}, at: vprintk_emit+0x1ac/0x4a8
  #1: 0000000041c22098 (console_srcu){....}-{0:0}, at: rcu_lock_acquire+0x0/0x68
  #2: 0000000041c21ea8 (console_owner){-...}-{0:0}, at: console_flush_all+0x304/0x638
 stack backtrace:
 CPU: 0 PID: 0 Comm: swapper/0 Tainted: G        W          6.7.0-rc3-64bit+ #1032
 Hardware name: 9000/785/C3700
 Backtrace:
  [<000000004030b544>] show_stack+0x8c/0xa8
  [<00000000412cb768>] dump_stack_lvl+0x148/0x1c8
  [<00000000412cb81c>] dump_stack+0x34/0x48
  [<00000000403d4324>] __lock_acquire+0x674/0x1cf8
  [<00000000403d68d4>] lock_acquire+0x36c/0x3a8
  [<00000000412cfba0>] _raw_spin_lock_irqsave+0xa0/0xe8
  [<000000004031121c>] pdc_iodc_print+0x64/0x180
  [<000000004031d0d8>] pdc_console_write+0x60/0x98
  [<00000000403e76c4>] console_flush_all+0x414/0x638
  [<00000000403e79e4>] console_unlock+0xfc/0x2a8
  [<00000000403e95a8>] vprintk_emit+0x490/0x4a8
  [<00000000403e95fc>] vprintk_default+0x3c/0x50
  [<00000000403e9c74>] vprintk+0x94/0xb8
  [<0000000041296cd0>] _printk+0x58/0x70
  [<000000004125a624>] report_bug+0x1f4/0x2b8
  [<000000004030bcac>] handle_interruption+0x3c4/0xbd8
  [<000000004030307c>] intr_check_sig+0x0/0x3c

Signed-off-by: Helge Deller <deller@gmx.de>

1 files changed, 143 insertions, 143 deletions

diff --git a/arch/parisc/kernel/firmware.c b/arch/parisc/kernel/firmware.c
index c69f6d5946e906..341f384b123dc5 100644
--- a/arch/parisc/kernel/firmware.c
+++ b/arch/parisc/kernel/firmware.c
@@ -66,12 +66,12 @@
 #include <asm/processor.h>	/* for boot_cpu_data */
 
 #if defined(BOOTLOADER)
-# undef  spin_lock_irqsave
-# define spin_lock_irqsave(a, b) { b = 1; }
-# undef  spin_unlock_irqrestore
-# define spin_unlock_irqrestore(a, b)
+# undef  raw_spin_lock_irqsave
+# define raw_spin_lock_irqsave(a, b) { b = 1; }
+# undef  raw_spin_unlock_irqrestore
+# define raw_spin_unlock_irqrestore(a, b)
 #else
-static DEFINE_SPINLOCK(pdc_lock);
+static DEFINE_RAW_SPINLOCK(pdc_lock);
 #endif
 
 static unsigned long pdc_result[NUM_PDC_RESULT]  __aligned(8);
@@ -181,9 +181,9 @@ void set_firmware_width(void)
 	if (parisc_narrow_firmware != NARROW_FIRMWARE)
 		return;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	set_firmware_width_unlocked();
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 }
 #else
 void set_firmware_width_unlocked(void)
@@ -208,8 +208,8 @@ void set_firmware_width(void)
 void pdc_emergency_unlock(void)
 {
  	/* Spinlock DEBUG code freaks out if we unconditionally unlock */
-        if (spin_is_locked(&pdc_lock))
-		spin_unlock(&pdc_lock);
+        if (raw_spin_is_locked(&pdc_lock))
+		raw_spin_unlock(&pdc_lock);
 }
 
 
@@ -227,9 +227,9 @@ int pdc_add_valid(unsigned long address)
         int retval;
 	unsigned long flags;
 
-        spin_lock_irqsave(&pdc_lock, flags);
+        raw_spin_lock_irqsave(&pdc_lock, flags);
         retval = mem_pdc_call(PDC_ADD_VALID, PDC_ADD_VALID_VERIFY, address);
-        spin_unlock_irqrestore(&pdc_lock, flags);
+        raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
         return retval;
 }
@@ -246,11 +246,11 @@ int __init pdc_instr(unsigned int *instr)
 	int retval;
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_INSTR, 0UL, __pa(pdc_result));
 	convert_to_wide(pdc_result);
 	*instr = pdc_result[0];
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return retval;
 }
@@ -268,14 +268,14 @@ int __init pdc_chassis_info(struct pdc_chassis_info *chassis_info, void *led_inf
         int retval;
 	unsigned long flags;
 
-        spin_lock_irqsave(&pdc_lock, flags);
+        raw_spin_lock_irqsave(&pdc_lock, flags);
         memcpy(&pdc_result, chassis_info, sizeof(*chassis_info));
         memcpy(&pdc_result2, led_info, len);
         retval = mem_pdc_call(PDC_CHASSIS, PDC_RETURN_CHASSIS_INFO,
                               __pa(pdc_result), __pa(pdc_result2), len);
         memcpy(chassis_info, pdc_result, sizeof(*chassis_info));
         memcpy(led_info, pdc_result2, len);
-        spin_unlock_irqrestore(&pdc_lock, flags);
+        raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
         return retval;
 }
@@ -296,9 +296,9 @@ int pdc_pat_chassis_send_log(unsigned long state, unsigned long data)
 	if (!is_pdc_pat())
 		return -1;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_PAT_CHASSIS_LOG, PDC_PAT_CHASSIS_WRITE_LOG, __pa(&state), __pa(&data));
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return retval;
 }
@@ -313,9 +313,9 @@ int pdc_chassis_disp(unsigned long disp)
 	int retval = 0;
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_CHASSIS, PDC_CHASSIS_DISP, disp);
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return retval;
 }
@@ -336,7 +336,7 @@ int __pdc_cpu_rendezvous(void)
  */
 void pdc_cpu_rendezvous_lock(void) __acquires(&pdc_lock)
 {
-	spin_lock(&pdc_lock);
+	raw_spin_lock(&pdc_lock);
 }
 
 /**
@@ -344,7 +344,7 @@ void pdc_cpu_rendezvous_lock(void) __acquires(&pdc_lock)
  */
 void pdc_cpu_rendezvous_unlock(void) __releases(&pdc_lock)
 {
-	spin_unlock(&pdc_lock);
+	raw_spin_unlock(&pdc_lock);
 }
 
 /**
@@ -361,11 +361,11 @@ int pdc_pat_get_PDC_entrypoint(unsigned long *pdc_entry)
 		return 0;
 	}
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_PAT_CPU, PDC_PAT_CPU_GET_PDC_ENTRYPOINT,
 			__pa(pdc_result));
 	*pdc_entry = pdc_result[0];
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return retval;
 }
@@ -378,10 +378,10 @@ int pdc_chassis_warn(unsigned long *warn)
 	int retval = 0;
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_CHASSIS, PDC_CHASSIS_WARN, __pa(pdc_result));
 	*warn = pdc_result[0];
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return retval;
 }
@@ -412,9 +412,9 @@ int pdc_coproc_cfg(struct pdc_coproc_cfg *pdc_coproc_info)
 	int ret;
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	ret = pdc_coproc_cfg_unlocked(pdc_coproc_info);
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return ret;
 }
@@ -436,13 +436,13 @@ int pdc_iodc_read(unsigned long *actcnt, unsigned long hpa, unsigned int index,
 	int retval;
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_IODC, PDC_IODC_READ, __pa(pdc_result), hpa, 
 			      index, __pa(pdc_result2), iodc_data_size);
 	convert_to_wide(pdc_result);
 	*actcnt = pdc_result[0];
 	memcpy(iodc_data, pdc_result2, iodc_data_size);
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return retval;
 }
@@ -463,13 +463,13 @@ int pdc_system_map_find_mods(struct pdc_system_map_mod_info *pdc_mod_info,
 	int retval;
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_SYSTEM_MAP, PDC_FIND_MODULE, __pa(pdc_result), 
 			      __pa(pdc_result2), mod_index);
 	convert_to_wide(pdc_result);
 	memcpy(pdc_mod_info, pdc_result, sizeof(*pdc_mod_info));
 	memcpy(mod_path, pdc_result2, sizeof(*mod_path));
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	pdc_mod_info->mod_addr = f_extend(pdc_mod_info->mod_addr);
 	return retval;
@@ -490,12 +490,12 @@ int pdc_system_map_find_addrs(struct pdc_system_map_addr_info *pdc_addr_info,
 	int retval;
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_SYSTEM_MAP, PDC_FIND_ADDRESS, __pa(pdc_result),
 			      mod_index, addr_index);
 	convert_to_wide(pdc_result);
 	memcpy(pdc_addr_info, pdc_result, sizeof(*pdc_addr_info));
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	pdc_addr_info->mod_addr = f_extend(pdc_addr_info->mod_addr);
 	return retval;
@@ -512,11 +512,11 @@ int pdc_model_info(struct pdc_model *model)
 	int retval;
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_MODEL, PDC_MODEL_INFO, __pa(pdc_result), 0);
 	convert_to_wide(pdc_result);
 	memcpy(model, pdc_result, sizeof(*model));
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return retval;
 }
@@ -535,7 +535,7 @@ int pdc_model_sysmodel(unsigned int os_id, char *name)
         int retval;
 	unsigned long flags;
 
-        spin_lock_irqsave(&pdc_lock, flags);
+        raw_spin_lock_irqsave(&pdc_lock, flags);
         retval = mem_pdc_call(PDC_MODEL, PDC_MODEL_SYSMODEL, __pa(pdc_result),
                               os_id, __pa(name));
         convert_to_wide(pdc_result);
@@ -545,7 +545,7 @@ int pdc_model_sysmodel(unsigned int os_id, char *name)
         } else {
                 name[0] = 0;
         }
-        spin_unlock_irqrestore(&pdc_lock, flags);
+        raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
         return retval;
 }
@@ -565,11 +565,11 @@ int pdc_model_versions(unsigned long *versions, int id)
         int retval;
 	unsigned long flags;
 
-        spin_lock_irqsave(&pdc_lock, flags);
+        raw_spin_lock_irqsave(&pdc_lock, flags);
         retval = mem_pdc_call(PDC_MODEL, PDC_MODEL_VERSIONS, __pa(pdc_result), id);
         convert_to_wide(pdc_result);
         *versions = pdc_result[0];
-        spin_unlock_irqrestore(&pdc_lock, flags);
+        raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
         return retval;
 }
@@ -586,12 +586,12 @@ int pdc_model_cpuid(unsigned long *cpu_id)
         int retval;
 	unsigned long flags;
 
-        spin_lock_irqsave(&pdc_lock, flags);
+        raw_spin_lock_irqsave(&pdc_lock, flags);
         pdc_result[0] = 0; /* preset zero (call may not be implemented!) */
         retval = mem_pdc_call(PDC_MODEL, PDC_MODEL_CPU_ID, __pa(pdc_result), 0);
         convert_to_wide(pdc_result);
         *cpu_id = pdc_result[0];
-        spin_unlock_irqrestore(&pdc_lock, flags);
+        raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
         return retval;
 }
@@ -608,7 +608,7 @@ int pdc_model_capabilities(unsigned long *capabilities)
         int retval;
 	unsigned long flags;
 
-        spin_lock_irqsave(&pdc_lock, flags);
+        raw_spin_lock_irqsave(&pdc_lock, flags);
         pdc_result[0] = 0; /* preset zero (call may not be implemented!) */
         retval = mem_pdc_call(PDC_MODEL, PDC_MODEL_CAPABILITIES, __pa(pdc_result), 0);
         convert_to_wide(pdc_result);
@@ -617,7 +617,7 @@ int pdc_model_capabilities(unsigned long *capabilities)
         } else {
                 *capabilities = PDC_MODEL_OS32;
         }
-        spin_unlock_irqrestore(&pdc_lock, flags);
+        raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
         return retval;
 }
@@ -637,11 +637,11 @@ int pdc_model_platform_info(char *orig_prod_num, char *current_prod_num,
 	int retval;
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_MODEL, PDC_MODEL_GET_PLATFORM_INFO,
 		__pa(orig_prod_num), __pa(current_prod_num), __pa(serial_no));
 	convert_to_wide(pdc_result);
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return retval;
 }
@@ -657,11 +657,11 @@ int pdc_cache_info(struct pdc_cache_info *cache_info)
         int retval;
 	unsigned long flags;
 
-        spin_lock_irqsave(&pdc_lock, flags);
+        raw_spin_lock_irqsave(&pdc_lock, flags);
         retval = mem_pdc_call(PDC_CACHE, PDC_CACHE_INFO, __pa(pdc_result), 0);
         convert_to_wide(pdc_result);
         memcpy(cache_info, pdc_result, sizeof(*cache_info));
-        spin_unlock_irqrestore(&pdc_lock, flags);
+        raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
         return retval;
 }
@@ -677,12 +677,12 @@ int pdc_spaceid_bits(unsigned long *space_bits)
 	int retval;
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	pdc_result[0] = 0;
 	retval = mem_pdc_call(PDC_CACHE, PDC_CACHE_RET_SPID, __pa(pdc_result), 0);
 	convert_to_wide(pdc_result);
 	*space_bits = pdc_result[0];
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return retval;
 }
@@ -701,10 +701,10 @@ int pdc_btlb_info(struct pdc_btlb_info *btlb)
 	if (IS_ENABLED(CONFIG_PA20))
 		return PDC_BAD_PROC;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_BLOCK_TLB, PDC_BTLB_INFO, __pa(pdc_result), 0);
 	memcpy(btlb, pdc_result, sizeof(*btlb));
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	if(retval < 0) {
 		btlb->max_size = 0;
@@ -721,10 +721,10 @@ int pdc_btlb_insert(unsigned long long vpage, unsigned long physpage, unsigned l
 	if (IS_ENABLED(CONFIG_PA20))
 		return PDC_BAD_PROC;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_BLOCK_TLB, PDC_BTLB_INSERT, (unsigned long) (vpage >> 32),
 			      (unsigned long) vpage, physpage, len, entry_info, slot);
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 	return retval;
 }
 
@@ -736,9 +736,9 @@ int pdc_btlb_purge_all(void)
 	if (IS_ENABLED(CONFIG_PA20))
 		return PDC_BAD_PROC;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_BLOCK_TLB, PDC_BTLB_PURGE_ALL);
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 	return retval;
 }
 
@@ -763,12 +763,12 @@ int pdc_mem_map_hpa(struct pdc_memory_map *address,
 	if (IS_ENABLED(CONFIG_PA20))
 		return PDC_BAD_PROC;
 
-        spin_lock_irqsave(&pdc_lock, flags);
+        raw_spin_lock_irqsave(&pdc_lock, flags);
         memcpy(pdc_result2, mod_path, sizeof(*mod_path));
         retval = mem_pdc_call(PDC_MEM_MAP, PDC_MEM_MAP_HPA, __pa(pdc_result),
 				__pa(pdc_result2));
         memcpy(address, pdc_result, sizeof(*address));
-        spin_unlock_irqrestore(&pdc_lock, flags);
+        raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
         return retval;
 }
@@ -785,7 +785,7 @@ int pdc_lan_station_id(char *lan_addr, unsigned long hpa)
 	int retval;
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_LAN_STATION_ID, PDC_LAN_STATION_ID_READ,
 			__pa(pdc_result), hpa);
 	if (retval < 0) {
@@ -794,7 +794,7 @@ int pdc_lan_station_id(char *lan_addr, unsigned long hpa)
 	} else {
 		memcpy(lan_addr, pdc_result, PDC_LAN_STATION_ID_SIZE);
 	}
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return retval;
 }
@@ -815,12 +815,12 @@ int pdc_stable_read(unsigned long staddr, void *memaddr, unsigned long count)
        int retval;
 	unsigned long flags;
 
-       spin_lock_irqsave(&pdc_lock, flags);
+       raw_spin_lock_irqsave(&pdc_lock, flags);
        retval = mem_pdc_call(PDC_STABLE, PDC_STABLE_READ, staddr,
                __pa(pdc_result), count);
        convert_to_wide(pdc_result);
        memcpy(memaddr, pdc_result, count);
-       spin_unlock_irqrestore(&pdc_lock, flags);
+       raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
        return retval;
 }
@@ -841,12 +841,12 @@ int pdc_stable_write(unsigned long staddr, void *memaddr, unsigned long count)
        int retval;
 	unsigned long flags;
 
-       spin_lock_irqsave(&pdc_lock, flags);
+       raw_spin_lock_irqsave(&pdc_lock, flags);
        memcpy(pdc_result, memaddr, count);
        convert_to_wide(pdc_result);
        retval = mem_pdc_call(PDC_STABLE, PDC_STABLE_WRITE, staddr,
                __pa(pdc_result), count);
-       spin_unlock_irqrestore(&pdc_lock, flags);
+       raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
        return retval;
 }
@@ -866,10 +866,10 @@ int pdc_stable_get_size(unsigned long *size)
        int retval;
 	unsigned long flags;
 
-       spin_lock_irqsave(&pdc_lock, flags);
+       raw_spin_lock_irqsave(&pdc_lock, flags);
        retval = mem_pdc_call(PDC_STABLE, PDC_STABLE_RETURN_SIZE, __pa(pdc_result));
        *size = pdc_result[0];
-       spin_unlock_irqrestore(&pdc_lock, flags);
+       raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
        return retval;
 }
@@ -886,9 +886,9 @@ int pdc_stable_verify_contents(void)
        int retval;
 	unsigned long flags;
 
-       spin_lock_irqsave(&pdc_lock, flags);
+       raw_spin_lock_irqsave(&pdc_lock, flags);
        retval = mem_pdc_call(PDC_STABLE, PDC_STABLE_VERIFY_CONTENTS);
-       spin_unlock_irqrestore(&pdc_lock, flags);
+       raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
        return retval;
 }
@@ -905,9 +905,9 @@ int pdc_stable_initialize(void)
        int retval;
 	unsigned long flags;
 
-       spin_lock_irqsave(&pdc_lock, flags);
+       raw_spin_lock_irqsave(&pdc_lock, flags);
        retval = mem_pdc_call(PDC_STABLE, PDC_STABLE_INITIALIZE);
-       spin_unlock_irqrestore(&pdc_lock, flags);
+       raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
        return retval;
 }
@@ -932,7 +932,7 @@ int pdc_get_initiator(struct hardware_path *hwpath, struct pdc_initiator *initia
 	int retval;
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 
 /* BCJ-XXXX series boxes. E.G. "9000/785/C3000" */
 #define IS_SPROCKETS() (strlen(boot_cpu_data.pdc.sys_model_name) == 14 && \
@@ -972,7 +972,7 @@ int pdc_get_initiator(struct hardware_path *hwpath, struct pdc_initiator *initia
 	}
 
  out:
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return (retval >= PDC_OK);
 }
@@ -993,12 +993,12 @@ int pdc_pci_irt_size(unsigned long *num_entries, unsigned long hpa)
 	int retval;
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_PCI_INDEX, PDC_PCI_GET_INT_TBL_SIZE, 
 			      __pa(pdc_result), hpa);
 	convert_to_wide(pdc_result);
 	*num_entries = pdc_result[0];
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return retval;
 }
@@ -1019,11 +1019,11 @@ int pdc_pci_irt(unsigned long num_entries, unsigned long hpa, void *tbl)
 
 	BUG_ON((unsigned long)tbl & 0x7);
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	pdc_result[0] = num_entries;
 	retval = mem_pdc_call(PDC_PCI_INDEX, PDC_PCI_GET_INT_TBL, 
 			      __pa(pdc_result), hpa, __pa(tbl));
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return retval;
 }
@@ -1043,12 +1043,12 @@ unsigned int pdc_pci_config_read(void *hpa, unsigned long cfg_addr)
 	int retval;
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	pdc_result[0] = 0;
 	pdc_result[1] = 0;
 	retval = mem_pdc_call(PDC_PCI_INDEX, PDC_PCI_READ_CONFIG, 
 			      __pa(pdc_result), hpa, cfg_addr&~3UL, 4UL);
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return retval ? ~0 : (unsigned int) pdc_result[0];
 }
@@ -1067,12 +1067,12 @@ void pdc_pci_config_write(void *hpa, unsigned long cfg_addr, unsigned int val)
 	int retval;
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	pdc_result[0] = 0;
 	retval = mem_pdc_call(PDC_PCI_INDEX, PDC_PCI_WRITE_CONFIG, 
 			      __pa(pdc_result), hpa,
 			      cfg_addr&~3UL, 4UL, (unsigned long) val);
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return retval;
 }
@@ -1089,11 +1089,11 @@ int pdc_tod_read(struct pdc_tod *tod)
         int retval;
 	unsigned long flags;
 
-        spin_lock_irqsave(&pdc_lock, flags);
+        raw_spin_lock_irqsave(&pdc_lock, flags);
         retval = mem_pdc_call(PDC_TOD, PDC_TOD_READ, __pa(pdc_result), 0);
         convert_to_wide(pdc_result);
         memcpy(tod, pdc_result, sizeof(*tod));
-        spin_unlock_irqrestore(&pdc_lock, flags);
+        raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
         return retval;
 }
@@ -1104,11 +1104,11 @@ int pdc_mem_pdt_info(struct pdc_mem_retinfo *rinfo)
 	int retval;
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_MEM, PDC_MEM_MEMINFO, __pa(pdc_result), 0);
 	convert_to_wide(pdc_result);
 	memcpy(rinfo, pdc_result, sizeof(*rinfo));
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return retval;
 }
@@ -1119,14 +1119,14 @@ int pdc_mem_pdt_read_entries(struct pdc_mem_read_pdt *pret,
 	int retval;
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_MEM, PDC_MEM_READ_PDT, __pa(pdc_result),
 			__pa(pdt_entries_ptr));
 	if (retval == PDC_OK) {
 		convert_to_wide(pdc_result);
 		memcpy(pret, pdc_result, sizeof(*pret));
 	}
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 #ifdef CONFIG_64BIT
 	/*
@@ -1149,10 +1149,10 @@ int pdc_pim_toc11(struct pdc_toc_pim_11 *ret)
 	int retval;
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_PIM, PDC_PIM_TOC, __pa(pdc_result),
 			      __pa(ret), sizeof(*ret));
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 	return retval;
 }
 
@@ -1165,10 +1165,10 @@ int pdc_pim_toc20(struct pdc_toc_pim_20 *ret)
 	int retval;
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_PIM, PDC_PIM_TOC, __pa(pdc_result),
 			      __pa(ret), sizeof(*ret));
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 	return retval;
 }
 
@@ -1184,9 +1184,9 @@ int pdc_tod_set(unsigned long sec, unsigned long usec)
         int retval;
 	unsigned long flags;
 
-        spin_lock_irqsave(&pdc_lock, flags);
+        raw_spin_lock_irqsave(&pdc_lock, flags);
         retval = mem_pdc_call(PDC_TOD, PDC_TOD_WRITE, sec, usec);
-        spin_unlock_irqrestore(&pdc_lock, flags);
+        raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
         return retval;
 }
@@ -1199,12 +1199,12 @@ int pdc_mem_mem_table(struct pdc_memory_table_raddr *r_addr,
 	int retval;
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_MEM, PDC_MEM_TABLE, __pa(pdc_result), __pa(pdc_result2), entries);
 	convert_to_wide(pdc_result);
 	memcpy(r_addr, pdc_result, sizeof(*r_addr));
 	memcpy(tbl, pdc_result2, entries * sizeof(*tbl));
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return retval;
 }
@@ -1219,10 +1219,10 @@ int pdc_do_firm_test_reset(unsigned long ftc_bitmap)
         int retval;
 	unsigned long flags;
 
-        spin_lock_irqsave(&pdc_lock, flags);
+        raw_spin_lock_irqsave(&pdc_lock, flags);
         retval = mem_pdc_call(PDC_BROADCAST_RESET, PDC_DO_FIRM_TEST_RESET,
                               PDC_FIRM_TEST_MAGIC, ftc_bitmap);
-        spin_unlock_irqrestore(&pdc_lock, flags);
+        raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
         return retval;
 }
@@ -1237,9 +1237,9 @@ int pdc_do_reset(void)
         int retval;
 	unsigned long flags;
 
-        spin_lock_irqsave(&pdc_lock, flags);
+        raw_spin_lock_irqsave(&pdc_lock, flags);
         retval = mem_pdc_call(PDC_BROADCAST_RESET, PDC_DO_RESET);
-        spin_unlock_irqrestore(&pdc_lock, flags);
+        raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
         return retval;
 }
@@ -1257,13 +1257,13 @@ int __init pdc_soft_power_info(unsigned long *power_reg)
 
 	*power_reg = (unsigned long) (-1);
 	
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_SOFT_POWER, PDC_SOFT_POWER_INFO, __pa(pdc_result), 0);
 	if (retval == PDC_OK) {
                 convert_to_wide(pdc_result);
                 *power_reg = f_extend(pdc_result[0]);
 	}
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return retval;
 }
@@ -1287,9 +1287,9 @@ int pdc_soft_power_button(int sw_control)
 	int retval;
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_SOFT_POWER, PDC_SOFT_POWER_ENABLE, __pa(pdc_result), sw_control);
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return retval;
 }
@@ -1299,13 +1299,13 @@ int pdc_soft_power_button_panic(int sw_control)
 	int retval;
 	unsigned long flags;
 
-	if (!spin_trylock_irqsave(&pdc_lock, flags)) {
+	if (!raw_spin_trylock_irqsave(&pdc_lock, flags)) {
 		pr_emerg("Couldn't enable soft power button\n");
 		return -EBUSY; /* ignored by the panic notifier */
 	}
 
 	retval = mem_pdc_call(PDC_SOFT_POWER, PDC_SOFT_POWER_ENABLE, __pa(pdc_result), sw_control);
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return retval;
 }
@@ -1319,9 +1319,9 @@ void pdc_io_reset(void)
 {
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	mem_pdc_call(PDC_IO, PDC_IO_RESET, 0);
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 }
 
 /*
@@ -1337,9 +1337,9 @@ void pdc_io_reset_devices(void)
 {
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	mem_pdc_call(PDC_IO, PDC_IO_RESET_DEVICES, 0);
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 }
 
 #endif /* defined(BOOTLOADER) */
@@ -1364,7 +1364,7 @@ int pdc_iodc_print(const unsigned char *str, unsigned count)
 
 	count = min_t(unsigned int, count, sizeof(iodc_dbuf));
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	for (i = 0; i < count;) {
 		switch(str[i]) {
 		case '\n':
@@ -1385,7 +1385,7 @@ print:
 		(unsigned long)PAGE0->mem_cons.hpa, ENTRY_IO_COUT,
 		PAGE0->mem_cons.spa, __pa(PAGE0->mem_cons.dp.layers),
 		__pa(pdc_result), 0, __pa(iodc_dbuf), i, 0);
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return i - found;
 }
@@ -1408,7 +1408,7 @@ int pdc_iodc_getc(void)
 		return 0;
 	
 	/* wait for a keyboard (rs232)-input */
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	real32_call(PAGE0->mem_kbd.iodc_io,
 		    (unsigned long)PAGE0->mem_kbd.hpa, ENTRY_IO_CIN,
 		    PAGE0->mem_kbd.spa, __pa(PAGE0->mem_kbd.dp.layers), 
@@ -1417,7 +1417,7 @@ int pdc_iodc_getc(void)
 	ch = *iodc_dbuf;
 	/* like convert_to_wide() but for first return value only: */
 	status = *(int *)&pdc_result;
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	if (status == 0)
 	    return -1;
@@ -1432,7 +1432,7 @@ int pdc_sti_call(unsigned long func, unsigned long flags,
 	int retval = 0;
 	unsigned long irqflags;
 
-	spin_lock_irqsave(&pdc_lock, irqflags);
+	raw_spin_lock_irqsave(&pdc_lock, irqflags);
 	if (IS_ENABLED(CONFIG_64BIT) && do_call64) {
 #ifdef CONFIG_64BIT
 		retval = real64_call(func, flags, inptr, outputr, glob_cfg);
@@ -1442,7 +1442,7 @@ int pdc_sti_call(unsigned long func, unsigned long flags,
 	} else {
 		retval = real32_call(func, flags, inptr, outputr, glob_cfg);
 	}
-	spin_unlock_irqrestore(&pdc_lock, irqflags);
+	raw_spin_unlock_irqrestore(&pdc_lock, irqflags);
 
 	return retval;
 }
@@ -1461,10 +1461,10 @@ int pdc_pat_cell_get_number(struct pdc_pat_cell_num *cell_info)
 	int retval;
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_PAT_CELL, PDC_PAT_CELL_GET_NUMBER, __pa(pdc_result));
 	memcpy(cell_info, pdc_result, sizeof(*cell_info));
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return retval;
 }
@@ -1487,14 +1487,14 @@ int pdc_pat_cell_module(unsigned long *actcnt, unsigned long ploc, unsigned long
 	unsigned long flags;
 	static struct pdc_pat_cell_mod_maddr_block result __attribute__ ((aligned (8)));
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_PAT_CELL, PDC_PAT_CELL_MODULE, __pa(pdc_result), 
 			      ploc, mod, view_type, __pa(&result));
 	if(!retval) {
 		*actcnt = pdc_result[0];
 		memcpy(mem_addr, &result, *actcnt);
 	}
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return retval;
 }
@@ -1516,7 +1516,7 @@ int pdc_pat_cell_info(struct pdc_pat_cell_info_rtn_block *info,
 	unsigned long flags;
 	struct pdc_pat_cell_info_rtn_block result;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_PAT_CELL, PDC_PAT_CELL_GET_INFO,
 			__pa(pdc_result), __pa(&result), *actcnt,
 			offset, cell_number);
@@ -1524,7 +1524,7 @@ int pdc_pat_cell_info(struct pdc_pat_cell_info_rtn_block *info,
 		*actcnt = pdc_result[0];
 		memcpy(info, &result, *actcnt);
 	}
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return retval;
 }
@@ -1541,11 +1541,11 @@ int pdc_pat_cpu_get_number(struct pdc_pat_cpu_num *cpu_info, unsigned long hpa)
 	int retval;
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_PAT_CPU, PDC_PAT_CPU_GET_NUMBER,
 			      __pa(&pdc_result), hpa);
 	memcpy(cpu_info, pdc_result, sizeof(*cpu_info));
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return retval;
 }
@@ -1563,11 +1563,11 @@ int pdc_pat_get_irt_size(unsigned long *num_entries, unsigned long cell_num)
 	int retval;
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_PAT_IO, PDC_PAT_IO_GET_PCI_ROUTING_TABLE_SIZE,
 			      __pa(pdc_result), cell_num);
 	*num_entries = pdc_result[0];
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return retval;
 }
@@ -1584,10 +1584,10 @@ int pdc_pat_get_irt(void *r_addr, unsigned long cell_num)
 	int retval;
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_PAT_IO, PDC_PAT_IO_GET_PCI_ROUTING_TABLE,
 			      __pa(r_addr), cell_num);
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return retval;
 }
@@ -1606,12 +1606,12 @@ int pdc_pat_pd_get_addr_map(unsigned long *actual_len, void *mem_addr,
 	int retval;
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_PAT_PD, PDC_PAT_PD_GET_ADDR_MAP, __pa(pdc_result), 
 			      __pa(pdc_result2), count, offset);
 	*actual_len = pdc_result[0];
 	memcpy(mem_addr, pdc_result2, *actual_len);
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return retval;
 }
@@ -1629,7 +1629,7 @@ int pdc_pat_pd_get_pdc_revisions(unsigned long *legacy_rev,
 	int retval;
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_PAT_PD, PDC_PAT_PD_GET_PDC_INTERF_REV,
 				__pa(pdc_result));
 	if (retval == PDC_OK) {
@@ -1637,7 +1637,7 @@ int pdc_pat_pd_get_pdc_revisions(unsigned long *legacy_rev,
 		*pat_rev = pdc_result[1];
 		*pdc_cap = pdc_result[2];
 	}
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return retval;
 }
@@ -1655,7 +1655,7 @@ int pdc_pat_io_pci_cfg_read(unsigned long pci_addr, int pci_size, u32 *mem_addr)
 	int retval;
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_PAT_IO, PDC_PAT_IO_PCI_CONFIG_READ,
 					__pa(pdc_result), pci_addr, pci_size);
 	switch(pci_size) {
@@ -1663,7 +1663,7 @@ int pdc_pat_io_pci_cfg_read(unsigned long pci_addr, int pci_size, u32 *mem_addr)
 		case 2: *(u16 *)mem_addr =  (u16) pdc_result[0]; break;
 		case 4: *(u32 *)mem_addr =  (u32) pdc_result[0]; break;
 	}
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return retval;
 }
@@ -1681,10 +1681,10 @@ int pdc_pat_io_pci_cfg_write(unsigned long pci_addr, int pci_size, u32 val)
 	int retval;
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_PAT_IO, PDC_PAT_IO_PCI_CONFIG_WRITE,
 				pci_addr, pci_size, val);
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return retval;
 }
@@ -1699,12 +1699,12 @@ int pdc_pat_mem_pdt_info(struct pdc_pat_mem_retinfo *rinfo)
 	int retval;
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_PAT_MEM, PDC_PAT_MEM_PD_INFO,
 			__pa(&pdc_result));
 	if (retval == PDC_OK)
 		memcpy(rinfo, &pdc_result, sizeof(*rinfo));
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return retval;
 }
@@ -1722,12 +1722,12 @@ int pdc_pat_mem_pdt_cell_info(struct pdc_pat_mem_cell_pdt_retinfo *rinfo,
 	int retval;
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_PAT_MEM, PDC_PAT_MEM_CELL_INFO,
 			__pa(&pdc_result), cell);
 	if (retval == PDC_OK)
 		memcpy(rinfo, &pdc_result, sizeof(*rinfo));
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return retval;
 }
@@ -1745,7 +1745,7 @@ int pdc_pat_mem_read_cell_pdt(struct pdc_pat_mem_read_pd_retinfo *pret,
 	int retval;
 	unsigned long flags, entries;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	/* PDC_PAT_MEM_CELL_READ is available on early PAT machines only */
 	retval = mem_pdc_call(PDC_PAT_MEM, PDC_PAT_MEM_CELL_READ,
 			__pa(&pdc_result), parisc_cell_num,
@@ -1758,7 +1758,7 @@ int pdc_pat_mem_read_cell_pdt(struct pdc_pat_mem_read_pd_retinfo *pret,
 		pret->actual_count_bytes = entries * sizeof(unsigned long);
 	}
 
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 	WARN_ON(retval == PDC_OK && pdc_result[0] > max_entries);
 
 	return retval;
@@ -1778,7 +1778,7 @@ int pdc_pat_mem_read_pd_pdt(struct pdc_pat_mem_read_pd_retinfo *pret,
 	int retval;
 	unsigned long flags, entries;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_PAT_MEM, PDC_PAT_MEM_PD_READ,
 		__pa(&pdc_result), __pa(pdt_entries_ptr),
 		count, offset);
@@ -1789,7 +1789,7 @@ int pdc_pat_mem_read_pd_pdt(struct pdc_pat_mem_read_pd_retinfo *pret,
 		pret->pdt_entries = entries / sizeof(unsigned long);
 	}
 
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return retval;
 }
@@ -1807,14 +1807,14 @@ int pdc_pat_mem_get_dimm_phys_location(
 	int retval;
 	unsigned long flags;
 
-	spin_lock_irqsave(&pdc_lock, flags);
+	raw_spin_lock_irqsave(&pdc_lock, flags);
 	retval = mem_pdc_call(PDC_PAT_MEM, PDC_PAT_MEM_ADDRESS,
 		__pa(&pdc_result), phys_addr);
 
 	if (retval == PDC_OK)
 		memcpy(pret, &pdc_result, sizeof(*pret));
 
-	spin_unlock_irqrestore(&pdc_lock, flags);
+	raw_spin_unlock_irqrestore(&pdc_lock, flags);
 
 	return retval;
 }