static void central_ranges_init(struct linux_central *central)
 {
        struct device_node *dp = central->prom_node;
-       void *pval;
+       const void *pval;
        int len;
        
        central->num_central_ranges = 0;
 static void fhc_ranges_init(struct linux_fhc *fhc)
 {
        struct device_node *dp = fhc->prom_node;
-       void *pval;
+       const void *pval;
        int len;
        
        fhc->num_fhc_ranges = 0;
 static void probe_other_fhcs(void)
 {
        struct device_node *dp;
-       struct linux_prom64_registers *fpregs;
+       const struct linux_prom64_registers *fpregs;
 
        for_each_node_by_name(dp, "fhc") {
                struct linux_fhc *fhc;
                              struct device_node *fp)
 {
        struct device_node *dp;
-       struct linux_prom_registers cregs[3], *pr;
+       struct linux_prom_registers cregs[3];
+       const struct linux_prom_registers *pr;
        int nslots, tmp, nregs;
 
        dp = fp->child;
 
 void central_probe(void)
 {
-       struct linux_prom_registers fpregs[6], *pr;
+       struct linux_prom_registers fpregs[6];
+       const struct linux_prom_registers *pr;
        struct linux_fhc *fhc;
        struct device_node *dp, *fp;
        int err;
 
 {
        struct mctrl_info *mp = kzalloc(sizeof(*mp), GFP_KERNEL);
        int portid = of_getintprop_default(dp, "portid", -1);
-       struct linux_prom64_registers *regs;
-       void *pval;
+       const struct linux_prom64_registers *regs;
+       const void *pval;
        int len;
 
        if (!mp)
 
                                   int non_standard_regs)
 {
        struct of_device *op;
-       int *regs;
+       const int *regs;
        int i, len;
 
        dev->prom_node = dp;
 
 static void map_prom_timers(void)
 {
        struct device_node *dp;
-       unsigned int *addr;
+       const unsigned int *addr;
 
        /* PROM timer node hangs out in the top level of device siblings... */
        dp = of_find_node_by_path("/");
 
 
 static void __init isa_dev_get_resource(struct sparc_isa_device *isa_dev)
 {
-       struct linux_prom_registers *pregs;
+       const struct linux_prom_registers *pregs;
        unsigned long base, len;
        int prop_len;
 
 
                                       int *addrc, int *sizec);
        int             (*map)(u32 *addr, const u32 *range,
                               int na, int ns, int pna);
-       unsigned int    (*get_flags)(u32 *addr);
+       unsigned int    (*get_flags)(const u32 *addr);
 };
 
 /*
        return 0;
 }
 
-static unsigned int of_bus_default_get_flags(u32 *addr)
+static unsigned int of_bus_default_get_flags(const u32 *addr)
 {
        return IORESOURCE_MEM;
 }
        return 0;
 }
 
-static unsigned int of_bus_pci_get_flags(u32 *addr)
+static unsigned int of_bus_pci_get_flags(const u32 *addr)
 {
        unsigned int flags = 0;
        u32 w = addr[0];
                                     u32 *addr,
                                     int na, int ns, int pna)
 {
-       u32 *ranges;
+       const u32 *ranges;
        unsigned int rlen;
        int rone;
 
 
 static int __init use_1to1_mapping(struct device_node *pp)
 {
-       char *model;
+       const char *model;
 
        /* If this is on the PMU bus, don't try to translate it even
         * if a ranges property exists.
        struct of_bus *bus;
        int na, ns;
        int index, num_reg;
-       void *preg;
+       const void *preg;
 
        if (!parent)
                return;
        for (index = 0; index < num_reg; index++) {
                struct resource *r = &op->resource[index];
                u32 addr[OF_MAX_ADDR_CELLS];
-               u32 *reg = (preg + (index * ((na + ns) * 4)));
+               const u32 *reg = (preg + (index * ((na + ns) * 4)));
                struct device_node *dp = op->node;
                struct device_node *pp = p_op->node;
                struct of_bus *pbus, *dbus;
 
 static struct device_node * __init
 apply_interrupt_map(struct device_node *dp, struct device_node *pp,
-                   u32 *imap, int imlen, u32 *imask,
+                   const u32 *imap, int imlen, const u32 *imask,
                    unsigned int *irq_p)
 {
        struct device_node *cp;
        unsigned int irq = *irq_p;
        struct of_bus *bus;
        phandle handle;
-       u32 *reg;
+       const u32 *reg;
        int na, num_reg, i;
 
        bus = of_match_bus(pp);
                                           struct device_node *pp,
                                           unsigned int irq)
 {
-       struct linux_prom_pci_registers *regs;
+       const struct linux_prom_pci_registers *regs;
        unsigned int bus, devfn, slot, ret;
 
        if (irq < 1 || irq > 4)
        pp = dp->parent;
        ip = NULL;
        while (pp) {
-               void *imap, *imsk;
+               const void *imap, *imsk;
                int imlen;
 
                imap = of_get_property(pp, "interrupt-map", &imlen);
                                                 struct device *parent)
 {
        struct of_device *op = kzalloc(sizeof(*op), GFP_KERNEL);
-       unsigned int *irq;
+       const unsigned int *irq;
        int len, i;
 
        if (!op)
 
 
 static void pci_sun4v_msi_init(struct pci_pbm_info *pbm)
 {
-       u32 *val;
+       const u32 *val;
        int len;
 
        val = of_get_property(pbm->prom_node, "#msi-eqs", &len);
                goto no_msi;
        pbm->msiq_num = *val;
        if (pbm->msiq_num) {
-               struct msiq_prop {
+               const struct msiq_prop {
                        u32 first_msiq;
                        u32 num_msiq;
                        u32 first_devino;
                } *mqp;
-               struct msi_range_prop {
+               const struct msi_range_prop {
                        u32 first_msi;
                        u32 num_msi;
                } *mrng;
-               struct addr_range_prop {
+               const struct addr_range_prop {
                        u32 msi32_high;
                        u32 msi32_low;
                        u32 msi32_len;
 
 
 int of_n_addr_cells(struct device_node *np)
 {
-       int* ip;
+       const int* ip;
        do {
                if (np->parent)
                        np = np->parent;
 
 int of_n_size_cells(struct device_node *np)
 {
-       int* ip;
+       const int* ip;
        do {
                if (np->parent)
                        np = np->parent;
 
 static void psycho_irq_trans_init(struct device_node *dp)
 {
-       struct linux_prom64_registers *regs;
+       const struct linux_prom64_registers *regs;
 
        dp->irq_trans = prom_early_alloc(sizeof(struct of_irq_controller));
        dp->irq_trans->irq_build = psycho_irq_build;
 static int sabre_device_needs_wsync(struct device_node *dp)
 {
        struct device_node *parent = dp->parent;
-       char *parent_model, *parent_compat;
+       const char *parent_model, *parent_compat;
 
        /* This traversal up towards the root is meant to
         * handle two cases:
 {
        struct sabre_irq_data *irq_data = _data;
        unsigned long controller_regs = irq_data->controller_regs;
-       struct linux_prom_pci_registers *regs;
+       const struct linux_prom_pci_registers *regs;
        unsigned long imap, iclr;
        unsigned long imap_off, iclr_off;
        int inofixup = 0;
 
 static void sabre_irq_trans_init(struct device_node *dp)
 {
-       struct linux_prom64_registers *regs;
+       const struct linux_prom64_registers *regs;
        struct sabre_irq_data *irq_data;
-       u32 *busrange;
+       const u32 *busrange;
 
        dp->irq_trans = prom_early_alloc(sizeof(struct of_irq_controller));
        dp->irq_trans->irq_build = sabre_irq_build;
 
 static void __schizo_irq_trans_init(struct device_node *dp, int is_tomatillo)
 {
-       struct linux_prom64_registers *regs;
+       const struct linux_prom64_registers *regs;
        struct schizo_irq_data *irq_data;
 
        dp->irq_trans = prom_early_alloc(sizeof(struct of_irq_controller));
 
 static void pci_sun4v_irq_trans_init(struct device_node *dp)
 {
-       struct linux_prom64_registers *regs;
+       const struct linux_prom64_registers *regs;
 
        dp->irq_trans = prom_early_alloc(sizeof(struct of_irq_controller));
        dp->irq_trans->irq_build = pci_sun4v_irq_build;
                                      void *_data)
 {
        unsigned long reg_base = (unsigned long) _data;
-       struct linux_prom_registers *regs;
+       const struct linux_prom_registers *regs;
        unsigned long imap, iclr;
        int sbus_slot = 0;
        int sbus_level = 0;
 
 static void sbus_irq_trans_init(struct device_node *dp)
 {
-       struct linux_prom64_registers *regs;
+       const struct linux_prom64_registers *regs;
 
        dp->irq_trans = prom_early_alloc(sizeof(struct of_irq_controller));
        dp->irq_trans->irq_build = sbus_of_build_irq;
 
 static void sun4v_vdev_irq_trans_init(struct device_node *dp)
 {
-       struct linux_prom64_registers *regs;
+       const struct linux_prom64_registers *regs;
 
        dp->irq_trans = prom_early_alloc(sizeof(struct of_irq_controller));
        dp->irq_trans->irq_build = sun4v_vdev_irq_build;
 
 /* Boot time initialization. */
 static void __init sbus_iommu_init(int __node, struct sbus_bus *sbus)
 {
-       struct linux_prom64_registers *pr;
+       const struct linux_prom64_registers *pr;
        struct device_node *dp;
        struct sbus_iommu *iommu;
        unsigned long regs;
 void sbus_fill_device_irq(struct sbus_dev *sdev)
 {
        struct device_node *dp = of_find_node_by_phandle(sdev->prom_node);
-       struct linux_prom_irqs *irqs;
+       const struct linux_prom_irqs *irqs;
 
        irqs = of_get_property(dp, "interrupts", NULL);
        if (!irqs) {
 
        return -EOPNOTSUPP;
 }
 
-static int __init clock_model_matches(char *model)
+static int __init clock_model_matches(const char *model)
 {
        if (strcmp(model, "mk48t02") &&
            strcmp(model, "mk48t08") &&
 static int __devinit clock_probe(struct of_device *op, const struct of_device_id *match)
 {
        struct device_node *dp = op->node;
-       char *model = of_get_property(dp, "model", NULL);
+       const char *model = of_get_property(dp, "model", NULL);
        unsigned long size, flags;
        void __iomem *regs;
 
 
 
        *buffer = 0;
        if (dp) {
-               char *val = of_get_property(dp, "system-board-serial#", &len);
+               const char *val =
+                       of_get_property(dp, "system-board-serial#", &len);
 
                if (val && len > 0) {
                        if (len > sz)