1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * STMicroelectronics TPM SPI Linux driver for TPM ST33ZP24 4 * Copyright (C) 2009 - 2016 STMicroelectronics 5 */ 6 7 #include <linux/module.h> 8 #include <linux/spi/spi.h> 9 #include <linux/of.h> 10 #include <linux/acpi.h> 11 #include <linux/tpm.h> 12 13 #include "../tpm.h" 14 #include "st33zp24.h" 15 16 #define TPM_DATA_FIFO 0x24 17 #define TPM_INTF_CAPABILITY 0x14 18 19 #define TPM_DUMMY_BYTE 0x00 20 21 #define MAX_SPI_LATENCY 15 22 #define LOCALITY0 0 23 24 #define ST33ZP24_OK 0x5A 25 #define ST33ZP24_UNDEFINED_ERR 0x80 26 #define ST33ZP24_BADLOCALITY 0x81 27 #define ST33ZP24_TISREGISTER_UNKNOWN 0x82 28 #define ST33ZP24_LOCALITY_NOT_ACTIVATED 0x83 29 #define ST33ZP24_HASH_END_BEFORE_HASH_START 0x84 30 #define ST33ZP24_BAD_COMMAND_ORDER 0x85 31 #define ST33ZP24_INCORECT_RECEIVED_LENGTH 0x86 32 #define ST33ZP24_TPM_FIFO_OVERFLOW 0x89 33 #define ST33ZP24_UNEXPECTED_READ_FIFO 0x8A 34 #define ST33ZP24_UNEXPECTED_WRITE_FIFO 0x8B 35 #define ST33ZP24_CMDRDY_SET_WHEN_PROCESSING_HASH_END 0x90 36 #define ST33ZP24_DUMMY_BYTES 0x00 37 38 /* 39 * TPM command can be up to 2048 byte, A TPM response can be up to 40 * 1024 byte. 41 * Between command and response, there are latency byte (up to 15 42 * usually on st33zp24 2 are enough). 43 * 44 * Overall when sending a command and expecting an answer we need if 45 * worst case: 46 * 2048 (for the TPM command) + 1024 (for the TPM answer). We need 47 * some latency byte before the answer is available (max 15). 48 * We have 2048 + 1024 + 15. 49 */ 50 #define ST33ZP24_SPI_BUFFER_SIZE (ST33ZP24_BUFSIZE + (ST33ZP24_BUFSIZE / 2) +\ 51 MAX_SPI_LATENCY) 52 53 54 struct st33zp24_spi_phy { 55 struct spi_device *spi_device; 56 57 u8 tx_buf[ST33ZP24_SPI_BUFFER_SIZE]; 58 u8 rx_buf[ST33ZP24_SPI_BUFFER_SIZE]; 59 60 int latency; 61 }; 62 63 static int st33zp24_status_to_errno(u8 code) 64 { 65 switch (code) { 66 case ST33ZP24_OK: 67 return 0; 68 case ST33ZP24_UNDEFINED_ERR: 69 case ST33ZP24_BADLOCALITY: 70 case ST33ZP24_TISREGISTER_UNKNOWN: 71 case ST33ZP24_LOCALITY_NOT_ACTIVATED: 72 case ST33ZP24_HASH_END_BEFORE_HASH_START: 73 case ST33ZP24_BAD_COMMAND_ORDER: 74 case ST33ZP24_UNEXPECTED_READ_FIFO: 75 case ST33ZP24_UNEXPECTED_WRITE_FIFO: 76 case ST33ZP24_CMDRDY_SET_WHEN_PROCESSING_HASH_END: 77 return -EPROTO; 78 case ST33ZP24_INCORECT_RECEIVED_LENGTH: 79 case ST33ZP24_TPM_FIFO_OVERFLOW: 80 return -EMSGSIZE; 81 case ST33ZP24_DUMMY_BYTES: 82 return -ENOSYS; 83 } 84 return code; 85 } 86 87 /* 88 * st33zp24_spi_send 89 * Send byte to the TIS register according to the ST33ZP24 SPI protocol. 90 * @param: phy_id, the phy description 91 * @param: tpm_register, the tpm tis register where the data should be written 92 * @param: tpm_data, the tpm_data to write inside the tpm_register 93 * @param: tpm_size, The length of the data 94 * @return: should be zero if success else a negative error code. 95 */ 96 static int st33zp24_spi_send(void *phy_id, u8 tpm_register, u8 *tpm_data, 97 int tpm_size) 98 { 99 int total_length = 0, ret = 0; 100 struct st33zp24_spi_phy *phy = phy_id; 101 struct spi_device *dev = phy->spi_device; 102 struct spi_transfer spi_xfer = { 103 .tx_buf = phy->tx_buf, 104 .rx_buf = phy->rx_buf, 105 }; 106 107 /* Pre-Header */ 108 phy->tx_buf[total_length++] = TPM_WRITE_DIRECTION | LOCALITY0; 109 phy->tx_buf[total_length++] = tpm_register; 110 111 if (tpm_size > 0 && tpm_register == TPM_DATA_FIFO) { 112 phy->tx_buf[total_length++] = tpm_size >> 8; 113 phy->tx_buf[total_length++] = tpm_size; 114 } 115 116 memcpy(&phy->tx_buf[total_length], tpm_data, tpm_size); 117 total_length += tpm_size; 118 119 memset(&phy->tx_buf[total_length], TPM_DUMMY_BYTE, phy->latency); 120 121 spi_xfer.len = total_length + phy->latency; 122 123 ret = spi_sync_transfer(dev, &spi_xfer, 1); 124 if (ret == 0) 125 ret = phy->rx_buf[total_length + phy->latency - 1]; 126 127 return st33zp24_status_to_errno(ret); 128 } /* st33zp24_spi_send() */ 129 130 /* 131 * st33zp24_spi_read8_recv 132 * Recv byte from the TIS register according to the ST33ZP24 SPI protocol. 133 * @param: phy_id, the phy description 134 * @param: tpm_register, the tpm tis register where the data should be read 135 * @param: tpm_data, the TPM response 136 * @param: tpm_size, tpm TPM response size to read. 137 * @return: should be zero if success else a negative error code. 138 */ 139 static int st33zp24_spi_read8_reg(void *phy_id, u8 tpm_register, u8 *tpm_data, 140 int tpm_size) 141 { 142 int total_length = 0, ret; 143 struct st33zp24_spi_phy *phy = phy_id; 144 struct spi_device *dev = phy->spi_device; 145 struct spi_transfer spi_xfer = { 146 .tx_buf = phy->tx_buf, 147 .rx_buf = phy->rx_buf, 148 }; 149 150 /* Pre-Header */ 151 phy->tx_buf[total_length++] = LOCALITY0; 152 phy->tx_buf[total_length++] = tpm_register; 153 154 memset(&phy->tx_buf[total_length], TPM_DUMMY_BYTE, 155 phy->latency + tpm_size); 156 157 spi_xfer.len = total_length + phy->latency + tpm_size; 158 159 /* header + status byte + size of the data + status byte */ 160 ret = spi_sync_transfer(dev, &spi_xfer, 1); 161 if (tpm_size > 0 && ret == 0) { 162 ret = phy->rx_buf[total_length + phy->latency - 1]; 163 164 memcpy(tpm_data, phy->rx_buf + total_length + phy->latency, 165 tpm_size); 166 } 167 168 return ret; 169 } /* st33zp24_spi_read8_reg() */ 170 171 /* 172 * st33zp24_spi_recv 173 * Recv byte from the TIS register according to the ST33ZP24 SPI protocol. 174 * @param: phy_id, the phy description 175 * @param: tpm_register, the tpm tis register where the data should be read 176 * @param: tpm_data, the TPM response 177 * @param: tpm_size, tpm TPM response size to read. 178 * @return: number of byte read successfully: should be one if success. 179 */ 180 static int st33zp24_spi_recv(void *phy_id, u8 tpm_register, u8 *tpm_data, 181 int tpm_size) 182 { 183 int ret; 184 185 ret = st33zp24_spi_read8_reg(phy_id, tpm_register, tpm_data, tpm_size); 186 if (!st33zp24_status_to_errno(ret)) 187 return tpm_size; 188 return ret; 189 } /* st33zp24_spi_recv() */ 190 191 static int st33zp24_spi_evaluate_latency(void *phy_id) 192 { 193 struct st33zp24_spi_phy *phy = phy_id; 194 int latency = 1, status = 0; 195 u8 data = 0; 196 197 while (!status && latency < MAX_SPI_LATENCY) { 198 phy->latency = latency; 199 status = st33zp24_spi_read8_reg(phy_id, TPM_INTF_CAPABILITY, 200 &data, 1); 201 latency++; 202 } 203 if (status < 0) 204 return status; 205 if (latency == MAX_SPI_LATENCY) 206 return -ENODEV; 207 208 return latency - 1; 209 } /* evaluate_latency() */ 210 211 static const struct st33zp24_phy_ops spi_phy_ops = { 212 .send = st33zp24_spi_send, 213 .recv = st33zp24_spi_recv, 214 }; 215 216 /* 217 * st33zp24_spi_probe initialize the TPM device 218 * @param: dev, the spi_device description (TPM SPI description). 219 * @return: 0 in case of success. 220 * or a negative value describing the error. 221 */ 222 static int st33zp24_spi_probe(struct spi_device *dev) 223 { 224 struct st33zp24_spi_phy *phy; 225 226 phy = devm_kzalloc(&dev->dev, sizeof(struct st33zp24_spi_phy), 227 GFP_KERNEL); 228 if (!phy) 229 return -ENOMEM; 230 231 phy->spi_device = dev; 232 233 phy->latency = st33zp24_spi_evaluate_latency(phy); 234 if (phy->latency <= 0) 235 return -ENODEV; 236 237 return st33zp24_probe(phy, &spi_phy_ops, &dev->dev, dev->irq); 238 } 239 240 /* 241 * st33zp24_spi_remove remove the TPM device 242 * @param: client, the spi_device description (TPM SPI description). 243 * @return: 0 in case of success. 244 */ 245 static void st33zp24_spi_remove(struct spi_device *dev) 246 { 247 struct tpm_chip *chip = spi_get_drvdata(dev); 248 249 st33zp24_remove(chip); 250 } 251 252 static const struct spi_device_id st33zp24_spi_id[] = { 253 {TPM_ST33_SPI, 0}, 254 {} 255 }; 256 MODULE_DEVICE_TABLE(spi, st33zp24_spi_id); 257 258 static const struct of_device_id of_st33zp24_spi_match[] __maybe_unused = { 259 { .compatible = "st,st33zp24-spi", }, 260 {} 261 }; 262 MODULE_DEVICE_TABLE(of, of_st33zp24_spi_match); 263 264 static const struct acpi_device_id st33zp24_spi_acpi_match[] __maybe_unused = { 265 {"SMO3324"}, 266 {} 267 }; 268 MODULE_DEVICE_TABLE(acpi, st33zp24_spi_acpi_match); 269 270 static SIMPLE_DEV_PM_OPS(st33zp24_spi_ops, st33zp24_pm_suspend, 271 st33zp24_pm_resume); 272 273 static struct spi_driver st33zp24_spi_driver = { 274 .driver = { 275 .name = "st33zp24-spi", 276 .pm = &st33zp24_spi_ops, 277 .of_match_table = of_match_ptr(of_st33zp24_spi_match), 278 .acpi_match_table = ACPI_PTR(st33zp24_spi_acpi_match), 279 }, 280 .probe = st33zp24_spi_probe, 281 .remove = st33zp24_spi_remove, 282 .id_table = st33zp24_spi_id, 283 }; 284 285 module_spi_driver(st33zp24_spi_driver); 286 287 MODULE_AUTHOR("TPM support (TPMsupport@list.st.com)"); 288 MODULE_DESCRIPTION("STM TPM 1.2 SPI ST33 Driver"); 289 MODULE_VERSION("1.3.0"); 290 MODULE_LICENSE("GPL"); 291