arch/ppc/syslib/ppc_sys.c

   1 /*
   2  * arch/ppc/syslib/ppc_sys.c
   3  *
   4  * PPC System library functions
   5  *
   6  * Maintainer: Kumar Gala <kumar.gala@freescale.com>
   7  *
   8  * Copyright 2005 Freescale Semiconductor Inc.
   9  * Copyright 2005 MontaVista, Inc. by Vitaly Bordug <vbordug@ru.mvista.com>
  10  *
  11  * This program is free software; you can redistribute  it and/or modify it
  12  * under  the terms of  the GNU General  Public License as published by the
  13  * Free Software Foundation;  either version 2 of the  License, or (at your
  14  * option) any later version.
  15  */
  16
  17 #include <asm/ppc_sys.h>
  18
  19 int (*ppc_sys_device_fixup) (struct platform_device * pdev);
  20
  21 static int ppc_sys_inited;
  22
  23 void __init identify_ppc_sys_by_id(u32 id)
  24 {
  25         unsigned int i = 0;
  26         while (1) {
  27                 if ((ppc_sys_specs[i].mask & id) == ppc_sys_specs[i].value)
  28                         break;
  29                 i++;
  30         }
  31
  32         cur_ppc_sys_spec = &ppc_sys_specs[i];
  33
  34         return;
  35 }
  36
  37 void __init identify_ppc_sys_by_name(char *name)
  38 {
  39         unsigned int i = 0;
  40         while (ppc_sys_specs[i].ppc_sys_name[0])
  41         {
  42                 if (!strcmp(ppc_sys_specs[i].ppc_sys_name, name))
  43                         break;
  44                 i++;
  45         }
  46         cur_ppc_sys_spec = &ppc_sys_specs[i];
  47         return;
  48 }
  49
  50 static int __init count_sys_specs(void)
  51 {
  52         int i = 0;
  53         while (ppc_sys_specs[i].ppc_sys_name[0])
  54                 i++;
  55         return i;
  56 }
  57
  58 static int __init find_chip_by_name_and_id(char *name, u32 id)
  59 {
  60         int ret = -1;
  61         unsigned int i = 0;
  62         unsigned int j = 0;
  63         unsigned int dups = 0;
  64
  65         unsigned char matched[count_sys_specs()];
  66
  67         while (ppc_sys_specs[i].ppc_sys_name[0]) {
  68                 if (!strcmp(ppc_sys_specs[i].ppc_sys_name, name))
  69                         matched[j++] = i;
  70                 i++;
  71         }
  72
  73         ret = i;
  74
  75         if (j != 0) {
  76                 for (i = 0; i < j; i++) {
  77                         if ((ppc_sys_specs[matched[i]].mask & id) ==
  78                             ppc_sys_specs[matched[i]].value) {
  79                                 ret = matched[i];
  80                                 dups++;
  81                         }
  82                 }
  83                 ret = (dups == 1) ? ret : (-1 * dups);
  84         }
  85         return ret;
  86 }
  87
  88 void __init identify_ppc_sys_by_name_and_id(char *name, u32 id)
  89 {
  90         int i = find_chip_by_name_and_id(name, id);
  91         BUG_ON(i < 0);
  92         cur_ppc_sys_spec = &ppc_sys_specs[i];
  93 }
  94
  95 /* Update all memory resources by paddr, call before platform_device_register */
  96 void __init
  97 ppc_sys_fixup_mem_resource(struct platform_device *pdev, phys_addr_t paddr)
  98 {
  99         int i;
 100         for (i = 0; i < pdev->num_resources; i++) {
 101                 struct resource *r = &pdev->resource[i];
 102                 if ((r->flags & IORESOURCE_MEM) == IORESOURCE_MEM) {
 103                         r->start += paddr;
 104                         r->end += paddr;
 105                 }
 106         }
 107 }
 108
 109 /* Get platform_data pointer out of platform device, call before platform_device_register */
 110 void *__init ppc_sys_get_pdata(enum ppc_sys_devices dev)
 111 {
 112         return ppc_sys_platform_devices[dev].dev.platform_data;
 113 }
 114
 115 void ppc_sys_device_remove(enum ppc_sys_devices dev)
 116 {
 117         unsigned int i;
 118
 119         if (ppc_sys_inited) {
 120                 platform_device_unregister(&ppc_sys_platform_devices[dev]);
 121         } else {
 122                 if (cur_ppc_sys_spec == NULL)
 123                         return;
 124                 for (i = 0; i < cur_ppc_sys_spec->num_devices; i++)
 125                         if (cur_ppc_sys_spec->device_list[i] == dev)
 126                                 cur_ppc_sys_spec->device_list[i] = -1;
 127         }
 128 }
 129
 130 static int __init ppc_sys_init(void)
 131 {
 132         unsigned int i, dev_id, ret = 0;
 133
 134         BUG_ON(cur_ppc_sys_spec == NULL);
 135
 136         for (i = 0; i < cur_ppc_sys_spec->num_devices; i++) {
 137                 dev_id = cur_ppc_sys_spec->device_list[i];
 138                 if (dev_id != -1) {
 139                         if (ppc_sys_device_fixup != NULL)
 140                                 ppc_sys_device_fixup(&ppc_sys_platform_devices
 141                                                      [dev_id]);
 142                         if (platform_device_register
 143                             (&ppc_sys_platform_devices[dev_id])) {
 144                                 ret = 1;
 145                                 printk(KERN_ERR
 146                                        "unable to register device %d\n",
 147                                        dev_id);
 148                         }
 149                 }
 150         }
 151
 152         ppc_sys_inited = 1;
 153         return ret;
 154 }
 155
 156 subsys_initcall(ppc_sys_init);