#include <linux/ftrace.h>
 #include <linux/suspend.h>
 #include <linux/gfp.h>
+#include <linux/io.h>
 
 #include <asm/pgtable.h>
 #include <asm/pgalloc.h>
 #include <asm/tlbflush.h>
 #include <asm/mmu_context.h>
-#include <asm/io.h>
 #include <asm/apic.h>
 #include <asm/cpufeature.h>
 #include <asm/desc.h>
                "\tmovl %%eax,%%fs\n"
                "\tmovl %%eax,%%gs\n"
                "\tmovl %%eax,%%ss\n"
-               ::: "eax", "memory");
+               : : : "eax", "memory");
 #undef STR
 #undef __STR
 }
 
        if (image->preserve_context) {
 #ifdef CONFIG_X86_IO_APIC
-               /* We need to put APICs in legacy mode so that we can
+               /*
+                * We need to put APICs in legacy mode so that we can
                 * get timer interrupts in second kernel. kexec/kdump
                 * paths already have calls to disable_IO_APIC() in
                 * one form or other. kexec jump path also need
                page_list[PA_SWAP_PAGE] = (page_to_pfn(image->swap_page)
                                                << PAGE_SHIFT);
 
-       /* The segment registers are funny things, they have both a
+       /*
+        * The segment registers are funny things, they have both a
         * visible and an invisible part.  Whenever the visible part is
         * set to a specific selector, the invisible part is loaded
         * with from a table in memory.  At no other time is the
         * segments, before I zap the gdt with an invalid value.
         */
        load_segments();
-       /* The gdt & idt are now invalid.
+       /*
+        * The gdt & idt are now invalid.
         * If you want to load them you must set up your own idt & gdt.
         */
-       set_gdt(phys_to_virt(0),0);
-       set_idt(phys_to_virt(0),0);
+       set_gdt(phys_to_virt(0), 0);
+       set_idt(phys_to_virt(0), 0);
 
        /* now call it */
        image->start = relocate_kernel_ptr((unsigned long)image->head,
 
 #include <linux/reboot.h>
 #include <linux/numa.h>
 #include <linux/ftrace.h>
+#include <linux/io.h>
 
 #include <asm/pgtable.h>
 #include <asm/tlbflush.h>
 #include <asm/mmu_context.h>
-#include <asm/io.h>
 
 static void init_level2_page(pmd_t *level2p, unsigned long addr)
 {
                }
                level3p = (pud_t *)page_address(page);
                result = init_level3_page(image, level3p, addr, last_addr);
-               if (result) {
+               if (result)
                        goto out;
-               }
                set_pgd(level4p++, __pgd(__pa(level3p) | _KERNPG_TABLE));
                addr += PGDIR_SIZE;
        }
        page_list[PA_TABLE_PAGE] =
          (unsigned long)__pa(page_address(image->control_code_page));
 
-       /* The segment registers are funny things, they have both a
+       /*
+        * The segment registers are funny things, they have both a
         * visible and an invisible part.  Whenever the visible part is
         * set to a specific selector, the invisible part is loaded
         * with from a table in memory.  At no other time is the
         * segments, before I zap the gdt with an invalid value.
         */
        load_segments();
-       /* The gdt & idt are now invalid.
+       /*
+        * The gdt & idt are now invalid.
         * If you want to load them you must set up your own idt & gdt.
         */
-       set_gdt(phys_to_virt(0),0);
-       set_idt(phys_to_virt(0),0);
+       set_gdt(phys_to_virt(0), 0);
+       set_idt(phys_to_virt(0), 0);
 
        /* now call it */
        relocate_kernel((unsigned long)image->head, (unsigned long)page_list,
 
 
 #define PTR(x) (x << 2)
 
-/* control_page + KEXEC_CONTROL_CODE_MAX_SIZE
+/*
+ * control_page + KEXEC_CONTROL_CODE_MAX_SIZE
  * ~ control_page + PAGE_SIZE are used as data storage and stack for
  * jumping back
  */
        movl    %eax, CP_PA_SWAP_PAGE(%edi)
        movl    %ebx, CP_PA_BACKUP_PAGES_MAP(%edi)
 
-       /* get physical address of control page now */
-       /* this is impossible after page table switch */
+       /*
+        * get physical address of control page now
+        * this is impossible after page table switch
+        */
        movl    PTR(PA_CONTROL_PAGE)(%ebp), %edi
 
        /* switch to new set of page tables */
        /* store the start address on the stack */
        pushl   %edx
 
-       /* Set cr0 to a known state:
+       /*
+        * Set cr0 to a known state:
         *  - Paging disabled
         *  - Alignment check disabled
         *  - Write protect disabled
        /* clear cr4 if applicable */
        testl   %ecx, %ecx
        jz      1f
-       /* Set cr4 to a known state:
+       /*
+        * Set cr4 to a known state:
         * Setting everything to zero seems safe.
         */
        xorl    %eax, %eax
        call    swap_pages
        addl    $8, %esp
 
-       /* To be certain of avoiding problems with self-modifying code
+       /*
+        * To be certain of avoiding problems with self-modifying code
         * I need to execute a serializing instruction here.
         * So I flush the TLB, it's handy, and not processor dependent.
         */
        xorl    %eax, %eax
        movl    %eax, %cr3
 
-       /* set all of the registers to known values */
-       /* leave %esp alone */
+       /*
+        * set all of the registers to known values
+        * leave %esp alone
+        */
 
        testl   %esi, %esi
        jnz 1f
 
        .code64
        .globl relocate_kernel
 relocate_kernel:
-       /* %rdi indirection_page
+       /*
+        * %rdi indirection_page
         * %rsi page_list
         * %rdx start address
         */
        pushq $0
        popfq
 
-       /* get physical address of control page now */
-       /* this is impossible after page table switch */
+       /*
+        * get physical address of control page now
+        * this is impossible after page table switch
+        */
        movq    PTR(PA_CONTROL_PAGE)(%rsi), %r8
 
        /* get physical address of page table now too */
        /* store the start address on the stack */
        pushq   %rdx
 
-       /* Set cr0 to a known state:
+       /*
+        * Set cr0 to a known state:
         *  - Paging enabled
         *  - Alignment check disabled
         *  - Write protect disabled
        orl     $(X86_CR0_PG | X86_CR0_PE), %eax
        movq    %rax, %cr0
 
-       /* Set cr4 to a known state:
+       /*
+        * Set cr4 to a known state:
         *  - physical address extension enabled
         */
        movq    $X86_CR4_PAE, %rax
        jmp     0b
 3:
 
-       /* To be certain of avoiding problems with self-modifying code
+       /*
+        * To be certain of avoiding problems with self-modifying code
         * I need to execute a serializing instruction here.
         * So I flush the TLB by reloading %cr3 here, it's handy,
         * and not processor dependent.
        movq    %cr3, %rax
        movq    %rax, %cr3
 
-       /* set all of the registers to known values */
-       /* leave %rsp alone */
+       /*
+        * set all of the registers to known values
+        * leave %rsp alone
+        */
 
        xorq    %rax, %rax
        xorq    %rbx, %rbx