Commit 8f2d751a authored by Olof Johansson's avatar Olof Johansson
Browse files

Merge tag 'at91-drivers' of git://github.com/at91linux/linux-at91 into next/drivers 

From Nicolas Ferre:

AT91 crypto drivers DT support:
- add DT to sha/des/aes existing drivers
- add DMA DT
- all documentation added to crypto/atmel-crypto.txt file

* tag 'at91-drivers' of git://github.com/at91linux/linux-at91

:
  crypto: atmel-sha - add sha information to the log
  crypto: atmel-sha - add support for Device Tree
  crypto: atmel-tdes - add support for Device Tree
  crypto: atmel-aes - add support for Device Tree

Signed-off-by: default avatarOlof Johansson <olof@lixom.net>
parents 958c025a 1ca5b7d9

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

0 → 100644
+68 −0
Original line number Diff line number Diff line 
* Atmel HW cryptographic accelerators



These are the HW cryptographic accelerators found on some Atmel products.



* Advanced Encryption Standard (AES)



Required properties:

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

- reg: Should contain AES registers location and length.

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

- dmas: List of two 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.



Example:

aes@f8038000 {

	compatible = "atmel,at91sam9g46-aes";

	reg = <0xf8038000 0x100>;

	interrupts = <43 4 0>;

	dmas = <&dma1 2 18>,

	       <&dma1 2 19>;

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



* Triple Data Encryption Standard (Triple DES)



Required properties:

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

- reg: Should contain TDES registers location and length.

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



Optional properties:

- dmas: List of two 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.



Example:

tdes@f803c000 {

	compatible = "atmel,at91sam9g46-tdes";

	reg = <0xf803c000 0x100>;

	interrupts = <44 4 0>;

	dmas = <&dma1 2 20>,

	       <&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-aes.c

+94 −49
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>
@@ -39,6 +40,7 @@ 
#include <crypto/hash.h>

#include <crypto/internal/hash.h>

#include <linux/platform_data/crypto-atmel.h>

#include <dt-bindings/dma/at91.h>

#include "atmel-aes-regs.h"



#define CFB8_BLOCK_SIZE		1
@@ -747,18 +749,14 @@ static int atmel_aes_dma_init(struct atmel_aes_dev *dd, 
	struct crypto_platform_data *pdata)

{

	int err = -ENOMEM;

	dma_cap_mask_t mask_in, mask_out;

	dma_cap_mask_t mask;



	if (pdata && pdata->dma_slave->txdata.dma_dev &&

		pdata->dma_slave->rxdata.dma_dev) {

	dma_cap_zero(mask);

	dma_cap_set(DMA_SLAVE, mask);



	/* Try to grab 2 DMA channels */

		dma_cap_zero(mask_in);

		dma_cap_set(DMA_SLAVE, mask_in);



		dd->dma_lch_in.chan = dma_request_channel(mask_in,

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



	dd->dma_lch_in.chan = dma_request_slave_channel_compat(mask,

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

	if (!dd->dma_lch_in.chan)

		goto err_dma_in;
@@ -773,11 +771,8 @@ static int atmel_aes_dma_init(struct atmel_aes_dev *dd, 
		DMA_SLAVE_BUSWIDTH_4_BYTES;

	dd->dma_lch_in.dma_conf.device_fc = false;



		dma_cap_zero(mask_out);

		dma_cap_set(DMA_SLAVE, mask_out);

		dd->dma_lch_out.chan = dma_request_channel(mask_out,

				atmel_aes_filter, &pdata->dma_slave->txdata);



	dd->dma_lch_out.chan = dma_request_slave_channel_compat(mask,

			atmel_aes_filter, &pdata->dma_slave->txdata, dd->dev, "rx");

	if (!dd->dma_lch_out.chan)

		goto err_dma_out;
@@ -793,13 +788,11 @@ static int atmel_aes_dma_init(struct atmel_aes_dev *dd, 
	dd->dma_lch_out.dma_conf.device_fc = false;



	return 0;

	} else {

		return -ENODEV;

	}



err_dma_out:

	dma_release_channel(dd->dma_lch_in.chan);

err_dma_in:

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

	return err;

}
@@ -1261,6 +1254,47 @@ static void atmel_aes_get_cap(struct atmel_aes_dev *dd) 
	}

}



#if defined(CONFIG_OF)

static const struct of_device_id atmel_aes_dt_ids[] = {

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

	{ /* sentinel */ }

};

MODULE_DEVICE_TABLE(of, atmel_aes_dt_ids);



static struct crypto_platform_data *atmel_aes_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

static inline struct crypto_platform_data *atmel_aes_of_init(struct platform_device *pdev)

{

	return ERR_PTR(-EINVAL);

}

#endif



static int atmel_aes_probe(struct platform_device *pdev)

{

	struct atmel_aes_dev *aes_dd;
@@ -1272,6 +1306,14 @@ static int atmel_aes_probe(struct platform_device *pdev) 


	pdata = pdev->dev.platform_data;

	if (!pdata) {

		pdata = atmel_aes_of_init(pdev);

		if (IS_ERR(pdata)) {

			err = PTR_ERR(pdata);

			goto aes_dd_err;

		}

	}



	if (!pdata->dma_slave) {

		err = -ENXIO;

		goto aes_dd_err;

	}
@@ -1358,7 +1400,9 @@ static int atmel_aes_probe(struct platform_device *pdev) 
	if (err)

		goto err_algs;



	dev_info(dev, "Atmel AES\n");

	dev_info(dev, "Atmel AES - Using %s, %s for DMA transfers\n",

			dma_chan_name(aes_dd->dma_lch_in.chan),

			dma_chan_name(aes_dd->dma_lch_out.chan));



	return 0;
@@ -1424,6 +1468,7 @@ static struct platform_driver atmel_aes_driver = { 
	.driver		= {

		.name	= "atmel_aes",

		.owner	= THIS_MODULE,

		.of_match_table = of_match_ptr(atmel_aes_dt_ids),

	},

};

drivers/crypto/atmel-sha.c

+78 −25
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);
@@ -1419,7 +1469,9 @@ static int atmel_sha_probe(struct platform_device *pdev) 
	if (err)

		goto err_algs;



	dev_info(dev, "Atmel SHA1/SHA256\n");

	dev_info(dev, "Atmel SHA1/SHA256%s%s\n",

			sha_dd->caps.has_sha224 ? "/SHA224" : "",

			sha_dd->caps.has_sha_384_512 ? "/SHA384/SHA512" : "");



	return 0;
@@ -1483,6 +1535,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),

	},

};

drivers/crypto/atmel-tdes.c

+94 −49
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>
@@ -716,18 +717,14 @@ static int atmel_tdes_dma_init(struct atmel_tdes_dev *dd, 
			struct crypto_platform_data *pdata)

{

	int err = -ENOMEM;

	dma_cap_mask_t mask_in, mask_out;

	dma_cap_mask_t mask;



	if (pdata && pdata->dma_slave->txdata.dma_dev &&

		pdata->dma_slave->rxdata.dma_dev) {

	dma_cap_zero(mask);

	dma_cap_set(DMA_SLAVE, mask);



	/* Try to grab 2 DMA channels */

		dma_cap_zero(mask_in);

		dma_cap_set(DMA_SLAVE, mask_in);



		dd->dma_lch_in.chan = dma_request_channel(mask_in,

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



	dd->dma_lch_in.chan = dma_request_slave_channel_compat(mask,

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

	if (!dd->dma_lch_in.chan)

		goto err_dma_in;
@@ -742,11 +739,8 @@ static int atmel_tdes_dma_init(struct atmel_tdes_dev *dd, 
		DMA_SLAVE_BUSWIDTH_4_BYTES;

	dd->dma_lch_in.dma_conf.device_fc = false;



		dma_cap_zero(mask_out);

		dma_cap_set(DMA_SLAVE, mask_out);

		dd->dma_lch_out.chan = dma_request_channel(mask_out,

				atmel_tdes_filter, &pdata->dma_slave->txdata);



	dd->dma_lch_out.chan = dma_request_slave_channel_compat(mask,

			atmel_tdes_filter, &pdata->dma_slave->txdata, dd->dev, "rx");

	if (!dd->dma_lch_out.chan)

		goto err_dma_out;
@@ -762,13 +756,11 @@ static int atmel_tdes_dma_init(struct atmel_tdes_dev *dd, 
	dd->dma_lch_out.dma_conf.device_fc = false;



	return 0;

	} else {

		return -ENODEV;

	}



err_dma_out:

	dma_release_channel(dd->dma_lch_in.chan);

err_dma_in:

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

	return err;

}
@@ -1317,6 +1309,47 @@ static void atmel_tdes_get_cap(struct atmel_tdes_dev *dd) 
	}

}



#if defined(CONFIG_OF)

static const struct of_device_id atmel_tdes_dt_ids[] = {

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

	{ /* sentinel */ }

};

MODULE_DEVICE_TABLE(of, atmel_tdes_dt_ids);



static struct crypto_platform_data *atmel_tdes_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_tdes_of_init(struct platform_device *pdev)

{

	return ERR_PTR(-EINVAL);

}

#endif



static int atmel_tdes_probe(struct platform_device *pdev)

{

	struct atmel_tdes_dev *tdes_dd;
@@ -1399,13 +1432,24 @@ static int atmel_tdes_probe(struct platform_device *pdev) 
	if (tdes_dd->caps.has_dma) {

		pdata = pdev->dev.platform_data;

		if (!pdata) {

			pdata = atmel_tdes_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_tdes_dma_init(tdes_dd, pdata);

		if (err)

			goto err_tdes_dma;



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

				dma_chan_name(tdes_dd->dma_lch_in.chan),

				dma_chan_name(tdes_dd->dma_lch_out.chan));

	}



	spin_lock(&atmel_tdes.lock);
@@ -1487,6 +1531,7 @@ static struct platform_driver atmel_tdes_driver = { 
	.driver		= {

		.name	= "atmel_tdes",

		.owner	= THIS_MODULE,

		.of_match_table = of_match_ptr(atmel_tdes_dt_ids),

	},

};

CRA Git | Maintained and supported by SUSTech CRA and CCSE