tpm_i2c_infineon.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * Copyright (C) 2012,2013 Infineon Technologies
  4 *
  5 * Authors:
  6 * Peter Huewe <peter.huewe@infineon.com>
  7 *
  8 * Device driver for TCG/TCPA TPM (trusted platform module).
  9 * Specifications at www.trustedcomputinggroup.org
 10 *
 11 * This device driver implements the TPM interface as defined in
 12 * the TCG TPM Interface Spec version 1.2, revision 1.0 and the
 13 * Infineon I2C Protocol Stack Specification v0.20.
 14 *
 15 * It is based on the original tpm_tis device driver from Leendert van
 16 * Dorn and Kyleen Hall.
 17 */
 18#include <linux/i2c.h>
 19#include <linux/module.h>
 20#include <linux/wait.h>
 21#include "tpm.h"
 22
 23#define TPM_I2C_INFINEON_BUFSIZE 1260
 24
 25/* max. number of iterations after I2C NAK */
 26#define MAX_COUNT 3
 27
 28#define SLEEP_DURATION_LOW 55
 29#define SLEEP_DURATION_HI 65
 30
 31/* max. number of iterations after I2C NAK for 'long' commands
 32 * we need this especially for sending TPM_READY, since the cleanup after the
 33 * transtion to the ready state may take some time, but it is unpredictable
 34 * how long it will take.
 35 */
 36#define MAX_COUNT_LONG 50
 37
 38#define SLEEP_DURATION_LONG_LOW 200
 39#define SLEEP_DURATION_LONG_HI 220
 40
 41/* After sending TPM_READY to 'reset' the TPM we have to sleep even longer */
 42#define SLEEP_DURATION_RESET_LOW 2400
 43#define SLEEP_DURATION_RESET_HI 2600
 44
 45/* we want to use usleep_range instead of msleep for the 5ms TPM_TIMEOUT */
 46#define TPM_TIMEOUT_US_LOW (TPM_TIMEOUT * 1000)
 47#define TPM_TIMEOUT_US_HI  (TPM_TIMEOUT_US_LOW + 2000)
 48
 49/* expected value for DIDVID register */
 50#define TPM_TIS_I2C_DID_VID_9635 0xd1150b00L
 51#define TPM_TIS_I2C_DID_VID_9645 0x001a15d1L
 52
 53enum i2c_chip_type {
 54	SLB9635,
 55	SLB9645,
 56	UNKNOWN,
 57};
 58
 59struct tpm_inf_dev {
 60	struct i2c_client *client;
 61	int locality;
 62	/* In addition to the data itself, the buffer must fit the 7-bit I2C
 63	 * address and the direction bit.
 64	 */
 65	u8 buf[TPM_I2C_INFINEON_BUFSIZE + 1];
 66	struct tpm_chip *chip;
 67	enum i2c_chip_type chip_type;
 68	unsigned int adapterlimit;
 69};
 70
 71static struct tpm_inf_dev tpm_dev;
 72
 73/*
 74 * iic_tpm_read() - read from TPM register
 75 * @addr: register address to read from
 76 * @buffer: provided by caller
 77 * @len: number of bytes to read
 78 *
 79 * Read len bytes from TPM register and put them into
 80 * buffer (little-endian format, i.e. first byte is put into buffer[0]).
 81 *
 82 * NOTE: TPM is big-endian for multi-byte values. Multi-byte
 83 * values have to be swapped.
 84 *
 85 * NOTE: We can't unfortunately use the combined read/write functions
 86 * provided by the i2c core as the TPM currently does not support the
 87 * repeated start condition and due to it's special requirements.
 88 * The i2c_smbus* functions do not work for this chip.
 89 *
 90 * Return -EIO on error, 0 on success.
 91 */
 92static int iic_tpm_read(u8 addr, u8 *buffer, size_t len)
 93{
 94
 95	struct i2c_msg msg1 = {
 96		.addr = tpm_dev.client->addr,
 97		.len = 1,
 98		.buf = &addr
 99	};
100	struct i2c_msg msg2 = {
101		.addr = tpm_dev.client->addr,
102		.flags = I2C_M_RD,
103		.len = len,
104		.buf = buffer
105	};
106	struct i2c_msg msgs[] = {msg1, msg2};
107
108	int rc = 0;
109	int count;
110	unsigned int msglen = len;
111
112	/* Lock the adapter for the duration of the whole sequence. */
113	if (!tpm_dev.client->adapter->algo->master_xfer)
114		return -EOPNOTSUPP;
115	i2c_lock_bus(tpm_dev.client->adapter, I2C_LOCK_SEGMENT);
116
117	if (tpm_dev.chip_type == SLB9645) {
118		/* use a combined read for newer chips
119		 * unfortunately the smbus functions are not suitable due to
120		 * the 32 byte limit of the smbus.
121		 * retries should usually not be needed, but are kept just to
122		 * be on the safe side.
123		 */
124		for (count = 0; count < MAX_COUNT; count++) {
125			rc = __i2c_transfer(tpm_dev.client->adapter, msgs, 2);
126			if (rc > 0)
127				break;	/* break here to skip sleep */
128			usleep_range(SLEEP_DURATION_LOW, SLEEP_DURATION_HI);
129		}
130	} else {
131		/* Expect to send one command message and one data message, but
132		 * support looping over each or both if necessary.
133		 */
134		while (len > 0) {
135			/* slb9635 protocol should work in all cases */
136			for (count = 0; count < MAX_COUNT; count++) {
137				rc = __i2c_transfer(tpm_dev.client->adapter,
138						    &msg1, 1);
139				if (rc > 0)
140					break;	/* break here to skip sleep */
141
142				usleep_range(SLEEP_DURATION_LOW,
143					     SLEEP_DURATION_HI);
144			}
145
146			if (rc <= 0)
147				goto out;
148
149			/* After the TPM has successfully received the register
150			 * address it needs some time, thus we're sleeping here
151			 * again, before retrieving the data
152			 */
153			for (count = 0; count < MAX_COUNT; count++) {
154				if (tpm_dev.adapterlimit) {
155					msglen = min_t(unsigned int,
156						       tpm_dev.adapterlimit,
157						       len);
158					msg2.len = msglen;
159				}
160				usleep_range(SLEEP_DURATION_LOW,
161					     SLEEP_DURATION_HI);
162				rc = __i2c_transfer(tpm_dev.client->adapter,
163						    &msg2, 1);
164				if (rc > 0) {
165					/* Since len is unsigned, make doubly
166					 * sure we do not underflow it.
167					 */
168					if (msglen > len)
169						len = 0;
170					else
171						len -= msglen;
172					msg2.buf += msglen;
173					break;
174				}
175				/* If the I2C adapter rejected the request (e.g
176				 * when the quirk read_max_len < len) fall back
177				 * to a sane minimum value and try again.
178				 */
179				if (rc == -EOPNOTSUPP)
180					tpm_dev.adapterlimit =
181							I2C_SMBUS_BLOCK_MAX;
182			}
183
184			if (rc <= 0)
185				goto out;
186		}
187	}
188
189out:
190	i2c_unlock_bus(tpm_dev.client->adapter, I2C_LOCK_SEGMENT);
191	/* take care of 'guard time' */
192	usleep_range(SLEEP_DURATION_LOW, SLEEP_DURATION_HI);
193
194	/* __i2c_transfer returns the number of successfully transferred
195	 * messages.
196	 * So rc should be greater than 0 here otherwise we have an error.
197	 */
198	if (rc <= 0)
199		return -EIO;
200
201	return 0;
202}
203
204static int iic_tpm_write_generic(u8 addr, u8 *buffer, size_t len,
205				 unsigned int sleep_low,
206				 unsigned int sleep_hi, u8 max_count)
207{
208	int rc = -EIO;
209	int count;
210
211	struct i2c_msg msg1 = {
212		.addr = tpm_dev.client->addr,
213		.len = len + 1,
214		.buf = tpm_dev.buf
215	};
216
217	if (len > TPM_I2C_INFINEON_BUFSIZE)
218		return -EINVAL;
219
220	if (!tpm_dev.client->adapter->algo->master_xfer)
221		return -EOPNOTSUPP;
222	i2c_lock_bus(tpm_dev.client->adapter, I2C_LOCK_SEGMENT);
223
224	/* prepend the 'register address' to the buffer */
225	tpm_dev.buf[0] = addr;
226	memcpy(&(tpm_dev.buf[1]), buffer, len);
227
228	/*
229	 * NOTE: We have to use these special mechanisms here and unfortunately
230	 * cannot rely on the standard behavior of i2c_transfer.
231	 * Even for newer chips the smbus functions are not
232	 * suitable due to the 32 byte limit of the smbus.
233	 */
234	for (count = 0; count < max_count; count++) {
235		rc = __i2c_transfer(tpm_dev.client->adapter, &msg1, 1);
236		if (rc > 0)
237			break;
238		usleep_range(sleep_low, sleep_hi);
239	}
240
241	i2c_unlock_bus(tpm_dev.client->adapter, I2C_LOCK_SEGMENT);
242	/* take care of 'guard time' */
243	usleep_range(SLEEP_DURATION_LOW, SLEEP_DURATION_HI);
244
245	/* __i2c_transfer returns the number of successfully transferred
246	 * messages.
247	 * So rc should be greater than 0 here otherwise we have an error.
248	 */
249	if (rc <= 0)
250		return -EIO;
251
252	return 0;
253}
254
255/*
256 * iic_tpm_write() - write to TPM register
257 * @addr: register address to write to
258 * @buffer: containing data to be written
259 * @len: number of bytes to write
260 *
261 * Write len bytes from provided buffer to TPM register (little
262 * endian format, i.e. buffer[0] is written as first byte).
263 *
264 * NOTE: TPM is big-endian for multi-byte values. Multi-byte
265 * values have to be swapped.
266 *
267 * NOTE: use this function instead of the iic_tpm_write_generic function.
268 *
269 * Return -EIO on error, 0 on success
270 */
271static int iic_tpm_write(u8 addr, u8 *buffer, size_t len)
272{
273	return iic_tpm_write_generic(addr, buffer, len, SLEEP_DURATION_LOW,
274				     SLEEP_DURATION_HI, MAX_COUNT);
275}
276
277/*
278 * This function is needed especially for the cleanup situation after
279 * sending TPM_READY
280 * */
281static int iic_tpm_write_long(u8 addr, u8 *buffer, size_t len)
282{
283	return iic_tpm_write_generic(addr, buffer, len, SLEEP_DURATION_LONG_LOW,
284				     SLEEP_DURATION_LONG_HI, MAX_COUNT_LONG);
285}
286
287enum tis_access {
288	TPM_ACCESS_VALID = 0x80,
289	TPM_ACCESS_ACTIVE_LOCALITY = 0x20,
290	TPM_ACCESS_REQUEST_PENDING = 0x04,
291	TPM_ACCESS_REQUEST_USE = 0x02,
292};
293
294enum tis_status {
295	TPM_STS_VALID = 0x80,
296	TPM_STS_COMMAND_READY = 0x40,
297	TPM_STS_GO = 0x20,
298	TPM_STS_DATA_AVAIL = 0x10,
299	TPM_STS_DATA_EXPECT = 0x08,
300};
301
302enum tis_defaults {
303	TIS_SHORT_TIMEOUT = 750,	/* ms */
304	TIS_LONG_TIMEOUT = 2000,	/* 2 sec */
305};
306
307#define	TPM_ACCESS(l)			(0x0000 | ((l) << 4))
308#define	TPM_STS(l)			(0x0001 | ((l) << 4))
309#define	TPM_DATA_FIFO(l)		(0x0005 | ((l) << 4))
310#define	TPM_DID_VID(l)			(0x0006 | ((l) << 4))
311
312static bool check_locality(struct tpm_chip *chip, int loc)
313{
314	u8 buf;
315	int rc;
316
317	rc = iic_tpm_read(TPM_ACCESS(loc), &buf, 1);
318	if (rc < 0)
319		return false;
320
321	if ((buf & (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID)) ==
322	    (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID)) {
323		tpm_dev.locality = loc;
324		return true;
325	}
326
327	return false;
328}
329
330/* implementation similar to tpm_tis */
331static void release_locality(struct tpm_chip *chip, int loc, int force)
332{
333	u8 buf;
334	if (iic_tpm_read(TPM_ACCESS(loc), &buf, 1) < 0)
335		return;
336
337	if (force || (buf & (TPM_ACCESS_REQUEST_PENDING | TPM_ACCESS_VALID)) ==
338	    (TPM_ACCESS_REQUEST_PENDING | TPM_ACCESS_VALID)) {
339		buf = TPM_ACCESS_ACTIVE_LOCALITY;
340		iic_tpm_write(TPM_ACCESS(loc), &buf, 1);
341	}
342}
343
344static int request_locality(struct tpm_chip *chip, int loc)
345{
346	unsigned long stop;
347	u8 buf = TPM_ACCESS_REQUEST_USE;
348
349	if (check_locality(chip, loc))
350		return loc;
351
352	iic_tpm_write(TPM_ACCESS(loc), &buf, 1);
353
354	/* wait for burstcount */
355	stop = jiffies + chip->timeout_a;
356	do {
357		if (check_locality(chip, loc))
358			return loc;
359		usleep_range(TPM_TIMEOUT_US_LOW, TPM_TIMEOUT_US_HI);
360	} while (time_before(jiffies, stop));
361
362	return -ETIME;
363}
364
365static u8 tpm_tis_i2c_status(struct tpm_chip *chip)
366{
367	/* NOTE: since I2C read may fail, return 0 in this case --> time-out */
368	u8 buf = 0xFF;
369	u8 i = 0;
370
371	do {
372		if (iic_tpm_read(TPM_STS(tpm_dev.locality), &buf, 1) < 0)
373			return 0;
374
375		i++;
376	/* if locallity is set STS should not be 0xFF */
377	} while ((buf == 0xFF) && i < 10);
378
379	return buf;
380}
381
382static void tpm_tis_i2c_ready(struct tpm_chip *chip)
383{
384	/* this causes the current command to be aborted */
385	u8 buf = TPM_STS_COMMAND_READY;
386	iic_tpm_write_long(TPM_STS(tpm_dev.locality), &buf, 1);
387}
388
389static ssize_t get_burstcount(struct tpm_chip *chip)
390{
391	unsigned long stop;
392	ssize_t burstcnt;
393	u8 buf[3];
394
395	/* wait for burstcount */
396	/* which timeout value, spec has 2 answers (c & d) */
397	stop = jiffies + chip->timeout_d;
398	do {
399		/* Note: STS is little endian */
400		if (iic_tpm_read(TPM_STS(tpm_dev.locality)+1, buf, 3) < 0)
401			burstcnt = 0;
402		else
403			burstcnt = (buf[2] << 16) + (buf[1] << 8) + buf[0];
404
405		if (burstcnt)
406			return burstcnt;
407
408		usleep_range(TPM_TIMEOUT_US_LOW, TPM_TIMEOUT_US_HI);
409	} while (time_before(jiffies, stop));
410	return -EBUSY;
411}
412
413static int wait_for_stat(struct tpm_chip *chip, u8 mask, unsigned long timeout,
414			 int *status)
415{
416	unsigned long stop;
417
418	/* check current status */
419	*status = tpm_tis_i2c_status(chip);
420	if ((*status != 0xFF) && (*status & mask) == mask)
421		return 0;
422
423	stop = jiffies + timeout;
424	do {
425		/* since we just checked the status, give the TPM some time */
426		usleep_range(TPM_TIMEOUT_US_LOW, TPM_TIMEOUT_US_HI);
427		*status = tpm_tis_i2c_status(chip);
428		if ((*status & mask) == mask)
429			return 0;
430
431	} while (time_before(jiffies, stop));
432
433	return -ETIME;
434}
435
436static int recv_data(struct tpm_chip *chip, u8 *buf, size_t count)
437{
438	size_t size = 0;
439	ssize_t burstcnt;
440	u8 retries = 0;
441	int rc;
442
443	while (size < count) {
444		burstcnt = get_burstcount(chip);
445
446		/* burstcnt < 0 = TPM is busy */
447		if (burstcnt < 0)
448			return burstcnt;
449
450		/* limit received data to max. left */
451		if (burstcnt > (count - size))
452			burstcnt = count - size;
453
454		rc = iic_tpm_read(TPM_DATA_FIFO(tpm_dev.locality),
455				  &(buf[size]), burstcnt);
456		if (rc == 0)
457			size += burstcnt;
458		else if (rc < 0)
459			retries++;
460
461		/* avoid endless loop in case of broken HW */
462		if (retries > MAX_COUNT_LONG)
463			return -EIO;
464	}
465	return size;
466}
467
468static int tpm_tis_i2c_recv(struct tpm_chip *chip, u8 *buf, size_t count)
469{
470	int size = 0;
471	int status;
472	u32 expected;
473
474	if (count < TPM_HEADER_SIZE) {
475		size = -EIO;
476		goto out;
477	}
478
479	/* read first 10 bytes, including tag, paramsize, and result */
480	size = recv_data(chip, buf, TPM_HEADER_SIZE);
481	if (size < TPM_HEADER_SIZE) {
482		dev_err(&chip->dev, "Unable to read header\n");
483		goto out;
484	}
485
486	expected = be32_to_cpu(*(__be32 *)(buf + 2));
487	if (((size_t) expected > count) || (expected < TPM_HEADER_SIZE)) {
488		size = -EIO;
489		goto out;
490	}
491
492	size += recv_data(chip, &buf[TPM_HEADER_SIZE],
493			  expected - TPM_HEADER_SIZE);
494	if (size < expected) {
495		dev_err(&chip->dev, "Unable to read remainder of result\n");
496		size = -ETIME;
497		goto out;
498	}
499
500	wait_for_stat(chip, TPM_STS_VALID, chip->timeout_c, &status);
501	if (status & TPM_STS_DATA_AVAIL) {	/* retry? */
502		dev_err(&chip->dev, "Error left over data\n");
503		size = -EIO;
504		goto out;
505	}
506
507out:
508	tpm_tis_i2c_ready(chip);
509	/* The TPM needs some time to clean up here,
510	 * so we sleep rather than keeping the bus busy
511	 */
512	usleep_range(SLEEP_DURATION_RESET_LOW, SLEEP_DURATION_RESET_HI);
513	release_locality(chip, tpm_dev.locality, 0);
514	return size;
515}
516
517static int tpm_tis_i2c_send(struct tpm_chip *chip, u8 *buf, size_t bufsiz,
518			    size_t len)
519{
520	int rc, status;
521	ssize_t burstcnt;
522	size_t count = 0;
523	u8 retries = 0;
524	u8 sts = TPM_STS_GO;
525
526	if (len > TPM_I2C_INFINEON_BUFSIZE)
527		return -E2BIG;
528
529	if (request_locality(chip, 0) < 0)
530		return -EBUSY;
531
532	status = tpm_tis_i2c_status(chip);
533	if ((status & TPM_STS_COMMAND_READY) == 0) {
534		tpm_tis_i2c_ready(chip);
535		if (wait_for_stat
536		    (chip, TPM_STS_COMMAND_READY,
537		     chip->timeout_b, &status) < 0) {
538			rc = -ETIME;
539			goto out_err;
540		}
541	}
542
543	while (count < len - 1) {
544		burstcnt = get_burstcount(chip);
545
546		/* burstcnt < 0 = TPM is busy */
547		if (burstcnt < 0) {
548			rc = burstcnt;
549			goto out_err;
550		}
551
552		if (burstcnt > (len - 1 - count))
553			burstcnt = len - 1 - count;
554
555		rc = iic_tpm_write(TPM_DATA_FIFO(tpm_dev.locality),
556				   &(buf[count]), burstcnt);
557		if (rc == 0)
558			count += burstcnt;
559		else if (rc < 0)
560			retries++;
561
562		/* avoid endless loop in case of broken HW */
563		if (retries > MAX_COUNT_LONG) {
564			rc = -EIO;
565			goto out_err;
566		}
567
568		wait_for_stat(chip, TPM_STS_VALID,
569			      chip->timeout_c, &status);
570
571		if ((status & TPM_STS_DATA_EXPECT) == 0) {
572			rc = -EIO;
573			goto out_err;
574		}
575	}
576
577	/* write last byte */
578	iic_tpm_write(TPM_DATA_FIFO(tpm_dev.locality), &(buf[count]), 1);
579	wait_for_stat(chip, TPM_STS_VALID, chip->timeout_c, &status);
580	if ((status & TPM_STS_DATA_EXPECT) != 0) {
581		rc = -EIO;
582		goto out_err;
583	}
584
585	/* go and do it */
586	iic_tpm_write(TPM_STS(tpm_dev.locality), &sts, 1);
587
588	return 0;
589out_err:
590	tpm_tis_i2c_ready(chip);
591	/* The TPM needs some time to clean up here,
592	 * so we sleep rather than keeping the bus busy
593	 */
594	usleep_range(SLEEP_DURATION_RESET_LOW, SLEEP_DURATION_RESET_HI);
595	release_locality(chip, tpm_dev.locality, 0);
596	return rc;
597}
598
599static bool tpm_tis_i2c_req_canceled(struct tpm_chip *chip, u8 status)
600{
601	return (status == TPM_STS_COMMAND_READY);
602}
603
604static const struct tpm_class_ops tpm_tis_i2c = {
605	.flags = TPM_OPS_AUTO_STARTUP,
606	.status = tpm_tis_i2c_status,
607	.recv = tpm_tis_i2c_recv,
608	.send = tpm_tis_i2c_send,
609	.cancel = tpm_tis_i2c_ready,
610	.req_complete_mask = TPM_STS_DATA_AVAIL | TPM_STS_VALID,
611	.req_complete_val = TPM_STS_DATA_AVAIL | TPM_STS_VALID,
612	.req_canceled = tpm_tis_i2c_req_canceled,
613};
614
615static int tpm_tis_i2c_init(struct device *dev)
616{
617	u32 vendor;
618	int rc = 0;
619	struct tpm_chip *chip;
620
621	chip = tpmm_chip_alloc(dev, &tpm_tis_i2c);
622	if (IS_ERR(chip))
623		return PTR_ERR(chip);
624
625	/* Default timeouts */
626	chip->timeout_a = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
627	chip->timeout_b = msecs_to_jiffies(TIS_LONG_TIMEOUT);
628	chip->timeout_c = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
629	chip->timeout_d = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
630
631	if (request_locality(chip, 0) != 0) {
632		dev_err(dev, "could not request locality\n");
633		rc = -ENODEV;
634		goto out_err;
635	}
636
637	/* read four bytes from DID_VID register */
638	if (iic_tpm_read(TPM_DID_VID(0), (u8 *)&vendor, 4) < 0) {
639		dev_err(dev, "could not read vendor id\n");
640		rc = -EIO;
641		goto out_release;
642	}
643
644	if (vendor == TPM_TIS_I2C_DID_VID_9645) {
645		tpm_dev.chip_type = SLB9645;
646	} else if (vendor == TPM_TIS_I2C_DID_VID_9635) {
647		tpm_dev.chip_type = SLB9635;
648	} else {
649		dev_err(dev, "vendor id did not match! ID was %08x\n", vendor);
650		rc = -ENODEV;
651		goto out_release;
652	}
653
654	dev_info(dev, "1.2 TPM (device-id 0x%X)\n", vendor >> 16);
655
656	tpm_dev.chip = chip;
657
658	return tpm_chip_register(chip);
659out_release:
660	release_locality(chip, tpm_dev.locality, 1);
661	tpm_dev.client = NULL;
662out_err:
663	return rc;
664}
665
666static const struct i2c_device_id tpm_tis_i2c_table[] = {
667	{"tpm_i2c_infineon"},
668	{"slb9635tt"},
669	{"slb9645tt"},
670	{},
671};
672
673MODULE_DEVICE_TABLE(i2c, tpm_tis_i2c_table);
674
675#ifdef CONFIG_OF
676static const struct of_device_id tpm_tis_i2c_of_match[] = {
677	{.compatible = "infineon,tpm_i2c_infineon"},
678	{.compatible = "infineon,slb9635tt"},
679	{.compatible = "infineon,slb9645tt"},
680	{},
681};
682MODULE_DEVICE_TABLE(of, tpm_tis_i2c_of_match);
683#endif
684
685static SIMPLE_DEV_PM_OPS(tpm_tis_i2c_ops, tpm_pm_suspend, tpm_pm_resume);
686
687static int tpm_tis_i2c_probe(struct i2c_client *client)
688{
689	int rc;
690	struct device *dev = &(client->dev);
691
692	if (tpm_dev.client != NULL) {
693		dev_err(dev, "This driver only supports one client at a time\n");
694		return -EBUSY;	/* We only support one client */
695	}
696
697	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
698		dev_err(dev, "no algorithms associated to the i2c bus\n");
699		return -ENODEV;
700	}
701
702	tpm_dev.client = client;
703	rc = tpm_tis_i2c_init(&client->dev);
704	if (rc != 0) {
705		tpm_dev.client = NULL;
706		rc = -ENODEV;
707	}
708	return rc;
709}
710
711static void tpm_tis_i2c_remove(struct i2c_client *client)
712{
713	struct tpm_chip *chip = tpm_dev.chip;
714
715	tpm_chip_unregister(chip);
716	release_locality(chip, tpm_dev.locality, 1);
717	tpm_dev.client = NULL;
718}
719
720static struct i2c_driver tpm_tis_i2c_driver = {
721	.id_table = tpm_tis_i2c_table,
722	.probe = tpm_tis_i2c_probe,
723	.remove = tpm_tis_i2c_remove,
724	.driver = {
725		   .name = "tpm_i2c_infineon",
726		   .pm = &tpm_tis_i2c_ops,
727		   .of_match_table = of_match_ptr(tpm_tis_i2c_of_match),
728		   },
729};
730
731module_i2c_driver(tpm_tis_i2c_driver);
732MODULE_AUTHOR("Peter Huewe <peter.huewe@infineon.com>");
733MODULE_DESCRIPTION("TPM TIS I2C Infineon Driver");
734MODULE_VERSION("2.2.0");
735MODULE_LICENSE("GPL");