You've already forked linux-apfs
mirror of
https://github.com/linux-apfs/linux-apfs.git
synced 2026-05-01 15:00:59 -07:00
Merge branch 'for-3.9/drivers' of git://git.kernel.dk/linux-block
Pull block driver bits from Jens Axboe:
"After the block IO core bits are in, please grab the driver updates
from below as well. It contains:
- Fix ancient regression in dac960. Nobody must be using that
anymore...
- Some good fixes from Guo Ghao for loop, fixing both potential
oopses and deadlocks.
- Improve mtip32xx for NUMA systems, by being a bit more clever in
distributing work.
- Add IBM RamSan 70/80 driver. A second round of fixes for that is
pending, that will come in through for-linus during the 3.9 cycle
as per usual.
- A few xen-blk{back,front} fixes from Konrad and Roger.
- Other minor fixes and improvements."
* 'for-3.9/drivers' of git://git.kernel.dk/linux-block:
loopdev: ignore negative offset when calculate loop device size
loopdev: remove an user triggerable oops
loopdev: move common code into loop_figure_size()
loopdev: update block device size in loop_set_status()
loopdev: fix a deadlock
xen-blkback: use balloon pages for persistent grants
xen-blkfront: drop the use of llist_for_each_entry_safe
xen/blkback: Don't trust the handle from the frontend.
xen-blkback: do not leak mode property
block: IBM RamSan 70/80 driver fixes
rsxx: add slab.h include to dma.c
drivers/block/mtip32xx: add missing GENERIC_HARDIRQS dependency
block: remove new __devinit/exit annotations on ramsam driver
block: IBM RamSan 70/80 device driver
drivers/block/mtip32xx/mtip32xx.c:1726:5: sparse: symbol 'mtip_send_trim' was not declared. Should it be static?
drivers/block/mtip32xx/mtip32xx.c:4029:1: sparse: symbol 'mtip_workq_sdbf0' was not declared. Should it be static?
dac960: return success instead of -ENOTTY
mtip32xx: add trim support
mtip32xx: Add workqueue and NUMA support
block: delete super ancient PC-XT driver for 1980's hardware
This commit is contained in:
Linus Torvalds
@@ -7054,6 +7054,7 @@ static long DAC960_gam_ioctl(struct file *file, unsigned int Request,
|
||||
else
|
||||
ErrorCode = 0;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
ErrorCode = -ENOTTY;
|
||||
}
|
||||
|
||||
+10
-13
@@ -63,19 +63,6 @@ config AMIGA_Z2RAM
|
||||
To compile this driver as a module, choose M here: the
|
||||
module will be called z2ram.
|
||||
|
||||
config BLK_DEV_XD
|
||||
tristate "XT hard disk support"
|
||||
depends on ISA && ISA_DMA_API
|
||||
select CHECK_SIGNATURE
|
||||
help
|
||||
Very old 8 bit hard disk controllers used in the IBM XT computer
|
||||
will be supported if you say Y here.
|
||||
|
||||
To compile this driver as a module, choose M here: the
|
||||
module will be called xd.
|
||||
|
||||
It's pretty unlikely that you have one of these: say N.
|
||||
|
||||
config GDROM
|
||||
tristate "SEGA Dreamcast GD-ROM drive"
|
||||
depends on SH_DREAMCAST
|
||||
@@ -544,4 +531,14 @@ config BLK_DEV_RBD
|
||||
|
||||
If unsure, say N.
|
||||
|
||||
config BLK_DEV_RSXX
|
||||
tristate "RamSam PCIe Flash SSD Device Driver"
|
||||
depends on PCI
|
||||
help
|
||||
Device driver for IBM's high speed PCIe SSD
|
||||
storage devices: RamSan-70 and RamSan-80.
|
||||
|
||||
To compile this driver as a module, choose M here: the
|
||||
module will be called rsxx.
|
||||
|
||||
endif # BLK_DEV
|
||||
|
||||
@@ -15,7 +15,6 @@ obj-$(CONFIG_ATARI_FLOPPY) += ataflop.o
|
||||
obj-$(CONFIG_AMIGA_Z2RAM) += z2ram.o
|
||||
obj-$(CONFIG_BLK_DEV_RAM) += brd.o
|
||||
obj-$(CONFIG_BLK_DEV_LOOP) += loop.o
|
||||
obj-$(CONFIG_BLK_DEV_XD) += xd.o
|
||||
obj-$(CONFIG_BLK_CPQ_DA) += cpqarray.o
|
||||
obj-$(CONFIG_BLK_CPQ_CISS_DA) += cciss.o
|
||||
obj-$(CONFIG_BLK_DEV_DAC960) += DAC960.o
|
||||
@@ -41,4 +40,6 @@ obj-$(CONFIG_BLK_DEV_DRBD) += drbd/
|
||||
obj-$(CONFIG_BLK_DEV_RBD) += rbd.o
|
||||
obj-$(CONFIG_BLK_DEV_PCIESSD_MTIP32XX) += mtip32xx/
|
||||
|
||||
obj-$(CONFIG_BLK_DEV_RSXX) += rsxx/
|
||||
|
||||
swim_mod-y := swim.o swim_asm.o
|
||||
|
||||
+29
-32
@@ -162,12 +162,13 @@ static struct loop_func_table *xfer_funcs[MAX_LO_CRYPT] = {
|
||||
|
||||
static loff_t get_size(loff_t offset, loff_t sizelimit, struct file *file)
|
||||
{
|
||||
loff_t size, loopsize;
|
||||
loff_t loopsize;
|
||||
|
||||
/* Compute loopsize in bytes */
|
||||
size = i_size_read(file->f_mapping->host);
|
||||
loopsize = size - offset;
|
||||
/* offset is beyond i_size, wierd but possible */
|
||||
loopsize = i_size_read(file->f_mapping->host);
|
||||
if (offset > 0)
|
||||
loopsize -= offset;
|
||||
/* offset is beyond i_size, weird but possible */
|
||||
if (loopsize < 0)
|
||||
return 0;
|
||||
|
||||
@@ -190,6 +191,7 @@ figure_loop_size(struct loop_device *lo, loff_t offset, loff_t sizelimit)
|
||||
{
|
||||
loff_t size = get_size(offset, sizelimit, lo->lo_backing_file);
|
||||
sector_t x = (sector_t)size;
|
||||
struct block_device *bdev = lo->lo_device;
|
||||
|
||||
if (unlikely((loff_t)x != size))
|
||||
return -EFBIG;
|
||||
@@ -198,6 +200,9 @@ figure_loop_size(struct loop_device *lo, loff_t offset, loff_t sizelimit)
|
||||
if (lo->lo_sizelimit != sizelimit)
|
||||
lo->lo_sizelimit = sizelimit;
|
||||
set_capacity(lo->lo_disk, x);
|
||||
bd_set_size(bdev, (loff_t)get_capacity(bdev->bd_disk) << 9);
|
||||
/* let user-space know about the new size */
|
||||
kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, KOBJ_CHANGE);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -1091,10 +1096,10 @@ loop_set_status(struct loop_device *lo, const struct loop_info64 *info)
|
||||
return err;
|
||||
|
||||
if (lo->lo_offset != info->lo_offset ||
|
||||
lo->lo_sizelimit != info->lo_sizelimit) {
|
||||
lo->lo_sizelimit != info->lo_sizelimit)
|
||||
if (figure_loop_size(lo, info->lo_offset, info->lo_sizelimit))
|
||||
return -EFBIG;
|
||||
}
|
||||
|
||||
loop_config_discard(lo);
|
||||
|
||||
memcpy(lo->lo_file_name, info->lo_file_name, LO_NAME_SIZE);
|
||||
@@ -1271,28 +1276,10 @@ loop_get_status64(struct loop_device *lo, struct loop_info64 __user *arg) {
|
||||
|
||||
static int loop_set_capacity(struct loop_device *lo, struct block_device *bdev)
|
||||
{
|
||||
int err;
|
||||
sector_t sec;
|
||||
loff_t sz;
|
||||
|
||||
err = -ENXIO;
|
||||
if (unlikely(lo->lo_state != Lo_bound))
|
||||
goto out;
|
||||
err = figure_loop_size(lo, lo->lo_offset, lo->lo_sizelimit);
|
||||
if (unlikely(err))
|
||||
goto out;
|
||||
sec = get_capacity(lo->lo_disk);
|
||||
/* the width of sector_t may be narrow for bit-shift */
|
||||
sz = sec;
|
||||
sz <<= 9;
|
||||
mutex_lock(&bdev->bd_mutex);
|
||||
bd_set_size(bdev, sz);
|
||||
/* let user-space know about the new size */
|
||||
kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, KOBJ_CHANGE);
|
||||
mutex_unlock(&bdev->bd_mutex);
|
||||
return -ENXIO;
|
||||
|
||||
out:
|
||||
return err;
|
||||
return figure_loop_size(lo, lo->lo_offset, lo->lo_sizelimit);
|
||||
}
|
||||
|
||||
static int lo_ioctl(struct block_device *bdev, fmode_t mode,
|
||||
@@ -1845,11 +1832,15 @@ static int __init loop_init(void)
|
||||
max_part = (1UL << part_shift) - 1;
|
||||
}
|
||||
|
||||
if ((1UL << part_shift) > DISK_MAX_PARTS)
|
||||
return -EINVAL;
|
||||
if ((1UL << part_shift) > DISK_MAX_PARTS) {
|
||||
err = -EINVAL;
|
||||
goto misc_out;
|
||||
}
|
||||
|
||||
if (max_loop > 1UL << (MINORBITS - part_shift))
|
||||
return -EINVAL;
|
||||
if (max_loop > 1UL << (MINORBITS - part_shift)) {
|
||||
err = -EINVAL;
|
||||
goto misc_out;
|
||||
}
|
||||
|
||||
/*
|
||||
* If max_loop is specified, create that many devices upfront.
|
||||
@@ -1867,8 +1858,10 @@ static int __init loop_init(void)
|
||||
range = 1UL << MINORBITS;
|
||||
}
|
||||
|
||||
if (register_blkdev(LOOP_MAJOR, "loop"))
|
||||
return -EIO;
|
||||
if (register_blkdev(LOOP_MAJOR, "loop")) {
|
||||
err = -EIO;
|
||||
goto misc_out;
|
||||
}
|
||||
|
||||
blk_register_region(MKDEV(LOOP_MAJOR, 0), range,
|
||||
THIS_MODULE, loop_probe, NULL, NULL);
|
||||
@@ -1881,6 +1874,10 @@ static int __init loop_init(void)
|
||||
|
||||
printk(KERN_INFO "loop: module loaded\n");
|
||||
return 0;
|
||||
|
||||
misc_out:
|
||||
misc_deregister(&loop_misc);
|
||||
return err;
|
||||
}
|
||||
|
||||
static int loop_exit_cb(int id, void *ptr, void *data)
|
||||
|
||||
@@ -4,6 +4,6 @@
|
||||
|
||||
config BLK_DEV_PCIESSD_MTIP32XX
|
||||
tristate "Block Device Driver for Micron PCIe SSDs"
|
||||
depends on PCI
|
||||
depends on PCI && GENERIC_HARDIRQS
|
||||
help
|
||||
This enables the block driver for Micron PCIe SSDs.
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -164,6 +164,35 @@ struct smart_attr {
|
||||
u8 res[3];
|
||||
} __packed;
|
||||
|
||||
struct mtip_work {
|
||||
struct work_struct work;
|
||||
void *port;
|
||||
int cpu_binding;
|
||||
u32 completed;
|
||||
} ____cacheline_aligned_in_smp;
|
||||
|
||||
#define DEFINE_HANDLER(group) \
|
||||
void mtip_workq_sdbf##group(struct work_struct *work) \
|
||||
{ \
|
||||
struct mtip_work *w = (struct mtip_work *) work; \
|
||||
mtip_workq_sdbfx(w->port, group, w->completed); \
|
||||
}
|
||||
|
||||
#define MTIP_TRIM_TIMEOUT_MS 240000
|
||||
#define MTIP_MAX_TRIM_ENTRIES 8
|
||||
#define MTIP_MAX_TRIM_ENTRY_LEN 0xfff8
|
||||
|
||||
struct mtip_trim_entry {
|
||||
u32 lba; /* starting lba of region */
|
||||
u16 rsvd; /* unused */
|
||||
u16 range; /* # of 512b blocks to trim */
|
||||
} __packed;
|
||||
|
||||
struct mtip_trim {
|
||||
/* Array of regions to trim */
|
||||
struct mtip_trim_entry entry[MTIP_MAX_TRIM_ENTRIES];
|
||||
} __packed;
|
||||
|
||||
/* Register Frame Information Structure (FIS), host to device. */
|
||||
struct host_to_dev_fis {
|
||||
/*
|
||||
@@ -424,7 +453,7 @@ struct mtip_port {
|
||||
*/
|
||||
struct semaphore cmd_slot;
|
||||
/* Spinlock for working around command-issue bug. */
|
||||
spinlock_t cmd_issue_lock;
|
||||
spinlock_t cmd_issue_lock[MTIP_MAX_SLOT_GROUPS];
|
||||
};
|
||||
|
||||
/*
|
||||
@@ -447,9 +476,6 @@ struct driver_data {
|
||||
|
||||
struct mtip_port *port; /* Pointer to the port data structure. */
|
||||
|
||||
/* Tasklet used to process the bottom half of the ISR. */
|
||||
struct tasklet_struct tasklet;
|
||||
|
||||
unsigned product_type; /* magic value declaring the product type */
|
||||
|
||||
unsigned slot_groups; /* number of slot groups the product supports */
|
||||
@@ -461,6 +487,20 @@ struct driver_data {
|
||||
struct task_struct *mtip_svc_handler; /* task_struct of svc thd */
|
||||
|
||||
struct dentry *dfs_node;
|
||||
|
||||
bool trim_supp; /* flag indicating trim support */
|
||||
|
||||
int numa_node; /* NUMA support */
|
||||
|
||||
char workq_name[32];
|
||||
|
||||
struct workqueue_struct *isr_workq;
|
||||
|
||||
struct mtip_work work[MTIP_MAX_SLOT_GROUPS];
|
||||
|
||||
atomic_t irq_workers_active;
|
||||
|
||||
int isr_binding;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,2 @@
|
||||
obj-$(CONFIG_BLK_DEV_RSXX) += rsxx.o
|
||||
rsxx-y := config.o core.o cregs.o dev.o dma.o
|
||||
@@ -0,0 +1,213 @@
|
||||
/*
|
||||
* Filename: config.c
|
||||
*
|
||||
*
|
||||
* Authors: Joshua Morris <josh.h.morris@us.ibm.com>
|
||||
* Philip Kelleher <pjk1939@linux.vnet.ibm.com>
|
||||
*
|
||||
* (C) Copyright 2013 IBM Corporation
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License as
|
||||
* published by the Free Software Foundation; either version 2 of the
|
||||
* License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <linux/types.h>
|
||||
#include <linux/crc32.h>
|
||||
#include <linux/swab.h>
|
||||
|
||||
#include "rsxx_priv.h"
|
||||
#include "rsxx_cfg.h"
|
||||
|
||||
static void initialize_config(void *config)
|
||||
{
|
||||
struct rsxx_card_cfg *cfg = config;
|
||||
|
||||
cfg->hdr.version = RSXX_CFG_VERSION;
|
||||
|
||||
cfg->data.block_size = RSXX_HW_BLK_SIZE;
|
||||
cfg->data.stripe_size = RSXX_HW_BLK_SIZE;
|
||||
cfg->data.vendor_id = RSXX_VENDOR_ID_TMS_IBM;
|
||||
cfg->data.cache_order = (-1);
|
||||
cfg->data.intr_coal.mode = RSXX_INTR_COAL_DISABLED;
|
||||
cfg->data.intr_coal.count = 0;
|
||||
cfg->data.intr_coal.latency = 0;
|
||||
}
|
||||
|
||||
static u32 config_data_crc32(struct rsxx_card_cfg *cfg)
|
||||
{
|
||||
/*
|
||||
* Return the compliment of the CRC to ensure compatibility
|
||||
* (i.e. this is how early rsxx drivers did it.)
|
||||
*/
|
||||
|
||||
return ~crc32(~0, &cfg->data, sizeof(cfg->data));
|
||||
}
|
||||
|
||||
|
||||
/*----------------- Config Byte Swap Functions -------------------*/
|
||||
static void config_hdr_be_to_cpu(struct card_cfg_hdr *hdr)
|
||||
{
|
||||
hdr->version = be32_to_cpu((__force __be32) hdr->version);
|
||||
hdr->crc = be32_to_cpu((__force __be32) hdr->crc);
|
||||
}
|
||||
|
||||
static void config_hdr_cpu_to_be(struct card_cfg_hdr *hdr)
|
||||
{
|
||||
hdr->version = (__force u32) cpu_to_be32(hdr->version);
|
||||
hdr->crc = (__force u32) cpu_to_be32(hdr->crc);
|
||||
}
|
||||
|
||||
static void config_data_swab(struct rsxx_card_cfg *cfg)
|
||||
{
|
||||
u32 *data = (u32 *) &cfg->data;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < (sizeof(cfg->data) / 4); i++)
|
||||
data[i] = swab32(data[i]);
|
||||
}
|
||||
|
||||
static void config_data_le_to_cpu(struct rsxx_card_cfg *cfg)
|
||||
{
|
||||
u32 *data = (u32 *) &cfg->data;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < (sizeof(cfg->data) / 4); i++)
|
||||
data[i] = le32_to_cpu((__force __le32) data[i]);
|
||||
}
|
||||
|
||||
static void config_data_cpu_to_le(struct rsxx_card_cfg *cfg)
|
||||
{
|
||||
u32 *data = (u32 *) &cfg->data;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < (sizeof(cfg->data) / 4); i++)
|
||||
data[i] = (__force u32) cpu_to_le32(data[i]);
|
||||
}
|
||||
|
||||
|
||||
/*----------------- Config Operations ------------------*/
|
||||
static int rsxx_save_config(struct rsxx_cardinfo *card)
|
||||
{
|
||||
struct rsxx_card_cfg cfg;
|
||||
int st;
|
||||
|
||||
memcpy(&cfg, &card->config, sizeof(cfg));
|
||||
|
||||
if (unlikely(cfg.hdr.version != RSXX_CFG_VERSION)) {
|
||||
dev_err(CARD_TO_DEV(card),
|
||||
"Cannot save config with invalid version %d\n",
|
||||
cfg.hdr.version);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* Convert data to little endian for the CRC calculation. */
|
||||
config_data_cpu_to_le(&cfg);
|
||||
|
||||
cfg.hdr.crc = config_data_crc32(&cfg);
|
||||
|
||||
/*
|
||||
* Swap the data from little endian to big endian so it can be
|
||||
* stored.
|
||||
*/
|
||||
config_data_swab(&cfg);
|
||||
config_hdr_cpu_to_be(&cfg.hdr);
|
||||
|
||||
st = rsxx_creg_write(card, CREG_ADD_CONFIG, sizeof(cfg), &cfg, 1);
|
||||
if (st)
|
||||
return st;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int rsxx_load_config(struct rsxx_cardinfo *card)
|
||||
{
|
||||
int st;
|
||||
u32 crc;
|
||||
|
||||
st = rsxx_creg_read(card, CREG_ADD_CONFIG, sizeof(card->config),
|
||||
&card->config, 1);
|
||||
if (st) {
|
||||
dev_err(CARD_TO_DEV(card),
|
||||
"Failed reading card config.\n");
|
||||
return st;
|
||||
}
|
||||
|
||||
config_hdr_be_to_cpu(&card->config.hdr);
|
||||
|
||||
if (card->config.hdr.version == RSXX_CFG_VERSION) {
|
||||
/*
|
||||
* We calculate the CRC with the data in little endian, because
|
||||
* early drivers did not take big endian CPUs into account.
|
||||
* The data is always stored in big endian, so we need to byte
|
||||
* swap it before calculating the CRC.
|
||||
*/
|
||||
|
||||
config_data_swab(&card->config);
|
||||
|
||||
/* Check the CRC */
|
||||
crc = config_data_crc32(&card->config);
|
||||
if (crc != card->config.hdr.crc) {
|
||||
dev_err(CARD_TO_DEV(card),
|
||||
"Config corruption detected!\n");
|
||||
dev_info(CARD_TO_DEV(card),
|
||||
"CRC (sb x%08x is x%08x)\n",
|
||||
card->config.hdr.crc, crc);
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
/* Convert the data to CPU byteorder */
|
||||
config_data_le_to_cpu(&card->config);
|
||||
|
||||
} else if (card->config.hdr.version != 0) {
|
||||
dev_err(CARD_TO_DEV(card),
|
||||
"Invalid config version %d.\n",
|
||||
card->config.hdr.version);
|
||||
/*
|
||||
* Config version changes require special handling from the
|
||||
* user
|
||||
*/
|
||||
return -EINVAL;
|
||||
} else {
|
||||
dev_info(CARD_TO_DEV(card),
|
||||
"Initializing card configuration.\n");
|
||||
initialize_config(card);
|
||||
st = rsxx_save_config(card);
|
||||
if (st)
|
||||
return st;
|
||||
}
|
||||
|
||||
card->config_valid = 1;
|
||||
|
||||
dev_dbg(CARD_TO_DEV(card), "version: x%08x\n",
|
||||
card->config.hdr.version);
|
||||
dev_dbg(CARD_TO_DEV(card), "crc: x%08x\n",
|
||||
card->config.hdr.crc);
|
||||
dev_dbg(CARD_TO_DEV(card), "block_size: x%08x\n",
|
||||
card->config.data.block_size);
|
||||
dev_dbg(CARD_TO_DEV(card), "stripe_size: x%08x\n",
|
||||
card->config.data.stripe_size);
|
||||
dev_dbg(CARD_TO_DEV(card), "vendor_id: x%08x\n",
|
||||
card->config.data.vendor_id);
|
||||
dev_dbg(CARD_TO_DEV(card), "cache_order: x%08x\n",
|
||||
card->config.data.cache_order);
|
||||
dev_dbg(CARD_TO_DEV(card), "mode: x%08x\n",
|
||||
card->config.data.intr_coal.mode);
|
||||
dev_dbg(CARD_TO_DEV(card), "count: x%08x\n",
|
||||
card->config.data.intr_coal.count);
|
||||
dev_dbg(CARD_TO_DEV(card), "latency: x%08x\n",
|
||||
card->config.data.intr_coal.latency);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,367 @@
|
||||
/*
|
||||
* Filename: dev.c
|
||||
*
|
||||
*
|
||||
* Authors: Joshua Morris <josh.h.morris@us.ibm.com>
|
||||
* Philip Kelleher <pjk1939@linux.vnet.ibm.com>
|
||||
*
|
||||
* (C) Copyright 2013 IBM Corporation
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License as
|
||||
* published by the Free Software Foundation; either version 2 of the
|
||||
* License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/interrupt.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/pci.h>
|
||||
#include <linux/slab.h>
|
||||
|
||||
#include <linux/hdreg.h>
|
||||
#include <linux/genhd.h>
|
||||
#include <linux/blkdev.h>
|
||||
#include <linux/bio.h>
|
||||
|
||||
#include <linux/fs.h>
|
||||
|
||||
#include "rsxx_priv.h"
|
||||
|
||||
static unsigned int blkdev_minors = 64;
|
||||
module_param(blkdev_minors, uint, 0444);
|
||||
MODULE_PARM_DESC(blkdev_minors, "Number of minors(partitions)");
|
||||
|
||||
/*
|
||||
* For now I'm making this tweakable in case any applications hit this limit.
|
||||
* If you see a "bio too big" error in the log you will need to raise this
|
||||
* value.
|
||||
*/
|
||||
static unsigned int blkdev_max_hw_sectors = 1024;
|
||||
module_param(blkdev_max_hw_sectors, uint, 0444);
|
||||
MODULE_PARM_DESC(blkdev_max_hw_sectors, "Max hw sectors for a single BIO");
|
||||
|
||||
static unsigned int enable_blkdev = 1;
|
||||
module_param(enable_blkdev , uint, 0444);
|
||||
MODULE_PARM_DESC(enable_blkdev, "Enable block device interfaces");
|
||||
|
||||
|
||||
struct rsxx_bio_meta {
|
||||
struct bio *bio;
|
||||
atomic_t pending_dmas;
|
||||
atomic_t error;
|
||||
unsigned long start_time;
|
||||
};
|
||||
|
||||
static struct kmem_cache *bio_meta_pool;
|
||||
|
||||
/*----------------- Block Device Operations -----------------*/
|
||||
static int rsxx_blkdev_ioctl(struct block_device *bdev,
|
||||
fmode_t mode,
|
||||
unsigned int cmd,
|
||||
unsigned long arg)
|
||||
{
|
||||
struct rsxx_cardinfo *card = bdev->bd_disk->private_data;
|
||||
|
||||
switch (cmd) {
|
||||
case RSXX_GETREG:
|
||||
return rsxx_reg_access(card, (void __user *)arg, 1);
|
||||
case RSXX_SETREG:
|
||||
return rsxx_reg_access(card, (void __user *)arg, 0);
|
||||
}
|
||||
|
||||
return -ENOTTY;
|
||||
}
|
||||
|
||||
static int rsxx_getgeo(struct block_device *bdev, struct hd_geometry *geo)
|
||||
{
|
||||
struct rsxx_cardinfo *card = bdev->bd_disk->private_data;
|
||||
u64 blocks = card->size8 >> 9;
|
||||
|
||||
/*
|
||||
* get geometry: Fake it. I haven't found any drivers that set
|
||||
* geo->start, so we won't either.
|
||||
*/
|
||||
if (card->size8) {
|
||||
geo->heads = 64;
|
||||
geo->sectors = 16;
|
||||
do_div(blocks, (geo->heads * geo->sectors));
|
||||
geo->cylinders = blocks;
|
||||
} else {
|
||||
geo->heads = 0;
|
||||
geo->sectors = 0;
|
||||
geo->cylinders = 0;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct block_device_operations rsxx_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.getgeo = rsxx_getgeo,
|
||||
.ioctl = rsxx_blkdev_ioctl,
|
||||
};
|
||||
|
||||
static void disk_stats_start(struct rsxx_cardinfo *card, struct bio *bio)
|
||||
{
|
||||
struct hd_struct *part0 = &card->gendisk->part0;
|
||||
int rw = bio_data_dir(bio);
|
||||
int cpu;
|
||||
|
||||
cpu = part_stat_lock();
|
||||
|
||||
part_round_stats(cpu, part0);
|
||||
part_inc_in_flight(part0, rw);
|
||||
|
||||
part_stat_unlock();
|
||||
}
|
||||
|
||||
static void disk_stats_complete(struct rsxx_cardinfo *card,
|
||||
struct bio *bio,
|
||||
unsigned long start_time)
|
||||
{
|
||||
struct hd_struct *part0 = &card->gendisk->part0;
|
||||
unsigned long duration = jiffies - start_time;
|
||||
int rw = bio_data_dir(bio);
|
||||
int cpu;
|
||||
|
||||
cpu = part_stat_lock();
|
||||
|
||||
part_stat_add(cpu, part0, sectors[rw], bio_sectors(bio));
|
||||
part_stat_inc(cpu, part0, ios[rw]);
|
||||
part_stat_add(cpu, part0, ticks[rw], duration);
|
||||
|
||||
part_round_stats(cpu, part0);
|
||||
part_dec_in_flight(part0, rw);
|
||||
|
||||
part_stat_unlock();
|
||||
}
|
||||
|
||||
static void bio_dma_done_cb(struct rsxx_cardinfo *card,
|
||||
void *cb_data,
|
||||
unsigned int error)
|
||||
{
|
||||
struct rsxx_bio_meta *meta = cb_data;
|
||||
|
||||
if (error)
|
||||
atomic_set(&meta->error, 1);
|
||||
|
||||
if (atomic_dec_and_test(&meta->pending_dmas)) {
|
||||
disk_stats_complete(card, meta->bio, meta->start_time);
|
||||
|
||||
bio_endio(meta->bio, atomic_read(&meta->error) ? -EIO : 0);
|
||||
kmem_cache_free(bio_meta_pool, meta);
|
||||
}
|
||||
}
|
||||
|
||||
static void rsxx_make_request(struct request_queue *q, struct bio *bio)
|
||||
{
|
||||
struct rsxx_cardinfo *card = q->queuedata;
|
||||
struct rsxx_bio_meta *bio_meta;
|
||||
int st = -EINVAL;
|
||||
|
||||
might_sleep();
|
||||
|
||||
if (unlikely(card->halt)) {
|
||||
st = -EFAULT;
|
||||
goto req_err;
|
||||
}
|
||||
|
||||
if (unlikely(card->dma_fault)) {
|
||||
st = (-EFAULT);
|
||||
goto req_err;
|
||||
}
|
||||
|
||||
if (bio->bi_size == 0) {
|
||||
dev_err(CARD_TO_DEV(card), "size zero BIO!\n");
|
||||
goto req_err;
|
||||
}
|
||||
|
||||
bio_meta = kmem_cache_alloc(bio_meta_pool, GFP_KERNEL);
|
||||
if (!bio_meta) {
|
||||
st = -ENOMEM;
|
||||
goto req_err;
|
||||
}
|
||||
|
||||
bio_meta->bio = bio;
|
||||
atomic_set(&bio_meta->error, 0);
|
||||
atomic_set(&bio_meta->pending_dmas, 0);
|
||||
bio_meta->start_time = jiffies;
|
||||
|
||||
disk_stats_start(card, bio);
|
||||
|
||||
dev_dbg(CARD_TO_DEV(card), "BIO[%c]: meta: %p addr8: x%llx size: %d\n",
|
||||
bio_data_dir(bio) ? 'W' : 'R', bio_meta,
|
||||
(u64)bio->bi_sector << 9, bio->bi_size);
|
||||
|
||||
st = rsxx_dma_queue_bio(card, bio, &bio_meta->pending_dmas,
|
||||
bio_dma_done_cb, bio_meta);
|
||||
if (st)
|
||||
goto queue_err;
|
||||
|
||||
return;
|
||||
|
||||
queue_err:
|
||||
kmem_cache_free(bio_meta_pool, bio_meta);
|
||||
req_err:
|
||||
bio_endio(bio, st);
|
||||
}
|
||||
|
||||
/*----------------- Device Setup -------------------*/
|
||||
static bool rsxx_discard_supported(struct rsxx_cardinfo *card)
|
||||
{
|
||||
unsigned char pci_rev;
|
||||
|
||||
pci_read_config_byte(card->dev, PCI_REVISION_ID, &pci_rev);
|
||||
|
||||
return (pci_rev >= RSXX_DISCARD_SUPPORT);
|
||||
}
|
||||
|
||||
static unsigned short rsxx_get_logical_block_size(
|
||||
struct rsxx_cardinfo *card)
|
||||
{
|
||||
u32 capabilities = 0;
|
||||
int st;
|
||||
|
||||
st = rsxx_get_card_capabilities(card, &capabilities);
|
||||
if (st)
|
||||
dev_warn(CARD_TO_DEV(card),
|
||||
"Failed reading card capabilities register\n");
|
||||
|
||||
/* Earlier firmware did not have support for 512 byte accesses */
|
||||
if (capabilities & CARD_CAP_SUBPAGE_WRITES)
|
||||
return 512;
|
||||
else
|
||||
return RSXX_HW_BLK_SIZE;
|
||||
}
|
||||
|
||||
int rsxx_attach_dev(struct rsxx_cardinfo *card)
|
||||
{
|
||||
mutex_lock(&card->dev_lock);
|
||||
|
||||
/* The block device requires the stripe size from the config. */
|
||||
if (enable_blkdev) {
|
||||
if (card->config_valid)
|
||||
set_capacity(card->gendisk, card->size8 >> 9);
|
||||
else
|
||||
set_capacity(card->gendisk, 0);
|
||||
add_disk(card->gendisk);
|
||||
|
||||
card->bdev_attached = 1;
|
||||
}
|
||||
|
||||
mutex_unlock(&card->dev_lock);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void rsxx_detach_dev(struct rsxx_cardinfo *card)
|
||||
{
|
||||
mutex_lock(&card->dev_lock);
|
||||
|
||||
if (card->bdev_attached) {
|
||||
del_gendisk(card->gendisk);
|
||||
card->bdev_attached = 0;
|
||||
}
|
||||
|
||||
mutex_unlock(&card->dev_lock);
|
||||
}
|
||||
|
||||
int rsxx_setup_dev(struct rsxx_cardinfo *card)
|
||||
{
|
||||
unsigned short blk_size;
|
||||
|
||||
mutex_init(&card->dev_lock);
|
||||
|
||||
if (!enable_blkdev)
|
||||
return 0;
|
||||
|
||||
card->major = register_blkdev(0, DRIVER_NAME);
|
||||
if (card->major < 0) {
|
||||
dev_err(CARD_TO_DEV(card), "Failed to get major number\n");
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
card->queue = blk_alloc_queue(GFP_KERNEL);
|
||||
if (!card->queue) {
|
||||
dev_err(CARD_TO_DEV(card), "Failed queue alloc\n");
|
||||
unregister_blkdev(card->major, DRIVER_NAME);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
card->gendisk = alloc_disk(blkdev_minors);
|
||||
if (!card->gendisk) {
|
||||
dev_err(CARD_TO_DEV(card), "Failed disk alloc\n");
|
||||
blk_cleanup_queue(card->queue);
|
||||
unregister_blkdev(card->major, DRIVER_NAME);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
blk_size = rsxx_get_logical_block_size(card);
|
||||
|
||||
blk_queue_make_request(card->queue, rsxx_make_request);
|
||||
blk_queue_bounce_limit(card->queue, BLK_BOUNCE_ANY);
|
||||
blk_queue_dma_alignment(card->queue, blk_size - 1);
|
||||
blk_queue_max_hw_sectors(card->queue, blkdev_max_hw_sectors);
|
||||
blk_queue_logical_block_size(card->queue, blk_size);
|
||||
blk_queue_physical_block_size(card->queue, RSXX_HW_BLK_SIZE);
|
||||
|
||||
queue_flag_set_unlocked(QUEUE_FLAG_NONROT, card->queue);
|
||||
if (rsxx_discard_supported(card)) {
|
||||
queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, card->queue);
|
||||
blk_queue_max_discard_sectors(card->queue,
|
||||
RSXX_HW_BLK_SIZE >> 9);
|
||||
card->queue->limits.discard_granularity = RSXX_HW_BLK_SIZE;
|
||||
card->queue->limits.discard_alignment = RSXX_HW_BLK_SIZE;
|
||||
card->queue->limits.discard_zeroes_data = 1;
|
||||
}
|
||||
|
||||
card->queue->queuedata = card;
|
||||
|
||||
snprintf(card->gendisk->disk_name, sizeof(card->gendisk->disk_name),
|
||||
"rsxx%d", card->disk_id);
|
||||
card->gendisk->driverfs_dev = &card->dev->dev;
|
||||
card->gendisk->major = card->major;
|
||||
card->gendisk->first_minor = 0;
|
||||
card->gendisk->fops = &rsxx_fops;
|
||||
card->gendisk->private_data = card;
|
||||
card->gendisk->queue = card->queue;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void rsxx_destroy_dev(struct rsxx_cardinfo *card)
|
||||
{
|
||||
if (!enable_blkdev)
|
||||
return;
|
||||
|
||||
put_disk(card->gendisk);
|
||||
card->gendisk = NULL;
|
||||
|
||||
blk_cleanup_queue(card->queue);
|
||||
unregister_blkdev(card->major, DRIVER_NAME);
|
||||
}
|
||||
|
||||
int rsxx_dev_init(void)
|
||||
{
|
||||
bio_meta_pool = KMEM_CACHE(rsxx_bio_meta, SLAB_HWCACHE_ALIGN);
|
||||
if (!bio_meta_pool)
|
||||
return -ENOMEM;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void rsxx_dev_cleanup(void)
|
||||
{
|
||||
kmem_cache_destroy(bio_meta_pool);
|
||||
}
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,45 @@
|
||||
/*
|
||||
* Filename: rsxx.h
|
||||
*
|
||||
*
|
||||
* Authors: Joshua Morris <josh.h.morris@us.ibm.com>
|
||||
* Philip Kelleher <pjk1939@linux.vnet.ibm.com>
|
||||
*
|
||||
* (C) Copyright 2013 IBM Corporation
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License as
|
||||
* published by the Free Software Foundation; either version 2 of the
|
||||
* License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#ifndef __RSXX_H__
|
||||
#define __RSXX_H__
|
||||
|
||||
/*----------------- IOCTL Definitions -------------------*/
|
||||
|
||||
struct rsxx_reg_access {
|
||||
__u32 addr;
|
||||
__u32 cnt;
|
||||
__u32 stat;
|
||||
__u32 stream;
|
||||
__u32 data[8];
|
||||
};
|
||||
|
||||
#define RSXX_MAX_REG_CNT (8 * (sizeof(__u32)))
|
||||
|
||||
#define RSXX_IOC_MAGIC 'r'
|
||||
|
||||
#define RSXX_GETREG _IOWR(RSXX_IOC_MAGIC, 0x20, struct rsxx_reg_access)
|
||||
#define RSXX_SETREG _IOWR(RSXX_IOC_MAGIC, 0x21, struct rsxx_reg_access)
|
||||
|
||||
#endif /* __RSXX_H_ */
|
||||
@@ -0,0 +1,72 @@
|
||||
/*
|
||||
* Filename: rsXX_cfg.h
|
||||
*
|
||||
*
|
||||
* Authors: Joshua Morris <josh.h.morris@us.ibm.com>
|
||||
* Philip Kelleher <pjk1939@linux.vnet.ibm.com>
|
||||
*
|
||||
* (C) Copyright 2013 IBM Corporation
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License as
|
||||
* published by the Free Software Foundation; either version 2 of the
|
||||
* License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#ifndef __RSXX_CFG_H__
|
||||
#define __RSXX_CFG_H__
|
||||
|
||||
/* NOTE: Config values will be saved in network byte order (i.e. Big endian) */
|
||||
#include <linux/types.h>
|
||||
|
||||
/*
|
||||
* The card config version must match the driver's expected version. If it does
|
||||
* not, the DMA interfaces will not be attached and the user will need to
|
||||
* initialize/upgrade the card configuration using the card config utility.
|
||||
*/
|
||||
#define RSXX_CFG_VERSION 4
|
||||
|
||||
struct card_cfg_hdr {
|
||||
__u32 version;
|
||||
__u32 crc;
|
||||
};
|
||||
|
||||
struct card_cfg_data {
|
||||
__u32 block_size;
|
||||
__u32 stripe_size;
|
||||
__u32 vendor_id;
|
||||
__u32 cache_order;
|
||||
struct {
|
||||
__u32 mode; /* Disabled, manual, auto-tune... */
|
||||
__u32 count; /* Number of intr to coalesce */
|
||||
__u32 latency;/* Max wait time (in ns) */
|
||||
} intr_coal;
|
||||
};
|
||||
|
||||
struct rsxx_card_cfg {
|
||||
struct card_cfg_hdr hdr;
|
||||
struct card_cfg_data data;
|
||||
};
|
||||
|
||||
/* Vendor ID Values */
|
||||
#define RSXX_VENDOR_ID_TMS_IBM 0
|
||||
#define RSXX_VENDOR_ID_DSI 1
|
||||
#define RSXX_VENDOR_COUNT 2
|
||||
|
||||
/* Interrupt Coalescing Values */
|
||||
#define RSXX_INTR_COAL_DISABLED 0
|
||||
#define RSXX_INTR_COAL_EXPLICIT 1
|
||||
#define RSXX_INTR_COAL_AUTO_TUNE 2
|
||||
|
||||
|
||||
#endif /* __RSXX_CFG_H__ */
|
||||
|
||||
@@ -0,0 +1,399 @@
|
||||
/*
|
||||
* Filename: rsxx_priv.h
|
||||
*
|
||||
*
|
||||
* Authors: Joshua Morris <josh.h.morris@us.ibm.com>
|
||||
* Philip Kelleher <pjk1939@linux.vnet.ibm.com>
|
||||
*
|
||||
* (C) Copyright 2013 IBM Corporation
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License as
|
||||
* published by the Free Software Foundation; either version 2 of the
|
||||
* License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#ifndef __RSXX_PRIV_H__
|
||||
#define __RSXX_PRIV_H__
|
||||
|
||||
#include <linux/version.h>
|
||||
#include <linux/semaphore.h>
|
||||
|
||||
#include <linux/fs.h>
|
||||
#include <linux/interrupt.h>
|
||||
#include <linux/mutex.h>
|
||||
#include <linux/pci.h>
|
||||
#include <linux/spinlock.h>
|
||||
#include <linux/sysfs.h>
|
||||
#include <linux/workqueue.h>
|
||||
#include <linux/bio.h>
|
||||
#include <linux/vmalloc.h>
|
||||
#include <linux/timer.h>
|
||||
#include <linux/ioctl.h>
|
||||
|
||||
#include "rsxx.h"
|
||||
#include "rsxx_cfg.h"
|
||||
|
||||
struct proc_cmd;
|
||||
|
||||
#define PCI_VENDOR_ID_TMS_IBM 0x15B6
|
||||
#define PCI_DEVICE_ID_RS70_FLASH 0x0019
|
||||
#define PCI_DEVICE_ID_RS70D_FLASH 0x001A
|
||||
#define PCI_DEVICE_ID_RS80_FLASH 0x001C
|
||||
#define PCI_DEVICE_ID_RS81_FLASH 0x001E
|
||||
|
||||
#define RS70_PCI_REV_SUPPORTED 4
|
||||
|
||||
#define DRIVER_NAME "rsxx"
|
||||
#define DRIVER_VERSION "3.7"
|
||||
|
||||
/* Block size is 4096 */
|
||||
#define RSXX_HW_BLK_SHIFT 12
|
||||
#define RSXX_HW_BLK_SIZE (1 << RSXX_HW_BLK_SHIFT)
|
||||
#define RSXX_HW_BLK_MASK (RSXX_HW_BLK_SIZE - 1)
|
||||
|
||||
#define MAX_CREG_DATA8 32
|
||||
#define LOG_BUF_SIZE8 128
|
||||
|
||||
#define RSXX_MAX_OUTSTANDING_CMDS 255
|
||||
#define RSXX_CS_IDX_MASK 0xff
|
||||
|
||||
#define RSXX_MAX_TARGETS 8
|
||||
|
||||
struct dma_tracker_list;
|
||||
|
||||
/* DMA Command/Status Buffer structure */
|
||||
struct rsxx_cs_buffer {
|
||||
dma_addr_t dma_addr;
|
||||
void *buf;
|
||||
u32 idx;
|
||||
};
|
||||
|
||||
struct rsxx_dma_stats {
|
||||
u32 crc_errors;
|
||||
u32 hard_errors;
|
||||
u32 soft_errors;
|
||||
u32 writes_issued;
|
||||
u32 writes_failed;
|
||||
u32 reads_issued;
|
||||
u32 reads_failed;
|
||||
u32 reads_retried;
|
||||
u32 discards_issued;
|
||||
u32 discards_failed;
|
||||
u32 done_rescheduled;
|
||||
u32 issue_rescheduled;
|
||||
u32 sw_q_depth; /* Number of DMAs on the SW queue. */
|
||||
atomic_t hw_q_depth; /* Number of DMAs queued to HW. */
|
||||
};
|
||||
|
||||
struct rsxx_dma_ctrl {
|
||||
struct rsxx_cardinfo *card;
|
||||
int id;
|
||||
void __iomem *regmap;
|
||||
struct rsxx_cs_buffer status;
|
||||
struct rsxx_cs_buffer cmd;
|
||||
u16 e_cnt;
|
||||
spinlock_t queue_lock;
|
||||
struct list_head queue;
|
||||
struct workqueue_struct *issue_wq;
|
||||
struct work_struct issue_dma_work;
|
||||
struct workqueue_struct *done_wq;
|
||||
struct work_struct dma_done_work;
|
||||
struct timer_list activity_timer;
|
||||
struct dma_tracker_list *trackers;
|
||||
struct rsxx_dma_stats stats;
|
||||
};
|
||||
|
||||
struct rsxx_cardinfo {
|
||||
struct pci_dev *dev;
|
||||
unsigned int halt;
|
||||
|
||||
void __iomem *regmap;
|
||||
spinlock_t irq_lock;
|
||||
unsigned int isr_mask;
|
||||
unsigned int ier_mask;
|
||||
|
||||
struct rsxx_card_cfg config;
|
||||
int config_valid;
|
||||
|
||||
/* Embedded CPU Communication */
|
||||
struct {
|
||||
spinlock_t lock;
|
||||
bool active;
|
||||
struct creg_cmd *active_cmd;
|
||||
struct work_struct done_work;
|
||||
struct list_head queue;
|
||||
unsigned int q_depth;
|
||||
/* Cache the creg status to prevent ioreads */
|
||||
struct {
|
||||
u32 stat;
|
||||
u32 failed_cancel_timer;
|
||||
u32 creg_timeout;
|
||||
} creg_stats;
|
||||
struct timer_list cmd_timer;
|
||||
struct mutex reset_lock;
|
||||
int reset;
|
||||
} creg_ctrl;
|
||||
|
||||
struct {
|
||||
char tmp[MAX_CREG_DATA8];
|
||||
char buf[LOG_BUF_SIZE8]; /* terminated */
|
||||
int buf_len;
|
||||
} log;
|
||||
|
||||
struct work_struct event_work;
|
||||
unsigned int state;
|
||||
u64 size8;
|
||||
|
||||
/* Lock the device attach/detach function */
|
||||
struct mutex dev_lock;
|
||||
|
||||
/* Block Device Variables */
|
||||
bool bdev_attached;
|
||||
int disk_id;
|
||||
int major;
|
||||
struct request_queue *queue;
|
||||
struct gendisk *gendisk;
|
||||
struct {
|
||||
/* Used to convert a byte address to a device address. */
|
||||
u64 lower_mask;
|
||||
u64 upper_shift;
|
||||
u64 upper_mask;
|
||||
u64 target_mask;
|
||||
u64 target_shift;
|
||||
} _stripe;
|
||||
unsigned int dma_fault;
|
||||
|
||||
int scrub_hard;
|
||||
|
||||
int n_targets;
|
||||
struct rsxx_dma_ctrl *ctrl;
|
||||
};
|
||||
|
||||
enum rsxx_pci_regmap {
|
||||
HWID = 0x00, /* Hardware Identification Register */
|
||||
SCRATCH = 0x04, /* Scratch/Debug Register */
|
||||
RESET = 0x08, /* Reset Register */
|
||||
ISR = 0x10, /* Interrupt Status Register */
|
||||
IER = 0x14, /* Interrupt Enable Register */
|
||||
IPR = 0x18, /* Interrupt Poll Register */
|
||||
CB_ADD_LO = 0x20, /* Command Host Buffer Address [31:0] */
|
||||
CB_ADD_HI = 0x24, /* Command Host Buffer Address [63:32]*/
|
||||
HW_CMD_IDX = 0x28, /* Hardware Processed Command Index */
|
||||
SW_CMD_IDX = 0x2C, /* Software Processed Command Index */
|
||||
SB_ADD_LO = 0x30, /* Status Host Buffer Address [31:0] */
|
||||
SB_ADD_HI = 0x34, /* Status Host Buffer Address [63:32] */
|
||||
HW_STATUS_CNT = 0x38, /* Hardware Status Counter */
|
||||
SW_STATUS_CNT = 0x3C, /* Deprecated */
|
||||
CREG_CMD = 0x40, /* CPU Command Register */
|
||||
CREG_ADD = 0x44, /* CPU Address Register */
|
||||
CREG_CNT = 0x48, /* CPU Count Register */
|
||||
CREG_STAT = 0x4C, /* CPU Status Register */
|
||||
CREG_DATA0 = 0x50, /* CPU Data Registers */
|
||||
CREG_DATA1 = 0x54,
|
||||
CREG_DATA2 = 0x58,
|
||||
CREG_DATA3 = 0x5C,
|
||||
CREG_DATA4 = 0x60,
|
||||
CREG_DATA5 = 0x64,
|
||||
CREG_DATA6 = 0x68,
|
||||
CREG_DATA7 = 0x6c,
|
||||
INTR_COAL = 0x70, /* Interrupt Coalescing Register */
|
||||
HW_ERROR = 0x74, /* Card Error Register */
|
||||
PCI_DEBUG0 = 0x78, /* PCI Debug Registers */
|
||||
PCI_DEBUG1 = 0x7C,
|
||||
PCI_DEBUG2 = 0x80,
|
||||
PCI_DEBUG3 = 0x84,
|
||||
PCI_DEBUG4 = 0x88,
|
||||
PCI_DEBUG5 = 0x8C,
|
||||
PCI_DEBUG6 = 0x90,
|
||||
PCI_DEBUG7 = 0x94,
|
||||
PCI_POWER_THROTTLE = 0x98,
|
||||
PERF_CTRL = 0x9c,
|
||||
PERF_TIMER_LO = 0xa0,
|
||||
PERF_TIMER_HI = 0xa4,
|
||||
PERF_RD512_LO = 0xa8,
|
||||
PERF_RD512_HI = 0xac,
|
||||
PERF_WR512_LO = 0xb0,
|
||||
PERF_WR512_HI = 0xb4,
|
||||
};
|
||||
|
||||
enum rsxx_intr {
|
||||
CR_INTR_DMA0 = 0x00000001,
|
||||
CR_INTR_CREG = 0x00000002,
|
||||
CR_INTR_DMA1 = 0x00000004,
|
||||
CR_INTR_EVENT = 0x00000008,
|
||||
CR_INTR_DMA2 = 0x00000010,
|
||||
CR_INTR_DMA3 = 0x00000020,
|
||||
CR_INTR_DMA4 = 0x00000040,
|
||||
CR_INTR_DMA5 = 0x00000080,
|
||||
CR_INTR_DMA6 = 0x00000100,
|
||||
CR_INTR_DMA7 = 0x00000200,
|
||||
CR_INTR_DMA_ALL = 0x000003f5,
|
||||
CR_INTR_ALL = 0xffffffff,
|
||||
};
|
||||
|
||||
static inline int CR_INTR_DMA(int N)
|
||||
{
|
||||
static const unsigned int _CR_INTR_DMA[] = {
|
||||
CR_INTR_DMA0, CR_INTR_DMA1, CR_INTR_DMA2, CR_INTR_DMA3,
|
||||
CR_INTR_DMA4, CR_INTR_DMA5, CR_INTR_DMA6, CR_INTR_DMA7
|
||||
};
|
||||
return _CR_INTR_DMA[N];
|
||||
}
|
||||
enum rsxx_pci_reset {
|
||||
DMA_QUEUE_RESET = 0x00000001,
|
||||
};
|
||||
|
||||
enum rsxx_pci_revision {
|
||||
RSXX_DISCARD_SUPPORT = 2,
|
||||
};
|
||||
|
||||
enum rsxx_creg_cmd {
|
||||
CREG_CMD_TAG_MASK = 0x0000FF00,
|
||||
CREG_OP_WRITE = 0x000000C0,
|
||||
CREG_OP_READ = 0x000000E0,
|
||||
};
|
||||
|
||||
enum rsxx_creg_addr {
|
||||
CREG_ADD_CARD_CMD = 0x80001000,
|
||||
CREG_ADD_CARD_STATE = 0x80001004,
|
||||
CREG_ADD_CARD_SIZE = 0x8000100c,
|
||||
CREG_ADD_CAPABILITIES = 0x80001050,
|
||||
CREG_ADD_LOG = 0x80002000,
|
||||
CREG_ADD_NUM_TARGETS = 0x80003000,
|
||||
CREG_ADD_CONFIG = 0xB0000000,
|
||||
};
|
||||
|
||||
enum rsxx_creg_card_cmd {
|
||||
CARD_CMD_STARTUP = 1,
|
||||
CARD_CMD_SHUTDOWN = 2,
|
||||
CARD_CMD_LOW_LEVEL_FORMAT = 3,
|
||||
CARD_CMD_FPGA_RECONFIG_BR = 4,
|
||||
CARD_CMD_FPGA_RECONFIG_MAIN = 5,
|
||||
CARD_CMD_BACKUP = 6,
|
||||
CARD_CMD_RESET = 7,
|
||||
CARD_CMD_deprecated = 8,
|
||||
CARD_CMD_UNINITIALIZE = 9,
|
||||
CARD_CMD_DSTROY_EMERGENCY = 10,
|
||||
CARD_CMD_DSTROY_NORMAL = 11,
|
||||
CARD_CMD_DSTROY_EXTENDED = 12,
|
||||
CARD_CMD_DSTROY_ABORT = 13,
|
||||
};
|
||||
|
||||
enum rsxx_card_state {
|
||||
CARD_STATE_SHUTDOWN = 0x00000001,
|
||||
CARD_STATE_STARTING = 0x00000002,
|
||||
CARD_STATE_FORMATTING = 0x00000004,
|
||||
CARD_STATE_UNINITIALIZED = 0x00000008,
|
||||
CARD_STATE_GOOD = 0x00000010,
|
||||
CARD_STATE_SHUTTING_DOWN = 0x00000020,
|
||||
CARD_STATE_FAULT = 0x00000040,
|
||||
CARD_STATE_RD_ONLY_FAULT = 0x00000080,
|
||||
CARD_STATE_DSTROYING = 0x00000100,
|
||||
};
|
||||
|
||||
enum rsxx_led {
|
||||
LED_DEFAULT = 0x0,
|
||||
LED_IDENTIFY = 0x1,
|
||||
LED_SOAK = 0x2,
|
||||
};
|
||||
|
||||
enum rsxx_creg_flash_lock {
|
||||
CREG_FLASH_LOCK = 1,
|
||||
CREG_FLASH_UNLOCK = 2,
|
||||
};
|
||||
|
||||
enum rsxx_card_capabilities {
|
||||
CARD_CAP_SUBPAGE_WRITES = 0x00000080,
|
||||
};
|
||||
|
||||
enum rsxx_creg_stat {
|
||||
CREG_STAT_STATUS_MASK = 0x00000003,
|
||||
CREG_STAT_SUCCESS = 0x1,
|
||||
CREG_STAT_ERROR = 0x2,
|
||||
CREG_STAT_CHAR_PENDING = 0x00000004, /* Character I/O pending bit */
|
||||
CREG_STAT_LOG_PENDING = 0x00000008, /* HW log message pending bit */
|
||||
CREG_STAT_TAG_MASK = 0x0000ff00,
|
||||
};
|
||||
|
||||
static inline unsigned int CREG_DATA(int N)
|
||||
{
|
||||
return CREG_DATA0 + (N << 2);
|
||||
}
|
||||
|
||||
/*----------------- Convenient Log Wrappers -------------------*/
|
||||
#define CARD_TO_DEV(__CARD) (&(__CARD)->dev->dev)
|
||||
|
||||
/***** config.c *****/
|
||||
int rsxx_load_config(struct rsxx_cardinfo *card);
|
||||
|
||||
/***** core.c *****/
|
||||
void rsxx_enable_ier(struct rsxx_cardinfo *card, unsigned int intr);
|
||||
void rsxx_disable_ier(struct rsxx_cardinfo *card, unsigned int intr);
|
||||
void rsxx_enable_ier_and_isr(struct rsxx_cardinfo *card,
|
||||
unsigned int intr);
|
||||
void rsxx_disable_ier_and_isr(struct rsxx_cardinfo *card,
|
||||
unsigned int intr);
|
||||
|
||||
/***** dev.c *****/
|
||||
int rsxx_attach_dev(struct rsxx_cardinfo *card);
|
||||
void rsxx_detach_dev(struct rsxx_cardinfo *card);
|
||||
int rsxx_setup_dev(struct rsxx_cardinfo *card);
|
||||
void rsxx_destroy_dev(struct rsxx_cardinfo *card);
|
||||
int rsxx_dev_init(void);
|
||||
void rsxx_dev_cleanup(void);
|
||||
|
||||
/***** dma.c ****/
|
||||
typedef void (*rsxx_dma_cb)(struct rsxx_cardinfo *card,
|
||||
void *cb_data,
|
||||
unsigned int status);
|
||||
int rsxx_dma_setup(struct rsxx_cardinfo *card);
|
||||
void rsxx_dma_destroy(struct rsxx_cardinfo *card);
|
||||
int rsxx_dma_init(void);
|
||||
void rsxx_dma_cleanup(void);
|
||||
int rsxx_dma_queue_bio(struct rsxx_cardinfo *card,
|
||||
struct bio *bio,
|
||||
atomic_t *n_dmas,
|
||||
rsxx_dma_cb cb,
|
||||
void *cb_data);
|
||||
|
||||
/***** cregs.c *****/
|
||||
int rsxx_creg_write(struct rsxx_cardinfo *card, u32 addr,
|
||||
unsigned int size8,
|
||||
void *data,
|
||||
int byte_stream);
|
||||
int rsxx_creg_read(struct rsxx_cardinfo *card,
|
||||
u32 addr,
|
||||
unsigned int size8,
|
||||
void *data,
|
||||
int byte_stream);
|
||||
int rsxx_read_hw_log(struct rsxx_cardinfo *card);
|
||||
int rsxx_get_card_state(struct rsxx_cardinfo *card,
|
||||
unsigned int *state);
|
||||
int rsxx_get_card_size8(struct rsxx_cardinfo *card, u64 *size8);
|
||||
int rsxx_get_num_targets(struct rsxx_cardinfo *card,
|
||||
unsigned int *n_targets);
|
||||
int rsxx_get_card_capabilities(struct rsxx_cardinfo *card,
|
||||
u32 *capabilities);
|
||||
int rsxx_issue_card_cmd(struct rsxx_cardinfo *card, u32 cmd);
|
||||
int rsxx_creg_setup(struct rsxx_cardinfo *card);
|
||||
void rsxx_creg_destroy(struct rsxx_cardinfo *card);
|
||||
int rsxx_creg_init(void);
|
||||
void rsxx_creg_cleanup(void);
|
||||
|
||||
int rsxx_reg_access(struct rsxx_cardinfo *card,
|
||||
struct rsxx_reg_access __user *ucmd,
|
||||
int read);
|
||||
|
||||
|
||||
|
||||
#endif /* __DRIVERS_BLOCK_RSXX_H__ */
|
||||
-1123
File diff suppressed because it is too large
Load Diff
@@ -1,134 +0,0 @@
|
||||
#ifndef _LINUX_XD_H
|
||||
#define _LINUX_XD_H
|
||||
|
||||
/*
|
||||
* This file contains the definitions for the IO ports and errors etc. for XT hard disk controllers (at least the DTC 5150X).
|
||||
*
|
||||
* Author: Pat Mackinlay, pat@it.com.au
|
||||
* Date: 29/09/92
|
||||
*
|
||||
* Revised: 01/01/93, ...
|
||||
*
|
||||
* Ref: DTC 5150X Controller Specification (thanks to Kevin Fowler, kevinf@agora.rain.com)
|
||||
* Also thanks to: Salvador Abreu, Dave Thaler, Risto Kankkunen and Wim Van Dorst.
|
||||
*/
|
||||
|
||||
#include <linux/interrupt.h>
|
||||
|
||||
/* XT hard disk controller registers */
|
||||
#define XD_DATA (xd_iobase + 0x00) /* data RW register */
|
||||
#define XD_RESET (xd_iobase + 0x01) /* reset WO register */
|
||||
#define XD_STATUS (xd_iobase + 0x01) /* status RO register */
|
||||
#define XD_SELECT (xd_iobase + 0x02) /* select WO register */
|
||||
#define XD_JUMPER (xd_iobase + 0x02) /* jumper RO register */
|
||||
#define XD_CONTROL (xd_iobase + 0x03) /* DMAE/INTE WO register */
|
||||
#define XD_RESERVED (xd_iobase + 0x03) /* reserved */
|
||||
|
||||
/* XT hard disk controller commands (incomplete list) */
|
||||
#define CMD_TESTREADY 0x00 /* test drive ready */
|
||||
#define CMD_RECALIBRATE 0x01 /* recalibrate drive */
|
||||
#define CMD_SENSE 0x03 /* request sense */
|
||||
#define CMD_FORMATDRV 0x04 /* format drive */
|
||||
#define CMD_VERIFY 0x05 /* read verify */
|
||||
#define CMD_FORMATTRK 0x06 /* format track */
|
||||
#define CMD_FORMATBAD 0x07 /* format bad track */
|
||||
#define CMD_READ 0x08 /* read */
|
||||
#define CMD_WRITE 0x0A /* write */
|
||||
#define CMD_SEEK 0x0B /* seek */
|
||||
|
||||
/* Controller specific commands */
|
||||
#define CMD_DTCSETPARAM 0x0C /* set drive parameters (DTC 5150X & CX only?) */
|
||||
#define CMD_DTCGETECC 0x0D /* get ecc error length (DTC 5150X only?) */
|
||||
#define CMD_DTCREADBUF 0x0E /* read sector buffer (DTC 5150X only?) */
|
||||
#define CMD_DTCWRITEBUF 0x0F /* write sector buffer (DTC 5150X only?) */
|
||||
#define CMD_DTCREMAPTRK 0x11 /* assign alternate track (DTC 5150X only?) */
|
||||
#define CMD_DTCGETPARAM 0xFB /* get drive parameters (DTC 5150X only?) */
|
||||
#define CMD_DTCSETSTEP 0xFC /* set step rate (DTC 5150X only?) */
|
||||
#define CMD_DTCSETGEOM 0xFE /* set geometry data (DTC 5150X only?) */
|
||||
#define CMD_DTCGETGEOM 0xFF /* get geometry data (DTC 5150X only?) */
|
||||
#define CMD_ST11GETGEOM 0xF8 /* get geometry data (Seagate ST11R/M only?) */
|
||||
#define CMD_WDSETPARAM 0x0C /* set drive parameters (WD 1004A27X only?) */
|
||||
#define CMD_XBSETPARAM 0x0C /* set drive parameters (XEBEC only?) */
|
||||
|
||||
/* Bits for command status byte */
|
||||
#define CSB_ERROR 0x02 /* error */
|
||||
#define CSB_LUN 0x20 /* logical Unit Number */
|
||||
|
||||
/* XT hard disk controller status bits */
|
||||
#define STAT_READY 0x01 /* controller is ready */
|
||||
#define STAT_INPUT 0x02 /* data flowing from controller to host */
|
||||
#define STAT_COMMAND 0x04 /* controller in command phase */
|
||||
#define STAT_SELECT 0x08 /* controller is selected */
|
||||
#define STAT_REQUEST 0x10 /* controller requesting data */
|
||||
#define STAT_INTERRUPT 0x20 /* controller requesting interrupt */
|
||||
|
||||
/* XT hard disk controller control bits */
|
||||
#define PIO_MODE 0x00 /* control bits to set for PIO */
|
||||
#define DMA_MODE 0x03 /* control bits to set for DMA & interrupt */
|
||||
|
||||
#define XD_MAXDRIVES 2 /* maximum 2 drives */
|
||||
#define XD_TIMEOUT HZ /* 1 second timeout */
|
||||
#define XD_RETRIES 4 /* maximum 4 retries */
|
||||
|
||||
#undef DEBUG /* define for debugging output */
|
||||
|
||||
#ifdef DEBUG
|
||||
#define DEBUG_STARTUP /* debug driver initialisation */
|
||||
#define DEBUG_OVERRIDE /* debug override geometry detection */
|
||||
#define DEBUG_READWRITE /* debug each read/write command */
|
||||
#define DEBUG_OTHER /* debug misc. interrupt/DMA stuff */
|
||||
#define DEBUG_COMMAND /* debug each controller command */
|
||||
#endif /* DEBUG */
|
||||
|
||||
/* this structure defines the XT drives and their types */
|
||||
typedef struct {
|
||||
u_char heads;
|
||||
u_short cylinders;
|
||||
u_char sectors;
|
||||
u_char control;
|
||||
int unit;
|
||||
} XD_INFO;
|
||||
|
||||
/* this structure defines a ROM BIOS signature */
|
||||
typedef struct {
|
||||
unsigned int offset;
|
||||
const char *string;
|
||||
void (*init_controller)(unsigned int address);
|
||||
void (*init_drive)(u_char drive);
|
||||
const char *name;
|
||||
} XD_SIGNATURE;
|
||||
|
||||
#ifndef MODULE
|
||||
static int xd_manual_geo_init (char *command);
|
||||
#endif /* MODULE */
|
||||
static u_char xd_detect (u_char *controller, unsigned int *address);
|
||||
static u_char xd_initdrives (void (*init_drive)(u_char drive));
|
||||
|
||||
static void do_xd_request (struct request_queue * q);
|
||||
static int xd_ioctl (struct block_device *bdev,fmode_t mode,unsigned int cmd,unsigned long arg);
|
||||
static int xd_readwrite (u_char operation,XD_INFO *disk,char *buffer,u_int block,u_int count);
|
||||
static void xd_recalibrate (u_char drive);
|
||||
|
||||
static irqreturn_t xd_interrupt_handler(int irq, void *dev_id);
|
||||
static u_char xd_setup_dma (u_char opcode,u_char *buffer,u_int count);
|
||||
static u_char *xd_build (u_char *cmdblk,u_char command,u_char drive,u_char head,u_short cylinder,u_char sector,u_char count,u_char control);
|
||||
static void xd_watchdog (unsigned long unused);
|
||||
static inline u_char xd_waitport (u_short port,u_char flags,u_char mask,u_long timeout);
|
||||
static u_int xd_command (u_char *command,u_char mode,u_char *indata,u_char *outdata,u_char *sense,u_long timeout);
|
||||
|
||||
/* card specific setup and geometry gathering code */
|
||||
static void xd_dtc_init_controller (unsigned int address);
|
||||
static void xd_dtc5150cx_init_drive (u_char drive);
|
||||
static void xd_dtc_init_drive (u_char drive);
|
||||
static void xd_wd_init_controller (unsigned int address);
|
||||
static void xd_wd_init_drive (u_char drive);
|
||||
static void xd_seagate_init_controller (unsigned int address);
|
||||
static void xd_seagate_init_drive (u_char drive);
|
||||
static void xd_omti_init_controller (unsigned int address);
|
||||
static void xd_omti_init_drive (u_char drive);
|
||||
static void xd_xebec_init_controller (unsigned int address);
|
||||
static void xd_xebec_init_drive (u_char drive);
|
||||
static void xd_setparam (u_char command,u_char drive,u_char heads,u_short cylinders,u_short rwrite,u_short wprecomp,u_char ecc);
|
||||
static void xd_override_init_drive (u_char drive);
|
||||
|
||||
#endif /* _LINUX_XD_H */
|
||||
@@ -46,6 +46,7 @@
|
||||
#include <xen/xen.h>
|
||||
#include <asm/xen/hypervisor.h>
|
||||
#include <asm/xen/hypercall.h>
|
||||
#include <xen/balloon.h>
|
||||
#include "common.h"
|
||||
|
||||
/*
|
||||
@@ -239,6 +240,7 @@ static void free_persistent_gnts(struct rb_root *root, unsigned int num)
|
||||
ret = gnttab_unmap_refs(unmap, NULL, pages,
|
||||
segs_to_unmap);
|
||||
BUG_ON(ret);
|
||||
free_xenballooned_pages(segs_to_unmap, pages);
|
||||
segs_to_unmap = 0;
|
||||
}
|
||||
|
||||
@@ -527,8 +529,8 @@ static int xen_blkbk_map(struct blkif_request *req,
|
||||
GFP_KERNEL);
|
||||
if (!persistent_gnt)
|
||||
return -ENOMEM;
|
||||
persistent_gnt->page = alloc_page(GFP_KERNEL);
|
||||
if (!persistent_gnt->page) {
|
||||
if (alloc_xenballooned_pages(1, &persistent_gnt->page,
|
||||
false)) {
|
||||
kfree(persistent_gnt);
|
||||
return -ENOMEM;
|
||||
}
|
||||
@@ -879,7 +881,6 @@ static int dispatch_rw_block_io(struct xen_blkif *blkif,
|
||||
goto fail_response;
|
||||
}
|
||||
|
||||
preq.dev = req->u.rw.handle;
|
||||
preq.sector_number = req->u.rw.sector_number;
|
||||
preq.nr_sects = 0;
|
||||
|
||||
|
||||
@@ -367,6 +367,7 @@ static int xen_blkbk_remove(struct xenbus_device *dev)
|
||||
be->blkif = NULL;
|
||||
}
|
||||
|
||||
kfree(be->mode);
|
||||
kfree(be);
|
||||
dev_set_drvdata(&dev->dev, NULL);
|
||||
return 0;
|
||||
@@ -502,6 +503,7 @@ static void backend_changed(struct xenbus_watch *watch,
|
||||
= container_of(watch, struct backend_info, backend_watch);
|
||||
struct xenbus_device *dev = be->dev;
|
||||
int cdrom = 0;
|
||||
unsigned long handle;
|
||||
char *device_type;
|
||||
|
||||
DPRINTK("");
|
||||
@@ -521,10 +523,10 @@ static void backend_changed(struct xenbus_watch *watch,
|
||||
return;
|
||||
}
|
||||
|
||||
if ((be->major || be->minor) &&
|
||||
((be->major != major) || (be->minor != minor))) {
|
||||
pr_warn(DRV_PFX "changing physical device (from %x:%x to %x:%x) not supported.\n",
|
||||
be->major, be->minor, major, minor);
|
||||
if (be->major | be->minor) {
|
||||
if (be->major != major || be->minor != minor)
|
||||
pr_warn(DRV_PFX "changing physical device (from %x:%x to %x:%x) not supported.\n",
|
||||
be->major, be->minor, major, minor);
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -542,36 +544,33 @@ static void backend_changed(struct xenbus_watch *watch,
|
||||
kfree(device_type);
|
||||
}
|
||||
|
||||
if (be->major == 0 && be->minor == 0) {
|
||||
/* Front end dir is a number, which is used as the handle. */
|
||||
/* Front end dir is a number, which is used as the handle. */
|
||||
err = strict_strtoul(strrchr(dev->otherend, '/') + 1, 0, &handle);
|
||||
if (err)
|
||||
return;
|
||||
|
||||
char *p = strrchr(dev->otherend, '/') + 1;
|
||||
long handle;
|
||||
err = strict_strtoul(p, 0, &handle);
|
||||
if (err)
|
||||
return;
|
||||
be->major = major;
|
||||
be->minor = minor;
|
||||
|
||||
be->major = major;
|
||||
be->minor = minor;
|
||||
|
||||
err = xen_vbd_create(be->blkif, handle, major, minor,
|
||||
(NULL == strchr(be->mode, 'w')), cdrom);
|
||||
if (err) {
|
||||
be->major = 0;
|
||||
be->minor = 0;
|
||||
xenbus_dev_fatal(dev, err, "creating vbd structure");
|
||||
return;
|
||||
}
|
||||
err = xen_vbd_create(be->blkif, handle, major, minor,
|
||||
!strchr(be->mode, 'w'), cdrom);
|
||||
|
||||
if (err)
|
||||
xenbus_dev_fatal(dev, err, "creating vbd structure");
|
||||
else {
|
||||
err = xenvbd_sysfs_addif(dev);
|
||||
if (err) {
|
||||
xen_vbd_free(&be->blkif->vbd);
|
||||
be->major = 0;
|
||||
be->minor = 0;
|
||||
xenbus_dev_fatal(dev, err, "creating sysfs entries");
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
if (err) {
|
||||
kfree(be->mode);
|
||||
be->mode = NULL;
|
||||
be->major = 0;
|
||||
be->minor = 0;
|
||||
} else {
|
||||
/* We're potentially connected now */
|
||||
xen_update_blkif_status(be->blkif);
|
||||
}
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user