mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-23 17:30:02 +00:00
![Uwe Kleine-König](/assets/img/avatar_default.png)
Returning an error value in an i2c remove callback results in an error message being emitted by the i2c core, but otherwise it doesn't make a difference. The device goes away anyhow and the devm cleanups are called. As atmel_ecc_remove() already emits an error message on failure and the additional error message by the i2c core doesn't add any useful information, change the return value to zero to suppress this message. Also make the error message a bit more drastical because when the device is still busy on remove, it's likely that it will access freed memory soon. This patch is a preparation for making i2c remove callbacks return void. Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de> Reviewed-by: Tudor Ambarus <tudor.ambarus@microchip.com> Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
418 lines
10 KiB
C
418 lines
10 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Microchip / Atmel ECC (I2C) driver.
|
|
*
|
|
* Copyright (c) 2017, Microchip Technology Inc.
|
|
* Author: Tudor Ambarus <tudor.ambarus@microchip.com>
|
|
*/
|
|
|
|
#include <linux/delay.h>
|
|
#include <linux/device.h>
|
|
#include <linux/err.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/i2c.h>
|
|
#include <linux/init.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/of_device.h>
|
|
#include <linux/scatterlist.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/workqueue.h>
|
|
#include <crypto/internal/kpp.h>
|
|
#include <crypto/ecdh.h>
|
|
#include <crypto/kpp.h>
|
|
#include "atmel-i2c.h"
|
|
|
|
static struct atmel_ecc_driver_data driver_data;
|
|
|
|
/**
|
|
* struct atmel_ecdh_ctx - transformation context
|
|
* @client : pointer to i2c client device
|
|
* @fallback : used for unsupported curves or when user wants to use its own
|
|
* private key.
|
|
* @public_key : generated when calling set_secret(). It's the responsibility
|
|
* of the user to not call set_secret() while
|
|
* generate_public_key() or compute_shared_secret() are in flight.
|
|
* @curve_id : elliptic curve id
|
|
* @do_fallback: true when the device doesn't support the curve or when the user
|
|
* wants to use its own private key.
|
|
*/
|
|
struct atmel_ecdh_ctx {
|
|
struct i2c_client *client;
|
|
struct crypto_kpp *fallback;
|
|
const u8 *public_key;
|
|
unsigned int curve_id;
|
|
bool do_fallback;
|
|
};
|
|
|
|
static void atmel_ecdh_done(struct atmel_i2c_work_data *work_data, void *areq,
|
|
int status)
|
|
{
|
|
struct kpp_request *req = areq;
|
|
struct atmel_i2c_cmd *cmd = &work_data->cmd;
|
|
size_t copied, n_sz;
|
|
|
|
if (status)
|
|
goto free_work_data;
|
|
|
|
/* might want less than we've got */
|
|
n_sz = min_t(size_t, ATMEL_ECC_NIST_P256_N_SIZE, req->dst_len);
|
|
|
|
/* copy the shared secret */
|
|
copied = sg_copy_from_buffer(req->dst, sg_nents_for_len(req->dst, n_sz),
|
|
&cmd->data[RSP_DATA_IDX], n_sz);
|
|
if (copied != n_sz)
|
|
status = -EINVAL;
|
|
|
|
/* fall through */
|
|
free_work_data:
|
|
kfree_sensitive(work_data);
|
|
kpp_request_complete(req, status);
|
|
}
|
|
|
|
/*
|
|
* A random private key is generated and stored in the device. The device
|
|
* returns the pair public key.
|
|
*/
|
|
static int atmel_ecdh_set_secret(struct crypto_kpp *tfm, const void *buf,
|
|
unsigned int len)
|
|
{
|
|
struct atmel_ecdh_ctx *ctx = kpp_tfm_ctx(tfm);
|
|
struct atmel_i2c_cmd *cmd;
|
|
void *public_key;
|
|
struct ecdh params;
|
|
int ret = -ENOMEM;
|
|
|
|
/* free the old public key, if any */
|
|
kfree(ctx->public_key);
|
|
/* make sure you don't free the old public key twice */
|
|
ctx->public_key = NULL;
|
|
|
|
if (crypto_ecdh_decode_key(buf, len, ¶ms) < 0) {
|
|
dev_err(&ctx->client->dev, "crypto_ecdh_decode_key failed\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (params.key_size) {
|
|
/* fallback to ecdh software implementation */
|
|
ctx->do_fallback = true;
|
|
return crypto_kpp_set_secret(ctx->fallback, buf, len);
|
|
}
|
|
|
|
cmd = kmalloc(sizeof(*cmd), GFP_KERNEL);
|
|
if (!cmd)
|
|
return -ENOMEM;
|
|
|
|
/*
|
|
* The device only supports NIST P256 ECC keys. The public key size will
|
|
* always be the same. Use a macro for the key size to avoid unnecessary
|
|
* computations.
|
|
*/
|
|
public_key = kmalloc(ATMEL_ECC_PUBKEY_SIZE, GFP_KERNEL);
|
|
if (!public_key)
|
|
goto free_cmd;
|
|
|
|
ctx->do_fallback = false;
|
|
|
|
atmel_i2c_init_genkey_cmd(cmd, DATA_SLOT_2);
|
|
|
|
ret = atmel_i2c_send_receive(ctx->client, cmd);
|
|
if (ret)
|
|
goto free_public_key;
|
|
|
|
/* save the public key */
|
|
memcpy(public_key, &cmd->data[RSP_DATA_IDX], ATMEL_ECC_PUBKEY_SIZE);
|
|
ctx->public_key = public_key;
|
|
|
|
kfree(cmd);
|
|
return 0;
|
|
|
|
free_public_key:
|
|
kfree(public_key);
|
|
free_cmd:
|
|
kfree(cmd);
|
|
return ret;
|
|
}
|
|
|
|
static int atmel_ecdh_generate_public_key(struct kpp_request *req)
|
|
{
|
|
struct crypto_kpp *tfm = crypto_kpp_reqtfm(req);
|
|
struct atmel_ecdh_ctx *ctx = kpp_tfm_ctx(tfm);
|
|
size_t copied, nbytes;
|
|
int ret = 0;
|
|
|
|
if (ctx->do_fallback) {
|
|
kpp_request_set_tfm(req, ctx->fallback);
|
|
return crypto_kpp_generate_public_key(req);
|
|
}
|
|
|
|
if (!ctx->public_key)
|
|
return -EINVAL;
|
|
|
|
/* might want less than we've got */
|
|
nbytes = min_t(size_t, ATMEL_ECC_PUBKEY_SIZE, req->dst_len);
|
|
|
|
/* public key was saved at private key generation */
|
|
copied = sg_copy_from_buffer(req->dst,
|
|
sg_nents_for_len(req->dst, nbytes),
|
|
ctx->public_key, nbytes);
|
|
if (copied != nbytes)
|
|
ret = -EINVAL;
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int atmel_ecdh_compute_shared_secret(struct kpp_request *req)
|
|
{
|
|
struct crypto_kpp *tfm = crypto_kpp_reqtfm(req);
|
|
struct atmel_ecdh_ctx *ctx = kpp_tfm_ctx(tfm);
|
|
struct atmel_i2c_work_data *work_data;
|
|
gfp_t gfp;
|
|
int ret;
|
|
|
|
if (ctx->do_fallback) {
|
|
kpp_request_set_tfm(req, ctx->fallback);
|
|
return crypto_kpp_compute_shared_secret(req);
|
|
}
|
|
|
|
/* must have exactly two points to be on the curve */
|
|
if (req->src_len != ATMEL_ECC_PUBKEY_SIZE)
|
|
return -EINVAL;
|
|
|
|
gfp = (req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP) ? GFP_KERNEL :
|
|
GFP_ATOMIC;
|
|
|
|
work_data = kmalloc(sizeof(*work_data), gfp);
|
|
if (!work_data)
|
|
return -ENOMEM;
|
|
|
|
work_data->ctx = ctx;
|
|
work_data->client = ctx->client;
|
|
|
|
ret = atmel_i2c_init_ecdh_cmd(&work_data->cmd, req->src);
|
|
if (ret)
|
|
goto free_work_data;
|
|
|
|
atmel_i2c_enqueue(work_data, atmel_ecdh_done, req);
|
|
|
|
return -EINPROGRESS;
|
|
|
|
free_work_data:
|
|
kfree(work_data);
|
|
return ret;
|
|
}
|
|
|
|
static struct i2c_client *atmel_ecc_i2c_client_alloc(void)
|
|
{
|
|
struct atmel_i2c_client_priv *i2c_priv, *min_i2c_priv = NULL;
|
|
struct i2c_client *client = ERR_PTR(-ENODEV);
|
|
int min_tfm_cnt = INT_MAX;
|
|
int tfm_cnt;
|
|
|
|
spin_lock(&driver_data.i2c_list_lock);
|
|
|
|
if (list_empty(&driver_data.i2c_client_list)) {
|
|
spin_unlock(&driver_data.i2c_list_lock);
|
|
return ERR_PTR(-ENODEV);
|
|
}
|
|
|
|
list_for_each_entry(i2c_priv, &driver_data.i2c_client_list,
|
|
i2c_client_list_node) {
|
|
tfm_cnt = atomic_read(&i2c_priv->tfm_count);
|
|
if (tfm_cnt < min_tfm_cnt) {
|
|
min_tfm_cnt = tfm_cnt;
|
|
min_i2c_priv = i2c_priv;
|
|
}
|
|
if (!min_tfm_cnt)
|
|
break;
|
|
}
|
|
|
|
if (min_i2c_priv) {
|
|
atomic_inc(&min_i2c_priv->tfm_count);
|
|
client = min_i2c_priv->client;
|
|
}
|
|
|
|
spin_unlock(&driver_data.i2c_list_lock);
|
|
|
|
return client;
|
|
}
|
|
|
|
static void atmel_ecc_i2c_client_free(struct i2c_client *client)
|
|
{
|
|
struct atmel_i2c_client_priv *i2c_priv = i2c_get_clientdata(client);
|
|
|
|
atomic_dec(&i2c_priv->tfm_count);
|
|
}
|
|
|
|
static int atmel_ecdh_init_tfm(struct crypto_kpp *tfm)
|
|
{
|
|
const char *alg = kpp_alg_name(tfm);
|
|
struct crypto_kpp *fallback;
|
|
struct atmel_ecdh_ctx *ctx = kpp_tfm_ctx(tfm);
|
|
|
|
ctx->curve_id = ECC_CURVE_NIST_P256;
|
|
ctx->client = atmel_ecc_i2c_client_alloc();
|
|
if (IS_ERR(ctx->client)) {
|
|
pr_err("tfm - i2c_client binding failed\n");
|
|
return PTR_ERR(ctx->client);
|
|
}
|
|
|
|
fallback = crypto_alloc_kpp(alg, 0, CRYPTO_ALG_NEED_FALLBACK);
|
|
if (IS_ERR(fallback)) {
|
|
dev_err(&ctx->client->dev, "Failed to allocate transformation for '%s': %ld\n",
|
|
alg, PTR_ERR(fallback));
|
|
return PTR_ERR(fallback);
|
|
}
|
|
|
|
crypto_kpp_set_flags(fallback, crypto_kpp_get_flags(tfm));
|
|
ctx->fallback = fallback;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void atmel_ecdh_exit_tfm(struct crypto_kpp *tfm)
|
|
{
|
|
struct atmel_ecdh_ctx *ctx = kpp_tfm_ctx(tfm);
|
|
|
|
kfree(ctx->public_key);
|
|
crypto_free_kpp(ctx->fallback);
|
|
atmel_ecc_i2c_client_free(ctx->client);
|
|
}
|
|
|
|
static unsigned int atmel_ecdh_max_size(struct crypto_kpp *tfm)
|
|
{
|
|
struct atmel_ecdh_ctx *ctx = kpp_tfm_ctx(tfm);
|
|
|
|
if (ctx->fallback)
|
|
return crypto_kpp_maxsize(ctx->fallback);
|
|
|
|
/*
|
|
* The device only supports NIST P256 ECC keys. The public key size will
|
|
* always be the same. Use a macro for the key size to avoid unnecessary
|
|
* computations.
|
|
*/
|
|
return ATMEL_ECC_PUBKEY_SIZE;
|
|
}
|
|
|
|
static struct kpp_alg atmel_ecdh_nist_p256 = {
|
|
.set_secret = atmel_ecdh_set_secret,
|
|
.generate_public_key = atmel_ecdh_generate_public_key,
|
|
.compute_shared_secret = atmel_ecdh_compute_shared_secret,
|
|
.init = atmel_ecdh_init_tfm,
|
|
.exit = atmel_ecdh_exit_tfm,
|
|
.max_size = atmel_ecdh_max_size,
|
|
.base = {
|
|
.cra_flags = CRYPTO_ALG_NEED_FALLBACK,
|
|
.cra_name = "ecdh-nist-p256",
|
|
.cra_driver_name = "atmel-ecdh",
|
|
.cra_priority = ATMEL_ECC_PRIORITY,
|
|
.cra_module = THIS_MODULE,
|
|
.cra_ctxsize = sizeof(struct atmel_ecdh_ctx),
|
|
},
|
|
};
|
|
|
|
static int atmel_ecc_probe(struct i2c_client *client,
|
|
const struct i2c_device_id *id)
|
|
{
|
|
struct atmel_i2c_client_priv *i2c_priv;
|
|
int ret;
|
|
|
|
ret = atmel_i2c_probe(client, id);
|
|
if (ret)
|
|
return ret;
|
|
|
|
i2c_priv = i2c_get_clientdata(client);
|
|
|
|
spin_lock(&driver_data.i2c_list_lock);
|
|
list_add_tail(&i2c_priv->i2c_client_list_node,
|
|
&driver_data.i2c_client_list);
|
|
spin_unlock(&driver_data.i2c_list_lock);
|
|
|
|
ret = crypto_register_kpp(&atmel_ecdh_nist_p256);
|
|
if (ret) {
|
|
spin_lock(&driver_data.i2c_list_lock);
|
|
list_del(&i2c_priv->i2c_client_list_node);
|
|
spin_unlock(&driver_data.i2c_list_lock);
|
|
|
|
dev_err(&client->dev, "%s alg registration failed\n",
|
|
atmel_ecdh_nist_p256.base.cra_driver_name);
|
|
} else {
|
|
dev_info(&client->dev, "atmel ecc algorithms registered in /proc/crypto\n");
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int atmel_ecc_remove(struct i2c_client *client)
|
|
{
|
|
struct atmel_i2c_client_priv *i2c_priv = i2c_get_clientdata(client);
|
|
|
|
/* Return EBUSY if i2c client already allocated. */
|
|
if (atomic_read(&i2c_priv->tfm_count)) {
|
|
/*
|
|
* After we return here, the memory backing the device is freed.
|
|
* That happens no matter what the return value of this function
|
|
* is because in the Linux device model there is no error
|
|
* handling for unbinding a driver.
|
|
* If there is still some action pending, it probably involves
|
|
* accessing the freed memory.
|
|
*/
|
|
dev_emerg(&client->dev, "Device is busy, expect memory corruption.\n");
|
|
return 0;
|
|
}
|
|
|
|
crypto_unregister_kpp(&atmel_ecdh_nist_p256);
|
|
|
|
spin_lock(&driver_data.i2c_list_lock);
|
|
list_del(&i2c_priv->i2c_client_list_node);
|
|
spin_unlock(&driver_data.i2c_list_lock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_OF
|
|
static const struct of_device_id atmel_ecc_dt_ids[] = {
|
|
{
|
|
.compatible = "atmel,atecc508a",
|
|
}, {
|
|
/* sentinel */
|
|
}
|
|
};
|
|
MODULE_DEVICE_TABLE(of, atmel_ecc_dt_ids);
|
|
#endif
|
|
|
|
static const struct i2c_device_id atmel_ecc_id[] = {
|
|
{ "atecc508a", 0 },
|
|
{ }
|
|
};
|
|
MODULE_DEVICE_TABLE(i2c, atmel_ecc_id);
|
|
|
|
static struct i2c_driver atmel_ecc_driver = {
|
|
.driver = {
|
|
.name = "atmel-ecc",
|
|
.of_match_table = of_match_ptr(atmel_ecc_dt_ids),
|
|
},
|
|
.probe = atmel_ecc_probe,
|
|
.remove = atmel_ecc_remove,
|
|
.id_table = atmel_ecc_id,
|
|
};
|
|
|
|
static int __init atmel_ecc_init(void)
|
|
{
|
|
spin_lock_init(&driver_data.i2c_list_lock);
|
|
INIT_LIST_HEAD(&driver_data.i2c_client_list);
|
|
return i2c_add_driver(&atmel_ecc_driver);
|
|
}
|
|
|
|
static void __exit atmel_ecc_exit(void)
|
|
{
|
|
atmel_i2c_flush_queue();
|
|
i2c_del_driver(&atmel_ecc_driver);
|
|
}
|
|
|
|
module_init(atmel_ecc_init);
|
|
module_exit(atmel_ecc_exit);
|
|
|
|
MODULE_AUTHOR("Tudor Ambarus <tudor.ambarus@microchip.com>");
|
|
MODULE_DESCRIPTION("Microchip / Atmel ECC (I2C) driver");
|
|
MODULE_LICENSE("GPL v2");
|