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

   1 /*
   2  *  $Id$
   3  *
   4  *  ADM5120 specific prom routines
   5  *
   6  *  Copyright (C) 2007 OpenWrt.org
   7  *  Copyright (C) 2007 Gabor Juhos <juhosg at openwrt.org>
   8  *
   9  *  This program is free software; you can redistribute it and/or
  10  *  modify it under the terms of the GNU General Public License
  11  *  as published by the Free Software Foundation; either version 2
  12  *  of the License, or (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the
  21  *  Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  22  *  Boston, MA  02110-1301, USA.
  23  *
  24  */
  25
  26 #include <linux/init.h>
  27 #include <linux/kernel.h>
  28 #include <linux/string.h>
  29 #include <linux/mm.h>
  30 #include <linux/io.h>
  31
  32 #include <asm/bootinfo.h>
  33 #include <asm/addrspace.h>
  34
  35 #include <adm5120_info.h>
  36 #include <adm5120_defs.h>
  37 #include <adm5120_uart.h>
  38
  39 #include <prom/cfe.h>
  40 #include <prom/generic.h>
  41 #include <prom/routerboot.h>
  42 #include <prom/myloader.h>
  43 #include <prom/zynos.h>
  44
  45 unsigned int adm5120_prom_type  = ADM5120_PROM_GENERIC;
  46
  47 struct board_desc {
  48         unsigned long   mach_type;
  49         char            *name;
  50 };
  51
  52 #define DEFBOARD(n, mt) { .mach_type = (mt), .name = (n)}
  53 static struct board_desc common_boards[] __initdata = {
  54         /* Cellvision/SparkLAN boards */
  55         DEFBOARD("CAS-630",     MACH_ADM5120_CAS630),
  56         DEFBOARD("CAS-670",     MACH_ADM5120_CAS670),
  57         DEFBOARD("CAS-700",     MACH_ADM5120_CAS700),
  58         DEFBOARD("CAS-771",     MACH_ADM5120_CAS771),
  59         DEFBOARD("CAS-790",     MACH_ADM5120_CAS790),
  60         DEFBOARD("CAS-861",     MACH_ADM5120_CAS861),
  61         DEFBOARD("NFS-101U",    MACH_ADM5120_NFS101U),
  62         /* Compex boards */
  63         DEFBOARD("WP54G-WRT",   MACH_ADM5120_WP54G_WRT),
  64         /* Edimax boards */
  65         DEFBOARD("BR-6104K",    MACH_ADM5120_BR6104K),
  66         DEFBOARD("BR-6104KP",   MACH_ADM5120_BR6104K),
  67         DEFBOARD("BR-6104WG",   MACH_ADM5120_BR61x4WG),
  68         DEFBOARD("BR-6114WG",   MACH_ADM5120_BR61x4WG),
  69         /* Infineon boards */
  70         DEFBOARD("EASY 5120P-ATA",      MACH_ADM5120_EASY5120PATA),
  71         DEFBOARD("EASY 5120-RT",        MACH_ADM5120_EASY5120RT),
  72         DEFBOARD("EASY 5120-WVoIP",     MACH_ADM5120_EASY5120WVOIP),
  73         DEFBOARD("EASY 83000",          MACH_ADM5120_EASY83000),
  74         /* Mikrotik RouterBOARDs */
  75         DEFBOARD("111",         MACH_ADM5120_RB_111),
  76         DEFBOARD("112",         MACH_ADM5120_RB_112),
  77         DEFBOARD("133",         MACH_ADM5120_RB_133),
  78         DEFBOARD("133C",        MACH_ADM5120_RB_133C),
  79         DEFBOARD("133C3",       MACH_ADM5120_RB_133C),
  80         DEFBOARD("150",         MACH_ADM5120_RB_153), /* it's intentional */
  81         DEFBOARD("153",         MACH_ADM5120_RB_153),
  82         DEFBOARD("192",         MACH_ADM5120_RB_192),
  83         DEFBOARD("miniROUTER",  MACH_ADM5120_RB_150),
  84 };
  85
  86 static unsigned long __init find_machtype_byname(char *name)
  87 {
  88         unsigned long ret;
  89         int i;
  90
  91         ret = MACH_ADM5120_GENERIC;
  92         if (name == NULL)
  93                 goto out;
  94
  95         if (*name == '\0')
  96                 goto out;
  97
  98         for (i = 0; i < ARRAY_SIZE(common_boards); i++) {
  99                 if (strcmp(common_boards[i].name, name) == 0) {
 100                         ret = common_boards[i].mach_type;
 101                         break;
 102                 }
 103         }
 104
 105 out:
 106         return ret;
 107 }
 108
 109 static unsigned long __init detect_machtype_routerboot(void)
 110 {
 111         char *name;
 112
 113         name = routerboot_get_boardname();
 114         return find_machtype_byname(name);
 115 }
 116
 117 static unsigned long __init detect_machtype_generic(void)
 118 {
 119         char *name;
 120
 121         name = generic_prom_getenv("board_name");
 122         return find_machtype_byname(name);
 123 }
 124
 125 unsigned long __init detect_machtype_cfe(void)
 126 {
 127         char *name;
 128
 129         name = cfe_getenv("BOARD_NAME");
 130         return find_machtype_byname(name);
 131 }
 132
 133 static struct {
 134         unsigned long   mach_type;
 135         u16             vendor_id;
 136         u16             board_id;
 137 } zynos_boards[] __initdata = {
 138 #define ZYNOS_BOARD(vi, bi, mt) \
 139         {.vendor_id = (vi), .board_id = (bi), .mach_type = (mt)}
 140
 141 #define ZYXEL_BOARD(bi, mt) ZYNOS_BOARD(ZYNOS_VENDOR_ID_ZYXEL, bi, mt)
 142 #define DLINK_BOARD(bi, mt) ZYNOS_BOARD(ZYNOS_VENDOR_ID_DLINK, bi, mt)
 143 #define LUCENT_BOARD(bi, mt) ZYNOS_BOARD(ZYNOS_VENDOR_ID_LUCENT, bi, mt)
 144         ZYXEL_BOARD(ZYNOS_BOARD_HS100,  MACH_ADM5120_HS100),
 145         ZYXEL_BOARD(ZYNOS_BOARD_P334,   MACH_ADM5120_P334),
 146         ZYXEL_BOARD(ZYNOS_BOARD_P334U,  MACH_ADM5120_P334U),
 147         ZYXEL_BOARD(ZYNOS_BOARD_P334W,  MACH_ADM5120_P334W),
 148         ZYXEL_BOARD(ZYNOS_BOARD_P334WH, MACH_ADM5120_P334WH),
 149         ZYXEL_BOARD(ZYNOS_BOARD_P334WHD, MACH_ADM5120_P334WHD),
 150         ZYXEL_BOARD(ZYNOS_BOARD_P334WT, MACH_ADM5120_P334WT),
 151         ZYXEL_BOARD(ZYNOS_BOARD_P335,   MACH_ADM5120_P335),
 152         ZYXEL_BOARD(ZYNOS_BOARD_P335PLUS, MACH_ADM5120_P335PLUS),
 153         ZYXEL_BOARD(ZYNOS_BOARD_P335U,  MACH_ADM5120_P335U)
 154 };
 155
 156 static unsigned long __init detect_machtype_bootbase(void)
 157 {
 158         unsigned long ret;
 159         int i;
 160
 161         ret = MACH_ADM5120_GENERIC;
 162         for (i = 0; i < ARRAY_SIZE(zynos_boards); i++) {
 163                 if (zynos_boards[i].vendor_id == bootbase_info.vendor_id &&
 164                         zynos_boards[i].board_id == bootbase_info.board_id) {
 165                         ret = zynos_boards[i].mach_type;
 166                         break;
 167                 }
 168         }
 169
 170         return ret;
 171 }
 172
 173 static struct {
 174         unsigned long   mach_type;
 175         u16     vid;
 176         u16     did;
 177         u16     svid;
 178         u16     sdid;
 179 } mylo_boards[]  __initdata = {
 180 #define MYLO_BOARD(v, d, sv, sd, mt) \
 181         {.vid = (v), .did = (d), .svid = (sv), .sdid = (sd), .mach_type = (mt)}
 182 #define COMPEX_BOARD(d, mt) \
 183         MYLO_BOARD(VENID_COMPEX, (d), VENID_COMPEX, (d), (mt))
 184
 185         COMPEX_BOARD(DEVID_COMPEX_NP27G, MACH_ADM5120_NP27G),
 186         COMPEX_BOARD(DEVID_COMPEX_NP28G, MACH_ADM5120_NP28G),
 187         COMPEX_BOARD(DEVID_COMPEX_NP28GHS, MACH_ADM5120_NP28GHS),
 188         COMPEX_BOARD(DEVID_COMPEX_WP54G, MACH_ADM5120_WP54G),
 189         COMPEX_BOARD(DEVID_COMPEX_WP54Gv1C, MACH_ADM5120_WP54Gv1C),
 190         COMPEX_BOARD(DEVID_COMPEX_WP54AG, MACH_ADM5120_WP54AG),
 191         COMPEX_BOARD(DEVID_COMPEX_WPP54G, MACH_ADM5120_WPP54G),
 192         COMPEX_BOARD(DEVID_COMPEX_WPP54AG, MACH_ADM5120_WPP54AG),
 193 };
 194
 195 static unsigned long __init detect_machtype_myloader(void)
 196 {
 197         unsigned long ret;
 198         int i;
 199
 200         ret = MACH_ADM5120_GENERIC;
 201         for (i = 0; i < ARRAY_SIZE(mylo_boards); i++) {
 202                 if (mylo_boards[i].vid == myloader_info.vid &&
 203                         mylo_boards[i].did == myloader_info.did &&
 204                         mylo_boards[i].svid == myloader_info.svid &&
 205                         mylo_boards[i].sdid == myloader_info.sdid) {
 206                         ret = mylo_boards[i].mach_type;
 207                         break;
 208                 }
 209         }
 210
 211         return ret;
 212 }
 213
 214 static void __init prom_detect_machtype(void)
 215 {
 216         if (bootbase_present()) {
 217                 adm5120_prom_type = ADM5120_PROM_BOOTBASE;
 218                 mips_machtype = detect_machtype_bootbase();
 219                 return;
 220         }
 221
 222         if (cfe_present()) {
 223                 adm5120_prom_type = ADM5120_PROM_CFE;
 224                 mips_machtype = detect_machtype_cfe();
 225                 return;
 226         }
 227
 228         if (myloader_present()) {
 229                 adm5120_prom_type = ADM5120_PROM_MYLOADER;
 230                 mips_machtype = detect_machtype_myloader();
 231                 return;
 232         }
 233
 234         if (routerboot_present()) {
 235                 adm5120_prom_type = ADM5120_PROM_ROUTERBOOT;
 236                 mips_machtype = detect_machtype_routerboot();
 237                 return;
 238         }
 239
 240         if (generic_prom_present()) {
 241                 adm5120_prom_type = ADM5120_PROM_GENERIC;
 242                 mips_machtype = detect_machtype_generic();
 243                 return;
 244         }
 245
 246         mips_machtype = MACH_ADM5120_GENERIC;
 247 }
 248
 249 /* TODO: this is an ugly hack for RouterBOARDS */
 250 extern char _image_cmdline;
 251 static void __init prom_init_cmdline(void)
 252 {
 253         char *cmd;
 254
 255         /* init command line, register a default kernel command line */
 256         cmd = &_image_cmdline + 8;
 257         if (strlen(cmd) > 0)
 258                 strcpy(arcs_cmdline, cmd);
 259         else
 260                 strcpy(arcs_cmdline, CONFIG_CMDLINE);
 261
 262 }
 263
 264 #define UART_READ(r) \
 265         __raw_readl((void __iomem *)(KSEG1ADDR(ADM5120_UART0_BASE)+(r)))
 266 #define UART_WRITE(r, v) \
 267         __raw_writel((v), (void __iomem *)(KSEG1ADDR(ADM5120_UART0_BASE)+(r)))
 268
 269 void __init prom_putchar(char ch)
 270 {
 271         while ((UART_READ(UART_REG_FLAG) & UART_FLAG_TXFE) == 0);
 272         UART_WRITE(UART_REG_DATA, ch);
 273         while ((UART_READ(UART_REG_FLAG) & UART_FLAG_TXFE) == 0);
 274 }
 275
 276 void __init prom_init(void)
 277 {
 278         mips_machgroup = MACH_GROUP_ADM5120;
 279         prom_detect_machtype();
 280
 281         prom_init_cmdline();
 282 }
 283
 284 void __init prom_free_prom_memory(void)
 285 {
 286         /* We do not have to prom memory to free */
 287 }