Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 599d49de authored by Dave Jiang's avatar Dave Jiang Committed by Vinod Koul
Browse files

dmaengine: ioatdma: move dma prep functions to single location 



Move all DMA descriptor prepping functions to prep.c file. Fixup all
broken bits caused by the move.

Signed-off-by: default avatarDave Jiang <dave.jiang@intel.com>
Acked-by: default avatarDan Williams <dan.j.williams@intel.com>
Signed-off-by: default avatarVinod Koul <vinod.koul@intel.com>
parent c0f28ce6

drivers/dma/ioat/Makefile

+1 −1
Original line number Diff line number Diff line 
obj-$(CONFIG_INTEL_IOATDMA) += ioatdma.o

ioatdma-y := init.o dma.o dma_v3.o dca.o sysfs.o
 
ioatdma-y := init.o dma.o dma_v3.o prep.o dca.o sysfs.o

drivers/dma/ioat/dma.c

+0 −47
Original line number Diff line number Diff line
@@ -578,50 +578,3 @@ int ioat_check_space_lock(struct ioatdma_chan *ioat_chan, int num_descs) 


	return -ENOMEM;

}
 


struct dma_async_tx_descriptor *

ioat_dma_prep_memcpy_lock(struct dma_chan *c, dma_addr_t dma_dest,

			   dma_addr_t dma_src, size_t len, unsigned long flags)

{

	struct ioatdma_chan *ioat_chan = to_ioat_chan(c);

	struct ioat_dma_descriptor *hw;

	struct ioat_ring_ent *desc;

	dma_addr_t dst = dma_dest;

	dma_addr_t src = dma_src;

	size_t total_len = len;

	int num_descs, idx, i;



	num_descs = ioat_xferlen_to_descs(ioat_chan, len);

	if (likely(num_descs) &&

	    ioat_check_space_lock(ioat_chan, num_descs) == 0)

		idx = ioat_chan->head;

	else

		return NULL;

	i = 0;

	do {

		size_t copy = min_t(size_t, len, 1 << ioat_chan->xfercap_log);



		desc = ioat_get_ring_ent(ioat_chan, idx + i);

		hw = desc->hw;



		hw->size = copy;

		hw->ctl = 0;

		hw->src_addr = src;

		hw->dst_addr = dst;



		len -= copy;

		dst += copy;

		src += copy;

		dump_desc_dbg(ioat_chan, desc);

	} while (++i < num_descs);



	desc->txd.flags = flags;

	desc->len = total_len;

	hw->ctl_f.int_en = !!(flags & DMA_PREP_INTERRUPT);

	hw->ctl_f.fence = !!(flags & DMA_PREP_FENCE);

	hw->ctl_f.compl_write = 1;

	dump_desc_dbg(ioat_chan, desc);

	/* we leave the channel locked to ensure in order submission */



	return &desc->txd;

}

drivers/dma/ioat/dma.h

+39 −42
Original line number Diff line number Diff line
@@ -37,6 +37,14 @@ 


#define chan_num(ch) ((int)((ch)->reg_base - (ch)->ioat_dma->reg_base) / 0x80)



/* ioat hardware assumes at least two sources for raid operations */

#define src_cnt_to_sw(x) ((x) + 2)

#define src_cnt_to_hw(x) ((x) - 2)

#define ndest_to_sw(x) ((x) + 1)

#define ndest_to_hw(x) ((x) - 1)

#define src16_cnt_to_sw(x) ((x) + 9)

#define src16_cnt_to_hw(x) ((x) - 9)



/*

 * workaround for IOAT ver.3.0 null descriptor issue

 * (channel returns error when size is 0)
@@ -190,15 +198,22 @@ struct ioat_ring_ent { 
	struct ioat_sed_ent *sed;

};



extern const struct sysfs_ops ioat_sysfs_ops;

extern struct ioat_sysfs_entry ioat_version_attr;

extern struct ioat_sysfs_entry ioat_cap_attr;

extern int ioat_pending_level;

extern int ioat_ring_alloc_order;

extern struct kobj_type ioat_ktype;

extern struct kmem_cache *ioat_cache;

extern int ioat_ring_max_alloc_order;

extern struct kmem_cache *ioat_sed_cache;



static inline struct ioatdma_chan *to_ioat_chan(struct dma_chan *c)

{

	return container_of(c, struct ioatdma_chan, dma_chan);

}







/* wrapper around hardware descriptor format + additional software fields */



#ifdef DEBUG

#define set_desc_id(desc, i) ((desc)->id = (i))

#define desc_id(desc) ((desc)->id)
@@ -381,13 +396,10 @@ ioat_set_chainaddr(struct ioatdma_chan *ioat_chan, u64 addr) 
	       ioat_chan->reg_base + IOAT2_CHAINADDR_OFFSET_HIGH);

}



irqreturn_t ioat_dma_do_interrupt(int irq, void *data);

irqreturn_t ioat_dma_do_interrupt_msix(int irq, void *data);

struct ioat_ring_ent **

ioat_alloc_ring(struct dma_chan *c, int order, gfp_t flags);

