release/src-rt-6.x.4708/cfe/cfe/arch/mips/board/carmel/src/dev_ide.c

   1 /*  *********************************************************************
   2     *  Broadcom Common Firmware Environment (CFE)
   3     *
   4     *  IDE disk driver                          File: dev_ide.c
   5     *
   6     *  This is a simple driver for IDE hard disks.  The disks
   7     *  are expected to be connected to the generic bus (this
   8     *  driver doesn't support PCI).
   9     *
  10     *  Author:  Mitch Lichtenberg (mpl@broadcom.com)
  11     *
  12     *********************************************************************
  13     *
  14     *  Copyright 2000,2001,2002,2003
  15     *  Broadcom Corporation. All rights reserved.
  16     *
  17     *  This software is furnished under license and may be used and
  18     *  copied only in accordance with the following terms and
  19     *  conditions.  Subject to these conditions, you may download,
  20     *  copy, install, use, modify and distribute modified or unmodified
  21     *  copies of this software in source and/or binary form.  No title
  22     *  or ownership is transferred hereby.
  23     *
  24     *  1) Any source code used, modified or distributed must reproduce
  25     *     and retain this copyright notice and list of conditions
  26     *     as they appear in the source file.
  27     *
  28     *  2) No right is granted to use any trade name, trademark, or
  29     *     logo of Broadcom Corporation.  The "Broadcom Corporation"
  30     *     name may not be used to endorse or promote products derived
  31     *     from this software without the prior written permission of
  32     *     Broadcom Corporation.
  33     *
  34     *  3) THIS SOFTWARE IS PROVIDED "AS-IS" AND ANY EXPRESS OR
  35     *     IMPLIED WARRANTIES, INCLUDING BUT NOT LIMITED TO, ANY IMPLIED
  36     *     WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  37     *     PURPOSE, OR NON-INFRINGEMENT ARE DISCLAIMED. IN NO EVENT
  38     *     SHALL BROADCOM BE LIABLE FOR ANY DAMAGES WHATSOEVER, AND IN
  39     *     PARTICULAR, BROADCOM SHALL NOT BE LIABLE FOR DIRECT, INDIRECT,
  40     *     INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  41     *     (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  42     *     GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  43     *     BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  44     *     OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  45     *     TORT (INCLUDING NEGLIGENCE OR OTHERWISE), EVEN IF ADVISED OF
  46     *     THE POSSIBILITY OF SUCH DAMAGE.
  47     ********************************************************************* */
  48
  49
  50 #include "sbmips.h"
  51 #include "lib_types.h"
  52 #include "lib_malloc.h"
  53 #include "lib_printf.h"
  54 #include "lib_string.h"
  55 #include "cfe_timer.h"
  56 #include "cfe_iocb.h"
  57 #include "cfe_device.h"
  58 #include "cfe_ioctl.h"
  59
  60 #include "dev_ide_common.h"
  61
  62 #include "dev_ide.h"
  63
  64 #include "carmel.h"
  65
  66 /*  *********************************************************************
  67     *  Macros
  68     ********************************************************************* */
  69
  70 /*  *********************************************************************
  71     *  Forward declarations
  72     ********************************************************************* */
  73
  74 static void idedrv_probe(cfe_driver_t *drv,
  75                               unsigned long probe_a, unsigned long probe_b,
  76                               void *probe_ptr);
  77
  78 /*  *********************************************************************
  79     *  Device Dispatch
  80     ********************************************************************* */
  81
  82 static cfe_devdisp_t idedrv_dispatch = {
  83     NULL,
  84     NULL,
  85     NULL,
  86     NULL,
  87     NULL,
  88     NULL,
  89     NULL,
  90     NULL
  91 };
  92
  93 const cfe_driver_t idedrv = {
  94     "IDE disk",
  95     "ide",
  96     CFE_DEV_DISK,
  97     &idedrv_dispatch,
  98     idedrv_probe
  99 };
 100
 101 const cfe_driver_t atapidrv = {
 102     "ATAPI device",
 103     "atapi",
 104     CFE_DEV_DISK,
 105     &idedrv_dispatch,
 106     idedrv_probe
 107 };
 108
 109
 110 #define IDE_REG_ADDR_SHIFT      5
 111
 112
 113 /*  *********************************************************************
 114     *  Port I/O routines
 115     *
 116     *  These routines are called back from the common code to do
 117     *  I/O cycles to the IDE disk.  We provide routines for
 118     *  reading and writing bytes, words, and strings of words.
 119     ********************************************************************* */
 120
 121 static uint8_t idedrv_inb(idecommon_dispatch_t *disp,uint32_t reg)
 122 {
 123     reg <<= IDE_REG_ADDR_SHIFT;
 124
 125     return  (*((volatile uint8_t *) PHYS_TO_K1(reg+disp->baseaddr)));
 126 }
 127
 128 static uint16_t idedrv_inw(idecommon_dispatch_t *disp,uint32_t reg)
 129 {
 130     reg <<= IDE_REG_ADDR_SHIFT;
 131
 132     return *((volatile uint16_t *) PHYS_TO_K1((reg+disp->baseaddr)));
 133 }
 134
 135 static void idedrv_ins(idecommon_dispatch_t *disp,uint32_t reg,uint8_t *buf,int len)
 136 {
 137     uint16_t data;
 138     uint16_t *buf16;
 139
 140     reg <<= IDE_REG_ADDR_SHIFT;
 141
 142     /* Do 16-bit reads/writes so that the byteswaps will work out right */
 143
 144     buf16 = (uint16_t *) buf;
 145
 146     while (len > 0) {
 147         data = *((volatile uint16_t *) PHYS_TO_K1(reg+disp->baseaddr));
 148         *buf16++ = data;
 149         len--;
 150         len--;
 151         }
 152
 153 }
 154
 155 static void idedrv_outb(idecommon_dispatch_t *disp,uint32_t reg,uint8_t val)
 156 {
 157     reg <<= IDE_REG_ADDR_SHIFT;
 158
 159     *((volatile uint8_t *) PHYS_TO_K1(reg+disp->baseaddr)) = (uint8_t) (val);
 160 }
 161
 162 static void idedrv_outw(idecommon_dispatch_t *disp,uint32_t reg,uint16_t val)
 163 {
 164     reg <<= IDE_REG_ADDR_SHIFT;
 165
 166     *((volatile uint16_t *) PHYS_TO_K1(reg+disp->baseaddr)) = val;
 167 }
 168
 169 static void idedrv_outs(idecommon_dispatch_t *disp,uint32_t reg,uint8_t *buf,int len)
 170 {
 171     uint16_t data;
 172     uint16_t *buf16;
 173
 174     reg <<= IDE_REG_ADDR_SHIFT;
 175
 176     buf16 = (uint16_t *) buf;
 177
 178     while (len > 0) {
 179         data = *buf16++;
 180         *((volatile uint16_t *) PHYS_TO_K1(reg+disp->baseaddr)) = data;
 181         len--;
 182         len--;
 183         }
 184 }
 185
 186
 187
 188 /*  *********************************************************************
 189     *  idedrv_probe(drv,probe_a,probe_b,probe_ptr)
 190     *
 191     *  Our probe routine.  Attach an IDE device to the firmware.
 192     *
 193     *  Input parameters:
 194     *      drv - driver structure
 195     *      probe_a - physical address of IDE registers
 196     *      probe_b - unit number
 197     *      probe_ptr - not used
 198     *
 199     *  Return value:
 200     *      nothing
 201     ********************************************************************* */
 202
 203 static void idedrv_probe(cfe_driver_t *drv,
 204                               unsigned long probe_a, unsigned long probe_b,
 205                               void *probe_ptr)
 206 {
 207     idecommon_t *softc = NULL;
 208     idecommon_dispatch_t *disp = NULL;
 209     char descr[80];
 210     char unitstr[50];
 211     int res;
 212     cfe_driver_t *realdrv;
 213     int unit;
 214
 215     /*
 216      * probe_a is the IDE base address
 217      * probe_b is a bitmask of unit numbers to check
 218      * probe_ptr is unused.
 219      */
 220
 221     for (unit = 0; unit < 2; unit++) {
 222
 223         if (IDE_PROBE_GET_TYPE(probe_b,unit) == IDE_DEVTYPE_NOPROBE) {
 224             continue;
 225             }
 226
 227         softc = (idecommon_t *) KMALLOC(sizeof(idecommon_t),0);
 228         disp = (idecommon_dispatch_t *) KMALLOC(sizeof(idecommon_dispatch_t),0);
 229
 230         if (!softc || !disp) {
 231             if (softc) KFREE(softc);
 232             if (disp) KFREE(disp);
 233             return;             /* out of memory, stop here */
 234             }
 235
 236         softc->idecommon_addr = probe_a;
 237         softc->idecommon_unit = unit;
 238         softc->idecommon_deferprobe = 0;
 239
 240         disp->ref = softc;
 241         disp->baseaddr = softc->idecommon_addr;
 242         softc->idecommon_dispatch = disp;
 243
 244         disp->outb = idedrv_outb;
 245         disp->outw = idedrv_outw;
 246         disp->outs = idedrv_outs;
 247
 248         disp->inb = idedrv_inb;
 249         disp->inw = idedrv_inw;
 250         disp->ins = idedrv_ins;
 251
 252         /*
 253          * If we're autoprobing, do it now.  Loop back if we have
 254          * trouble finding the device.
 255          *
 256          * If not autoprobing, assume the device is there and set the
 257          * common routines to double check later.
 258          */
 259
 260         if (IDE_PROBE_GET_TYPE(probe_b,unit) == IDE_DEVTYPE_AUTO) {
 261             res = idecommon_devprobe(softc,1);
 262             if (res < 0) {
 263                 KFREE(softc);
 264                 KFREE(disp);
 265                 continue;
 266                 }
 267             }
 268         else {
 269             idecommon_init(softc,IDE_PROBE_GET_TYPE(probe_b,unit));
 270             softc->idecommon_deferprobe = 1;
 271             }
 272
 273
 274         xsprintf(descr,"%s unit %d at %08X",drv->drv_description,unit,probe_a);
 275         xsprintf(unitstr,"%d",unit);
 276
 277         realdrv = (cfe_driver_t *) (softc->idecommon_atapi ? &atapidrv : &idedrv);
 278         idecommon_attach(&idedrv_dispatch);
 279
 280         cfe_attach(realdrv,softc,unitstr,descr);
 281         }
 282 }