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