target/linux/adm5120/files/arch/mips/adm5120/common/prom.c

   1 /*
   2  *  ADM5120 specific prom routines
   3  *
   4  *  Copyright (C) 2007-2008 Gabor Juhos <juhosg@openwrt.org>
   5  *
   6  *  This program is free software; you can redistribute it and/or modify it
   7  *  under the terms of the GNU General Public License version 2 as published
   8  *  by the Free Software Foundation.
   9  *
  10  */
  11
  12 #include <linux/init.h>
  13 #include <linux/kernel.h>
  14 #include <linux/string.h>
  15 #include <linux/mm.h>
  16
  17 #include <asm/bootinfo.h>
  18 #include <asm/mips_machine.h>
  19
  20 #include <asm/mach-adm5120/adm5120_info.h>
  21
  22 #include <prom/cfe.h>
  23 #include <prom/generic.h>
  24 #include <prom/routerboot.h>
  25 #include <prom/myloader.h>
  26 #include <prom/zynos.h>
  27
  28 unsigned int adm5120_prom_type  = ADM5120_PROM_GENERIC;
  29
  30 struct board_desc {
  31         unsigned long   mach_type;
  32         char            *name;
  33 };
  34
  35 #define DEFBOARD(n, mt) { .mach_type = (mt), .name = (n)}
  36 static struct board_desc common_boards[] __initdata = {
  37         /* Cellvision/SparkLAN boards */
  38         DEFBOARD("CAS-630",     MACH_ADM5120_CAS630),
  39         DEFBOARD("CAS-670",     MACH_ADM5120_CAS670),
  40         DEFBOARD("CAS-700",     MACH_ADM5120_CAS700),
  41         DEFBOARD("CAS-771",     MACH_ADM5120_CAS771),
  42         DEFBOARD("CAS-790",     MACH_ADM5120_CAS790),
  43         DEFBOARD("CAS-861",     MACH_ADM5120_CAS861),
  44         DEFBOARD("NFS-101U",    MACH_ADM5120_NFS101U),
  45         /* Compex boards */
  46         DEFBOARD("WP54G-WRT",   MACH_ADM5120_WP54G_WRT),
  47         /* Edimax boards */
  48         DEFBOARD("BR-6104K",    MACH_ADM5120_BR6104K),
  49         DEFBOARD("BR-6104KP",   MACH_ADM5120_BR6104KP),
  50         DEFBOARD("BR-6104WG",   MACH_ADM5120_BR61X4WG),
  51         DEFBOARD("BR-6114WG",   MACH_ADM5120_BR61X4WG),
  52         /* Infineon boards */
  53         DEFBOARD("EASY 5120P-ATA",      MACH_ADM5120_EASY5120PATA),
  54         DEFBOARD("EASY 5120-RT",        MACH_ADM5120_EASY5120RT),
  55         DEFBOARD("EASY 5120-WVoIP",     MACH_ADM5120_EASY5120WVOIP),
  56         DEFBOARD("EASY 83000",          MACH_ADM5120_EASY83000),
  57         /* Mikrotik RouterBOARDs */
  58         DEFBOARD("111",         MACH_ADM5120_RB_11X),
  59         DEFBOARD("112",         MACH_ADM5120_RB_11X),
  60         DEFBOARD("133",         MACH_ADM5120_RB_133),
  61         DEFBOARD("133C",        MACH_ADM5120_RB_133C),
  62         DEFBOARD("133C3",       MACH_ADM5120_RB_133C),
  63         DEFBOARD("150",         MACH_ADM5120_RB_153), /* it's intentional */
  64         DEFBOARD("153",         MACH_ADM5120_RB_153),
  65         DEFBOARD("192",         MACH_ADM5120_RB_192),
  66         DEFBOARD("miniROUTER",  MACH_ADM5120_RB_150),
  67         /* OSBRiDGE boards */
  68         DEFBOARD("OSBRiDGE 5GXi",       MACH_ADM5120_5GXI),
  69         /* Motorola boards */
  70         DEFBOARD("Powerline MU Gateway",MACH_ADM5120_PMUGW),
  71 };
  72
  73 static unsigned long __init find_machtype_byname(char *name)
  74 {
  75         unsigned long ret;
  76         int i;
  77
  78         ret = MACH_ADM5120_GENERIC;
  79         if (name == NULL)
  80                 goto out;
  81
  82         if (*name == '\0')
  83                 goto out;
  84
  85         for (i = 0; i < ARRAY_SIZE(common_boards); i++) {
  86                 if (strcmp(common_boards[i].name, name) == 0) {
  87                         ret = common_boards[i].mach_type;
  88                         break;
  89                 }
  90         }
  91
  92 out:
  93         return ret;
  94 }
  95
  96 static unsigned long __init detect_machtype_routerboot(void)
  97 {
  98         char *name;
  99
 100         name = routerboot_get_boardname();
 101         return find_machtype_byname(name);
 102 }
 103
 104 static unsigned long __init detect_machtype_generic(void)
 105 {
 106         char *name;
 107
 108         name = generic_prom_getenv("board_name");
 109         return find_machtype_byname(name);
 110 }
 111
 112 unsigned long __init detect_machtype_cfe(void)
 113 {
 114         char *name;
 115
 116         name = cfe_getenv("BOARD_NAME");
 117         return find_machtype_byname(name);
 118 }
 119
 120 static struct {
 121         unsigned long   mach_type;
 122         u16             vendor_id;
 123         u16             board_id;
 124 } zynos_boards[] __initdata = {
 125 #define ZYNOS_BOARD(vi, bi, mt) \
 126         {.vendor_id = (vi), .board_id = (bi), .mach_type = (mt)}
 127
 128 #define ZYXEL_BOARD(bi, mt) ZYNOS_BOARD(ZYNOS_VENDOR_ID_ZYXEL, bi, mt)
 129 #define DLINK_BOARD(bi, mt) ZYNOS_BOARD(ZYNOS_VENDOR_ID_DLINK, bi, mt)
 130 #define LUCENT_BOARD(bi, mt) ZYNOS_BOARD(ZYNOS_VENDOR_ID_LUCENT, bi, mt)
 131         ZYXEL_BOARD(ZYNOS_BOARD_HS100,  MACH_ADM5120_HS100),
 132         ZYXEL_BOARD(ZYNOS_BOARD_P334U,  MACH_ADM5120_P334U),
 133         ZYXEL_BOARD(ZYNOS_BOARD_P334W,  MACH_ADM5120_P334W),
 134         ZYXEL_BOARD(ZYNOS_BOARD_P334WH, MACH_ADM5120_P334WH),
 135         ZYXEL_BOARD(ZYNOS_BOARD_P334WHD, MACH_ADM5120_P334WHD),
 136         ZYXEL_BOARD(ZYNOS_BOARD_P334WT, MACH_ADM5120_P334WT),
 137         ZYXEL_BOARD(ZYNOS_BOARD_P334WT_ALT,     MACH_ADM5120_P334WT),
 138         ZYXEL_BOARD(ZYNOS_BOARD_P335,   MACH_ADM5120_P335),
 139         ZYXEL_BOARD(ZYNOS_BOARD_P335PLUS, MACH_ADM5120_P335PLUS),
 140         ZYXEL_BOARD(ZYNOS_BOARD_P335U,  MACH_ADM5120_P335U)
 141 };
 142
 143 static unsigned long __init detect_machtype_bootbase(void)
 144 {
 145         int i;
 146
 147         for (i = 0; i < ARRAY_SIZE(zynos_boards); i++) {
 148                 if (zynos_boards[i].vendor_id == bootbase_info.vendor_id &&
 149                         zynos_boards[i].board_id == bootbase_info.board_id) {
 150                         return zynos_boards[i].mach_type;
 151                         break;
 152                 }
 153         }
 154
 155         printk(KERN_WARNING "Unknown ZyXEL model (%u)\n",
 156                                 bootbase_info.board_id);
 157         return MACH_ADM5120_GENERIC;
 158 }
 159
 160 static struct {
 161         unsigned long   mach_type;
 162         u16     vid;
 163         u16     did;
 164         u16     svid;
 165         u16     sdid;
 166 } mylo_boards[]  __initdata = {
 167 #define MYLO_BOARD(v, d, sv, sd, mt) \
 168         {.vid = (v), .did = (d), .svid = (sv), .sdid = (sd), .mach_type = (mt)}
 169 #define COMPEX_BOARD(d, mt) \
 170         MYLO_BOARD(VENID_COMPEX, (d), VENID_COMPEX, (d), (mt))
 171
 172         COMPEX_BOARD(DEVID_COMPEX_NP27G, MACH_ADM5120_NP27G),
 173         COMPEX_BOARD(DEVID_COMPEX_NP28G, MACH_ADM5120_NP28G),
 174         COMPEX_BOARD(DEVID_COMPEX_NP28GHS, MACH_ADM5120_NP28GHS),
 175         COMPEX_BOARD(DEVID_COMPEX_WP54G, MACH_ADM5120_WP54),
 176         COMPEX_BOARD(DEVID_COMPEX_WP54Gv1C, MACH_ADM5120_WP54Gv1C),
 177         COMPEX_BOARD(DEVID_COMPEX_WP54AG, MACH_ADM5120_WP54),
 178         COMPEX_BOARD(DEVID_COMPEX_WPP54G, MACH_ADM5120_WP54),
 179         COMPEX_BOARD(DEVID_COMPEX_WPP54AG, MACH_ADM5120_WP54),
 180 };
 181
 182 static unsigned long __init detect_machtype_myloader(void)
 183 {
 184         unsigned long ret;
 185         int i;
 186
 187         ret = MACH_ADM5120_GENERIC;
 188         for (i = 0; i < ARRAY_SIZE(mylo_boards); i++) {
 189                 if (mylo_boards[i].vid == myloader_info.vid &&
 190                         mylo_boards[i].did == myloader_info.did &&
 191                         mylo_boards[i].svid == myloader_info.svid &&
 192                         mylo_boards[i].sdid == myloader_info.sdid) {
 193                         ret = mylo_boards[i].mach_type;
 194                         break;
 195                 }
 196         }
 197
 198         return ret;
 199 }
 200
 201 static void __init prom_detect_machtype(void)
 202 {
 203         if (bootbase_present()) {
 204                 adm5120_prom_type = ADM5120_PROM_BOOTBASE;
 205                 adm5120_mach_type = detect_machtype_bootbase();
 206                 return;
 207         }
 208
 209         if (cfe_present()) {
 210                 adm5120_prom_type = ADM5120_PROM_CFE;
 211                 adm5120_mach_type = detect_machtype_cfe();
 212                 return;
 213         }
 214
 215         if (myloader_present()) {
 216                 adm5120_prom_type = ADM5120_PROM_MYLOADER;
 217                 adm5120_mach_type = detect_machtype_myloader();
 218                 return;
 219         }
 220
 221         if (routerboot_present()) {
 222                 adm5120_prom_type = ADM5120_PROM_ROUTERBOOT;
 223                 adm5120_mach_type = detect_machtype_routerboot();
 224                 return;
 225         }
 226
 227         if (generic_prom_present()) {
 228                 adm5120_prom_type = ADM5120_PROM_GENERIC;
 229                 adm5120_mach_type = detect_machtype_generic();
 230                 return;
 231         }
 232
 233         adm5120_mach_type = MACH_ADM5120_GENERIC;
 234 }
 235
 236 #ifdef CONFIG_IMAGE_CMDLINE_HACK
 237 extern char __image_cmdline[];
 238
 239 static void __init prom_init_cmdline(void)
 240 {
 241         char *cmd;
 242
 243         /* init command line, register a default kernel command line */
 244         cmd = __image_cmdline;
 245         if (strlen(cmd) > 0)
 246                 strlcpy(arcs_cmdline, cmd, sizeof(arcs_cmdline));
 247
 248 }
 249 #else
 250 static void inline prom_init_cmdline(void) {}
 251 #endif /* CONFIG_IMAGE_CMDLINE_HACK */
 252
 253 void __init prom_init(void)
 254 {
 255         prom_detect_machtype();
 256         prom_init_cmdline();
 257 }
 258
 259 void __init prom_free_prom_memory(void)
 260 {
 261         /* We do not have to prom memory to free */
 262 }