Menu
▾
▴
blob-cvs-commit
|
From: Stefan E. <se...@us...> - 2002-04-18 19:52:59
|
Update of /cvsroot/blob/blob/src/lib
In directory usw-pr-cvs1:/tmp/cvs-serv13514
Modified Files:
Makefile.am
Added Files:
ide.c pcmcia.c
Log Message:
- Added PCMCIA and IDE framework. Based on Brad Parker's code.
NOTE NOTE NOTE:
This is all Work-In-Progress (you have been warned)
--- NEW FILE: ide.c ---
/**********************************************************************
* ide.c
*
* Basic ide drive framework. Based on Brad Parkers work.
*
* Copyright (C) 2001 Stefan Eletzhofer <ste...@ww...>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* $Id: ide.c,v 1.1 2002/04/18 19:52:49 seletz Exp $
*
* $Log: ide.c,v $
* Revision 1.1 2002/04/18 19:52:49 seletz
* - Added PCMCIA and IDE framework. Based on Brad Parker's code.
* NOTE NOTE NOTE:
* This is all Work-In-Progress (you have been warned)
*
*/
/**********************************************************************
* Includes
*/
#ifdef HAVE_CONFIG_H
# include <blob/config.h>
#endif
#include <blob/types.h>
#include <blob/errno.h>
#include <blob/util.h>
#include <blob/command.h>
#include <blob/time.h>
#include <blob/serial.h>
#include <blob/sa1100.h>
#include <blob/sa1111.h>
#include <blob/ide.h>
/**********************************************************************
* Defines / Makros
*/
#define WEAK_SYM __attribute__ (( weak ))
#define IDE_DEBUG 1
#ifdef IDE_DEBUG
# define _DBG( args... ) printf( args )
#else
# define _DBG( args... )
#endif
#define IDE_DELAY 10
/**********************************************************************
* Typen
*/
/**********************************************************************
* Programmglobale Variable
*/
/**********************************************************************
* Modulglobale Variable
*/
static char *version = "$Id: ide.c,v 1.1 2002/04/18 19:52:49 seletz Exp $";
#ifdef IDE_DEBUG
static int dbg = 1;
#else
static int dbg = 0;
#endif
/**********************************************************************
* Prototypen
*/
static int hd_identify(volatile u8 *port, volatile u8 *reg, char *buffer);
static int hd_recal(volatile u8 *port);
static int hd_busy_wait(volatile u8 *port);
static void ide_fixstring (u8 *s, const int bytecount, const int byteswap);
/**********************************************************************
* Exported functions
*/
/**********************************************************************
* ide_init
*
* - Initialize ide drive struct
* - calculatees and sets HD_PORT and HD_REG_RORT from a base address
*/
int ide_init( ide_drive_t *drive, u32 *base_addr )
{
if ( !base_addr )
return -1;
if ( !drive )
return -1;
if ( dbg > 0 ) {
printf( "ide: %s\n", version );
}
drive->ide_port = (u8 *)(base_addr + HD_PORT);
drive->ide_reg = (u8 *)(base_addr + HD_REG_PORT);
drive->last_status = 0;
return 0;
}
/**********************************************************************
* ide_status_dump
*
* - Dump IDE ports
*/
int ide_status_dump( ide_drive_t *drive )
{
u8 status;
int i;
if ( !drive || !drive->ide_port )
return -1;
for (i = 0; i < 8; i++) {
status = drive->ide_port[i];
printf("port[ %d ] %x\n", i, status);
}
return 0;
}
/**********************************************************************
* ide_reset
*
* - reset ide controller
*
* FIXME: resolve those magic numbers
*/
int ide_reset( ide_drive_t *drive )
{
volatile u8 *port = NULL;
volatile u8 *reg = NULL;
if ( !drive || !drive->ide_port )
return -1;
port = drive->ide_port;
reg = drive->ide_reg;
#if 1
/* reset hd controller */
reg[0] = 0x04;
msleep(IDE_DELAY);
reg[0] = 0x00;
msleep(IDE_DELAY);
#else
msleep(5*IDE_DELAY);
#endif
port[1] = 0;
port[2] = 0;
port[3] = 0;
port[4] = 0;
port[5] = 0;
port[6] = 0xa0;
msleep(IDE_DELAY);
return 0;
}
/**********************************************************************
* ide_identify_drive
*
* - Try to identify hd
* - Stores hd_driveid struct in ide drive struct
* - gets sectors per track and heads of disk
*/
int ide_identify_drive( ide_drive_t *drive )
{
struct hd_driveid *id;
volatile u8 *port = NULL;
volatile u8 *reg = NULL;
static char id_buffer[512];
if ( !drive || !drive->ide_port )
return -1;
port = drive->ide_port;
reg = drive->ide_reg;
if (hd_identify(port, reg, id_buffer)) {
return -1;
}
id = (struct hd_driveid *)id_buffer;
ide_fixstring (id->model, sizeof(id->model), 1);
printf("ide: model: %s\n", id->model);
printf("ide: CHS: %d/%d/%d\n", id->cyls, id->heads, id->sectors);
if (id->sectors && id->heads) {
drive->disk_sectors_per_track = id->sectors;
drive->disk_heads = id->heads;
} else {
drive->disk_sectors_per_track = 0;
drive->disk_heads = 0;
}
drive->driveid = *id;
return 0;
}
/**********************************************************************
* hd_read
*
* - read head/sector/cyl of drive to a buffer. Reads 1 block (512 bytes) of
* data.
*/
int hd_read( ide_drive_t *drive, int head, int sector, int cyl, char *buffer)
{
int i, hd_drive, hd_cyl, hd_head, hd_sector;
u8 status, hd_cmd[8];
volatile u8 *port = NULL;
volatile u8 *reg = NULL;
if ( !drive || !drive->ide_port )
return -1;
port = drive->ide_port;
reg = drive->ide_reg;
hd_drive = 0;
hd_cyl = cyl;
hd_head = head;
hd_sector = sector;
hd_cmd[1] = 0;
hd_cmd[2] = 1; /* # sectors */
hd_cmd[3] = hd_sector; /* starting sector */
hd_cmd[4] = cyl & 0xff; /* cylinder low byte */
hd_cmd[5] = (cyl >> 8) & 0xff; /* cylinder hi byte */
hd_cmd[6] = (hd_drive << 4) | (hd_head & 0x0f) | 0xa0;
if (dbg > 2)
printf("hd_read() h=%d s=%d c=%d\n", hd_head, hd_sector, hd_cyl);
#if 0
if (hd_head > 7) {
// hd_control |= 0x08;
// reg[0] = hd_control;
// hd_control &= 0xf7;
reg[0] = 0x08;
}
#endif
/* --- */
hd_busy_wait(port);
for (i = 1; i < 7; i++) {
hd_busy_wait(port);
port[i] = hd_cmd[i];
}
port[7] = HDC_READ;
hd_busy_wait(port);
for (i = 0; i < 512; i++) {
buffer[i] = port[0];
}
drive->last_status = status = port[7];
if (status & ERROR) {
printf("read status: %2x\n", status);
printf("h=%d s=%d c=%d\n", hd_head, hd_sector, hd_cyl);
for (i = 1; i < 7; i++) {
printf("set reg[%d] %2x\n", i, hd_cmd[i]);
}
}
if (status & ERROR)
return -1;
return 0;
}
/**********************************************************************
* hd_read_mapped
*
* - reads 512 bytes from sector <sector_num> from drive <drive>
* - <sector_num> gets mapped to CHS, then hd_read() is called.
*/
int hd_read_mapped( ide_drive_t *drive, int sector_num, char *buffer)
{
int head, sector, cyl;
if ( !drive || !drive->ide_port )
return -1;
if (dbg > 2)
printf("hd_read_mapped(sector_num=%d, buffer=%x)\n",
sector_num, buffer);
#if 0
sector = (sector_num % disk_sectors_per_track) + 1;
sector_num /= disk_sectors_per_track;
head = sector_num % disk_heads;
sector_num /= disk_heads;
cyl = sector_num;
#endif
hd_map_sector( drive, sector_num, &head, §or, &cyl );
return hd_read( drive, head, sector, cyl, buffer);
}
/**********************************************************************
* hd_map_sector
*
* - map continguous sector numbers to CHS values of <drive>
*/
int hd_map_sector( ide_drive_t *drive, int sector, int *head, int *sec, int *cyl )
{
int _cyl, _head, _sec;
if ( !drive )
return -1;
_sec = (sector % drive->disk_sectors_per_track) + 1;
sector /= drive->disk_sectors_per_track;
_head = sector % drive->disk_heads;
sector /= drive->disk_heads;
_cyl = sector;
_DBG( "%s: => (h:%d, s:%d, c:%d)\n", __FUNCTION__, _head, _sec, _cyl );
if ( head ) *head = _head;
if ( sec ) *sec = _sec;
if ( cyl ) *cyl = _cyl;
return 0;
}
/**********************************************************************
* Statische Funktionen
*/
/**********************************************************************
* hd_identify
*
* - performs HDC_IDENTIFY command and reads result to buffer
*/
static int hd_identify(volatile u8 *port, volatile u8 *reg, char *buffer)
{
int i;
unsigned char status;
hd_busy_wait(port);
port[1] = 0;
port[2] = 1;
port[3] = 0;
port[4] = 0;
port[5] = 0;
port[6] = 0xa0;
port[7] = HDC_IDENTIFY;
hd_busy_wait(port);
for (i = 0; i < 512; i++) {
buffer[i] = port[0];
}
status = port[7];
if (status & ERROR) {
printf("ide: identify status: %2x\n", status);
return -1;
}
return 0;
}
static int hd_recal(volatile u8 *port)
{
int i, hd_drive, hd_head, sector;
u8 hd_cmd[8];
hd_drive = 0;
sector = 0;
hd_head = sector & 0xffff;
hd_cmd[1] = 0;
hd_cmd[2] = 1; /* # sectors */
hd_cmd[3] = 0;
hd_cmd[4] = 0;
hd_cmd[5] = 0;
hd_cmd[6] = (hd_drive << 4) | (hd_head & 0x0f) | 0xa0;
hd_busy_wait(port);
for (i = 1; i < 7; i++) {
hd_busy_wait(port);
port[i] = hd_cmd[i];
}
port[7] = HDC_RECAL;
if (hd_busy_wait(port))
return -1;
return 0;
}
static int hd_busy_wait(volatile u8 *port)
{
int count;
u8 status, err;
count = 0;
while (count++ < 2500) {
status = port[7];
if ((status & BUSY) == 0)
break;
msleep(1);
}
_DBG( "ide: %s: port=%x, count=%d, status=%x\n", __FUNCTION__,
port, count, status );
if (status & 0x01) {
err = port[1];
printf( "ide: busy_wait: err = %2x\n", err );
return -1;
}
return 0;
}
static void ide_fixstring (u8 *s, const int bytecount, const int byteswap)
{
u8 *p = s, *end = &s[bytecount & ~1]; /* bytecount must be even */
if (byteswap) {
/* convert from big-endian to host byte order */
for (p = end ; p != s;) {
unsigned short *pp = (unsigned short *) (p -= 2);
// *pp = ntohs(*pp);
*pp = ((*pp >> 8) & 0xff) | ((*pp & 0xff) << 8);
}
}
/* strip leading blanks */
while (s != end && *s == ' ')
++s;
/* compress internal blanks and strip trailing blanks */
while (s != end && *s) {
if (*s++ != ' ' || (s != end && *s && *s != ' '))
*p++ = *(s-1);
}
/* wipe out trailing garbage */
while (p != end)
*p++ = '\0';
}
--- NEW FILE: pcmcia.c ---
/**********************************************************************
* pcmcia framework
*
* Provides an raw pcmcia/cf framework for blob. Based on original
* work from Brad Parker.
*
* Copyright (C) 2001 Stefan Eletzhofer <ste...@ww...>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* $Id: pcmcia.c,v 1.1 2002/04/18 19:52:49 seletz Exp $
*
* $Log: pcmcia.c,v $
* Revision 1.1 2002/04/18 19:52:49 seletz
* - Added PCMCIA and IDE framework. Based on Brad Parker's code.
* NOTE NOTE NOTE:
* This is all Work-In-Progress (you have been warned)
*
*/
/**********************************************************************
* Includes
*/
#ifdef HAVE_CONFIG_H
# include <blob/config.h>
#endif
#include <blob/types.h>
#include <blob/errno.h>
#include <blob/util.h>
#include <blob/command.h>
#include <blob/time.h>
#include <blob/serial.h>
#include <blob/sa1100.h>
#include <blob/sa1111.h>
#include <blob/pcmcia.h>
/**********************************************************************
* Defines / Makros
*/
#define WEAK_SYM __attribute__ (( weak ))
#define MEM(adr) (*((u32 *)adr))
#define SET(reg,bit) ((reg) |= (1<<(bit)))
#define CLR(reg,bit) ((reg) &= ~(1<<(bit)))
#define PCMCIA_DEBUG 1
#ifdef PCMCIA_DEBUG
# define _DBG( args... ) printf( args )
#else
# define _DBG( args... )
#endif
/**********************************************************************
* Typen
*/
typedef unsigned char uchar;
typedef struct {
u16 status;
int vcc;
int vpp;
u32 attr_base;
u32 base;
volatile uchar *ident;
volatile uchar *feature_p[PCMCIA_MAX_FEATURES];
int n_features;
u16 config_base;
} pcmcia_slot_t;
/**********************************************************************
* Programmglobale Variable
*/
pcmcia_slot_t pcmcia_slots[ PCMCIA_MAX_SLOTS ] = {
{
status: 0,
vcc: 0,
vpp: 0,
attr_base: PCMCIA_S0_ATTR_BASE,
base: PCMCIA_S0_BASE,
},{
status: 0,
vcc: 0,
vpp: 0,
attr_base: PCMCIA_S1_ATTR_BASE,
base: PCMCIA_S1_BASE,
},
};
/**********************************************************************
* Modulglobale Variable
*/
static char *module_version = "$Id: pcmcia.c,v 1.1 2002/04/18 19:52:49 seletz Exp $";
#ifdef PCMCIA_DEBUG
static int dbg = 1;
#else
static int dbg = 0;
#endif
/**********************************************************************
* Prototypen
*/
static int pcmcia_print_fixed(volatile uchar *p);
static int pcmcia_print_funcid(int func);
/**********************************************************************
* Exportierte Funktionen
*/
void pcmcia_dbg_set( int level )
{
printf( "pcmcia: debug level set to %d\n", level );
dbg = level;
}
/* do whatever is needed to get pcmcia initialized */
int WEAK_SYM pcmcia_init()
{
return 0;
}
/* set pcmcia slot voltage levels */
int WEAK_SYM pcmcia_voltage_set( int slot, int vcc, int vpp )
{
return 0;
}
/* detect slot */
int WEAK_SYM pcmcia_slot_detect( int slot )
{
int detect = 0;
unsigned int flags = PCSR;
switch ( slot ) {
case 0:
detect = (flags & PCSR_S0_DETECT) == 0;
break;
case 1:
detect = (flags & PCSR_S1_DETECT) == 0;
break;
default:
detect = -1;
goto DONE;
break;
}
if ( detect ) {
pcmcia_slots[slot].status |= PCMCIA_SS_DETECT;
} else {
pcmcia_slots[slot].status &= ~PCMCIA_SS_DETECT;
}
_DBG( "%s: slot %d status: %x\n", __FUNCTION__, slot, pcmcia_slots[slot].status );
DONE:
return detect;
}
/* enable slot */
int WEAK_SYM pcmcia_slot_enable( int slot )
{
int ret = 0;
switch ( slot ) {
case 0:
PCCR = (PCCR & ~PCCR_S0_PSE) | PCCR_S0_FLT | PCCR_S0_PWAITEN;
break;
case 1:
PCCR = (PCCR & ~PCCR_S1_PSE) | PCCR_S1_FLT | PCCR_S1_PWAITEN;
break;
default:
ret = -1;
goto DONE;
break;
}
pcmcia_slots[slot].status |= PCMCIA_SS_ENABLED;
_DBG( "%s: slot %d status: %x\n", __FUNCTION__, slot, pcmcia_slots[slot].status );
DONE:
return ret;
}
/* disable slot */
int WEAK_SYM pcmcia_slot_disable( int slot )
{
int ret = 0;
switch ( slot ) {
case 0:
PCCR = PCCR | PCCR_S0_PSE;
break;
case 1:
PCCR = PCCR | PCCR_S1_PSE;
break;
default:
ret = -1;
goto DONE;
break;
}
pcmcia_slots[slot].status &= ~PCMCIA_SS_ENABLED;
_DBG( "%s: slot %d status: %x\n", __FUNCTION__, slot, pcmcia_slots[slot].status );
DONE:
return ret;
}
/* reset pcmcia slot */
int WEAK_SYM pcmcia_slot_reset(int slot)
{
int ret = 0;
switch ( slot ) {
case 0:
PCCR |= PCCR_S0_RST;
msleep(20);
PCCR &= ~PCCR_S0_RST;
msleep(20);
break;
case 1:
PCCR |= PCCR_S1_RST;
msleep(20);
PCCR &= ~PCCR_S1_RST;
msleep(20);
break;
default:
ret = -1;
break;
}
_DBG( "%s: slot %d reset\n", __FUNCTION__, slot );
return ret;
}
/* dump slot HW line stati */
int pcmcia_dump_stati( void )
{
int status = PCSR;
printf("s0: ");
if (status & PCSR_S0_READY) printf("ready "); else printf(" ");
if (status & PCSR_S0_DETECT) printf("detect "); else printf(" ");
if (status & PCSR_S0_VS1) printf("vs1 "); else printf(" ");
if (status & PCSR_S0_VS2) printf("vs2 "); else printf(" ");
if (status & PCSR_S0_WP) printf("wp "); else printf(" ");
if (status & PCSR_S0_BVD1) printf("bvd1 "); else printf(" ");
if (status & PCSR_S0_BVD2) printf("bvd2 "); else printf(" ");
printf("; ");
printf("s1: ");
if (status & PCSR_S1_READY) printf("ready "); else printf(" ");
if (status & PCSR_S1_DETECT) printf("detect "); else printf(" ");
if (status & PCSR_S1_VS1) printf("vs1 "); else printf(" ");
if (status & PCSR_S1_VS2) printf("vs2 "); else printf(" ");
if (status & PCSR_S1_WP) printf("wp "); else printf(" ");
if (status & PCSR_S1_BVD1) printf("bvd1 "); else printf(" ");
if (status & PCSR_S1_BVD2) printf("bvd2 "); else printf(" ");
printf("\n");
return 0;
}
/* identify pcmcia card */
int pcmcia_identify( volatile unsigned char *p )
{
unsigned char id_str[PCMCIA_MAX_IDENT_CHARS];
unsigned char data;
unsigned char *t;
int i, done;
if (p == NULL)
return (0); /* Don't know */
t = id_str;
done =0;
for (i=0; i<=4 && !done; ++i, p+=2) {
while ((data = *p) != '\0') {
if (data == 0xFF) {
done = 1;
break;
}
*t++ = data;
if (t == &id_str[PCMCIA_MAX_IDENT_CHARS-1]) {
done = 1;
break;
}
p += 2;
}
if (!done)
*t++ = ' ';
}
*t = '\0';
while (--t > id_str) {
if (*t == ' ')
*t = '\0';
else
break;
}
printf("%s\n", id_str);
return (0); /* don't know */
}
/* parse cis tuples of card in slot <slot> */
int pcmcia_cis_parse( int slot )
{
int ret = 0;
void *cfg_mem_addr = NULL;
volatile uchar *ident = NULL;
volatile uchar *p = NULL;
volatile uchar *start = NULL;
int n_features = 0;
uchar func_id = ~0;
uchar len = 0;
uchar code = 0;
u16 config_base = 0;
int found = 0;
int i = 0;
volatile uchar **feature_p;
/* sanity check */
if ( slot < 0 ) {
printf( "pcmcia: invalid slot slot %d\n", slot );
ret = -1;
goto DONE;
}
if ( slot > PCMCIA_MAX_SLOTS ) {
printf( "pcmcia: invalid slot slot %d\n", slot );
ret = -1;
goto DONE;
}
if ( !( pcmcia_slots[slot].status & PCMCIA_SS_ENABLED ) ||
!( pcmcia_slots[slot].status & PCMCIA_SS_DETECT )) {
printf( "pcmcia: slot %d not detected and enabled\n", slot );
ret = -1;
goto DONE;
}
cfg_mem_addr = (void *)pcmcia_slots[slot].attr_base;
feature_p = pcmcia_slots[slot].feature_p;
ident = pcmcia_slots[slot].ident;
if (dbg > 0) printf("PCMCIA MEM: %p\n", cfg_mem_addr);
start = p = (volatile uchar *)cfg_mem_addr;
while ((p - start) < PCMCIA_MAX_TUPEL_SZ) {
code = *p; p += 2;
if (code == 0xFF) { /* End of chain */
break;
}
len = *p; p += 2;
if (dbg > 1) {
volatile uchar *q = p;
printf ("\nTuple code %2x length %d\n\tData:",
code, len);
for (i = 0; i < len; ++i) {
printf (" %2x", *q);
q+= 2;
}
}
switch (code) {
case CISTPL_VERS_1:
ident = p + 4;
break;
case CISTPL_FUNCID:
func_id = *p;
break;
case CISTPL_FUNCE:
if (n_features < PCMCIA_MAX_FEATURES)
feature_p[n_features++] = p;
break;
case CISTPL_CONFIG:
config_base = (*(p+6) << 8) + (*(p+4));
printf("\n## Config_base = %x ###\n", config_base);
default:
break;
}
p += 2 * len;
}
found = pcmcia_identify( ident );
if (func_id != ((uchar)~0)) {
pcmcia_print_funcid(func_id);
if (func_id == CISTPL_FUNCID_FIXED)
found = 1;
}
if ( found ) {
for (i=0; i<n_features; ++i) {
pcmcia_print_fixed (feature_p[i]);
}
}
#if 1
/* hmmm, should this happen here?
* FIXME: provide extra function?
*/
#define COR_FUNC_ENA 0x01
/* set configuration option register to enable card */
*((uchar *)(cfg_mem_addr + config_base)) = COR_FUNC_ENA;
#endif
ret = 0;
DONE:
return ret;
}
int pcmcia_slot_address_get( int slot, u32 **base, u32 **attr )
{
int ret = 0;
/* sanity check */
if ( slot < 0 ) {
printf( "pcmcia: invalid slot slot %d\n", slot );
ret = -1;
goto DONE;
}
if ( slot > PCMCIA_MAX_SLOTS ) {
printf( "pcmcia: invalid slot slot %d\n", slot );
ret = -1;
goto DONE;
}
if ( !( pcmcia_slots[slot].status & PCMCIA_SS_ENABLED ) ||
!( pcmcia_slots[slot].status & PCMCIA_SS_DETECT )) {
printf( "pcmcia: slot %d not detected and enabled\n", slot );
ret = -1;
goto DONE;
}
if ( base ) *base = (u32 *)pcmcia_slots[slot].base;
if ( attr ) *attr = (u32 *)pcmcia_slots[slot].attr_base;
ret = 0;
DONE:
return ret;
}
/**********************************************************************
* Statische Funktionen
*/
/* print function id strings */
static int pcmcia_print_funcid(int func)
{
printf("\t ");
switch (func) {
case CISTPL_FUNCID_MULTI:
printf("Multi-Function");
break;
case CISTPL_FUNCID_MEMORY:
printf("Memory");
break;
case CISTPL_FUNCID_SERIAL:
printf("Serial Port");
break;
case CISTPL_FUNCID_PARALLEL:
printf("Parallel Port");
break;
case CISTPL_FUNCID_FIXED:
printf("Fixed Disk");
break;
case CISTPL_FUNCID_VIDEO:
printf("Video Adapter");
break;
case CISTPL_FUNCID_NETWORK:
printf("Network Adapter");
break;
case CISTPL_FUNCID_AIMS:
printf("AIMS Card");
break;
case CISTPL_FUNCID_SCSI:
printf("SCSI Adapter");
break;
default:
printf("Unknown");
break;
}
printf(" Card\n");
return 0;
}
/* print info for FIXED_DISK function type card */
static int pcmcia_print_fixed(volatile uchar *p)
{
if (p == NULL)
return -1;
printf("\t ");
switch (*p) {
case CISTPL_FUNCE_IDE_IFACE:
{ uchar iface = *(p+2);
printf((iface == CISTPL_IDE_INTERFACE) ? " IDE" : " unknown");
printf(" interface ");
break;
}
case CISTPL_FUNCE_IDE_MASTER:
case CISTPL_FUNCE_IDE_SLAVE:
{ uchar f1 = *(p+2);
uchar f2 = *(p+4);
printf((f1 & CISTPL_IDE_SILICON) ? " [silicon]" : " [rotating]");
if (f1 & CISTPL_IDE_UNIQUE)
printf(" [unique]");
printf((f1 & CISTPL_IDE_DUAL) ? " [dual]" : " [single]");
if (f2 & CISTPL_IDE_HAS_SLEEP)
printf(" [sleep]");
if (f2 & CISTPL_IDE_HAS_STANDBY)
printf(" [standby]");
if (f2 & CISTPL_IDE_HAS_IDLE)
printf(" [idle]");
if (f2 & CISTPL_IDE_LOW_POWER)
printf(" [low power]");
if (f2 & CISTPL_IDE_REG_INHIBIT)
printf(" [reg inhibit]");
if (f2 & CISTPL_IDE_HAS_INDEX)
printf(" [index]");
if (f2 & CISTPL_IDE_IOIS16)
printf(" [IOis16]");
break;
}
}
printf("\n");
return 0;
}
Index: Makefile.am
===================================================================
RCS file: /cvsroot/blob/blob/src/lib/Makefile.am,v
retrieving revision 1.14
retrieving revision 1.15
diff -u -d -r1.14 -r1.15
--- Makefile.am 17 Feb 2002 19:54:47 -0000 1.14
+++ Makefile.am 18 Apr 2002 19:52:49 -0000 1.15
@@ -30,6 +30,7 @@
crc32.c \
error.c \
icache.c \
+ ide.c \
init.c \
led.c \
md5.c \
@@ -37,6 +38,7 @@
memcpy.c \
memset.c \
mini_inflate.c \
+ pcmcia.c \
printf.c \
reboot.c \
serial.c \
|
|
From: Tim R. <Ti...@Ri...> - 2002-04-18 20:42:49
|
cept you missed blob/ide.h so CVS is broken -- Tim Riker - http://rikers.org/ - short SIGs! <g> All I need to know I could have learned in Kindergarten ... if I'd just been paying attention. |
×
Want the latest updates on software, tech news, and AI?
Get latest updates about software, tech news, and AI from SourceForge directly in your inbox once a month.
Thanks for helping keep SourceForge clean.
X