void ioat_start_null_desc(struct ioatdma_chan *ioat_chan);

void ioat_free_ring_ent(struct ioat_ring_ent *desc, struct dma_chan *chan);

int ioat_reset_hw(struct ioatdma_chan *ioat_chan);

/* IOAT Prep functions */

struct dma_async_tx_descriptor *

ioat_dma_prep_memcpy_lock(struct dma_chan *c, dma_addr_t dma_dest,

			   dma_addr_t dma_src, size_t len, unsigned long flags);

struct dma_async_tx_descriptor *

ioat_prep_interrupt_lock(struct dma_chan *c, unsigned long flags);

struct dma_async_tx_descriptor *
@@ -412,53 +424,38 @@ struct dma_async_tx_descriptor * 
ioat_prep_pqxor_val(struct dma_chan *chan, dma_addr_t *src,

		     unsigned int src_cnt, size_t len,

		     enum sum_check_flags *result, unsigned long flags);



/* IOAT Operation functions */

irqreturn_t ioat_dma_do_interrupt(int irq, void *data);

irqreturn_t ioat_dma_do_interrupt_msix(int irq, void *data);

struct ioat_ring_ent **

ioat_alloc_ring(struct dma_chan *c, int order, gfp_t flags);

void ioat_start_null_desc(struct ioatdma_chan *ioat_chan);

void ioat_free_ring_ent(struct ioat_ring_ent *desc, struct dma_chan *chan);

int ioat_reset_hw(struct ioatdma_chan *ioat_chan);

enum dma_status

ioat_tx_status(struct dma_chan *c, dma_cookie_t cookie,

		struct dma_tx_state *txstate);

void ioat_cleanup_event(unsigned long data);

void ioat_timer_event(unsigned long data);

bool is_bwd_ioat(struct pci_dev *pdev);

int ioat_probe(struct ioatdma_device *ioat_dma);

int ioat_register(struct ioatdma_device *ioat_dma);

int ioat_dma_self_test(struct ioatdma_device *ioat_dma);

void ioat_dma_remove(struct ioatdma_device *ioat_dma);

struct dca_provider *ioat_dca_init(struct pci_dev *pdev, void __iomem *iobase);

void ioat_init_channel(struct ioatdma_device *ioat_dma,

		       struct ioatdma_chan *ioat_chan, int idx);

enum dma_status ioat_dma_tx_status(struct dma_chan *c, dma_cookie_t cookie,

				   struct dma_tx_state *txstate);

bool ioat_cleanup_preamble(struct ioatdma_chan *ioat_chan,

			   dma_addr_t *phys_complete);

void ioat_kobject_add(struct ioatdma_device *ioat_dma, struct kobj_type *type);

void ioat_kobject_del(struct ioatdma_device *ioat_dma);

int ioat_dma_setup_interrupts(struct ioatdma_device *ioat_dma);

void ioat_stop(struct ioatdma_chan *ioat_chan);

int ioat_dma_probe(struct ioatdma_device *ioat_dma, int dca);

int ioat3_dma_probe(struct ioatdma_device *ioat_dma, int dca);

struct dca_provider *ioat3_dca_init(struct pci_dev *pdev, void __iomem *iobase);

int ioat_check_space_lock(struct ioatdma_chan *ioat_chan, int num_descs);

int ioat_enumerate_channels(struct ioatdma_device *ioat_dma);

struct dma_async_tx_descriptor *

ioat_dma_prep_memcpy_lock(struct dma_chan *c, dma_addr_t dma_dest,

			   dma_addr_t dma_src, size_t len, unsigned long flags);

void ioat_issue_pending(struct dma_chan *chan);

int ioat_alloc_chan_resources(struct dma_chan *c);

void ioat_free_chan_resources(struct dma_chan *c);

void __ioat_restart_chan(struct ioatdma_chan *ioat_chan);

bool reshape_ring(struct ioatdma_chan *ioat, int order);

void __ioat_issue_pending(struct ioatdma_chan *ioat_chan);

void ioat_timer_event(unsigned long data);

int ioat_quiesce(struct ioatdma_chan *ioat_chan, unsigned long tmo);

int ioat_reset_sync(struct ioatdma_chan *ioat_chan, unsigned long tmo);

void __ioat_restart_chan(struct ioatdma_chan *ioat_chan);



extern const struct sysfs_ops ioat_sysfs_ops;

extern struct ioat_sysfs_entry ioat_version_attr;

extern struct ioat_sysfs_entry ioat_cap_attr;

extern int ioat_pending_level;

extern int ioat_ring_alloc_order;

extern struct kobj_type ioat_ktype;

extern struct kmem_cache *ioat_cache;

extern int ioat_ring_max_alloc_order;

extern struct kmem_cache *ioat_sed_cache;



/* IOAT Init functions */

bool is_bwd_ioat(struct pci_dev *pdev);

void ioat_kobject_add(struct ioatdma_device *ioat_dma, struct kobj_type *type);

void ioat_kobject_del(struct ioatdma_device *ioat_dma);

