Commit aa1e6f1a authored by Dan Williams's avatar Dan Williams
Browse files

dmaengine: kill struct dma_client and supporting infrastructure 



All users have been converted to either the general-purpose allocator,
dma_find_channel, or dma_request_channel.

Reviewed-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarDan Williams <dan.j.williams@intel.com>
parent 209b84a8

drivers/dma/dmaengine.c

+3 −71
Original line number Diff line number Diff line
@@ -31,15 +31,12 @@ 
 *

 * LOCKING:

 *

 * The subsystem keeps two global lists, dma_device_list and dma_client_list.

 * Both of these are protected by a mutex, dma_list_mutex.

 * The subsystem keeps a global list of dma_device structs it is protected by a

 * mutex, dma_list_mutex.

 *

 * Each device has a channels list, which runs unlocked but is never modified

 * once the device is registered, it's just setup by the driver.

 *

 * Each client is responsible for keeping track of the channels it uses.  See

 * the definition of dma_event_callback in dmaengine.h.

 *

 * Each device has a kref, which is initialized to 1 when the device is

 * registered. A kref_get is done for each device registered.  When the

 * device is released, the corresponding kref_put is done in the release
@@ -74,7 +71,6 @@ 


static DEFINE_MUTEX(dma_list_mutex);

static LIST_HEAD(dma_device_list);

static LIST_HEAD(dma_client_list);

static long dmaengine_ref_count;



/* --- sysfs implementation --- */
@@ -189,7 +185,7 @@ static int dma_chan_get(struct dma_chan *chan) 


	/* allocate upon first client reference */

	if (chan->client_count == 1 && err == 0) {

		int desc_cnt = chan->device->device_alloc_chan_resources(chan, NULL);

		int desc_cnt = chan->device->device_alloc_chan_resources(chan);



		if (desc_cnt < 0) {

			err = desc_cnt;
@@ -218,40 +214,6 @@ static void dma_chan_put(struct dma_chan *chan) 
		chan->device->device_free_chan_resources(chan);

}



/**

 * dma_client_chan_alloc - try to allocate channels to a client

 * @client: &dma_client

 *

 * Called with dma_list_mutex held.

 */

static void dma_client_chan_alloc(struct dma_client *client)

{

	struct dma_device *device;

	struct dma_chan *chan;

	enum dma_state_client ack;



	/* Find a channel */

	list_for_each_entry(device, &dma_device_list, global_node) {

		if (dma_has_cap(DMA_PRIVATE, device->cap_mask))

			continue;

		if (!dma_device_satisfies_mask(device, client->cap_mask))

			continue;



		list_for_each_entry(chan, &device->channels, device_node) {

			if (!chan->client_count)

				continue;

			ack = client->event_callback(client, chan,

						     DMA_RESOURCE_AVAILABLE);



			/* we are done once this client rejects

			 * an available resource

			 */

			if (ack == DMA_NAK)

				return;

		}

	}

}



enum dma_status dma_sync_wait(struct dma_chan *chan, dma_cookie_t cookie)

{

	enum dma_status status;
@@ -584,21 +546,6 @@ void dma_release_channel(struct dma_chan *chan) 
}

EXPORT_SYMBOL_GPL(dma_release_channel);



/**

 * dma_chans_notify_available - broadcast available channels to the clients

 */

static void dma_clients_notify_available(void)

{

	struct dma_client *client;



	mutex_lock(&dma_list_mutex);



	list_for_each_entry(client, &dma_client_list, global_node)

		dma_client_chan_alloc(client);



	mutex_unlock(&dma_list_mutex);

}



/**

 * dmaengine_get - register interest in dma_channels

 */
@@ -659,19 +606,6 @@ void dmaengine_put(void) 
}

EXPORT_SYMBOL(dmaengine_put);



/**

 * dma_async_client_chan_request - send all available channels to the

 * client that satisfy the capability mask

 * @client - requester

 */

void dma_async_client_chan_request(struct dma_client *client)

{

	mutex_lock(&dma_list_mutex);

	dma_client_chan_alloc(client);

	mutex_unlock(&dma_list_mutex);

}

