This source file includes following definitions.
- read_data
- write_data
- read_status
- write_status
- update_status_bits
- set_state
- kcs_force_abort
- kcs_bmc_handle_data
- kcs_bmc_handle_cmd
- kcs_bmc_handle_event
- to_kcs_bmc
- kcs_bmc_open
- kcs_bmc_poll
- kcs_bmc_read
- kcs_bmc_write
- kcs_bmc_ioctl
- kcs_bmc_release
- kcs_bmc_alloc
1
2
3
4
5
6 #define pr_fmt(fmt) "kcs-bmc: " fmt
7
8 #include <linux/errno.h>
9 #include <linux/io.h>
10 #include <linux/ipmi_bmc.h>
11 #include <linux/module.h>
12 #include <linux/platform_device.h>
13 #include <linux/poll.h>
14 #include <linux/sched.h>
15 #include <linux/slab.h>
16
17 #include "kcs_bmc.h"
18
19 #define DEVICE_NAME "ipmi-kcs"
20
21 #define KCS_MSG_BUFSIZ 1000
22
23 #define KCS_ZERO_DATA 0
24
25
26
27 #define KCS_STATUS_STATE(state) (state << 6)
28 #define KCS_STATUS_STATE_MASK GENMASK(7, 6)
29 #define KCS_STATUS_CMD_DAT BIT(3)
30 #define KCS_STATUS_SMS_ATN BIT(2)
31 #define KCS_STATUS_IBF BIT(1)
32 #define KCS_STATUS_OBF BIT(0)
33
34
35 enum kcs_states {
36 IDLE_STATE = 0,
37 READ_STATE = 1,
38 WRITE_STATE = 2,
39 ERROR_STATE = 3,
40 };
41
42
43 #define KCS_CMD_GET_STATUS_ABORT 0x60
44 #define KCS_CMD_WRITE_START 0x61
45 #define KCS_CMD_WRITE_END 0x62
46 #define KCS_CMD_READ_BYTE 0x68
47
48 static inline u8 read_data(struct kcs_bmc *kcs_bmc)
49 {
50 return kcs_bmc->io_inputb(kcs_bmc, kcs_bmc->ioreg.idr);
51 }
52
53 static inline void write_data(struct kcs_bmc *kcs_bmc, u8 data)
54 {
55 kcs_bmc->io_outputb(kcs_bmc, kcs_bmc->ioreg.odr, data);
56 }
57
58 static inline u8 read_status(struct kcs_bmc *kcs_bmc)
59 {
60 return kcs_bmc->io_inputb(kcs_bmc, kcs_bmc->ioreg.str);
61 }
62
63 static inline void write_status(struct kcs_bmc *kcs_bmc, u8 data)
64 {
65 kcs_bmc->io_outputb(kcs_bmc, kcs_bmc->ioreg.str, data);
66 }
67
68 static void update_status_bits(struct kcs_bmc *kcs_bmc, u8 mask, u8 val)
69 {
70 u8 tmp = read_status(kcs_bmc);
71
72 tmp &= ~mask;
73 tmp |= val & mask;
74
75 write_status(kcs_bmc, tmp);
76 }
77
78 static inline void set_state(struct kcs_bmc *kcs_bmc, u8 state)
79 {
80 update_status_bits(kcs_bmc, KCS_STATUS_STATE_MASK,
81 KCS_STATUS_STATE(state));
82 }
83
84 static void kcs_force_abort(struct kcs_bmc *kcs_bmc)
85 {
86 set_state(kcs_bmc, ERROR_STATE);
87 read_data(kcs_bmc);
88 write_data(kcs_bmc, KCS_ZERO_DATA);
89
90 kcs_bmc->phase = KCS_PHASE_ERROR;
91 kcs_bmc->data_in_avail = false;
92 kcs_bmc->data_in_idx = 0;
93 }
94
95 static void kcs_bmc_handle_data(struct kcs_bmc *kcs_bmc)
96 {
97 u8 data;
98
99 switch (kcs_bmc->phase) {
100 case KCS_PHASE_WRITE_START:
101 kcs_bmc->phase = KCS_PHASE_WRITE_DATA;
102
103
104 case KCS_PHASE_WRITE_DATA:
105 if (kcs_bmc->data_in_idx < KCS_MSG_BUFSIZ) {
106 set_state(kcs_bmc, WRITE_STATE);
107 write_data(kcs_bmc, KCS_ZERO_DATA);
108 kcs_bmc->data_in[kcs_bmc->data_in_idx++] =
109 read_data(kcs_bmc);
110 } else {
111 kcs_force_abort(kcs_bmc);
112 kcs_bmc->error = KCS_LENGTH_ERROR;
113 }
114 break;
115
116 case KCS_PHASE_WRITE_END_CMD:
117 if (kcs_bmc->data_in_idx < KCS_MSG_BUFSIZ) {
118 set_state(kcs_bmc, READ_STATE);
119 kcs_bmc->data_in[kcs_bmc->data_in_idx++] =
120 read_data(kcs_bmc);
121 kcs_bmc->phase = KCS_PHASE_WRITE_DONE;
122 kcs_bmc->data_in_avail = true;
123 wake_up_interruptible(&kcs_bmc->queue);
124 } else {
125 kcs_force_abort(kcs_bmc);
126 kcs_bmc->error = KCS_LENGTH_ERROR;
127 }
128 break;
129
130 case KCS_PHASE_READ:
131 if (kcs_bmc->data_out_idx == kcs_bmc->data_out_len)
132 set_state(kcs_bmc, IDLE_STATE);
133
134 data = read_data(kcs_bmc);
135 if (data != KCS_CMD_READ_BYTE) {
136 set_state(kcs_bmc, ERROR_STATE);
137 write_data(kcs_bmc, KCS_ZERO_DATA);
138 break;
139 }
140
141 if (kcs_bmc->data_out_idx == kcs_bmc->data_out_len) {
142 write_data(kcs_bmc, KCS_ZERO_DATA);
143 kcs_bmc->phase = KCS_PHASE_IDLE;
144 break;
145 }
146
147 write_data(kcs_bmc,
148 kcs_bmc->data_out[kcs_bmc->data_out_idx++]);
149 break;
150
151 case KCS_PHASE_ABORT_ERROR1:
152 set_state(kcs_bmc, READ_STATE);
153 read_data(kcs_bmc);
154 write_data(kcs_bmc, kcs_bmc->error);
155 kcs_bmc->phase = KCS_PHASE_ABORT_ERROR2;
156 break;
157
158 case KCS_PHASE_ABORT_ERROR2:
159 set_state(kcs_bmc, IDLE_STATE);
160 read_data(kcs_bmc);
161 write_data(kcs_bmc, KCS_ZERO_DATA);
162 kcs_bmc->phase = KCS_PHASE_IDLE;
163 break;
164
165 default:
166 kcs_force_abort(kcs_bmc);
167 break;
168 }
169 }
170
171 static void kcs_bmc_handle_cmd(struct kcs_bmc *kcs_bmc)
172 {
173 u8 cmd;
174
175 set_state(kcs_bmc, WRITE_STATE);
176 write_data(kcs_bmc, KCS_ZERO_DATA);
177
178 cmd = read_data(kcs_bmc);
179 switch (cmd) {
180 case KCS_CMD_WRITE_START:
181 kcs_bmc->phase = KCS_PHASE_WRITE_START;
182 kcs_bmc->error = KCS_NO_ERROR;
183 kcs_bmc->data_in_avail = false;
184 kcs_bmc->data_in_idx = 0;
185 break;
186
187 case KCS_CMD_WRITE_END:
188 if (kcs_bmc->phase != KCS_PHASE_WRITE_DATA) {
189 kcs_force_abort(kcs_bmc);
190 break;
191 }
192
193 kcs_bmc->phase = KCS_PHASE_WRITE_END_CMD;
194 break;
195
196 case KCS_CMD_GET_STATUS_ABORT:
197 if (kcs_bmc->error == KCS_NO_ERROR)
198 kcs_bmc->error = KCS_ABORTED_BY_COMMAND;
199
200 kcs_bmc->phase = KCS_PHASE_ABORT_ERROR1;
201 kcs_bmc->data_in_avail = false;
202 kcs_bmc->data_in_idx = 0;
203 break;
204
205 default:
206 kcs_force_abort(kcs_bmc);
207 kcs_bmc->error = KCS_ILLEGAL_CONTROL_CODE;
208 break;
209 }
210 }
211
212 int kcs_bmc_handle_event(struct kcs_bmc *kcs_bmc)
213 {
214 unsigned long flags;
215 int ret = -ENODATA;
216 u8 status;
217
218 spin_lock_irqsave(&kcs_bmc->lock, flags);
219
220 status = read_status(kcs_bmc);
221 if (status & KCS_STATUS_IBF) {
222 if (!kcs_bmc->running)
223 kcs_force_abort(kcs_bmc);
224 else if (status & KCS_STATUS_CMD_DAT)
225 kcs_bmc_handle_cmd(kcs_bmc);
226 else
227 kcs_bmc_handle_data(kcs_bmc);
228
229 ret = 0;
230 }
231
232 spin_unlock_irqrestore(&kcs_bmc->lock, flags);
233
234 return ret;
235 }
236 EXPORT_SYMBOL(kcs_bmc_handle_event);
237
238 static inline struct kcs_bmc *to_kcs_bmc(struct file *filp)
239 {
240 return container_of(filp->private_data, struct kcs_bmc, miscdev);
241 }
242
243 static int kcs_bmc_open(struct inode *inode, struct file *filp)
244 {
245 struct kcs_bmc *kcs_bmc = to_kcs_bmc(filp);
246 int ret = 0;
247
248 spin_lock_irq(&kcs_bmc->lock);
249 if (!kcs_bmc->running)
250 kcs_bmc->running = 1;
251 else
252 ret = -EBUSY;
253 spin_unlock_irq(&kcs_bmc->lock);
254
255 return ret;
256 }
257
258 static __poll_t kcs_bmc_poll(struct file *filp, poll_table *wait)
259 {
260 struct kcs_bmc *kcs_bmc = to_kcs_bmc(filp);
261 __poll_t mask = 0;
262
263 poll_wait(filp, &kcs_bmc->queue, wait);
264
265 spin_lock_irq(&kcs_bmc->lock);
266 if (kcs_bmc->data_in_avail)
267 mask |= EPOLLIN;
268 spin_unlock_irq(&kcs_bmc->lock);
269
270 return mask;
271 }
272
273 static ssize_t kcs_bmc_read(struct file *filp, char __user *buf,
274 size_t count, loff_t *ppos)
275 {
276 struct kcs_bmc *kcs_bmc = to_kcs_bmc(filp);
277 bool data_avail;
278 size_t data_len;
279 ssize_t ret;
280
281 if (!(filp->f_flags & O_NONBLOCK))
282 wait_event_interruptible(kcs_bmc->queue,
283 kcs_bmc->data_in_avail);
284
285 mutex_lock(&kcs_bmc->mutex);
286
287 spin_lock_irq(&kcs_bmc->lock);
288 data_avail = kcs_bmc->data_in_avail;
289 if (data_avail) {
290 data_len = kcs_bmc->data_in_idx;
291 memcpy(kcs_bmc->kbuffer, kcs_bmc->data_in, data_len);
292 }
293 spin_unlock_irq(&kcs_bmc->lock);
294
295 if (!data_avail) {
296 ret = -EAGAIN;
297 goto out_unlock;
298 }
299
300 if (count < data_len) {
301 pr_err("channel=%u with too large data : %zu\n",
302 kcs_bmc->channel, data_len);
303
304 spin_lock_irq(&kcs_bmc->lock);
305 kcs_force_abort(kcs_bmc);
306 spin_unlock_irq(&kcs_bmc->lock);
307
308 ret = -EOVERFLOW;
309 goto out_unlock;
310 }
311
312 if (copy_to_user(buf, kcs_bmc->kbuffer, data_len)) {
313 ret = -EFAULT;
314 goto out_unlock;
315 }
316
317 ret = data_len;
318
319 spin_lock_irq(&kcs_bmc->lock);
320 if (kcs_bmc->phase == KCS_PHASE_WRITE_DONE) {
321 kcs_bmc->phase = KCS_PHASE_WAIT_READ;
322 kcs_bmc->data_in_avail = false;
323 kcs_bmc->data_in_idx = 0;
324 } else {
325 ret = -EAGAIN;
326 }
327 spin_unlock_irq(&kcs_bmc->lock);
328
329 out_unlock:
330 mutex_unlock(&kcs_bmc->mutex);
331
332 return ret;
333 }
334
335 static ssize_t kcs_bmc_write(struct file *filp, const char __user *buf,
336 size_t count, loff_t *ppos)
337 {
338 struct kcs_bmc *kcs_bmc = to_kcs_bmc(filp);
339 ssize_t ret;
340
341
342 if (count < 3 || count > KCS_MSG_BUFSIZ)
343 return -EINVAL;
344
345 mutex_lock(&kcs_bmc->mutex);
346
347 if (copy_from_user(kcs_bmc->kbuffer, buf, count)) {
348 ret = -EFAULT;
349 goto out_unlock;
350 }
351
352 spin_lock_irq(&kcs_bmc->lock);
353 if (kcs_bmc->phase == KCS_PHASE_WAIT_READ) {
354 kcs_bmc->phase = KCS_PHASE_READ;
355 kcs_bmc->data_out_idx = 1;
356 kcs_bmc->data_out_len = count;
357 memcpy(kcs_bmc->data_out, kcs_bmc->kbuffer, count);
358 write_data(kcs_bmc, kcs_bmc->data_out[0]);
359 ret = count;
360 } else {
361 ret = -EINVAL;
362 }
363 spin_unlock_irq(&kcs_bmc->lock);
364
365 out_unlock:
366 mutex_unlock(&kcs_bmc->mutex);
367
368 return ret;
369 }
370
371 static long kcs_bmc_ioctl(struct file *filp, unsigned int cmd,
372 unsigned long arg)
373 {
374 struct kcs_bmc *kcs_bmc = to_kcs_bmc(filp);
375 long ret = 0;
376
377 spin_lock_irq(&kcs_bmc->lock);
378
379 switch (cmd) {
380 case IPMI_BMC_IOCTL_SET_SMS_ATN:
381 update_status_bits(kcs_bmc, KCS_STATUS_SMS_ATN,
382 KCS_STATUS_SMS_ATN);
383 break;
384
385 case IPMI_BMC_IOCTL_CLEAR_SMS_ATN:
386 update_status_bits(kcs_bmc, KCS_STATUS_SMS_ATN,
387 0);
388 break;
389
390 case IPMI_BMC_IOCTL_FORCE_ABORT:
391 kcs_force_abort(kcs_bmc);
392 break;
393
394 default:
395 ret = -EINVAL;
396 break;
397 }
398
399 spin_unlock_irq(&kcs_bmc->lock);
400
401 return ret;
402 }
403
404 static int kcs_bmc_release(struct inode *inode, struct file *filp)
405 {
406 struct kcs_bmc *kcs_bmc = to_kcs_bmc(filp);
407
408 spin_lock_irq(&kcs_bmc->lock);
409 kcs_bmc->running = 0;
410 kcs_force_abort(kcs_bmc);
411 spin_unlock_irq(&kcs_bmc->lock);
412
413 return 0;
414 }
415
416 static const struct file_operations kcs_bmc_fops = {
417 .owner = THIS_MODULE,
418 .open = kcs_bmc_open,
419 .read = kcs_bmc_read,
420 .write = kcs_bmc_write,
421 .release = kcs_bmc_release,
422 .poll = kcs_bmc_poll,
423 .unlocked_ioctl = kcs_bmc_ioctl,
424 };
425
426 struct kcs_bmc *kcs_bmc_alloc(struct device *dev, int sizeof_priv, u32 channel)
427 {
428 struct kcs_bmc *kcs_bmc;
429
430 kcs_bmc = devm_kzalloc(dev, sizeof(*kcs_bmc) + sizeof_priv, GFP_KERNEL);
431 if (!kcs_bmc)
432 return NULL;
433
434 spin_lock_init(&kcs_bmc->lock);
435 kcs_bmc->channel = channel;
436
437 mutex_init(&kcs_bmc->mutex);
438 init_waitqueue_head(&kcs_bmc->queue);
439
440 kcs_bmc->data_in = devm_kmalloc(dev, KCS_MSG_BUFSIZ, GFP_KERNEL);
441 kcs_bmc->data_out = devm_kmalloc(dev, KCS_MSG_BUFSIZ, GFP_KERNEL);
442 kcs_bmc->kbuffer = devm_kmalloc(dev, KCS_MSG_BUFSIZ, GFP_KERNEL);
443
444 kcs_bmc->miscdev.minor = MISC_DYNAMIC_MINOR;
445 kcs_bmc->miscdev.name = devm_kasprintf(dev, GFP_KERNEL, "%s%u",
446 DEVICE_NAME, channel);
447 if (!kcs_bmc->data_in || !kcs_bmc->data_out || !kcs_bmc->kbuffer ||
448 !kcs_bmc->miscdev.name)
449 return NULL;
450 kcs_bmc->miscdev.fops = &kcs_bmc_fops;
451
452 return kcs_bmc;
453 }
454 EXPORT_SYMBOL(kcs_bmc_alloc);
455
456 MODULE_LICENSE("GPL v2");
457 MODULE_AUTHOR("Haiyue Wang <haiyue.wang@linux.intel.com>");
458 MODULE_DESCRIPTION("KCS BMC to handle the IPMI request from system software");