1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Microchip / Atmel SHA204A (I2C) driver. 4 * 5 * Copyright (c) 2019 Linaro, Ltd. <ard.biesheuvel@linaro.org> 6 */ 7 8 #include <linux/delay.h> 9 #include <linux/device.h> 10 #include <linux/err.h> 11 #include <linux/errno.h> 12 #include <linux/i2c.h> 13 #include <linux/init.h> 14 #include <linux/kernel.h> 15 #include <linux/module.h> 16 #include <linux/scatterlist.h> 17 #include <linux/slab.h> 18 #include <linux/string.h> 19 #include <linux/sysfs.h> 20 #include <linux/workqueue.h> 21 #include "atmel-i2c.h" 22 23 /* 24 * According to review by Bill Cox [1], the ATSHA204 has very low entropy. 25 * [1] https://www.metzdowd.com/pipermail/cryptography/2014-December/023858.html 26 */ 27 static const unsigned short atsha204_quality = 1; 28 29 static void atmel_sha204a_rng_done(struct atmel_i2c_work_data *work_data, 30 void *areq, int status) 31 { 32 struct atmel_i2c_client_priv *i2c_priv = work_data->ctx; 33 struct hwrng *rng = areq; 34 35 if (status) { 36 dev_warn_ratelimited(&i2c_priv->client->dev, 37 "i2c transaction failed (%d)\n", 38 status); 39 kfree_sensitive(work_data); 40 atomic_dec(&i2c_priv->tfm_count); 41 return; 42 } 43 44 rng->priv = (unsigned long)work_data; 45 atomic_dec(&i2c_priv->tfm_count); 46 } 47 48 static int atmel_sha204a_rng_read_nonblocking(struct hwrng *rng, void *data, 49 size_t max) 50 { 51 struct atmel_i2c_client_priv *i2c_priv; 52 struct atmel_i2c_work_data *work_data; 53 54 i2c_priv = container_of(rng, struct atmel_i2c_client_priv, hwrng); 55 56 /* keep maximum 1 asynchronous read in flight at any time */ 57 if (!atomic_add_unless(&i2c_priv->tfm_count, 1, 1)) 58 return 0; 59 60 if (rng->priv) { 61 work_data = (struct atmel_i2c_work_data *)rng->priv; 62 max = min(RANDOM_RSP_SIZE - CMD_OVERHEAD_SIZE, max); 63 memcpy(data, &work_data->cmd.data[RSP_DATA_IDX], max); 64 rng->priv = 0; 65 } else { 66 work_data = kmalloc_obj(*work_data, GFP_ATOMIC); 67 if (!work_data) { 68 atomic_dec(&i2c_priv->tfm_count); 69 return -ENOMEM; 70 } 71 work_data->ctx = i2c_priv; 72 work_data->client = i2c_priv->client; 73 74 max = 0; 75 } 76 77 atmel_i2c_init_random_cmd(&work_data->cmd); 78 atmel_i2c_enqueue(work_data, atmel_sha204a_rng_done, rng); 79 80 return max; 81 } 82 83 static int atmel_sha204a_rng_read(struct hwrng *rng, void *data, size_t max, 84 bool wait) 85 { 86 struct atmel_i2c_client_priv *i2c_priv; 87 struct atmel_i2c_cmd cmd; 88 int ret; 89 90 if (!wait) 91 return atmel_sha204a_rng_read_nonblocking(rng, data, max); 92 93 i2c_priv = container_of(rng, struct atmel_i2c_client_priv, hwrng); 94 95 atmel_i2c_init_random_cmd(&cmd); 96 97 ret = atmel_i2c_send_receive(i2c_priv->client, &cmd); 98 if (ret) 99 goto out; 100 101 max = min(RANDOM_RSP_SIZE - CMD_OVERHEAD_SIZE, max); 102 memcpy(data, &cmd.data[RSP_DATA_IDX], max); 103 ret = max; 104 105 out: 106 memzero_explicit(&cmd, sizeof(cmd)); 107 return ret; 108 } 109 110 static int atmel_sha204a_otp_read(struct i2c_client *client, u16 addr, u8 *otp) 111 { 112 struct atmel_i2c_cmd cmd; 113 int ret; 114 115 ret = atmel_i2c_init_read_otp_cmd(&cmd, addr); 116 if (ret < 0) { 117 dev_err(&client->dev, "failed, invalid otp address %04X\n", 118 addr); 119 return ret; 120 } 121 122 ret = atmel_i2c_send_receive(client, &cmd); 123 if (ret < 0) { 124 dev_err(&client->dev, "failed to read otp at %04X\n", addr); 125 return ret; 126 } 127 128 if (cmd.data[0] == 0xff) { 129 dev_err(&client->dev, "failed, device not ready\n"); 130 return -EIO; 131 } 132 133 memcpy(otp, cmd.data+1, 4); 134 135 return ret; 136 } 137 138 static ssize_t otp_show(struct device *dev, 139 struct device_attribute *attr, char *buf) 140 { 141 u16 addr; 142 u8 otp[OTP_ZONE_SIZE]; 143 struct i2c_client *client = to_i2c_client(dev); 144 ssize_t len = 0; 145 int i, ret; 146 147 for (addr = 0; addr < OTP_ZONE_SIZE / 4; addr++) { 148 ret = atmel_sha204a_otp_read(client, addr, otp + addr * 4); 149 if (ret < 0) { 150 dev_err(dev, "failed to read otp zone\n"); 151 return ret; 152 } 153 } 154 155 for (i = 0; i < OTP_ZONE_SIZE; i++) 156 len += sysfs_emit_at(buf, len, "%02X", otp[i]); 157 len += sysfs_emit_at(buf, len, "\n"); 158 return len; 159 } 160 static DEVICE_ATTR_RO(otp); 161 162 static struct attribute *atmel_sha204a_attrs[] = { 163 &dev_attr_otp.attr, 164 NULL 165 }; 166 167 static const struct attribute_group atmel_sha204a_groups = { 168 .name = "atsha204a", 169 .attrs = atmel_sha204a_attrs, 170 }; 171 172 static int atmel_sha204a_probe(struct i2c_client *client) 173 { 174 struct atmel_i2c_client_priv *i2c_priv; 175 const unsigned short *quality; 176 int ret; 177 178 ret = atmel_i2c_probe(client); 179 if (ret) 180 return ret; 181 182 i2c_priv = i2c_get_clientdata(client); 183 184 memset(&i2c_priv->hwrng, 0, sizeof(i2c_priv->hwrng)); 185 186 i2c_priv->hwrng.name = dev_name(&client->dev); 187 i2c_priv->hwrng.read = atmel_sha204a_rng_read; 188 189 quality = i2c_get_match_data(client); 190 if (quality) 191 i2c_priv->hwrng.quality = *quality; 192 193 ret = devm_hwrng_register(&client->dev, &i2c_priv->hwrng); 194 if (ret) { 195 dev_err(&client->dev, "failed to register RNG (%d)\n", ret); 196 return ret; 197 } 198 199 ret = sysfs_create_group(&client->dev.kobj, &atmel_sha204a_groups); 200 if (ret) { 201 dev_err(&client->dev, "failed to create sysfs group (%d)\n", ret); 202 return ret; 203 } 204 205 return ret; 206 } 207 208 static void atmel_sha204a_remove(struct i2c_client *client) 209 { 210 struct atmel_i2c_client_priv *i2c_priv = i2c_get_clientdata(client); 211 212 sysfs_remove_group(&client->dev.kobj, &atmel_sha204a_groups); 213 devm_hwrng_unregister(&client->dev, &i2c_priv->hwrng); 214 atmel_i2c_flush_queue(); 215 216 kfree_sensitive((void *)i2c_priv->hwrng.priv); 217 } 218 219 static const struct of_device_id atmel_sha204a_dt_ids[] = { 220 { .compatible = "atmel,atsha204" }, 221 { .compatible = "atmel,atsha204a" }, 222 { } 223 }; 224 MODULE_DEVICE_TABLE(of, atmel_sha204a_dt_ids); 225 226 static const struct i2c_device_id atmel_sha204a_id[] = { 227 { .name = "atsha204", .driver_data = (kernel_ulong_t)&atsha204_quality }, 228 { .name = "atsha204a", .driver_data = (kernel_ulong_t)NULL }, 229 { } 230 }; 231 MODULE_DEVICE_TABLE(i2c, atmel_sha204a_id); 232 233 static struct i2c_driver atmel_sha204a_driver = { 234 .probe = atmel_sha204a_probe, 235 .remove = atmel_sha204a_remove, 236 .id_table = atmel_sha204a_id, 237 238 .driver.name = "atmel-sha204a", 239 .driver.of_match_table = atmel_sha204a_dt_ids, 240 }; 241 242 static int __init atmel_sha204a_init(void) 243 { 244 return i2c_add_driver(&atmel_sha204a_driver); 245 } 246 247 static void __exit atmel_sha204a_exit(void) 248 { 249 atmel_i2c_flush_queue(); 250 i2c_del_driver(&atmel_sha204a_driver); 251 } 252 253 module_init(atmel_sha204a_init); 254 module_exit(atmel_sha204a_exit); 255 256 MODULE_AUTHOR("Ard Biesheuvel <ard.biesheuvel@linaro.org>"); 257 MODULE_DESCRIPTION("Microchip / Atmel SHA204A (I2C) driver"); 258 MODULE_LICENSE("GPL v2"); 259