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