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