EXPORT_SYMBOL(dma_async_client_chan_request);



/**

 * dma_async_device_register - registers DMA devices found

 * @device: &dma_device
@@ -765,8 +699,6 @@ int dma_async_device_register(struct dma_device *device) 
	dma_channel_rebalance();

	mutex_unlock(&dma_list_mutex);



	dma_clients_notify_available();



	return 0;



err_out:

drivers/dma/dw_dmac.c

+1 −2
Original line number Diff line number Diff line
@@ -758,8 +758,7 @@ static void dwc_issue_pending(struct dma_chan *chan) 
	spin_unlock_bh(&dwc->lock);

}



static int dwc_alloc_chan_resources(struct dma_chan *chan,

		struct dma_client *client)

static int dwc_alloc_chan_resources(struct dma_chan *chan)

{

	struct dw_dma_chan	*dwc = to_dw_dma_chan(chan);

	struct dw_dma		*dw = to_dw_dma(chan->device);

drivers/dma/fsldma.c

+1 −2
Original line number Diff line number Diff line
@@ -366,8 +366,7 @@ static struct fsl_desc_sw *fsl_dma_alloc_descriptor( 
 *

 * Return - The number of descriptors allocated.

 */

static int fsl_dma_alloc_chan_resources(struct dma_chan *chan,

					struct dma_client *client)

static int fsl_dma_alloc_chan_resources(struct dma_chan *chan)

{

	struct fsl_dma_chan *fsl_chan = to_fsl_chan(chan);

drivers/dma/ioat_dma.c

+2 −3
Original line number Diff line number Diff line
@@ -734,8 +734,7 @@ static void ioat2_dma_massage_chan_desc(struct ioat_dma_chan *ioat_chan) 
 * ioat_dma_alloc_chan_resources - returns the number of allocated descriptors

 * @chan: the channel to be filled out

 */

static int ioat_dma_alloc_chan_resources(struct dma_chan *chan,

					 struct dma_client *client)

static int ioat_dma_alloc_chan_resources(struct dma_chan *chan)

{

	struct ioat_dma_chan *ioat_chan = to_ioat_chan(chan);

	struct ioat_desc_sw *desc;
@@ -1381,7 +1380,7 @@ static int ioat_dma_self_test(struct ioatdma_device *device) 
	dma_chan = container_of(device->common.channels.next,

				struct dma_chan,

				device_node);

	if (device->common.device_alloc_chan_resources(dma_chan, NULL) < 1) {

	if (device->common.device_alloc_chan_resources(dma_chan) < 1) {

		dev_err(&device->pdev->dev,

			"selftest cannot allocate chan resource\n");

		err = -ENODEV;

drivers/dma/iop-adma.c

+3 −4
Original line number Diff line number Diff line
@@ -470,8 +470,7 @@ static void iop_chan_start_null_xor(struct iop_adma_chan *iop_chan); 
 * greater than 2x the number slots needed to satisfy a device->max_xor

 * request.

 * */

static int iop_adma_alloc_chan_resources(struct dma_chan *chan,

					 struct dma_client *client)

static int iop_adma_alloc_chan_resources(struct dma_chan *chan)

{

	char *hw_desc;

	int idx;
@@ -865,7 +864,7 @@ static int __devinit iop_adma_memcpy_self_test(struct iop_adma_device *device) 
	dma_chan = container_of(device->common.channels.next,

				struct dma_chan,

				device_node);

	if (iop_adma_alloc_chan_resources(dma_chan, NULL) < 1) {

	if (iop_adma_alloc_chan_resources(dma_chan) < 1) {

		err = -ENODEV;

		goto out;

	}
@@ -963,7 +962,7 @@ iop_adma_xor_zero_sum_self_test(struct iop_adma_device *device) 
	dma_chan = container_of(device->common.channels.next,

				struct dma_chan,

				device_node);

	if (iop_adma_alloc_chan_resources(dma_chan, NULL) < 1) {

	if (iop_adma_alloc_chan_resources(dma_chan) < 1) {

		err = -ENODEV;

		goto out;

	}