1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Microchip / Atmel ECC (I2C) driver.
  4 *
  5 * Copyright (c) 2017, Microchip Technology Inc.
  6 * Author: Tudor Ambarus <tudor.ambarus@microchip.com>
  7 */
  8
  9#include <linux/delay.h>
 10#include <linux/device.h>
 11#include <linux/err.h>
 12#include <linux/errno.h>
 13#include <linux/i2c.h>
 14#include <linux/init.h>
 15#include <linux/kernel.h>
 16#include <linux/module.h>
 17#include <linux/of_device.h>
 18#include <linux/scatterlist.h>
 19#include <linux/slab.h>
 20#include <linux/workqueue.h>
 21#include <crypto/internal/kpp.h>
 22#include <crypto/ecdh.h>
 23#include <crypto/kpp.h>
 24#include "atmel-i2c.h"
 25
 26static struct atmel_ecc_driver_data driver_data;
 27
 28/**
 29 * atmel_ecdh_ctx - transformation context
 30 * @client     : pointer to i2c client device
 31 * @fallback   : used for unsupported curves or when user wants to use its own
 32 *               private key.
 33 * @public_key : generated when calling set_secret(). It's the responsibility
 34 *               of the user to not call set_secret() while
 35 *               generate_public_key() or compute_shared_secret() are in flight.
 36 * @curve_id   : elliptic curve id
 37 * @n_sz       : size in bytes of the n prime
 38 * @do_fallback: true when the device doesn't support the curve or when the user
 39 *               wants to use its own private key.
 40 */
 41struct atmel_ecdh_ctx {
 42	struct i2c_client *client;
 43	struct crypto_kpp *fallback;
 44	const u8 *public_key;
 45	unsigned int curve_id;
 46	size_t n_sz;
 47	bool do_fallback;
 48};
 49
 50static void atmel_ecdh_done(struct atmel_i2c_work_data *work_data, void *areq,
 51			    int status)
 52{
 53	struct kpp_request *req = areq;
 54	struct atmel_ecdh_ctx *ctx = work_data->ctx;
 55	struct atmel_i2c_cmd *cmd = &work_data->cmd;
 56	size_t copied, n_sz;
 57
 58	if (status)
 59		goto free_work_data;
 60
 61	/* might want less than we've got */
 62	n_sz = min_t(size_t, ctx->n_sz, req->dst_len);
 63
 64	/* copy the shared secret */
 65	copied = sg_copy_from_buffer(req->dst, sg_nents_for_len(req->dst, n_sz),
 66				     &cmd->data[RSP_DATA_IDX], n_sz);
 67	if (copied != n_sz)
 68		status = -EINVAL;
 69
 70	/* fall through */
 71free_work_data:
 72	kfree_sensitive(work_data);
 73	kpp_request_complete(req, status);
 74}
 75
 76static unsigned int atmel_ecdh_supported_curve(unsigned int curve_id)
 77{
 78	if (curve_id == ECC_CURVE_NIST_P256)
 79		return ATMEL_ECC_NIST_P256_N_SIZE;
 80
 81	return 0;
 82}
 83
 84/*
 85 * A random private key is generated and stored in the device. The device
 86 * returns the pair public key.
 87 */
 88static int atmel_ecdh_set_secret(struct crypto_kpp *tfm, const void *buf,
 89				 unsigned int len)
 90{
 91	struct atmel_ecdh_ctx *ctx = kpp_tfm_ctx(tfm);
 92	struct atmel_i2c_cmd *cmd;
 93	void *public_key;
 94	struct ecdh params;
 95	int ret = -ENOMEM;
 96
 97	/* free the old public key, if any */
 98	kfree(ctx->public_key);
 99	/* make sure you don't free the old public key twice */
100	ctx->public_key = NULL;
101
102	if (crypto_ecdh_decode_key(buf, len, &params) < 0) {
103		dev_err(&ctx->client->dev, "crypto_ecdh_decode_key failed\n");
104		return -EINVAL;
105	}
106
107	ctx->n_sz = atmel_ecdh_supported_curve(params.curve_id);
108	if (!ctx->n_sz || params.key_size) {
109		/* fallback to ecdh software implementation */
110		ctx->do_fallback = true;
111		return crypto_kpp_set_secret(ctx->fallback, buf, len);
112	}
113
114	cmd = kmalloc(sizeof(*cmd), GFP_KERNEL);
115	if (!cmd)
116		return -ENOMEM;
117
118	/*
119	 * The device only supports NIST P256 ECC keys. The public key size will
120	 * always be the same. Use a macro for the key size to avoid unnecessary
121	 * computations.
122	 */
123	public_key = kmalloc(ATMEL_ECC_PUBKEY_SIZE, GFP_KERNEL);
124	if (!public_key)
125		goto free_cmd;
126
127	ctx->do_fallback = false;
128	ctx->curve_id = params.curve_id;
129
130	atmel_i2c_init_genkey_cmd(cmd, DATA_SLOT_2);
131
132	ret = atmel_i2c_send_receive(ctx->client, cmd);
133	if (ret)
134		goto free_public_key;
135
136	/* save the public key */
137	memcpy(public_key, &cmd->data[RSP_DATA_IDX], ATMEL_ECC_PUBKEY_SIZE);
138	ctx->public_key = public_key;
139
140	kfree(cmd);
141	return 0;
142
143free_public_key:
144	kfree(public_key);
145free_cmd:
146	kfree(cmd);
147	return ret;
148}
149
150static int atmel_ecdh_generate_public_key(struct kpp_request *req)
151{
152	struct crypto_kpp *tfm = crypto_kpp_reqtfm(req);
153	struct atmel_ecdh_ctx *ctx = kpp_tfm_ctx(tfm);
154	size_t copied, nbytes;
155	int ret = 0;
156
157	if (ctx->do_fallback) {
158		kpp_request_set_tfm(req, ctx->fallback);
159		return crypto_kpp_generate_public_key(req);
160	}
161
162	if (!ctx->public_key)
163		return -EINVAL;
164
165	/* might want less than we've got */
166	nbytes = min_t(size_t, ATMEL_ECC_PUBKEY_SIZE, req->dst_len);
167
168	/* public key was saved at private key generation */
169	copied = sg_copy_from_buffer(req->dst,
170				     sg_nents_for_len(req->dst, nbytes),
171				     ctx->public_key, nbytes);
172	if (copied != nbytes)
173		ret = -EINVAL;
174
175	return ret;
176}
177
178static int atmel_ecdh_compute_shared_secret(struct kpp_request *req)
179{
180	struct crypto_kpp *tfm = crypto_kpp_reqtfm(req);
181	struct atmel_ecdh_ctx *ctx = kpp_tfm_ctx(tfm);
182	struct atmel_i2c_work_data *work_data;
183	gfp_t gfp;
184	int ret;
185
186	if (ctx->do_fallback) {
187		kpp_request_set_tfm(req, ctx->fallback);
188		return crypto_kpp_compute_shared_secret(req);
189	}
190
191	/* must have exactly two points to be on the curve */
192	if (req->src_len != ATMEL_ECC_PUBKEY_SIZE)
193		return -EINVAL;
194
195	gfp = (req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP) ? GFP_KERNEL :
196							     GFP_ATOMIC;
197
198	work_data = kmalloc(sizeof(*work_data), gfp);
199	if (!work_data)
200		return -ENOMEM;
201
202	work_data->ctx = ctx;
203	work_data->client = ctx->client;
204
205	ret = atmel_i2c_init_ecdh_cmd(&work_data->cmd, req->src);
206	if (ret)
207		goto free_work_data;
208
209	atmel_i2c_enqueue(work_data, atmel_ecdh_done, req);
210
211	return -EINPROGRESS;
212
213free_work_data:
214	kfree(work_data);
215	return ret;
216}
217
218static struct i2c_client *atmel_ecc_i2c_client_alloc(void)
219{
220	struct atmel_i2c_client_priv *i2c_priv, *min_i2c_priv = NULL;
221	struct i2c_client *client = ERR_PTR(-ENODEV);
222	int min_tfm_cnt = INT_MAX;
223	int tfm_cnt;
224
225	spin_lock(&driver_data.i2c_list_lock);
226
227	if (list_empty(&driver_data.i2c_client_list)) {
228		spin_unlock(&driver_data.i2c_list_lock);
229		return ERR_PTR(-ENODEV);
230	}
231
232	list_for_each_entry(i2c_priv, &driver_data.i2c_client_list,
233			    i2c_client_list_node) {
234		tfm_cnt = atomic_read(&i2c_priv->tfm_count);
235		if (tfm_cnt < min_tfm_cnt) {
236			min_tfm_cnt = tfm_cnt;
237			min_i2c_priv = i2c_priv;
238		}
239		if (!min_tfm_cnt)
240			break;
241	}
242
243	if (min_i2c_priv) {
244		atomic_inc(&min_i2c_priv->tfm_count);
245		client = min_i2c_priv->client;
246	}
247
248	spin_unlock(&driver_data.i2c_list_lock);
249
250	return client;
251}
252
253static void atmel_ecc_i2c_client_free(struct i2c_client *client)
254{
255	struct atmel_i2c_client_priv *i2c_priv = i2c_get_clientdata(client);
256
257	atomic_dec(&i2c_priv->tfm_count);
258}
259
260static int atmel_ecdh_init_tfm(struct crypto_kpp *tfm)
261{
262	const char *alg = kpp_alg_name(tfm);
263	struct crypto_kpp *fallback;
264	struct atmel_ecdh_ctx *ctx = kpp_tfm_ctx(tfm);
265
266	ctx->client = atmel_ecc_i2c_client_alloc();
267	if (IS_ERR(ctx->client)) {
268		pr_err("tfm - i2c_client binding failed\n");
269		return PTR_ERR(ctx->client);
270	}
271
272	fallback = crypto_alloc_kpp(alg, 0, CRYPTO_ALG_NEED_FALLBACK);
273	if (IS_ERR(fallback)) {
274		dev_err(&ctx->client->dev, "Failed to allocate transformation for '%s': %ld\n",
275			alg, PTR_ERR(fallback));
276		return PTR_ERR(fallback);
277	}
278
279	crypto_kpp_set_flags(fallback, crypto_kpp_get_flags(tfm));
280	ctx->fallback = fallback;
281
282	return 0;
283}
284
285static void atmel_ecdh_exit_tfm(struct crypto_kpp *tfm)
286{
287	struct atmel_ecdh_ctx *ctx = kpp_tfm_ctx(tfm);
288
289	kfree(ctx->public_key);
290	crypto_free_kpp(ctx->fallback);
291	atmel_ecc_i2c_client_free(ctx->client);
292}
293
294static unsigned int atmel_ecdh_max_size(struct crypto_kpp *tfm)
295{
296	struct atmel_ecdh_ctx *ctx = kpp_tfm_ctx(tfm);
297
298	if (ctx->fallback)
299		return crypto_kpp_maxsize(ctx->fallback);
300
301	/*
302	 * The device only supports NIST P256 ECC keys. The public key size will
303	 * always be the same. Use a macro for the key size to avoid unnecessary
304	 * computations.
305	 */
306	return ATMEL_ECC_PUBKEY_SIZE;
307}
308
309static struct kpp_alg atmel_ecdh = {
310	.set_secret = atmel_ecdh_set_secret,
311	.generate_public_key = atmel_ecdh_generate_public_key,
312	.compute_shared_secret = atmel_ecdh_compute_shared_secret,
313	.init = atmel_ecdh_init_tfm,
314	.exit = atmel_ecdh_exit_tfm,
315	.max_size = atmel_ecdh_max_size,
316	.base = {
317		.cra_flags = CRYPTO_ALG_NEED_FALLBACK,
318		.cra_name = "ecdh",
319		.cra_driver_name = "atmel-ecdh",
320		.cra_priority = ATMEL_ECC_PRIORITY,
321		.cra_module = THIS_MODULE,
322		.cra_ctxsize = sizeof(struct atmel_ecdh_ctx),
323	},
324};
325
326static int atmel_ecc_probe(struct i2c_client *client,
327			   const struct i2c_device_id *id)
328{
329	struct atmel_i2c_client_priv *i2c_priv;
330	int ret;
331
332	ret = atmel_i2c_probe(client, id);
333	if (ret)
334		return ret;
335
336	i2c_priv = i2c_get_clientdata(client);
337
338	spin_lock(&driver_data.i2c_list_lock);
339	list_add_tail(&i2c_priv->i2c_client_list_node,
340		      &driver_data.i2c_client_list);
341	spin_unlock(&driver_data.i2c_list_lock);
342
343	ret = crypto_register_kpp(&atmel_ecdh);
344	if (ret) {
345		spin_lock(&driver_data.i2c_list_lock);
346		list_del(&i2c_priv->i2c_client_list_node);
347		spin_unlock(&driver_data.i2c_list_lock);
348
349		dev_err(&client->dev, "%s alg registration failed\n",
350			atmel_ecdh.base.cra_driver_name);
351	} else {
352		dev_info(&client->dev, "atmel ecc algorithms registered in /proc/crypto\n");
353	}
354
355	return ret;
356}
357
358static int atmel_ecc_remove(struct i2c_client *client)
359{
360	struct atmel_i2c_client_priv *i2c_priv = i2c_get_clientdata(client);
361
362	/* Return EBUSY if i2c client already allocated. */
363	if (atomic_read(&i2c_priv->tfm_count)) {
364		dev_err(&client->dev, "Device is busy\n");
365		return -EBUSY;
366	}
367
368	crypto_unregister_kpp(&atmel_ecdh);
369
370	spin_lock(&driver_data.i2c_list_lock);
371	list_del(&i2c_priv->i2c_client_list_node);
372	spin_unlock(&driver_data.i2c_list_lock);
373
374	return 0;
375}
376
377#ifdef CONFIG_OF
378static const struct of_device_id atmel_ecc_dt_ids[] = {
379	{
380		.compatible = "atmel,atecc508a",
381	}, {
382		/* sentinel */
383	}
384};
385MODULE_DEVICE_TABLE(of, atmel_ecc_dt_ids);
386#endif
387
388static const struct i2c_device_id atmel_ecc_id[] = {
389	{ "atecc508a", 0 },
390	{ }
391};
392MODULE_DEVICE_TABLE(i2c, atmel_ecc_id);
393
394static struct i2c_driver atmel_ecc_driver = {
395	.driver = {
396		.name	= "atmel-ecc",
397		.of_match_table = of_match_ptr(atmel_ecc_dt_ids),
398	},
399	.probe		= atmel_ecc_probe,
400	.remove		= atmel_ecc_remove,
401	.id_table	= atmel_ecc_id,
402};
403
404static int __init atmel_ecc_init(void)
405{
406	spin_lock_init(&driver_data.i2c_list_lock);
407	INIT_LIST_HEAD(&driver_data.i2c_client_list);
408	return i2c_add_driver(&atmel_ecc_driver);
409}
410
411static void __exit atmel_ecc_exit(void)
412{
413	flush_scheduled_work();
414	i2c_del_driver(&atmel_ecc_driver);
415}
416
417module_init(atmel_ecc_init);
418module_exit(atmel_ecc_exit);
419
420MODULE_AUTHOR("Tudor Ambarus <tudor.ambarus@microchip.com>");
421MODULE_DESCRIPTION("Microchip / Atmel ECC (I2C) driver");
422MODULE_LICENSE("GPL v2");

  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Microchip / Atmel ECC (I2C) driver.
  4 *
  5 * Copyright (c) 2017, Microchip Technology Inc.
  6 * Author: Tudor Ambarus <tudor.ambarus@microchip.com>
  7 */
  8
  9#include <linux/delay.h>
 10#include <linux/device.h>
 11#include <linux/err.h>
 12#include <linux/errno.h>
 13#include <linux/i2c.h>
 14#include <linux/init.h>
 15#include <linux/kernel.h>
 16#include <linux/module.h>
 17#include <linux/of_device.h>
 18#include <linux/scatterlist.h>
 19#include <linux/slab.h>
 20#include <linux/workqueue.h>
 21#include <crypto/internal/kpp.h>
 22#include <crypto/ecdh.h>
 23#include <crypto/kpp.h>
 24#include "atmel-i2c.h"
 25
 26static struct atmel_ecc_driver_data driver_data;
 27
 28/**
 29 * atmel_ecdh_ctx - transformation context
 30 * @client     : pointer to i2c client device
 31 * @fallback   : used for unsupported curves or when user wants to use its own
 32 *               private key.
 33 * @public_key : generated when calling set_secret(). It's the responsibility
 34 *               of the user to not call set_secret() while
 35 *               generate_public_key() or compute_shared_secret() are in flight.
 36 * @curve_id   : elliptic curve id
 37 * @n_sz       : size in bytes of the n prime
 38 * @do_fallback: true when the device doesn't support the curve or when the user
 39 *               wants to use its own private key.
 40 */
 41struct atmel_ecdh_ctx {
 42	struct i2c_client *client;
 43	struct crypto_kpp *fallback;
 44	const u8 *public_key;
 45	unsigned int curve_id;
 46	size_t n_sz;
 47	bool do_fallback;
 48};
 49
 50static void atmel_ecdh_done(struct atmel_i2c_work_data *work_data, void *areq,
 51			    int status)
 52{
 53	struct kpp_request *req = areq;
 54	struct atmel_ecdh_ctx *ctx = work_data->ctx;
 55	struct atmel_i2c_cmd *cmd = &work_data->cmd;
 56	size_t copied, n_sz;
 57
 58	if (status)
 59		goto free_work_data;
 60
 61	/* might want less than we've got */
 62	n_sz = min_t(size_t, ctx->n_sz, req->dst_len);
 63
 64	/* copy the shared secret */
 65	copied = sg_copy_from_buffer(req->dst, sg_nents_for_len(req->dst, n_sz),
 66				     &cmd->data[RSP_DATA_IDX], n_sz);
 67	if (copied != n_sz)
 68		status = -EINVAL;
 69
 70	/* fall through */
 71free_work_data:
 72	kzfree(work_data);
 73	kpp_request_complete(req, status);
 74}
 75
 76static unsigned int atmel_ecdh_supported_curve(unsigned int curve_id)
 77{
 78	if (curve_id == ECC_CURVE_NIST_P256)
 79		return ATMEL_ECC_NIST_P256_N_SIZE;
 80
 81	return 0;
 82}
 83
 84/*
 85 * A random private key is generated and stored in the device. The device
 86 * returns the pair public key.
 87 */
 88static int atmel_ecdh_set_secret(struct crypto_kpp *tfm, const void *buf,
 89				 unsigned int len)
 90{
 91	struct atmel_ecdh_ctx *ctx = kpp_tfm_ctx(tfm);
 92	struct atmel_i2c_cmd *cmd;
 93	void *public_key;
 94	struct ecdh params;
 95	int ret = -ENOMEM;
 96
 97	/* free the old public key, if any */
 98	kfree(ctx->public_key);
 99	/* make sure you don't free the old public key twice */
100	ctx->public_key = NULL;
101
102	if (crypto_ecdh_decode_key(buf, len, &params) < 0) {
103		dev_err(&ctx->client->dev, "crypto_ecdh_decode_key failed\n");
104		return -EINVAL;
105	}
106
107	ctx->n_sz = atmel_ecdh_supported_curve(params.curve_id);
108	if (!ctx->n_sz || params.key_size) {
109		/* fallback to ecdh software implementation */
110		ctx->do_fallback = true;
111		return crypto_kpp_set_secret(ctx->fallback, buf, len);
112	}
113
114	cmd = kmalloc(sizeof(*cmd), GFP_KERNEL);
115	if (!cmd)
116		return -ENOMEM;
117
118	/*
119	 * The device only supports NIST P256 ECC keys. The public key size will
120	 * always be the same. Use a macro for the key size to avoid unnecessary
121	 * computations.
122	 */
123	public_key = kmalloc(ATMEL_ECC_PUBKEY_SIZE, GFP_KERNEL);
124	if (!public_key)
125		goto free_cmd;
126
127	ctx->do_fallback = false;
128	ctx->curve_id = params.curve_id;
129
130	atmel_i2c_init_genkey_cmd(cmd, DATA_SLOT_2);
131
132	ret = atmel_i2c_send_receive(ctx->client, cmd);
133	if (ret)
134		goto free_public_key;
135
136	/* save the public key */
137	memcpy(public_key, &cmd->data[RSP_DATA_IDX], ATMEL_ECC_PUBKEY_SIZE);
138	ctx->public_key = public_key;
139
140	kfree(cmd);
141	return 0;
142
143free_public_key:
144	kfree(public_key);
145free_cmd:
146	kfree(cmd);
147	return ret;
148}
149
150static int atmel_ecdh_generate_public_key(struct kpp_request *req)
151{
152	struct crypto_kpp *tfm = crypto_kpp_reqtfm(req);
153	struct atmel_ecdh_ctx *ctx = kpp_tfm_ctx(tfm);
154	size_t copied, nbytes;
155	int ret = 0;
156
157	if (ctx->do_fallback) {
158		kpp_request_set_tfm(req, ctx->fallback);
159		return crypto_kpp_generate_public_key(req);
160	}
161
162	if (!ctx->public_key)
163		return -EINVAL;
164
165	/* might want less than we've got */
166	nbytes = min_t(size_t, ATMEL_ECC_PUBKEY_SIZE, req->dst_len);
167
168	/* public key was saved at private key generation */
169	copied = sg_copy_from_buffer(req->dst,
170				     sg_nents_for_len(req->dst, nbytes),
171				     ctx->public_key, nbytes);
172	if (copied != nbytes)
173		ret = -EINVAL;
174
175	return ret;
176}
177
178static int atmel_ecdh_compute_shared_secret(struct kpp_request *req)
179{
180	struct crypto_kpp *tfm = crypto_kpp_reqtfm(req);
181	struct atmel_ecdh_ctx *ctx = kpp_tfm_ctx(tfm);
182	struct atmel_i2c_work_data *work_data;
183	gfp_t gfp;
184	int ret;
185
186	if (ctx->do_fallback) {
187		kpp_request_set_tfm(req, ctx->fallback);
188		return crypto_kpp_compute_shared_secret(req);
189	}
190
191	/* must have exactly two points to be on the curve */
192	if (req->src_len != ATMEL_ECC_PUBKEY_SIZE)
193		return -EINVAL;
194
195	gfp = (req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP) ? GFP_KERNEL :
196							     GFP_ATOMIC;
197
198	work_data = kmalloc(sizeof(*work_data), gfp);
199	if (!work_data)
200		return -ENOMEM;
201
202	work_data->ctx = ctx;
203	work_data->client = ctx->client;
204
205	ret = atmel_i2c_init_ecdh_cmd(&work_data->cmd, req->src);
206	if (ret)
207		goto free_work_data;
208
209	atmel_i2c_enqueue(work_data, atmel_ecdh_done, req);
210
211	return -EINPROGRESS;
212
213free_work_data:
214	kfree(work_data);
215	return ret;
216}
217
218static struct i2c_client *atmel_ecc_i2c_client_alloc(void)
219{
220	struct atmel_i2c_client_priv *i2c_priv, *min_i2c_priv = NULL;
221	struct i2c_client *client = ERR_PTR(-ENODEV);
222	int min_tfm_cnt = INT_MAX;
223	int tfm_cnt;
224
225	spin_lock(&driver_data.i2c_list_lock);
226
227	if (list_empty(&driver_data.i2c_client_list)) {
228		spin_unlock(&driver_data.i2c_list_lock);
229		return ERR_PTR(-ENODEV);
230	}
231
232	list_for_each_entry(i2c_priv, &driver_data.i2c_client_list,
233			    i2c_client_list_node) {
234		tfm_cnt = atomic_read(&i2c_priv->tfm_count);
235		if (tfm_cnt < min_tfm_cnt) {
236			min_tfm_cnt = tfm_cnt;
237			min_i2c_priv = i2c_priv;
238		}
239		if (!min_tfm_cnt)
240			break;
241	}
242
243	if (min_i2c_priv) {
244		atomic_inc(&min_i2c_priv->tfm_count);
245		client = min_i2c_priv->client;
246	}
247
248	spin_unlock(&driver_data.i2c_list_lock);
249
250	return client;
251}
252
253static void atmel_ecc_i2c_client_free(struct i2c_client *client)
254{
255	struct atmel_i2c_client_priv *i2c_priv = i2c_get_clientdata(client);
256
257	atomic_dec(&i2c_priv->tfm_count);
258}
259
260static int atmel_ecdh_init_tfm(struct crypto_kpp *tfm)
261{
262	const char *alg = kpp_alg_name(tfm);
263	struct crypto_kpp *fallback;
264	struct atmel_ecdh_ctx *ctx = kpp_tfm_ctx(tfm);
265
266	ctx->client = atmel_ecc_i2c_client_alloc();
267	if (IS_ERR(ctx->client)) {
268		pr_err("tfm - i2c_client binding failed\n");
269		return PTR_ERR(ctx->client);
270	}
271
272	fallback = crypto_alloc_kpp(alg, 0, CRYPTO_ALG_NEED_FALLBACK);
273	if (IS_ERR(fallback)) {
274		dev_err(&ctx->client->dev, "Failed to allocate transformation for '%s': %ld\n",
275			alg, PTR_ERR(fallback));
276		return PTR_ERR(fallback);
277	}
278
279	crypto_kpp_set_flags(fallback, crypto_kpp_get_flags(tfm));
280	ctx->fallback = fallback;
281
282	return 0;
283}
284
285static void atmel_ecdh_exit_tfm(struct crypto_kpp *tfm)
286{
287	struct atmel_ecdh_ctx *ctx = kpp_tfm_ctx(tfm);
288
289	kfree(ctx->public_key);
290	crypto_free_kpp(ctx->fallback);
291	atmel_ecc_i2c_client_free(ctx->client);
292}
293
294static unsigned int atmel_ecdh_max_size(struct crypto_kpp *tfm)
295{
296	struct atmel_ecdh_ctx *ctx = kpp_tfm_ctx(tfm);
297
298	if (ctx->fallback)
299		return crypto_kpp_maxsize(ctx->fallback);
300
301	/*
302	 * The device only supports NIST P256 ECC keys. The public key size will
303	 * always be the same. Use a macro for the key size to avoid unnecessary
304	 * computations.
305	 */
306	return ATMEL_ECC_PUBKEY_SIZE;
307}
308
309static struct kpp_alg atmel_ecdh = {
310	.set_secret = atmel_ecdh_set_secret,
311	.generate_public_key = atmel_ecdh_generate_public_key,
312	.compute_shared_secret = atmel_ecdh_compute_shared_secret,
313	.init = atmel_ecdh_init_tfm,
314	.exit = atmel_ecdh_exit_tfm,
315	.max_size = atmel_ecdh_max_size,
316	.base = {
317		.cra_flags = CRYPTO_ALG_NEED_FALLBACK,
318		.cra_name = "ecdh",
319		.cra_driver_name = "atmel-ecdh",
320		.cra_priority = ATMEL_ECC_PRIORITY,
321		.cra_module = THIS_MODULE,
322		.cra_ctxsize = sizeof(struct atmel_ecdh_ctx),
323	},
324};
325
326static int atmel_ecc_probe(struct i2c_client *client,
327			   const struct i2c_device_id *id)
328{
329	struct atmel_i2c_client_priv *i2c_priv;
330	int ret;
331
332	ret = atmel_i2c_probe(client, id);
333	if (ret)
334		return ret;
335
336	i2c_priv = i2c_get_clientdata(client);
337
338	spin_lock(&driver_data.i2c_list_lock);
339	list_add_tail(&i2c_priv->i2c_client_list_node,
340		      &driver_data.i2c_client_list);
341	spin_unlock(&driver_data.i2c_list_lock);
342
343	ret = crypto_register_kpp(&atmel_ecdh);
344	if (ret) {
345		spin_lock(&driver_data.i2c_list_lock);
346		list_del(&i2c_priv->i2c_client_list_node);
347		spin_unlock(&driver_data.i2c_list_lock);
348
349		dev_err(&client->dev, "%s alg registration failed\n",
350			atmel_ecdh.base.cra_driver_name);
351	} else {
352		dev_info(&client->dev, "atmel ecc algorithms registered in /proc/crypto\n");
353	}
354
355	return ret;
356}
357
358static int atmel_ecc_remove(struct i2c_client *client)
359{
360	struct atmel_i2c_client_priv *i2c_priv = i2c_get_clientdata(client);
361
362	/* Return EBUSY if i2c client already allocated. */
363	if (atomic_read(&i2c_priv->tfm_count)) {
364		dev_err(&client->dev, "Device is busy\n");
365		return -EBUSY;
366	}
367
368	crypto_unregister_kpp(&atmel_ecdh);
369
370	spin_lock(&driver_data.i2c_list_lock);
371	list_del(&i2c_priv->i2c_client_list_node);
372	spin_unlock(&driver_data.i2c_list_lock);
373
374	return 0;
375}
376
377#ifdef CONFIG_OF
378static const struct of_device_id atmel_ecc_dt_ids[] = {
379	{
380		.compatible = "atmel,atecc508a",
381	}, {
382		/* sentinel */
383	}
384};
385MODULE_DEVICE_TABLE(of, atmel_ecc_dt_ids);
386#endif
387
388static const struct i2c_device_id atmel_ecc_id[] = {
389	{ "atecc508a", 0 },
390	{ }
391};
392MODULE_DEVICE_TABLE(i2c, atmel_ecc_id);
393
394static struct i2c_driver atmel_ecc_driver = {
395	.driver = {
396		.name	= "atmel-ecc",
397		.of_match_table = of_match_ptr(atmel_ecc_dt_ids),
398	},
399	.probe		= atmel_ecc_probe,
400	.remove		= atmel_ecc_remove,
401	.id_table	= atmel_ecc_id,
402};
403
404static int __init atmel_ecc_init(void)
405{
406	spin_lock_init(&driver_data.i2c_list_lock);
407	INIT_LIST_HEAD(&driver_data.i2c_client_list);
408	return i2c_add_driver(&atmel_ecc_driver);
409}
410
411static void __exit atmel_ecc_exit(void)
412{
413	flush_scheduled_work();
414	i2c_del_driver(&atmel_ecc_driver);
415}
416
417module_init(atmel_ecc_init);
418module_exit(atmel_ecc_exit);
419
420MODULE_AUTHOR("Tudor Ambarus <tudor.ambarus@microchip.com>");
421MODULE_DESCRIPTION("Microchip / Atmel ECC (I2C) driver");
422MODULE_LICENSE("GPL v2");