URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [bootloaders/] [orpmon/] [cmds/] [atabug.c] - Blame information for rev 248

Go to most recent revision | Details | Compare with Previous | View Log


/*
    atabug.c -- ATA debugging
    Copyright (C) 2002 Richard Herveille, rherveille@opencores.org
 
    This file is part of OpenRISC 1000 Reference Platform Monitor (ORPmon)
 
    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., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
 
 
#include "support.h"
#include "common.h"
#include "atabug.h"
#include "ata.h"
 
#include <ctype.h>
 
static int ata_num_commands;
static command_struct ata_command[MAX_ATA_COMMANDS];
 
/* inode struct for ata */
static struct inode _inode;
static struct inode *inode = &_inode;
 
/* file struct for ata */
static struct file _filp;
static struct file *filp = &_filp;
 
/* buffer for ata-data */
static unsigned char buf[512];
 
 
/**********************************************************************/
/*                                                                    */
/*      A T A B U G                                                   */
/*                                                                    */
/**********************************************************************/
/*
        A T A _ I N I T
 
        initializes the ATA core, and registers it with ORPmon
*/
void module_ata_init (void)
{
  ata_num_commands = 0;
 
  register_command ("atabug", "", "ATA debugger. Type 'atabug help' for help", atabug);
 
  register_ata_command ("help", "", "Display this help message", atabug_help);
  register_ata_command ("exit", "", "Exit atabug and return to ORPmon", atabug_exit);
  register_ata_command ("open", "<device> [<mode>]", "Opens the requested device. Device=<0|1>, Mode=<r>eadonly|read<w>rite.", ata_open_cmd);
  register_ata_command ("close", "", "Closes the device.", ata_close_cmd);
  register_ata_command ("reset", "<mode>", "Reset ata device(s).", ata_reset_cmd);
  register_ata_command ("enable", "", "Enables ATA host controller, clears all resets", ata_enable_cmd);
  register_ata_command ("dump_dev_regs", "", "Dump the (readable) ata device registers.", ata_dump_device_regs_cmd);
  register_ata_command ("dump_host_regs", "", "Dump the ata host registers.", ata_dump_host_regs_cmd);
  register_ata_command ("exec_cmd", "<cmd>", "Execute ata command <cmd> (hex)", ata_exec_cmd_cmd);
  register_ata_command ("identify_device", "", "Dumps device's IDENTIFY DEVICE block.", ata_identify_device_cmd);
  register_ata_command ("program_timing", "<PIO mode>", "Programs the device to the selected PIO mode.", ata_set_piomode_cmd);
  register_ata_command ("read_sectors", "<startsector> [<sectorcount>]", "Reads sector", ata_read_sectors_cmd);
  register_ata_command ("read_mbr", "<partition>", "Reads the Master Boot Record.", ata_read_mbr_cmd);
  register_ata_command ("read_dosboot", "<sector>", "Reads the device's bootsector (FAT).", ata_read_dosboot_cmd);
  register_ata_command ("select_device", "<device_no>", "Select ata device. device_no=<0|1>", ata_select_device_cmd);
}
 
 
int atabug(int argc, char **argv)
{
 
  /* take care of commandline options                                 */
  if (argc == 0)
  {
    /* start atabug                                                   */
    while ( !ata_mon_command() );
  }
  else
    return execute_ata_command(argv[0], argc -1, &argv[1]);
 
  return 0;
}
 
int atabug_exit(int argc, char **argv)
{
  ata_close_cmd(argc, argv);
  return -2;
}
 
/*
 The next code is graceously taken from the "common.c" file
 and slightly modified to suit the big list of ATA commands
 
 Better would be if we could access the routines in 'common.c'
 directly, using our own set of commands.
*/
 
/* Process command-line, generate arguments */
int ata_mon_command(void)
{
  char c = '\0';
  char str[1000];
  char *pstr = str;
  char *command_str;
  char *argv[20];
  int argc = 0;
 
 
  /* Show prompt */
  printf ("\natabug> ");
 
 
  /* Get characters from UART */
  c = getc();
  while (c != '\r' && c != '\f' && c != '\n')
  {
    if (c == '\b')
      pstr--;
    else
      *pstr++ = c;
    putc(c);
    c = getc();
  }
  *pstr = '\0';
  printf ("\n");
 
  /* Skip leading blanks */
  pstr = str;
  while ( isspace(*pstr) ) pstr++;
 
  /* Get command from the string */
  command_str = pstr;
 
  while (1) {
    /* Go to next argument */
    while ( isgraph(*pstr) ) pstr++;
    if (*pstr) {
      *pstr++ = '\0';
      while ( isspace(*pstr) ) pstr++;
      argv[argc++] = pstr;
    }
    else
      break;
  }
 
  return execute_ata_command(command_str, argc, argv);
}
 
 
int execute_ata_command(char *command_str, int argc, char **argv)
{
  int i, found = 0;
 
  for (i = 0; i < ata_num_commands; i++)
    if ( !strcmp(command_str, ata_command[i].name) )
    {
      switch ( ata_command[i].func(argc, argv) )
      {
        case -1:
          printf ("Missing/wrong parameters, usage: %s %s\n", ata_command[i].name, ata_command[i].params);
          break;
 
        case -2:
          return -1;
      }
 
      found++;
      break;
    }
 
    if (!found)
      printf ("Unknown command. Type 'ata help' for help.\n");
 
  return 0;
}
 
 
void register_ata_command (const char *name, const char *params, const char *help, int (*func)(int argc, char *argv[]) )
{
  if (ata_num_commands < MAX_ATA_COMMANDS)
  {
    ata_command[ata_num_commands].name = name;
    ata_command[ata_num_commands].params = params;
    ata_command[ata_num_commands].help = help;
    ata_command[ata_num_commands].func = func;
    ata_num_commands++;
  }
  else
    printf ("ata-command '%s' ignored; MAX_COMMANDS limit reached\n", name);
}
 
