?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge remote-tracking branch 'moduleh/module.h-split'
[linux-2.6/next.git] / drivers / staging / mei / main.c
blob8d7678569e7196e6d374f98bfb06d4e0e7e36c30
1 /*
2 *
3 * Intel Management Engine Interface (Intel MEI) Linux driver
4 * Copyright (c) 2003-2011, Intel Corporation.
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms and conditions of the GNU General Public License,
8 * version 2, as published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * more details.
14 *
15 */
16
17 #include <linux/module.h>
18 #include <linux/moduleparam.h>
19 #include <linux/kernel.h>
20 #include <linux/device.h>
21 #include <linux/fs.h>
22 #include <linux/errno.h>
23 #include <linux/types.h>
24 #include <linux/fcntl.h>
25 #include <linux/aio.h>
26 #include <linux/pci.h>
27 #include <linux/poll.h>
28 #include <linux/init.h>
29 #include <linux/ioctl.h>
30 #include <linux/cdev.h>
31 #include <linux/sched.h>
32 #include <linux/uuid.h>
33 #include <linux/compat.h>
34 #include <linux/jiffies.h>
35 #include <linux/interrupt.h>
36
37 #include "mei_dev.h"
38 #include "mei.h"
39 #include "interface.h"
40 #include "mei_version.h"
41
42
43 #define MEI_READ_TIMEOUT 45
44 #define MEI_DRIVER_NAME "mei"
45 #define MEI_DEV_NAME "mei"
46
47 /*
48 * mei driver strings
49 */
50 static char mei_driver_name[] = MEI_DRIVER_NAME;
51 static const char mei_driver_string[] = "Intel(R) Management Engine Interface";
52 static const char mei_driver_version[] = MEI_DRIVER_VERSION;
53
54 /* mei char device for registration */
55 static struct cdev mei_cdev;
56
57 /* major number for device */
58 static int mei_major;
59 /* The device pointer */
60 /* Currently this driver works as long as there is only a single AMT device. */
61 static struct pci_dev *mei_device;
62
63 static struct class *mei_class;
64
65
66 /* mei_pci_tbl - PCI Device ID Table */
67 static DEFINE_PCI_DEVICE_TABLE(mei_pci_tbl) = {
68 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MEI_DEV_ID_82946GZ)},
69 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MEI_DEV_ID_82G35)},
70 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MEI_DEV_ID_82Q965)},
71 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MEI_DEV_ID_82G965)},
72 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MEI_DEV_ID_82GM965)},
73 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MEI_DEV_ID_82GME965)},
74 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MEI_DEV_ID_ICH9_82Q35)},
75 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MEI_DEV_ID_ICH9_82G33)},
76 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MEI_DEV_ID_ICH9_82Q33)},
77 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MEI_DEV_ID_ICH9_82X38)},
78 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MEI_DEV_ID_ICH9_3200)},
79 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MEI_DEV_ID_ICH9_6)},
80 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MEI_DEV_ID_ICH9_7)},
81 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MEI_DEV_ID_ICH9_8)},
82 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MEI_DEV_ID_ICH9_9)},
83 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MEI_DEV_ID_ICH9_10)},
84 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MEI_DEV_ID_ICH9M_1)},
85 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MEI_DEV_ID_ICH9M_2)},
86 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MEI_DEV_ID_ICH9M_3)},
87 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MEI_DEV_ID_ICH9M_4)},
88 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MEI_DEV_ID_ICH10_1)},
89 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MEI_DEV_ID_ICH10_2)},
90 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MEI_DEV_ID_ICH10_3)},
91 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MEI_DEV_ID_ICH10_4)},
92 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MEI_DEV_ID_IBXPK_1)},
93 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MEI_DEV_ID_IBXPK_2)},
94 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MEI_DEV_ID_CPT_1)},
95 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MEI_DEV_ID_PBG_1)},
96 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MEI_DEV_ID_PPT_1)},
97 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MEI_DEV_ID_PPT_2)},
98 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, MEI_DEV_ID_PPT_3)},
99
100 /* required last entry */
101 {0, }
102 };
103
104 MODULE_DEVICE_TABLE(pci, mei_pci_tbl);
105
106 static DEFINE_MUTEX(mei_mutex);
107
108 /**
109 * mei_probe - Device Initialization Routine
110 *
111 * @pdev: PCI device structure
112 * @ent: entry in kcs_pci_tbl
113 *
114 * returns 0 on success, <0 on failure.
115 */
116 static int __devinit mei_probe(struct pci_dev *pdev,
117 const struct pci_device_id *ent)
118 {
119 struct mei_device *dev;
120 int err;
121
122 mutex_lock(&mei_mutex);
123 if (mei_device) {
124 err = -EEXIST;
125 goto end;
126 }
127 /* enable pci dev */
128 err = pci_enable_device(pdev);
129 if (err) {
130 printk(KERN_ERR "mei: Failed to enable pci device.\n");
131 goto end;
132 }
133 /* set PCI host mastering */
134 pci_set_master(pdev);
135 /* pci request regions for mei driver */
136 err = pci_request_regions(pdev, mei_driver_name);
137 if (err) {
138 printk(KERN_ERR "mei: Failed to get pci regions.\n");
139 goto disable_device;
140 }
141 /* allocates and initializes the mei dev structure */
142 dev = mei_device_init(pdev);
143 if (!dev) {
144 err = -ENOMEM;
145 goto release_regions;
146 }
147 /* mapping IO device memory */
148 dev->mem_addr = pci_iomap(pdev, 0, 0);
149 if (!dev->mem_addr) {
150 printk(KERN_ERR "mei: mapping I/O device memory failure.\n");
151 err = -ENOMEM;
152 goto free_device;
153 }
154 pci_enable_msi(pdev);
155
156 /* request and enable interrupt */
157 if (pci_dev_msi_enabled(pdev))
158 err = request_threaded_irq(pdev->irq,
159 NULL,
160 mei_interrupt_thread_handler,
161 0, mei_driver_name, dev);
162 else
163 err = request_threaded_irq(pdev->irq,
164 mei_interrupt_quick_handler,
165 mei_interrupt_thread_handler,
166 IRQF_SHARED, mei_driver_name, dev);
167
168 if (err) {
169 printk(KERN_ERR "mei: request_threaded_irq failure. irq = %d\n",
170 pdev->irq);
171 goto unmap_memory;
172 }
173 INIT_DELAYED_WORK(&dev->wd_work, mei_wd_timer);
174 if (mei_hw_init(dev)) {
175 printk(KERN_ERR "mei: Init hw failure.\n");
176 err = -ENODEV;
177 goto release_irq;
178 }
179 mei_device = pdev;
180 pci_set_drvdata(pdev, dev);
181 schedule_delayed_work(&dev->wd_work, HZ);
182
183 mutex_unlock(&mei_mutex);
184
185 pr_debug("mei: Driver initialization successful.\n");
186
187 return 0;
188
189 release_irq:
190 /* disable interrupts */
191 dev->host_hw_state = mei_hcsr_read(dev);
192 mei_disable_interrupts(dev);
193 flush_scheduled_work();
194 free_irq(pdev->irq, dev);
195 pci_disable_msi(pdev);
196 unmap_memory:
197 pci_iounmap(pdev, dev->mem_addr);
198 free_device:
199 kfree(dev);
200 release_regions:
201 pci_release_regions(pdev);
202 disable_device:
203 pci_disable_device(pdev);
204 end:
205 mutex_unlock(&mei_mutex);
206 printk(KERN_ERR "mei: Driver initialization failed.\n");
207 return err;
208 }
209
210 /**
211 * mei_remove - Device Removal Routine
212 *
213 * @pdev: PCI device structure
214 *
215 * mei_remove is called by the PCI subsystem to alert the driver
216 * that it should release a PCI device.
217 */
218 static void __devexit mei_remove(struct pci_dev *pdev)
219 {
220 struct mei_device *dev;
221
222 if (mei_device != pdev)
223 return;
224
225 dev = pci_get_drvdata(pdev);
226 if (!dev)
227 return;
228
229 mutex_lock(&dev->device_lock);
230
231 mei_wd_stop(dev, false);
232
233 mei_device = NULL;
234
235 if (dev->iamthif_cl.state == MEI_FILE_CONNECTED) {
236 dev->iamthif_cl.state = MEI_FILE_DISCONNECTING;
237 mei_disconnect_host_client(dev, &dev->iamthif_cl);
238 }
239 if (dev->wd_cl.state == MEI_FILE_CONNECTED) {
240 dev->wd_cl.state = MEI_FILE_DISCONNECTING;
241 mei_disconnect_host_client(dev, &dev->wd_cl);
242 }
243
244 /* remove entry if already in list */
245 dev_dbg(&pdev->dev, "list del iamthif and wd file list.\n");
246 mei_remove_client_from_file_list(dev, dev->wd_cl.host_client_id);
247 mei_remove_client_from_file_list(dev, dev->iamthif_cl.host_client_id);
248
249 dev->iamthif_current_cb = NULL;
250 dev->me_clients_num = 0;
251
252 mutex_unlock(&dev->device_lock);
253
254 flush_scheduled_work();
255
256 /* disable interrupts */
257 mei_disable_interrupts(dev);
258
259 free_irq(pdev->irq, dev);
260 pci_disable_msi(pdev);
261 pci_set_drvdata(pdev, NULL);
262
263 if (dev->mem_addr)
264 pci_iounmap(pdev, dev->mem_addr);
265
266 kfree(dev);
267
268 pci_release_regions(pdev);
269 pci_disable_device(pdev);
270 }
271
272 /**
273 * mei_clear_list - removes all callbacks associated with file
274 * from mei_cb_list
275 *
276 * @dev: device structure.
277 * @file: file structure
278 * @mei_cb_list: callbacks list
279 *
280 * mei_clear_list is called to clear resources associated with file
281 * when application calls close function or Ctrl-C was pressed
282 *
283 * returns true if callback removed from the list, false otherwise
284 */
285 static bool mei_clear_list(struct mei_device *dev,
286 struct file *file, struct list_head *mei_cb_list)
287 {
288 struct mei_cl_cb *cb_pos = NULL;
289 struct mei_cl_cb *cb_next = NULL;
290 struct file *file_temp;
291 bool removed = false;
292
293 /* list all list member */
294 list_for_each_entry_safe(cb_pos, cb_next, mei_cb_list, cb_list) {
295 file_temp = (struct file *)cb_pos->file_object;
296 /* check if list member associated with a file */
297 if (file_temp == file) {
298 /* remove member from the list */
299 list_del(&cb_pos->cb_list);
300 /* check if cb equal to current iamthif cb */
301 if (dev->iamthif_current_cb == cb_pos) {
302 dev->iamthif_current_cb = NULL;
303 /* send flow control to iamthif client */
304 mei_send_flow_control(dev, &dev->iamthif_cl);
305 }
306 /* free all allocated buffers */
307 mei_free_cb_private(cb_pos);
308 cb_pos = NULL;
309 removed = true;
310 }
311 }
312 return removed;
313 }
314
315 /**
316 * mei_clear_lists - removes all callbacks associated with file
317 *
318 * @dev: device structure
319 * @file: file structure
320 *
321 * mei_clear_lists is called to clear resources associated with file
322 * when application calls close function or Ctrl-C was pressed
323 *
324 * returns true if callback removed from the list, false otherwise
325 */
326 static bool mei_clear_lists(struct mei_device *dev, struct file *file)
327 {
328 bool removed = false;
329
330 /* remove callbacks associated with a file */
331 mei_clear_list(dev, file, &dev->amthi_cmd_list.mei_cb.cb_list);
332 if (mei_clear_list(dev, file,
333 &dev->amthi_read_complete_list.mei_cb.cb_list))
334 removed = true;
335
336 mei_clear_list(dev, file, &dev->ctrl_rd_list.mei_cb.cb_list);
337
338 if (mei_clear_list(dev, file, &dev->ctrl_wr_list.mei_cb.cb_list))
339 removed = true;
340
341 if (mei_clear_list(dev, file, &dev->write_waiting_list.mei_cb.cb_list))
342 removed = true;
343
344 if (mei_clear_list(dev, file, &dev->write_list.mei_cb.cb_list))
345 removed = true;
346
347 /* check if iamthif_current_cb not NULL */
348 if (dev->iamthif_current_cb && !removed) {
349 /* check file and iamthif current cb association */
350 if (dev->iamthif_current_cb->file_object == file) {
351 /* remove cb */
352 mei_free_cb_private(dev->iamthif_current_cb);
353 dev->iamthif_current_cb = NULL;
354 removed = true;
355 }
356 }
357 return removed;
358 }
359 /**
360 * find_read_list_entry - find read list entry
361 *
362 * @dev: device structure
363 * @file: pointer to file structure
364 *
365 * returns cb on success, NULL on error
366 */
367 static struct mei_cl_cb *find_read_list_entry(
368 struct mei_device *dev,
369 struct mei_cl *cl)
370 {
371 struct mei_cl_cb *cb_pos = NULL;
372 struct mei_cl_cb *cb_next = NULL;
373
374 if (!dev->read_list.status &&
375 !list_empty(&dev->read_list.mei_cb.cb_list)) {
376
377 dev_dbg(&dev->pdev->dev, "remove read_list CB\n");
378 list_for_each_entry_safe(cb_pos, cb_next,
379 &dev->read_list.mei_cb.cb_list, cb_list) {
380 struct mei_cl *cl_temp;
381 cl_temp = (struct mei_cl *)cb_pos->file_private;
382
383 if (mei_cl_cmp_id(cl, cl_temp))
384 return cb_pos;
385 }
386 }
387 return NULL;
388 }
389
390 /**
391 * mei_open - the open function
392 *
393 * @inode: pointer to inode structure
394 * @file: pointer to file structure
395 *
396 * returns 0 on success, <0 on error
397 */
398 static int mei_open(struct inode *inode, struct file *file)
399 {
400 struct mei_cl *cl;
401 int if_num = iminor(inode), err;
402 struct mei_device *dev;
403
404 err = -ENODEV;
405 if (!mei_device)
406 goto out;
407
408 dev = pci_get_drvdata(mei_device);
409 if (if_num != MEI_MINOR_NUMBER || !dev)
410 goto out;
411
412 mutex_lock(&dev->device_lock);
413 err = -ENOMEM;
414 cl = mei_cl_allocate(dev);
415 if (!cl)
416 goto out;
417
418 err = -ENODEV;
419 if (dev->mei_state != MEI_ENABLED) {
420 dev_dbg(&dev->pdev->dev, "mei_state != MEI_ENABLED mei_state= %d\n",
421 dev->mei_state);
422 goto out_unlock;
423 }
424 err = -EMFILE;
425 if (dev->open_handle_count >= MEI_MAX_OPEN_HANDLE_COUNT)
426 goto out_unlock;
427
428 cl->host_client_id = find_first_zero_bit(dev->host_clients_map,
429 MEI_CLIENTS_MAX);
430 if (cl->host_client_id > MEI_CLIENTS_MAX)
431 goto out_unlock;
432
433 dev_dbg(&dev->pdev->dev, "client_id = %d\n", cl->host_client_id);
434
435 dev->open_handle_count++;
436 list_add_tail(&cl->link, &dev->file_list);
437
438 set_bit(cl->host_client_id, dev->host_clients_map);
439 cl->state = MEI_FILE_INITIALIZING;
440 cl->sm_state = 0;
441
442 file->private_data = cl;
443 mutex_unlock(&dev->device_lock);
444
445 return 0;
446
447 out_unlock:
448 mutex_unlock(&dev->device_lock);
449 kfree(cl);
450 out:
451 return err;
452 }
453
454 /**
455 * mei_release - the release function
456 *
457 * @inode: pointer to inode structure
458 * @file: pointer to file structure
459 *
460 * returns 0 on success, <0 on error
461 */
462 static int mei_release(struct inode *inode, struct file *file)
463 {
464 struct mei_cl *cl = file->private_data;
465 struct mei_cl_cb *cb;
466 struct mei_device *dev;
467 int rets = 0;
468
469 if (WARN_ON(!cl || !cl->dev))
470 return -ENODEV;
471
472 dev = cl->dev;
473
474 mutex_lock(&dev->device_lock);
475 if (cl != &dev->iamthif_cl) {
476 if (cl->state == MEI_FILE_CONNECTED) {
477 cl->state = MEI_FILE_DISCONNECTING;
478 dev_dbg(&dev->pdev->dev,
479 "disconnecting client host client = %d, "
480 "ME client = %d\n",
481 cl->host_client_id,
482 cl->me_client_id);
483 rets = mei_disconnect_host_client(dev, cl);
484 }
485 mei_cl_flush_queues(cl);
486 dev_dbg(&dev->pdev->dev, "remove client host client = %d, ME client = %d\n",
487 cl->host_client_id,
488 cl->me_client_id);
489
490 if (dev->open_handle_count > 0) {
491 clear_bit(cl->host_client_id,
492 dev->host_clients_map);
493 dev->open_handle_count--;
494 }
495 mei_remove_client_from_file_list(dev, cl->host_client_id);
496
497 /* free read cb */
498 cb = NULL;
499 if (cl->read_cb) {
500 cb = find_read_list_entry(dev, cl);
501 /* Remove entry from read list */
502 if (cb)
503 list_del(&cb->cb_list);
504
505 cb = cl->read_cb;
506 cl->read_cb = NULL;
507 }
508
509 file->private_data = NULL;
510
511 if (cb) {
512 mei_free_cb_private(cb);
513 cb = NULL;
514 }
515
516 kfree(cl);
517 } else {
518 if (dev->open_handle_count > 0)
519 dev->open_handle_count--;
520
521 if (dev->iamthif_file_object == file &&
522 dev->iamthif_state != MEI_IAMTHIF_IDLE) {
523
524 dev_dbg(&dev->pdev->dev, "amthi canceled iamthif state %d\n",
525 dev->iamthif_state);
526 dev->iamthif_canceled = true;
527 if (dev->iamthif_state == MEI_IAMTHIF_READ_COMPLETE) {
528 dev_dbg(&dev->pdev->dev, "run next amthi iamthif cb\n");
529 mei_run_next_iamthif_cmd(dev);
530 }
531 }
532
533 if (mei_clear_lists(dev, file))
534 dev->iamthif_state = MEI_IAMTHIF_IDLE;
535
536 }
537 mutex_unlock(&dev->device_lock);
538 return rets;
539 }
540
541
542 /**
543 * mei_read - the read function.
544 *
545 * @file: pointer to file structure
546 * @ubuf: pointer to user buffer
547 * @length: buffer length
548 * @offset: data offset in buffer
549 *
550 * returns >=0 data length on success , <0 on error
551 */
552 static ssize_t mei_read(struct file *file, char __user *ubuf,
553 size_t length, loff_t *offset)
554 {
555 struct mei_cl *cl = file->private_data;
556 struct mei_cl_cb *cb_pos = NULL;
557 struct mei_cl_cb *cb = NULL;
558 struct mei_device *dev;
559 int i;
560 int rets;
561 int err;
562
563
564 if (WARN_ON(!cl || !cl->dev))
565 return -ENODEV;
566
567 dev = cl->dev;
568
569 mutex_lock(&dev->device_lock);
570 if (dev->mei_state != MEI_ENABLED) {
571 rets = -ENODEV;
572 goto out;
573 }
574
575 if ((cl->sm_state & MEI_WD_STATE_INDEPENDENCE_MSG_SENT) == 0) {
576 /* Do not allow to read watchdog client */
577 i = mei_find_me_client_index(dev, mei_wd_guid);
578 if (i >= 0) {
579 struct mei_me_client *me_client = &dev->me_clients[i];
580
581 if (cl->me_client_id == me_client->client_id) {
582 rets = -EBADF;
583 goto out;
584 }
585 }
586 } else {
587 cl->sm_state &= ~MEI_WD_STATE_INDEPENDENCE_MSG_SENT;
588 }
589
590 if (cl == &dev->iamthif_cl) {
591 rets = amthi_read(dev, file, ubuf, length, offset);
592 goto out;
593 }
594
595 if (cl->read_cb && cl->read_cb->information > *offset) {
596 cb = cl->read_cb;
597 goto copy_buffer;
598 } else if (cl->read_cb && cl->read_cb->information > 0 &&
599 cl->read_cb->information <= *offset) {
600 cb = cl->read_cb;
601 rets = 0;
602 goto free;
603 } else if ((!cl->read_cb || !cl->read_cb->information) &&
604 *offset > 0) {
605 /*Offset needs to be cleaned for contingous reads*/
606 *offset = 0;
607 rets = 0;
608 goto out;
609 }
610
611 err = mei_start_read(dev, cl);
612 if (err && err != -EBUSY) {
613 dev_dbg(&dev->pdev->dev,
614 "mei start read failure with status = %d\n", err);
615 rets = err;
616 goto out;
617 }
618
619 if (MEI_READ_COMPLETE != cl->reading_state &&
620 !waitqueue_active(&cl->rx_wait)) {
621 if (file->f_flags & O_NONBLOCK) {
622 rets = -EAGAIN;
623 goto out;
624 }
625
626 mutex_unlock(&dev->device_lock);
627
628 if (wait_event_interruptible(cl->rx_wait,
629 (MEI_READ_COMPLETE == cl->reading_state ||
630 MEI_FILE_INITIALIZING == cl->state ||
631 MEI_FILE_DISCONNECTED == cl->state ||
632 MEI_FILE_DISCONNECTING == cl->state))) {
633 if (signal_pending(current))
634 return -EINTR;
635 return -ERESTARTSYS;
636 }
637
638 mutex_lock(&dev->device_lock);
639 if (MEI_FILE_INITIALIZING == cl->state ||
640 MEI_FILE_DISCONNECTED == cl->state ||
641 MEI_FILE_DISCONNECTING == cl->state) {
642 rets = -EBUSY;
643 goto out;
644 }
645 }
646
647 cb = cl->read_cb;
648
649 if (!cb) {
650 rets = -ENODEV;
651 goto out;
652 }
653 if (cl->reading_state != MEI_READ_COMPLETE) {
654 rets = 0;
655 goto out;
656 }
657 /* now copy the data to user space */
658 copy_buffer:
659 dev_dbg(&dev->pdev->dev, "cb->response_buffer size - %d\n",
660 cb->response_buffer.size);
661 dev_dbg(&dev->pdev->dev, "cb->information - %lu\n",
662 cb->information);
663 if (length == 0 || ubuf == NULL || *offset > cb->information) {
664 rets = -EMSGSIZE;
665 goto free;
666 }
667
668 /* length is being turncated to PAGE_SIZE, however, */
669 /* information size may be longer */
670 length = min_t(size_t, length, (cb->information - *offset));
671
672 if (copy_to_user(ubuf,
673 cb->response_buffer.data + *offset,
674 length)) {
675 rets = -EFAULT;
676 goto free;
677 }
678
679 rets = length;
680 *offset += length;
681 if ((unsigned long)*offset < cb->information)
682 goto out;
683
684 free:
685 cb_pos = find_read_list_entry(dev, cl);
686 /* Remove entry from read list */
687 if (cb_pos)
688 list_del(&cb_pos->cb_list);
689 mei_free_cb_private(cb);
690 cl->reading_state = MEI_IDLE;
691 cl->read_cb = NULL;
692 cl->read_pending = 0;
693 out:
694 dev_dbg(&dev->pdev->dev, "end mei read rets= %d\n", rets);
695 mutex_unlock(&dev->device_lock);
696 return rets;
697 }
698
699 /**
700 * mei_write - the write function.
701 *
702 * @file: pointer to file structure
703 * @ubuf: pointer to user buffer
704 * @length: buffer length
705 * @offset: data offset in buffer
706 *
707 * returns >=0 data length on success , <0 on error
708 */
709 static ssize_t mei_write(struct file *file, const char __user *ubuf,
710 size_t length, loff_t *offset)
711 {
712 struct mei_cl *cl = file->private_data;
713 struct mei_cl_cb *write_cb = NULL;
714 struct mei_msg_hdr mei_hdr;
715 struct mei_device *dev;
716 unsigned long timeout = 0;
717 int rets;
718 int i;
719
720 if (WARN_ON(!cl || !cl->dev))
721 return -ENODEV;
722
723 dev = cl->dev;
724
725 mutex_lock(&dev->device_lock);
726
727 if (dev->mei_state != MEI_ENABLED) {
728 mutex_unlock(&dev->device_lock);
729 return -ENODEV;
730 }
731
732 if (cl == &dev->iamthif_cl) {
733 write_cb = find_amthi_read_list_entry(dev, file);
734
735 if (write_cb) {
736 timeout = write_cb->read_time +
737 msecs_to_jiffies(IAMTHIF_READ_TIMER);
738
739 if (time_after(jiffies, timeout) ||
740 cl->reading_state == MEI_READ_COMPLETE) {
741 *offset = 0;
742 list_del(&write_cb->cb_list);
743 mei_free_cb_private(write_cb);
744 write_cb = NULL;
745 }
746 }
747 }
748
749 /* free entry used in read */
750 if (cl->reading_state == MEI_READ_COMPLETE) {
751 *offset = 0;
752 write_cb = find_read_list_entry(dev, cl);
753 if (write_cb) {
754 list_del(&write_cb->cb_list);
755 mei_free_cb_private(write_cb);
756 write_cb = NULL;
757 cl->reading_state = MEI_IDLE;
758 cl->read_cb = NULL;
759 cl->read_pending = 0;
760 }
761 } else if (cl->reading_state == MEI_IDLE &&
762 !cl->read_pending)
763 *offset = 0;
764
765
766 write_cb = kzalloc(sizeof(struct mei_cl_cb), GFP_KERNEL);
767 if (!write_cb) {
768 mutex_unlock(&dev->device_lock);
769 return -ENOMEM;
770 }
771
772 write_cb->file_object = file;
773 write_cb->file_private = cl;
774 write_cb->request_buffer.data = kmalloc(length, GFP_KERNEL);
775 rets = -ENOMEM;
776 if (!write_cb->request_buffer.data)
777 goto unlock_dev;
778
779 dev_dbg(&dev->pdev->dev, "length =%d\n", (int) length);
780
781 rets = -EFAULT;
782 if (copy_from_user(write_cb->request_buffer.data, ubuf, length))
783 goto unlock_dev;
784
785 cl->sm_state = 0;
786 if (length == 4 &&
787 ((memcmp(mei_wd_state_independence_msg[0],
788 write_cb->request_buffer.data, 4) == 0) ||
789 (memcmp(mei_wd_state_independence_msg[1],
790 write_cb->request_buffer.data, 4) == 0) ||
791 (memcmp(mei_wd_state_independence_msg[2],
792 write_cb->request_buffer.data, 4) == 0)))
793 cl->sm_state |= MEI_WD_STATE_INDEPENDENCE_MSG_SENT;
794
795 INIT_LIST_HEAD(&write_cb->cb_list);
796 if (cl == &dev->iamthif_cl) {
797 write_cb->response_buffer.data =
798 kmalloc(dev->iamthif_mtu, GFP_KERNEL);
799 if (!write_cb->response_buffer.data) {
800 rets = -ENOMEM;
801 goto unlock_dev;
802 }
803 if (dev->mei_state != MEI_ENABLED) {
804 rets = -ENODEV;
805 goto unlock_dev;
806 }
807 for (i = 0; i < dev->me_clients_num; i++) {
808 if (dev->me_clients[i].client_id ==
809 dev->iamthif_cl.me_client_id)
810 break;
811 }
812
813 if (WARN_ON(dev->me_clients[i].client_id != cl->me_client_id)) {
814 rets = -ENODEV;
815 goto unlock_dev;
816 }
817 if (i == dev->me_clients_num ||
818 (dev->me_clients[i].client_id !=
819 dev->iamthif_cl.me_client_id)) {
820 rets = -ENODEV;
821 goto unlock_dev;
822 } else if (length > dev->me_clients[i].props.max_msg_length ||
823 length <= 0) {
824 rets = -EMSGSIZE;
825 goto unlock_dev;
826 }
827
828 write_cb->response_buffer.size = dev->iamthif_mtu;
829 write_cb->major_file_operations = MEI_IOCTL;
830 write_cb->information = 0;
831 write_cb->request_buffer.size = length;
832 if (dev->iamthif_cl.state != MEI_FILE_CONNECTED) {
833 rets = -ENODEV;
834 goto unlock_dev;
835 }
836
837 if (!list_empty(&dev->amthi_cmd_list.mei_cb.cb_list) ||
838 dev->iamthif_state != MEI_IAMTHIF_IDLE) {
839 dev_dbg(&dev->pdev->dev, "amthi_state = %d\n",
840 (int) dev->iamthif_state);
841 dev_dbg(&dev->pdev->dev, "add amthi cb to amthi cmd waiting list\n");
842 list_add_tail(&write_cb->cb_list,
843 &dev->amthi_cmd_list.mei_cb.cb_list);
844 rets = length;
845 } else {
846 dev_dbg(&dev->pdev->dev, "call amthi write\n");
847 rets = amthi_write(dev, write_cb);
848
849 if (rets) {
850 dev_dbg(&dev->pdev->dev, "amthi write failed with status = %d\n",
851 rets);
852 goto unlock_dev;
853 }
854 rets = length;
855 }
856 mutex_unlock(&dev->device_lock);
857 return rets;
858 }
859
860 write_cb->major_file_operations = MEI_WRITE;
861 /* make sure information is zero before we start */
862
863 write_cb->information = 0;
864 write_cb->request_buffer.size = length;
865
866 dev_dbg(&dev->pdev->dev, "host client = %d, ME client = %d\n",
867 cl->host_client_id, cl->me_client_id);
868 if (cl->state != MEI_FILE_CONNECTED) {
869 rets = -ENODEV;
870 dev_dbg(&dev->pdev->dev, "host client = %d, is not connected to ME client = %d",
871 cl->host_client_id,
872 cl->me_client_id);
873 goto unlock_dev;
874 }
875 for (i = 0; i < dev->me_clients_num; i++) {
876 if (dev->me_clients[i].client_id ==
877 cl->me_client_id)
878 break;
879 }
880 if (WARN_ON(dev->me_clients[i].client_id != cl->me_client_id)) {
881 rets = -ENODEV;
882 goto unlock_dev;
883 }
884 if (i == dev->me_clients_num) {
885 rets = -ENODEV;
886 goto unlock_dev;
887 }
888 if (length > dev->me_clients[i].props.max_msg_length || length <= 0) {
889 rets = -EINVAL;
890 goto unlock_dev;
891 }
892 write_cb->file_private = cl;
893
894 rets = mei_flow_ctrl_creds(dev, cl);
895 if (rets < 0)
896 goto unlock_dev;
897
898 if (rets && dev->mei_host_buffer_is_empty) {
899 rets = 0;
900 dev->mei_host_buffer_is_empty = false;
901 if (length > ((((dev->host_hw_state & H_CBD) >> 24) *
902 sizeof(u32)) - sizeof(struct mei_msg_hdr))) {
903
904 mei_hdr.length =
905 (((dev->host_hw_state & H_CBD) >> 24) *
906 sizeof(u32)) -
907 sizeof(struct mei_msg_hdr);
908 mei_hdr.msg_complete = 0;
909 } else {
910 mei_hdr.length = length;
911 mei_hdr.msg_complete = 1;
912 }
913 mei_hdr.host_addr = cl->host_client_id;
914 mei_hdr.me_addr = cl->me_client_id;
915 mei_hdr.reserved = 0;
916 dev_dbg(&dev->pdev->dev, "call mei_write_message header=%08x.\n",
917 *((u32 *) &mei_hdr));
918 if (!mei_write_message(dev, &mei_hdr,
919 (unsigned char *) (write_cb->request_buffer.data),
920 mei_hdr.length)) {
921 rets = -ENODEV;
922 goto unlock_dev;
923 }
924 cl->writing_state = MEI_WRITING;
925 write_cb->information = mei_hdr.length;
926 if (mei_hdr.msg_complete) {
927 if (mei_flow_ctrl_reduce(dev, cl)) {
928 rets = -ENODEV;
929 goto unlock_dev;
930 }
931 list_add_tail(&write_cb->cb_list,
932 &dev->write_waiting_list.mei_cb.cb_list);
933 } else {
934 list_add_tail(&write_cb->cb_list,
935 &dev->write_list.mei_cb.cb_list);
936 }
937
938 } else {
939
940 write_cb->information = 0;
941 cl->writing_state = MEI_WRITING;
942 list_add_tail(&write_cb->cb_list,
943 &dev->write_list.mei_cb.cb_list);
944 }
945 mutex_unlock(&dev->device_lock);
946 return length;
947
948 unlock_dev:
949 mutex_unlock(&dev->device_lock);
950 mei_free_cb_private(write_cb);
951 return rets;
952 }
953
954
955 /**
956 * mei_ioctl - the IOCTL function
957 *
958 * @file: pointer to file structure
959 * @cmd: ioctl command
960 * @data: pointer to mei message structure
961 *
962 * returns 0 on success , <0 on error
963 */
964 static long mei_ioctl(struct file *file, unsigned int cmd, unsigned long data)
965 {
966 struct mei_device *dev;
967 struct mei_cl *cl = file->private_data;
968 struct mei_connect_client_data *connect_data = NULL;
969 int rets;
970
971 if (cmd != IOCTL_MEI_CONNECT_CLIENT)
972 return -EINVAL;
973
974 if (WARN_ON(!cl || !cl->dev))
975 return -ENODEV;
976
977 dev = cl->dev;
978
979 dev_dbg(&dev->pdev->dev, "IOCTL cmd = 0x%x", cmd);
980
981 mutex_lock(&dev->device_lock);
982 if (dev->mei_state != MEI_ENABLED) {
983 rets = -ENODEV;
984 goto out;
985 }
986
987 dev_dbg(&dev->pdev->dev, ": IOCTL_MEI_CONNECT_CLIENT.\n");
988
989 connect_data = kzalloc(sizeof(struct mei_connect_client_data),
990 GFP_KERNEL);
991 if (!connect_data) {
992 rets = -ENOMEM;
993 goto out;
994 }
995 dev_dbg(&dev->pdev->dev, "copy connect data from user\n");
996 if (copy_from_user(connect_data, (char __user *)data,
997 sizeof(struct mei_connect_client_data))) {
998 dev_dbg(&dev->pdev->dev, "failed to copy data from userland\n");
999 rets = -EFAULT;
1000 goto out;
1001 }
1002 rets = mei_ioctl_connect_client(file, connect_data);
1003
1004 /* if all is ok, copying the data back to user. */
1005 if (rets)
1006 goto out;
1007
1008 dev_dbg(&dev->pdev->dev, "copy connect data to user\n");
1009 if (copy_to_user((char __user *)data, connect_data,
1010 sizeof(struct mei_connect_client_data))) {
1011 dev_dbg(&dev->pdev->dev, "failed to copy data to userland\n");
1012 rets = -EFAULT;
1013 goto out;
1014 }
1015
1016 out:
1017 kfree(connect_data);
1018 mutex_unlock(&dev->device_lock);
1019 return rets;
1020 }
1021
1022 /**
1023 * mei_compat_ioctl - the compat IOCTL function
1024 *
1025 * @file: pointer to file structure
1026 * @cmd: ioctl command
1027 * @data: pointer to mei message structure
1028 *
1029 * returns 0 on success , <0 on error
1030 */
1031 #ifdef CONFIG_COMPAT
1032 static long mei_compat_ioctl(struct file *file,
1033 unsigned int cmd, unsigned long data)
1034 {
1035 return mei_ioctl(file, cmd, (unsigned long)compat_ptr(data));
1036 }
1037 #endif
1038
1039
1040 /**
1041 * mei_poll - the poll function
1042 *
1043 * @file: pointer to file structure
1044 * @wait: pointer to poll_table structure
1045 *
1046 * returns poll mask
1047 */
1048 static unsigned int mei_poll(struct file *file, poll_table *wait)
1049 {
1050 struct mei_cl *cl = file->private_data;
1051 struct mei_device *dev;
1052 unsigned int mask = 0;
1053
1054 if (WARN_ON(!cl || !cl->dev))
1055 return mask;
1056
1057 dev = cl->dev;
1058
1059 mutex_lock(&dev->device_lock);
1060
1061 if (dev->mei_state != MEI_ENABLED)
1062 goto out;
1063
1064
1065 if (cl == &dev->iamthif_cl) {
1066 mutex_unlock(&dev->device_lock);
1067 poll_wait(file, &dev->iamthif_cl.wait, wait);
1068 mutex_lock(&dev->device_lock);
1069 if (dev->iamthif_state == MEI_IAMTHIF_READ_COMPLETE &&
1070 dev->iamthif_file_object == file) {
1071 mask |= (POLLIN | POLLRDNORM);
1072 dev_dbg(&dev->pdev->dev, "run next amthi cb\n");
1073 mei_run_next_iamthif_cmd(dev);
1074 }
1075 goto out;
1076 }
1077
1078 mutex_unlock(&dev->device_lock);
1079 poll_wait(file, &cl->tx_wait, wait);
1080 mutex_lock(&dev->device_lock);
1081 if (MEI_WRITE_COMPLETE == cl->writing_state)
1082 mask |= (POLLIN | POLLRDNORM);
1083
1084 out:
1085 mutex_unlock(&dev->device_lock);
1086 return mask;
1087 }
1088
1089 #ifdef CONFIG_PM
1090 static int mei_pci_suspend(struct device *device)
1091 {
1092 struct pci_dev *pdev = to_pci_dev(device);
1093 struct mei_device *dev = pci_get_drvdata(pdev);
1094 int err;
1095
1096 if (!dev)
1097 return -ENODEV;
1098 mutex_lock(&dev->device_lock);
1099 /* Stop watchdog if exists */
1100 err = mei_wd_stop(dev, true);
1101 /* Set new mei state */
1102 if (dev->mei_state == MEI_ENABLED ||
1103 dev->mei_state == MEI_RECOVERING_FROM_RESET) {
1104 dev->mei_state = MEI_POWER_DOWN;
1105 mei_reset(dev, 0);
1106 }
1107 mutex_unlock(&dev->device_lock);
1108
1109 free_irq(pdev->irq, dev);
1110 pci_disable_msi(pdev);
1111
1112 return err;
1113 }
1114
1115 static int mei_pci_resume(struct device *device)
1116 {
1117 struct pci_dev *pdev = to_pci_dev(device);
1118 struct mei_device *dev;
1119 int err;
1120
1121 dev = pci_get_drvdata(pdev);
1122 if (!dev)
1123 return -ENODEV;
1124
1125 pci_enable_msi(pdev);
1126
1127 /* request and enable interrupt */
1128 if (pci_dev_msi_enabled(pdev))
1129 err = request_threaded_irq(pdev->irq,
1130 NULL,
1131 mei_interrupt_thread_handler,
1132 0, mei_driver_name, dev);
1133 else
1134 err = request_threaded_irq(pdev->irq,
1135 mei_interrupt_quick_handler,
1136 mei_interrupt_thread_handler,
1137 IRQF_SHARED, mei_driver_name, dev);
1138
1139 if (err) {
1140 printk(KERN_ERR "mei: Request_irq failure. irq = %d\n",
1141 pdev->irq);
1142 return err;
1143 }
1144
1145 mutex_lock(&dev->device_lock);
1146 dev->mei_state = MEI_POWER_UP;
1147 mei_reset(dev, 1);
1148 mutex_unlock(&dev->device_lock);
1149
1150 /* Start watchdog if stopped in suspend */
1151 if (dev->wd_timeout) {
1152 mei_wd_start_setup(dev);
1153 dev->wd_due_counter = 1;
1154 schedule_delayed_work(&dev->wd_work, HZ);
1155 }
1156 return err;
1157 }
1158 static SIMPLE_DEV_PM_OPS(mei_pm_ops, mei_pci_suspend, mei_pci_resume);
1159 #define MEI_PM_OPS (&mei_pm_ops)
1160 #else
1161 #define MEI_PM_OPS NULL
1162 #endif /* CONFIG_PM */
1163 /*
1164 * PCI driver structure
1165 */
1166 static struct pci_driver mei_driver = {
1167 .name = mei_driver_name,
1168 .id_table = mei_pci_tbl,
1169 .probe = mei_probe,
1170 .remove = __devexit_p(mei_remove),
1171 .shutdown = __devexit_p(mei_remove),
1172 .driver.pm = MEI_PM_OPS,
1173 };
1174
1175 /*
1176 * file operations structure will be used for mei char device.
1177 */
1178 static const struct file_operations mei_fops = {
1179 .owner = THIS_MODULE,
1180 .read = mei_read,
1181 .unlocked_ioctl = mei_ioctl,
1182 #ifdef CONFIG_COMPAT
1183 .compat_ioctl = mei_compat_ioctl,
1184 #endif
1185 .open = mei_open,
1186 .release = mei_release,
1187 .write = mei_write,
1188 .poll = mei_poll,
1189 };
1190
1191 /**
1192 * mei_registration_cdev - sets up the cdev structure for mei device.
1193 *
1194 * @dev: char device struct
1195 * @hminor: minor number for registration char device
1196 * @fops: file operations structure
1197 *
1198 * returns 0 on success, <0 on failure.
1199 */
1200 static int mei_registration_cdev(struct cdev *dev, int hminor,
1201 const struct file_operations *fops)
1202 {
1203 int ret, devno = MKDEV(mei_major, hminor);
1204
1205 cdev_init(dev, fops);
1206 dev->owner = THIS_MODULE;
1207 ret = cdev_add(dev, devno, 1);
1208 /* Fail gracefully if need be */
1209 if (ret)
1210 printk(KERN_ERR "mei: Error %d registering mei device %d\n",
1211 ret, hminor);
1212 return ret;
1213 }
1214
1215 /**
1216 * mei_register_cdev - registers mei char device
1217 *
1218 * returns 0 on success, <0 on failure.
1219 */
1220 static int mei_register_cdev(void)
1221 {
1222 int ret;
1223 dev_t dev;
1224
1225 /* registration of char devices */
1226 ret = alloc_chrdev_region(&dev, MEI_MINORS_BASE, MEI_MINORS_COUNT,
1227 MEI_DRIVER_NAME);
1228 if (ret) {
1229 printk(KERN_ERR "mei: Error allocating char device region.\n");
1230 return ret;
1231 }
1232
1233 mei_major = MAJOR(dev);
1234
1235 ret = mei_registration_cdev(&mei_cdev, MEI_MINOR_NUMBER,
1236 &mei_fops);
1237 if (ret)
1238 unregister_chrdev_region(MKDEV(mei_major, MEI_MINORS_BASE),
1239 MEI_MINORS_COUNT);
1240
1241 return ret;
1242 }
1243
1244 /**
1245 * mei_unregister_cdev - unregisters mei char device
1246 */
1247 static void mei_unregister_cdev(void)
1248 {
1249 cdev_del(&mei_cdev);
1250 unregister_chrdev_region(MKDEV(mei_major, MEI_MINORS_BASE),
1251 MEI_MINORS_COUNT);
1252 }
1253
1254 /**
1255 * mei_sysfs_device_create - adds device entry to sysfs
1256 *
1257 * returns 0 on success, <0 on failure.
1258 */
1259 static int mei_sysfs_device_create(void)
1260 {
1261 struct class *class;
1262 void *tmphdev;
1263 int err;
1264
1265 class = class_create(THIS_MODULE, MEI_DRIVER_NAME);
1266 if (IS_ERR(class)) {
1267 err = PTR_ERR(class);
1268 printk(KERN_ERR "mei: Error creating mei class.\n");
1269 goto err_out;
1270 }
1271
1272 tmphdev = device_create(class, NULL, mei_cdev.dev, NULL,
1273 MEI_DEV_NAME);
1274 if (IS_ERR(tmphdev)) {
1275 err = PTR_ERR(tmphdev);
1276 goto err_destroy;
1277 }
1278
1279 mei_class = class;
1280 return 0;
1281
1282 err_destroy:
1283 class_destroy(class);
1284 err_out:
1285 return err;
1286 }
1287
1288 /**
1289 * mei_sysfs_device_remove - unregisters the device entry on sysfs
1290 */
1291 static void mei_sysfs_device_remove(void)
1292 {
1293 if (IS_ERR_OR_NULL(mei_class))
1294 return;
1295
1296 device_destroy(mei_class, mei_cdev.dev);
1297 class_destroy(mei_class);
1298 }
1299
1300 /**
1301 * mei_init_module - Driver Registration Routine
1302 *
1303 * mei_init_module is the first routine called when the driver is
1304 * loaded. All it does is to register with the PCI subsystem.
1305 *
1306 * returns 0 on success, <0 on failure.
1307 */
1308 static int __init mei_init_module(void)
1309 {
1310 int ret;
1311
1312 pr_debug("mei: %s - version %s\n",
1313 mei_driver_string, mei_driver_version);
1314 /* init pci module */
1315 ret = pci_register_driver(&mei_driver);
1316 if (ret < 0) {
1317 printk(KERN_ERR "mei: Error registering driver.\n");
1318 goto end;
1319 }
1320
1321 ret = mei_register_cdev();
1322 if (ret)
1323 goto unregister_pci;
1324
1325 ret = mei_sysfs_device_create();
1326 if (ret)
1327 goto unregister_cdev;
1328
1329 return ret;
1330
1331 unregister_cdev:
1332 mei_unregister_cdev();
1333 unregister_pci:
1334 pci_unregister_driver(&mei_driver);
1335 end:
1336 return ret;
1337 }
1338
1339 module_init(mei_init_module);
1340
1341 /**
1342 * mei_exit_module - Driver Exit Cleanup Routine
1343 *
1344 * mei_exit_module is called just before the driver is removed
1345 * from memory.
1346 */
1347 static void __exit mei_exit_module(void)
1348 {
1349 mei_sysfs_device_remove();
1350 mei_unregister_cdev();
1351 pci_unregister_driver(&mei_driver);
1352
1353 pr_debug("mei: Driver unloaded successfully.\n");
1354 }
1355
1356 module_exit(mei_exit_module);
1357
1358
1359 MODULE_AUTHOR("Intel Corporation");
1360 MODULE_DESCRIPTION("Intel(R) Management Engine Interface");
1361 MODULE_LICENSE("GPL v2");
1362 MODULE_VERSION(MEI_DRIVER_VERSION);
linux-next