SCSI postmerge on 20180202
This is a set of three patches that depended on mq and zone changes in the block tree (now upstream). Signed-off-by: James E.J. Bottomley <jejb@linux.vnet.ibm.com> -----BEGIN PGP SIGNATURE----- iJwEABMIAEQWIQTnYEDbdso9F2cI+arnQslM7pishQUCWnSq/iYcamFtZXMuYm90 dG9tbGV5QGhhbnNlbnBhcnRuZXJzaGlwLmNvbQAKCRDnQslM7pishVRjAP4kVZ+d o2gd6CqfhQqdbps7bcGdDCTjxTVZd4w56zgRAAEA4xjO6lhPCGlGEwJVlSMmojCE rJuw2ITmWMX//V4iBmU= =YQ8Y -----END PGP SIGNATURE----- Merge tag 'scsi-postmerge' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi Pull second set of SCSI updates from James Bottomley: "This is a set of three patches that depended on mq and zone changes in the block tree (now upstream)" * tag 'scsi-postmerge' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi: scsi: sd: Remove zone write locking scsi: sd_zbc: Initialize device request queue zoned data scsi: scsi-mq-debugfs: Show more informationhifive-unleashed-5.1
Linus Torvalds
commit
abbbd0211d
|
|
@ -4,15 +4,49 @@
|
|||
#include <scsi/scsi_dbg.h>
|
||||
#include "scsi_debugfs.h"
|
||||
|
||||
#define SCSI_CMD_FLAG_NAME(name) [ilog2(SCMD_##name)] = #name
|
||||
static const char *const scsi_cmd_flags[] = {
|
||||
SCSI_CMD_FLAG_NAME(TAGGED),
|
||||
SCSI_CMD_FLAG_NAME(UNCHECKED_ISA_DMA),
|
||||
SCSI_CMD_FLAG_NAME(INITIALIZED),
|
||||
};
|
||||
#undef SCSI_CMD_FLAG_NAME
|
||||
|
||||
static int scsi_flags_show(struct seq_file *m, const unsigned long flags,
|
||||
const char *const *flag_name, int flag_name_count)
|
||||
{
|
||||
bool sep = false;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < sizeof(flags) * BITS_PER_BYTE; i++) {
|
||||
if (!(flags & BIT(i)))
|
||||
continue;
|
||||
if (sep)
|
||||
seq_puts(m, "|");
|
||||
sep = true;
|
||||
if (i < flag_name_count && flag_name[i])
|
||||
seq_puts(m, flag_name[i]);
|
||||
else
|
||||
seq_printf(m, "%d", i);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
void scsi_show_rq(struct seq_file *m, struct request *rq)
|
||||
{
|
||||
struct scsi_cmnd *cmd = container_of(scsi_req(rq), typeof(*cmd), req);
|
||||
int msecs = jiffies_to_msecs(jiffies - cmd->jiffies_at_alloc);
|
||||
int alloc_ms = jiffies_to_msecs(jiffies - cmd->jiffies_at_alloc);
|
||||
int timeout_ms = jiffies_to_msecs(rq->timeout);
|
||||
const u8 *const cdb = READ_ONCE(cmd->cmnd);
|
||||
char buf[80] = "(?)";
|
||||
|
||||
if (cdb)
|
||||
__scsi_format_command(buf, sizeof(buf), cdb, cmd->cmd_len);
|
||||
seq_printf(m, ", .cmd=%s, .retries=%d, allocated %d.%03d s ago", buf,
|
||||
cmd->retries, msecs / 1000, msecs % 1000);
|
||||
seq_printf(m, ", .cmd=%s, .retries=%d, .result = %#x, .flags=", buf,
|
||||
cmd->retries, cmd->result);
|
||||
scsi_flags_show(m, cmd->flags, scsi_cmd_flags,
|
||||
ARRAY_SIZE(scsi_cmd_flags));
|
||||
seq_printf(m, ", .timeout=%d.%03d, allocated %d.%03d s ago",
|
||||
timeout_ms / 1000, timeout_ms % 1000,
|
||||
alloc_ms / 1000, alloc_ms % 1000);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -851,16 +851,13 @@ static int sd_setup_write_zeroes_cmnd(struct scsi_cmnd *cmd)
|
|||
struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);
|
||||
u64 sector = blk_rq_pos(rq) >> (ilog2(sdp->sector_size) - 9);
|
||||
u32 nr_sectors = blk_rq_sectors(rq) >> (ilog2(sdp->sector_size) - 9);
|
||||
int ret;
|
||||
|
||||
if (!(rq->cmd_flags & REQ_NOUNMAP)) {
|
||||
switch (sdkp->zeroing_mode) {
|
||||
case SD_ZERO_WS16_UNMAP:
|
||||
ret = sd_setup_write_same16_cmnd(cmd, true);
|
||||
goto out;
|
||||
return sd_setup_write_same16_cmnd(cmd, true);
|
||||
case SD_ZERO_WS10_UNMAP:
|
||||
ret = sd_setup_write_same10_cmnd(cmd, true);
|
||||
goto out;
|
||||
return sd_setup_write_same10_cmnd(cmd, true);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -868,15 +865,9 @@ static int sd_setup_write_zeroes_cmnd(struct scsi_cmnd *cmd)
|
|||
return BLKPREP_INVALID;
|
||||
|
||||
if (sdkp->ws16 || sector > 0xffffffff || nr_sectors > 0xffff)
|
||||
ret = sd_setup_write_same16_cmnd(cmd, false);
|
||||
else
|
||||
ret = sd_setup_write_same10_cmnd(cmd, false);
|
||||
return sd_setup_write_same16_cmnd(cmd, false);
|
||||
|
||||
out:
|
||||
if (sd_is_zoned(sdkp) && ret == BLKPREP_OK)
|
||||
return sd_zbc_write_lock_zone(cmd);
|
||||
|
||||
return ret;
|
||||
return sd_setup_write_same10_cmnd(cmd, false);
|
||||
}
|
||||
|
||||
static void sd_config_write_same(struct scsi_disk *sdkp)
|
||||
|
|
@ -964,12 +955,6 @@ static int sd_setup_write_same_cmnd(struct scsi_cmnd *cmd)
|
|||
|
||||
BUG_ON(bio_offset(bio) || bio_iovec(bio).bv_len != sdp->sector_size);
|
||||
|
||||
if (sd_is_zoned(sdkp)) {
|
||||
ret = sd_zbc_write_lock_zone(cmd);
|
||||
if (ret != BLKPREP_OK)
|
||||
return ret;
|
||||
}
|
||||
|
||||
sector >>= ilog2(sdp->sector_size) - 9;
|
||||
nr_sectors >>= ilog2(sdp->sector_size) - 9;
|
||||
|
||||
|
|
@ -1004,9 +989,6 @@ static int sd_setup_write_same_cmnd(struct scsi_cmnd *cmd)
|
|||
ret = scsi_init_io(cmd);
|
||||
rq->__data_len = nr_bytes;
|
||||
|
||||
if (sd_is_zoned(sdkp) && ret != BLKPREP_OK)
|
||||
sd_zbc_write_unlock_zone(cmd);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
@ -1036,19 +1018,12 @@ static int sd_setup_read_write_cmnd(struct scsi_cmnd *SCpnt)
|
|||
sector_t threshold;
|
||||
unsigned int this_count = blk_rq_sectors(rq);
|
||||
unsigned int dif, dix;
|
||||
bool zoned_write = sd_is_zoned(sdkp) && rq_data_dir(rq) == WRITE;
|
||||
int ret;
|
||||
unsigned char protect;
|
||||
|
||||
if (zoned_write) {
|
||||
ret = sd_zbc_write_lock_zone(SCpnt);
|
||||
if (ret != BLKPREP_OK)
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = scsi_init_io(SCpnt);
|
||||
if (ret != BLKPREP_OK)
|
||||
goto out;
|
||||
return ret;
|
||||
WARN_ON_ONCE(SCpnt != rq->special);
|
||||
|
||||
/* from here on until we're complete, any goto out
|
||||
|
|
@ -1267,9 +1242,6 @@ static int sd_setup_read_write_cmnd(struct scsi_cmnd *SCpnt)
|
|||
*/
|
||||
ret = BLKPREP_OK;
|
||||
out:
|
||||
if (zoned_write && ret != BLKPREP_OK)
|
||||
sd_zbc_write_unlock_zone(SCpnt);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
@ -1314,9 +1286,6 @@ static void sd_uninit_command(struct scsi_cmnd *SCpnt)
|
|||
struct request *rq = SCpnt->request;
|
||||
u8 *cmnd;
|
||||
|
||||
if (SCpnt->flags & SCMD_ZONE_WRITE_LOCK)
|
||||
sd_zbc_write_unlock_zone(SCpnt);
|
||||
|
||||
if (rq->rq_flags & RQF_SPECIAL_PAYLOAD)
|
||||
__free_page(rq->special_vec.bv_page);
|
||||
|
||||
|
|
|
|||
|
|
@ -77,7 +77,6 @@ struct scsi_disk {
|
|||
unsigned int nr_zones;
|
||||
unsigned int zone_blocks;
|
||||
unsigned int zone_shift;
|
||||
unsigned long *zones_wlock;
|
||||
unsigned int zones_optimal_open;
|
||||
unsigned int zones_optimal_nonseq;
|
||||
unsigned int zones_max_open;
|
||||
|
|
@ -283,8 +282,6 @@ static inline int sd_is_zoned(struct scsi_disk *sdkp)
|
|||
extern int sd_zbc_read_zones(struct scsi_disk *sdkp, unsigned char *buffer);
|
||||
extern void sd_zbc_remove(struct scsi_disk *sdkp);
|
||||
extern void sd_zbc_print_zones(struct scsi_disk *sdkp);
|
||||
extern int sd_zbc_write_lock_zone(struct scsi_cmnd *cmd);
|
||||
extern void sd_zbc_write_unlock_zone(struct scsi_cmnd *cmd);
|
||||
extern int sd_zbc_setup_report_cmnd(struct scsi_cmnd *cmd);
|
||||
extern int sd_zbc_setup_reset_cmnd(struct scsi_cmnd *cmd);
|
||||
extern void sd_zbc_complete(struct scsi_cmnd *cmd, unsigned int good_bytes,
|
||||
|
|
@ -302,14 +299,6 @@ static inline void sd_zbc_remove(struct scsi_disk *sdkp) {}
|
|||
|
||||
static inline void sd_zbc_print_zones(struct scsi_disk *sdkp) {}
|
||||
|
||||
static inline int sd_zbc_write_lock_zone(struct scsi_cmnd *cmd)
|
||||
{
|
||||
/* Let the drive fail requests */
|
||||
return BLKPREP_OK;
|
||||
}
|
||||
|
||||
static inline void sd_zbc_write_unlock_zone(struct scsi_cmnd *cmd) {}
|
||||
|
||||
static inline int sd_zbc_setup_report_cmnd(struct scsi_cmnd *cmd)
|
||||
{
|
||||
return BLKPREP_INVALID;
|
||||
|
|
|
|||
|
|
@ -229,17 +229,6 @@ static inline sector_t sd_zbc_zone_sectors(struct scsi_disk *sdkp)
|
|||
return logical_to_sectors(sdkp->device, sdkp->zone_blocks);
|
||||
}
|
||||
|
||||
/**
|
||||
* sd_zbc_zone_no - Get the number of the zone conataining a sector.
|
||||
* @sdkp: The target disk
|
||||
* @sector: 512B sector address contained in the zone
|
||||
*/
|
||||
static inline unsigned int sd_zbc_zone_no(struct scsi_disk *sdkp,
|
||||
sector_t sector)
|
||||
{
|
||||
return sectors_to_logical(sdkp->device, sector) >> sdkp->zone_shift;
|
||||
}
|
||||
|
||||
/**
|
||||
* sd_zbc_setup_reset_cmnd - Prepare a RESET WRITE POINTER scsi command.
|
||||
* @cmd: the command to setup
|
||||
|
|
@ -278,78 +267,6 @@ int sd_zbc_setup_reset_cmnd(struct scsi_cmnd *cmd)
|
|||
return BLKPREP_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* sd_zbc_write_lock_zone - Write lock a sequential zone.
|
||||
* @cmd: write command
|
||||
*
|
||||
* Called from sd_init_cmd() for write requests (standard write, write same or
|
||||
* write zeroes operations). If the request target zone is not already locked,
|
||||
* the zone is locked and BLKPREP_OK returned, allowing the request to proceed
|
||||
* through dispatch in scsi_request_fn(). Otherwise, BLKPREP_DEFER is returned,
|
||||
* forcing the request to wait for the zone to be unlocked, that is, for the
|
||||
* previously issued write request targeting the same zone to complete.
|
||||
*
|
||||
* This is called from blk_peek_request() context with the queue lock held and
|
||||
* before the request is removed from the scheduler. As a result, multiple
|
||||
* contexts executing concurrently scsi_request_fn() cannot result in write
|
||||
* sequence reordering as only a single write request per zone is allowed to
|
||||
* proceed.
|
||||
*/
|
||||
int sd_zbc_write_lock_zone(struct scsi_cmnd *cmd)
|
||||
{
|
||||
struct request *rq = cmd->request;
|
||||
struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);
|
||||
sector_t sector = blk_rq_pos(rq);
|
||||
sector_t zone_sectors = sd_zbc_zone_sectors(sdkp);
|
||||
unsigned int zno = sd_zbc_zone_no(sdkp, sector);
|
||||
|
||||
/*
|
||||
* Note: Checks of the alignment of the write command on
|
||||
* logical blocks is done in sd.c
|
||||
*/
|
||||
|
||||
/* Do not allow zone boundaries crossing on host-managed drives */
|
||||
if (blk_queue_zoned_model(sdkp->disk->queue) == BLK_ZONED_HM &&
|
||||
(sector & (zone_sectors - 1)) + blk_rq_sectors(rq) > zone_sectors)
|
||||
return BLKPREP_KILL;
|
||||
|
||||
/*
|
||||
* Do not issue more than one write at a time per
|
||||
* zone. This solves write ordering problems due to
|
||||
* the unlocking of the request queue in the dispatch
|
||||
* path in the non scsi-mq case.
|
||||
*/
|
||||
if (sdkp->zones_wlock &&
|
||||
test_and_set_bit(zno, sdkp->zones_wlock))
|
||||
return BLKPREP_DEFER;
|
||||
|
||||
WARN_ON_ONCE(cmd->flags & SCMD_ZONE_WRITE_LOCK);
|
||||
cmd->flags |= SCMD_ZONE_WRITE_LOCK;
|
||||
|
||||
return BLKPREP_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* sd_zbc_write_unlock_zone - Write unlock a sequential zone.
|
||||
* @cmd: write command
|
||||
*
|
||||
* Called from sd_uninit_cmd(). Unlocking the request target zone will allow
|
||||
* dispatching the next write request for the zone.
|
||||
*/
|
||||
void sd_zbc_write_unlock_zone(struct scsi_cmnd *cmd)
|
||||
{
|
||||
struct request *rq = cmd->request;
|
||||
struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);
|
||||
|
||||
if (sdkp->zones_wlock && cmd->flags & SCMD_ZONE_WRITE_LOCK) {
|
||||
unsigned int zno = sd_zbc_zone_no(sdkp, blk_rq_pos(rq));
|
||||
WARN_ON_ONCE(!test_bit(zno, sdkp->zones_wlock));
|
||||
cmd->flags &= ~SCMD_ZONE_WRITE_LOCK;
|
||||
clear_bit_unlock(zno, sdkp->zones_wlock);
|
||||
smp_mb__after_atomic();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* sd_zbc_complete - ZBC command post processing.
|
||||
* @cmd: Completed command
|
||||
|
|
@ -586,8 +503,123 @@ out:
|
|||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* sd_zbc_alloc_zone_bitmap - Allocate a zone bitmap (one bit per zone).
|
||||
* @sdkp: The disk of the bitmap
|
||||
*/
|
||||
static inline unsigned long *sd_zbc_alloc_zone_bitmap(struct scsi_disk *sdkp)
|
||||
{
|
||||
struct request_queue *q = sdkp->disk->queue;
|
||||
|
||||
return kzalloc_node(BITS_TO_LONGS(sdkp->nr_zones)
|
||||
* sizeof(unsigned long),
|
||||
GFP_KERNEL, q->node);
|
||||
}
|
||||
|
||||
/**
|
||||
* sd_zbc_get_seq_zones - Parse report zones reply to identify sequential zones
|
||||
* @sdkp: disk used
|
||||
* @buf: report reply buffer
|
||||
* @seq_zone_bitamp: bitmap of sequential zones to set
|
||||
*
|
||||
* Parse reported zone descriptors in @buf to identify sequential zones and
|
||||
* set the reported zone bit in @seq_zones_bitmap accordingly.
|
||||
* Since read-only and offline zones cannot be written, do not
|
||||
* mark them as sequential in the bitmap.
|
||||
* Return the LBA after the last zone reported.
|
||||
*/
|
||||
static sector_t sd_zbc_get_seq_zones(struct scsi_disk *sdkp, unsigned char *buf,
|
||||
unsigned int buflen,
|
||||
unsigned long *seq_zones_bitmap)
|
||||
{
|
||||
sector_t lba, next_lba = sdkp->capacity;
|
||||
unsigned int buf_len, list_length;
|
||||
unsigned char *rec;
|
||||
u8 type, cond;
|
||||
|
||||
list_length = get_unaligned_be32(&buf[0]) + 64;
|
||||
buf_len = min(list_length, buflen);
|
||||
rec = buf + 64;
|
||||
|
||||
while (rec < buf + buf_len) {
|
||||
type = rec[0] & 0x0f;
|
||||
cond = (rec[1] >> 4) & 0xf;
|
||||
lba = get_unaligned_be64(&rec[16]);
|
||||
if (type != ZBC_ZONE_TYPE_CONV &&
|
||||
cond != ZBC_ZONE_COND_READONLY &&
|
||||
cond != ZBC_ZONE_COND_OFFLINE)
|
||||
set_bit(lba >> sdkp->zone_shift, seq_zones_bitmap);
|
||||
next_lba = lba + get_unaligned_be64(&rec[8]);
|
||||
rec += 64;
|
||||
}
|
||||
|
||||
return next_lba;
|
||||
}
|
||||
|
||||
/**
|
||||
* sd_zbc_setup_seq_zones_bitmap - Initialize the disk seq zone bitmap.
|
||||
* @sdkp: target disk
|
||||
*
|
||||
* Allocate a zone bitmap and initialize it by identifying sequential zones.
|
||||
*/
|
||||
static int sd_zbc_setup_seq_zones_bitmap(struct scsi_disk *sdkp)
|
||||
{
|
||||
struct request_queue *q = sdkp->disk->queue;
|
||||
unsigned long *seq_zones_bitmap;
|
||||
sector_t lba = 0;
|
||||
unsigned char *buf;
|
||||
int ret = -ENOMEM;
|
||||
|
||||
seq_zones_bitmap = sd_zbc_alloc_zone_bitmap(sdkp);
|
||||
if (!seq_zones_bitmap)
|
||||
return -ENOMEM;
|
||||
|
||||
buf = kmalloc(SD_ZBC_BUF_SIZE, GFP_KERNEL);
|
||||
if (!buf)
|
||||
goto out;
|
||||
|
||||
while (lba < sdkp->capacity) {
|
||||
ret = sd_zbc_report_zones(sdkp, buf, SD_ZBC_BUF_SIZE, lba);
|
||||
if (ret)
|
||||
goto out;
|
||||
lba = sd_zbc_get_seq_zones(sdkp, buf, SD_ZBC_BUF_SIZE,
|
||||
seq_zones_bitmap);
|
||||
}
|
||||
|
||||
if (lba != sdkp->capacity) {
|
||||
/* Something went wrong */
|
||||
ret = -EIO;
|
||||
}
|
||||
|
||||
out:
|
||||
kfree(buf);
|
||||
if (ret) {
|
||||
kfree(seq_zones_bitmap);
|
||||
return ret;
|
||||
}
|
||||
|
||||
q->seq_zones_bitmap = seq_zones_bitmap;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void sd_zbc_cleanup(struct scsi_disk *sdkp)
|
||||
{
|
||||
struct request_queue *q = sdkp->disk->queue;
|
||||
|
||||
kfree(q->seq_zones_bitmap);
|
||||
q->seq_zones_bitmap = NULL;
|
||||
|
||||
kfree(q->seq_zones_wlock);
|
||||
q->seq_zones_wlock = NULL;
|
||||
|
||||
q->nr_zones = 0;
|
||||
}
|
||||
|
||||
static int sd_zbc_setup(struct scsi_disk *sdkp)
|
||||
{
|
||||
struct request_queue *q = sdkp->disk->queue;
|
||||
int ret;
|
||||
|
||||
/* READ16/WRITE16 is mandatory for ZBC disks */
|
||||
sdkp->device->use_16_for_rw = 1;
|
||||
|
|
@ -599,15 +631,36 @@ static int sd_zbc_setup(struct scsi_disk *sdkp)
|
|||
sdkp->nr_zones =
|
||||
round_up(sdkp->capacity, sdkp->zone_blocks) >> sdkp->zone_shift;
|
||||
|
||||
if (!sdkp->zones_wlock) {
|
||||
sdkp->zones_wlock = kcalloc(BITS_TO_LONGS(sdkp->nr_zones),
|
||||
sizeof(unsigned long),
|
||||
GFP_KERNEL);
|
||||
if (!sdkp->zones_wlock)
|
||||
return -ENOMEM;
|
||||
/*
|
||||
* Initialize the device request queue information if the number
|
||||
* of zones changed.
|
||||
*/
|
||||
if (sdkp->nr_zones != q->nr_zones) {
|
||||
|
||||
sd_zbc_cleanup(sdkp);
|
||||
|
||||
q->nr_zones = sdkp->nr_zones;
|
||||
if (sdkp->nr_zones) {
|
||||
q->seq_zones_wlock = sd_zbc_alloc_zone_bitmap(sdkp);
|
||||
if (!q->seq_zones_wlock) {
|
||||
ret = -ENOMEM;
|
||||
goto err;
|
||||
}
|
||||
|
||||
ret = sd_zbc_setup_seq_zones_bitmap(sdkp);
|
||||
if (ret) {
|
||||
sd_zbc_cleanup(sdkp);
|
||||
goto err;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
err:
|
||||
sd_zbc_cleanup(sdkp);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int sd_zbc_read_zones(struct scsi_disk *sdkp, unsigned char *buf)
|
||||
|
|
@ -661,14 +714,14 @@ int sd_zbc_read_zones(struct scsi_disk *sdkp, unsigned char *buf)
|
|||
|
||||
err:
|
||||
sdkp->capacity = 0;
|
||||
sd_zbc_cleanup(sdkp);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
void sd_zbc_remove(struct scsi_disk *sdkp)
|
||||
{
|
||||
kfree(sdkp->zones_wlock);
|
||||
sdkp->zones_wlock = NULL;
|
||||
sd_zbc_cleanup(sdkp);
|
||||
}
|
||||
|
||||
void sd_zbc_print_zones(struct scsi_disk *sdkp)
|
||||
|
|
|
|||
|
|
@ -58,8 +58,7 @@ struct scsi_pointer {
|
|||
/* for scmd->flags */
|
||||
#define SCMD_TAGGED (1 << 0)
|
||||
#define SCMD_UNCHECKED_ISA_DMA (1 << 1)
|
||||
#define SCMD_ZONE_WRITE_LOCK (1 << 2)
|
||||
#define SCMD_INITIALIZED (1 << 3)
|
||||
#define SCMD_INITIALIZED (1 << 2)
|
||||
/* flags preserved across unprep / reprep */
|
||||
#define SCMD_PRESERVED_FLAGS (SCMD_UNCHECKED_ISA_DMA | SCMD_INITIALIZED)
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue