1 /* 2 * Copyright (C) 2004 IBM Corporation 3 * 4 * Authors: 5 * Leendert van Doorn <leendert@watson.ibm.com> 6 * Dave Safford <safford@watson.ibm.com> 7 * Reiner Sailer <sailer@watson.ibm.com> 8 * Kylene Hall <kjhall@us.ibm.com> 9 * 10 * Maintained by: <tpmdd-devel@lists.sourceforge.net> 11 * 12 * Device driver for TCG/TCPA TPM (trusted platform module). 13 * Specifications at www.trustedcomputinggroup.org 14 * 15 * This program is free software; you can redistribute it and/or 16 * modify it under the terms of the GNU General Public License as 17 * published by the Free Software Foundation, version 2 of the 18 * License. 19 * 20 */ 21 22 #include "tpm.h" 23 #include "tpm_atmel.h" 24 25 /* write status bits */ 26 enum tpm_atmel_write_status { 27 ATML_STATUS_ABORT = 0x01, 28 ATML_STATUS_LASTBYTE = 0x04 29 }; 30 /* read status bits */ 31 enum tpm_atmel_read_status { 32 ATML_STATUS_BUSY = 0x01, 33 ATML_STATUS_DATA_AVAIL = 0x02, 34 ATML_STATUS_REWRITE = 0x04, 35 ATML_STATUS_READY = 0x08 36 }; 37 38 static int tpm_atml_recv(struct tpm_chip *chip, u8 *buf, size_t count) 39 { 40 struct tpm_atmel_priv *priv = dev_get_drvdata(&chip->dev); 41 u8 status, *hdr = buf; 42 u32 size; 43 int i; 44 __be32 *native_size; 45 46 /* start reading header */ 47 if (count < 6) 48 return -EIO; 49 50 for (i = 0; i < 6; i++) { 51 status = ioread8(priv->iobase + 1); 52 if ((status & ATML_STATUS_DATA_AVAIL) == 0) { 53 dev_err(&chip->dev, "error reading header\n"); 54 return -EIO; 55 } 56 *buf++ = ioread8(priv->iobase); 57 } 58 59 /* size of the data received */ 60 native_size = (__force __be32 *) (hdr + 2); 61 size = be32_to_cpu(*native_size); 62 63 if (count < size) { 64 dev_err(&chip->dev, 65 "Recv size(%d) less than available space\n", size); 66 for (; i < size; i++) { /* clear the waiting data anyway */ 67 status = ioread8(priv->iobase + 1); 68 if ((status & ATML_STATUS_DATA_AVAIL) == 0) { 69 dev_err(&chip->dev, "error reading data\n"); 70 return -EIO; 71 } 72 } 73 return -EIO; 74 } 75 76 /* read all the data available */ 77 for (; i < size; i++) { 78 status = ioread8(priv->iobase + 1); 79 if ((status & ATML_STATUS_DATA_AVAIL) == 0) { 80 dev_err(&chip->dev, "error reading data\n"); 81 return -EIO; 82 } 83 *buf++ = ioread8(priv->iobase); 84 } 85 86 /* make sure data available is gone */ 87 status = ioread8(priv->iobase + 1); 88 89 if (status & ATML_STATUS_DATA_AVAIL) { 90 dev_err(&chip->dev, "data available is stuck\n"); 91 return -EIO; 92 } 93 94 return size; 95 } 96 97 static int tpm_atml_send(struct tpm_chip *chip, u8 *buf, size_t count) 98 { 99 struct tpm_atmel_priv *priv = dev_get_drvdata(&chip->dev); 100 int i; 101 102 dev_dbg(&chip->dev, "tpm_atml_send:\n"); 103 for (i = 0; i < count; i++) { 104 dev_dbg(&chip->dev, "%d 0x%x(%d)\n", i, buf[i], buf[i]); 105 iowrite8(buf[i], priv->iobase); 106 } 107 108 return count; 109 } 110 111 static void tpm_atml_cancel(struct tpm_chip *chip) 112 { 113 struct tpm_atmel_priv *priv = dev_get_drvdata(&chip->dev); 114 115 iowrite8(ATML_STATUS_ABORT, priv->iobase + 1); 116 } 117 118 static u8 tpm_atml_status(struct tpm_chip *chip) 119 { 120 struct tpm_atmel_priv *priv = dev_get_drvdata(&chip->dev); 121 122 return ioread8(priv->iobase + 1); 123 } 124 125 static bool tpm_atml_req_canceled(struct tpm_chip *chip, u8 status) 126 { 127 return (status == ATML_STATUS_READY); 128 } 129 130 static const struct tpm_class_ops tpm_atmel = { 131 .recv = tpm_atml_recv, 132 .send = tpm_atml_send, 133 .cancel = tpm_atml_cancel, 134 .status = tpm_atml_status, 135 .req_complete_mask = ATML_STATUS_BUSY | ATML_STATUS_DATA_AVAIL, 136 .req_complete_val = ATML_STATUS_DATA_AVAIL, 137 .req_canceled = tpm_atml_req_canceled, 138 }; 139 140 static struct platform_device *pdev; 141 142 static void atml_plat_remove(void) 143 { 144 struct tpm_chip *chip = dev_get_drvdata(&pdev->dev); 145 struct tpm_atmel_priv *priv = dev_get_drvdata(&chip->dev); 146 147 if (chip) { 148 tpm_chip_unregister(chip); 149 if (priv->have_region) 150 atmel_release_region(priv->base, priv->region_size); 151 atmel_put_base_addr(priv->iobase); 152 platform_device_unregister(pdev); 153 } 154 } 155 156 static SIMPLE_DEV_PM_OPS(tpm_atml_pm, tpm_pm_suspend, tpm_pm_resume); 157 158 static struct platform_driver atml_drv = { 159 .driver = { 160 .name = "tpm_atmel", 161 .pm = &tpm_atml_pm, 162 }, 163 }; 164 165 static int __init init_atmel(void) 166 { 167 int rc = 0; 168 void __iomem *iobase = NULL; 169 int have_region, region_size; 170 unsigned long base; 171 struct tpm_chip *chip; 172 struct tpm_atmel_priv *priv; 173 174 rc = platform_driver_register(&atml_drv); 175 if (rc) 176 return rc; 177 178 if ((iobase = atmel_get_base_addr(&base, ®ion_size)) == NULL) { 179 rc = -ENODEV; 180 goto err_unreg_drv; 181 } 182 183 have_region = 184 (atmel_request_region 185 (base, region_size, "tpm_atmel0") == NULL) ? 0 : 1; 186 187 pdev = platform_device_register_simple("tpm_atmel", -1, NULL, 0); 188 if (IS_ERR(pdev)) { 189 rc = PTR_ERR(pdev); 190 goto err_rel_reg; 191 } 192 193 priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL); 194 if (!priv) { 195 rc = -ENOMEM; 196 goto err_unreg_dev; 197 } 198 199 priv->iobase = iobase; 200 priv->base = base; 201 priv->have_region = have_region; 202 priv->region_size = region_size; 203 204 chip = tpmm_chip_alloc(&pdev->dev, &tpm_atmel); 205 if (IS_ERR(chip)) { 206 rc = PTR_ERR(chip); 207 goto err_unreg_dev; 208 } 209 210 dev_set_drvdata(&chip->dev, priv); 211 212 rc = tpm_chip_register(chip); 213 if (rc) 214 goto err_unreg_dev; 215 216 return 0; 217 218 err_unreg_dev: 219 platform_device_unregister(pdev); 220 err_rel_reg: 221 atmel_put_base_addr(iobase); 222 if (have_region) 223 atmel_release_region(base, 224 region_size); 225 err_unreg_drv: 226 platform_driver_unregister(&atml_drv); 227 return rc; 228 } 229 230 static void __exit cleanup_atmel(void) 231 { 232 platform_driver_unregister(&atml_drv); 233 atml_plat_remove(); 234 } 235 236 module_init(init_atmel); 237 module_exit(cleanup_atmel); 238 239 MODULE_AUTHOR("Leendert van Doorn (leendert@watson.ibm.com)"); 240 MODULE_DESCRIPTION("TPM Driver"); 241 MODULE_VERSION("2.0"); 242 MODULE_LICENSE("GPL"); 243