Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Description: |
| 3 | * Device Driver for the Infineon Technologies |
Marcel Selhorst | f9abb02 | 2005-08-05 11:59:33 -0700 | [diff] [blame] | 4 | * SLD 9630 TT 1.1 and SLB 9635 TT 1.2 Trusted Platform Module |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 5 | * Specifications at www.trustedcomputinggroup.org |
| 6 | * |
Rajiv Andrade | cbb2d5e | 2012-04-24 11:19:58 -0300 | [diff] [blame] | 7 | * Copyright (C) 2005, Marcel Selhorst <tpmdd@selhorst.net> |
| 8 | * Sirrix AG - security technologies <tpmdd@sirrix.com> and |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 9 | * Applied Data Security Group, Ruhr-University Bochum, Germany |
Justin P. Mattock | 631dd1a | 2010-10-18 11:03:14 +0200 | [diff] [blame] | 10 | * Project-Homepage: http://www.trust.rub.de/projects/linux-device-driver-infineon-tpm/ |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 11 | * |
| 12 | * This program is free software; you can redistribute it and/or |
| 13 | * modify it under the terms of the GNU General Public License as |
| 14 | * published by the Free Software Foundation, version 2 of the |
| 15 | * License. |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 16 | */ |
| 17 | |
Randy Dunlap | 397c718 | 2006-04-22 02:39:18 -0700 | [diff] [blame] | 18 | #include <linux/init.h> |
Marcel Selhorst | f9abb02 | 2005-08-05 11:59:33 -0700 | [diff] [blame] | 19 | #include <linux/pnp.h> |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 20 | #include "tpm.h" |
| 21 | |
| 22 | /* Infineon specific definitions */ |
| 23 | /* maximum number of WTX-packages */ |
| 24 | #define TPM_MAX_WTX_PACKAGES 50 |
| 25 | /* msleep-Time for WTX-packages */ |
| 26 | #define TPM_WTX_MSLEEP_TIME 20 |
| 27 | /* msleep-Time --> Interval to check status register */ |
| 28 | #define TPM_MSLEEP_TIME 3 |
| 29 | /* gives number of max. msleep()-calls before throwing timeout */ |
| 30 | #define TPM_MAX_TRIES 5000 |
Marcel Selhorst | f9abb02 | 2005-08-05 11:59:33 -0700 | [diff] [blame] | 31 | #define TPM_INFINEON_DEV_VEN_VALUE 0x15D1 |
| 32 | |
Alex Williamson | d954e8e | 2007-05-08 00:25:55 -0700 | [diff] [blame] | 33 | #define TPM_INF_IO_PORT 0x0 |
| 34 | #define TPM_INF_IO_MEM 0x1 |
| 35 | |
| 36 | #define TPM_INF_ADDR 0x0 |
| 37 | #define TPM_INF_DATA 0x1 |
| 38 | |
| 39 | struct tpm_inf_dev { |
| 40 | int iotype; |
| 41 | |
Marcel Selhorst | 93716b9 | 2010-02-10 13:56:32 -0800 | [diff] [blame] | 42 | void __iomem *mem_base; /* MMIO ioremap'd addr */ |
| 43 | unsigned long map_base; /* phys MMIO base */ |
| 44 | unsigned long map_size; /* MMIO region size */ |
| 45 | unsigned int index_off; /* index register offset */ |
Alex Williamson | d954e8e | 2007-05-08 00:25:55 -0700 | [diff] [blame] | 46 | |
Marcel Selhorst | 93716b9 | 2010-02-10 13:56:32 -0800 | [diff] [blame] | 47 | unsigned int data_regs; /* Data registers */ |
Alex Williamson | d954e8e | 2007-05-08 00:25:55 -0700 | [diff] [blame] | 48 | unsigned int data_size; |
| 49 | |
| 50 | unsigned int config_port; /* IO Port config index reg */ |
| 51 | unsigned int config_size; |
| 52 | }; |
| 53 | |
| 54 | static struct tpm_inf_dev tpm_dev; |
| 55 | |
| 56 | static inline void tpm_data_out(unsigned char data, unsigned char offset) |
| 57 | { |
| 58 | if (tpm_dev.iotype == TPM_INF_IO_PORT) |
| 59 | outb(data, tpm_dev.data_regs + offset); |
| 60 | else |
| 61 | writeb(data, tpm_dev.mem_base + tpm_dev.data_regs + offset); |
| 62 | } |
| 63 | |
| 64 | static inline unsigned char tpm_data_in(unsigned char offset) |
| 65 | { |
| 66 | if (tpm_dev.iotype == TPM_INF_IO_PORT) |
| 67 | return inb(tpm_dev.data_regs + offset); |
| 68 | else |
| 69 | return readb(tpm_dev.mem_base + tpm_dev.data_regs + offset); |
| 70 | } |
| 71 | |
| 72 | static inline void tpm_config_out(unsigned char data, unsigned char offset) |
| 73 | { |
| 74 | if (tpm_dev.iotype == TPM_INF_IO_PORT) |
| 75 | outb(data, tpm_dev.config_port + offset); |
| 76 | else |
| 77 | writeb(data, tpm_dev.mem_base + tpm_dev.index_off + offset); |
| 78 | } |
| 79 | |
| 80 | static inline unsigned char tpm_config_in(unsigned char offset) |
| 81 | { |
| 82 | if (tpm_dev.iotype == TPM_INF_IO_PORT) |
| 83 | return inb(tpm_dev.config_port + offset); |
| 84 | else |
| 85 | return readb(tpm_dev.mem_base + tpm_dev.index_off + offset); |
| 86 | } |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 87 | |
| 88 | /* TPM header definitions */ |
| 89 | enum infineon_tpm_header { |
| 90 | TPM_VL_VER = 0x01, |
| 91 | TPM_VL_CHANNEL_CONTROL = 0x07, |
| 92 | TPM_VL_CHANNEL_PERSONALISATION = 0x0A, |
| 93 | TPM_VL_CHANNEL_TPM = 0x0B, |
| 94 | TPM_VL_CONTROL = 0x00, |
| 95 | TPM_INF_NAK = 0x15, |
| 96 | TPM_CTRL_WTX = 0x10, |
| 97 | TPM_CTRL_WTX_ABORT = 0x18, |
| 98 | TPM_CTRL_WTX_ABORT_ACK = 0x18, |
| 99 | TPM_CTRL_ERROR = 0x20, |
| 100 | TPM_CTRL_CHAININGACK = 0x40, |
| 101 | TPM_CTRL_CHAINING = 0x80, |
| 102 | TPM_CTRL_DATA = 0x04, |
| 103 | TPM_CTRL_DATA_CHA = 0x84, |
| 104 | TPM_CTRL_DATA_CHA_ACK = 0xC4 |
| 105 | }; |
| 106 | |
| 107 | enum infineon_tpm_register { |
| 108 | WRFIFO = 0x00, |
| 109 | RDFIFO = 0x01, |
| 110 | STAT = 0x02, |
| 111 | CMD = 0x03 |
| 112 | }; |
| 113 | |
| 114 | enum infineon_tpm_command_bits { |
| 115 | CMD_DIS = 0x00, |
| 116 | CMD_LP = 0x01, |
| 117 | CMD_RES = 0x02, |
| 118 | CMD_IRQC = 0x06 |
| 119 | }; |
| 120 | |
| 121 | enum infineon_tpm_status_bits { |
| 122 | STAT_XFE = 0x00, |
| 123 | STAT_LPA = 0x01, |
| 124 | STAT_FOK = 0x02, |
| 125 | STAT_TOK = 0x03, |
| 126 | STAT_IRQA = 0x06, |
| 127 | STAT_RDA = 0x07 |
| 128 | }; |
| 129 | |
| 130 | /* some outgoing values */ |
| 131 | enum infineon_tpm_values { |
| 132 | CHIP_ID1 = 0x20, |
| 133 | CHIP_ID2 = 0x21, |
Andrew Morton | 3dcce8e | 2005-07-27 11:45:14 -0700 | [diff] [blame] | 134 | TPM_DAR = 0x30, |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 135 | RESET_LP_IRQC_DISABLE = 0x41, |
| 136 | ENABLE_REGISTER_PAIR = 0x55, |
| 137 | IOLIMH = 0x60, |
| 138 | IOLIML = 0x61, |
| 139 | DISABLE_REGISTER_PAIR = 0xAA, |
| 140 | IDVENL = 0xF1, |
| 141 | IDVENH = 0xF2, |
| 142 | IDPDL = 0xF3, |
| 143 | IDPDH = 0xF4 |
| 144 | }; |
| 145 | |
| 146 | static int number_of_wtx; |
| 147 | |
| 148 | static int empty_fifo(struct tpm_chip *chip, int clear_wrfifo) |
| 149 | { |
| 150 | int status; |
| 151 | int check = 0; |
| 152 | int i; |
| 153 | |
| 154 | if (clear_wrfifo) { |
| 155 | for (i = 0; i < 4096; i++) { |
Alex Williamson | d954e8e | 2007-05-08 00:25:55 -0700 | [diff] [blame] | 156 | status = tpm_data_in(WRFIFO); |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 157 | if (status == 0xff) { |
| 158 | if (check == 5) |
| 159 | break; |
| 160 | else |
| 161 | check++; |
| 162 | } |
| 163 | } |
| 164 | } |
| 165 | /* Note: The values which are currently in the FIFO of the TPM |
| 166 | are thrown away since there is no usage for them. Usually, |
| 167 | this has nothing to say, since the TPM will give its answer |
| 168 | immediately or will be aborted anyway, so the data here is |
| 169 | usually garbage and useless. |
| 170 | We have to clean this, because the next communication with |
| 171 | the TPM would be rubbish, if there is still some old data |
| 172 | in the Read FIFO. |
| 173 | */ |
| 174 | i = 0; |
| 175 | do { |
Alex Williamson | d954e8e | 2007-05-08 00:25:55 -0700 | [diff] [blame] | 176 | status = tpm_data_in(RDFIFO); |
| 177 | status = tpm_data_in(STAT); |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 178 | i++; |
| 179 | if (i == TPM_MAX_TRIES) |
| 180 | return -EIO; |
| 181 | } while ((status & (1 << STAT_RDA)) != 0); |
| 182 | return 0; |
| 183 | } |
| 184 | |
| 185 | static int wait(struct tpm_chip *chip, int wait_for_bit) |
| 186 | { |
| 187 | int status; |
| 188 | int i; |
| 189 | for (i = 0; i < TPM_MAX_TRIES; i++) { |
Alex Williamson | d954e8e | 2007-05-08 00:25:55 -0700 | [diff] [blame] | 190 | status = tpm_data_in(STAT); |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 191 | /* check the status-register if wait_for_bit is set */ |
| 192 | if (status & 1 << wait_for_bit) |
| 193 | break; |
| 194 | msleep(TPM_MSLEEP_TIME); |
| 195 | } |
| 196 | if (i == TPM_MAX_TRIES) { /* timeout occurs */ |
| 197 | if (wait_for_bit == STAT_XFE) |
Marcel Selhorst | 1b8333b | 2005-10-30 15:03:27 -0800 | [diff] [blame] | 198 | dev_err(chip->dev, "Timeout in wait(STAT_XFE)\n"); |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 199 | if (wait_for_bit == STAT_RDA) |
Marcel Selhorst | 1b8333b | 2005-10-30 15:03:27 -0800 | [diff] [blame] | 200 | dev_err(chip->dev, "Timeout in wait(STAT_RDA)\n"); |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 201 | return -EIO; |
| 202 | } |
| 203 | return 0; |
| 204 | }; |
| 205 | |
| 206 | static void wait_and_send(struct tpm_chip *chip, u8 sendbyte) |
| 207 | { |
| 208 | wait(chip, STAT_XFE); |
Alex Williamson | d954e8e | 2007-05-08 00:25:55 -0700 | [diff] [blame] | 209 | tpm_data_out(sendbyte, WRFIFO); |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 210 | } |
| 211 | |
| 212 | /* Note: WTX means Waiting-Time-Extension. Whenever the TPM needs more |
| 213 | calculation time, it sends a WTX-package, which has to be acknowledged |
| 214 | or aborted. This usually occurs if you are hammering the TPM with key |
| 215 | creation. Set the maximum number of WTX-packages in the definitions |
| 216 | above, if the number is reached, the waiting-time will be denied |
| 217 | and the TPM command has to be resend. |
| 218 | */ |
| 219 | |
| 220 | static void tpm_wtx(struct tpm_chip *chip) |
| 221 | { |
| 222 | number_of_wtx++; |
Kylene Jo Hall | e659a3f | 2005-10-30 15:03:24 -0800 | [diff] [blame] | 223 | dev_info(chip->dev, "Granting WTX (%02d / %02d)\n", |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 224 | number_of_wtx, TPM_MAX_WTX_PACKAGES); |
| 225 | wait_and_send(chip, TPM_VL_VER); |
| 226 | wait_and_send(chip, TPM_CTRL_WTX); |
| 227 | wait_and_send(chip, 0x00); |
| 228 | wait_and_send(chip, 0x00); |
| 229 | msleep(TPM_WTX_MSLEEP_TIME); |
| 230 | } |
| 231 | |
| 232 | static void tpm_wtx_abort(struct tpm_chip *chip) |
| 233 | { |
Kylene Jo Hall | e659a3f | 2005-10-30 15:03:24 -0800 | [diff] [blame] | 234 | dev_info(chip->dev, "Aborting WTX\n"); |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 235 | wait_and_send(chip, TPM_VL_VER); |
| 236 | wait_and_send(chip, TPM_CTRL_WTX_ABORT); |
| 237 | wait_and_send(chip, 0x00); |
| 238 | wait_and_send(chip, 0x00); |
| 239 | number_of_wtx = 0; |
| 240 | msleep(TPM_WTX_MSLEEP_TIME); |
| 241 | } |
| 242 | |
| 243 | static int tpm_inf_recv(struct tpm_chip *chip, u8 * buf, size_t count) |
| 244 | { |
| 245 | int i; |
| 246 | int ret; |
| 247 | u32 size = 0; |
Marcel Selhorst | 8c9e877 | 2006-02-17 13:52:41 -0800 | [diff] [blame] | 248 | number_of_wtx = 0; |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 249 | |
| 250 | recv_begin: |
| 251 | /* start receiving header */ |
| 252 | for (i = 0; i < 4; i++) { |
| 253 | ret = wait(chip, STAT_RDA); |
| 254 | if (ret) |
| 255 | return -EIO; |
Alex Williamson | d954e8e | 2007-05-08 00:25:55 -0700 | [diff] [blame] | 256 | buf[i] = tpm_data_in(RDFIFO); |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 257 | } |
| 258 | |
| 259 | if (buf[0] != TPM_VL_VER) { |
Kylene Jo Hall | e659a3f | 2005-10-30 15:03:24 -0800 | [diff] [blame] | 260 | dev_err(chip->dev, |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 261 | "Wrong transport protocol implementation!\n"); |
| 262 | return -EIO; |
| 263 | } |
| 264 | |
| 265 | if (buf[1] == TPM_CTRL_DATA) { |
| 266 | /* size of the data received */ |
| 267 | size = ((buf[2] << 8) | buf[3]); |
| 268 | |
| 269 | for (i = 0; i < size; i++) { |
| 270 | wait(chip, STAT_RDA); |
Alex Williamson | d954e8e | 2007-05-08 00:25:55 -0700 | [diff] [blame] | 271 | buf[i] = tpm_data_in(RDFIFO); |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 272 | } |
| 273 | |
| 274 | if ((size == 0x6D00) && (buf[1] == 0x80)) { |
Marcel Selhorst | 1b8333b | 2005-10-30 15:03:27 -0800 | [diff] [blame] | 275 | dev_err(chip->dev, "Error handling on vendor layer!\n"); |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 276 | return -EIO; |
| 277 | } |
| 278 | |
| 279 | for (i = 0; i < size; i++) |
| 280 | buf[i] = buf[i + 6]; |
| 281 | |
| 282 | size = size - 6; |
| 283 | return size; |
| 284 | } |
| 285 | |
| 286 | if (buf[1] == TPM_CTRL_WTX) { |
Kylene Jo Hall | e659a3f | 2005-10-30 15:03:24 -0800 | [diff] [blame] | 287 | dev_info(chip->dev, "WTX-package received\n"); |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 288 | if (number_of_wtx < TPM_MAX_WTX_PACKAGES) { |
| 289 | tpm_wtx(chip); |
| 290 | goto recv_begin; |
| 291 | } else { |
| 292 | tpm_wtx_abort(chip); |
| 293 | goto recv_begin; |
| 294 | } |
| 295 | } |
| 296 | |
| 297 | if (buf[1] == TPM_CTRL_WTX_ABORT_ACK) { |
Kylene Jo Hall | e659a3f | 2005-10-30 15:03:24 -0800 | [diff] [blame] | 298 | dev_info(chip->dev, "WTX-abort acknowledged\n"); |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 299 | return size; |
| 300 | } |
| 301 | |
| 302 | if (buf[1] == TPM_CTRL_ERROR) { |
Kylene Jo Hall | e659a3f | 2005-10-30 15:03:24 -0800 | [diff] [blame] | 303 | dev_err(chip->dev, "ERROR-package received:\n"); |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 304 | if (buf[4] == TPM_INF_NAK) |
Kylene Jo Hall | e659a3f | 2005-10-30 15:03:24 -0800 | [diff] [blame] | 305 | dev_err(chip->dev, |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 306 | "-> Negative acknowledgement" |
| 307 | " - retransmit command!\n"); |
| 308 | return -EIO; |
| 309 | } |
| 310 | return -EIO; |
| 311 | } |
| 312 | |
| 313 | static int tpm_inf_send(struct tpm_chip *chip, u8 * buf, size_t count) |
| 314 | { |
| 315 | int i; |
| 316 | int ret; |
| 317 | u8 count_high, count_low, count_4, count_3, count_2, count_1; |
| 318 | |
| 319 | /* Disabling Reset, LP and IRQC */ |
Alex Williamson | d954e8e | 2007-05-08 00:25:55 -0700 | [diff] [blame] | 320 | tpm_data_out(RESET_LP_IRQC_DISABLE, CMD); |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 321 | |
| 322 | ret = empty_fifo(chip, 1); |
| 323 | if (ret) { |
Kylene Jo Hall | e659a3f | 2005-10-30 15:03:24 -0800 | [diff] [blame] | 324 | dev_err(chip->dev, "Timeout while clearing FIFO\n"); |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 325 | return -EIO; |
| 326 | } |
| 327 | |
| 328 | ret = wait(chip, STAT_XFE); |
| 329 | if (ret) |
| 330 | return -EIO; |
| 331 | |
| 332 | count_4 = (count & 0xff000000) >> 24; |
| 333 | count_3 = (count & 0x00ff0000) >> 16; |
| 334 | count_2 = (count & 0x0000ff00) >> 8; |
| 335 | count_1 = (count & 0x000000ff); |
| 336 | count_high = ((count + 6) & 0xffffff00) >> 8; |
| 337 | count_low = ((count + 6) & 0x000000ff); |
| 338 | |
| 339 | /* Sending Header */ |
| 340 | wait_and_send(chip, TPM_VL_VER); |
| 341 | wait_and_send(chip, TPM_CTRL_DATA); |
| 342 | wait_and_send(chip, count_high); |
| 343 | wait_and_send(chip, count_low); |
| 344 | |
| 345 | /* Sending Data Header */ |
| 346 | wait_and_send(chip, TPM_VL_VER); |
| 347 | wait_and_send(chip, TPM_VL_CHANNEL_TPM); |
| 348 | wait_and_send(chip, count_4); |
| 349 | wait_and_send(chip, count_3); |
| 350 | wait_and_send(chip, count_2); |
| 351 | wait_and_send(chip, count_1); |
| 352 | |
| 353 | /* Sending Data */ |
| 354 | for (i = 0; i < count; i++) { |
| 355 | wait_and_send(chip, buf[i]); |
| 356 | } |
| 357 | return count; |
| 358 | } |
| 359 | |
| 360 | static void tpm_inf_cancel(struct tpm_chip *chip) |
| 361 | { |
Marcel Selhorst | f9abb02 | 2005-08-05 11:59:33 -0700 | [diff] [blame] | 362 | /* |
| 363 | Since we are using the legacy mode to communicate |
| 364 | with the TPM, we have no cancel functions, but have |
| 365 | a workaround for interrupting the TPM through WTX. |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 366 | */ |
| 367 | } |
| 368 | |
Kylene Jo Hall | b4ed3e3 | 2005-10-30 15:03:23 -0800 | [diff] [blame] | 369 | static u8 tpm_inf_status(struct tpm_chip *chip) |
| 370 | { |
Alex Williamson | d954e8e | 2007-05-08 00:25:55 -0700 | [diff] [blame] | 371 | return tpm_data_in(STAT); |
Kylene Jo Hall | b4ed3e3 | 2005-10-30 15:03:23 -0800 | [diff] [blame] | 372 | } |
| 373 | |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 374 | static DEVICE_ATTR(pubek, S_IRUGO, tpm_show_pubek, NULL); |
| 375 | static DEVICE_ATTR(pcrs, S_IRUGO, tpm_show_pcrs, NULL); |
| 376 | static DEVICE_ATTR(caps, S_IRUGO, tpm_show_caps, NULL); |
| 377 | static DEVICE_ATTR(cancel, S_IWUSR | S_IWGRP, NULL, tpm_store_cancel); |
| 378 | |
| 379 | static struct attribute *inf_attrs[] = { |
| 380 | &dev_attr_pubek.attr, |
| 381 | &dev_attr_pcrs.attr, |
| 382 | &dev_attr_caps.attr, |
| 383 | &dev_attr_cancel.attr, |
| 384 | NULL, |
| 385 | }; |
| 386 | |
| 387 | static struct attribute_group inf_attr_grp = {.attrs = inf_attrs }; |
| 388 | |
Arjan van de Ven | 62322d2 | 2006-07-03 00:24:21 -0700 | [diff] [blame] | 389 | static const struct file_operations inf_ops = { |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 390 | .owner = THIS_MODULE, |
| 391 | .llseek = no_llseek, |
| 392 | .open = tpm_open, |
| 393 | .read = tpm_read, |
| 394 | .write = tpm_write, |
| 395 | .release = tpm_release, |
| 396 | }; |
| 397 | |
Marcel Selhorst | e496f540 | 2006-04-22 02:38:42 -0700 | [diff] [blame] | 398 | static const struct tpm_vendor_specific tpm_inf = { |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 399 | .recv = tpm_inf_recv, |
| 400 | .send = tpm_inf_send, |
| 401 | .cancel = tpm_inf_cancel, |
Kylene Jo Hall | b4ed3e3 | 2005-10-30 15:03:23 -0800 | [diff] [blame] | 402 | .status = tpm_inf_status, |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 403 | .req_complete_mask = 0, |
| 404 | .req_complete_val = 0, |
| 405 | .attr_group = &inf_attr_grp, |
| 406 | .miscdev = {.fops = &inf_ops,}, |
| 407 | }; |
| 408 | |
Marcel Selhorst | 93716b9 | 2010-02-10 13:56:32 -0800 | [diff] [blame] | 409 | static const struct pnp_device_id tpm_inf_pnp_tbl[] = { |
Marcel Selhorst | f9abb02 | 2005-08-05 11:59:33 -0700 | [diff] [blame] | 410 | /* Infineon TPMs */ |
| 411 | {"IFX0101", 0}, |
| 412 | {"IFX0102", 0}, |
| 413 | {"", 0} |
| 414 | }; |
Marcel Selhorst | 1b8333b | 2005-10-30 15:03:27 -0800 | [diff] [blame] | 415 | |
Marcel Selhorst | 93716b9 | 2010-02-10 13:56:32 -0800 | [diff] [blame] | 416 | MODULE_DEVICE_TABLE(pnp, tpm_inf_pnp_tbl); |
Marcel Selhorst | f9abb02 | 2005-08-05 11:59:33 -0700 | [diff] [blame] | 417 | |
Bill Pemberton | afc6d36 | 2012-11-19 13:22:42 -0500 | [diff] [blame^] | 418 | static int tpm_inf_pnp_probe(struct pnp_dev *dev, |
Marcel Selhorst | 1b8333b | 2005-10-30 15:03:27 -0800 | [diff] [blame] | 419 | const struct pnp_device_id *dev_id) |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 420 | { |
| 421 | int rc = 0; |
| 422 | u8 iol, ioh; |
| 423 | int vendorid[2]; |
| 424 | int version[2]; |
| 425 | int productid[2]; |
Marcel Selhorst | f9abb02 | 2005-08-05 11:59:33 -0700 | [diff] [blame] | 426 | char chipname[20]; |
Marcel Selhorst | e496f540 | 2006-04-22 02:38:42 -0700 | [diff] [blame] | 427 | struct tpm_chip *chip; |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 428 | |
Marcel Selhorst | 1b8333b | 2005-10-30 15:03:27 -0800 | [diff] [blame] | 429 | /* read IO-ports through PnP */ |
| 430 | if (pnp_port_valid(dev, 0) && pnp_port_valid(dev, 1) && |
| 431 | !(pnp_port_flags(dev, 0) & IORESOURCE_DISABLED)) { |
Alex Williamson | d954e8e | 2007-05-08 00:25:55 -0700 | [diff] [blame] | 432 | |
Marcel Selhorst | 93716b9 | 2010-02-10 13:56:32 -0800 | [diff] [blame] | 433 | tpm_dev.iotype = TPM_INF_IO_PORT; |
Alex Williamson | d954e8e | 2007-05-08 00:25:55 -0700 | [diff] [blame] | 434 | |
| 435 | tpm_dev.config_port = pnp_port_start(dev, 0); |
| 436 | tpm_dev.config_size = pnp_port_len(dev, 0); |
| 437 | tpm_dev.data_regs = pnp_port_start(dev, 1); |
| 438 | tpm_dev.data_size = pnp_port_len(dev, 1); |
| 439 | if ((tpm_dev.data_size < 4) || (tpm_dev.config_size < 2)) { |
Marcel Selhorst | 8c9e877 | 2006-02-17 13:52:41 -0800 | [diff] [blame] | 440 | rc = -EINVAL; |
| 441 | goto err_last; |
| 442 | } |
Marcel Selhorst | 1b8333b | 2005-10-30 15:03:27 -0800 | [diff] [blame] | 443 | dev_info(&dev->dev, "Found %s with ID %s\n", |
| 444 | dev->name, dev_id->id); |
Alex Williamson | d954e8e | 2007-05-08 00:25:55 -0700 | [diff] [blame] | 445 | if (!((tpm_dev.data_regs >> 8) & 0xff)) { |
Marcel Selhorst | 8c9e877 | 2006-02-17 13:52:41 -0800 | [diff] [blame] | 446 | rc = -EINVAL; |
| 447 | goto err_last; |
| 448 | } |
Marcel Selhorst | 1b8333b | 2005-10-30 15:03:27 -0800 | [diff] [blame] | 449 | /* publish my base address and request region */ |
Alex Williamson | d954e8e | 2007-05-08 00:25:55 -0700 | [diff] [blame] | 450 | if (request_region(tpm_dev.data_regs, tpm_dev.data_size, |
| 451 | "tpm_infineon0") == NULL) { |
Marcel Selhorst | 8c9e877 | 2006-02-17 13:52:41 -0800 | [diff] [blame] | 452 | rc = -EINVAL; |
| 453 | goto err_last; |
| 454 | } |
Alex Williamson | d954e8e | 2007-05-08 00:25:55 -0700 | [diff] [blame] | 455 | if (request_region(tpm_dev.config_port, tpm_dev.config_size, |
| 456 | "tpm_infineon0") == NULL) { |
| 457 | release_region(tpm_dev.data_regs, tpm_dev.data_size); |
Marcel Selhorst | 8c9e877 | 2006-02-17 13:52:41 -0800 | [diff] [blame] | 458 | rc = -EINVAL; |
| 459 | goto err_last; |
Marcel Selhorst | 1b8333b | 2005-10-30 15:03:27 -0800 | [diff] [blame] | 460 | } |
Alex Williamson | d954e8e | 2007-05-08 00:25:55 -0700 | [diff] [blame] | 461 | } else if (pnp_mem_valid(dev, 0) && |
Marcel Selhorst | 93716b9 | 2010-02-10 13:56:32 -0800 | [diff] [blame] | 462 | !(pnp_mem_flags(dev, 0) & IORESOURCE_DISABLED)) { |
Alex Williamson | d954e8e | 2007-05-08 00:25:55 -0700 | [diff] [blame] | 463 | |
Marcel Selhorst | 93716b9 | 2010-02-10 13:56:32 -0800 | [diff] [blame] | 464 | tpm_dev.iotype = TPM_INF_IO_MEM; |
Alex Williamson | d954e8e | 2007-05-08 00:25:55 -0700 | [diff] [blame] | 465 | |
| 466 | tpm_dev.map_base = pnp_mem_start(dev, 0); |
| 467 | tpm_dev.map_size = pnp_mem_len(dev, 0); |
| 468 | |
| 469 | dev_info(&dev->dev, "Found %s with ID %s\n", |
| 470 | dev->name, dev_id->id); |
| 471 | |
| 472 | /* publish my base address and request region */ |
| 473 | if (request_mem_region(tpm_dev.map_base, tpm_dev.map_size, |
| 474 | "tpm_infineon0") == NULL) { |
| 475 | rc = -EINVAL; |
| 476 | goto err_last; |
| 477 | } |
| 478 | |
| 479 | tpm_dev.mem_base = ioremap(tpm_dev.map_base, tpm_dev.map_size); |
| 480 | if (tpm_dev.mem_base == NULL) { |
| 481 | release_mem_region(tpm_dev.map_base, tpm_dev.map_size); |
| 482 | rc = -EINVAL; |
| 483 | goto err_last; |
| 484 | } |
| 485 | |
| 486 | /* |
| 487 | * The only known MMIO based Infineon TPM system provides |
| 488 | * a single large mem region with the device config |
| 489 | * registers at the default TPM_ADDR. The data registers |
| 490 | * seem like they could be placed anywhere within the MMIO |
| 491 | * region, but lets just put them at zero offset. |
| 492 | */ |
| 493 | tpm_dev.index_off = TPM_ADDR; |
| 494 | tpm_dev.data_regs = 0x0; |
Marcel Selhorst | e8a6501 | 2005-09-03 15:54:20 -0700 | [diff] [blame] | 495 | } else { |
Marcel Selhorst | 8c9e877 | 2006-02-17 13:52:41 -0800 | [diff] [blame] | 496 | rc = -EINVAL; |
| 497 | goto err_last; |
Marcel Selhorst | f9abb02 | 2005-08-05 11:59:33 -0700 | [diff] [blame] | 498 | } |
| 499 | |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 500 | /* query chip for its vendor, its version number a.s.o. */ |
Alex Williamson | d954e8e | 2007-05-08 00:25:55 -0700 | [diff] [blame] | 501 | tpm_config_out(ENABLE_REGISTER_PAIR, TPM_INF_ADDR); |
| 502 | tpm_config_out(IDVENL, TPM_INF_ADDR); |
| 503 | vendorid[1] = tpm_config_in(TPM_INF_DATA); |
| 504 | tpm_config_out(IDVENH, TPM_INF_ADDR); |
| 505 | vendorid[0] = tpm_config_in(TPM_INF_DATA); |
| 506 | tpm_config_out(IDPDL, TPM_INF_ADDR); |
| 507 | productid[1] = tpm_config_in(TPM_INF_DATA); |
| 508 | tpm_config_out(IDPDH, TPM_INF_ADDR); |
| 509 | productid[0] = tpm_config_in(TPM_INF_DATA); |
| 510 | tpm_config_out(CHIP_ID1, TPM_INF_ADDR); |
| 511 | version[1] = tpm_config_in(TPM_INF_DATA); |
| 512 | tpm_config_out(CHIP_ID2, TPM_INF_ADDR); |
| 513 | version[0] = tpm_config_in(TPM_INF_DATA); |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 514 | |
Marcel Selhorst | f9abb02 | 2005-08-05 11:59:33 -0700 | [diff] [blame] | 515 | switch ((productid[0] << 8) | productid[1]) { |
| 516 | case 6: |
Marcel Selhorst | e8a6501 | 2005-09-03 15:54:20 -0700 | [diff] [blame] | 517 | snprintf(chipname, sizeof(chipname), " (SLD 9630 TT 1.1)"); |
Marcel Selhorst | f9abb02 | 2005-08-05 11:59:33 -0700 | [diff] [blame] | 518 | break; |
| 519 | case 11: |
Marcel Selhorst | e8a6501 | 2005-09-03 15:54:20 -0700 | [diff] [blame] | 520 | snprintf(chipname, sizeof(chipname), " (SLB 9635 TT 1.2)"); |
Marcel Selhorst | f9abb02 | 2005-08-05 11:59:33 -0700 | [diff] [blame] | 521 | break; |
| 522 | default: |
Marcel Selhorst | e8a6501 | 2005-09-03 15:54:20 -0700 | [diff] [blame] | 523 | snprintf(chipname, sizeof(chipname), " (unknown chip)"); |
Marcel Selhorst | f9abb02 | 2005-08-05 11:59:33 -0700 | [diff] [blame] | 524 | break; |
| 525 | } |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 526 | |
Marcel Selhorst | f9abb02 | 2005-08-05 11:59:33 -0700 | [diff] [blame] | 527 | if ((vendorid[0] << 8 | vendorid[1]) == (TPM_INFINEON_DEV_VEN_VALUE)) { |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 528 | |
Marcel Selhorst | f9abb02 | 2005-08-05 11:59:33 -0700 | [diff] [blame] | 529 | /* configure TPM with IO-ports */ |
Alex Williamson | d954e8e | 2007-05-08 00:25:55 -0700 | [diff] [blame] | 530 | tpm_config_out(IOLIMH, TPM_INF_ADDR); |
| 531 | tpm_config_out((tpm_dev.data_regs >> 8) & 0xff, TPM_INF_DATA); |
| 532 | tpm_config_out(IOLIML, TPM_INF_ADDR); |
| 533 | tpm_config_out((tpm_dev.data_regs & 0xff), TPM_INF_DATA); |
Marcel Selhorst | f9abb02 | 2005-08-05 11:59:33 -0700 | [diff] [blame] | 534 | |
| 535 | /* control if IO-ports are set correctly */ |
Alex Williamson | d954e8e | 2007-05-08 00:25:55 -0700 | [diff] [blame] | 536 | tpm_config_out(IOLIMH, TPM_INF_ADDR); |
| 537 | ioh = tpm_config_in(TPM_INF_DATA); |
| 538 | tpm_config_out(IOLIML, TPM_INF_ADDR); |
| 539 | iol = tpm_config_in(TPM_INF_DATA); |
Marcel Selhorst | f9abb02 | 2005-08-05 11:59:33 -0700 | [diff] [blame] | 540 | |
Alex Williamson | d954e8e | 2007-05-08 00:25:55 -0700 | [diff] [blame] | 541 | if ((ioh << 8 | iol) != tpm_dev.data_regs) { |
Marcel Selhorst | 1b8333b | 2005-10-30 15:03:27 -0800 | [diff] [blame] | 542 | dev_err(&dev->dev, |
Alex Williamson | d954e8e | 2007-05-08 00:25:55 -0700 | [diff] [blame] | 543 | "Could not set IO-data registers to 0x%x\n", |
| 544 | tpm_dev.data_regs); |
Marcel Selhorst | 8c9e877 | 2006-02-17 13:52:41 -0800 | [diff] [blame] | 545 | rc = -EIO; |
| 546 | goto err_release_region; |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 547 | } |
| 548 | |
| 549 | /* activate register */ |
Alex Williamson | d954e8e | 2007-05-08 00:25:55 -0700 | [diff] [blame] | 550 | tpm_config_out(TPM_DAR, TPM_INF_ADDR); |
| 551 | tpm_config_out(0x01, TPM_INF_DATA); |
| 552 | tpm_config_out(DISABLE_REGISTER_PAIR, TPM_INF_ADDR); |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 553 | |
| 554 | /* disable RESET, LP and IRQC */ |
Alex Williamson | d954e8e | 2007-05-08 00:25:55 -0700 | [diff] [blame] | 555 | tpm_data_out(RESET_LP_IRQC_DISABLE, CMD); |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 556 | |
| 557 | /* Finally, we're done, print some infos */ |
Marcel Selhorst | 1b8333b | 2005-10-30 15:03:27 -0800 | [diff] [blame] | 558 | dev_info(&dev->dev, "TPM found: " |
Alex Williamson | d954e8e | 2007-05-08 00:25:55 -0700 | [diff] [blame] | 559 | "config base 0x%lx, " |
| 560 | "data base 0x%lx, " |
Marcel Selhorst | e496f540 | 2006-04-22 02:38:42 -0700 | [diff] [blame] | 561 | "chip version 0x%02x%02x, " |
| 562 | "vendor id 0x%x%x (Infineon), " |
| 563 | "product id 0x%02x%02x" |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 564 | "%s\n", |
Alex Williamson | d954e8e | 2007-05-08 00:25:55 -0700 | [diff] [blame] | 565 | tpm_dev.iotype == TPM_INF_IO_PORT ? |
Marcel Selhorst | 93716b9 | 2010-02-10 13:56:32 -0800 | [diff] [blame] | 566 | tpm_dev.config_port : |
| 567 | tpm_dev.map_base + tpm_dev.index_off, |
Alex Williamson | d954e8e | 2007-05-08 00:25:55 -0700 | [diff] [blame] | 568 | tpm_dev.iotype == TPM_INF_IO_PORT ? |
Marcel Selhorst | 93716b9 | 2010-02-10 13:56:32 -0800 | [diff] [blame] | 569 | tpm_dev.data_regs : |
| 570 | tpm_dev.map_base + tpm_dev.data_regs, |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 571 | version[0], version[1], |
| 572 | vendorid[0], vendorid[1], |
Marcel Selhorst | f9abb02 | 2005-08-05 11:59:33 -0700 | [diff] [blame] | 573 | productid[0], productid[1], chipname); |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 574 | |
Alex Williamson | d954e8e | 2007-05-08 00:25:55 -0700 | [diff] [blame] | 575 | if (!(chip = tpm_register_hardware(&dev->dev, &tpm_inf))) |
Marcel Selhorst | 8c9e877 | 2006-02-17 13:52:41 -0800 | [diff] [blame] | 576 | goto err_release_region; |
Alex Williamson | d954e8e | 2007-05-08 00:25:55 -0700 | [diff] [blame] | 577 | |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 578 | return 0; |
| 579 | } else { |
Marcel Selhorst | 8c9e877 | 2006-02-17 13:52:41 -0800 | [diff] [blame] | 580 | rc = -ENODEV; |
| 581 | goto err_release_region; |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 582 | } |
Marcel Selhorst | 8c9e877 | 2006-02-17 13:52:41 -0800 | [diff] [blame] | 583 | |
| 584 | err_release_region: |
Alex Williamson | d954e8e | 2007-05-08 00:25:55 -0700 | [diff] [blame] | 585 | if (tpm_dev.iotype == TPM_INF_IO_PORT) { |
| 586 | release_region(tpm_dev.data_regs, tpm_dev.data_size); |
| 587 | release_region(tpm_dev.config_port, tpm_dev.config_size); |
| 588 | } else { |
| 589 | iounmap(tpm_dev.mem_base); |
| 590 | release_mem_region(tpm_dev.map_base, tpm_dev.map_size); |
| 591 | } |
Marcel Selhorst | 8c9e877 | 2006-02-17 13:52:41 -0800 | [diff] [blame] | 592 | |
| 593 | err_last: |
| 594 | return rc; |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 595 | } |
| 596 | |
Marcel Selhorst | 1b8333b | 2005-10-30 15:03:27 -0800 | [diff] [blame] | 597 | static __devexit void tpm_inf_pnp_remove(struct pnp_dev *dev) |
Kylene Jo Hall | e659a3f | 2005-10-30 15:03:24 -0800 | [diff] [blame] | 598 | { |
Marcel Selhorst | 1b8333b | 2005-10-30 15:03:27 -0800 | [diff] [blame] | 599 | struct tpm_chip *chip = pnp_get_drvdata(dev); |
Kylene Jo Hall | e659a3f | 2005-10-30 15:03:24 -0800 | [diff] [blame] | 600 | |
Marcel Selhorst | 1b8333b | 2005-10-30 15:03:27 -0800 | [diff] [blame] | 601 | if (chip) { |
Alex Williamson | d954e8e | 2007-05-08 00:25:55 -0700 | [diff] [blame] | 602 | if (tpm_dev.iotype == TPM_INF_IO_PORT) { |
| 603 | release_region(tpm_dev.data_regs, tpm_dev.data_size); |
| 604 | release_region(tpm_dev.config_port, |
| 605 | tpm_dev.config_size); |
| 606 | } else { |
| 607 | iounmap(tpm_dev.mem_base); |
| 608 | release_mem_region(tpm_dev.map_base, tpm_dev.map_size); |
| 609 | } |
Marcel Selhorst | 93716b9 | 2010-02-10 13:56:32 -0800 | [diff] [blame] | 610 | tpm_dev_vendor_release(chip); |
Kylene Jo Hall | e659a3f | 2005-10-30 15:03:24 -0800 | [diff] [blame] | 611 | tpm_remove_hardware(chip->dev); |
Marcel Selhorst | 1b8333b | 2005-10-30 15:03:27 -0800 | [diff] [blame] | 612 | } |
Kylene Jo Hall | e659a3f | 2005-10-30 15:03:24 -0800 | [diff] [blame] | 613 | } |
| 614 | |
Marcel Selhorst | 93716b9 | 2010-02-10 13:56:32 -0800 | [diff] [blame] | 615 | static int tpm_inf_pnp_suspend(struct pnp_dev *dev, pm_message_t pm_state) |
| 616 | { |
| 617 | struct tpm_chip *chip = pnp_get_drvdata(dev); |
| 618 | int rc; |
| 619 | if (chip) { |
| 620 | u8 savestate[] = { |
| 621 | 0, 193, /* TPM_TAG_RQU_COMMAND */ |
| 622 | 0, 0, 0, 10, /* blob length (in bytes) */ |
| 623 | 0, 0, 0, 152 /* TPM_ORD_SaveState */ |
| 624 | }; |
| 625 | dev_info(&dev->dev, "saving TPM state\n"); |
| 626 | rc = tpm_inf_send(chip, savestate, sizeof(savestate)); |
| 627 | if (rc < 0) { |
| 628 | dev_err(&dev->dev, "error while saving TPM state\n"); |
| 629 | return rc; |
| 630 | } |
| 631 | } |
| 632 | return 0; |
| 633 | } |
| 634 | |
| 635 | static int tpm_inf_pnp_resume(struct pnp_dev *dev) |
| 636 | { |
| 637 | /* Re-configure TPM after suspending */ |
| 638 | tpm_config_out(ENABLE_REGISTER_PAIR, TPM_INF_ADDR); |
| 639 | tpm_config_out(IOLIMH, TPM_INF_ADDR); |
| 640 | tpm_config_out((tpm_dev.data_regs >> 8) & 0xff, TPM_INF_DATA); |
| 641 | tpm_config_out(IOLIML, TPM_INF_ADDR); |
| 642 | tpm_config_out((tpm_dev.data_regs & 0xff), TPM_INF_DATA); |
| 643 | /* activate register */ |
| 644 | tpm_config_out(TPM_DAR, TPM_INF_ADDR); |
| 645 | tpm_config_out(0x01, TPM_INF_DATA); |
| 646 | tpm_config_out(DISABLE_REGISTER_PAIR, TPM_INF_ADDR); |
| 647 | /* disable RESET, LP and IRQC */ |
| 648 | tpm_data_out(RESET_LP_IRQC_DISABLE, CMD); |
| 649 | return tpm_pm_resume(&dev->dev); |
| 650 | } |
| 651 | |
Randy Dunlap | e1d42c9 | 2008-02-06 01:38:06 -0800 | [diff] [blame] | 652 | static struct pnp_driver tpm_inf_pnp_driver = { |
Marcel Selhorst | 1b8333b | 2005-10-30 15:03:27 -0800 | [diff] [blame] | 653 | .name = "tpm_inf_pnp", |
Marcel Selhorst | 93716b9 | 2010-02-10 13:56:32 -0800 | [diff] [blame] | 654 | .id_table = tpm_inf_pnp_tbl, |
Marcel Selhorst | 1b8333b | 2005-10-30 15:03:27 -0800 | [diff] [blame] | 655 | .probe = tpm_inf_pnp_probe, |
Marcel Selhorst | 93716b9 | 2010-02-10 13:56:32 -0800 | [diff] [blame] | 656 | .suspend = tpm_inf_pnp_suspend, |
| 657 | .resume = tpm_inf_pnp_resume, |
| 658 | .remove = __devexit_p(tpm_inf_pnp_remove) |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 659 | }; |
| 660 | |
| 661 | static int __init init_inf(void) |
| 662 | { |
Randy Dunlap | e1d42c9 | 2008-02-06 01:38:06 -0800 | [diff] [blame] | 663 | return pnp_register_driver(&tpm_inf_pnp_driver); |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 664 | } |
| 665 | |
| 666 | static void __exit cleanup_inf(void) |
| 667 | { |
Randy Dunlap | e1d42c9 | 2008-02-06 01:38:06 -0800 | [diff] [blame] | 668 | pnp_unregister_driver(&tpm_inf_pnp_driver); |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 669 | } |
| 670 | |
| 671 | module_init(init_inf); |
| 672 | module_exit(cleanup_inf); |
| 673 | |
Rajiv Andrade | cbb2d5e | 2012-04-24 11:19:58 -0300 | [diff] [blame] | 674 | MODULE_AUTHOR("Marcel Selhorst <tpmdd@sirrix.com>"); |
Marcel Selhorst | f9abb02 | 2005-08-05 11:59:33 -0700 | [diff] [blame] | 675 | MODULE_DESCRIPTION("Driver for Infineon TPM SLD 9630 TT 1.1 / SLB 9635 TT 1.2"); |
Marcel Selhorst | 93716b9 | 2010-02-10 13:56:32 -0800 | [diff] [blame] | 676 | MODULE_VERSION("1.9.2"); |
Marcel Selhorst | ebb81fd | 2005-07-27 11:45:12 -0700 | [diff] [blame] | 677 | MODULE_LICENSE("GPL"); |