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

Commit abfe7ae4 authored by Nicolas Ferre's avatar Nicolas Ferre
Browse files

crypto: atmel-sha - add support for Device Tree 



Add support for Device Tree and use of the DMA DT API to
get the channels if needed.
Documentation is added for these DT nodes.

Initial code by: Nicolas Royer and Eukrea.

Signed-off-by: default avatarNicolas Ferre <nicolas.ferre@atmel.com>
Acked-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>
parent 84c8976b

Documentation/devicetree/bindings/crypto/atmel-crypto.txt

+22 −0
Original line number Diff line number Diff line
@@ -44,3 +44,25 @@ tdes@f803c000 { 
	       <&dma1 2 21>;

	dma-names = "tx", "rx";

};



* Secure Hash Algorithm (SHA)



Required properties:

- compatible : Should be "atmel,at91sam9g46-sha".

- reg: Should contain SHA registers location and length.

- interrupts: Should contain the IRQ line for the SHA.



Optional properties:

- dmas: One DMA specifiers as described in

        atmel-dma.txt and dma.txt files.

- dma-names: Contains one identifier string for each DMA specifier

             in the dmas property. Only one "tx" string needed.



Example:

sha@f8034000 {

	compatible = "atmel,at91sam9g46-sha";

	reg = <0xf8034000 0x100>;

	interrupts = <42 4 0>;

	dmas = <&dma1 2 17>;

	dma-names = "tx";

};

drivers/crypto/atmel-sha.c

+75 −24
Original line number Diff line number Diff line
@@ -30,6 +30,7 @@ 
#include <linux/irq.h>

#include <linux/scatterlist.h>

#include <linux/dma-mapping.h>

#include <linux/of_device.h>

#include <linux/delay.h>

#include <linux/crypto.h>

#include <linux/cryptohash.h>
@@ -1263,16 +1264,16 @@ static int atmel_sha_dma_init(struct atmel_sha_dev *dd, 
	int err = -ENOMEM;

	dma_cap_mask_t mask_in;



	if (pdata && pdata->dma_slave->rxdata.dma_dev) {

	/* Try to grab DMA channel */

	dma_cap_zero(mask_in);

	dma_cap_set(DMA_SLAVE, mask_in);



		dd->dma_lch_in.chan = dma_request_channel(mask_in,

				atmel_sha_filter, &pdata->dma_slave->rxdata);



		if (!dd->dma_lch_in.chan)

	dd->dma_lch_in.chan = dma_request_slave_channel_compat(mask_in,

			atmel_sha_filter, &pdata->dma_slave->rxdata, dd->dev, "tx");

	if (!dd->dma_lch_in.chan) {

		dev_warn(dd->dev, "no DMA channel available\n");

		return err;

	}



	dd->dma_lch_in.dma_conf.direction = DMA_MEM_TO_DEV;

	dd->dma_lch_in.dma_conf.dst_addr = dd->phys_base +
@@ -1288,9 +1289,6 @@ static int atmel_sha_dma_init(struct atmel_sha_dev *dd, 
	return 0;

}



	return -ENODEV;

}



static void atmel_sha_dma_cleanup(struct atmel_sha_dev *dd)

{

	dma_release_channel(dd->dma_lch_in.chan);
@@ -1326,6 +1324,48 @@ static void atmel_sha_get_cap(struct atmel_sha_dev *dd) 
	}

}



#if defined(CONFIG_OF)

static const struct of_device_id atmel_sha_dt_ids[] = {

	{ .compatible = "atmel,at91sam9g46-sha" },

	{ /* sentinel */ }

};



MODULE_DEVICE_TABLE(of, atmel_sha_dt_ids);



static struct crypto_platform_data *atmel_sha_of_init(struct platform_device *pdev)

{

	struct device_node *np = pdev->dev.of_node;

	struct crypto_platform_data *pdata;



	if (!np) {

		dev_err(&pdev->dev, "device node not found\n");

		return ERR_PTR(-EINVAL);

	}



	pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);

	if (!pdata) {

		dev_err(&pdev->dev, "could not allocate memory for pdata\n");

		return ERR_PTR(-ENOMEM);

	}



	pdata->dma_slave = devm_kzalloc(&pdev->dev,

					sizeof(*(pdata->dma_slave)),

					GFP_KERNEL);

	if (!pdata->dma_slave) {

		dev_err(&pdev->dev, "could not allocate memory for dma_slave\n");

		devm_kfree(&pdev->dev, pdata);

		return ERR_PTR(-ENOMEM);

	}



	return pdata;

}

#else /* CONFIG_OF */

static inline struct crypto_platform_data *atmel_sha_of_init(struct platform_device *dev)

{

	return ERR_PTR(-EINVAL);

}

#endif



static int atmel_sha_probe(struct platform_device *pdev)

{

	struct atmel_sha_dev *sha_dd;
@@ -1402,13 +1442,23 @@ static int atmel_sha_probe(struct platform_device *pdev) 
	if (sha_dd->caps.has_dma) {

		pdata = pdev->dev.platform_data;

		if (!pdata) {

			pdata = atmel_sha_of_init(pdev);

			if (IS_ERR(pdata)) {

				dev_err(&pdev->dev, "platform data not available\n");

				err = PTR_ERR(pdata);

				goto err_pdata;

			}

		}

		if (!pdata->dma_slave) {

			err = -ENXIO;

			goto err_pdata;

		}

		err = atmel_sha_dma_init(sha_dd, pdata);

		if (err)

			goto err_sha_dma;



		dev_info(dev, "using %s for DMA transfers\n",

				dma_chan_name(sha_dd->dma_lch_in.chan));

	}



	spin_lock(&atmel_sha.lock);
@@ -1483,6 +1533,7 @@ static struct platform_driver atmel_sha_driver = { 
	.driver		= {

		.name	= "atmel_sha",

		.owner	= THIS_MODULE,

		.of_match_table	= of_match_ptr(atmel_sha_dt_ids),

	},

};