int atabug_help(int argc, char **argv)
{
  int i;
 
  for (i = 0; i < ata_num_commands; i++)
    printf ("%-15s %-17s -%s\n", ata_command[i].name, ata_command[i].params, ata_command[i].help);
 
  return 0;
}
 
 
 
 
/**********************************************************************/
/*                                                                    */
/*      A T A B U G   C O M M A N D S E T                             */
/*                                                                    */
/**********************************************************************/
 
/*
        A T A _ C L O S E
 
        closes the ata_device
*/
int ata_close_cmd(int argc, char **argv)
{
    inode->i_rdev = (ATA_BASE_ADDR >> 16) | (*argv[0] - '0');
 
    return ata_release(inode, filp);
}
 
 
/*
        A T A _ D U M P _ D E V I C E _ R E G S
 
        Dumps the (readable) ata-registers.
        Exception: status register is not read, this could mask an interrupt
*/
int ata_dump_device_regs_cmd(int argc, char **argv)
{
    if (argc)
      printf("\nWARNING: Ignoring invalid argument(s)\n\n");
 
 
    printf("Alternate status register : 0x%02lX\n", REG32(ATA_BASE_ADDR + ATA_ASR) );
    printf("Cylinder high register    : 0x%02lX\n", REG32(ATA_BASE_ADDR + ATA_CHR) );
    printf("Cylinder low register     : 0x%02lX\n", REG32(ATA_BASE_ADDR + ATA_CLR) );
    printf("Device head register      : 0x%02lX\n", REG32(ATA_BASE_ADDR + ATA_DHR) );
    printf("Error register            : 0x%02lX\n", REG32(ATA_BASE_ADDR + ATA_ERR) );
    printf("Sector count register     : 0x%02lX\n", REG32(ATA_BASE_ADDR + ATA_SCR) );
    printf("Sector number register    : 0x%02lX\n", REG32(ATA_BASE_ADDR + ATA_SNR) );
    printf("Status register (see alternate status register)\n" );
 
    return 0;
}
 
 
/*
        A T A _ D U M P _ H O S T _ R E G S
 
        Dumps the ata-host registers
*/
int ata_dump_host_regs_cmd(int argc, char **argv)
{
    if (argc)
      printf("\nWARNING: Ignoring invalid argument(s)\n\n");
 
 
    printf("Control register                   CTRL : 0x%08lX\n", REG32(ATA_BASE_ADDR + ATA_CTRL) );
    printf("Status register                    STAT : 0x%08lX\n", REG32(ATA_BASE_ADDR + ATA_STAT) );
    printf("Pio command timing register        PCTR : 0x%08lX\n", REG32(ATA_BASE_ADDR + ATA_PCTR) );
    printf("Pio fast timing register (device0) PFTR0: 0x%08lX\n", REG32(ATA_BASE_ADDR + ATA_PFTR0) );
    printf("Pio fast timing register (device1) PFTR1: 0x%08lX\n", REG32(ATA_BASE_ADDR + ATA_PFTR1) );
    printf("Dma timing register (device0)      DTR0 : 0x%08lX\n", REG32(ATA_BASE_ADDR + ATA_DTR0) );
    printf("Dma timing register (device1)      DTR1 : 0x%08lX\n", REG32(ATA_BASE_ADDR + ATA_DTR1) );
 
    return 0;
}
 
 
/*
        A T A _ E N A B L E
 
        clears reset bits
*/
int ata_enable_cmd(int argc, char **argv)
{
    if (argc != 0)
        printf("Ignoring invalid parameters\n");
 
    inode->i_rdev = (ATA_BASE_ADDR >> 16);
 
    // clear hardware reset bit
    if ( ata_ioctl(inode, filp, ATA_IOCTL_SET_RST, CLR | ARG_HW_RST) )
      return -1;
 
    // clear software reset bit
    if ( ata_ioctl(inode, filp, ATA_IOCTL_SET_RST, CLR | ARG_SW_RST) )
      return -1;
 
    // enable ATA Hostcontroller core
    if ( ata_ioctl(inode, filp, ATA_IOCTL_ENABLE_HOST, 0) )
      return -1;
 
    printf("ATA host controller enabled\n");
 
    return 0;
}
 
 
/*
        A T A _ E X E C _ C M D
 
        Executes the command; writes the command number in the command register
*/
int ata_exec_cmd_cmd(int argc, char **argv)
{
    if (argc != 1)
        return -1;
 
    inode->i_rdev = (ATA_BASE_ADDR >> 16);
 
    ata_ioctl(inode, filp, ATA_IOCTL_EXEC_CMD, strtoul(*argv, argv, 16) );
    return 0;
}
 
 
/*
        A T A _ I D E N T I F Y _ D E V I C E
 
        Reads the identify_device block and dumps it to the screen
*/
int ata_identify_device_cmd(int argc, char **argv)
{
    unsigned char checksum;
 
    if (argc != 0)
        printf("Ignoring invalid parameters\n");
 
 
    /* check for busy flag                                            */
    if ( ata_dev_busy(ATA_BASE_ADDR) )
        printf("Selected ata device busy, ignoring command\n");
    else
    {
        /* execute identify device                                    */
        ata_ioctl(inode, filp, ATA_IOCTL_EXEC_CMD, IDENTIFY_DEVICE);
 
        /* read block from ata-device                                 */
        buf[0] = 0;
        buf[1] = 1;
        ata_ioctl(inode, filp, ATA_IOCTL_READ, (unsigned long) buf);
 
        /* dump data to the screen                                    */
        checksum = atabug_dump_data(buf, 512);
 
        if (buf[512] == 0xa5)
            printf("Checksum = 0x%02X (%s)\n", checksum, checksum ? "error" : "OK");
        else
            printf("No checksum supported\n");
    }
    return 0;
}
 
 
/*
        A T A _ O P E N
 
        opens the ata_device
*/
int ata_open_cmd(int argc, char **argv)
{
    inode->i_rdev = (ATA_BASE_ADDR >> 16) | (*argv[0] - '0');
 
    filp->f_mode = FMODE_READ;
 
    if (*argv[1] == 'w')
      filp->f_mode |= FMODE_WRITE;
 
    switch( ata_open(inode, filp) ) {
      case EOPENIDEV:
        printf( "Error: Invalid device (invalid MINOR %02X)\n", MINOR(inode->i_rdev) );
        break;
 
      case EOPENNODEV:
        printf( "Error: Requested device not found\n" );
        break;
 
      case EOPENIHOST:
        printf( "Error: Invalid host (invalid MAJOR %02X)\n", MAJOR(inode->i_rdev) );
      default:
        break;
    }
 
    return 0;
}
 
 
/*
        A T A _ S E T _ P I O M O D E
 
        Sets the device to the requested PIO mode
*/
int ata_set_piomode_cmd(int argc, char **argv)
{
    return 0;
}
 
 
/*
        A T A _ R E A D _ S E C T O R S
 
        Reads 1 sector from the device and dumps it to the screen
*/
int ata_read_sectors_cmd(int argc, char **argv)
{
    struct request request;
    unsigned long sector_cnt, sector;
 
    sector = strtoul(argv[0], argv, 10);
 
    switch (argc) {
      case 2:
        sector_cnt = strtoul(argv[1], argv, 10);
        break;
 
      case 1:
        sector_cnt = 1;
        break;
 
      default:
        return -1;
    }
 
    if ( !sector_cnt )
    {
      printf( "Invalid number of sectors.\n" );
      return 0;
    }
 
    /* check for busy flag                                            */
    if ( ata_dev_busy(ATA_BASE_ADDR) )
        printf("Selected ata device busy, ignoring command\n");
    else
    {
        /* fill the request structure                                 */
        request.cmd = READ;
        request.sector = sector;
        request.nr_sectors = sector_cnt;
        request.buffer = buf;
 
        if ( ata_request(inode, filp, &request) )
        {
            printf("Error while executing READ_SECTOR(S) command\n");
            printf("Status register = 0x%02lX, error register = 0x%02lX\n", ata_astatus(ATA_BASE_ADDR), ata_error(ATA_BASE_ADDR) );
        }
        else
        {
            /* dump data to the screen                                    */
            atabug_dump_data(buf, 512 * sector_cnt);
        }
    }
    return 0;
}
 
 
/*
        A T A _ R E A D _ M B R
 
        Reads master boot record from the device and dumps it's contents to the screen
*/
int ata_read_mbr_cmd(int argc, char **argv)
{
    struct request request;
    unsigned int partition;
 
    // get requested partition number
    partition = 0;
    if (argc)
        partition = strtoul(*argv, argv, 10);
 
    /* check for busy flag                                            */
    if ( ata_dev_busy(ATA_BASE_ADDR) )
        printf("Selected ata device busy, ignoring command\n");
    else
    {
        /* fill the request structure                                 */
        request.cmd = READ;
        request.sector = 0;
        request.nr_sectors = 1;
        request.buffer = buf;
 
        if ( ata_request(inode, filp, &request) )
        {
            printf("Error while reading master boot sector.\n");
            printf("Status register = 0x%02lX, error register = 0x%02lX\n", ata_astatus(ATA_BASE_ADDR), ata_error(ATA_BASE_ADDR) );
        }
        else
        {
          printf( "Skipping bootloader (446bytes)\n" );
          printf( "Partition %1d:\n", partition);
 
          // abuse partitionnumber to get offset in MBR record
          partition *= 16;
          partition += 446;
 
          printf( "Bootindicator: 0x%2X (%s)\n", buf[partition], buf[partition] ? "bootable" : "non-bootable");
          printf( "Partition start (head: 0x%02X cyl: 0x%03X sect: 0x%02X)\n",
              buf[partition +1], (buf[partition +2] & 0xc0) << 2 | buf[partition +3] ,buf[partition +2] & 0x3f );
          printf( "Systemindicator: 0x%02X (", buf[partition +4]);
 
          switch (buf[partition +4])
          {
              case 0: printf ("Non DOS"); break;
              case 1: printf ("DOS FAT12"); break;
              case 4: printf ("DOS FAT16"); break;
              case 5: printf ("DOS extended"); break;
              case 6: printf ("DOS >32MByte"); break;
 
              default : printf ("unkown");
          };
          printf (")\n");
          printf( "Partition end (head: 0x%02X cyl: 0x%03X sect: 0x%02X)\n",
              buf[partition +5], (buf[partition +6] & 0xc0) << 2 | buf[partition +7] ,buf[partition +6] & 0x3f );
          printf( "Physical Startsector: 0x%08X\n", buf[partition +11] << 24 |
                                                    buf[partition +10] << 16 |
                                                    buf[partition +9] << 8   |
                                                    buf[partition +8]);
          printf( "Sector count: 0x%08X\n", buf[partition +15] << 24 |
                                            buf[partition +14] << 16 |
                                            buf[partition +13] << 8  |
                                            buf[partition +12]);
        }
    }
    return 0;
}
 
 
/*
        A T A _ R E A D _ D O S B O O T
 
        Reads boot sector from the device and dumps it's contents to the screen
*/
int ata_read_dosboot_cmd(int argc, char **argv)
{
    struct request request;
    unsigned int sector;
    char txt[8];
 
    sector = 0;
    if (argc)
      sector = strtoul(*argv, argv, 0);
 
    /* check for busy flag                                            */
    if ( ata_dev_busy(ATA_BASE_ADDR) )
        printf("Selected ata device busy, ignoring command\n");
    else
    {
        /* fill the request structure                                 */
        request.cmd = READ;
        request.sector = sector;
        request.nr_sectors = 1;
        request.buffer = buf;
 
        if ( ata_request(inode, filp, &request) )
        {
            printf("Error whilereading boot sector 0x%02X.\n", sector);
            printf("Status register = 0x%02lX, error register = 0x%02lX\n", ata_astatus(ATA_BASE_ADDR), ata_error(ATA_BASE_ADDR) );
        }
        else
        {
          printf( "Reading boot sector 0x%02X\n", sector );
          printf( "ID number: 0x%2X%2X%2X\n", buf[0], buf[1], buf[2] );
 
          printf( "OEM-name and number: " );
          memcpy(txt, &buf[3], 8);
          txt[8] = '\0';
          printf( "%s\n", txt );
 
          printf( "Bytes per sector: %5d\n", (buf[12]<<8) | buf[11] );
          printf( "Sectors per cluster: %3d\n", buf[13] );
          printf( "Reserved IM-sectors: %5d\n", (buf[15]<<8) | buf[14] );
          printf( "Number of FATs: %3d\n", buf[16] );
          printf( "Number of entries in the root-directory: %5d\n", (buf[18]<<8) | buf[17] );
          printf( "Number of logical sectors: %5d\n", (buf[20]<<8) | buf[19] );
          printf( "Medium descriptor byte: %02X\n", buf[21] );
          printf( "Sectors per FAT: %5d\n", (buf[23]<<8) | buf[22] );
          printf( "Sectors per track: %5d\n", (buf[25]<<8) | buf[24] );
          printf( "Number of heads: %5d\n", (buf[27]<<8) | buf[26] );
          printf( "Number of hidden sectors: %5d\n", (buf[29]<<8) | buf[28] );
        }
    }
    return 0;
}
 
 
/*
        A T A _ R E S E T
 
        resets the ATA device, using the select method
*/
int ata_reset_cmd(int argc, char **argv)
{
    if (argc != 1)
        return -1;
 
    return ata_ioctl(inode, filp, ATA_IOCTL_SET_RST, SET | (**argv - '0') );
}
 
 
/*
        A T A _ S E L E C T _ D E V I C E
 
        selects the ATA device; sets the DEV bit in the device/head register
*/
int ata_select_device_cmd(int argc, char **argv)
{
    if (argc != 1)
      return -1;
 
    inode->i_rdev = (ATA_BASE_ADDR >> 16) | (*argv[0] - '0');
 
    ata_ioctl(inode, filp, ATA_IOCTL_SELECT_DEVICE, **argv - '0');
 
    printf("Ata device %1d selected.\n", REG32(ATA_BASE_ADDR + ATA_DHR) & ATA_DHR_DEV ? 1 : 0);
    return 0;
}
 
 
 
 
/**********************************************************************/
/*                                                                    */
/*      A T A B U G   T O O L S                                       */
/*                                                                    */
/**********************************************************************/
 
