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(spi: dev, xfers: &spi_xfer, num_xfers: 1); |
124 | if (ret == 0) |
125 | ret = phy->rx_buf[total_length + phy->latency - 1]; |
126 | |
127 | return st33zp24_status_to_errno(code: 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(spi: dev, xfers: &spi_xfer, num_xfers: 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(code: 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 | tpm_data: &data, tpm_size: 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->dev, size: 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_id: phy); |
234 | if (phy->latency <= 0) |
235 | return -ENODEV; |
236 | |
237 | return st33zp24_probe(phy_id: phy, ops: &spi_phy_ops, dev: &dev->dev, irq: 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(spi: 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 | |