2 * Copyright (C) 2004 IBM Corporation
4 * Leendert van Doorn <leendert@watson.ibm.com>
5 * Dave Safford <safford@watson.ibm.com>
6 * Reiner Sailer <sailer@watson.ibm.com>
7 * Kylene Hall <kjhall@us.ibm.com>
9 * Copyright (C) 2013 Obsidian Research Corp
10 * Jason Gunthorpe <jgunthorpe@obsidianresearch.com>
12 * Device file system interface to the TPM
14 * This program is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU General Public License as
16 * published by the Free Software Foundation, version 2 of the
20 #include <linux/slab.h>
21 #include <linux/uaccess.h>
25 struct tpm_chip
*chip
;
27 /* Data passed to and from the tpm via the read/write calls */
28 atomic_t data_pending
;
29 struct mutex buffer_mutex
;
31 struct timer_list user_read_timer
; /* user needs to claim result */
32 struct work_struct work
;
34 u8 data_buffer
[TPM_BUFSIZE
];
37 static void user_reader_timeout(unsigned long ptr
)
39 struct file_priv
*priv
= (struct file_priv
*)ptr
;
41 schedule_work(&priv
->work
);
44 static void timeout_work(struct work_struct
*work
)
46 struct file_priv
*priv
= container_of(work
, struct file_priv
, work
);
48 mutex_lock(&priv
->buffer_mutex
);
49 atomic_set(&priv
->data_pending
, 0);
50 memset(priv
->data_buffer
, 0, sizeof(priv
->data_buffer
));
51 mutex_unlock(&priv
->buffer_mutex
);
54 static int tpm_open(struct inode
*inode
, struct file
*file
)
56 struct tpm_chip
*chip
=
57 container_of(inode
->i_cdev
, struct tpm_chip
, cdev
);
58 struct file_priv
*priv
;
60 /* It's assured that the chip will be opened just once,
61 * by the check of is_open variable, which is protected
63 if (test_and_set_bit(0, &chip
->is_open
)) {
64 dev_dbg(&chip
->dev
, "Another process owns this TPM\n");
68 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
70 clear_bit(0, &chip
->is_open
);
75 atomic_set(&priv
->data_pending
, 0);
76 mutex_init(&priv
->buffer_mutex
);
77 setup_timer(&priv
->user_read_timer
, user_reader_timeout
,
79 INIT_WORK(&priv
->work
, timeout_work
);
81 file
->private_data
= priv
;
85 static ssize_t
tpm_read(struct file
*file
, char __user
*buf
,
86 size_t size
, loff_t
*off
)
88 struct file_priv
*priv
= file
->private_data
;
92 del_singleshot_timer_sync(&priv
->user_read_timer
);
93 flush_work(&priv
->work
);
94 ret_size
= atomic_read(&priv
->data_pending
);
95 if (ret_size
> 0) { /* relay data */
96 ssize_t orig_ret_size
= ret_size
;
100 mutex_lock(&priv
->buffer_mutex
);
101 rc
= copy_to_user(buf
, priv
->data_buffer
, ret_size
);
102 memset(priv
->data_buffer
, 0, orig_ret_size
);
106 mutex_unlock(&priv
->buffer_mutex
);
109 atomic_set(&priv
->data_pending
, 0);
114 static ssize_t
tpm_write(struct file
*file
, const char __user
*buf
,
115 size_t size
, loff_t
*off
)
117 struct file_priv
*priv
= file
->private_data
;
118 size_t in_size
= size
;
121 /* cannot perform a write until the read has cleared
122 either via tpm_read or a user_read_timer timeout.
123 This also prevents splitted buffered writes from blocking here.
125 if (atomic_read(&priv
->data_pending
) != 0)
128 if (in_size
> TPM_BUFSIZE
)
131 mutex_lock(&priv
->buffer_mutex
);
134 (priv
->data_buffer
, (void __user
*) buf
, in_size
)) {
135 mutex_unlock(&priv
->buffer_mutex
);
139 /* atomic tpm command send and result receive */
140 out_size
= tpm_transmit(priv
->chip
, priv
->data_buffer
,
141 sizeof(priv
->data_buffer
));
143 mutex_unlock(&priv
->buffer_mutex
);
147 atomic_set(&priv
->data_pending
, out_size
);
148 mutex_unlock(&priv
->buffer_mutex
);
150 /* Set a timeout by which the reader must come claim the result */
151 mod_timer(&priv
->user_read_timer
, jiffies
+ (60 * HZ
));
157 * Called on file close
159 static int tpm_release(struct inode
*inode
, struct file
*file
)
161 struct file_priv
*priv
= file
->private_data
;
163 del_singleshot_timer_sync(&priv
->user_read_timer
);
164 flush_work(&priv
->work
);
165 file
->private_data
= NULL
;
166 atomic_set(&priv
->data_pending
, 0);
167 clear_bit(0, &priv
->chip
->is_open
);
172 const struct file_operations tpm_fops
= {
173 .owner
= THIS_MODULE
,
178 .release
= tpm_release
,