int ioat_dma_setup_interrupts(struct ioatdma_device *ioat_dma);

void ioat_stop(struct ioatdma_chan *ioat_chan);

struct dca_provider *ioat3_dca_init(struct pci_dev *pdev, void __iomem *iobase);

#endif /* IOATDMA_H */

drivers/dma/ioat/dma_v3.c

+10 −649

File changed.

Preview size limit exceeded, changes collapsed.

drivers/dma/ioat/init.c

+12 −10
Original line number Diff line number Diff line
@@ -110,6 +110,9 @@ MODULE_DEVICE_TABLE(pci, ioat_pci_tbl); 


static int ioat_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id);

static void ioat_remove(struct pci_dev *pdev);

static void

ioat_init_channel(struct ioatdma_device *ioat_dma,

		  struct ioatdma_chan *ioat_chan, int idx);



static int ioat_dca_enabled = 1;

module_param(ioat_dca_enabled, int, 0644);
@@ -269,7 +272,7 @@ static void ioat_dma_test_callback(void *dma_async_param) 
 * ioat_dma_self_test - Perform a IOAT transaction to verify the HW works.

 * @ioat_dma: dma device to be tested

 */

int ioat_dma_self_test(struct ioatdma_device *ioat_dma)

static int ioat_dma_self_test(struct ioatdma_device *ioat_dma)

{

	int i;

	u8 *src;
@@ -453,7 +456,6 @@ int ioat_dma_setup_interrupts(struct ioatdma_device *ioat_dma) 
	dev_err(dev, "no usable interrupts\n");

	return err;

}

EXPORT_SYMBOL(ioat_dma_setup_interrupts);



static void ioat_disable_interrupts(struct ioatdma_device *ioat_dma)

{
@@ -461,7 +463,7 @@ static void ioat_disable_interrupts(struct ioatdma_device *ioat_dma) 
	writeb(0, ioat_dma->reg_base + IOAT_INTRCTRL_OFFSET);

}



int ioat_probe(struct ioatdma_device *ioat_dma)

static int ioat_probe(struct ioatdma_device *ioat_dma)

{

	int err = -ENODEV;

	struct dma_device *dma = &ioat_dma->dma_dev;
@@ -517,7 +519,7 @@ int ioat_probe(struct ioatdma_device *ioat_dma) 
	return err;

}



int ioat_register(struct ioatdma_device *ioat_dma)

static int ioat_register(struct ioatdma_device *ioat_dma)

{

	int err = dma_async_device_register(&ioat_dma->dma_dev);
@@ -530,7 +532,7 @@ int ioat_register(struct ioatdma_device *ioat_dma) 
	return err;

}



void ioat_dma_remove(struct ioatdma_device *ioat_dma)

static void ioat_dma_remove(struct ioatdma_device *ioat_dma)

{

	struct dma_device *dma = &ioat_dma->dma_dev;
@@ -550,7 +552,7 @@ void ioat_dma_remove(struct ioatdma_device *ioat_dma) 
 * ioat_enumerate_channels - find and initialize the device's channels

 * @ioat_dma: the ioat dma device to be enumerated

 */

int ioat_enumerate_channels(struct ioatdma_device *ioat_dma)

static int ioat_enumerate_channels(struct ioatdma_device *ioat_dma)

{

	struct ioatdma_chan *ioat_chan;

	struct device *dev = &ioat_dma->pdev->dev;
@@ -593,7 +595,7 @@ int ioat_enumerate_channels(struct ioatdma_device *ioat_dma) 
 * ioat_free_chan_resources - release all the descriptors

 * @chan: the channel to be cleaned

 */

void ioat_free_chan_resources(struct dma_chan *c)

static void ioat_free_chan_resources(struct dma_chan *c)

{

	struct ioatdma_chan *ioat_chan = to_ioat_chan(c);

	struct ioatdma_device *ioat_dma = ioat_chan->ioat_dma;
@@ -646,7 +648,7 @@ void ioat_free_chan_resources(struct dma_chan *c) 
/* ioat_alloc_chan_resources - allocate/initialize ioat descriptor ring

 * @chan: channel to be initialized

 */

int ioat_alloc_chan_resources(struct dma_chan *c)

static int ioat_alloc_chan_resources(struct dma_chan *c)

{

	struct ioatdma_chan *ioat_chan = to_ioat_chan(c);

	struct ioat_ring_ent **ring;
@@ -712,7 +714,7 @@ int ioat_alloc_chan_resources(struct dma_chan *c) 
}



/* common channel initialization */

void

static void

ioat_init_channel(struct ioatdma_device *ioat_dma,

		  struct ioatdma_chan *ioat_chan, int idx)

{
@@ -1048,7 +1050,7 @@ static void ioat3_intr_quirk(struct ioatdma_device *ioat_dma) 
	}

}



int ioat3_dma_probe(struct ioatdma_device *ioat_dma, int dca)

static int ioat3_dma_probe(struct ioatdma_device *ioat_dma, int dca)

{

	struct pci_dev *pdev = ioat_dma->pdev;

	int dca_en = system_has_dca_enabled(pdev);