merge mainline into ahci
This commit is contained in:
Vladimir 'phcoder' Serbinenko
commit
de2690be7c
984 changed files with 85724 additions and 20016 deletions
620
grub-core/disk/scsi.c
Normal file
620
grub-core/disk/scsi.c
Normal file
|
|
@ -0,0 +1,620 @@
|
|||
/* scsi.c - scsi support. */
|
||||
/*
|
||||
* GRUB -- GRand Unified Bootloader
|
||||
* Copyright (C) 2008,2009 Free Software Foundation, Inc.
|
||||
*
|
||||
* GRUB 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 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* GRUB 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 GRUB. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <grub/disk.h>
|
||||
#include <grub/dl.h>
|
||||
#include <grub/kernel.h>
|
||||
#include <grub/misc.h>
|
||||
#include <grub/mm.h>
|
||||
#include <grub/types.h>
|
||||
#include <grub/scsi.h>
|
||||
#include <grub/scsicmd.h>
|
||||
#include <grub/time.h>
|
||||
|
||||
|
||||
static grub_scsi_dev_t grub_scsi_dev_list;
|
||||
|
||||
char grub_scsi_names[GRUB_SCSI_NUM_SUBSYSTEMS][5] = {
|
||||
[GRUB_SCSI_SUBSYSTEM_USBMS] = "usb",
|
||||
[GRUB_SCSI_SUBSYSTEM_PATA] = "ata",
|
||||
[GRUB_SCSI_SUBSYSTEM_AHCI] = "ahci"
|
||||
};
|
||||
|
||||
void
|
||||
grub_scsi_dev_register (grub_scsi_dev_t dev)
|
||||
{
|
||||
dev->next = grub_scsi_dev_list;
|
||||
grub_scsi_dev_list = dev;
|
||||
}
|
||||
|
||||
void
|
||||
grub_scsi_dev_unregister (grub_scsi_dev_t dev)
|
||||
{
|
||||
grub_scsi_dev_t *p, q;
|
||||
|
||||
for (p = &grub_scsi_dev_list, q = *p; q; p = &(q->next), q = q->next)
|
||||
if (q == dev)
|
||||
{
|
||||
*p = q->next;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* Check result of previous operation. */
|
||||
static grub_err_t
|
||||
grub_scsi_request_sense (grub_scsi_t scsi)
|
||||
{
|
||||
struct grub_scsi_request_sense rs;
|
||||
struct grub_scsi_request_sense_data rsd;
|
||||
grub_err_t err;
|
||||
|
||||
rs.opcode = grub_scsi_cmd_request_sense;
|
||||
rs.lun = scsi->lun << GRUB_SCSI_LUN_SHIFT;
|
||||
rs.reserved1 = 0;
|
||||
rs.reserved2 = 0;
|
||||
rs.alloc_length = 0x12; /* XXX: Hardcoded for now */
|
||||
rs.control = 0;
|
||||
grub_memset (rs.pad, 0, sizeof(rs.pad));
|
||||
|
||||
err = scsi->dev->read (scsi, sizeof (rs), (char *) &rs,
|
||||
sizeof (rsd), (char *) &rsd);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
/* Self commenting... */
|
||||
static grub_err_t
|
||||
grub_scsi_test_unit_ready (grub_scsi_t scsi)
|
||||
{
|
||||
struct grub_scsi_test_unit_ready tur;
|
||||
grub_err_t err;
|
||||
grub_err_t err_sense;
|
||||
|
||||
tur.opcode = grub_scsi_cmd_test_unit_ready;
|
||||
tur.lun = scsi->lun << GRUB_SCSI_LUN_SHIFT;
|
||||
tur.reserved1 = 0;
|
||||
tur.reserved2 = 0;
|
||||
tur.reserved3 = 0;
|
||||
tur.control = 0;
|
||||
grub_memset (tur.pad, 0, sizeof(tur.pad));
|
||||
|
||||
err = scsi->dev->read (scsi, sizeof (tur), (char *) &tur,
|
||||
0, NULL);
|
||||
|
||||
/* Each SCSI command should be followed by Request Sense.
|
||||
If not so, many devices STALLs or definitely freezes. */
|
||||
err_sense = grub_scsi_request_sense (scsi);
|
||||
if (err_sense != GRUB_ERR_NONE)
|
||||
grub_errno = err;
|
||||
/* err_sense is ignored for now and Request Sense Data also... */
|
||||
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
/* Determine if the device is removable and the type of the device
|
||||
SCSI. */
|
||||
static grub_err_t
|
||||
grub_scsi_inquiry (grub_scsi_t scsi)
|
||||
{
|
||||
struct grub_scsi_inquiry iq;
|
||||
struct grub_scsi_inquiry_data iqd;
|
||||
grub_err_t err;
|
||||
grub_err_t err_sense;
|
||||
|
||||
iq.opcode = grub_scsi_cmd_inquiry;
|
||||
iq.lun = scsi->lun << GRUB_SCSI_LUN_SHIFT;
|
||||
iq.page = 0;
|
||||
iq.reserved = 0;
|
||||
iq.alloc_length = 0x24; /* XXX: Hardcoded for now */
|
||||
iq.control = 0;
|
||||
grub_memset (iq.pad, 0, sizeof(iq.pad));
|
||||
|
||||
err = scsi->dev->read (scsi, sizeof (iq), (char *) &iq,
|
||||
sizeof (iqd), (char *) &iqd);
|
||||
|
||||
/* Each SCSI command should be followed by Request Sense.
|
||||
If not so, many devices STALLs or definitely freezes. */
|
||||
err_sense = grub_scsi_request_sense (scsi);
|
||||
if (err_sense != GRUB_ERR_NONE)
|
||||
grub_errno = err;
|
||||
/* err_sense is ignored for now and Request Sense Data also... */
|
||||
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
scsi->devtype = iqd.devtype & GRUB_SCSI_DEVTYPE_MASK;
|
||||
scsi->removable = iqd.rmb >> GRUB_SCSI_REMOVABLE_BIT;
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
/* Read the capacity and block size of SCSI. */
|
||||
static grub_err_t
|
||||
grub_scsi_read_capacity (grub_scsi_t scsi)
|
||||
{
|
||||
struct grub_scsi_read_capacity rc;
|
||||
struct grub_scsi_read_capacity_data rcd;
|
||||
grub_err_t err;
|
||||
grub_err_t err_sense;
|
||||
|
||||
rc.opcode = grub_scsi_cmd_read_capacity;
|
||||
rc.lun = scsi->lun << GRUB_SCSI_LUN_SHIFT;
|
||||
rc.logical_block_addr = 0;
|
||||
rc.reserved1 = 0;
|
||||
rc.reserved2 = 0;
|
||||
rc.PMI = 0;
|
||||
rc.control = 0;
|
||||
rc.pad = 0;
|
||||
|
||||
err = scsi->dev->read (scsi, sizeof (rc), (char *) &rc,
|
||||
sizeof (rcd), (char *) &rcd);
|
||||
|
||||
/* Each SCSI command should be followed by Request Sense.
|
||||
If not so, many devices STALLs or definitely freezes. */
|
||||
err_sense = grub_scsi_request_sense (scsi);
|
||||
if (err_sense != GRUB_ERR_NONE)
|
||||
grub_errno = err;
|
||||
/* err_sense is ignored for now and Request Sense Data also... */
|
||||
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
scsi->size = grub_be_to_cpu32 (rcd.size);
|
||||
scsi->blocksize = grub_be_to_cpu32 (rcd.blocksize);
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
/* Send a SCSI request for DISK: read SIZE sectors starting with
|
||||
sector SECTOR to BUF. */
|
||||
static grub_err_t
|
||||
grub_scsi_read10 (grub_disk_t disk, grub_disk_addr_t sector,
|
||||
grub_size_t size, char *buf)
|
||||
{
|
||||
grub_scsi_t scsi;
|
||||
struct grub_scsi_read10 rd;
|
||||
grub_err_t err;
|
||||
grub_err_t err_sense;
|
||||
|
||||
scsi = disk->data;
|
||||
|
||||
rd.opcode = grub_scsi_cmd_read10;
|
||||
rd.lun = scsi->lun << GRUB_SCSI_LUN_SHIFT;
|
||||
rd.lba = grub_cpu_to_be32 (sector);
|
||||
rd.reserved = 0;
|
||||
rd.size = grub_cpu_to_be16 (size);
|
||||
rd.reserved2 = 0;
|
||||
rd.pad = 0;
|
||||
|
||||
err = scsi->dev->read (scsi, sizeof (rd), (char *) &rd, size * scsi->blocksize, buf);
|
||||
|
||||
/* Each SCSI command should be followed by Request Sense.
|
||||
If not so, many devices STALLs or definitely freezes. */
|
||||
err_sense = grub_scsi_request_sense (scsi);
|
||||
if (err_sense != GRUB_ERR_NONE)
|
||||
grub_errno = err;
|
||||
/* err_sense is ignored for now and Request Sense Data also... */
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
/* Send a SCSI request for DISK: read SIZE sectors starting with
|
||||
sector SECTOR to BUF. */
|
||||
static grub_err_t
|
||||
grub_scsi_read12 (grub_disk_t disk, grub_disk_addr_t sector,
|
||||
grub_size_t size, char *buf)
|
||||
{
|
||||
grub_scsi_t scsi;
|
||||
struct grub_scsi_read12 rd;
|
||||
grub_err_t err;
|
||||
grub_err_t err_sense;
|
||||
|
||||
scsi = disk->data;
|
||||
|
||||
rd.opcode = grub_scsi_cmd_read12;
|
||||
rd.lun = scsi->lun << GRUB_SCSI_LUN_SHIFT;
|
||||
rd.lba = grub_cpu_to_be32 (sector);
|
||||
rd.size = grub_cpu_to_be32 (size);
|
||||
rd.reserved = 0;
|
||||
rd.control = 0;
|
||||
|
||||
err = scsi->dev->read (scsi, sizeof (rd), (char *) &rd, size * scsi->blocksize, buf);
|
||||
|
||||
/* Each SCSI command should be followed by Request Sense.
|
||||
If not so, many devices STALLs or definitely freezes. */
|
||||
err_sense = grub_scsi_request_sense (scsi);
|
||||
if (err_sense != GRUB_ERR_NONE)
|
||||
grub_errno = err;
|
||||
/* err_sense is ignored for now and Request Sense Data also... */
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
#if 0
|
||||
/* Send a SCSI request for DISK: write the data stored in BUF to SIZE
|
||||
sectors starting with SECTOR. */
|
||||
static grub_err_t
|
||||
grub_scsi_write10 (grub_disk_t disk, grub_disk_addr_t sector,
|
||||
grub_size_t size, char *buf)
|
||||
{
|
||||
grub_scsi_t scsi;
|
||||
struct grub_scsi_write10 wr;
|
||||
grub_err_t err;
|
||||
grub_err_t err_sense;
|
||||
|
||||
scsi = disk->data;
|
||||
|
||||
wr.opcode = grub_scsi_cmd_write10;
|
||||
wr.lun = scsi->lun << GRUB_SCSI_LUN_SHIFT;
|
||||
wr.lba = grub_cpu_to_be32 (sector);
|
||||
wr.reserved = 0;
|
||||
wr.size = grub_cpu_to_be16 (size);
|
||||
wr.reserved2 = 0;
|
||||
wr.pad = 0;
|
||||
|
||||
err = scsi->dev->write (scsi, sizeof (wr), (char *) &wr, size * scsi->blocksize, buf);
|
||||
|
||||
/* Each SCSI command should be followed by Request Sense.
|
||||
If not so, many devices STALLs or definitely freezes. */
|
||||
err_sense = grub_scsi_request_sense (scsi);
|
||||
if (err_sense != GRUB_ERR_NONE)
|
||||
grub_errno = err;
|
||||
/* err_sense is ignored for now and Request Sense Data also... */
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
/* Send a SCSI request for DISK: write the data stored in BUF to SIZE
|
||||
sectors starting with SECTOR. */
|
||||
static grub_err_t
|
||||
grub_scsi_write12 (grub_disk_t disk, grub_disk_addr_t sector,
|
||||
grub_size_t size, char *buf)
|
||||
{
|
||||
grub_scsi_t scsi;
|
||||
struct grub_scsi_write12 wr;
|
||||
grub_err_t err;
|
||||
grub_err_t err_sense;
|
||||
|
||||
scsi = disk->data;
|
||||
|
||||
wr.opcode = grub_scsi_cmd_write12;
|
||||
wr.lun = scsi->lun << GRUB_SCSI_LUN_SHIFT;
|
||||
wr.lba = grub_cpu_to_be32 (sector);
|
||||
wr.size = grub_cpu_to_be32 (size);
|
||||
wr.reserved = 0;
|
||||
wr.control = 0;
|
||||
|
||||
err = scsi->dev->write (scsi, sizeof (wr), (char *) &wr, size * scsi->blocksize, buf);
|
||||
|
||||
/* Each SCSI command should be followed by Request Sense.
|
||||
If not so, many devices STALLs or definitely freezes. */
|
||||
err_sense = grub_scsi_request_sense (scsi);
|
||||
if (err_sense != GRUB_ERR_NONE)
|
||||
grub_errno = err;
|
||||
/* err_sense is ignored for now and Request Sense Data also... */
|
||||
|
||||
return err;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
static int
|
||||
grub_scsi_iterate (int (*hook) (const char *name))
|
||||
{
|
||||
grub_scsi_dev_t p;
|
||||
|
||||
auto int scsi_iterate (int id, int bus, int luns);
|
||||
|
||||
int scsi_iterate (int id, int bus, int luns)
|
||||
{
|
||||
int i;
|
||||
|
||||
/* In case of a single LUN, just return `usbX'. */
|
||||
if (luns == 1)
|
||||
{
|
||||
char *sname;
|
||||
int ret;
|
||||
sname = grub_xasprintf ("%s%d", grub_scsi_names[id], bus);
|
||||
if (!sname)
|
||||
return 1;
|
||||
ret = hook (sname);
|
||||
grub_free (sname);
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* In case of multiple LUNs, every LUN will get a prefix to
|
||||
distinguish it. */
|
||||
for (i = 0; i < luns; i++)
|
||||
{
|
||||
char *sname;
|
||||
int ret;
|
||||
sname = grub_xasprintf ("%s%d%c", grub_scsi_names[id], bus, 'a' + i);
|
||||
if (!sname)
|
||||
return 1;
|
||||
ret = hook (sname);
|
||||
grub_free (sname);
|
||||
if (ret)
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
for (p = grub_scsi_dev_list; p; p = p->next)
|
||||
if (p->iterate && (p->iterate) (scsi_iterate))
|
||||
return 1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_scsi_open (const char *name, grub_disk_t disk)
|
||||
{
|
||||
grub_scsi_dev_t p;
|
||||
grub_scsi_t scsi;
|
||||
grub_err_t err;
|
||||
int lun, bus;
|
||||
grub_uint64_t maxtime;
|
||||
const char *nameend;
|
||||
unsigned id;
|
||||
|
||||
nameend = name + grub_strlen (name) - 1;
|
||||
/* Try to detect a LUN ('a'-'z'), otherwise just use the first
|
||||
LUN. */
|
||||
if (nameend >= name && *nameend >= 'a' && *nameend <= 'z')
|
||||
{
|
||||
lun = *nameend - 'a';
|
||||
nameend--;
|
||||
}
|
||||
else
|
||||
lun = 0;
|
||||
|
||||
while (nameend >= name && grub_isdigit (*nameend))
|
||||
nameend--;
|
||||
|
||||
if (!nameend[1] || !grub_isdigit (nameend[1]))
|
||||
return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "not a SCSI disk");
|
||||
|
||||
bus = grub_strtoul (nameend + 1, 0, 0);
|
||||
|
||||
scsi = grub_malloc (sizeof (*scsi));
|
||||
if (! scsi)
|
||||
return grub_errno;
|
||||
|
||||
for (id = 0; id < ARRAY_SIZE (grub_scsi_names); id++)
|
||||
if (grub_strncmp (grub_scsi_names[id], name, nameend - name) == 0)
|
||||
break;
|
||||
|
||||
if (id == ARRAY_SIZE (grub_scsi_names))
|
||||
{
|
||||
grub_free (scsi);
|
||||
return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "not a SCSI disk");
|
||||
}
|
||||
|
||||
for (p = grub_scsi_dev_list; p; p = p->next)
|
||||
{
|
||||
if (p->open (id, bus, scsi))
|
||||
{
|
||||
grub_errno = GRUB_ERR_NONE;
|
||||
continue;
|
||||
}
|
||||
|
||||
disk->id = grub_make_scsi_id (id, bus, lun);
|
||||
disk->data = scsi;
|
||||
scsi->dev = p;
|
||||
scsi->lun = lun;
|
||||
scsi->bus = bus;
|
||||
|
||||
grub_dprintf ("scsi", "dev opened\n");
|
||||
|
||||
err = grub_scsi_inquiry (scsi);
|
||||
if (err)
|
||||
{
|
||||
grub_free (scsi);
|
||||
grub_dprintf ("scsi", "inquiry failed\n");
|
||||
return err;
|
||||
}
|
||||
|
||||
grub_dprintf ("scsi", "inquiry: devtype=0x%02x removable=%d\n",
|
||||
scsi->devtype, scsi->removable);
|
||||
|
||||
/* Try to be conservative about the device types
|
||||
supported. */
|
||||
if (scsi->devtype != grub_scsi_devtype_direct
|
||||
&& scsi->devtype != grub_scsi_devtype_cdrom)
|
||||
{
|
||||
grub_free (scsi);
|
||||
return grub_error (GRUB_ERR_UNKNOWN_DEVICE,
|
||||
"unknown SCSI device");
|
||||
}
|
||||
|
||||
/* According to USB MS tests specification, issue Test Unit Ready
|
||||
* until OK */
|
||||
maxtime = grub_get_time_ms () + 5000; /* It is safer value */
|
||||
do
|
||||
{
|
||||
/* Timeout is necessary - for example in case when we have
|
||||
* universal card reader with more LUNs and we have only
|
||||
* one card inserted (or none), so only one LUN (or none)
|
||||
* will be ready - and we want not to hang... */
|
||||
if (grub_get_time_ms () > maxtime)
|
||||
{
|
||||
err = GRUB_ERR_READ_ERROR;
|
||||
grub_free (scsi);
|
||||
grub_dprintf ("scsi", "LUN is not ready - timeout\n");
|
||||
return err;
|
||||
}
|
||||
err = grub_scsi_test_unit_ready (scsi);
|
||||
}
|
||||
while (err == GRUB_ERR_READ_ERROR);
|
||||
/* Reset grub_errno !
|
||||
* It is set to some error code in loop before... */
|
||||
grub_errno = GRUB_ERR_NONE;
|
||||
|
||||
/* Read capacity of media */
|
||||
err = grub_scsi_read_capacity (scsi);
|
||||
if (err)
|
||||
{
|
||||
grub_free (scsi);
|
||||
grub_dprintf ("scsi", "READ CAPACITY failed\n");
|
||||
return err;
|
||||
}
|
||||
|
||||
/* SCSI blocks can be something else than 512, although GRUB
|
||||
wants 512 byte blocks. */
|
||||
disk->total_sectors = ((grub_uint64_t)scsi->size
|
||||
* (grub_uint64_t)scsi->blocksize)
|
||||
>> GRUB_DISK_SECTOR_BITS;
|
||||
|
||||
grub_dprintf ("scsi", "blocks=%u, blocksize=%u\n",
|
||||
scsi->size, scsi->blocksize);
|
||||
grub_dprintf ("scsi", "Disk total 512 sectors = %llu\n",
|
||||
(unsigned long long) disk->total_sectors);
|
||||
|
||||
return GRUB_ERR_NONE;
|
||||
}
|
||||
|
||||
grub_free (scsi);
|
||||
return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "not a SCSI disk");
|
||||
}
|
||||
|
||||
static void
|
||||
grub_scsi_close (grub_disk_t disk)
|
||||
{
|
||||
grub_scsi_t scsi;
|
||||
|
||||
scsi = disk->data;
|
||||
if (scsi->dev->close)
|
||||
scsi->dev->close (scsi);
|
||||
grub_free (scsi);
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_scsi_read (grub_disk_t disk, grub_disk_addr_t sector,
|
||||
grub_size_t size, char *buf)
|
||||
{
|
||||
grub_scsi_t scsi;
|
||||
|
||||
scsi = disk->data;
|
||||
|
||||
/* SCSI sectors are variable in size. GRUB uses 512 byte
|
||||
sectors. */
|
||||
if (scsi->blocksize != GRUB_DISK_SECTOR_SIZE)
|
||||
{
|
||||
unsigned spb = scsi->blocksize >> GRUB_DISK_SECTOR_BITS;
|
||||
if (! (spb != 0 && (scsi->blocksize & GRUB_DISK_SECTOR_SIZE) == 0))
|
||||
return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
|
||||
"unsupported SCSI block size");
|
||||
|
||||
grub_uint32_t sector_mod = 0;
|
||||
sector = grub_divmod64 (sector, spb, §or_mod);
|
||||
|
||||
if (! (sector_mod == 0 && size % spb == 0))
|
||||
return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
|
||||
"unaligned SCSI read not supported");
|
||||
|
||||
size /= spb;
|
||||
}
|
||||
|
||||
/* Depending on the type, select a read function. */
|
||||
switch (scsi->devtype)
|
||||
{
|
||||
case grub_scsi_devtype_direct:
|
||||
return grub_scsi_read10 (disk, sector, size, buf);
|
||||
|
||||
case grub_scsi_devtype_cdrom:
|
||||
return grub_scsi_read12 (disk, sector, size, buf);
|
||||
}
|
||||
|
||||
/* XXX: Never reached. */
|
||||
return GRUB_ERR_NONE;
|
||||
|
||||
#if 0 /* Workaround - it works - but very slowly, from some reason
|
||||
* unknown to me (specially on OHCI). Do not use it. */
|
||||
/* Split transfer requests to device sector size because */
|
||||
/* some devices are not able to transfer more than 512-1024 bytes */
|
||||
grub_err_t err = GRUB_ERR_NONE;
|
||||
|
||||
for ( ; size; size--)
|
||||
{
|
||||
/* Depending on the type, select a read function. */
|
||||
switch (scsi->devtype)
|
||||
{
|
||||
case grub_scsi_devtype_direct:
|
||||
err = grub_scsi_read10 (disk, sector, 1, buf);
|
||||
break;
|
||||
|
||||
case grub_scsi_devtype_cdrom:
|
||||
err = grub_scsi_read12 (disk, sector, 1, buf);
|
||||
break;
|
||||
|
||||
default: /* This should not happen */
|
||||
return GRUB_ERR_READ_ERROR;
|
||||
}
|
||||
if (err)
|
||||
return err;
|
||||
sector++;
|
||||
buf += scsi->blocksize;
|
||||
}
|
||||
|
||||
return err;
|
||||
#endif
|
||||
}
|
||||
|
||||
static grub_err_t
|
||||
grub_scsi_write (grub_disk_t disk __attribute((unused)),
|
||||
grub_disk_addr_t sector __attribute((unused)),
|
||||
grub_size_t size __attribute((unused)),
|
||||
const char *buf __attribute((unused)))
|
||||
{
|
||||
#if 0
|
||||
/* XXX: Not tested yet! */
|
||||
|
||||
/* XXX: This should depend on the device type? */
|
||||
return grub_scsi_write10 (disk, sector, size, buf);
|
||||
#endif
|
||||
return GRUB_ERR_NOT_IMPLEMENTED_YET;
|
||||
}
|
||||
|
||||
|
||||
static struct grub_disk_dev grub_scsi_dev =
|
||||
{
|
||||
.name = "scsi",
|
||||
.id = GRUB_DISK_DEVICE_SCSI_ID,
|
||||
.iterate = grub_scsi_iterate,
|
||||
.open = grub_scsi_open,
|
||||
.close = grub_scsi_close,
|
||||
.read = grub_scsi_read,
|
||||
.write = grub_scsi_write,
|
||||
.next = 0
|
||||
};
|
||||
|
||||
GRUB_MOD_INIT(scsi)
|
||||
{
|
||||
grub_disk_dev_register (&grub_scsi_dev);
|
||||
}
|
||||
|
||||
GRUB_MOD_FINI(scsi)
|
||||
{
|
||||
grub_disk_dev_unregister (&grub_scsi_dev);
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue