Tudor Ambarus | 820684c | 2018-08-21 16:36:09 +0300 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0 |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 2 | /* |
| 3 | * Microchip / Atmel ECC (I2C) driver. |
| 4 | * |
| 5 | * Copyright (c) 2017, Microchip Technology Inc. |
| 6 | * Author: Tudor Ambarus <tudor.ambarus@microchip.com> |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 7 | */ |
| 8 | |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 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> |
Ard Biesheuvel | c34a320 | 2019-05-24 18:26:48 +0200 | [diff] [blame] | 24 | #include "atmel-i2c.h" |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 25 | |
| 26 | static struct atmel_ecc_driver_data driver_data; |
| 27 | |
| 28 | /** |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 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 | */ |
| 41 | struct 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 | |
Ard Biesheuvel | c34a320 | 2019-05-24 18:26:48 +0200 | [diff] [blame] | 50 | static void atmel_ecdh_done(struct atmel_i2c_work_data *work_data, void *areq, |
Tudor-Dan Ambarus | 6d2bce6 | 2017-07-20 16:35:49 +0300 | [diff] [blame] | 51 | int status) |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 52 | { |
| 53 | struct kpp_request *req = areq; |
| 54 | struct atmel_ecdh_ctx *ctx = work_data->ctx; |
Ard Biesheuvel | c34a320 | 2019-05-24 18:26:48 +0200 | [diff] [blame] | 55 | struct atmel_i2c_cmd *cmd = &work_data->cmd; |
Tudor-Dan Ambarus | e9440ff | 2018-06-13 16:29:58 +0300 | [diff] [blame] | 56 | size_t copied, n_sz; |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 57 | |
| 58 | if (status) |
| 59 | goto free_work_data; |
| 60 | |
Tudor-Dan Ambarus | e9440ff | 2018-06-13 16:29:58 +0300 | [diff] [blame] | 61 | /* might want less than we've got */ |
| 62 | n_sz = min_t(size_t, ctx->n_sz, req->dst_len); |
| 63 | |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 64 | /* copy the shared secret */ |
Tudor-Dan Ambarus | e9440ff | 2018-06-13 16:29:58 +0300 | [diff] [blame] | 65 | copied = sg_copy_from_buffer(req->dst, sg_nents_for_len(req->dst, n_sz), |
| 66 | &cmd->data[RSP_DATA_IDX], n_sz); |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 67 | if (copied != n_sz) |
| 68 | status = -EINVAL; |
| 69 | |
| 70 | /* fall through */ |
| 71 | free_work_data: |
Waiman Long | 453431a | 2020-08-06 23:18:13 -0700 | [diff] [blame] | 72 | kfree_sensitive(work_data); |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 73 | kpp_request_complete(req, status); |
| 74 | } |
| 75 | |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 76 | static 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 | */ |
| 88 | static 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); |
Ard Biesheuvel | c34a320 | 2019-05-24 18:26:48 +0200 | [diff] [blame] | 92 | struct atmel_i2c_cmd *cmd; |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 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, ¶ms) < 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 | |
Ard Biesheuvel | c34a320 | 2019-05-24 18:26:48 +0200 | [diff] [blame] | 130 | atmel_i2c_init_genkey_cmd(cmd, DATA_SLOT_2); |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 131 | |
Ard Biesheuvel | c34a320 | 2019-05-24 18:26:48 +0200 | [diff] [blame] | 132 | ret = atmel_i2c_send_receive(ctx->client, cmd); |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 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 | |
| 143 | free_public_key: |
| 144 | kfree(public_key); |
| 145 | free_cmd: |
| 146 | kfree(cmd); |
| 147 | return ret; |
| 148 | } |
| 149 | |
| 150 | static 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); |
Tudor-Dan Ambarus | e9440ff | 2018-06-13 16:29:58 +0300 | [diff] [blame] | 154 | size_t copied, nbytes; |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 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 | |
Ard Biesheuvel | c34a320 | 2019-05-24 18:26:48 +0200 | [diff] [blame] | 162 | if (!ctx->public_key) |
| 163 | return -EINVAL; |
| 164 | |
Tudor-Dan Ambarus | e9440ff | 2018-06-13 16:29:58 +0300 | [diff] [blame] | 165 | /* might want less than we've got */ |
| 166 | nbytes = min_t(size_t, ATMEL_ECC_PUBKEY_SIZE, req->dst_len); |
| 167 | |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 168 | /* public key was saved at private key generation */ |
Tudor-Dan Ambarus | e9440ff | 2018-06-13 16:29:58 +0300 | [diff] [blame] | 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) |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 173 | ret = -EINVAL; |
| 174 | |
| 175 | return ret; |
| 176 | } |
| 177 | |
| 178 | static 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); |
Ard Biesheuvel | c34a320 | 2019-05-24 18:26:48 +0200 | [diff] [blame] | 182 | struct atmel_i2c_work_data *work_data; |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 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 | |
Tudor-Dan Ambarus | e9440ff | 2018-06-13 16:29:58 +0300 | [diff] [blame] | 191 | /* must have exactly two points to be on the curve */ |
| 192 | if (req->src_len != ATMEL_ECC_PUBKEY_SIZE) |
| 193 | return -EINVAL; |
| 194 | |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 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; |
Ard Biesheuvel | c34a320 | 2019-05-24 18:26:48 +0200 | [diff] [blame] | 203 | work_data->client = ctx->client; |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 204 | |
Ard Biesheuvel | c34a320 | 2019-05-24 18:26:48 +0200 | [diff] [blame] | 205 | ret = atmel_i2c_init_ecdh_cmd(&work_data->cmd, req->src); |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 206 | if (ret) |
| 207 | goto free_work_data; |
| 208 | |
Ard Biesheuvel | c34a320 | 2019-05-24 18:26:48 +0200 | [diff] [blame] | 209 | atmel_i2c_enqueue(work_data, atmel_ecdh_done, req); |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 210 | |
| 211 | return -EINPROGRESS; |
| 212 | |
| 213 | free_work_data: |
| 214 | kfree(work_data); |
| 215 | return ret; |
| 216 | } |
| 217 | |
Colin Ian King | 0138d32 | 2017-07-19 10:24:15 +0100 | [diff] [blame] | 218 | static struct i2c_client *atmel_ecc_i2c_client_alloc(void) |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 219 | { |
Ard Biesheuvel | c34a320 | 2019-05-24 18:26:48 +0200 | [diff] [blame] | 220 | struct atmel_i2c_client_priv *i2c_priv, *min_i2c_priv = NULL; |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 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 | |
Colin Ian King | 0138d32 | 2017-07-19 10:24:15 +0100 | [diff] [blame] | 253 | static void atmel_ecc_i2c_client_free(struct i2c_client *client) |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 254 | { |
Ard Biesheuvel | c34a320 | 2019-05-24 18:26:48 +0200 | [diff] [blame] | 255 | struct atmel_i2c_client_priv *i2c_priv = i2c_get_clientdata(client); |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 256 | |
| 257 | atomic_dec(&i2c_priv->tfm_count); |
| 258 | } |
| 259 | |
| 260 | static 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)); |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 280 | ctx->fallback = fallback; |
| 281 | |
| 282 | return 0; |
| 283 | } |
| 284 | |
| 285 | static 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 | |
| 294 | static 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 | |
| 309 | static 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 | |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 326 | static int atmel_ecc_probe(struct i2c_client *client, |
| 327 | const struct i2c_device_id *id) |
| 328 | { |
Ard Biesheuvel | c34a320 | 2019-05-24 18:26:48 +0200 | [diff] [blame] | 329 | struct atmel_i2c_client_priv *i2c_priv; |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 330 | int ret; |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 331 | |
Ard Biesheuvel | c34a320 | 2019-05-24 18:26:48 +0200 | [diff] [blame] | 332 | ret = atmel_i2c_probe(client, id); |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 333 | if (ret) |
| 334 | return ret; |
| 335 | |
Ard Biesheuvel | c34a320 | 2019-05-24 18:26:48 +0200 | [diff] [blame] | 336 | i2c_priv = i2c_get_clientdata(client); |
| 337 | |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 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 | |
Ard Biesheuvel | c34a320 | 2019-05-24 18:26:48 +0200 | [diff] [blame] | 349 | dev_err(&client->dev, "%s alg registration failed\n", |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 350 | atmel_ecdh.base.cra_driver_name); |
| 351 | } else { |
Ard Biesheuvel | c34a320 | 2019-05-24 18:26:48 +0200 | [diff] [blame] | 352 | dev_info(&client->dev, "atmel ecc algorithms registered in /proc/crypto\n"); |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 353 | } |
| 354 | |
| 355 | return ret; |
| 356 | } |
| 357 | |
| 358 | static int atmel_ecc_remove(struct i2c_client *client) |
| 359 | { |
Ard Biesheuvel | c34a320 | 2019-05-24 18:26:48 +0200 | [diff] [blame] | 360 | struct atmel_i2c_client_priv *i2c_priv = i2c_get_clientdata(client); |
Tudor-Dan Ambarus | 1110569 | 2017-07-05 13:07:59 +0300 | [diff] [blame] | 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 |
| 378 | static const struct of_device_id atmel_ecc_dt_ids[] = { |
| 379 | { |
| 380 | .compatible = "atmel,atecc508a", |
| 381 | }, { |
| 382 | /* sentinel */ |
| 383 | } |
| 384 | }; |
| 385 | MODULE_DEVICE_TABLE(of, atmel_ecc_dt_ids); |
| 386 | #endif |
| 387 | |
| 388 | static const struct i2c_device_id atmel_ecc_id[] = { |
| 389 | { "atecc508a", 0 }, |
| 390 | { } |
| 391 | }; |
| 392 | MODULE_DEVICE_TABLE(i2c, atmel_ecc_id); |
| 393 | |
| 394 | static 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 | |
| 404 | static 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 | |
| 411 | static void __exit atmel_ecc_exit(void) |
| 412 | { |
| 413 | flush_scheduled_work(); |
| 414 | i2c_del_driver(&atmel_ecc_driver); |
| 415 | } |
| 416 | |
| 417 | module_init(atmel_ecc_init); |
| 418 | module_exit(atmel_ecc_exit); |
| 419 | |
| 420 | MODULE_AUTHOR("Tudor Ambarus <tudor.ambarus@microchip.com>"); |
| 421 | MODULE_DESCRIPTION("Microchip / Atmel ECC (I2C) driver"); |
| 422 | MODULE_LICENSE("GPL v2"); |