Merge branch 'for-linus' of git://selinuxproject.org/~jmorris/linux-security
[linux-3.10.git] / drivers / char / tpm / tpm_tis.c
1 /*
2  * Copyright (C) 2005, 2006 IBM Corporation
3  *
4  * Authors:
5  * Leendert van Doorn <leendert@watson.ibm.com>
6  * Kylene Hall <kjhall@us.ibm.com>
7  *
8  * Maintained by: <tpmdd-devel@lists.sourceforge.net>
9  *
10  * Device driver for TCG/TCPA TPM (trusted platform module).
11  * Specifications at www.trustedcomputinggroup.org
12  *
13  * This device driver implements the TPM interface as defined in
14  * the TCG TPM Interface Spec version 1.2, revision 1.0.
15  *
16  * This program is free software; you can redistribute it and/or
17  * modify it under the terms of the GNU General Public License as
18  * published by the Free Software Foundation, version 2 of the
19  * License.
20  */
21 #include <linux/init.h>
22 #include <linux/module.h>
23 #include <linux/moduleparam.h>
24 #include <linux/pnp.h>
25 #include <linux/slab.h>
26 #include <linux/interrupt.h>
27 #include <linux/wait.h>
28 #include <linux/acpi.h>
29 #include <linux/freezer.h>
30 #include "tpm.h"
31
32 enum tis_access {
33         TPM_ACCESS_VALID = 0x80,
34         TPM_ACCESS_ACTIVE_LOCALITY = 0x20,
35         TPM_ACCESS_REQUEST_PENDING = 0x04,
36         TPM_ACCESS_REQUEST_USE = 0x02,
37 };
38
39 enum tis_status {
40         TPM_STS_VALID = 0x80,
41         TPM_STS_COMMAND_READY = 0x40,
42         TPM_STS_GO = 0x20,
43         TPM_STS_DATA_AVAIL = 0x10,
44         TPM_STS_DATA_EXPECT = 0x08,
45 };
46
47 enum tis_int_flags {
48         TPM_GLOBAL_INT_ENABLE = 0x80000000,
49         TPM_INTF_BURST_COUNT_STATIC = 0x100,
50         TPM_INTF_CMD_READY_INT = 0x080,
51         TPM_INTF_INT_EDGE_FALLING = 0x040,
52         TPM_INTF_INT_EDGE_RISING = 0x020,
53         TPM_INTF_INT_LEVEL_LOW = 0x010,
54         TPM_INTF_INT_LEVEL_HIGH = 0x008,
55         TPM_INTF_LOCALITY_CHANGE_INT = 0x004,
56         TPM_INTF_STS_VALID_INT = 0x002,
57         TPM_INTF_DATA_AVAIL_INT = 0x001,
58 };
59
60 enum tis_defaults {
61         TIS_MEM_BASE = 0xFED40000,
62         TIS_MEM_LEN = 0x5000,
63         TIS_SHORT_TIMEOUT = 750,        /* ms */
64         TIS_LONG_TIMEOUT = 2000,        /* 2 sec */
65 };
66
67 #define TPM_ACCESS(l)                   (0x0000 | ((l) << 12))
68 #define TPM_INT_ENABLE(l)               (0x0008 | ((l) << 12))
69 #define TPM_INT_VECTOR(l)               (0x000C | ((l) << 12))
70 #define TPM_INT_STATUS(l)               (0x0010 | ((l) << 12))
71 #define TPM_INTF_CAPS(l)                (0x0014 | ((l) << 12))
72 #define TPM_STS(l)                      (0x0018 | ((l) << 12))
73 #define TPM_DATA_FIFO(l)                (0x0024 | ((l) << 12))
74
75 #define TPM_DID_VID(l)                  (0x0F00 | ((l) << 12))
76 #define TPM_RID(l)                      (0x0F04 | ((l) << 12))
77
78 static LIST_HEAD(tis_chips);
79 static DEFINE_SPINLOCK(tis_lock);
80
81 #if defined(CONFIG_PNP) && defined(CONFIG_ACPI)
82 static int is_itpm(struct pnp_dev *dev)
83 {
84         struct acpi_device *acpi = pnp_acpi_device(dev);
85         struct acpi_hardware_id *id;
86
87         list_for_each_entry(id, &acpi->pnp.ids, list) {
88                 if (!strcmp("INTC0102", id->id))
89                         return 1;
90         }
91
92         return 0;
93 }
94 #else
95 static inline int is_itpm(struct pnp_dev *dev)
96 {
97         return 0;
98 }
99 #endif
100
101 static int check_locality(struct tpm_chip *chip, int l)
102 {
103         if ((ioread8(chip->vendor.iobase + TPM_ACCESS(l)) &
104              (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID)) ==
105             (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID))
106                 return chip->vendor.locality = l;
107
108         return -1;
109 }
110
111 static void release_locality(struct tpm_chip *chip, int l, int force)
112 {
113         if (force || (ioread8(chip->vendor.iobase + TPM_ACCESS(l)) &
114                       (TPM_ACCESS_REQUEST_PENDING | TPM_ACCESS_VALID)) ==
115             (TPM_ACCESS_REQUEST_PENDING | TPM_ACCESS_VALID))
116                 iowrite8(TPM_ACCESS_ACTIVE_LOCALITY,
117                          chip->vendor.iobase + TPM_ACCESS(l));
118 }
119
120 static int request_locality(struct tpm_chip *chip, int l)
121 {
122         unsigned long stop, timeout;
123         long rc;
124
125         if (check_locality(chip, l) >= 0)
126                 return l;
127
128         iowrite8(TPM_ACCESS_REQUEST_USE,
129                  chip->vendor.iobase + TPM_ACCESS(l));
130
131         stop = jiffies + chip->vendor.timeout_a;
132
133         if (chip->vendor.irq) {
134 again:
135                 timeout = stop - jiffies;
136                 if ((long)timeout <= 0)
137                         return -1;
138                 rc = wait_event_interruptible_timeout(chip->vendor.int_queue,
139                                                       (check_locality
140                                                        (chip, l) >= 0),
141                                                       timeout);
142                 if (rc > 0)
143                         return l;
144                 if (rc == -ERESTARTSYS && freezing(current)) {
145                         clear_thread_flag(TIF_SIGPENDING);
146                         goto again;
147                 }
148         } else {
149                 /* wait for burstcount */
150                 do {
151                         if (check_locality(chip, l) >= 0)
152                                 return l;
153                         msleep(TPM_TIMEOUT);
154                 }
155                 while (time_before(jiffies, stop));
156         }
157         return -1;
158 }
159
160 static u8 tpm_tis_status(struct tpm_chip *chip)
161 {
162         return ioread8(chip->vendor.iobase +
163                        TPM_STS(chip->vendor.locality));
164 }
165
166 static void tpm_tis_ready(struct tpm_chip *chip)
167 {
168         /* this causes the current command to be aborted */
169         iowrite8(TPM_STS_COMMAND_READY,
170                  chip->vendor.iobase + TPM_STS(chip->vendor.locality));
171 }
172
173 static int get_burstcount(struct tpm_chip *chip)
174 {
175         unsigned long stop;
176         int burstcnt;
177
178         /* wait for burstcount */
179         /* which timeout value, spec has 2 answers (c & d) */
180         stop = jiffies + chip->vendor.timeout_d;
181         do {
182                 burstcnt = ioread8(chip->vendor.iobase +
183                                    TPM_STS(chip->vendor.locality) + 1);
184                 burstcnt += ioread8(chip->vendor.iobase +
185                                     TPM_STS(chip->vendor.locality) +
186                                     2) << 8;
187                 if (burstcnt)
188                         return burstcnt;
189                 msleep(TPM_TIMEOUT);
190         } while (time_before(jiffies, stop));
191         return -EBUSY;
192 }
193
194 static int recv_data(struct tpm_chip *chip, u8 *buf, size_t count)
195 {
196         int size = 0, burstcnt;
197         while (size < count &&
198                wait_for_tpm_stat(chip,
199                                  TPM_STS_DATA_AVAIL | TPM_STS_VALID,
200                                  chip->vendor.timeout_c,
201                                  &chip->vendor.read_queue)
202                == 0) {
203                 burstcnt = get_burstcount(chip);
204                 for (; burstcnt > 0 && size < count; burstcnt--)
205                         buf[size++] = ioread8(chip->vendor.iobase +
206                                               TPM_DATA_FIFO(chip->vendor.
207                                                             locality));
208         }
209         return size;
210 }
211
212 static int tpm_tis_recv(struct tpm_chip *chip, u8 *buf, size_t count)
213 {
214         int size = 0;
215         int expected, status;
216
217         if (count < TPM_HEADER_SIZE) {
218                 size = -EIO;
219                 goto out;
220         }
221
222         /* read first 10 bytes, including tag, paramsize, and result */
223         if ((size =
224              recv_data(chip, buf, TPM_HEADER_SIZE)) < TPM_HEADER_SIZE) {
225                 dev_err(chip->dev, "Unable to read header\n");
226                 goto out;
227         }
228
229         expected = be32_to_cpu(*(__be32 *) (buf + 2));
230         if (expected > count) {
231                 size = -EIO;
232                 goto out;
233         }
234
235         if ((size +=
236              recv_data(chip, &buf[TPM_HEADER_SIZE],
237                        expected - TPM_HEADER_SIZE)) < expected) {
238                 dev_err(chip->dev, "Unable to read remainder of result\n");
239                 size = -ETIME;
240                 goto out;
241         }
242
243         wait_for_tpm_stat(chip, TPM_STS_VALID, chip->vendor.timeout_c,
244                           &chip->vendor.int_queue);
245         status = tpm_tis_status(chip);
246         if (status & TPM_STS_DATA_AVAIL) {      /* retry? */
247                 dev_err(chip->dev, "Error left over data\n");
248                 size = -EIO;
249                 goto out;
250         }
251
252 out:
253         tpm_tis_ready(chip);
254         release_locality(chip, chip->vendor.locality, 0);
255         return size;
256 }
257
258 static int itpm;
259 module_param(itpm, bool, 0444);
260 MODULE_PARM_DESC(itpm, "Force iTPM workarounds (found on some Lenovo laptops)");
261
262 /*
263  * If interrupts are used (signaled by an irq set in the vendor structure)
264  * tpm.c can skip polling for the data to be available as the interrupt is
265  * waited for here
266  */
267 static int tpm_tis_send_data(struct tpm_chip *chip, u8 *buf, size_t len)
268 {
269         int rc, status, burstcnt;
270         size_t count = 0;
271
272         if (request_locality(chip, 0) < 0)
273                 return -EBUSY;
274
275         status = tpm_tis_status(chip);
276         if ((status & TPM_STS_COMMAND_READY) == 0) {
277                 tpm_tis_ready(chip);
278                 if (wait_for_tpm_stat
279                     (chip, TPM_STS_COMMAND_READY, chip->vendor.timeout_b,
280                      &chip->vendor.int_queue) < 0) {
281                         rc = -ETIME;
282                         goto out_err;
283                 }
284         }
285
286         while (count < len - 1) {
287                 burstcnt = get_burstcount(chip);
288                 for (; burstcnt > 0 && count < len - 1; burstcnt--) {
289                         iowrite8(buf[count], chip->vendor.iobase +
290                                  TPM_DATA_FIFO(chip->vendor.locality));
291                         count++;
292                 }
293
294                 wait_for_tpm_stat(chip, TPM_STS_VALID, chip->vendor.timeout_c,
295                                   &chip->vendor.int_queue);
296                 status = tpm_tis_status(chip);
297                 if (!itpm && (status & TPM_STS_DATA_EXPECT) == 0) {
298                         rc = -EIO;
299                         goto out_err;
300                 }
301         }
302
303         /* write last byte */
304         iowrite8(buf[count],
305                  chip->vendor.iobase + TPM_DATA_FIFO(chip->vendor.locality));
306         wait_for_tpm_stat(chip, TPM_STS_VALID, chip->vendor.timeout_c,
307                           &chip->vendor.int_queue);
308         status = tpm_tis_status(chip);
309         if ((status & TPM_STS_DATA_EXPECT) != 0) {
310                 rc = -EIO;
311                 goto out_err;
312         }
313
314         return 0;
315
316 out_err:
317         tpm_tis_ready(chip);
318         release_locality(chip, chip->vendor.locality, 0);
319         return rc;
320 }
321
322 /*
323  * If interrupts are used (signaled by an irq set in the vendor structure)
324  * tpm.c can skip polling for the data to be available as the interrupt is
325  * waited for here
326  */
327 static int tpm_tis_send(struct tpm_chip *chip, u8 *buf, size_t len)
328 {
329         int rc;
330         u32 ordinal;
331
332         rc = tpm_tis_send_data(chip, buf, len);
333         if (rc < 0)
334                 return rc;
335
336         /* go and do it */
337         iowrite8(TPM_STS_GO,
338                  chip->vendor.iobase + TPM_STS(chip->vendor.locality));
339
340         if (chip->vendor.irq) {
341                 ordinal = be32_to_cpu(*((__be32 *) (buf + 6)));
342                 if (wait_for_tpm_stat
343                     (chip, TPM_STS_DATA_AVAIL | TPM_STS_VALID,
344                      tpm_calc_ordinal_duration(chip, ordinal),
345                      &chip->vendor.read_queue) < 0) {
346                         rc = -ETIME;
347                         goto out_err;
348                 }
349         }
350         return len;
351 out_err:
352         tpm_tis_ready(chip);
353         release_locality(chip, chip->vendor.locality, 0);
354         return rc;
355 }
356
357 /*
358  * Early probing for iTPM with STS_DATA_EXPECT flaw.
359  * Try sending command without itpm flag set and if that
360  * fails, repeat with itpm flag set.
361  */
362 static int probe_itpm(struct tpm_chip *chip)
363 {
364         int rc = 0;
365         u8 cmd_getticks[] = {
366                 0x00, 0xc1, 0x00, 0x00, 0x00, 0x0a,
367                 0x00, 0x00, 0x00, 0xf1
368         };
369         size_t len = sizeof(cmd_getticks);
370         int rem_itpm = itpm;
371
372         itpm = 0;
373
374         rc = tpm_tis_send_data(chip, cmd_getticks, len);
375         if (rc == 0)
376                 goto out;
377
378         tpm_tis_ready(chip);
379         release_locality(chip, chip->vendor.locality, 0);
380
381         itpm = 1;
382
383         rc = tpm_tis_send_data(chip, cmd_getticks, len);
384         if (rc == 0) {
385                 dev_info(chip->dev, "Detected an iTPM.\n");
386                 rc = 1;
387         } else
388                 rc = -EFAULT;
389
390 out:
391         itpm = rem_itpm;
392         tpm_tis_ready(chip);
393         /* some TPMs need a break here otherwise they will not work
394          * correctly on the immediately subsequent command */
395         msleep(chip->vendor.timeout_b);
396         release_locality(chip, chip->vendor.locality, 0);
397
398         return rc;
399 }
400
401 static const struct file_operations tis_ops = {
402         .owner = THIS_MODULE,
403         .llseek = no_llseek,
404         .open = tpm_open,
405         .read = tpm_read,
406         .write = tpm_write,
407         .release = tpm_release,
408 };
409
410 static DEVICE_ATTR(pubek, S_IRUGO, tpm_show_pubek, NULL);
411 static DEVICE_ATTR(pcrs, S_IRUGO, tpm_show_pcrs, NULL);
412 static DEVICE_ATTR(enabled, S_IRUGO, tpm_show_enabled, NULL);
413 static DEVICE_ATTR(active, S_IRUGO, tpm_show_active, NULL);
414 static DEVICE_ATTR(owned, S_IRUGO, tpm_show_owned, NULL);
415 static DEVICE_ATTR(temp_deactivated, S_IRUGO, tpm_show_temp_deactivated,
416                    NULL);
417 static DEVICE_ATTR(caps, S_IRUGO, tpm_show_caps_1_2, NULL);
418 static DEVICE_ATTR(cancel, S_IWUSR | S_IWGRP, NULL, tpm_store_cancel);
419 static DEVICE_ATTR(durations, S_IRUGO, tpm_show_durations, NULL);
420 static DEVICE_ATTR(timeouts, S_IRUGO, tpm_show_timeouts, NULL);
421
422 static struct attribute *tis_attrs[] = {
423         &dev_attr_pubek.attr,
424         &dev_attr_pcrs.attr,
425         &dev_attr_enabled.attr,
426         &dev_attr_active.attr,
427         &dev_attr_owned.attr,
428         &dev_attr_temp_deactivated.attr,
429         &dev_attr_caps.attr,
430         &dev_attr_cancel.attr,
431         &dev_attr_durations.attr,
432         &dev_attr_timeouts.attr, NULL,
433 };
434
435 static struct attribute_group tis_attr_grp = {
436         .attrs = tis_attrs
437 };
438
439 static struct tpm_vendor_specific tpm_tis = {
440         .status = tpm_tis_status,
441         .recv = tpm_tis_recv,
442         .send = tpm_tis_send,
443         .cancel = tpm_tis_ready,
444         .req_complete_mask = TPM_STS_DATA_AVAIL | TPM_STS_VALID,
445         .req_complete_val = TPM_STS_DATA_AVAIL | TPM_STS_VALID,
446         .req_canceled = TPM_STS_COMMAND_READY,
447         .attr_group = &tis_attr_grp,
448         .miscdev = {
449                     .fops = &tis_ops,},
450 };
451
452 static irqreturn_t tis_int_probe(int irq, void *dev_id)
453 {
454         struct tpm_chip *chip = dev_id;
455         u32 interrupt;
456
457         interrupt = ioread32(chip->vendor.iobase +
458                              TPM_INT_STATUS(chip->vendor.locality));
459
460         if (interrupt == 0)
461                 return IRQ_NONE;
462
463         chip->vendor.probed_irq = irq;
464
465         /* Clear interrupts handled with TPM_EOI */
466         iowrite32(interrupt,
467                   chip->vendor.iobase +
468                   TPM_INT_STATUS(chip->vendor.locality));
469         return IRQ_HANDLED;
470 }
471
472 static irqreturn_t tis_int_handler(int dummy, void *dev_id)
473 {
474         struct tpm_chip *chip = dev_id;
475         u32 interrupt;
476         int i;
477
478         interrupt = ioread32(chip->vendor.iobase +
479                              TPM_INT_STATUS(chip->vendor.locality));
480
481         if (interrupt == 0)
482                 return IRQ_NONE;
483
484         if (interrupt & TPM_INTF_DATA_AVAIL_INT)
485                 wake_up_interruptible(&chip->vendor.read_queue);
486         if (interrupt & TPM_INTF_LOCALITY_CHANGE_INT)
487                 for (i = 0; i < 5; i++)
488                         if (check_locality(chip, i) >= 0)
489                                 break;
490         if (interrupt &
491             (TPM_INTF_LOCALITY_CHANGE_INT | TPM_INTF_STS_VALID_INT |
492              TPM_INTF_CMD_READY_INT))
493                 wake_up_interruptible(&chip->vendor.int_queue);
494
495         /* Clear interrupts handled with TPM_EOI */
496         iowrite32(interrupt,
497                   chip->vendor.iobase +
498                   TPM_INT_STATUS(chip->vendor.locality));
499         ioread32(chip->vendor.iobase + TPM_INT_STATUS(chip->vendor.locality));
500         return IRQ_HANDLED;
501 }
502
503 static int interrupts = 1;
504 module_param(interrupts, bool, 0444);
505 MODULE_PARM_DESC(interrupts, "Enable interrupts");
506
507 static int tpm_tis_init(struct device *dev, resource_size_t start,
508                         resource_size_t len, unsigned int irq)
509 {
510         u32 vendor, intfcaps, intmask;
511         int rc, i, irq_s, irq_e;
512         struct tpm_chip *chip;
513
514         if (!(chip = tpm_register_hardware(dev, &tpm_tis)))
515                 return -ENODEV;
516
517         chip->vendor.iobase = ioremap(start, len);
518         if (!chip->vendor.iobase) {
519                 rc = -EIO;
520                 goto out_err;
521         }
522
523         /* Default timeouts */
524         chip->vendor.timeout_a = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
525         chip->vendor.timeout_b = msecs_to_jiffies(TIS_LONG_TIMEOUT);
526         chip->vendor.timeout_c = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
527         chip->vendor.timeout_d = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
528
529         if (request_locality(chip, 0) != 0) {
530                 rc = -ENODEV;
531                 goto out_err;
532         }
533
534         vendor = ioread32(chip->vendor.iobase + TPM_DID_VID(0));
535
536         dev_info(dev,
537                  "1.2 TPM (device-id 0x%X, rev-id %d)\n",
538                  vendor >> 16, ioread8(chip->vendor.iobase + TPM_RID(0)));
539
540         if (!itpm) {
541                 itpm = probe_itpm(chip);
542                 if (itpm < 0) {
543                         rc = -ENODEV;
544                         goto out_err;
545                 }
546         }
547
548         if (itpm)
549                 dev_info(dev, "Intel iTPM workaround enabled\n");
550
551
552         /* Figure out the capabilities */
553         intfcaps =
554             ioread32(chip->vendor.iobase +
555                      TPM_INTF_CAPS(chip->vendor.locality));
556         dev_dbg(dev, "TPM interface capabilities (0x%x):\n",
557                 intfcaps);
558         if (intfcaps & TPM_INTF_BURST_COUNT_STATIC)
559                 dev_dbg(dev, "\tBurst Count Static\n");
560         if (intfcaps & TPM_INTF_CMD_READY_INT)
561                 dev_dbg(dev, "\tCommand Ready Int Support\n");
562         if (intfcaps & TPM_INTF_INT_EDGE_FALLING)
563                 dev_dbg(dev, "\tInterrupt Edge Falling\n");
564         if (intfcaps & TPM_INTF_INT_EDGE_RISING)
565                 dev_dbg(dev, "\tInterrupt Edge Rising\n");
566         if (intfcaps & TPM_INTF_INT_LEVEL_LOW)
567                 dev_dbg(dev, "\tInterrupt Level Low\n");
568         if (intfcaps & TPM_INTF_INT_LEVEL_HIGH)
569                 dev_dbg(dev, "\tInterrupt Level High\n");
570         if (intfcaps & TPM_INTF_LOCALITY_CHANGE_INT)
571                 dev_dbg(dev, "\tLocality Change Int Support\n");
572         if (intfcaps & TPM_INTF_STS_VALID_INT)
573                 dev_dbg(dev, "\tSts Valid Int Support\n");
574         if (intfcaps & TPM_INTF_DATA_AVAIL_INT)
575                 dev_dbg(dev, "\tData Avail Int Support\n");
576
577         /* get the timeouts before testing for irqs */
578         if (tpm_get_timeouts(chip)) {
579                 dev_err(dev, "Could not get TPM timeouts and durations\n");
580                 rc = -ENODEV;
581                 goto out_err;
582         }
583
584         if (tpm_do_selftest(chip)) {
585                 dev_err(dev, "TPM self test failed\n");
586                 rc = -ENODEV;
587                 goto out_err;
588         }
589
590         /* INTERRUPT Setup */
591         init_waitqueue_head(&chip->vendor.read_queue);
592         init_waitqueue_head(&chip->vendor.int_queue);
593
594         intmask =
595             ioread32(chip->vendor.iobase +
596                      TPM_INT_ENABLE(chip->vendor.locality));
597
598         intmask |= TPM_INTF_CMD_READY_INT
599             | TPM_INTF_LOCALITY_CHANGE_INT | TPM_INTF_DATA_AVAIL_INT
600             | TPM_INTF_STS_VALID_INT;
601
602         iowrite32(intmask,
603                   chip->vendor.iobase +
604                   TPM_INT_ENABLE(chip->vendor.locality));
605         if (interrupts)
606                 chip->vendor.irq = irq;
607         if (interrupts && !chip->vendor.irq) {
608                 irq_s =
609                     ioread8(chip->vendor.iobase +
610                             TPM_INT_VECTOR(chip->vendor.locality));
611                 if (irq_s) {
612                         irq_e = irq_s;
613                 } else {
614                         irq_s = 3;
615                         irq_e = 15;
616                 }
617
618                 for (i = irq_s; i <= irq_e && chip->vendor.irq == 0; i++) {
619                         iowrite8(i, chip->vendor.iobase +
620                                  TPM_INT_VECTOR(chip->vendor.locality));
621                         if (request_irq
622                             (i, tis_int_probe, IRQF_SHARED,
623                              chip->vendor.miscdev.name, chip) != 0) {
624                                 dev_info(chip->dev,
625                                          "Unable to request irq: %d for probe\n",
626                                          i);
627                                 continue;
628                         }
629
630                         /* Clear all existing */
631                         iowrite32(ioread32
632                                   (chip->vendor.iobase +
633                                    TPM_INT_STATUS(chip->vendor.locality)),
634                                   chip->vendor.iobase +
635                                   TPM_INT_STATUS(chip->vendor.locality));
636
637                         /* Turn on */
638                         iowrite32(intmask | TPM_GLOBAL_INT_ENABLE,
639                                   chip->vendor.iobase +
640                                   TPM_INT_ENABLE(chip->vendor.locality));
641
642                         chip->vendor.probed_irq = 0;
643
644                         /* Generate Interrupts */
645                         tpm_gen_interrupt(chip);
646
647                         chip->vendor.irq = chip->vendor.probed_irq;
648
649                         /* free_irq will call into tis_int_probe;
650                            clear all irqs we haven't seen while doing
651                            tpm_gen_interrupt */
652                         iowrite32(ioread32
653                                   (chip->vendor.iobase +
654                                    TPM_INT_STATUS(chip->vendor.locality)),
655                                   chip->vendor.iobase +
656                                   TPM_INT_STATUS(chip->vendor.locality));
657
658                         /* Turn off */
659                         iowrite32(intmask,
660                                   chip->vendor.iobase +
661                                   TPM_INT_ENABLE(chip->vendor.locality));
662                         free_irq(i, chip);
663                 }
664         }
665         if (chip->vendor.irq) {
666                 iowrite8(chip->vendor.irq,
667                          chip->vendor.iobase +
668                          TPM_INT_VECTOR(chip->vendor.locality));
669                 if (request_irq
670                     (chip->vendor.irq, tis_int_handler, IRQF_SHARED,
671                      chip->vendor.miscdev.name, chip) != 0) {
672                         dev_info(chip->dev,
673                                  "Unable to request irq: %d for use\n",
674                                  chip->vendor.irq);
675                         chip->vendor.irq = 0;
676                 } else {
677                         /* Clear all existing */
678                         iowrite32(ioread32
679                                   (chip->vendor.iobase +
680                                    TPM_INT_STATUS(chip->vendor.locality)),
681                                   chip->vendor.iobase +
682                                   TPM_INT_STATUS(chip->vendor.locality));
683
684                         /* Turn on */
685                         iowrite32(intmask | TPM_GLOBAL_INT_ENABLE,
686                                   chip->vendor.iobase +
687                                   TPM_INT_ENABLE(chip->vendor.locality));
688                 }
689         }
690
691         INIT_LIST_HEAD(&chip->vendor.list);
692         spin_lock(&tis_lock);
693         list_add(&chip->vendor.list, &tis_chips);
694         spin_unlock(&tis_lock);
695
696
697         return 0;
698 out_err:
699         if (chip->vendor.iobase)
700                 iounmap(chip->vendor.iobase);
701         tpm_remove_hardware(chip->dev);
702         return rc;
703 }
704
705 static void tpm_tis_reenable_interrupts(struct tpm_chip *chip)
706 {
707         u32 intmask;
708
709         /* reenable interrupts that device may have lost or
710            BIOS/firmware may have disabled */
711         iowrite8(chip->vendor.irq, chip->vendor.iobase +
712                  TPM_INT_VECTOR(chip->vendor.locality));
713
714         intmask =
715             ioread32(chip->vendor.iobase +
716                      TPM_INT_ENABLE(chip->vendor.locality));
717
718         intmask |= TPM_INTF_CMD_READY_INT
719             | TPM_INTF_LOCALITY_CHANGE_INT | TPM_INTF_DATA_AVAIL_INT
720             | TPM_INTF_STS_VALID_INT | TPM_GLOBAL_INT_ENABLE;
721
722         iowrite32(intmask,
723                   chip->vendor.iobase + TPM_INT_ENABLE(chip->vendor.locality));
724 }
725
726
727 #ifdef CONFIG_PNP
728 static int __devinit tpm_tis_pnp_init(struct pnp_dev *pnp_dev,
729                                       const struct pnp_device_id *pnp_id)
730 {
731         resource_size_t start, len;
732         unsigned int irq = 0;
733
734         start = pnp_mem_start(pnp_dev, 0);
735         len = pnp_mem_len(pnp_dev, 0);
736
737         if (pnp_irq_valid(pnp_dev, 0))
738                 irq = pnp_irq(pnp_dev, 0);
739         else
740                 interrupts = 0;
741
742         if (is_itpm(pnp_dev))
743                 itpm = 1;
744
745         return tpm_tis_init(&pnp_dev->dev, start, len, irq);
746 }
747
748 static int tpm_tis_pnp_suspend(struct pnp_dev *dev, pm_message_t msg)
749 {
750         return tpm_pm_suspend(&dev->dev, msg);
751 }
752
753 static int tpm_tis_pnp_resume(struct pnp_dev *dev)
754 {
755         struct tpm_chip *chip = pnp_get_drvdata(dev);
756         int ret;
757
758         if (chip->vendor.irq)
759                 tpm_tis_reenable_interrupts(chip);
760
761         ret = tpm_pm_resume(&dev->dev);
762         if (!ret)
763                 tpm_do_selftest(chip);
764
765         return ret;
766 }
767
768 static struct pnp_device_id tpm_pnp_tbl[] __devinitdata = {
769         {"PNP0C31", 0},         /* TPM */
770         {"ATM1200", 0},         /* Atmel */
771         {"IFX0102", 0},         /* Infineon */
772         {"BCM0101", 0},         /* Broadcom */
773         {"BCM0102", 0},         /* Broadcom */
774         {"NSC1200", 0},         /* National */
775         {"ICO0102", 0},         /* Intel */
776         /* Add new here */
777         {"", 0},                /* User Specified */
778         {"", 0}                 /* Terminator */
779 };
780 MODULE_DEVICE_TABLE(pnp, tpm_pnp_tbl);
781
782 static __devexit void tpm_tis_pnp_remove(struct pnp_dev *dev)
783 {
784         struct tpm_chip *chip = pnp_get_drvdata(dev);
785
786         tpm_dev_vendor_release(chip);
787
788         kfree(chip);
789 }
790
791
792 static struct pnp_driver tis_pnp_driver = {
793         .name = "tpm_tis",
794         .id_table = tpm_pnp_tbl,
795         .probe = tpm_tis_pnp_init,
796         .suspend = tpm_tis_pnp_suspend,
797         .resume = tpm_tis_pnp_resume,
798         .remove = tpm_tis_pnp_remove,
799 };
800
801 #define TIS_HID_USR_IDX sizeof(tpm_pnp_tbl)/sizeof(struct pnp_device_id) -2
802 module_param_string(hid, tpm_pnp_tbl[TIS_HID_USR_IDX].id,
803                     sizeof(tpm_pnp_tbl[TIS_HID_USR_IDX].id), 0444);
804 MODULE_PARM_DESC(hid, "Set additional specific HID for this driver to probe");
805 #endif
806 static int tpm_tis_suspend(struct platform_device *dev, pm_message_t msg)
807 {
808         return tpm_pm_suspend(&dev->dev, msg);
809 }
810
811 static int tpm_tis_resume(struct platform_device *dev)
812 {
813         struct tpm_chip *chip = dev_get_drvdata(&dev->dev);
814
815         if (chip->vendor.irq)
816                 tpm_tis_reenable_interrupts(chip);
817
818         return tpm_pm_resume(&dev->dev);
819 }
820 static struct platform_driver tis_drv = {
821         .driver = {
822                 .name = "tpm_tis",
823                 .owner          = THIS_MODULE,
824         },
825         .suspend = tpm_tis_suspend,
826         .resume = tpm_tis_resume,
827 };
828
829 static struct platform_device *pdev;
830
831 static int force;
832 module_param(force, bool, 0444);
833 MODULE_PARM_DESC(force, "Force device probe rather than using ACPI entry");
834 static int __init init_tis(void)
835 {
836         int rc;
837 #ifdef CONFIG_PNP
838         if (!force)
839                 return pnp_register_driver(&tis_pnp_driver);
840 #endif
841
842         rc = platform_driver_register(&tis_drv);
843         if (rc < 0)
844                 return rc;
845         if (IS_ERR(pdev=platform_device_register_simple("tpm_tis", -1, NULL, 0)))
846                 return PTR_ERR(pdev);
847         if((rc=tpm_tis_init(&pdev->dev, TIS_MEM_BASE, TIS_MEM_LEN, 0)) != 0) {
848                 platform_device_unregister(pdev);
849                 platform_driver_unregister(&tis_drv);
850         }
851         return rc;
852 }
853
854 static void __exit cleanup_tis(void)
855 {
856         struct tpm_vendor_specific *i, *j;
857         struct tpm_chip *chip;
858         spin_lock(&tis_lock);
859         list_for_each_entry_safe(i, j, &tis_chips, list) {
860                 chip = to_tpm_chip(i);
861                 tpm_remove_hardware(chip->dev);
862                 iowrite32(~TPM_GLOBAL_INT_ENABLE &
863                           ioread32(chip->vendor.iobase +
864                                    TPM_INT_ENABLE(chip->vendor.
865                                                   locality)),
866                           chip->vendor.iobase +
867                           TPM_INT_ENABLE(chip->vendor.locality));
868                 release_locality(chip, chip->vendor.locality, 1);
869                 if (chip->vendor.irq)
870                         free_irq(chip->vendor.irq, chip);
871                 iounmap(i->iobase);
872                 list_del(&i->list);
873         }
874         spin_unlock(&tis_lock);
875 #ifdef CONFIG_PNP
876         if (!force) {
877                 pnp_unregister_driver(&tis_pnp_driver);
878                 return;
879         }
880 #endif
881         platform_device_unregister(pdev);
882         platform_driver_unregister(&tis_drv);
883 }
884
885 module_init(init_tis);
886 module_exit(cleanup_tis);
887 MODULE_AUTHOR("Leendert van Doorn (leendert@watson.ibm.com)");
888 MODULE_DESCRIPTION("TPM Driver");
889 MODULE_VERSION("2.0");
890 MODULE_LICENSE("GPL");