/*
 D U M P _ D A T A
 
 dumps byte-data in a buffer of type short to the screen
 and returns the byte-checksum
 
 *buffer = pointer to (short)buffer
 cnt     = number of bytes to display
*/
unsigned char atabug_dump_data(unsigned char *buffer, int cnt)
{
    int i, n, bytes_per_line = 16;
    unsigned char  c, checksum;
    unsigned char *buf_ptr;
 
    /* prepare stored data for display & calculate checksum           */
    checksum = 0;
    buf_ptr = buffer;
 
    /* display data                                                   */
    for (i=0; i < cnt; i += bytes_per_line)
    {
      printf("%3X ", i);
 
      /* print hexadecimal notation                                   */
      for (n=0; n < bytes_per_line; n++)
          printf("%02X ", *buf_ptr++);
 
      buf_ptr -= bytes_per_line; /* back to the start (of this block) */
 
      /* print ASCII notation & calculate checksum                    */
      for (n=0; n < bytes_per_line; n++)
      {
        c = *buf_ptr++;
        printf("%c", isprint(c) ? c : '.');
        checksum += c;
      }
      printf("\n");
    }
 
    return checksum;
}
 
 

Browse

Tools

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [bootloaders/] [orpmon/] [cmds/] [atabug.c] - Blame information for rev 248

