?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
staging: brcm80211: remove brcms_b_dotxstatus wrapper function
[zen-stable.git] / drivers / staging / mei / main.c
blobeb05c36f45d4181f0fb7c4df36165a9a9dd87e8f
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 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->timer_work, mei_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->timer_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 /* Unregistering watchdog device */
245 if (dev->wd_interface_reg)
246 watchdog_unregister_device(&amt_wd_dev);
247
248 /* remove entry if already in list */
249 dev_dbg(&pdev->dev, "list del iamthif and wd file list.\n");
250 mei_remove_client_from_file_list(dev, dev->wd_cl.host_client_id);
251 mei_remove_client_from_file_list(dev, dev->iamthif_cl.host_client_id);
252
253 dev->iamthif_current_cb = NULL;
254 dev->me_clients_num = 0;
255
256 mutex_unlock(&dev->device_lock);
257
258 flush_scheduled_work();
259
260 /* disable interrupts */
261 mei_disable_interrupts(dev);
262
263 free_irq(pdev->irq, dev);
264 pci_disable_msi(pdev);
265 pci_set_drvdata(pdev, NULL);
266
267 if (dev->mem_addr)
268 pci_iounmap(pdev, dev->mem_addr);
269
270 kfree(dev);
271
272 pci_release_regions(pdev);
273 pci_disable_device(pdev);
274 }
275
276 /**
277 * mei_clear_list - removes all callbacks associated with file
278 * from mei_cb_list
279 *
280 * @dev: device structure.
281 * @file: file structure
282 * @mei_cb_list: callbacks list
283 *
284 * mei_clear_list is called to clear resources associated with file
285 * when application calls close function or Ctrl-C was pressed
286 *
287 * returns true if callback removed from the list, false otherwise
288 */
289 static bool mei_clear_list(struct mei_device *dev,
290 struct file *file, struct list_head *mei_cb_list)
291 {
292 struct mei_cl_cb *cb_pos = NULL;
293 struct mei_cl_cb *cb_next = NULL;
294 struct file *file_temp;
295 bool removed = false;
296
297 /* list all list member */
298 list_for_each_entry_safe(cb_pos, cb_next, mei_cb_list, cb_list) {
299 file_temp = (struct file *)cb_pos->file_object;
300 /* check if list member associated with a file */
301 if (file_temp == file) {
302 /* remove member from the list */
303 list_del(&cb_pos->cb_list);
304 /* check if cb equal to current iamthif cb */
305 if (dev->iamthif_current_cb == cb_pos) {
306 dev->iamthif_current_cb = NULL;
307 /* send flow control to iamthif client */
308 mei_send_flow_control(dev, &dev->iamthif_cl);
309 }
310 /* free all allocated buffers */
311 mei_free_cb_private(cb_pos);
312 cb_pos = NULL;
313 removed = true;
314 }
315 }
316 return removed;
317 }
318
319 /**
320 * mei_clear_lists - removes all callbacks associated with file
321 *
322 * @dev: device structure
323 * @file: file structure
324 *
325 * mei_clear_lists is called to clear resources associated with file
326 * when application calls close function or Ctrl-C was pressed
327 *
328 * returns true if callback removed from the list, false otherwise
329 */
330 static bool mei_clear_lists(struct mei_device *dev, struct file *file)
331 {
332 bool removed = false;
333
334 /* remove callbacks associated with a file */
335 mei_clear_list(dev, file, &dev->amthi_cmd_list.mei_cb.cb_list);
336 if (mei_clear_list(dev, file,
337 &dev->amthi_read_complete_list.mei_cb.cb_list))
338 removed = true;
339
340 mei_clear_list(dev, file, &dev->ctrl_rd_list.mei_cb.cb_list);
341
342 if (mei_clear_list(dev, file, &dev->ctrl_wr_list.mei_cb.cb_list))
343 removed = true;
344
345 if (mei_clear_list(dev, file, &dev->write_waiting_list.mei_cb.cb_list))
346 removed = true;
347
348 if (mei_clear_list(dev, file, &dev->write_list.mei_cb.cb_list))
349 removed = true;
350
351 /* check if iamthif_current_cb not NULL */
352 if (dev->iamthif_current_cb && !removed) {
353 /* check file and iamthif current cb association */
354 if (dev->iamthif_current_cb->file_object == file) {
355 /* remove cb */
356 mei_free_cb_private(dev->iamthif_current_cb);
357 dev->iamthif_current_cb = NULL;
358 removed = true;
359 }
360 }
361 return removed;
362 }
363 /**
364 * find_read_list_entry - find read list entry
365 *
366 * @dev: device structure
367 * @file: pointer to file structure
368 *
369 * returns cb on success, NULL on error
370 */
371 static struct mei_cl_cb *find_read_list_entry(
372 struct mei_device *dev,
373 struct mei_cl *cl)
374 {
375 struct mei_cl_cb *cb_pos = NULL;
376 struct mei_cl_cb *cb_next = NULL;
377
378 if (!dev->read_list.status &&
379 !list_empty(&dev->read_list.mei_cb.cb_list)) {
380
381 dev_dbg(&dev->pdev->dev, "remove read_list CB\n");
382 list_for_each_entry_safe(cb_pos, cb_next,
383 &dev->read_list.mei_cb.cb_list, cb_list) {
384 struct mei_cl *cl_temp;
385 cl_temp = (struct mei_cl *)cb_pos->file_private;
386
387 if (mei_cl_cmp_id(cl, cl_temp))
388 return cb_pos;
389 }
390 }
391 return NULL;
392 }
393
394 /**
395 * mei_open - the open function
396 *
397 * @inode: pointer to inode structure
398 * @file: pointer to file structure
399 *
400 * returns 0 on success, <0 on error
401 */
402 static int mei_open(struct inode *inode, struct file *file)
403 {
404 struct mei_cl *cl;
405 int if_num = iminor(inode), err;
406 struct mei_device *dev;
407
408 err = -ENODEV;
409 if (!mei_device)
410 goto out;
411
412 dev = pci_get_drvdata(mei_device);
413 if (if_num != MEI_MINOR_NUMBER || !dev)
414 goto out;
415
416 mutex_lock(&dev->device_lock);
417 err = -ENOMEM;
418 cl = mei_cl_allocate(dev);
419 if (!cl)
420 goto out_unlock;
421
422 err = -ENODEV;
423 if (dev->mei_state != MEI_ENABLED) {
424 dev_dbg(&dev->pdev->dev, "mei_state != MEI_ENABLED mei_state= %d\n",
425 dev->mei_state);
426 goto out_unlock;
427 }
428 err = -EMFILE;
429 if (dev->open_handle_count >= MEI_MAX_OPEN_HANDLE_COUNT)
430 goto out_unlock;
431
432 cl->host_client_id = find_first_zero_bit(dev->host_clients_map,
433 MEI_CLIENTS_MAX);
434 if (cl->host_client_id > MEI_CLIENTS_MAX)
435 goto out_unlock;
436
437 dev_dbg(&dev->pdev->dev, "client_id = %d\n", cl->host_client_id);
438
439 dev->open_handle_count++;
440 list_add_tail(&cl->link, &dev->file_list);
441
442 set_bit(cl->host_client_id, dev->host_clients_map);
443 cl->state = MEI_FILE_INITIALIZING;
444 cl->sm_state = 0;
445
446 file->private_data = cl;
447 mutex_unlock(&dev->device_lock);
448
449 return 0;
450
451 out_unlock:
452 mutex_unlock(&dev->device_lock);
453 kfree(cl);
454 out:
455 return err;
456 }
457
458 /**
459 * mei_release - the release function
460 *
461 * @inode: pointer to inode structure
462 * @file: pointer to file structure
463 *
464 * returns 0 on success, <0 on error
465 */
466 static int mei_release(struct inode *inode, struct file *file)
467 {
468 struct mei_cl *cl = file->private_data;
469 struct mei_cl_cb *cb;
470 struct mei_device *dev;
471 int rets = 0;
472
473 if (WARN_ON(!cl || !cl->dev))
474 return -ENODEV;
475
476 dev = cl->dev;
477
478 mutex_lock(&dev->device_lock);
479 if (cl != &dev->iamthif_cl) {
480 if (cl->state == MEI_FILE_CONNECTED) {
481 cl->state = MEI_FILE_DISCONNECTING;
482 dev_dbg(&dev->pdev->dev,
483 "disconnecting client host client = %d, "
484 "ME client = %d\n",
485 cl->host_client_id,
486 cl->me_client_id);
487 rets = mei_disconnect_host_client(dev, cl);
488 }
489 mei_cl_flush_queues(cl);
490 dev_dbg(&dev->pdev->dev, "remove client host client = %d, ME client = %d\n",
491 cl->host_client_id,
492 cl->me_client_id);
493
494 if (dev->open_handle_count > 0) {
495 clear_bit(cl->host_client_id,
496 dev->host_clients_map);
497 dev->open_handle_count--;
498 }
499 mei_remove_client_from_file_list(dev, cl->host_client_id);
500
501 /* free read cb */
502 cb = NULL;
503 if (cl->read_cb) {
504 cb = find_read_list_entry(dev, cl);
505 /* Remove entry from read list */
506 if (cb)
507 list_del(&cb->cb_list);
508
509 cb = cl->read_cb;
510 cl->read_cb = NULL;
511 }
512
513 file->private_data = NULL;
514
515 if (cb) {
516 mei_free_cb_private(cb);
517 cb = NULL;
518 }
519
520 kfree(cl);
521 } else {
522 if (dev->open_handle_count > 0)
523 dev->open_handle_count--;
524
525 if (dev->iamthif_file_object == file &&
526 dev->iamthif_state != MEI_IAMTHIF_IDLE) {
527
528 dev_dbg(&dev->pdev->dev, "amthi canceled iamthif state %d\n",
529 dev->iamthif_state);
530 dev->iamthif_canceled = true;
531 if (dev->iamthif_state == MEI_IAMTHIF_READ_COMPLETE) {
532 dev_dbg(&dev->pdev->dev, "run next amthi iamthif cb\n");
533 mei_run_next_iamthif_cmd(dev);
534 }
535 }
536
537 if (mei_clear_lists(dev, file))
538 dev->iamthif_state = MEI_IAMTHIF_IDLE;
539
540 }
541 mutex_unlock(&dev->device_lock);
542 return rets;
543 }
544
545
546 /**
547 * mei_read - the read function.
548 *
549 * @file: pointer to file structure
550 * @ubuf: pointer to user buffer
551 * @length: buffer length
552 * @offset: data offset in buffer
553 *
554 * returns >=0 data length on success , <0 on error
555 */
556 static ssize_t mei_read(struct file *file, char __user *ubuf,
557 size_t length, loff_t *offset)
558 {
559 struct mei_cl *cl = file->private_data;
560 struct mei_cl_cb *cb_pos = NULL;
561 struct mei_cl_cb *cb = NULL;
562 struct mei_device *dev;
563 int i;
564 int rets;
565 int err;
566
567
568 if (WARN_ON(!cl || !cl->dev))
569 return -ENODEV;
570
571 dev = cl->dev;
572
573 mutex_lock(&dev->device_lock);
574 if (dev->mei_state != MEI_ENABLED) {
575 rets = -ENODEV;
576 goto out;
577 }
578
579 if ((cl->sm_state & MEI_WD_STATE_INDEPENDENCE_MSG_SENT) == 0) {
580 /* Do not allow to read watchdog client */
581 i = mei_find_me_client_index(dev, mei_wd_guid);
582 if (i >= 0) {
583 struct mei_me_client *me_client = &dev->me_clients[i];
584
585 if (cl->me_client_id == me_client->client_id) {
586 rets = -EBADF;
587 goto out;
588 }
589 }
590 } else {
591 cl->sm_state &= ~MEI_WD_STATE_INDEPENDENCE_MSG_SENT;
592 }
593
594 if (cl == &dev->iamthif_cl) {
595 rets = amthi_read(dev, file, ubuf, length, offset);
596 goto out;
597 }
598
599 if (cl->read_cb && cl->read_cb->information > *offset) {
600 cb = cl->read_cb;
601 goto copy_buffer;
602 } else if (cl->read_cb && cl->read_cb->information > 0 &&
603 cl->read_cb->information <= *offset) {
604 cb = cl->read_cb;
605 rets = 0;
606 goto free;
607 } else if ((!cl->read_cb || !cl->read_cb->information) &&
608 *offset > 0) {
609 /*Offset needs to be cleaned for contingous reads*/
610 *offset = 0;
611 rets = 0;
612 goto out;
613 }
614
615 err = mei_start_read(dev, cl);
616 if (err && err != -EBUSY) {
617 dev_dbg(&dev->pdev->dev,
618 "mei start read failure with status = %d\n", err);
619 rets = err;
620 goto out;
621 }
622
623 if (MEI_READ_COMPLETE != cl->reading_state &&
624 !waitqueue_active(&cl->rx_wait)) {
625 if (file->f_flags & O_NONBLOCK) {
626 rets = -EAGAIN;
627 goto out;
628 }
629
630 mutex_unlock(&dev->device_lock);
631
632 if (wait_event_interruptible(cl->rx_wait,
633 (MEI_READ_COMPLETE == cl->reading_state ||
634 MEI_FILE_INITIALIZING == cl->state ||
635 MEI_FILE_DISCONNECTED == cl->state ||
636 MEI_FILE_DISCONNECTING == cl->state))) {
637 if (signal_pending(current))
638 return -EINTR;
639 return -ERESTARTSYS;
640 }
641
642 mutex_lock(&dev->device_lock);
643 if (MEI_FILE_INITIALIZING == cl->state ||
644 MEI_FILE_DISCONNECTED == cl->state ||
645 MEI_FILE_DISCONNECTING == cl->state) {
646 rets = -EBUSY;
647 goto out;
648 }
649 }
650
651 cb = cl->read_cb;
652
653 if (!cb) {
654 rets = -ENODEV;
655 goto out;
656 }
657 if (cl->reading_state != MEI_READ_COMPLETE) {
658 rets = 0;
659 goto out;
660 }
661 /* now copy the data to user space */
662 copy_buffer:
663 dev_dbg(&dev->pdev->dev, "cb->response_buffer size - %d\n",
664 cb->response_buffer.size);
665 dev_dbg(&dev->pdev->dev, "cb->information - %lu\n",
666 cb->information);
667 if (length == 0 || ubuf == NULL || *offset > cb->information) {
668 rets = -EMSGSIZE;
669 goto free;
670 }
671
672 /* length is being turncated to PAGE_SIZE, however, */
673 /* information size may be longer */
674 length = min_t(size_t, length, (cb->information - *offset));
675
676 if (copy_to_user(ubuf,
677 cb->response_buffer.data + *offset,
678 length)) {
679 rets = -EFAULT;
680 goto free;
681 }
682
683 rets = length;
684 *offset += length;
685 if ((unsigned long)*offset < cb->information)
686 goto out;
687
688 free:
689 cb_pos = find_read_list_entry(dev, cl);
690 /* Remove entry from read list */
691 if (cb_pos)
692 list_del(&cb_pos->cb_list);
693 mei_free_cb_private(cb);
694 cl->reading_state = MEI_IDLE;
695 cl->read_cb = NULL;
696 cl->read_pending = 0;
697 out:
698 dev_dbg(&dev->pdev->dev, "end mei read rets= %d\n", rets);
699 mutex_unlock(&dev->device_lock);
700 return rets;
701 }
702
703 /**
704 * mei_write - the write function.
705 *
706 * @file: pointer to file structure
707 * @ubuf: pointer to user buffer
708 * @length: buffer length
709 * @offset: data offset in buffer
710 *
711 * returns >=0 data length on success , <0 on error
712 */
713 static ssize_t mei_write(struct file *file, const char __user *ubuf,
714 size_t length, loff_t *offset)
715 {
716 struct mei_cl *cl = file->private_data;
717 struct mei_cl_cb *write_cb = NULL;
718 struct mei_msg_hdr mei_hdr;
719 struct mei_device *dev;
720 unsigned long timeout = 0;
721 int rets;
722 int i;
723
724 if (WARN_ON(!cl || !cl->dev))
725 return -ENODEV;
726
727 dev = cl->dev;
728
729 mutex_lock(&dev->device_lock);
730
731 if (dev->mei_state != MEI_ENABLED) {
732 mutex_unlock(&dev->device_lock);
733 return -ENODEV;
734 }
735
736 if (cl == &dev->iamthif_cl) {
737 write_cb = find_amthi_read_list_entry(dev, file);
738
739 if (write_cb) {
740 timeout = write_cb->read_time +
741 msecs_to_jiffies(IAMTHIF_READ_TIMER);
742
743 if (time_after(jiffies, timeout) ||
744 cl->reading_state == MEI_READ_COMPLETE) {
745 *offset = 0;
746 list_del(&write_cb->cb_list);
747 mei_free_cb_private(write_cb);
748 write_cb = NULL;
749 }
750 }
751 }
752
753 /* free entry used in read */
754 if (cl->reading_state == MEI_READ_COMPLETE) {
755 *offset = 0;
756 write_cb = find_read_list_entry(dev, cl);
757 if (write_cb) {
758 list_del(&write_cb->cb_list);
759 mei_free_cb_private(write_cb);
760 write_cb = NULL;
761 cl->reading_state = MEI_IDLE;
762 cl->read_cb = NULL;
763 cl->read_pending = 0;
764 }
765 } else if (cl->reading_state == MEI_IDLE &&
766 !cl->read_pending)
767 *offset = 0;
768
769
770 write_cb = kzalloc(sizeof(struct mei_cl_cb), GFP_KERNEL);
771 if (!write_cb) {
772 mutex_unlock(&dev->device_lock);
773 return -ENOMEM;
774 }
775
776 write_cb->file_object = file;
777 write_cb->file_private = cl;
778 write_cb->request_buffer.data = kmalloc(length, GFP_KERNEL);
779 rets = -ENOMEM;
780 if (!write_cb->request_buffer.data)
781 goto unlock_dev;
782
783 dev_dbg(&dev->pdev->dev, "length =%d\n", (int) length);
784
785 rets = -EFAULT;
786 if (copy_from_user(write_cb->request_buffer.data, ubuf, length))
787 goto unlock_dev;
788
789 cl->sm_state = 0;
790 if (length == 4 &&
791 ((memcmp(mei_wd_state_independence_msg[0],
792 write_cb->request_buffer.data, 4) == 0) ||
793 (memcmp(mei_wd_state_independence_msg[1],
794 write_cb->request_buffer.data, 4) == 0) ||
795 (memcmp(mei_wd_state_independence_msg[2],
796 write_cb->request_buffer.data, 4) == 0)))
797 cl->sm_state |= MEI_WD_STATE_INDEPENDENCE_MSG_SENT;
798
799 INIT_LIST_HEAD(&write_cb->cb_list);
800 if (cl == &dev->iamthif_cl) {
801 write_cb->response_buffer.data =
802 kmalloc(dev->iamthif_mtu, GFP_KERNEL);
803 if (!write_cb->response_buffer.data) {
804 rets = -ENOMEM;
805 goto unlock_dev;
806 }
807 if (dev->mei_state != MEI_ENABLED) {
808 rets = -ENODEV;
809 goto unlock_dev;
810 }
811 for (i = 0; i < dev->me_clients_num; i++) {
812 if (dev->me_clients[i].client_id ==
813 dev->iamthif_cl.me_client_id)
814 break;
815 }
816
817 if (WARN_ON(dev->me_clients[i].client_id != cl->me_client_id)) {
818 rets = -ENODEV;
819 goto unlock_dev;
820 }
821 if (i == dev->me_clients_num ||
822 (dev->me_clients[i].client_id !=
823 dev->iamthif_cl.me_client_id)) {
824 rets = -ENODEV;
825 goto unlock_dev;
826 } else if (length > dev->me_clients[i].props.max_msg_length ||
827 length <= 0) {
828 rets = -EMSGSIZE;
829 goto unlock_dev;
830 }
831
832 write_cb->response_buffer.size = dev->iamthif_mtu;
833 write_cb->major_file_operations = MEI_IOCTL;
834 write_cb->information = 0;
835 write_cb->request_buffer.size = length;
836 if (dev->iamthif_cl.state != MEI_FILE_CONNECTED) {
837 rets = -ENODEV;
838 goto unlock_dev;
839 }
840
841 if (!list_empty(&dev->amthi_cmd_list.mei_cb.cb_list) ||
842 dev->iamthif_state != MEI_IAMTHIF_IDLE) {
843 dev_dbg(&dev->pdev->dev, "amthi_state = %d\n",
844 (int) dev->iamthif_state);
845 dev_dbg(&dev->pdev->dev, "add amthi cb to amthi cmd waiting list\n");
846 list_add_tail(&write_cb->cb_list,
847 &dev->amthi_cmd_list.mei_cb.cb_list);
848 rets = length;
849 } else {
850 dev_dbg(&dev->pdev->dev, "call amthi write\n");
851 rets = amthi_write(dev, write_cb);
852
853 if (rets) {
854 dev_dbg(&dev->pdev->dev, "amthi write failed with status = %d\n",
855 rets);
856 goto unlock_dev;
857 }
858 rets = length;
859 }
860 mutex_unlock(&dev->device_lock);
861 return rets;
862 }
863
864 write_cb->major_file_operations = MEI_WRITE;
865 /* make sure information is zero before we start */
866
867 write_cb->information = 0;
868 write_cb->request_buffer.size = length;
869
870 dev_dbg(&dev->pdev->dev, "host client = %d, ME client = %d\n",
871 cl->host_client_id, cl->me_client_id);
872 if (cl->state != MEI_FILE_CONNECTED) {
873 rets = -ENODEV;
874 dev_dbg(&dev->pdev->dev, "host client = %d, is not connected to ME client = %d",
875 cl->host_client_id,
876 cl->me_client_id);
877 goto unlock_dev;
878 }
879 for (i = 0; i < dev->me_clients_num; i++) {
880 if (dev->me_clients[i].client_id ==
881 cl->me_client_id)
882 break;
883 }
884 if (WARN_ON(dev->me_clients[i].client_id != cl->me_client_id)) {
885 rets = -ENODEV;
886 goto unlock_dev;
887 }
888 if (i == dev->me_clients_num) {
889 rets = -ENODEV;
890 goto unlock_dev;
891 }
892 if (length > dev->me_clients[i].props.max_msg_length || length <= 0) {
893 rets = -EINVAL;
894 goto unlock_dev;
895 }
896 write_cb->file_private = cl;
897
898 rets = mei_flow_ctrl_creds(dev, cl);
899 if (rets < 0)
900 goto unlock_dev;
901
902 if (rets && dev->mei_host_buffer_is_empty) {
903 rets = 0;
904 dev->mei_host_buffer_is_empty = false;
905 if (length > ((((dev->host_hw_state & H_CBD) >> 24) *
906 sizeof(u32)) - sizeof(struct mei_msg_hdr))) {
907
908 mei_hdr.length =
909 (((dev->host_hw_state & H_CBD) >> 24) *
910 sizeof(u32)) -
911 sizeof(struct mei_msg_hdr);
912 mei_hdr.msg_complete = 0;
913 } else {
914 mei_hdr.length = length;
915 mei_hdr.msg_complete = 1;
916 }
917 mei_hdr.host_addr = cl->host_client_id;
918 mei_hdr.me_addr = cl->me_client_id;
919 mei_hdr.reserved = 0;
920 dev_dbg(&dev->pdev->dev, "call mei_write_message header=%08x.\n",
921 *((u32 *) &mei_hdr));
922 if (!mei_write_message(dev, &mei_hdr,
923 (unsigned char *) (write_cb->request_buffer.data),
924 mei_hdr.length)) {
925 rets = -ENODEV;
926 goto unlock_dev;
927 }
928 cl->writing_state = MEI_WRITING;
929 write_cb->information = mei_hdr.length;
930 if (mei_hdr.msg_complete) {
931 if (mei_flow_ctrl_reduce(dev, cl)) {
932 rets = -ENODEV;
933 goto unlock_dev;
934 }
935 list_add_tail(&write_cb->cb_list,
936 &dev->write_waiting_list.mei_cb.cb_list);
937 } else {
938 list_add_tail(&write_cb->cb_list,
939 &dev->write_list.mei_cb.cb_list);
940 }
941
942 } else {
943
944 write_cb->information = 0;
945 cl->writing_state = MEI_WRITING;
946 list_add_tail(&write_cb->cb_list,
947 &dev->write_list.mei_cb.cb_list);
948 }
949 mutex_unlock(&dev->device_lock);
950 return length;
951
952 unlock_dev:
953 mutex_unlock(&dev->device_lock);
954 mei_free_cb_private(write_cb);
955 return rets;
956 }
957
958
959 /**
960 * mei_ioctl - the IOCTL function
961 *
962 * @file: pointer to file structure
963 * @cmd: ioctl command
964 * @data: pointer to mei message structure
965 *
966 * returns 0 on success , <0 on error
967 */
968 static long mei_ioctl(struct file *file, unsigned int cmd, unsigned long data)
969 {
970 struct mei_device *dev;
971 struct mei_cl *cl = file->private_data;
972 struct mei_connect_client_data *connect_data = NULL;
973 int rets;
974
975 if (cmd != IOCTL_MEI_CONNECT_CLIENT)
976 return -EINVAL;
977
978 if (WARN_ON(!cl || !cl->dev))
979 return -ENODEV;
980
981 dev = cl->dev;
982
983 dev_dbg(&dev->pdev->dev, "IOCTL cmd = 0x%x", cmd);
984
985 mutex_lock(&dev->device_lock);
986 if (dev->mei_state != MEI_ENABLED) {
987 rets = -ENODEV;
988 goto out;
989 }
990
991 dev_dbg(&dev->pdev->dev, ": IOCTL_MEI_CONNECT_CLIENT.\n");
992
993 connect_data = kzalloc(sizeof(struct mei_connect_client_data),
994 GFP_KERNEL);
995 if (!connect_data) {
996 rets = -ENOMEM;
997 goto out;
998 }
999 dev_dbg(&dev->pdev->dev, "copy connect data from user\n");
1000 if (copy_from_user(connect_data, (char __user *)data,
1001 sizeof(struct mei_connect_client_data))) {
1002 dev_dbg(&dev->pdev->dev, "failed to copy data from userland\n");
1003 rets = -EFAULT;
1004 goto out;
1005 }
1006 rets = mei_ioctl_connect_client(file, connect_data);
1007
1008 /* if all is ok, copying the data back to user. */
1009 if (rets)
1010 goto out;
1011
1012 dev_dbg(&dev->pdev->dev, "copy connect data to user\n");
1013 if (copy_to_user((char __user *)data, connect_data,
1014 sizeof(struct mei_connect_client_data))) {
1015 dev_dbg(&dev->pdev->dev, "failed to copy data to userland\n");
1016 rets = -EFAULT;
1017 goto out;
1018 }
1019
1020 out:
1021 kfree(connect_data);
1022 mutex_unlock(&dev->device_lock);
1023 return rets;
1024 }
1025
1026 /**
1027 * mei_compat_ioctl - the compat IOCTL function
1028 *
1029 * @file: pointer to file structure
1030 * @cmd: ioctl command
1031 * @data: pointer to mei message structure
1032 *
1033 * returns 0 on success , <0 on error
1034 */
1035 #ifdef CONFIG_COMPAT
1036 static long mei_compat_ioctl(struct file *file,
1037 unsigned int cmd, unsigned long data)
1038 {
1039 return mei_ioctl(file, cmd, (unsigned long)compat_ptr(data));
1040 }
1041 #endif
1042
1043
1044 /**
1045 * mei_poll - the poll function
1046 *
1047 * @file: pointer to file structure
1048 * @wait: pointer to poll_table structure
1049 *
1050 * returns poll mask
1051 */
1052 static unsigned int mei_poll(struct file *file, poll_table *wait)
1053 {
1054 struct mei_cl *cl = file->private_data;
1055 struct mei_device *dev;
1056 unsigned int mask = 0;
1057
1058 if (WARN_ON(!cl || !cl->dev))
1059 return mask;
1060
1061 dev = cl->dev;
1062
1063 mutex_lock(&dev->device_lock);
1064
1065 if (dev->mei_state != MEI_ENABLED)
1066 goto out;
1067
1068
1069 if (cl == &dev->iamthif_cl) {
1070 mutex_unlock(&dev->device_lock);
1071 poll_wait(file, &dev->iamthif_cl.wait, wait);
1072 mutex_lock(&dev->device_lock);
1073 if (dev->iamthif_state == MEI_IAMTHIF_READ_COMPLETE &&
1074 dev->iamthif_file_object == file) {
1075 mask |= (POLLIN | POLLRDNORM);
1076 dev_dbg(&dev->pdev->dev, "run next amthi cb\n");
1077 mei_run_next_iamthif_cmd(dev);
1078 }
1079 goto out;
1080 }
1081
1082 mutex_unlock(&dev->device_lock);
1083 poll_wait(file, &cl->tx_wait, wait);
1084 mutex_lock(&dev->device_lock);
1085 if (MEI_WRITE_COMPLETE == cl->writing_state)
1086 mask |= (POLLIN | POLLRDNORM);
1087
1088 out:
1089 mutex_unlock(&dev->device_lock);
1090 return mask;
1091 }
1092
1093 #ifdef CONFIG_PM
1094 static int mei_pci_suspend(struct device *device)
1095 {
1096 struct pci_dev *pdev = to_pci_dev(device);
1097 struct mei_device *dev = pci_get_drvdata(pdev);
1098 int err;
1099
1100 if (!dev)
1101 return -ENODEV;
1102 mutex_lock(&dev->device_lock);
1103 /* Stop watchdog if exists */
1104 err = mei_wd_stop(dev, true);
1105 /* Set new mei state */
1106 if (dev->mei_state == MEI_ENABLED ||
1107 dev->mei_state == MEI_RECOVERING_FROM_RESET) {
1108 dev->mei_state = MEI_POWER_DOWN;
1109 mei_reset(dev, 0);
1110 }
1111 mutex_unlock(&dev->device_lock);
1112
1113 free_irq(pdev->irq, dev);
1114 pci_disable_msi(pdev);
1115
1116 return err;
1117 }
1118
1119 static int mei_pci_resume(struct device *device)
1120 {
1121 struct pci_dev *pdev = to_pci_dev(device);
1122 struct mei_device *dev;
1123 int err;
1124
1125 dev = pci_get_drvdata(pdev);
1126 if (!dev)
1127 return -ENODEV;
1128
1129 pci_enable_msi(pdev);
1130
1131 /* request and enable interrupt */
1132 if (pci_dev_msi_enabled(pdev))
1133 err = request_threaded_irq(pdev->irq,
1134 NULL,
1135 mei_interrupt_thread_handler,
1136 0, mei_driver_name, dev);
1137 else
1138 err = request_threaded_irq(pdev->irq,
1139 mei_interrupt_quick_handler,
1140 mei_interrupt_thread_handler,
1141 IRQF_SHARED, mei_driver_name, dev);
1142
1143 if (err) {
1144 printk(KERN_ERR "mei: Request_irq failure. irq = %d\n",
1145 pdev->irq);
1146 return err;
1147 }
1148
1149 mutex_lock(&dev->device_lock);
1150 dev->mei_state = MEI_POWER_UP;
1151 mei_reset(dev, 1);
1152 mutex_unlock(&dev->device_lock);
1153
1154 /* Start timer if stopped in suspend */
1155 schedule_delayed_work(&dev->timer_work, HZ);
1156
1157 return err;
1158 }
1159 static SIMPLE_DEV_PM_OPS(mei_pm_ops, mei_pci_suspend, mei_pci_resume);
1160 #define MEI_PM_OPS (&mei_pm_ops)
1161 #else
1162 #define MEI_PM_OPS NULL
1163 #endif /* CONFIG_PM */
1164 /*
1165 * PCI driver structure
1166 */
1167 static struct pci_driver mei_driver = {
1168 .name = mei_driver_name,
1169 .id_table = mei_pci_tbl,
1170 .probe = mei_probe,
1171 .remove = __devexit_p(mei_remove),
1172 .shutdown = __devexit_p(mei_remove),
1173 .driver.pm = MEI_PM_OPS,
1174 };
1175
1176 /*
1177 * file operations structure will be used for mei char device.
1178 */
1179 static const struct file_operations mei_fops = {
1180 .owner = THIS_MODULE,
1181 .read = mei_read,
1182 .unlocked_ioctl = mei_ioctl,
1183 #ifdef CONFIG_COMPAT
1184 .compat_ioctl = mei_compat_ioctl,
1185 #endif
1186 .open = mei_open,
1187 .release = mei_release,
1188 .write = mei_write,
1189 .poll = mei_poll,
1190 };
1191
1192 /**
1193 * mei_registration_cdev - sets up the cdev structure for mei device.
1194 *
1195 * @dev: char device struct
1196 * @hminor: minor number for registration char device
1197 * @fops: file operations structure
1198 *
1199 * returns 0 on success, <0 on failure.
1200 */
1201 static int mei_registration_cdev(struct cdev *dev, int hminor,
1202 const struct file_operations *fops)
1203 {
1204 int ret, devno = MKDEV(mei_major, hminor);
1205
1206 cdev_init(dev, fops);
1207 dev->owner = THIS_MODULE;
1208 ret = cdev_add(dev, devno, 1);
1209 /* Fail gracefully if need be */
1210 if (ret)
1211 printk(KERN_ERR "mei: Error %d registering mei device %d\n",
1212 ret, hminor);
1213 return ret;
1214 }
1215
1216 /**
1217 * mei_register_cdev - registers mei char device
1218 *
1219 * returns 0 on success, <0 on failure.
1220 */
1221 static int mei_register_cdev(void)
1222 {
1223 int ret;
1224 dev_t dev;
1225
1226 /* registration of char devices */
1227 ret = alloc_chrdev_region(&dev, MEI_MINORS_BASE, MEI_MINORS_COUNT,
1228 MEI_DRIVER_NAME);
1229 if (ret) {
1230 printk(KERN_ERR "mei: Error allocating char device region.\n");
1231 return ret;
1232 }
1233
1234 mei_major = MAJOR(dev);
1235
1236 ret = mei_registration_cdev(&mei_cdev, MEI_MINOR_NUMBER,
1237 &mei_fops);
1238 if (ret)
1239 unregister_chrdev_region(MKDEV(mei_major, MEI_MINORS_BASE),
1240 MEI_MINORS_COUNT);
1241
1242 return ret;
1243 }
1244
1245 /**
1246 * mei_unregister_cdev - unregisters mei char device
1247 */
1248 static void mei_unregister_cdev(void)
1249 {
1250 cdev_del(&mei_cdev);
1251 unregister_chrdev_region(MKDEV(mei_major, MEI_MINORS_BASE),
1252 MEI_MINORS_COUNT);
1253 }
1254
1255 /**
1256 * mei_sysfs_device_create - adds device entry to sysfs
1257 *
1258 * returns 0 on success, <0 on failure.
1259 */
1260 static int mei_sysfs_device_create(void)
1261 {
1262 struct class *class;
1263 void *tmphdev;
1264 int err;
1265
1266 class = class_create(THIS_MODULE, MEI_DRIVER_NAME);
1267 if (IS_ERR(class)) {
1268 err = PTR_ERR(class);
1269 printk(KERN_ERR "mei: Error creating mei class.\n");
1270 goto err_out;
1271 }
1272
1273 tmphdev = device_create(class, NULL, mei_cdev.dev, NULL,
1274 MEI_DEV_NAME);
1275 if (IS_ERR(tmphdev)) {
1276 err = PTR_ERR(tmphdev);
1277 goto err_destroy;
1278 }
1279
1280 mei_class = class;
1281 return 0;
1282
1283 err_destroy:
1284 class_destroy(class);
1285 err_out:
1286 return err;
1287 }
1288
1289 /**
1290 * mei_sysfs_device_remove - unregisters the device entry on sysfs
1291 */
1292 static void mei_sysfs_device_remove(void)
1293 {
1294 if (IS_ERR_OR_NULL(mei_class))
1295 return;
1296
1297 device_destroy(mei_class, mei_cdev.dev);
1298 class_destroy(mei_class);
1299 }
1300
1301 /**
1302 * mei_init_module - Driver Registration Routine
1303 *
1304 * mei_init_module is the first routine called when the driver is
1305 * loaded. All it does is to register with the PCI subsystem.
1306 *
1307 * returns 0 on success, <0 on failure.
1308 */
1309 static int __init mei_init_module(void)
1310 {
1311 int ret;
1312
1313 pr_debug("mei: %s - version %s\n",
1314 mei_driver_string, mei_driver_version);
1315 /* init pci module */
1316 ret = pci_register_driver(&mei_driver);
1317 if (ret < 0) {
1318 printk(KERN_ERR "mei: Error registering driver.\n");
1319 goto end;
1320 }
1321
1322 ret = mei_register_cdev();
1323 if (ret)
1324 goto unregister_pci;
1325
1326 ret = mei_sysfs_device_create();
1327 if (ret)
1328 goto unregister_cdev;
1329
1330 return ret;
1331
1332 unregister_cdev:
1333 mei_unregister_cdev();
1334 unregister_pci:
1335 pci_unregister_driver(&mei_driver);
1336 end:
1337 return ret;
1338 }
1339
1340 module_init(mei_init_module);
1341
1342 /**
1343 * mei_exit_module - Driver Exit Cleanup Routine
1344 *
1345 * mei_exit_module is called just before the driver is removed
1346 * from memory.
1347 */
1348 static void __exit mei_exit_module(void)
1349 {
1350 mei_sysfs_device_remove();
1351 mei_unregister_cdev();
1352 pci_unregister_driver(&mei_driver);
1353
1354 pr_debug("mei: Driver unloaded successfully.\n");
1355 }
1356
1357 module_exit(mei_exit_module);
1358
1359
1360 MODULE_AUTHOR("Intel Corporation");
1361 MODULE_DESCRIPTION("Intel(R) Management Engine Interface");
1362 MODULE_LICENSE("GPL v2");
1363 MODULE_VERSION(MEI_DRIVER_VERSION);