release/src-rt-6.x.4708/cfe/cfe/arch/mips/board/p6064/src/dev_ide_piix.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 /*  *********************************************************************
  65     *  Macros
  66     ********************************************************************* */
  67
  68 /* #define _BYTESWAP_ */        /* don't byteswap these disks */
  69
  70 /*  *********************************************************************
  71     *  Forward declarations
  72     ********************************************************************* */
  73
  74 extern void _wbflush(void);
  75
  76 static void idedrv_probe(cfe_driver_t *drv,
  77                               unsigned long probe_a, unsigned long probe_b,
  78                               void *probe_ptr);
  79
  80 /*  *********************************************************************
  81     *  Device Dispatch
  82     ********************************************************************* */
  83
  84 const static cfe_devdisp_t idedrv_dispatch = {
  85     idecommon_open,
  86     idecommon_read,
  87     idecommon_inpstat,
  88     idecommon_write,
  89     idecommon_ioctl,
  90     idecommon_close,
  91     NULL,
  92     NULL
  93 };
  94
  95 const cfe_driver_t piixidedrv = {
  96     "IDE disk (PIIX)",
  97     "ide",
  98     CFE_DEV_DISK,
  99     &idedrv_dispatch,
 100     idedrv_probe
 101 };
 102
 103 const cfe_driver_t piixatapidrv = {
 104     "ATAPI device (PIIX)",
 105     "atapi",
 106     CFE_DEV_DISK,
 107     &idedrv_dispatch,
 108     idedrv_probe
 109 };
 110
 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     return *((volatile uint8_t *) PHYS_TO_K1(reg+disp->baseaddr));
 124 }
 125
 126 static uint16_t idedrv_inw(idecommon_dispatch_t *disp,uint32_t reg)
 127 {
 128     return *((volatile uint16_t *) PHYS_TO_K1((reg+disp->baseaddr)));
 129 }
 130
 131 static void idedrv_ins(idecommon_dispatch_t *disp,uint32_t reg,uint8_t *buf,int len)
 132 {
 133     uint16_t data;
 134
 135     while (len > 0) {
 136         data = *((volatile uint16_t *) PHYS_TO_K1(reg+disp->baseaddr));
 137
 138 #ifdef _BYTESWAP_
 139         *buf++ = (data >> 8) & 0xFF;
 140         *buf++ = (data & 0xFF);
 141 #else
 142         *buf++ = (data & 0xFF);
 143         *buf++ = (data >> 8) & 0xFF;
 144 #endif
 145         len--;
 146         len--;
 147         }
 148
 149 }
 150
 151 static void idedrv_outb(idecommon_dispatch_t *disp,uint32_t reg,uint8_t val)
 152 {
 153     *((volatile uint8_t *) PHYS_TO_K1(reg+disp->baseaddr)) = val;
 154     _wbflush();
 155 }
 156
 157 static void idedrv_outw(idecommon_dispatch_t *disp,uint32_t reg,uint16_t val)
 158 {
 159     *((volatile uint16_t *) PHYS_TO_K1(reg+disp->baseaddr)) = val;
 160     _wbflush();
 161 }
 162
 163 static void idedrv_outs(idecommon_dispatch_t *disp,uint32_t reg,uint8_t *buf,int len)
 164 {
 165     uint16_t data;
 166
 167     while (len > 0) {
 168 #ifdef _BYTESWAP_
 169         data = (uint16_t) buf[1] + ((uint16_t) buf[0] << 8);
 170 #else
 171         data = (uint16_t) buf[0] + ((uint16_t) buf[1] << 8);
 172 #endif
 173
 174         *((volatile uint16_t *) PHYS_TO_K1(reg+disp->baseaddr)) = data;
 175         _wbflush();
 176
 177         buf++;
 178         buf++;
 179         len--;
 180         len--;
 181         }
 182 }
 183
 184
 185
 186 /*  *********************************************************************
 187     *  idedrv_probe(drv,probe_a,probe_b,probe_ptr)
 188     *
 189     *  Our probe routine.  Attach an IDE device to the firmware.
 190     *
 191     *  Input parameters:
 192     *      drv - driver structure
 193     *      probe_a - physical address of IDE registers
 194     *      probe_b - unit number
 195     *      probe_ptr - not used
 196     *
 197     *  Return value:
 198     *      nothing
 199     ********************************************************************* */
 200
 201 static void idedrv_probe(cfe_driver_t *drv,
 202                               unsigned long probe_a, unsigned long probe_b,
 203                               void *probe_ptr)
 204 {
 205     idecommon_t *softc = NULL;
 206     idecommon_dispatch_t *disp = NULL;
 207     char descr[80];
 208     char unitstr[50];
 209     int res;
 210     cfe_driver_t *realdrv;
 211     int unit;
 212
 213     /*
 214      * probe_a is the IDE base address
 215      * probe_b is a bitmask of unit numbers to check
 216      * probe_ptr is unused.
 217      */
 218
 219     for (unit = 0; unit < 2; unit++) {
 220
 221         if (IDE_PROBE_GET_TYPE(probe_b,unit) == IDE_DEVTYPE_NOPROBE) {
 222             continue;
 223             }
 224
 225         softc = (idecommon_t *) KMALLOC(sizeof(idecommon_t),0);
 226         disp = (idecommon_dispatch_t *) KMALLOC(sizeof(idecommon_dispatch_t),0);
 227
 228         if (!softc || !disp) {
 229             if (softc) KFREE(softc);
 230             if (disp) KFREE(disp);
 231             return;             /* out of memory, stop here */
 232             }
 233
 234         softc->idecommon_addr = probe_a;
 235         softc->idecommon_unit = unit;
 236         softc->idecommon_deferprobe = 0;
 237
 238         disp->ref = softc;
 239         disp->baseaddr = softc->idecommon_addr;
 240         softc->idecommon_dispatch = disp;
 241
 242         disp->outb = idedrv_outb;
 243         disp->outw = idedrv_outw;
 244         disp->outs = idedrv_outs;
 245
 246         disp->inb = idedrv_inb;
 247         disp->inw = idedrv_inw;
 248         disp->ins = idedrv_ins;
 249
 250         /*
 251          * If we're autoprobing, do it now.  Loop back if we have
 252          * trouble finding the device.
 253          *
 254          * If not autoprobing, assume the device is there and set the
 255          * common routines to double check later.
 256          */
 257
 258         if (IDE_PROBE_GET_TYPE(probe_b,unit) == IDE_DEVTYPE_AUTO) {
 259             res = idecommon_devprobe(softc,1);
 260             if (res < 0) {
 261                 KFREE(softc);
 262                 KFREE(disp);
 263                 continue;
 264                 }
 265             }
 266         else {
 267             idecommon_init(softc,IDE_PROBE_GET_TYPE(probe_b,unit));
 268             softc->idecommon_deferprobe = 1;
 269             }
 270
 271
 272         xsprintf(descr,"%s unit %d at %08X",drv->drv_description,unit,probe_a);
 273         xsprintf(unitstr,"%d",unit);
 274
 275         realdrv = (cfe_driver_t *) (softc->idecommon_atapi ? &piixatapidrv : &piixidedrv);
 276
 277         cfe_attach(realdrv,softc,unitstr,descr);
 278         }
 279 }