Line No.	Rev	Author	Line
1	2	marcus.erl	`/*`
2			`atabug.c -- ATA debugging`
3			`Copyright (C) 2002 Richard Herveille, rherveille@opencores.org`
4
5			`This file is part of OpenRISC 1000 Reference Platform Monitor (ORPmon)`
6
7			`This program is free software; you can redistribute it and/or modify`
8			`it under the terms of the GNU General Public License as published by`
9			`the Free Software Foundation; either version 2 of the License, or`
10			`(at your option) any later version`
11
12			`This program is distributed in the hope that it will be useful,`
13			`but WITHOUT ANY WARRANTY; without even the implied warranty of`
14			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
15			`GNU General Public License for more details.`
16
17			`You should have received a copy of the GNU General Public License`
18			`along with this program; if not, write to the Free Software`
19			`Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.`
20			`*/`
21
22
23			`#include "support.h"`
24			`#include "common.h"`
25			`#include "atabug.h"`
26			`#include "ata.h"`
27
28			`#include <ctype.h>`
29
30			`static int ata_num_commands;`
31			`static command_struct ata_command[MAX_ATA_COMMANDS];`
32
33			`/* inode struct for ata */`
34			`static struct inode _inode;`
35			`static struct inode *inode = &_inode;`
36
37			`/* file struct for ata */`
38			`static struct file _filp;`
39			`static struct file *filp = &_filp;`
40
41			`/* buffer for ata-data */`
42			`static unsigned char buf[512];`
43
44
45			`/**********************************************************************/`
46			`/* */`
47			`/* A T A B U G */`
48			`/* */`
49			`/**********************************************************************/`
50			`/*`
51			`A T A _ I N I T`
52
53			`initializes the ATA core, and registers it with ORPmon`
54			`*/`
55			`void module_ata_init (void)`
56			`{`
57			`ata_num_commands = 0;`
58
59			`register_command ("atabug", "", "ATA debugger. Type 'atabug help' for help", atabug);`
60
61			`register_ata_command ("help", "", "Display this help message", atabug_help);`
62			`register_ata_command ("exit", "", "Exit atabug and return to ORPmon", atabug_exit);`
63			`register_ata_command ("open", "<device> [<mode>]", "Opens the requested device. Device=<0\|1>, Mode=<r>eadonly\|read<w>rite.", ata_open_cmd);`
64			`register_ata_command ("close", "", "Closes the device.", ata_close_cmd);`
65			`register_ata_command ("reset", "<mode>", "Reset ata device(s).", ata_reset_cmd);`
66			`register_ata_command ("enable", "", "Enables ATA host controller, clears all resets", ata_enable_cmd);`
67			`register_ata_command ("dump_dev_regs", "", "Dump the (readable) ata device registers.", ata_dump_device_regs_cmd);`
68			`register_ata_command ("dump_host_regs", "", "Dump the ata host registers.", ata_dump_host_regs_cmd);`
69			`register_ata_command ("exec_cmd", "<cmd>", "Execute ata command <cmd> (hex)", ata_exec_cmd_cmd);`
70			`register_ata_command ("identify_device", "", "Dumps device's IDENTIFY DEVICE block.", ata_identify_device_cmd);`
71			`register_ata_command ("program_timing", "<PIO mode>", "Programs the device to the selected PIO mode.", ata_set_piomode_cmd);`
72			`register_ata_command ("read_sectors", "<startsector> [<sectorcount>]", "Reads sector", ata_read_sectors_cmd);`
73			`register_ata_command ("read_mbr", "<partition>", "Reads the Master Boot Record.", ata_read_mbr_cmd);`
74			`register_ata_command ("read_dosboot", "<sector>", "Reads the device's bootsector (FAT).", ata_read_dosboot_cmd);`
75			`register_ata_command ("select_device", "<device_no>", "Select ata device. device_no=<0\|1>", ata_select_device_cmd);`
76			`}`
77
78
79			`int atabug(int argc, char **argv)`
80			`{`
81
82			`/* take care of commandline options */`
83			`if (argc == 0)`
84			`{`
85			`/* start atabug */`
86			`while ( !ata_mon_command() );`
87			`}`
88			`else`
89			`return execute_ata_command(argv[0], argc -1, &argv[1]);`
90
91			`return 0;`
92			`}`
93
94			`int atabug_exit(int argc, char **argv)`
95			`{`
96			`ata_close_cmd(argc, argv);`
97			`return -2;`
98			`}`
99
100			`/*`
101			`The next code is graceously taken from the "common.c" file`
102			`and slightly modified to suit the big list of ATA commands`
103
104			`Better would be if we could access the routines in 'common.c'`
105			`directly, using our own set of commands.`
106			`*/`
107
108			`/* Process command-line, generate arguments */`
109			`int ata_mon_command(void)`
110			`{`
111			`char c = '\0';`
112			`char str[1000];`
113			`char *pstr = str;`
114			`char *command_str;`
115			`char *argv[20];`
116			`int argc = 0;`
117
118
119			`/* Show prompt */`
120			`printf ("\natabug> ");`
121
122
123			`/* Get characters from UART */`
124			`c = getc();`
125			`while (c != '\r' && c != '\f' && c != '\n')`
126			`{`
127			`if (c == '\b')`
128			`pstr--;`
129			`else`
130			`*pstr++ = c;`
131			`putc(c);`
132			`c = getc();`
133			`}`
134			`*pstr = '\0';`
135			`printf ("\n");`
136
137			`/* Skip leading blanks */`
138			`pstr = str;`
139			`while ( isspace(*pstr) ) pstr++;`
140
141			`/* Get command from the string */`
142			`command_str = pstr;`
143
144			`while (1) {`
145			`/* Go to next argument */`
146			`while ( isgraph(*pstr) ) pstr++;`
147			`if (*pstr) {`
148			`*pstr++ = '\0';`
149			`while ( isspace(*pstr) ) pstr++;`
150			`argv[argc++] = pstr;`
151			`}`
152			`else`
153			`break;`
154			`}`
155
156			`return execute_ata_command(command_str, argc, argv);`
157			`}`
158
159
160			`int execute_ata_command(char command_str, int argc, char *argv)`
161			`{`
162			`int i, found = 0;`
163
164			`for (i = 0; i < ata_num_commands; i++)`
165			`if ( !strcmp(command_str, ata_command[i].name) )`
166			`{`
167			`switch ( ata_command[i].func(argc, argv) )`
168			`{`
169			`case -1:`
170			`printf ("Missing/wrong parameters, usage: %s %s\n", ata_command[i].name, ata_command[i].params);`
171			`break;`
172
173			`case -2:`
174			`return -1;`
175			`}`
176
177			`found++;`
178			`break;`
179			`}`
180
181			`if (!found)`
182			`printf ("Unknown command. Type 'ata help' for help.\n");`
183
184			`return 0;`
185			`}`
186
187
188			`void register_ata_command (const char name, const char params, const char help, int (func)(int argc, char *argv[]) )`
189			`{`
190			`if (ata_num_commands < MAX_ATA_COMMANDS)`
191			`{`
192			`ata_command[ata_num_commands].name = name;`
193			`ata_command[ata_num_commands].params = params;`
194			`ata_command[ata_num_commands].help = help;`
195			`ata_command[ata_num_commands].func = func;`
196			`ata_num_commands++;`
197			`}`
198			`else`
199			`printf ("ata-command '%s' ignored; MAX_COMMANDS limit reached\n", name);`
200			`}`
201
202			`int atabug_help(int argc, char **argv)`
203			`{`
204			`int i;`
205
206			`for (i = 0; i < ata_num_commands; i++)`
207			`printf ("%-15s %-17s -%s\n", ata_command[i].name, ata_command[i].params, ata_command[i].help);`
208
209			`return 0;`
210			`}`
211
212
213
214
215			`/**********************************************************************/`
216			`/* */`
217			`/* A T A B U G C O M M A N D S E T */`
218			`/* */`
219			`/**********************************************************************/`
220
221			`/*`
222			`A T A _ C L O S E`
223
224			`closes the ata_device`
225			`*/`
226			`int ata_close_cmd(int argc, char **argv)`
227			`{`
228			`inode->i_rdev = (ATA_BASE_ADDR >> 16) \| (*argv[0] - '0');`
229
230			`return ata_release(inode, filp);`
231			`}`
232
233
234			`/*`
235			`A T A _ D U M P _ D E V I C E _ R E G S`
236
237			`Dumps the (readable) ata-registers.`
238			`Exception: status register is not read, this could mask an interrupt`
239			`*/`
240			`int ata_dump_device_regs_cmd(int argc, char **argv)`
241			`{`
242			`if (argc)`
243			`printf("\nWARNING: Ignoring invalid argument(s)\n\n");`
244
245
246			`printf("Alternate status register : 0x%02lX\n", REG32(ATA_BASE_ADDR + ATA_ASR) );`
247			`printf("Cylinder high register : 0x%02lX\n", REG32(ATA_BASE_ADDR + ATA_CHR) );`
248			`printf("Cylinder low register : 0x%02lX\n", REG32(ATA_BASE_ADDR + ATA_CLR) );`
249			`printf("Device head register : 0x%02lX\n", REG32(ATA_BASE_ADDR + ATA_DHR) );`
250			`printf("Error register : 0x%02lX\n", REG32(ATA_BASE_ADDR + ATA_ERR) );`
251			`printf("Sector count register : 0x%02lX\n", REG32(ATA_BASE_ADDR + ATA_SCR) );`
252			`printf("Sector number register : 0x%02lX\n", REG32(ATA_BASE_ADDR + ATA_SNR) );`
253			`printf("Status register (see alternate status register)\n" );`
254
255			`return 0;`
256			`}`
257
258
259			`/*`
260			`A T A _ D U M P _ H O S T _ R E G S`
261
262			`Dumps the ata-host registers`
263			`*/`
264			`int ata_dump_host_regs_cmd(int argc, char **argv)`
265			`{`
266			`if (argc)`
267			`printf("\nWARNING: Ignoring invalid argument(s)\n\n");`
268
269
270			`printf("Control register CTRL : 0x%08lX\n", REG32(ATA_BASE_ADDR + ATA_CTRL) );`
271			`printf("Status register STAT : 0x%08lX\n", REG32(ATA_BASE_ADDR + ATA_STAT) );`
272			`printf("Pio command timing register PCTR : 0x%08lX\n", REG32(ATA_BASE_ADDR + ATA_PCTR) );`
273			`printf("Pio fast timing register (device0) PFTR0: 0x%08lX\n", REG32(ATA_BASE_ADDR + ATA_PFTR0) );`
274			`printf("Pio fast timing register (device1) PFTR1: 0x%08lX\n", REG32(ATA_BASE_ADDR + ATA_PFTR1) );`
275			`printf("Dma timing register (device0) DTR0 : 0x%08lX\n", REG32(ATA_BASE_ADDR + ATA_DTR0) );`
276			`printf("Dma timing register (device1) DTR1 : 0x%08lX\n", REG32(ATA_BASE_ADDR + ATA_DTR1) );`
277
278			`return 0;`
279			`}`
280
281
282			`/*`
283			`A T A _ E N A B L E`
284
285			`clears reset bits`
286			`*/`
287			`int ata_enable_cmd(int argc, char **argv)`
288			`{`
289			`if (argc != 0)`
290			`printf("Ignoring invalid parameters\n");`
291
292			`inode->i_rdev = (ATA_BASE_ADDR >> 16);`
293
294			`// clear hardware reset bit`
295			`if ( ata_ioctl(inode, filp, ATA_IOCTL_SET_RST, CLR \| ARG_HW_RST) )`
296			`return -1;`
297
298			`// clear software reset bit`
299			`if ( ata_ioctl(inode, filp, ATA_IOCTL_SET_RST, CLR \| ARG_SW_RST) )`
300			`return -1;`
301
302			`// enable ATA Hostcontroller core`
303			`if ( ata_ioctl(inode, filp, ATA_IOCTL_ENABLE_HOST, 0) )`
304			`return -1;`
305
306			`printf("ATA host controller enabled\n");`
307
308			`return 0;`
309			`}`
310
311
312			`/*`
313			`A T A _ E X E C _ C M D`
314
315			`Executes the command; writes the command number in the command register`
316			`*/`
317			`int ata_exec_cmd_cmd(int argc, char **argv)`
318			`{`
319			`if (argc != 1)`
320			`return -1;`
321
322			`inode->i_rdev = (ATA_BASE_ADDR >> 16);`
323
324			`ata_ioctl(inode, filp, ATA_IOCTL_EXEC_CMD, strtoul(*argv, argv, 16) );`
325			`return 0;`
326			`}`
327
328
329			`/*`
330			`A T A _ I D E N T I F Y _ D E V I C E`
331
332			`Reads the identify_device block and dumps it to the screen`
333			`*/`
334			`int ata_identify_device_cmd(int argc, char **argv)`
335			`{`
336			`unsigned char checksum;`
337
338			`if (argc != 0)`
339			`printf("Ignoring invalid parameters\n");`
340
341
342			`/* check for busy flag */`
343			`if ( ata_dev_busy(ATA_BASE_ADDR) )`
344			`printf("Selected ata device busy, ignoring command\n");`
345			`else`
346			`{`
347			`/* execute identify device */`
348			`ata_ioctl(inode, filp, ATA_IOCTL_EXEC_CMD, IDENTIFY_DEVICE);`
349
350			`/* read block from ata-device */`
351			`buf[0] = 0;`
352			`buf[1] = 1;`
353			`ata_ioctl(inode, filp, ATA_IOCTL_READ, (unsigned long) buf);`
354
355			`/* dump data to the screen */`
356			`checksum = atabug_dump_data(buf, 512);`
357
358			`if (buf[512] == 0xa5)`
359			`printf("Checksum = 0x%02X (%s)\n", checksum, checksum ? "error" : "OK");`
360			`else`
361			`printf("No checksum supported\n");`
362			`}`
363			`return 0;`
364			`}`
365
366
367			`/*`
368			`A T A _ O P E N`
369
370			`opens the ata_device`
371			`*/`
372			`int ata_open_cmd(int argc, char **argv)`
373			`{`
374			`inode->i_rdev = (ATA_BASE_ADDR >> 16) \| (*argv[0] - '0');`
375
376			`filp->f_mode = FMODE_READ;`
377
378			`if (*argv[1] == 'w')`
379			`filp->f_mode \|= FMODE_WRITE;`
380
381			`switch( ata_open(inode, filp) ) {`
382			`case EOPENIDEV:`
383			`printf( "Error: Invalid device (invalid MINOR %02X)\n", MINOR(inode->i_rdev) );`
384			`break;`
385
386			`case EOPENNODEV:`
387			`printf( "Error: Requested device not found\n" );`
388			`break;`
389
390			`case EOPENIHOST:`
391			`printf( "Error: Invalid host (invalid MAJOR %02X)\n", MAJOR(inode->i_rdev) );`
392			`default:`
393			`break;`
394			`}`
395
396			`return 0;`
397			`}`
398
399
400			`/*`
401			`A T A _ S E T _ P I O M O D E`
402
403			`Sets the device to the requested PIO mode`
404			`*/`
405			`int ata_set_piomode_cmd(int argc, char **argv)`
406			`{`
407			`return 0;`
408			`}`
409
410
411			`/*`
412			`A T A _ R E A D _ S E C T O R S`
413
414			`Reads 1 sector from the device and dumps it to the screen`
415			`*/`
416			`int ata_read_sectors_cmd(int argc, char **argv)`
417			`{`
418			`struct request request;`
419			`unsigned long sector_cnt, sector;`
420
421			`sector = strtoul(argv[0], argv, 10);`
422
423			`switch (argc) {`
424			`case 2:`
425			`sector_cnt = strtoul(argv[1], argv, 10);`
426			`break;`
427
428			`case 1:`
429			`sector_cnt = 1;`
430			`break;`
431
432			`default:`
433			`return -1;`
434			`}`
435
436			`if ( !sector_cnt )`
437			`{`
438			`printf( "Invalid number of sectors.\n" );`
439			`return 0;`
440			`}`
441
442			`/* check for busy flag */`
443			`if ( ata_dev_busy(ATA_BASE_ADDR) )`
444			`printf("Selected ata device busy, ignoring command\n");`
445			`else`
446			`{`
447			`/* fill the request structure */`
448			`request.cmd = READ;`
449			`request.sector = sector;`
450			`request.nr_sectors = sector_cnt;`
451			`request.buffer = buf;`
452
453			`if ( ata_request(inode, filp, &request) )`
454			`{`
455			`printf("Error while executing READ_SECTOR(S) command\n");`
456			`printf("Status register = 0x%02lX, error register = 0x%02lX\n", ata_astatus(ATA_BASE_ADDR), ata_error(ATA_BASE_ADDR) );`
457			`}`
458			`else`
459			`{`
460			`/* dump data to the screen */`
461			`atabug_dump_data(buf, 512 * sector_cnt);`
462			`}`
463			`}`
464			`return 0;`
465			`}`
466
467
468			`/*`
469			`A T A _ R E A D _ M B R`
470
471			`Reads master boot record from the device and dumps it's contents to the screen`
472			`*/`
473			`int ata_read_mbr_cmd(int argc, char **argv)`
474			`{`
475			`struct request request;`
476			`unsigned int partition;`
477
478			`// get requested partition number`
479			`partition = 0;`
480			`if (argc)`
481			`partition = strtoul(*argv, argv, 10);`
482
483			`/* check for busy flag */`
484			`if ( ata_dev_busy(ATA_BASE_ADDR) )`
485			`printf("Selected ata device busy, ignoring command\n");`
486			`else`
487			`{`
488			`/* fill the request structure */`
489			`request.cmd = READ;`
490			`request.sector = 0;`
491			`request.nr_sectors = 1;`
492			`request.buffer = buf;`
493
494			`if ( ata_request(inode, filp, &request) )`
495			`{`
496			`printf("Error while reading master boot sector.\n");`
497			`printf("Status register = 0x%02lX, error register = 0x%02lX\n", ata_astatus(ATA_BASE_ADDR), ata_error(ATA_BASE_ADDR) );`
498			`}`
499			`else`
500			`{`
501			`printf( "Skipping bootloader (446bytes)\n" );`
502			`printf( "Partition %1d:\n", partition);`
503
504			`// abuse partitionnumber to get offset in MBR record`
505			`partition *= 16;`
506			`partition += 446;`
507
508			`printf( "Bootindicator: 0x%2X (%s)\n", buf[partition], buf[partition] ? "bootable" : "non-bootable");`
509			`printf( "Partition start (head: 0x%02X cyl: 0x%03X sect: 0x%02X)\n",`
510			`buf[partition +1], (buf[partition +2] & 0xc0) << 2 \| buf[partition +3] ,buf[partition +2] & 0x3f );`
511			`printf( "Systemindicator: 0x%02X (", buf[partition +4]);`
512
513			`switch (buf[partition +4])`
514			`{`
515			`case 0: printf ("Non DOS"); break;`
516			`case 1: printf ("DOS FAT12"); break;`
517			`case 4: printf ("DOS FAT16"); break;`
518			`case 5: printf ("DOS extended"); break;`
519			`case 6: printf ("DOS >32MByte"); break;`
520
521			`default : printf ("unkown");`
522			`};`
523			`printf (")\n");`
524			`printf( "Partition end (head: 0x%02X cyl: 0x%03X sect: 0x%02X)\n",`
525			`buf[partition +5], (buf[partition +6] & 0xc0) << 2 \| buf[partition +7] ,buf[partition +6] & 0x3f );`
526			`printf( "Physical Startsector: 0x%08X\n", buf[partition +11] << 24 \|`
527			`buf[partition +10] << 16 \|`
528			`buf[partition +9] << 8 \|`
529			`buf[partition +8]);`
530			`printf( "Sector count: 0x%08X\n", buf[partition +15] << 24 \|`
531			`buf[partition +14] << 16 \|`
532			`buf[partition +13] << 8 \|`
533			`buf[partition +12]);`
534			`}`
535			`}`
536			`return 0;`
537			`}`
538
539
540			`/*`
541			`A T A _ R E A D _ D O S B O O T`
542
543			`Reads boot sector from the device and dumps it's contents to the screen`
544			`*/`
545			`int ata_read_dosboot_cmd(int argc, char **argv)`
546			`{`
547			`struct request request;`
548			`unsigned int sector;`
549			`char txt[8];`
550
551			`sector = 0;`
552			`if (argc)`
553			`sector = strtoul(*argv, argv, 0);`
554
555			`/* check for busy flag */`
556			`if ( ata_dev_busy(ATA_BASE_ADDR) )`
557			`printf("Selected ata device busy, ignoring command\n");`
558			`else`
559			`{`
560			`/* fill the request structure */`
561			`request.cmd = READ;`
562			`request.sector = sector;`
563			`request.nr_sectors = 1;`
564			`request.buffer = buf;`
565
566			`if ( ata_request(inode, filp, &request) )`
567			`{`
568			`printf("Error whilereading boot sector 0x%02X.\n", sector);`
569			`printf("Status register = 0x%02lX, error register = 0x%02lX\n", ata_astatus(ATA_BASE_ADDR), ata_error(ATA_BASE_ADDR) );`
570			`}`
571			`else`
572			`{`
573			`printf( "Reading boot sector 0x%02X\n", sector );`
574			`printf( "ID number: 0x%2X%2X%2X\n", buf[0], buf[1], buf[2] );`
575
576			`printf( "OEM-name and number: " );`
577			`memcpy(txt, &buf[3], 8);`
578			`txt[8] = '\0';`
579			`printf( "%s\n", txt );`
580
581			`printf( "Bytes per sector: %5d\n", (buf[12]<<8) \| buf[11] );`
582			`printf( "Sectors per cluster: %3d\n", buf[13] );`
583			`printf( "Reserved IM-sectors: %5d\n", (buf[15]<<8) \| buf[14] );`
584			`printf( "Number of FATs: %3d\n", buf[16] );`
585			`printf( "Number of entries in the root-directory: %5d\n", (buf[18]<<8) \| buf[17] );`
586			`printf( "Number of logical sectors: %5d\n", (buf[20]<<8) \| buf[19] );`
587			`printf( "Medium descriptor byte: %02X\n", buf[21] );`
588			`printf( "Sectors per FAT: %5d\n", (buf[23]<<8) \| buf[22] );`
589			`printf( "Sectors per track: %5d\n", (buf[25]<<8) \| buf[24] );`
590			`printf( "Number of heads: %5d\n", (buf[27]<<8) \| buf[26] );`
591			`printf( "Number of hidden sectors: %5d\n", (buf[29]<<8) \| buf[28] );`
592			`}`
593			`}`
594			`return 0;`
595			`}`
596
597
598			`/*`
599			`A T A _ R E S E T`
600
601			`resets the ATA device, using the select method`
602			`*/`
603			`int ata_reset_cmd(int argc, char **argv)`
604			`{`
605			`if (argc != 1)`
606			`return -1;`
607
608			`return ata_ioctl(inode, filp, ATA_IOCTL_SET_RST, SET \| (**argv - '0') );`
609			`}`
610
611
612			`/*`
613			`A T A _ S E L E C T _ D E V I C E`
614
615			`selects the ATA device; sets the DEV bit in the device/head register`
616			`*/`
617			`int ata_select_device_cmd(int argc, char **argv)`
618			`{`
619			`if (argc != 1)`
620			`return -1;`
621
622			`inode->i_rdev = (ATA_BASE_ADDR >> 16) \| (*argv[0] - '0');`
623
624			`ata_ioctl(inode, filp, ATA_IOCTL_SELECT_DEVICE, **argv - '0');`
625
626			`printf("Ata device %1d selected.\n", REG32(ATA_BASE_ADDR + ATA_DHR) & ATA_DHR_DEV ? 1 : 0);`
627			`return 0;`
628			`}`
629
630
631
632
633			`/**********************************************************************/`
634			`/* */`
635			`/* A T A B U G T O O L S */`
636			`/* */`
637			`/**********************************************************************/`
638
639			`/*`
640			`D U M P _ D A T A`
641
642			`dumps byte-data in a buffer of type short to the screen`
643			`and returns the byte-checksum`
644
645			`*buffer = pointer to (short)buffer`
646			`cnt = number of bytes to display`
647			`*/`
648			`unsigned char atabug_dump_data(unsigned char *buffer, int cnt)`
649			`{`
650			`int i, n, bytes_per_line = 16;`
651			`unsigned char c, checksum;`
652			`unsigned char *buf_ptr;`
653
654			`/* prepare stored data for display & calculate checksum */`
655			`checksum = 0;`
656			`buf_ptr = buffer;`
657
658			`/* display data */`
659			`for (i=0; i < cnt; i += bytes_per_line)`
660			`{`
661			`printf("%3X ", i);`
662
663			`/* print hexadecimal notation */`
664			`for (n=0; n < bytes_per_line; n++)`
665			`printf("%02X ", *buf_ptr++);`
666
667			`buf_ptr -= bytes_per_line; /* back to the start (of this block) */`
668
669			`/* print ASCII notation & calculate checksum */`
670			`for (n=0; n < bytes_per_line; n++)`
671			`{`
672			`c = *buf_ptr++;`
673			`printf("%c", isprint(c) ? c : '.');`
674			`checksum += c;`
675			`}`
676			`printf("\n");`
677			`}`
678
679			`return checksum;`
680			`}`
681
682