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