1
2
3
4
5
6
7
8
9#include <linux/module.h>
10#include <linux/ata.h>
11#include <linux/delay.h>
12#include <linux/device.h>
13#include <linux/errno.h>
14#include <linux/kernel.h>
15#include <linux/acpi.h>
16#include <linux/libata.h>
17#include <linux/pci.h>
18#include <scsi/scsi_device.h>
19#include "libata.h"
20
21#include <acpi/acpi_bus.h>
22
23unsigned int ata_acpi_gtf_filter = ATA_ACPI_FILTER_DEFAULT;
24module_param_named(acpi_gtf_filter, ata_acpi_gtf_filter, int, 0644);
25MODULE_PARM_DESC(acpi_gtf_filter, "filter mask for ACPI _GTF commands, set to filter out (0x1=set xfermode, 0x2=lock/freeze lock, 0x4=DIPM, 0x8=FPDMA non-zero offset, 0x10=FPDMA DMA Setup FIS auto-activate)");
26
27#define NO_PORT_MULT 0xffff
28#define SATA_ADR(root, pmp) (((root) << 16) | (pmp))
29
30#define REGS_PER_GTF 7
31struct ata_acpi_gtf {
32 u8 tf[REGS_PER_GTF];
33} __packed;
34
35
36
37
38static int is_pci_dev(struct device *dev)
39{
40 return (dev->bus == &pci_bus_type);
41}
42
43static void ata_acpi_clear_gtf(struct ata_device *dev)
44{
45 kfree(dev->gtf_cache);
46 dev->gtf_cache = NULL;
47}
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62void ata_acpi_associate_sata_port(struct ata_port *ap)
63{
64 WARN_ON(!(ap->flags & ATA_FLAG_ACPI_SATA));
65
66 if (!sata_pmp_attached(ap)) {
67 acpi_integer adr = SATA_ADR(ap->port_no, NO_PORT_MULT);
68
69 ap->link.device->acpi_handle =
70 acpi_get_child(ap->host->acpi_handle, adr);
71 } else {
72 struct ata_link *link;
73
74 ap->link.device->acpi_handle = NULL;
75
76 ata_for_each_link(link, ap, EDGE) {
77 acpi_integer adr = SATA_ADR(ap->port_no, link->pmp);
78
79 link->device->acpi_handle =
80 acpi_get_child(ap->host->acpi_handle, adr);
81 }
82 }
83}
84
85static void ata_acpi_associate_ide_port(struct ata_port *ap)
86{
87 int max_devices, i;
88
89 ap->acpi_handle = acpi_get_child(ap->host->acpi_handle, ap->port_no);
90 if (!ap->acpi_handle)
91 return;
92
93 max_devices = 1;
94 if (ap->flags & ATA_FLAG_SLAVE_POSS)
95 max_devices++;
96
97 for (i = 0; i < max_devices; i++) {
98 struct ata_device *dev = &ap->link.device[i];
99
100 dev->acpi_handle = acpi_get_child(ap->acpi_handle, i);
101 }
102
103 if (ata_acpi_gtm(ap, &ap->__acpi_init_gtm) == 0)
104 ap->pflags |= ATA_PFLAG_INIT_GTM_VALID;
105}
106
107
108static void ata_acpi_detach_device(struct ata_port *ap, struct ata_device *dev)
109{
110 if (dev)
111 dev->flags |= ATA_DFLAG_DETACH;
112 else {
113 struct ata_link *tlink;
114 struct ata_device *tdev;
115
116 ata_for_each_link(tlink, ap, EDGE)
117 ata_for_each_dev(tdev, tlink, ALL)
118 tdev->flags |= ATA_DFLAG_DETACH;
119 }
120
121 ata_port_schedule_eh(ap);
122}
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141static void ata_acpi_handle_hotplug(struct ata_port *ap, struct ata_device *dev,
142 u32 event)
143{
144 struct ata_eh_info *ehi = &ap->link.eh_info;
145 int wait = 0;
146 unsigned long flags;
147 acpi_handle handle;
148
149 if (dev)
150 handle = dev->acpi_handle;
151 else
152 handle = ap->acpi_handle;
153
154 spin_lock_irqsave(ap->lock, flags);
155
156
157
158
159
160 switch (event) {
161 case ACPI_NOTIFY_BUS_CHECK:
162 case ACPI_NOTIFY_DEVICE_CHECK:
163 ata_ehi_push_desc(ehi, "ACPI event");
164
165 ata_ehi_hotplugged(ehi);
166 ata_port_freeze(ap);
167 break;
168 case ACPI_NOTIFY_EJECT_REQUEST:
169 ata_ehi_push_desc(ehi, "ACPI event");
170
171 ata_acpi_detach_device(ap, dev);
172 wait = 1;
173 break;
174 }
175
176 spin_unlock_irqrestore(ap->lock, flags);
177
178 if (wait)
179 ata_port_wait_eh(ap);
180}
181
182static void ata_acpi_dev_notify_dock(acpi_handle handle, u32 event, void *data)
183{
184 struct ata_device *dev = data;
185
186 ata_acpi_handle_hotplug(dev->link->ap, dev, event);
187}
188
189static void ata_acpi_ap_notify_dock(acpi_handle handle, u32 event, void *data)
190{
191 struct ata_port *ap = data;
192
193 ata_acpi_handle_hotplug(ap, NULL, event);
194}
195
196static void ata_acpi_uevent(struct ata_port *ap, struct ata_device *dev,
197 u32 event)
198{
199 struct kobject *kobj = NULL;
200 char event_string[20];
201 char *envp[] = { event_string, NULL };
202
203 if (dev) {
204 if (dev->sdev)
205 kobj = &dev->sdev->sdev_gendev.kobj;
206 } else
207 kobj = &ap->dev->kobj;
208
209 if (kobj) {
210 snprintf(event_string, 20, "BAY_EVENT=%d", event);
211 kobject_uevent_env(kobj, KOBJ_CHANGE, envp);
212 }
213}
214
215static void ata_acpi_ap_uevent(acpi_handle handle, u32 event, void *data)
216{
217 ata_acpi_uevent(data, NULL, event);
218}
219
220static void ata_acpi_dev_uevent(acpi_handle handle, u32 event, void *data)
221{
222 struct ata_device *dev = data;
223 ata_acpi_uevent(dev->link->ap, dev, event);
224}
225
226static struct acpi_dock_ops ata_acpi_dev_dock_ops = {
227 .handler = ata_acpi_dev_notify_dock,
228 .uevent = ata_acpi_dev_uevent,
229};
230
231static struct acpi_dock_ops ata_acpi_ap_dock_ops = {
232 .handler = ata_acpi_ap_notify_dock,
233 .uevent = ata_acpi_ap_uevent,
234};
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249void ata_acpi_associate(struct ata_host *host)
250{
251 int i, j;
252
253 if (!is_pci_dev(host->dev) || libata_noacpi)
254 return;
255
256 host->acpi_handle = DEVICE_ACPI_HANDLE(host->dev);
257 if (!host->acpi_handle)
258 return;
259
260 for (i = 0; i < host->n_ports; i++) {
261 struct ata_port *ap = host->ports[i];
262
263 if (host->ports[0]->flags & ATA_FLAG_ACPI_SATA)
264 ata_acpi_associate_sata_port(ap);
265 else
266 ata_acpi_associate_ide_port(ap);
267
268 if (ap->acpi_handle) {
269
270 register_hotplug_dock_device(ap->acpi_handle,
271 &ata_acpi_ap_dock_ops, ap);
272 }
273
274 for (j = 0; j < ata_link_max_devices(&ap->link); j++) {
275 struct ata_device *dev = &ap->link.device[j];
276
277 if (dev->acpi_handle) {
278
279 register_hotplug_dock_device(dev->acpi_handle,
280 &ata_acpi_dev_dock_ops, dev);
281 }
282 }
283 }
284}
285
286
287
288
289
290
291
292
293
294
295
296void ata_acpi_dissociate(struct ata_host *host)
297{
298 int i;
299
300
301
302
303 for (i = 0; i < host->n_ports; i++) {
304 struct ata_port *ap = host->ports[i];
305 const struct ata_acpi_gtm *gtm = ata_acpi_init_gtm(ap);
306
307 if (ap->acpi_handle && gtm)
308 ata_acpi_stm(ap, gtm);
309 }
310}
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325int ata_acpi_gtm(struct ata_port *ap, struct ata_acpi_gtm *gtm)
326{
327 struct acpi_buffer output = { .length = ACPI_ALLOCATE_BUFFER };
328 union acpi_object *out_obj;
329 acpi_status status;
330 int rc = 0;
331
332 status = acpi_evaluate_object(ap->acpi_handle, "_GTM", NULL, &output);
333
334 rc = -ENOENT;
335 if (status == AE_NOT_FOUND)
336 goto out_free;
337
338 rc = -EINVAL;
339 if (ACPI_FAILURE(status)) {
340 ata_port_printk(ap, KERN_ERR,
341 "ACPI get timing mode failed (AE 0x%x)\n",
342 status);
343 goto out_free;
344 }
345
346 out_obj = output.pointer;
347 if (out_obj->type != ACPI_TYPE_BUFFER) {
348 ata_port_printk(ap, KERN_WARNING,
349 "_GTM returned unexpected object type 0x%x\n",
350 out_obj->type);
351
352 goto out_free;
353 }
354
355 if (out_obj->buffer.length != sizeof(struct ata_acpi_gtm)) {
356 ata_port_printk(ap, KERN_ERR,
357 "_GTM returned invalid length %d\n",
358 out_obj->buffer.length);
359 goto out_free;
360 }
361
362 memcpy(gtm, out_obj->buffer.pointer, sizeof(struct ata_acpi_gtm));
363 rc = 0;
364 out_free:
365 kfree(output.pointer);
366 return rc;
367}
368
369EXPORT_SYMBOL_GPL(ata_acpi_gtm);
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384int ata_acpi_stm(struct ata_port *ap, const struct ata_acpi_gtm *stm)
385{
386 acpi_status status;
387 struct ata_acpi_gtm stm_buf = *stm;
388 struct acpi_object_list input;
389 union acpi_object in_params[3];
390
391 in_params[0].type = ACPI_TYPE_BUFFER;
392 in_params[0].buffer.length = sizeof(struct ata_acpi_gtm);
393 in_params[0].buffer.pointer = (u8 *)&stm_buf;
394
395 in_params[1].type = ACPI_TYPE_BUFFER;
396 in_params[1].buffer.length = 512;
397 in_params[1].buffer.pointer = (u8 *)ap->link.device[0].id;
398 in_params[2].type = ACPI_TYPE_BUFFER;
399 in_params[2].buffer.length = 512;
400 in_params[2].buffer.pointer = (u8 *)ap->link.device[1].id;
401
402 input.count = 3;
403 input.pointer = in_params;
404
405 status = acpi_evaluate_object(ap->acpi_handle, "_STM", &input, NULL);
406
407 if (status == AE_NOT_FOUND)
408 return -ENOENT;
409 if (ACPI_FAILURE(status)) {
410 ata_port_printk(ap, KERN_ERR,
411 "ACPI set timing mode failed (status=0x%x)\n", status);
412 return -EINVAL;
413 }
414 return 0;
415}
416
417EXPORT_SYMBOL_GPL(ata_acpi_stm);
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439static int ata_dev_get_GTF(struct ata_device *dev, struct ata_acpi_gtf **gtf)
440{
441 struct ata_port *ap = dev->link->ap;
442 acpi_status status;
443 struct acpi_buffer output;
444 union acpi_object *out_obj;
445 int rc = 0;
446
447
448 if (dev->gtf_cache) {
449 out_obj = dev->gtf_cache;
450 goto done;
451 }
452
453
454 output.length = ACPI_ALLOCATE_BUFFER;
455 output.pointer = NULL;
456
457 if (ata_msg_probe(ap))
458 ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER: port#: %d\n",
459 __func__, ap->port_no);
460
461
462 status = acpi_evaluate_object(dev->acpi_handle, "_GTF", NULL, &output);
463 out_obj = dev->gtf_cache = output.pointer;
464
465 if (ACPI_FAILURE(status)) {
466 if (status != AE_NOT_FOUND) {
467 ata_dev_printk(dev, KERN_WARNING,
468 "_GTF evaluation failed (AE 0x%x)\n",
469 status);
470 rc = -EINVAL;
471 }
472 goto out_free;
473 }
474
475 if (!output.length || !output.pointer) {
476 if (ata_msg_probe(ap))
477 ata_dev_printk(dev, KERN_DEBUG, "%s: Run _GTF: "
478 "length or ptr is NULL (0x%llx, 0x%p)\n",
479 __func__,
480 (unsigned long long)output.length,
481 output.pointer);
482 rc = -EINVAL;
483 goto out_free;
484 }
485
486 if (out_obj->type != ACPI_TYPE_BUFFER) {
487 ata_dev_printk(dev, KERN_WARNING,
488 "_GTF unexpected object type 0x%x\n",
489 out_obj->type);
490 rc = -EINVAL;
491 goto out_free;
492 }
493
494 if (out_obj->buffer.length % REGS_PER_GTF) {
495 ata_dev_printk(dev, KERN_WARNING,
496 "unexpected _GTF length (%d)\n",
497 out_obj->buffer.length);
498 rc = -EINVAL;
499 goto out_free;
500 }
501
502 done:
503 rc = out_obj->buffer.length / REGS_PER_GTF;
504 if (gtf) {
505 *gtf = (void *)out_obj->buffer.pointer;
506 if (ata_msg_probe(ap))
507 ata_dev_printk(dev, KERN_DEBUG,
508 "%s: returning gtf=%p, gtf_count=%d\n",
509 __func__, *gtf, rc);
510 }
511 return rc;
512
513 out_free:
514 ata_acpi_clear_gtf(dev);
515 return rc;
516}
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531unsigned long ata_acpi_gtm_xfermask(struct ata_device *dev,
532 const struct ata_acpi_gtm *gtm)
533{
534 unsigned long xfer_mask = 0;
535 unsigned int type;
536 int unit;
537 u8 mode;
538
539
540 unit = dev->devno;
541 if (!(gtm->flags & 0x10))
542 unit = 0;
543
544
545 mode = ata_timing_cycle2mode(ATA_SHIFT_PIO, gtm->drive[unit].pio);
546 xfer_mask |= ata_xfer_mode2mask(mode);
547
548
549
550
551
552 if (!(gtm->flags & (1 << (2 * unit))))
553 type = ATA_SHIFT_MWDMA;
554 else
555 type = ATA_SHIFT_UDMA;
556
557 mode = ata_timing_cycle2mode(type, gtm->drive[unit].dma);
558 xfer_mask |= ata_xfer_mode2mask(mode);
559
560 return xfer_mask;
561}
562EXPORT_SYMBOL_GPL(ata_acpi_gtm_xfermask);
563
564
565
566
567
568
569
570
571int ata_acpi_cbl_80wire(struct ata_port *ap, const struct ata_acpi_gtm *gtm)
572{
573 struct ata_device *dev;
574
575 ata_for_each_dev(dev, &ap->link, ENABLED) {
576 unsigned long xfer_mask, udma_mask;
577
578 xfer_mask = ata_acpi_gtm_xfermask(dev, gtm);
579 ata_unpack_xfermask(xfer_mask, NULL, NULL, &udma_mask);
580
581 if (udma_mask & ~ATA_UDMA_MASK_40C)
582 return 1;
583 }
584
585 return 0;
586}
587EXPORT_SYMBOL_GPL(ata_acpi_cbl_80wire);
588
589static void ata_acpi_gtf_to_tf(struct ata_device *dev,
590 const struct ata_acpi_gtf *gtf,
591 struct ata_taskfile *tf)
592{
593 ata_tf_init(dev, tf);
594
595 tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
596 tf->protocol = ATA_PROT_NODATA;
597 tf->feature = gtf->tf[0];
598 tf->nsect = gtf->tf[1];
599 tf->lbal = gtf->tf[2];
600 tf->lbam = gtf->tf[3];
601 tf->lbah = gtf->tf[4];
602 tf->device = gtf->tf[5];
603 tf->command = gtf->tf[6];
604}
605
606static int ata_acpi_filter_tf(struct ata_device *dev,
607 const struct ata_taskfile *tf,
608 const struct ata_taskfile *ptf)
609{
610 if (dev->gtf_filter & ATA_ACPI_FILTER_SETXFER) {
611
612
613
614 if (tf->command == ATA_CMD_SET_FEATURES &&
615 tf->feature == SETFEATURES_XFER)
616 return 1;
617 }
618
619 if (dev->gtf_filter & ATA_ACPI_FILTER_LOCK) {
620
621
622
623
624
625 if (tf->command == ATA_CMD_CONF_OVERLAY &&
626 tf->feature == ATA_DCO_FREEZE_LOCK)
627 return 1;
628
629
630 if (tf->command == ATA_CMD_SEC_FREEZE_LOCK)
631 return 1;
632
633
634 if ((!ptf || ptf->command != ATA_CMD_READ_NATIVE_MAX) &&
635 tf->command == ATA_CMD_SET_MAX &&
636 (tf->feature == ATA_SET_MAX_LOCK ||
637 tf->feature == ATA_SET_MAX_FREEZE_LOCK))
638 return 1;
639 }
640
641 if (tf->command == ATA_CMD_SET_FEATURES &&
642 tf->feature == SETFEATURES_SATA_ENABLE) {
643
644 if (dev->gtf_filter & ATA_ACPI_FILTER_DIPM &&
645 tf->nsect == SATA_DIPM)
646 return 1;
647
648
649 if (dev->gtf_filter & ATA_ACPI_FILTER_FPDMA_OFFSET &&
650 (tf->nsect == SATA_FPDMA_OFFSET ||
651 tf->nsect == SATA_FPDMA_IN_ORDER))
652 return 1;
653
654
655 if (dev->gtf_filter & ATA_ACPI_FILTER_FPDMA_AA &&
656 tf->nsect == SATA_FPDMA_AA)
657 return 1;
658 }
659
660 return 0;
661}
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686static int ata_acpi_run_tf(struct ata_device *dev,
687 const struct ata_acpi_gtf *gtf,
688 const struct ata_acpi_gtf *prev_gtf)
689{
690 struct ata_taskfile *pptf = NULL;
691 struct ata_taskfile tf, ptf, rtf;
692 unsigned int err_mask;
693 const char *level;
694 const char *descr;
695 char msg[60];
696 int rc;
697
698 if ((gtf->tf[0] == 0) && (gtf->tf[1] == 0) && (gtf->tf[2] == 0)
699 && (gtf->tf[3] == 0) && (gtf->tf[4] == 0) && (gtf->tf[5] == 0)
700 && (gtf->tf[6] == 0))
701 return 0;
702
703 ata_acpi_gtf_to_tf(dev, gtf, &tf);
704 if (prev_gtf) {
705 ata_acpi_gtf_to_tf(dev, prev_gtf, &ptf);
706 pptf = &ptf;
707 }
708
709 if (!ata_acpi_filter_tf(dev, &tf, pptf)) {
710 rtf = tf;
711 err_mask = ata_exec_internal(dev, &rtf, NULL,
712 DMA_NONE, NULL, 0, 0);
713
714 switch (err_mask) {
715 case 0:
716 level = KERN_DEBUG;
717 snprintf(msg, sizeof(msg), "succeeded");
718 rc = 1;
719 break;
720
721 case AC_ERR_DEV:
722 level = KERN_INFO;
723 snprintf(msg, sizeof(msg),
724 "rejected by device (Stat=0x%02x Err=0x%02x)",
725 rtf.command, rtf.feature);
726 rc = 0;
727 break;
728
729 default:
730 level = KERN_ERR;
731 snprintf(msg, sizeof(msg),
732 "failed (Emask=0x%x Stat=0x%02x Err=0x%02x)",
733 err_mask, rtf.command, rtf.feature);
734 rc = -EIO;
735 break;
736 }
737 } else {
738 level = KERN_INFO;
739 snprintf(msg, sizeof(msg), "filtered out");
740 rc = 0;
741 }
742 descr = ata_get_cmd_descript(tf.command);
743
744 ata_dev_printk(dev, level,
745 "ACPI cmd %02x/%02x:%02x:%02x:%02x:%02x:%02x (%s) %s\n",
746 tf.command, tf.feature, tf.nsect, tf.lbal,
747 tf.lbam, tf.lbah, tf.device,
748 (descr ? descr : "unknown"), msg);
749
750 return rc;
751}
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767static int ata_acpi_exec_tfs(struct ata_device *dev, int *nr_executed)
768{
769 struct ata_acpi_gtf *gtf = NULL, *pgtf = NULL;
770 int gtf_count, i, rc;
771
772
773 rc = ata_dev_get_GTF(dev, >f);
774 if (rc < 0)
775 return rc;
776 gtf_count = rc;
777
778
779 for (i = 0; i < gtf_count; i++, gtf++) {
780 rc = ata_acpi_run_tf(dev, gtf, pgtf);
781 if (rc < 0)
782 break;
783 if (rc) {
784 (*nr_executed)++;
785 pgtf = gtf;
786 }
787 }
788
789 ata_acpi_clear_gtf(dev);
790
791 if (rc < 0)
792 return rc;
793 return 0;
794}
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812static int ata_acpi_push_id(struct ata_device *dev)
813{
814 struct ata_port *ap = dev->link->ap;
815 int err;
816 acpi_status status;
817 struct acpi_object_list input;
818 union acpi_object in_params[1];
819
820 if (ata_msg_probe(ap))
821 ata_dev_printk(dev, KERN_DEBUG, "%s: ix = %d, port#: %d\n",
822 __func__, dev->devno, ap->port_no);
823
824
825
826 input.count = 1;
827 input.pointer = in_params;
828 in_params[0].type = ACPI_TYPE_BUFFER;
829 in_params[0].buffer.length = sizeof(dev->id[0]) * ATA_ID_WORDS;
830 in_params[0].buffer.pointer = (u8 *)dev->id;
831
832
833
834 swap_buf_le16(dev->id, ATA_ID_WORDS);
835 status = acpi_evaluate_object(dev->acpi_handle, "_SDD", &input, NULL);
836 swap_buf_le16(dev->id, ATA_ID_WORDS);
837
838 err = ACPI_FAILURE(status) ? -EIO : 0;
839 if (err < 0)
840 ata_dev_printk(dev, KERN_WARNING,
841 "ACPI _SDD failed (AE 0x%x)\n", status);
842
843 return err;
844}
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861int ata_acpi_on_suspend(struct ata_port *ap)
862{
863
864 return 0;
865}
866
867
868
869
870
871
872
873
874
875
876
877void ata_acpi_on_resume(struct ata_port *ap)
878{
879 const struct ata_acpi_gtm *gtm = ata_acpi_init_gtm(ap);
880 struct ata_device *dev;
881
882 if (ap->acpi_handle && gtm) {
883
884
885
886 ata_acpi_stm(ap, gtm);
887
888
889
890
891
892 ata_for_each_dev(dev, &ap->link, ALL) {
893 ata_acpi_clear_gtf(dev);
894 if (ata_dev_enabled(dev) &&
895 ata_dev_get_GTF(dev, NULL) >= 0)
896 dev->flags |= ATA_DFLAG_ACPI_PENDING;
897 }
898 } else {
899
900
901
902
903 ata_for_each_dev(dev, &ap->link, ALL) {
904 ata_acpi_clear_gtf(dev);
905 if (ata_dev_enabled(dev))
906 dev->flags |= ATA_DFLAG_ACPI_PENDING;
907 }
908 }
909}
910
911
912
913
914
915
916
917
918
919void ata_acpi_set_state(struct ata_port *ap, pm_message_t state)
920{
921 struct ata_device *dev;
922
923 if (!ap->acpi_handle || (ap->flags & ATA_FLAG_ACPI_SATA))
924 return;
925
926
927
928 if (state.event == PM_EVENT_ON)
929 acpi_bus_set_power(ap->acpi_handle, ACPI_STATE_D0);
930
931 ata_for_each_dev(dev, &ap->link, ENABLED) {
932 if (dev->acpi_handle)
933 acpi_bus_set_power(dev->acpi_handle,
934 state.event == PM_EVENT_ON ?
935 ACPI_STATE_D0 : ACPI_STATE_D3);
936 }
937 if (state.event != PM_EVENT_ON)
938 acpi_bus_set_power(ap->acpi_handle, ACPI_STATE_D3);
939}
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955int ata_acpi_on_devcfg(struct ata_device *dev)
956{
957 struct ata_port *ap = dev->link->ap;
958 struct ata_eh_context *ehc = &ap->link.eh_context;
959 int acpi_sata = ap->flags & ATA_FLAG_ACPI_SATA;
960 int nr_executed = 0;
961 int rc;
962
963 if (!dev->acpi_handle)
964 return 0;
965
966
967 if (!(dev->flags & ATA_DFLAG_ACPI_PENDING) &&
968 !(acpi_sata && (ehc->i.flags & ATA_EHI_DID_HARDRESET)))
969 return 0;
970
971
972 if (acpi_sata) {
973 rc = ata_acpi_push_id(dev);
974 if (rc)
975 goto acpi_err;
976 }
977
978
979 rc = ata_acpi_exec_tfs(dev, &nr_executed);
980 if (rc)
981 goto acpi_err;
982
983 dev->flags &= ~ATA_DFLAG_ACPI_PENDING;
984
985
986 if (nr_executed) {
987 rc = ata_dev_reread_id(dev, 0);
988 if (rc < 0) {
989 ata_dev_printk(dev, KERN_ERR, "failed to IDENTIFY "
990 "after ACPI commands\n");
991 return rc;
992 }
993 }
994
995 return 0;
996
997 acpi_err:
998
999 if (rc == -EINVAL && !nr_executed && !(ap->pflags & ATA_PFLAG_FROZEN))
1000 return 0;
1001
1002
1003 if (!(dev->flags & ATA_DFLAG_ACPI_FAILED)) {
1004 dev->flags |= ATA_DFLAG_ACPI_FAILED;
1005 return rc;
1006 }
1007
1008 ata_dev_printk(dev, KERN_WARNING,
1009 "ACPI: failed the second time, disabled\n");
1010 dev->acpi_handle = NULL;
1011
1012
1013
1014
1015 if (!nr_executed && !(ap->pflags & ATA_PFLAG_FROZEN))
1016 return 0;
1017
1018 return rc;
1019}
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030void ata_acpi_on_disable(struct ata_device *dev)
1031{
1032 ata_acpi_clear_gtf(dev);
1033}
1034