arch/ppc-chrp/efika/ata/lowlevel_mpc5200b.c

   1 /*
   2     Copyright © 1995-2014, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define DEBUG 0
   7
   8 #include <aros/debug.h>
   9 #include <exec/types.h>
  10 #include <asm/io.h>
  11 #include <asm/mpc5200b.h>
  12 #include <exec/exec.h>
  13 #include <exec/tasks.h>
  14 #include <exec/memory.h>
  15 #include <exec/nodes.h>
  16 #include <utility/utility.h>
  17 #include <proto/exec.h>
  18 #include <proto/timer.h>
  19 #include <proto/oop.h>
  20 #include <proto/openfirmware.h>
  21
  22 #include "ata.h"
  23
  24 extern uint8_t *sram;
  25 extern bestcomm_t *bestcomm;
  26 extern uint32_t bestcomm_taskid;
  27
  28 extern void bestcomm_init();
  29
  30 UBYTE *mbar;
  31 uint32_t bus_frequency;
  32
  33 volatile ata_5k2_t *ata_5k2;
  34
  35 static void ata_out(UBYTE val, UWORD offset, IPTR port, APTR data)
  36 {
  37         while(inl(&ata_5k2->ata_status) & 0x80000000) asm volatile("nop");
  38
  39         if (port +offset * 4 == 0x3a7c)
  40         {
  41                 ULONG val = inl(&mbar[port + offset * 4]);
  42                 outb(0, &mbar[port + 1 + offset * 4]);
  43         }
  44
  45         outl((ULONG)val << 24, &mbar[port + offset * 4]);
  46 }
  47
  48 static UBYTE ata_in(UWORD offset, IPTR port, APTR data)
  49 {
  50         while(inl(&ata_5k2->ata_status) & 0x80000000) asm volatile("nop");
  51
  52         if (port +offset * 4 == 0x3a7c)
  53         {
  54                 ULONG val = inl(&mbar[port + offset * 4]);
  55                 outb(0, &mbar[port + 1 + offset * 4]);
  56         }
  57
  58         return inl(&mbar[port + offset * 4]) >> 24;
  59 }
  60
  61 static void ata_outl(ULONG val, UWORD offset, IPTR port, APTR data)
  62 {
  63         while(inl(&ata_5k2->ata_status) & 0x80000000) asm volatile("nop");
  64
  65         outl_le(val, &mbar[port + offset * 4]);
  66 }
  67
  68 static VOID ata_insw(APTR address, UWORD port, ULONG count, APTR data)
  69 {
  70     UWORD *addr = address;
  71     volatile UWORD *p = (UWORD*)(&mbar[port]);
  72
  73     D(bug("[ATA 5k2] insw(%08x, %04x)\n", address, count));
  74
  75     count &= ~1;
  76
  77         while(inl(&ata_5k2->ata_status) & 0x80000000) asm volatile("nop");
  78
  79         asm volatile("sync");
  80         while(count)
  81     {
  82 //      *addr++ = inw(p);
  83                 *addr++ = *p;
  84         count -= 2;
  85     }
  86         asm volatile("sync");
  87 }
  88
  89 static VOID ata_outsw(APTR address, UWORD port, ULONG count, APTR data)
  90 {
  91     UWORD *addr = address;
  92     volatile UWORD *p = (UWORD*)(&mbar[port]);
  93
  94     D(bug("[ATA 5k2] outsw(%08x, %04x)\n", address, count));
  95
  96     count &= ~1;
  97
  98         while(inl(&ata_5k2->ata_status) & 0x80000000) asm volatile("nop");
  99
 100         asm volatile("sync");
 101         while(count)
 102     {
 103 //      outw(*addr++, p);
 104                 *p = *addr++;
 105         count -= 2;
 106     }
 107         asm volatile("sync");
 108 }
 109
 110 static void ata_400ns()
 111 {
 112         register ULONG tick_old, tick;
 113
 114         asm volatile("mftbl %0":"=r"(tick_old));
 115
 116         do {
 117                 asm volatile("mftbl %0":"=r"(tick));
 118         } while(tick < (tick_old + 15));
 119 }
 120
 121 static AROS_INTH1(ata_Interrupt, void *, data)
 122 {
 123     AROS_INTFUNC_INIT
 124     /*
 125      * Our interrupt handler should call this function.
 126      * It's our problem how to store bus pointer. Here we use h_Data for it.
 127      */
 128     ata_HandleIRQ(data);
 129
 130     return FALSE;
 131
 132     AROS_INTFUNC_EXIT
 133 }
 134
 135 /* Actually a quick hack. Proper implementation really needs HIDDizing this code. */
 136 static BOOL CreateInterrupt(struct ata_Bus *bus)
 137 {
 138     struct Interrupt *IntHandler = &bus->ab_IntHandler;
 139
 140     /*
 141         Prepare nice interrupt for our bus. Even if interrupt sharing is enabled,
 142         it should work quite well
 143     */
 144     IntHandler->is_Node.ln_Pri = 10;
 145     IntHandler->is_Node.ln_Name = bus->ab_Task->tc_Node.ln_Name;
 146     IntHandler->is_Code = (VOID_FUNC)ata_Interrupt;
 147     IntHandler->is_Data = bus;
 148
 149     AddIntServer(INTB_KERNEL + bus->ab_IRQ, IntHandler);
 150
 151     return TRUE;
 152 }
 153
 154 static const struct ata_BusDriver mpc_driver =
 155 {
 156     ata_out,
 157     ata_in,
 158     ata_outl,
 159     ata_insw,
 160     ata_outsw,
 161     ata_insw,   /* These are intentionally the same as 16-bit routines */
 162     ata_outsw,
 163     CreateInterrupt
 164 };
 165
 166 static int ata_mpc_init(struct ataBase *LIBBASE)
 167 {
 168     int i;
 169     /*
 170      * I've decided to use memory pools again. Alloc everything needed from
 171      * a pool, so that we avoid memory fragmentation.
 172      */
 173     LIBBASE->ata_MemPool = CreatePool(MEMF_CLEAR | MEMF_PUBLIC | MEMF_SEM_PROTECTED , 8192, 4096);
 174     if (LIBBASE->ata_MemPool == NULL)
 175         return FALSE;
 176
 177     void *OpenFirmwareBase = OpenResource("openfirmware.resource");
 178     void *key = OF_OpenKey("/builtin");
 179     if (key)
 180     {
 181         void *prop = OF_FindProperty(key, "reg");
 182         if (prop)
 183         {
 184                 intptr_t *m_ = OF_GetPropValue(prop);
 185                         mbar = (UBYTE *)*m_;
 186                         ata_5k2 = (ata_5k2_t *)(*m_ + 0x3a00);
 187
 188                 D(bug("[ATA] MBAR located at %08x\n", mbar));
 189         }
 190
 191         /* Get the bus frequency for Efika */
 192         prop = OF_FindProperty(key, "bus-frequency");
 193         if (prop)
 194         {
 195                 bus_frequency = *(uint32_t *)OF_GetPropValue(prop);
 196                 D(bug("[ATA] bus frequency: %d\n", bus_frequency));
 197         }
 198     }
 199
 200     key = OF_OpenKey("/builtin/ata");
 201     if (key)
 202     {
 203         void *prop = OF_FindProperty(key, "reg");
 204                 if (prop)
 205                 {
 206                         ata_5k2 = *(ata_5k2_t **)OF_GetPropValue(prop);
 207
 208                         D(bug("[ATA] ATA registers at %08x\n", ata_5k2));
 209                 }
 210     }
 211
 212     key = OF_OpenKey("/builtin/ata/bestcomm-task");
 213     if (key)
 214     {
 215         void *prop = OF_FindProperty(key, "taskid");
 216                 if (prop)
 217                 {
 218                         bestcomm_taskid = *(uint32_t *)OF_GetPropValue(prop);
 219
 220                         D(bug("[ATA] ATA uses bestcomm task %d\n", bestcomm_taskid));
 221                 }
 222     }
 223
 224     key = OF_OpenKey("/builtin/sram");
 225     if (key)
 226     {
 227         void *prop = OF_FindProperty(key, "reg");
 228         if (prop)
 229         {
 230                 sram = *(void **)OF_GetPropValue(prop);
 231         }
 232         D(bug("[ATA] SRAM at %08x\n", sram));
 233     }
 234
 235     key = OF_OpenKey("/builtin/bestcomm");
 236     if (key)
 237     {
 238         void *prop = OF_FindProperty(key, "reg");
 239         if (prop)
 240         {
 241                 bestcomm = *(void **)OF_GetPropValue(prop);
 242         }
 243         D(bug("[ATA] bestcomm at %08x\n", bestcomm));
 244     }
 245
 246     D(bug("[ATA] ata_config=%08x\n", inl(&ata_5k2->ata_config)));
 247     D(bug("[ATA] ata_status=%08x\n", inl(&ata_5k2->ata_status)));
 248     D(bug("[ATA] ata_pio1=%08x\n", inl(&ata_5k2->ata_pio1)));
 249     D(bug("[ATA] ata_pio2=%08x\n", inl(&ata_5k2->ata_pio2)));
 250
 251     /* Disable XLB pipelining... */
 252     D(bug("[ATA] xlb_config=%08x\n", inl(mbar+0x1f40)));
 253     outl(inl(mbar + 0x1f40) | 0x80000000, mbar + 0x1f40);
 254
 255     outl(0, &ata_5k2->ata_invalid);
 256     outl(0xc3000000, &ata_5k2->ata_config);
 257
 258     for (i=0; i < 100 / 4; i++)
 259         ata_400ns();
 260
 261         /* Hacky timing pokes */
 262     outl(0x03000000, &ata_5k2->ata_config);
 263     outl(132 << 16, &ata_5k2->ata_invalid);
 264
 265     /* PIO2 timing table. Replace it by correct calculations soon !!! */
 266
 267 #warning TODO: Set the timings in right way!
 268
 269     outl(0x21270e00, &ata_5k2->ata_pio1);
 270     outl(0x03050600, &ata_5k2->ata_pio2);
 271
 272     bestcomm_init();
 273
 274     /*
 275      * FIXME: This code uses static data variables.
 276      * Move them into DriverData instead.
 277      */
 278     ata_RegisterBus(0x3a60, 0x3a5c - 8, MPC5200B_ATA, 0, FALSE, &mpc_driver, NULL, LIBBASE);
 279
 280     return TRUE;
 281 }
 282
 283 ADD2INITLIB(ata_mpc_init, 20)