This source file includes following definitions.
- smb_word_op
- secocec_adap_enable
- secocec_adap_log_addr
- secocec_adap_transmit
- secocec_tx_done
- secocec_rx_done
- secocec_ir_probe
- secocec_ir_rx
- secocec_ir_rx
- secocec_ir_probe
- secocec_irq_handler
- secocec_cec_find_hdmi_dev
- secocec_acpi_probe
- secocec_probe
- secocec_remove
- secocec_suspend
- secocec_resume
1
2
3
4
5
6
7
8
9
10 #include <linux/module.h>
11 #include <linux/acpi.h>
12 #include <linux/delay.h>
13 #include <linux/dmi.h>
14 #include <linux/gpio/consumer.h>
15 #include <linux/gpio.h>
16 #include <linux/interrupt.h>
17 #include <linux/pci.h>
18 #include <linux/platform_device.h>
19
20
21 #include <media/cec-notifier.h>
22
23 #include "seco-cec.h"
24
25 struct secocec_data {
26 struct device *dev;
27 struct platform_device *pdev;
28 struct cec_adapter *cec_adap;
29 struct cec_notifier *notifier;
30 struct rc_dev *ir;
31 char ir_input_phys[32];
32 int irq;
33 };
34
35 #define smb_wr16(cmd, data) smb_word_op(CMD_WORD_DATA, SECOCEC_MICRO_ADDRESS, \
36 cmd, data, SMBUS_WRITE, NULL)
37 #define smb_rd16(cmd, res) smb_word_op(CMD_WORD_DATA, SECOCEC_MICRO_ADDRESS, \
38 cmd, 0, SMBUS_READ, res)
39
40 static int smb_word_op(short data_format, u16 slave_addr, u8 cmd, u16 data,
41 u8 operation, u16 *result)
42 {
43 unsigned int count;
44 short _data_format;
45 int status = 0;
46
47 switch (data_format) {
48 case CMD_BYTE_DATA:
49 _data_format = BRA_SMB_CMD_BYTE_DATA;
50 break;
51 case CMD_WORD_DATA:
52 _data_format = BRA_SMB_CMD_WORD_DATA;
53 break;
54 default:
55 return -EINVAL;
56 }
57
58
59 for (count = 0; count <= SMBTIMEOUT; ++count) {
60 if (!(inb(HSTS) & BRA_INUSE_STS))
61 break;
62 udelay(SMB_POLL_UDELAY);
63 }
64
65 if (count > SMBTIMEOUT)
66
67 outb(0xff, HSTS);
68
69 outb(0x00, HCNT);
70 outb((u8)(slave_addr & 0xfe) | operation, XMIT_SLVA);
71 outb(cmd, HCMD);
72 inb(HCNT);
73
74 if (operation == SMBUS_WRITE) {
75 outb((u8)data, HDAT0);
76 outb((u8)(data >> 8), HDAT1);
77 }
78
79 outb(BRA_START + _data_format, HCNT);
80
81 for (count = 0; count <= SMBTIMEOUT; count++) {
82 if (!(inb(HSTS) & BRA_HOST_BUSY))
83 break;
84 udelay(SMB_POLL_UDELAY);
85 }
86
87 if (count > SMBTIMEOUT) {
88 status = -EBUSY;
89 goto err;
90 }
91
92 if (inb(HSTS) & BRA_HSTS_ERR_MASK) {
93 status = -EIO;
94 goto err;
95 }
96
97 if (operation == SMBUS_READ)
98 *result = ((inb(HDAT0) & 0xff) + ((inb(HDAT1) & 0xff) << 8));
99
100 err:
101 outb(0xff, HSTS);
102 return status;
103 }
104
105 static int secocec_adap_enable(struct cec_adapter *adap, bool enable)
106 {
107 struct secocec_data *cec = cec_get_drvdata(adap);
108 struct device *dev = cec->dev;
109 u16 val = 0;
110 int status;
111
112 if (enable) {
113
114 status = smb_rd16(SECOCEC_STATUS_REG_1, &val);
115 if (status)
116 goto err;
117
118 status = smb_wr16(SECOCEC_STATUS_REG_1, val);
119 if (status)
120 goto err;
121
122
123 status = smb_rd16(SECOCEC_ENABLE_REG_1, &val);
124 if (status)
125 goto err;
126
127 status = smb_wr16(SECOCEC_ENABLE_REG_1,
128 val | SECOCEC_ENABLE_REG_1_CEC);
129 if (status)
130 goto err;
131
132 dev_dbg(dev, "Device enabled");
133 } else {
134
135 status = smb_rd16(SECOCEC_STATUS_REG_1, &val);
136 status = smb_wr16(SECOCEC_STATUS_REG_1, val);
137
138
139 status = smb_rd16(SECOCEC_ENABLE_REG_1, &val);
140 status = smb_wr16(SECOCEC_ENABLE_REG_1, val &
141 ~SECOCEC_ENABLE_REG_1_CEC &
142 ~SECOCEC_ENABLE_REG_1_IR);
143
144 dev_dbg(dev, "Device disabled");
145 }
146
147 return 0;
148 err:
149 return status;
150 }
151
152 static int secocec_adap_log_addr(struct cec_adapter *adap, u8 logical_addr)
153 {
154 u16 enable_val = 0;
155 int status;
156
157
158 status = smb_rd16(SECOCEC_ENABLE_REG_1, &enable_val);
159 if (status)
160 return status;
161
162 status = smb_wr16(SECOCEC_ENABLE_REG_1,
163 enable_val & ~SECOCEC_ENABLE_REG_1_CEC);
164 if (status)
165 return status;
166
167
168
169
170 status = smb_wr16(SECOCEC_DEVICE_LA, logical_addr & 0xf);
171 if (status)
172 return status;
173
174
175 status = smb_wr16(SECOCEC_ENABLE_REG_1,
176 enable_val | SECOCEC_ENABLE_REG_1_CEC);
177 if (status)
178 return status;
179
180 return 0;
181 }
182
183 static int secocec_adap_transmit(struct cec_adapter *adap, u8 attempts,
184 u32 signal_free_time, struct cec_msg *msg)
185 {
186 u16 payload_len, payload_id_len, destination, val = 0;
187 u8 *payload_msg;
188 int status;
189 u8 i;
190
191
192 payload_id_len = msg->len - 1;
193
194
195 status = smb_wr16(SECOCEC_WRITE_DATA_LENGTH, payload_id_len);
196 if (status)
197 goto err;
198
199
200 if (payload_id_len > 0) {
201 status = smb_wr16(SECOCEC_WRITE_OPERATION_ID, msg->msg[1]);
202 if (status)
203 goto err;
204 }
205
206 if (payload_id_len > 1) {
207
208 payload_len = msg->len - 2;
209 payload_msg = &msg->msg[2];
210
211
212 for (i = 0; i < payload_len; i += 2) {
213
214 val = payload_msg[i + 1] << 8;
215
216
217 val |= payload_msg[i];
218
219 status = smb_wr16(SECOCEC_WRITE_DATA_00 + i / 2, val);
220 if (status)
221 goto err;
222 }
223 }
224
225 destination = msg->msg[0];
226 status = smb_wr16(SECOCEC_WRITE_BYTE0, destination);
227 if (status)
228 goto err;
229
230 return 0;
231
232 err:
233 return status;
234 }
235
236 static void secocec_tx_done(struct cec_adapter *adap, u16 status_val)
237 {
238 if (status_val & SECOCEC_STATUS_TX_ERROR_MASK) {
239 if (status_val & SECOCEC_STATUS_TX_NACK_ERROR)
240 cec_transmit_attempt_done(adap, CEC_TX_STATUS_NACK);
241 else
242 cec_transmit_attempt_done(adap, CEC_TX_STATUS_ERROR);
243 } else {
244 cec_transmit_attempt_done(adap, CEC_TX_STATUS_OK);
245 }
246
247
248 status_val = SECOCEC_STATUS_TX_ERROR_MASK |
249 SECOCEC_STATUS_MSG_SENT_MASK |
250 SECOCEC_STATUS_TX_NACK_ERROR;
251 smb_wr16(SECOCEC_STATUS, status_val);
252 }
253
254 static void secocec_rx_done(struct cec_adapter *adap, u16 status_val)
255 {
256 struct secocec_data *cec = cec_get_drvdata(adap);
257 struct device *dev = cec->dev;
258 struct cec_msg msg = { };
259 bool flag_overflow = false;
260 u8 payload_len, i = 0;
261 u8 *payload_msg;
262 u16 val = 0;
263 int status;
264
265 if (status_val & SECOCEC_STATUS_RX_OVERFLOW_MASK) {
266
267 dev_warn(dev, "Received more than 16 bytes. Discarding");
268 flag_overflow = true;
269 }
270
271 if (status_val & SECOCEC_STATUS_RX_ERROR_MASK) {
272 dev_warn(dev, "Message received with errors. Discarding");
273 status = -EIO;
274 goto rxerr;
275 }
276
277
278 status = smb_rd16(SECOCEC_READ_DATA_LENGTH, &val);
279 if (status)
280 return;
281
282
283 msg.len = min(val + 1, CEC_MAX_MSG_SIZE);
284
285
286 status = smb_rd16(SECOCEC_READ_BYTE0, &val);
287 if (status)
288 return;
289
290
291 msg.msg[0] = val;
292
293
294 status = smb_rd16(SECOCEC_READ_OPERATION_ID, &val);
295 if (status)
296 return;
297
298 msg.msg[1] = val;
299
300
301 if (msg.len > 1) {
302 payload_len = msg.len - 2;
303 payload_msg = &msg.msg[2];
304
305
306 for (i = 0; i < payload_len; i += 2) {
307 status = smb_rd16(SECOCEC_READ_DATA_00 + i / 2, &val);
308 if (status)
309 return;
310
311
312 payload_msg[i] = val & 0x00ff;
313
314
315 payload_msg[i + 1] = (val & 0xff00) >> 8;
316 }
317 }
318
319 cec_received_msg(cec->cec_adap, &msg);
320
321
322 status_val = SECOCEC_STATUS_MSG_RECEIVED_MASK;
323 if (flag_overflow)
324 status_val |= SECOCEC_STATUS_RX_OVERFLOW_MASK;
325
326 status = smb_wr16(SECOCEC_STATUS, status_val);
327
328 return;
329
330 rxerr:
331
332 status_val = SECOCEC_STATUS_MSG_RECEIVED_MASK |
333 SECOCEC_STATUS_RX_ERROR_MASK;
334 if (flag_overflow)
335 status_val |= SECOCEC_STATUS_RX_OVERFLOW_MASK;
336 smb_wr16(SECOCEC_STATUS, status_val);
337 }
338
339 static const struct cec_adap_ops secocec_cec_adap_ops = {
340
341 .adap_enable = secocec_adap_enable,
342 .adap_log_addr = secocec_adap_log_addr,
343 .adap_transmit = secocec_adap_transmit,
344 };
345
346 #ifdef CONFIG_VIDEO_SECO_RC
347 static int secocec_ir_probe(void *priv)
348 {
349 struct secocec_data *cec = priv;
350 struct device *dev = cec->dev;
351 int status;
352 u16 val;
353
354
355 cec->ir = devm_rc_allocate_device(dev, RC_DRIVER_SCANCODE);
356 if (!cec->ir)
357 return -ENOMEM;
358
359 snprintf(cec->ir_input_phys, sizeof(cec->ir_input_phys),
360 "%s/input0", dev_name(dev));
361
362 cec->ir->device_name = dev_name(dev);
363 cec->ir->input_phys = cec->ir_input_phys;
364 cec->ir->input_id.bustype = BUS_HOST;
365 cec->ir->input_id.vendor = 0;
366 cec->ir->input_id.product = 0;
367 cec->ir->input_id.version = 1;
368 cec->ir->driver_name = SECOCEC_DEV_NAME;
369 cec->ir->allowed_protocols = RC_PROTO_BIT_RC5;
370 cec->ir->priv = cec;
371 cec->ir->map_name = RC_MAP_HAUPPAUGE;
372 cec->ir->timeout = MS_TO_NS(100);
373
374
375 status = smb_rd16(SECOCEC_STATUS_REG_1, &val);
376 if (status != 0)
377 goto err;
378
379 status = smb_wr16(SECOCEC_STATUS_REG_1, val);
380 if (status != 0)
381 goto err;
382
383
384 status = smb_rd16(SECOCEC_ENABLE_REG_1, &val);
385 if (status != 0)
386 goto err;
387
388 status = smb_wr16(SECOCEC_ENABLE_REG_1,
389 val | SECOCEC_ENABLE_REG_1_IR);
390 if (status != 0)
391 goto err;
392
393 dev_dbg(dev, "IR enabled");
394
395 status = devm_rc_register_device(dev, cec->ir);
396
397 if (status) {
398 dev_err(dev, "Failed to prepare input device");
399 cec->ir = NULL;
400 goto err;
401 }
402
403 return 0;
404
405 err:
406 smb_rd16(SECOCEC_ENABLE_REG_1, &val);
407
408 smb_wr16(SECOCEC_ENABLE_REG_1,
409 val & ~SECOCEC_ENABLE_REG_1_IR);
410
411 dev_dbg(dev, "IR disabled");
412 return status;
413 }
414
415 static int secocec_ir_rx(struct secocec_data *priv)
416 {
417 struct secocec_data *cec = priv;
418 struct device *dev = cec->dev;
419 u16 val, status, key, addr, toggle;
420
421 if (!cec->ir)
422 return -ENODEV;
423
424 status = smb_rd16(SECOCEC_IR_READ_DATA, &val);
425 if (status != 0)
426 goto err;
427
428 key = val & SECOCEC_IR_COMMAND_MASK;
429 addr = (val & SECOCEC_IR_ADDRESS_MASK) >> SECOCEC_IR_ADDRESS_SHL;
430 toggle = (val & SECOCEC_IR_TOGGLE_MASK) >> SECOCEC_IR_TOGGLE_SHL;
431
432 rc_keydown(cec->ir, RC_PROTO_RC5, RC_SCANCODE_RC5(addr, key), toggle);
433
434 dev_dbg(dev, "IR key pressed: 0x%02x addr 0x%02x toggle 0x%02x", key,
435 addr, toggle);
436
437 return 0;
438
439 err:
440 dev_err(dev, "IR Receive message failed (%d)", status);
441 return -EIO;
442 }
443 #else
444 static void secocec_ir_rx(struct secocec_data *priv)
445 {
446 }
447
448 static int secocec_ir_probe(void *priv)
449 {
450 return 0;
451 }
452 #endif
453
454 static irqreturn_t secocec_irq_handler(int irq, void *priv)
455 {
456 struct secocec_data *cec = priv;
457 struct device *dev = cec->dev;
458 u16 status_val, cec_val, val = 0;
459 int status;
460
461
462 status = smb_rd16(SECOCEC_STATUS_REG_1, &status_val);
463 if (status)
464 goto err;
465
466 if (status_val & SECOCEC_STATUS_REG_1_CEC) {
467
468 status = smb_rd16(SECOCEC_STATUS, &cec_val);
469 if (status)
470 goto err;
471
472 if (cec_val & SECOCEC_STATUS_MSG_RECEIVED_MASK)
473 secocec_rx_done(cec->cec_adap, cec_val);
474
475 if (cec_val & SECOCEC_STATUS_MSG_SENT_MASK)
476 secocec_tx_done(cec->cec_adap, cec_val);
477
478 if ((~cec_val & SECOCEC_STATUS_MSG_SENT_MASK) &&
479 (~cec_val & SECOCEC_STATUS_MSG_RECEIVED_MASK))
480 dev_warn_once(dev,
481 "Message not received or sent, but interrupt fired");
482
483 val = SECOCEC_STATUS_REG_1_CEC;
484 }
485
486 if (status_val & SECOCEC_STATUS_REG_1_IR) {
487 val |= SECOCEC_STATUS_REG_1_IR;
488
489 secocec_ir_rx(cec);
490 }
491
492
493 status = smb_wr16(SECOCEC_STATUS_REG_1, val);
494 if (status)
495 goto err;
496
497 return IRQ_HANDLED;
498
499 err:
500 dev_err_once(dev, "IRQ: R/W SMBus operation failed (%d)", status);
501
502
503 val = SECOCEC_STATUS_REG_1_CEC | SECOCEC_STATUS_REG_1_IR;
504 smb_wr16(SECOCEC_STATUS_REG_1, val);
505
506 return IRQ_HANDLED;
507 }
508
509 struct cec_dmi_match {
510 const char *sys_vendor;
511 const char *product_name;
512 const char *devname;
513 const char *conn;
514 };
515
516 static const struct cec_dmi_match secocec_dmi_match_table[] = {
517
518 { "SECO", "UDOO x86", "0000:00:02.0", "Port B" },
519 };
520
521 static struct device *secocec_cec_find_hdmi_dev(struct device *dev,
522 const char **conn)
523 {
524 int i;
525
526 for (i = 0 ; i < ARRAY_SIZE(secocec_dmi_match_table) ; ++i) {
527 const struct cec_dmi_match *m = &secocec_dmi_match_table[i];
528
529 if (dmi_match(DMI_SYS_VENDOR, m->sys_vendor) &&
530 dmi_match(DMI_PRODUCT_NAME, m->product_name)) {
531 struct device *d;
532
533
534 d = bus_find_device_by_name(&pci_bus_type, NULL,
535 m->devname);
536 if (!d)
537 return ERR_PTR(-EPROBE_DEFER);
538
539 put_device(d);
540 *conn = m->conn;
541 return d;
542 }
543 }
544
545 return ERR_PTR(-EINVAL);
546 }
547
548 static int secocec_acpi_probe(struct secocec_data *sdev)
549 {
550 struct device *dev = sdev->dev;
551 struct gpio_desc *gpio;
552 int irq = 0;
553
554 gpio = devm_gpiod_get(dev, NULL, GPIOF_IN);
555 if (IS_ERR(gpio)) {
556 dev_err(dev, "Cannot request interrupt gpio");
557 return PTR_ERR(gpio);
558 }
559
560 irq = gpiod_to_irq(gpio);
561 if (irq < 0) {
562 dev_err(dev, "Cannot find valid irq");
563 return -ENODEV;
564 }
565 dev_dbg(dev, "irq-gpio is bound to IRQ %d", irq);
566
567 sdev->irq = irq;
568
569 return 0;
570 }
571
572 static int secocec_probe(struct platform_device *pdev)
573 {
574 struct secocec_data *secocec;
575 struct device *dev = &pdev->dev;
576 struct device *hdmi_dev;
577 const char *conn = NULL;
578 int ret;
579 u16 val;
580
581 hdmi_dev = secocec_cec_find_hdmi_dev(&pdev->dev, &conn);
582 if (IS_ERR(hdmi_dev))
583 return PTR_ERR(hdmi_dev);
584
585 secocec = devm_kzalloc(dev, sizeof(*secocec), GFP_KERNEL);
586 if (!secocec)
587 return -ENOMEM;
588
589 dev_set_drvdata(dev, secocec);
590
591
592 if (!request_muxed_region(BRA_SMB_BASE_ADDR, 7, "CEC00001")) {
593 dev_err(dev, "Request memory region failed");
594 return -ENXIO;
595 }
596
597 secocec->pdev = pdev;
598 secocec->dev = dev;
599
600 if (!has_acpi_companion(dev)) {
601 dev_dbg(dev, "Cannot find any ACPI companion");
602 ret = -ENODEV;
603 goto err;
604 }
605
606 ret = secocec_acpi_probe(secocec);
607 if (ret) {
608 dev_err(dev, "Cannot assign gpio to IRQ");
609 ret = -ENODEV;
610 goto err;
611 }
612
613
614 ret = smb_rd16(SECOCEC_VERSION, &val);
615 if (ret) {
616 dev_err(dev, "Cannot check fw version");
617 goto err;
618 }
619 if (val < SECOCEC_LATEST_FW) {
620 dev_err(dev, "CEC Firmware not supported (v.%04x). Use ver > v.%04x",
621 val, SECOCEC_LATEST_FW);
622 ret = -EINVAL;
623 goto err;
624 }
625
626 ret = devm_request_threaded_irq(dev,
627 secocec->irq,
628 NULL,
629 secocec_irq_handler,
630 IRQF_TRIGGER_RISING | IRQF_ONESHOT,
631 dev_name(&pdev->dev), secocec);
632
633 if (ret) {
634 dev_err(dev, "Cannot request IRQ %d", secocec->irq);
635 ret = -EIO;
636 goto err;
637 }
638
639
640 secocec->cec_adap = cec_allocate_adapter(&secocec_cec_adap_ops,
641 secocec,
642 dev_name(dev),
643 CEC_CAP_DEFAULTS |
644 CEC_CAP_CONNECTOR_INFO,
645 SECOCEC_MAX_ADDRS);
646
647 if (IS_ERR(secocec->cec_adap)) {
648 ret = PTR_ERR(secocec->cec_adap);
649 goto err;
650 }
651
652 secocec->notifier = cec_notifier_cec_adap_register(hdmi_dev, conn,
653 secocec->cec_adap);
654 if (!secocec->notifier) {
655 ret = -ENOMEM;
656 goto err_delete_adapter;
657 }
658
659 ret = cec_register_adapter(secocec->cec_adap, dev);
660 if (ret)
661 goto err_notifier;
662
663 ret = secocec_ir_probe(secocec);
664 if (ret)
665 goto err_notifier;
666
667 platform_set_drvdata(pdev, secocec);
668
669 dev_dbg(dev, "Device registered");
670
671 return ret;
672
673 err_notifier:
674 cec_notifier_cec_adap_unregister(secocec->notifier);
675 err_delete_adapter:
676 cec_delete_adapter(secocec->cec_adap);
677 err:
678 release_region(BRA_SMB_BASE_ADDR, 7);
679 dev_err(dev, "%s device probe failed\n", dev_name(dev));
680
681 return ret;
682 }
683
684 static int secocec_remove(struct platform_device *pdev)
685 {
686 struct secocec_data *secocec = platform_get_drvdata(pdev);
687 u16 val;
688
689 if (secocec->ir) {
690 smb_rd16(SECOCEC_ENABLE_REG_1, &val);
691
692 smb_wr16(SECOCEC_ENABLE_REG_1, val & ~SECOCEC_ENABLE_REG_1_IR);
693
694 dev_dbg(&pdev->dev, "IR disabled");
695 }
696 cec_notifier_cec_adap_unregister(secocec->notifier);
697 cec_unregister_adapter(secocec->cec_adap);
698
699 release_region(BRA_SMB_BASE_ADDR, 7);
700
701 dev_dbg(&pdev->dev, "CEC device removed");
702
703 return 0;
704 }
705
706 #ifdef CONFIG_PM_SLEEP
707 static int secocec_suspend(struct device *dev)
708 {
709 int status;
710 u16 val;
711
712 dev_dbg(dev, "Device going to suspend, disabling");
713
714
715 status = smb_rd16(SECOCEC_STATUS_REG_1, &val);
716 if (status)
717 goto err;
718
719 status = smb_wr16(SECOCEC_STATUS_REG_1, val);
720 if (status)
721 goto err;
722
723
724 status = smb_rd16(SECOCEC_ENABLE_REG_1, &val);
725 if (status)
726 goto err;
727
728 status = smb_wr16(SECOCEC_ENABLE_REG_1, val &
729 ~SECOCEC_ENABLE_REG_1_CEC & ~SECOCEC_ENABLE_REG_1_IR);
730 if (status)
731 goto err;
732
733 return 0;
734
735 err:
736 dev_err(dev, "Suspend failed (err: %d)", status);
737 return status;
738 }
739
740 static int secocec_resume(struct device *dev)
741 {
742 int status;
743 u16 val;
744
745 dev_dbg(dev, "Resuming device from suspend");
746
747
748 status = smb_rd16(SECOCEC_STATUS_REG_1, &val);
749 if (status)
750 goto err;
751
752 status = smb_wr16(SECOCEC_STATUS_REG_1, val);
753 if (status)
754 goto err;
755
756
757 status = smb_rd16(SECOCEC_ENABLE_REG_1, &val);
758 if (status)
759 goto err;
760
761 status = smb_wr16(SECOCEC_ENABLE_REG_1, val | SECOCEC_ENABLE_REG_1_CEC);
762 if (status)
763 goto err;
764
765 dev_dbg(dev, "Device resumed from suspend");
766
767 return 0;
768
769 err:
770 dev_err(dev, "Resume failed (err: %d)", status);
771 return status;
772 }
773
774 static SIMPLE_DEV_PM_OPS(secocec_pm_ops, secocec_suspend, secocec_resume);
775 #define SECOCEC_PM_OPS (&secocec_pm_ops)
776 #else
777 #define SECOCEC_PM_OPS NULL
778 #endif
779
780 #ifdef CONFIG_ACPI
781 static const struct acpi_device_id secocec_acpi_match[] = {
782 {"CEC00001", 0},
783 {},
784 };
785
786 MODULE_DEVICE_TABLE(acpi, secocec_acpi_match);
787 #endif
788
789 static struct platform_driver secocec_driver = {
790 .driver = {
791 .name = SECOCEC_DEV_NAME,
792 .acpi_match_table = ACPI_PTR(secocec_acpi_match),
793 .pm = SECOCEC_PM_OPS,
794 },
795 .probe = secocec_probe,
796 .remove = secocec_remove,
797 };
798
799 module_platform_driver(secocec_driver);
800
801 MODULE_DESCRIPTION("SECO CEC X86 Driver");
802 MODULE_AUTHOR("Ettore Chimenti <ek5.chimenti@gmail.com>");
803 MODULE_LICENSE("Dual BSD/GPL");