Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
e2984c62 | 2 | #include <linux/kernel.h> |
5a0e3ad6 | 3 | #include <linux/gfp.h> |
e2984c62 | 4 | #include <linux/ide.h> |
e2984c62 BZ |
5 | |
6 | int generic_ide_suspend(struct device *dev, pm_message_t mesg) | |
7 | { | |
9974e43d | 8 | ide_drive_t *drive = to_ide_device(dev); |
fcb52077 | 9 | ide_drive_t *pair = ide_get_pair_dev(drive); |
898ec223 | 10 | ide_hwif_t *hwif = drive->hwif; |
e2984c62 | 11 | struct request *rq; |
a7928c15 | 12 | struct ide_pm_state rqpm; |
e2984c62 BZ |
13 | int ret; |
14 | ||
2bf427b2 BZ |
15 | if (ide_port_acpi(hwif)) { |
16 | /* call ACPI _GTM only once */ | |
17 | if ((drive->dn & 1) == 0 || pair == NULL) | |
18 | ide_acpi_get_timing(hwif); | |
19 | } | |
e2984c62 BZ |
20 | |
21 | memset(&rqpm, 0, sizeof(rqpm)); | |
ff005a06 | 22 | rq = blk_get_request(drive->queue, REQ_OP_DRV_IN, 0); |
2f5a8e80 | 23 | ide_req(rq)->type = ATA_PRIV_PM_SUSPEND; |
22ce0a7c | 24 | ide_req(rq)->special = &rqpm; |
e2984c62 BZ |
25 | rqpm.pm_step = IDE_PM_START_SUSPEND; |
26 | if (mesg.event == PM_EVENT_PRETHAW) | |
27 | mesg.event = PM_EVENT_FREEZE; | |
28 | rqpm.pm_state = mesg.event; | |
29 | ||
b7819b92 | 30 | blk_execute_rq(drive->queue, NULL, rq, 0); |
17d5363b | 31 | ret = scsi_req(rq)->result ? -EIO : 0; |
e2984c62 BZ |
32 | blk_put_request(rq); |
33 | ||
2bf427b2 BZ |
34 | if (ret == 0 && ide_port_acpi(hwif)) { |
35 | /* call ACPI _PS3 only after both devices are suspended */ | |
36 | if ((drive->dn & 1) || pair == NULL) | |
37 | ide_acpi_set_state(hwif, 0); | |
38 | } | |
e2984c62 BZ |
39 | |
40 | return ret; | |
41 | } | |
42 | ||
a7928c15 CH |
43 | static int ide_pm_execute_rq(struct request *rq) |
44 | { | |
45 | struct request_queue *q = rq->q; | |
a7928c15 | 46 | |
a7928c15 | 47 | if (unlikely(blk_queue_dying(q))) { |
e8064021 | 48 | rq->rq_flags |= RQF_QUIET; |
17d5363b | 49 | scsi_req(rq)->result = -ENXIO; |
60033520 | 50 | blk_mq_end_request(rq, BLK_STS_OK); |
a7928c15 CH |
51 | return -ENXIO; |
52 | } | |
60033520 | 53 | blk_execute_rq(q, NULL, rq, true); |
a7928c15 | 54 | |
17d5363b | 55 | return scsi_req(rq)->result ? -EIO : 0; |
a7928c15 CH |
56 | } |
57 | ||
e2984c62 BZ |
58 | int generic_ide_resume(struct device *dev) |
59 | { | |
9974e43d | 60 | ide_drive_t *drive = to_ide_device(dev); |
fcb52077 | 61 | ide_drive_t *pair = ide_get_pair_dev(drive); |
898ec223 | 62 | ide_hwif_t *hwif = drive->hwif; |
e2984c62 | 63 | struct request *rq; |
a7928c15 | 64 | struct ide_pm_state rqpm; |
e2984c62 BZ |
65 | int err; |
66 | ||
60033520 JA |
67 | blk_mq_start_stopped_hw_queues(drive->queue, true); |
68 | ||
2bf427b2 BZ |
69 | if (ide_port_acpi(hwif)) { |
70 | /* call ACPI _PS0 / _STM only once */ | |
71 | if ((drive->dn & 1) == 0 || pair == NULL) { | |
72 | ide_acpi_set_state(hwif, 1); | |
73 | ide_acpi_push_timing(hwif); | |
74 | } | |
e2984c62 | 75 | |
2bf427b2 BZ |
76 | ide_acpi_exec_tfs(drive); |
77 | } | |
e2984c62 BZ |
78 | |
79 | memset(&rqpm, 0, sizeof(rqpm)); | |
ff005a06 | 80 | rq = blk_get_request(drive->queue, REQ_OP_DRV_IN, BLK_MQ_REQ_PREEMPT); |
2f5a8e80 | 81 | ide_req(rq)->type = ATA_PRIV_PM_RESUME; |
22ce0a7c | 82 | ide_req(rq)->special = &rqpm; |
e2984c62 BZ |
83 | rqpm.pm_step = IDE_PM_START_RESUME; |
84 | rqpm.pm_state = PM_EVENT_ON; | |
85 | ||
a7928c15 | 86 | err = ide_pm_execute_rq(rq); |
e2984c62 BZ |
87 | blk_put_request(rq); |
88 | ||
89 | if (err == 0 && dev->driver) { | |
7f3c868b | 90 | struct ide_driver *drv = to_ide_driver(dev->driver); |
e2984c62 BZ |
91 | |
92 | if (drv->resume) | |
93 | drv->resume(drive); | |
94 | } | |
95 | ||
96 | return err; | |
97 | } | |
98 | ||
99 | void ide_complete_power_step(ide_drive_t *drive, struct request *rq) | |
100 | { | |
22ce0a7c | 101 | struct ide_pm_state *pm = ide_req(rq)->special; |
e2984c62 BZ |
102 | |
103 | #ifdef DEBUG_PM | |
104 | printk(KERN_INFO "%s: complete_power_step(step: %d)\n", | |
105 | drive->name, pm->pm_step); | |
106 | #endif | |
107 | if (drive->media != ide_disk) | |
108 | return; | |
109 | ||
110 | switch (pm->pm_step) { | |
111 | case IDE_PM_FLUSH_CACHE: /* Suspend step 1 (flush cache) */ | |
112 | if (pm->pm_state == PM_EVENT_FREEZE) | |
113 | pm->pm_step = IDE_PM_COMPLETED; | |
114 | else | |
115 | pm->pm_step = IDE_PM_STANDBY; | |
116 | break; | |
117 | case IDE_PM_STANDBY: /* Suspend step 2 (standby) */ | |
118 | pm->pm_step = IDE_PM_COMPLETED; | |
119 | break; | |
120 | case IDE_PM_RESTORE_PIO: /* Resume step 1 (restore PIO) */ | |
121 | pm->pm_step = IDE_PM_IDLE; | |
122 | break; | |
123 | case IDE_PM_IDLE: /* Resume step 2 (idle)*/ | |
124 | pm->pm_step = IDE_PM_RESTORE_DMA; | |
125 | break; | |
126 | } | |
127 | } | |
128 | ||
129 | ide_startstop_t ide_start_power_step(ide_drive_t *drive, struct request *rq) | |
130 | { | |
22ce0a7c | 131 | struct ide_pm_state *pm = ide_req(rq)->special; |
fc38b521 | 132 | struct ide_cmd cmd = { }; |
e2984c62 BZ |
133 | |
134 | switch (pm->pm_step) { | |
135 | case IDE_PM_FLUSH_CACHE: /* Suspend step 1 (flush cache) */ | |
136 | if (drive->media != ide_disk) | |
137 | break; | |
138 | /* Not supported? Switch to next step now. */ | |
139 | if (ata_id_flush_enabled(drive->id) == 0 || | |
140 | (drive->dev_flags & IDE_DFLAG_WCACHE) == 0) { | |
141 | ide_complete_power_step(drive, rq); | |
142 | return ide_stopped; | |
143 | } | |
144 | if (ata_id_flush_ext_enabled(drive->id)) | |
fc38b521 | 145 | cmd.tf.command = ATA_CMD_FLUSH_EXT; |
e2984c62 | 146 | else |
fc38b521 | 147 | cmd.tf.command = ATA_CMD_FLUSH; |
e2984c62 BZ |
148 | goto out_do_tf; |
149 | case IDE_PM_STANDBY: /* Suspend step 2 (standby) */ | |
fc38b521 | 150 | cmd.tf.command = ATA_CMD_STANDBYNOW1; |
e2984c62 BZ |
151 | goto out_do_tf; |
152 | case IDE_PM_RESTORE_PIO: /* Resume step 1 (restore PIO) */ | |
153 | ide_set_max_pio(drive); | |
154 | /* | |
155 | * skip IDE_PM_IDLE for ATAPI devices | |
156 | */ | |
157 | if (drive->media != ide_disk) | |
158 | pm->pm_step = IDE_PM_RESTORE_DMA; | |
159 | else | |
160 | ide_complete_power_step(drive, rq); | |
161 | return ide_stopped; | |
162 | case IDE_PM_IDLE: /* Resume step 2 (idle) */ | |
fc38b521 | 163 | cmd.tf.command = ATA_CMD_IDLEIMMEDIATE; |
e2984c62 BZ |
164 | goto out_do_tf; |
165 | case IDE_PM_RESTORE_DMA: /* Resume step 3 (restore DMA) */ | |
166 | /* | |
167 | * Right now, all we do is call ide_set_dma(drive), | |
168 | * we could be smarter and check for current xfer_speed | |
169 | * in struct drive etc... | |
170 | */ | |
171 | if (drive->hwif->dma_ops == NULL) | |
172 | break; | |
173 | /* | |
174 | * TODO: respect IDE_DFLAG_USING_DMA | |
175 | */ | |
176 | ide_set_dma(drive); | |
177 | break; | |
178 | } | |
179 | ||
180 | pm->pm_step = IDE_PM_COMPLETED; | |
22aa4b32 | 181 | |
e2984c62 BZ |
182 | return ide_stopped; |
183 | ||
184 | out_do_tf: | |
fc38b521 TH |
185 | cmd.valid.out.tf = IDE_VALID_OUT_TF | IDE_VALID_DEVICE; |
186 | cmd.valid.in.tf = IDE_VALID_IN_TF | IDE_VALID_DEVICE; | |
187 | cmd.protocol = ATA_PROT_NODATA; | |
22aa4b32 | 188 | |
fc38b521 | 189 | return do_rw_taskfile(drive, &cmd); |
e2984c62 BZ |
190 | } |
191 | ||
192 | /** | |
3616b653 | 193 | * ide_complete_pm_rq - end the current Power Management request |
e2984c62 BZ |
194 | * @drive: target drive |
195 | * @rq: request | |
196 | * | |
197 | * This function cleans up the current PM request and stops the queue | |
198 | * if necessary. | |
199 | */ | |
3616b653 | 200 | void ide_complete_pm_rq(ide_drive_t *drive, struct request *rq) |
e2984c62 BZ |
201 | { |
202 | struct request_queue *q = drive->queue; | |
22ce0a7c | 203 | struct ide_pm_state *pm = ide_req(rq)->special; |
e2984c62 | 204 | |
3616b653 BZ |
205 | ide_complete_power_step(drive, rq); |
206 | if (pm->pm_step != IDE_PM_COMPLETED) | |
207 | return; | |
208 | ||
e2984c62 BZ |
209 | #ifdef DEBUG_PM |
210 | printk("%s: completing PM request, %s\n", drive->name, | |
2f5a8e80 | 211 | (ide_req(rq)->type == ATA_PRIV_PM_SUSPEND) ? "suspend" : "resume"); |
e2984c62 | 212 | #endif |
2f5a8e80 | 213 | if (ide_req(rq)->type == ATA_PRIV_PM_SUSPEND) |
60033520 | 214 | blk_mq_stop_hw_queues(q); |
2ea55210 | 215 | else |
e2984c62 | 216 | drive->dev_flags &= ~IDE_DFLAG_BLOCKED; |
e2984c62 | 217 | |
b65fac32 | 218 | drive->hwif->rq = NULL; |
e2984c62 | 219 | |
60033520 | 220 | blk_mq_end_request(rq, BLK_STS_OK); |
e2984c62 BZ |
221 | } |
222 | ||
223 | void ide_check_pm_state(ide_drive_t *drive, struct request *rq) | |
224 | { | |
22ce0a7c | 225 | struct ide_pm_state *pm = ide_req(rq)->special; |
e2984c62 | 226 | |
aebf526b | 227 | if (blk_rq_is_private(rq) && |
2f5a8e80 | 228 | ide_req(rq)->type == ATA_PRIV_PM_SUSPEND && |
e2984c62 BZ |
229 | pm->pm_step == IDE_PM_START_SUSPEND) |
230 | /* Mark drive blocked when starting the suspend sequence. */ | |
231 | drive->dev_flags |= IDE_DFLAG_BLOCKED; | |
aebf526b | 232 | else if (blk_rq_is_private(rq) && |
2f5a8e80 | 233 | ide_req(rq)->type == ATA_PRIV_PM_RESUME && |
e2984c62 BZ |
234 | pm->pm_step == IDE_PM_START_RESUME) { |
235 | /* | |
236 | * The first thing we do on wakeup is to wait for BSY bit to | |
237 | * go away (with a looong timeout) as a drive on this hwif may | |
238 | * just be POSTing itself. | |
239 | * We do that before even selecting as the "other" device on | |
240 | * the bus may be broken enough to walk on our toes at this | |
241 | * point. | |
242 | */ | |
243 | ide_hwif_t *hwif = drive->hwif; | |
fdd88f0a | 244 | const struct ide_tp_ops *tp_ops = hwif->tp_ops; |
2ea55210 | 245 | struct request_queue *q = drive->queue; |
e2984c62 BZ |
246 | int rc; |
247 | #ifdef DEBUG_PM | |
248 | printk("%s: Wakeup request inited, waiting for !BSY...\n", drive->name); | |
249 | #endif | |
250 | rc = ide_wait_not_busy(hwif, 35000); | |
251 | if (rc) | |
252 | printk(KERN_WARNING "%s: bus not ready on wakeup\n", drive->name); | |
fdd88f0a SS |
253 | tp_ops->dev_select(drive); |
254 | tp_ops->write_devctl(hwif, ATA_DEVCTL_OBS); | |
e2984c62 BZ |
255 | rc = ide_wait_not_busy(hwif, 100000); |
256 | if (rc) | |
257 | printk(KERN_WARNING "%s: drive not ready on wakeup\n", drive->name); | |
2ea55210 | 258 | |
60033520 | 259 | blk_mq_start_hw_queues(q); |
e2984c62 BZ |
260 | } |
261 | } |