board/mvblue/mvblue.c

   1 /*
   2  * GNU General Public License for more details.
   3  *
   4  * MATRIX Vision GmbH / June 2002-Nov 2003
   5  * Andre Schwarz
   6  */
   7
   8 #include <common.h>
   9 #include <mpc824x.h>
  10 #include <asm/io.h>
  11 #include <ns16550.h>
  12
  13 #ifdef CONFIG_PCI
  14 #include <pci.h>
  15 #endif
  16
  17 u32 get_BoardType (void);
  18
  19 #define PCI_CONFIG(b,d,f,r)    cpu_to_le32(0x80000000 | ((b&0xff)<<16) \
  20                                                       | ((d&0x1f)<<11) \
  21                                                       | ((f&0x7)<<7)   \
  22                                                       | (r&0xfc) )
  23
  24 int mv_pci_read (int bus, int dev, int func, int reg)
  25 {
  26         *(u32 *) (0xfec00cf8) = PCI_CONFIG (bus, dev, func, reg);
  27         asm ("sync");
  28         return cpu_to_le32 (*(u32 *) (0xfee00cfc));
  29 }
  30
  31 u32 get_BoardType ()
  32 {
  33         return (mv_pci_read (0, 0xe, 0, 0) == 0x06801095 ? 0 : 1);
  34 }
  35
  36 void init_2nd_DUART (void)
  37 {
  38         NS16550_t console = (NS16550_t) CFG_NS16550_COM2;
  39         int clock_divisor = CFG_NS16550_CLK / 16 / CONFIG_BAUDRATE;
  40
  41         *(u8 *) (0xfc004511) = 0x1;
  42         NS16550_init (console, clock_divisor);
  43 }
  44 void hw_watchdog_reset (void)
  45 {
  46         if (get_BoardType () == 0) {
  47                 *(u32 *) (0xff000005) = 0;
  48                 asm ("sync");
  49         }
  50 }
  51 int checkboard (void)
  52 {
  53         DECLARE_GLOBAL_DATA_PTR;
  54         ulong busfreq = get_bus_freq (0);
  55         char buf[32];
  56         u32 BoardType = get_BoardType ();
  57         char *BoardName[2] = { "mvBlueBOX", "mvBlueLYNX" };
  58         char *p;
  59         bd_t *bd = gd->bd;
  60
  61         hw_watchdog_reset ();
  62
  63         printf ("U-Boot (%s) running on mvBLUE device.\n", MV_VERSION);
  64         printf ("       Found %s running at %s MHz memory clock.\n",
  65                 BoardName[BoardType], strmhz (buf, busfreq));
  66
  67         init_2nd_DUART ();
  68
  69         if ((p = getenv ("console_nr")) != NULL) {
  70                 unsigned long con_nr = simple_strtoul (p, NULL, 10) & 3;
  71
  72                 bd->bi_baudrate &= ~3;
  73                 bd->bi_baudrate |= con_nr & 3;
  74         }
  75         return 0;
  76 }
  77
  78 long int initdram (int board_type)
  79 {
  80         int i, cnt;
  81         volatile uchar *base = CFG_SDRAM_BASE;
  82         volatile ulong *addr;
  83         ulong save[32];
  84         ulong val, ret = 0;
  85
  86         for (i = 0, cnt = (CFG_MAX_RAM_SIZE / sizeof (long)) >> 1; cnt > 0;
  87              cnt >>= 1) {
  88                 addr = (volatile ulong *) base + cnt;
  89                 save[i++] = *addr;
  90                 *addr = ~cnt;
  91         }
  92
  93         addr = (volatile ulong *) base;
  94         save[i] = *addr;
  95         *addr = 0;
  96
  97         if (*addr != 0) {
  98                 *addr = save[i];
  99                 goto Done;
 100         }
 101
 102         for (cnt = 1; cnt <= CFG_MAX_RAM_SIZE / sizeof (long); cnt <<= 1) {
 103                 addr = (volatile ulong *) base + cnt;
 104                 val = *addr;
 105                 *addr = save[--i];
 106                 if (val != ~cnt) {
 107                         ulong new_bank0_end = cnt * sizeof (long) - 1;
 108                         ulong mear1 = mpc824x_mpc107_getreg (MEAR1);
 109                         ulong emear1 = mpc824x_mpc107_getreg (EMEAR1);
 110
 111                         mear1 = (mear1 & 0xFFFFFF00) |
 112                                 ((new_bank0_end & MICR_ADDR_MASK) >>
 113                                  MICR_ADDR_SHIFT);
 114                         emear1 = (emear1 & 0xFFFFFF00) |
 115                                 ((new_bank0_end & MICR_ADDR_MASK) >>
 116                                  MICR_EADDR_SHIFT);
 117                         mpc824x_mpc107_setreg (MEAR1, mear1);
 118                         mpc824x_mpc107_setreg (EMEAR1, emear1);
 119                         ret = cnt * sizeof (long);
 120                         goto Done;
 121                 }
 122         }
 123
 124         ret = CFG_MAX_RAM_SIZE;
 125       Done:
 126         return ret;
 127 }
 128
 129 /* ------------------------------------------------------------------------- */
 130 u8 *dhcp_vendorex_prep (u8 * e)
 131 {
 132         char *ptr;
 133
 134         /* DHCP vendor-class-identifier = 60 */
 135         if ((ptr = getenv ("dhcp_vendor-class-identifier"))) {
 136                 *e++ = 60;
 137                 *e++ = strlen (ptr);
 138                 while (*ptr)
 139                         *e++ = *ptr++;
 140         }
 141         /* my DHCP_CLIENT_IDENTIFIER = 61 */
 142         if ((ptr = getenv ("dhcp_client_id"))) {
 143                 *e++ = 61;
 144                 *e++ = strlen (ptr);
 145                 while (*ptr)
 146                         *e++ = *ptr++;
 147         }
 148         return e;
 149 }
 150
 151 u8 *dhcp_vendorex_proc (u8 * popt)
 152 {
 153         return NULL;
 154 }
 155
 156 /* ------------------------------------------------------------------------- */
 157
 158 /*
 159  * Initialize PCI Devices
 160  */
 161 #ifdef CONFIG_PCI
 162 void pci_mvblue_clear_base (struct pci_controller *hose, pci_dev_t dev)
 163 {
 164         u32 cnt;
 165
 166         printf ("clear base @ dev/func 0x%02x/0x%02x ... ", PCI_DEV (dev),
 167                 PCI_FUNC (dev));
 168         for (cnt = 0; cnt < 6; cnt++)
 169                 pci_hose_write_config_dword (hose, dev, 0x10 + (4 * cnt),
 170                                              0x0);
 171         printf ("done\n");
 172 }
 173
 174 void duart_setup (u32 base, u16 divisor)
 175 {
 176         printf ("duart setup ...");
 177         out_8 ((u8 *) (CFG_ISA_IO + base + 3), 0x80);
 178         out_8 ((u8 *) (CFG_ISA_IO + base + 0), divisor & 0xff);
 179         out_8 ((u8 *) (CFG_ISA_IO + base + 1), divisor >> 8);
 180         out_8 ((u8 *) (CFG_ISA_IO + base + 3), 0x03);
 181         out_8 ((u8 *) (CFG_ISA_IO + base + 4), 0x03);
 182         out_8 ((u8 *) (CFG_ISA_IO + base + 2), 0x07);
 183         printf ("done\n");
 184 }
 185
 186 void pci_mvblue_fixup_irq_behind_bridge (struct pci_controller *hose,
 187                                          pci_dev_t bridge, unsigned char irq)
 188 {
 189         pci_dev_t d;
 190         unsigned char bus;
 191         unsigned short vendor, class;
 192
 193         pci_hose_read_config_byte (hose, bridge, PCI_SECONDARY_BUS, &bus);
 194         for (d = PCI_BDF (bus, 0, 0);
 195              d < PCI_BDF (bus, PCI_MAX_PCI_DEVICES - 1,
 196                           PCI_MAX_PCI_FUNCTIONS - 1);
 197              d += PCI_BDF (0, 0, 1)) {
 198                 pci_hose_read_config_word (hose, d, PCI_VENDOR_ID, &vendor);
 199                 if (vendor != 0xffff && vendor != 0x0000) {
 200                         pci_hose_read_config_word (hose, d, PCI_CLASS_DEVICE,
 201                                                    &class);
 202                         if (class == PCI_CLASS_BRIDGE_PCI)
 203                                 pci_mvblue_fixup_irq_behind_bridge (hose, d,
 204                                                                     irq);
 205                         else
 206                                 pci_hose_write_config_byte (hose, d,
 207                                                             PCI_INTERRUPT_LINE,
 208                                                             irq);
 209                 }
 210         }
 211 }
 212
 213 #define MV_MAX_PCI_BUSSES       3
 214 #define SLOT0_IRQ       3
 215 #define SLOT1_IRQ       4
 216 void pci_mvblue_fixup_irq (struct pci_controller *hose, pci_dev_t dev)
 217 {
 218         unsigned char line = 0xff;
 219         unsigned short class;
 220
 221         if (PCI_BUS (dev) == 0) {
 222                 switch (PCI_DEV (dev)) {
 223                 case 0xd:
 224                         if (get_BoardType () == 0) {
 225                                 line = 1;
 226                         } else
 227                                 /* mvBL */
 228                                 line = 2;
 229                         break;
 230                 case 0xe:
 231                         /* mvBB: IDE */
 232                         line = 2;
 233                         pci_hose_write_config_byte (hose, dev, 0x8a, 0x20);
 234                         break;
 235                 case 0xf:
 236                         /* mvBB: Slot0 (Grabber) */
 237                         pci_hose_read_config_word (hose, dev,
 238                                                    PCI_CLASS_DEVICE, &class);
 239                         if (class == PCI_CLASS_BRIDGE_PCI) {
 240                                 pci_mvblue_fixup_irq_behind_bridge (hose, dev,
 241                                                                     SLOT0_IRQ);
 242                                 line = 0xff;
 243                         } else
 244                                 line = SLOT0_IRQ;
 245                         break;
 246                 case 0x10:
 247                         /* mvBB: Slot1 */
 248                         pci_hose_read_config_word (hose, dev,
 249                                                    PCI_CLASS_DEVICE, &class);
 250                         if (class == PCI_CLASS_BRIDGE_PCI) {
 251                                 pci_mvblue_fixup_irq_behind_bridge (hose, dev,
 252                                                                     SLOT1_IRQ);
 253                                 line = 0xff;
 254                         } else
 255                                 line = SLOT1_IRQ;
 256                         break;
 257                 default:
 258                         printf ("***pci_scan: illegal dev = 0x%08x\n",
 259                                 PCI_DEV (dev));
 260                         line = 0xff;
 261                         break;
 262                 }
 263                 pci_hose_write_config_byte (hose, dev, PCI_INTERRUPT_LINE,
 264                                             line);
 265         }
 266 }
 267
 268 struct pci_controller hose = {
 269         fixup_irq:pci_mvblue_fixup_irq
 270 };
 271
 272 void pci_init_board (void)
 273 {
 274         pci_mpc824x_init (&hose);
 275 }
 276 #endif