URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

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

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;
}

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			`#include "support.h"`
23			`#include "common.h"`
24			`#include "atabug.h"`
25			`#include "ata.h"`
26
27			`#include <ctype.h>`
28
29			`static int ata_num_commands;`
30			`static command_struct ata_command[MAX_ATA_COMMANDS];`
31
32			`/* inode struct for ata */`
33			`static struct inode _inode;`
34			`static struct inode *inode = &_inode;`
35
36			`/* file struct for ata */`
37			`static struct file _filp;`
38			`static struct file *filp = &_filp;`
39
40			`/* buffer for ata-data */`
41			`static unsigned char buf[512];`
42
43			`/**********************************************************************/`
44			`/* */`
45			`/* A T A B U G */`
46			`/* */`
47			`/**********************************************************************/`
48			`/*`
49			`A T A _ I N I T`
50
51			`initializes the ATA core, and registers it with ORPmon`
52			`*/`
53	406	julius	`void module_ata_init(void)`
54	2	marcus.erl	`{`
55	406	julius	`ata_num_commands = 0;`
56	2	marcus.erl
57	406	julius	`register_command("atabug", "",`
58			`"ATA debugger. Type 'atabug help' for help", atabug);`
59	2	marcus.erl
60	406	julius	`register_ata_command("help", "", "Display this help message",`
61			`atabug_help);`
62			`register_ata_command("exit", "", "Exit atabug and return to ORPmon",`
63			`atabug_exit);`
64			`register_ata_command("open", "<device> [<mode>]",`
65			`"Opens the requested device. Device=<0\|1>, Mode=<r>eadonly\|read<w>rite.",`
66			`ata_open_cmd);`
67			`register_ata_command("close", "", "Closes the device.", ata_close_cmd);`
68			`register_ata_command("reset", "<mode>", "Reset ata device(s).",`
69			`ata_reset_cmd);`
70			`register_ata_command("enable", "",`
71			`"Enables ATA host controller, clears all resets",`
72			`ata_enable_cmd);`
73			`register_ata_command("dump_dev_regs", "",`
74			`"Dump the (readable) ata device registers.",`
75			`ata_dump_device_regs_cmd);`
76			`register_ata_command("dump_host_regs", "",`
77			`"Dump the ata host registers.",`
78			`ata_dump_host_regs_cmd);`
79			`register_ata_command("exec_cmd", "<cmd>",`
80			`"Execute ata command <cmd> (hex)",`
81			`ata_exec_cmd_cmd);`
82			`register_ata_command("identify_device", "",`
83			`"Dumps device's IDENTIFY DEVICE block.",`
84			`ata_identify_device_cmd);`
85			`register_ata_command("program_timing", "<PIO mode>",`
86			`"Programs the device to the selected PIO mode.",`
87			`ata_set_piomode_cmd);`
88			`register_ata_command("read_sectors", "<startsector> [<sectorcount>]",`
89			`"Reads sector", ata_read_sectors_cmd);`
90			`register_ata_command("read_mbr", "<partition>",`
91			`"Reads the Master Boot Record.", ata_read_mbr_cmd);`
92			`register_ata_command("read_dosboot", "<sector>",`
93			`"Reads the device's bootsector (FAT).",`
94			`ata_read_dosboot_cmd);`
95			`register_ata_command("select_device", "<device_no>",`
96			`"Select ata device. device_no=<0\|1>",`
97			`ata_select_device_cmd);`
98	2	marcus.erl	`}`
99
100			`int atabug(int argc, char **argv)`
101			`{`
102
103	406	julius	`/* take care of commandline options */`
104			`if (argc == 0) {`
105			`/* start atabug */`
106			`while (!ata_mon_command()) ;`
107			`} else`
108			`return execute_ata_command(argv[0], argc - 1, &argv[1]);`
109	2	marcus.erl
110	406	julius	`return 0;`
111	2	marcus.erl	`}`
112
113			`int atabug_exit(int argc, char **argv)`
114			`{`
115	406	julius	`ata_close_cmd(argc, argv);`
116			`return -2;`
117	2	marcus.erl	`}`
118
119			`/*`
120			`The next code is graceously taken from the "common.c" file`
121			`and slightly modified to suit the big list of ATA commands`
122
123			`Better would be if we could access the routines in 'common.c'`
124			`directly, using our own set of commands.`
125			`*/`
126
127			`/* Process command-line, generate arguments */`
128			`int ata_mon_command(void)`
129			`{`
130	406	julius	`char c = '\0';`
131			`char str[1000];`
132			`char *pstr = str;`
133			`char *command_str;`
134			`char *argv[20];`
135			`int argc = 0;`
136	2	marcus.erl
137	406	julius	`/* Show prompt */`
138			`printf("\natabug> ");`
139	2	marcus.erl
140	406	julius	`/* Get characters from UART */`
141			`c = getc();`
142			`while (c != '\r' && c != '\f' && c != '\n') {`
143			`if (c == '\b')`
144			`pstr--;`
145			`else`
146			`*pstr++ = c;`
147			`putc(c);`
148			`c = getc();`
149			`}`
150			`*pstr = '\0';`
151			`printf("\n");`
152	2	marcus.erl
153	406	julius	`/* Skip leading blanks */`
154			`pstr = str;`
155			`while (isspace(*pstr))`
156			`pstr++;`
157	2	marcus.erl
158	406	julius	`/* Get command from the string */`
159			`command_str = pstr;`
160	2	marcus.erl
161	406	julius	`while (1) {`
162			`/* Go to next argument */`
163			`while (isgraph(*pstr))`
164			`pstr++;`
165			`if (*pstr) {`
166			`*pstr++ = '\0';`
167			`while (isspace(*pstr))`
168			`pstr++;`
169			`argv[argc++] = pstr;`
170			`} else`
171			`break;`
172			`}`
173	2	marcus.erl
174	406	julius	`return execute_ata_command(command_str, argc, argv);`
175	2	marcus.erl	`}`
176
177			`int execute_ata_command(char command_str, int argc, char *argv)`
178			`{`
179	406	julius	`int i, found = 0;`
180	2	marcus.erl
181	406	julius	`for (i = 0; i < ata_num_commands; i++)`
182			`if (!strcmp(command_str, ata_command[i].name)) {`
183			`switch (ata_command[i].func(argc, argv)) {`
184			`case -1:`
185			`printf`
186			`("Missing/wrong parameters, usage: %s %s\n",`
187			`ata_command[i].name,`
188			`ata_command[i].params);`
189			`break;`
190	2	marcus.erl
191	406	julius	`case -2:`
192			`return -1;`
193			`}`
194	2	marcus.erl
195	406	julius	`found++;`
196			`break;`
197			`}`
198	2	marcus.erl
199	406	julius	`if (!found)`
200			`printf("Unknown command. Type 'ata help' for help.\n");`
201
202			`return 0;`
203	2	marcus.erl	`}`
204
205	406	julius	`void register_ata_command(const char name, const char params,`
206			`const char help, int (func) (int argc,`
207			`char *argv[]))`
208	2	marcus.erl	`{`
209	406	julius	`if (ata_num_commands < MAX_ATA_COMMANDS) {`
210			`ata_command[ata_num_commands].name = name;`
211			`ata_command[ata_num_commands].params = params;`
212			`ata_command[ata_num_commands].help = help;`
213			`ata_command[ata_num_commands].func = func;`
214			`ata_num_commands++;`
215			`} else`
216			`printf("ata-command '%s' ignored; MAX_COMMANDS limit reached\n",`
217			`name);`
218	2	marcus.erl	`}`
219
220			`int atabug_help(int argc, char **argv)`
221			`{`
222	406	julius	`int i;`
223	2	marcus.erl
224	406	julius	`for (i = 0; i < ata_num_commands; i++)`
225			`printf("%-15s %-17s -%s\n", ata_command[i].name,`
226			`ata_command[i].params, ata_command[i].help);`
227	2	marcus.erl
228	406	julius	`return 0;`
229	2	marcus.erl	`}`
230
231			`/**********************************************************************/`
232			`/* */`
233			`/* A T A B U G C O M M A N D S E T */`
234			`/* */`
235			`/**********************************************************************/`
236
237			`/*`
238			`A T A _ C L O S E`
239
240			`closes the ata_device`
241			`*/`
242			`int ata_close_cmd(int argc, char **argv)`
243			`{`
244	406	julius	`inode->i_rdev = (ATA_BASE_ADDR >> 16) \| (*argv[0] - '0');`
245	2	marcus.erl
246	406	julius	`return ata_release(inode, filp);`
247	2	marcus.erl	`}`
248
249			`/*`
250			`A T A _ D U M P _ D E V I C E _ R E G S`
251
252			`Dumps the (readable) ata-registers.`
253			`Exception: status register is not read, this could mask an interrupt`
254			`*/`
255			`int ata_dump_device_regs_cmd(int argc, char **argv)`
256			`{`
257	406	julius	`if (argc)`
258			`printf("\nWARNING: Ignoring invalid argument(s)\n\n");`
259	2	marcus.erl
260	406	julius	`printf("Alternate status register : 0x%02lX\n",`
261			`REG32(ATA_BASE_ADDR + ATA_ASR));`
262			`printf("Cylinder high register : 0x%02lX\n",`
263			`REG32(ATA_BASE_ADDR + ATA_CHR));`
264			`printf("Cylinder low register : 0x%02lX\n",`
265			`REG32(ATA_BASE_ADDR + ATA_CLR));`
266			`printf("Device head register : 0x%02lX\n",`
267			`REG32(ATA_BASE_ADDR + ATA_DHR));`
268			`printf("Error register : 0x%02lX\n",`
269			`REG32(ATA_BASE_ADDR + ATA_ERR));`
270			`printf("Sector count register : 0x%02lX\n",`
271			`REG32(ATA_BASE_ADDR + ATA_SCR));`
272			`printf("Sector number register : 0x%02lX\n",`
273			`REG32(ATA_BASE_ADDR + ATA_SNR));`
274			`printf("Status register (see alternate status register)\n");`
275	2	marcus.erl
276	406	julius	`return 0;`
277	2	marcus.erl	`}`
278
279			`/*`
280			`A T A _ D U M P _ H O S T _ R E G S`
281
282			`Dumps the ata-host registers`
283			`*/`
284			`int ata_dump_host_regs_cmd(int argc, char **argv)`
285			`{`
286	406	julius	`if (argc)`
287			`printf("\nWARNING: Ignoring invalid argument(s)\n\n");`
288	2	marcus.erl
289	406	julius	`printf("Control register CTRL : 0x%08lX\n",`
290			`REG32(ATA_BASE_ADDR + ATA_CTRL));`
291			`printf("Status register STAT : 0x%08lX\n",`
292			`REG32(ATA_BASE_ADDR + ATA_STAT));`
293			`printf("Pio command timing register PCTR : 0x%08lX\n",`
294			`REG32(ATA_BASE_ADDR + ATA_PCTR));`
295			`printf("Pio fast timing register (device0) PFTR0: 0x%08lX\n",`
296			`REG32(ATA_BASE_ADDR + ATA_PFTR0));`
297			`printf("Pio fast timing register (device1) PFTR1: 0x%08lX\n",`
298			`REG32(ATA_BASE_ADDR + ATA_PFTR1));`
299			`printf("Dma timing register (device0) DTR0 : 0x%08lX\n",`
300			`REG32(ATA_BASE_ADDR + ATA_DTR0));`
301			`printf("Dma timing register (device1) DTR1 : 0x%08lX\n",`
302			`REG32(ATA_BASE_ADDR + ATA_DTR1));`
303	2	marcus.erl
304	406	julius	`return 0;`
305	2	marcus.erl	`}`
306
307			`/*`
308			`A T A _ E N A B L E`
309
310			`clears reset bits`
311			`*/`
312			`int ata_enable_cmd(int argc, char **argv)`
313			`{`
314	406	julius	`if (argc != 0)`
315			`printf("Ignoring invalid parameters\n");`
316	2	marcus.erl
317	406	julius	`inode->i_rdev = (ATA_BASE_ADDR >> 16);`
318	2	marcus.erl
319	406	julius	`// clear hardware reset bit`
320			`if (ata_ioctl(inode, filp, ATA_IOCTL_SET_RST, CLR \| ARG_HW_RST))`
321			`return -1;`
322	2	marcus.erl
323	406	julius	`// clear software reset bit`
324			`if (ata_ioctl(inode, filp, ATA_IOCTL_SET_RST, CLR \| ARG_SW_RST))`
325			`return -1;`
326	2	marcus.erl
327	406	julius	`// enable ATA Hostcontroller core`
328			`if (ata_ioctl(inode, filp, ATA_IOCTL_ENABLE_HOST, 0))`
329			`return -1;`
330	2	marcus.erl
331	406	julius	`printf("ATA host controller enabled\n");`
332	2	marcus.erl
333	406	julius	`return 0;`
334	2	marcus.erl	`}`
335
336			`/*`
337			`A T A _ E X E C _ C M D`
338
339			`Executes the command; writes the command number in the command register`
340			`*/`
341			`int ata_exec_cmd_cmd(int argc, char **argv)`
342			`{`
343	406	julius	`if (argc != 1)`
344			`return -1;`
345	2	marcus.erl
346	406	julius	`inode->i_rdev = (ATA_BASE_ADDR >> 16);`
347
348			`ata_ioctl(inode, filp, ATA_IOCTL_EXEC_CMD, strtoul(*argv, argv, 16));`
349			`return 0;`
350	2	marcus.erl	`}`
351
352			`/*`
353			`A T A _ I D E N T I F Y _ D E V I C E`
354
355			`Reads the identify_device block and dumps it to the screen`
356			`*/`
357			`int ata_identify_device_cmd(int argc, char **argv)`
358			`{`
359	406	julius	`unsigned char checksum;`
360	2	marcus.erl
361	406	julius	`if (argc != 0)`
362			`printf("Ignoring invalid parameters\n");`
363	2	marcus.erl
364	406	julius	`/* check for busy flag */`
365			`if (ata_dev_busy(ATA_BASE_ADDR))`
366			`printf("Selected ata device busy, ignoring command\n");`
367			`else {`
368			`/* execute identify device */`
369			`ata_ioctl(inode, filp, ATA_IOCTL_EXEC_CMD, IDENTIFY_DEVICE);`
370	2	marcus.erl
371	406	julius	`/* read block from ata-device */`
372			`buf[0] = 0;`
373			`buf[1] = 1;`
374			`ata_ioctl(inode, filp, ATA_IOCTL_READ, (unsigned long)buf);`
375	2	marcus.erl
376	406	julius	`/* dump data to the screen */`
377			`checksum = atabug_dump_data(buf, 512);`
378	2	marcus.erl
379	406	julius	`if (buf[512] == 0xa5)`
380			`printf("Checksum = 0x%02X (%s)\n", checksum,`
381			`checksum ? "error" : "OK");`
382			`else`
383			`printf("No checksum supported\n");`
384			`}`
385			`return 0;`
386	2	marcus.erl	`}`
387
388			`/*`
389			`A T A _ O P E N`
390
391			`opens the ata_device`
392			`*/`
393			`int ata_open_cmd(int argc, char **argv)`
394			`{`
395	406	julius	`inode->i_rdev = (ATA_BASE_ADDR >> 16) \| (*argv[0] - '0');`
396	2	marcus.erl
397	406	julius	`filp->f_mode = FMODE_READ;`
398	2	marcus.erl
399	406	julius	`if (*argv[1] == 'w')`
400			`filp->f_mode \|= FMODE_WRITE;`
401	2	marcus.erl
402	406	julius	`switch (ata_open(inode, filp)) {`
403			`case EOPENIDEV:`
404			`printf("Error: Invalid device (invalid MINOR %02X)\n",`
405			`MINOR(inode->i_rdev));`
406			`break;`
407	2	marcus.erl
408	406	julius	`case EOPENNODEV:`
409			`printf("Error: Requested device not found\n");`
410			`break;`
411	2	marcus.erl
412	406	julius	`case EOPENIHOST:`
413			`printf("Error: Invalid host (invalid MAJOR %02X)\n",`
414			`MAJOR(inode->i_rdev));`
415			`default:`
416			`break;`
417			`}`
418	2	marcus.erl
419	406	julius	`return 0;`
420	2	marcus.erl	`}`
421
422			`/*`
423			`A T A _ S E T _ P I O M O D E`
424
425			`Sets the device to the requested PIO mode`
426			`*/`
427			`int ata_set_piomode_cmd(int argc, char **argv)`
428			`{`
429	406	julius	`return 0;`
430	2	marcus.erl	`}`
431
432			`/*`
433			`A T A _ R E A D _ S E C T O R S`
434
435			`Reads 1 sector from the device and dumps it to the screen`
436			`*/`
437			`int ata_read_sectors_cmd(int argc, char **argv)`
438			`{`
439	406	julius	`struct request request;`
440			`unsigned long sector_cnt, sector;`
441	2	marcus.erl
442	406	julius	`sector = strtoul(argv[0], argv, 10);`
443	2	marcus.erl
444	406	julius	`switch (argc) {`
445			`case 2:`
446			`sector_cnt = strtoul(argv[1], argv, 10);`
447			`break;`
448	2	marcus.erl
449	406	julius	`case 1:`
450			`sector_cnt = 1;`
451			`break;`
452	2	marcus.erl
453	406	julius	`default:`
454			`return -1;`
455			`}`
456	2	marcus.erl
457	406	julius	`if (!sector_cnt) {`
458			`printf("Invalid number of sectors.\n");`
459			`return 0;`
460			`}`
461	2	marcus.erl
462	406	julius	`/* check for busy flag */`
463			`if (ata_dev_busy(ATA_BASE_ADDR))`
464			`printf("Selected ata device busy, ignoring command\n");`
465			`else {`
466			`/* fill the request structure */`
467			`request.cmd = READ;`
468			`request.sector = sector;`
469			`request.nr_sectors = sector_cnt;`
470			`request.buffer = buf;`
471	2	marcus.erl
472	406	julius	`if (ata_request(inode, filp, &request)) {`
473			`printf`
474			`("Error while executing READ_SECTOR(S) command\n");`
475			`printf`
476			`("Status register = 0x%02lX, error register = 0x%02lX\n",`
477			`ata_astatus(ATA_BASE_ADDR),`
478			`ata_error(ATA_BASE_ADDR));`
479			`} else {`
480			`/* dump data to the screen */`
481			`atabug_dump_data(buf, 512 * sector_cnt);`
482			`}`
483	2	marcus.erl	`}`
484	406	julius	`return 0;`
485	2	marcus.erl	`}`
486
487			`/*`
488			`A T A _ R E A D _ M B R`
489
490			`Reads master boot record from the device and dumps it's contents to the screen`
491			`*/`
492			`int ata_read_mbr_cmd(int argc, char **argv)`
493			`{`
494	406	julius	`struct request request;`
495			`unsigned int partition;`
496	2	marcus.erl
497	406	julius	`// get requested partition number`
498			`partition = 0;`
499			`if (argc)`
500			`partition = strtoul(*argv, argv, 10);`

Browse

Tools

Subversion Repositories openrisc

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