]>
Commit | Line | Data |
---|---|---|
1a119d1d DM |
1 | From de665f28f788ad72ff6a0ce6ac2721d77248b7cf Mon Sep 17 00:00:00 2001 |
2 | From: Mahesh Rajashekhara <Mahesh.Rajashekhara@pmcs.com> | |
3 | Date: Fri, 28 Aug 2015 06:38:34 -0400 | |
4 | Subject: aacraid: Add Power Management support | |
5 | ||
6 | * .suspend() and .resume() routines implemented in the driver | |
7 | * aac_release_resources() initiates firmware shutdown | |
8 | * aac_acquire_resources re-initializes the host interface | |
9 | ||
10 | Reviewed-by: Tomas Henzl <thenzl@redhat.com> | |
11 | Reviewed-by: Murthy Bhat <Murthy.Bhat@pmcs.com> | |
12 | Reviewed-by: Karthikeya Sunkesula <Karthikeya.Sunkesula@pmcs.com> | |
13 | Signed-off-by: Mahesh Rajashekhara <Mahesh.Rajashekhara@pmcs.com> | |
14 | Signed-off-by: James Bottomley <JBottomley@Odin.com> | |
15 | --- | |
16 | drivers/scsi/aacraid/aacraid.h | 5 ++ | |
17 | drivers/scsi/aacraid/comminit.c | 154 ++++++++++++++++++++-------------------- | |
18 | drivers/scsi/aacraid/linit.c | 147 ++++++++++++++++++++++++++++++++++++++ | |
19 | drivers/scsi/aacraid/rx.c | 1 + | |
20 | drivers/scsi/aacraid/sa.c | 1 + | |
21 | drivers/scsi/aacraid/src.c | 2 + | |
22 | 6 files changed, 232 insertions(+), 78 deletions(-) | |
23 | ||
24 | diff --git a/drivers/scsi/aacraid/aacraid.h b/drivers/scsi/aacraid/aacraid.h | |
25 | index 40fe65c..62b0999 100644 | |
26 | --- a/drivers/scsi/aacraid/aacraid.h | |
27 | +++ b/drivers/scsi/aacraid/aacraid.h | |
28 | @@ -547,6 +547,7 @@ struct adapter_ops | |
29 | int (*adapter_sync_cmd)(struct aac_dev *dev, u32 command, u32 p1, u32 p2, u32 p3, u32 p4, u32 p5, u32 p6, u32 *status, u32 *r1, u32 *r2, u32 *r3, u32 *r4); | |
30 | int (*adapter_check_health)(struct aac_dev *dev); | |
31 | int (*adapter_restart)(struct aac_dev *dev, int bled); | |
32 | + void (*adapter_start)(struct aac_dev *dev); | |
33 | /* Transport operations */ | |
34 | int (*adapter_ioremap)(struct aac_dev * dev, u32 size); | |
35 | irq_handler_t adapter_intr; | |
36 | @@ -1247,6 +1248,9 @@ struct aac_dev | |
37 | #define aac_adapter_restart(dev,bled) \ | |
38 | (dev)->a_ops.adapter_restart(dev,bled) | |
39 | ||
40 | +#define aac_adapter_start(dev) \ | |
41 | + ((dev)->a_ops.adapter_start(dev)) | |
42 | + | |
43 | #define aac_adapter_ioremap(dev, size) \ | |
44 | (dev)->a_ops.adapter_ioremap(dev, size) | |
45 | ||
46 | @@ -2127,6 +2131,7 @@ int aac_sa_init(struct aac_dev *dev); | |
47 | int aac_src_init(struct aac_dev *dev); | |
48 | int aac_srcv_init(struct aac_dev *dev); | |
49 | int aac_queue_get(struct aac_dev * dev, u32 * index, u32 qid, struct hw_fib * hw_fib, int wait, struct fib * fibptr, unsigned long *nonotify); | |
50 | +void aac_define_int_mode(struct aac_dev *dev); | |
51 | unsigned int aac_response_normal(struct aac_queue * q); | |
52 | unsigned int aac_command_normal(struct aac_queue * q); | |
53 | unsigned int aac_intr_normal(struct aac_dev *dev, u32 Index, | |
54 | diff --git a/drivers/scsi/aacraid/comminit.c b/drivers/scsi/aacraid/comminit.c | |
55 | index 45db84a..45a0a04 100644 | |
56 | --- a/drivers/scsi/aacraid/comminit.c | |
57 | +++ b/drivers/scsi/aacraid/comminit.c | |
58 | @@ -43,8 +43,6 @@ | |
59 | ||
60 | #include "aacraid.h" | |
61 | ||
62 | -static void aac_define_int_mode(struct aac_dev *dev); | |
63 | - | |
64 | struct aac_common aac_config = { | |
65 | .irq_mod = 1 | |
66 | }; | |
67 | @@ -338,6 +336,82 @@ static int aac_comm_init(struct aac_dev * dev) | |
68 | return 0; | |
69 | } | |
70 | ||
71 | +void aac_define_int_mode(struct aac_dev *dev) | |
72 | +{ | |
73 | + int i, msi_count; | |
74 | + | |
75 | + msi_count = i = 0; | |
76 | + /* max. vectors from GET_COMM_PREFERRED_SETTINGS */ | |
77 | + if (dev->max_msix == 0 || | |
78 | + dev->pdev->device == PMC_DEVICE_S6 || | |
79 | + dev->sync_mode) { | |
80 | + dev->max_msix = 1; | |
81 | + dev->vector_cap = | |
82 | + dev->scsi_host_ptr->can_queue + | |
83 | + AAC_NUM_MGT_FIB; | |
84 | + return; | |
85 | + } | |
86 | + | |
87 | + /* Don't bother allocating more MSI-X vectors than cpus */ | |
88 | + msi_count = min(dev->max_msix, | |
89 | + (unsigned int)num_online_cpus()); | |
90 | + | |
91 | + dev->max_msix = msi_count; | |
92 | + | |
93 | + if (msi_count > AAC_MAX_MSIX) | |
94 | + msi_count = AAC_MAX_MSIX; | |
95 | + | |
96 | + for (i = 0; i < msi_count; i++) | |
97 | + dev->msixentry[i].entry = i; | |
98 | + | |
99 | + if (msi_count > 1 && | |
100 | + pci_find_capability(dev->pdev, PCI_CAP_ID_MSIX)) { | |
101 | + i = pci_enable_msix(dev->pdev, | |
102 | + dev->msixentry, | |
103 | + msi_count); | |
104 | + /* Check how many MSIX vectors are allocated */ | |
105 | + if (i >= 0) { | |
106 | + dev->msi_enabled = 1; | |
107 | + if (i) { | |
108 | + msi_count = i; | |
109 | + if (pci_enable_msix(dev->pdev, | |
110 | + dev->msixentry, | |
111 | + msi_count)) { | |
112 | + dev->msi_enabled = 0; | |
113 | + printk(KERN_ERR "%s%d: MSIX not supported!! Will try MSI 0x%x.\n", | |
114 | + dev->name, dev->id, i); | |
115 | + } | |
116 | + } | |
117 | + } else { | |
118 | + dev->msi_enabled = 0; | |
119 | + printk(KERN_ERR "%s%d: MSIX not supported!! Will try MSI 0x%x.\n", | |
120 | + dev->name, dev->id, i); | |
121 | + } | |
122 | + } | |
123 | + | |
124 | + if (!dev->msi_enabled) { | |
125 | + msi_count = 1; | |
126 | + i = pci_enable_msi(dev->pdev); | |
127 | + | |
128 | + if (!i) { | |
129 | + dev->msi_enabled = 1; | |
130 | + dev->msi = 1; | |
131 | + } else { | |
132 | + printk(KERN_ERR "%s%d: MSI not supported!! Will try INTx 0x%x.\n", | |
133 | + dev->name, dev->id, i); | |
134 | + } | |
135 | + } | |
136 | + | |
137 | + if (!dev->msi_enabled) | |
138 | + dev->max_msix = msi_count = 1; | |
139 | + else { | |
140 | + if (dev->max_msix > msi_count) | |
141 | + dev->max_msix = msi_count; | |
142 | + } | |
143 | + dev->vector_cap = | |
144 | + (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB) / | |
145 | + msi_count; | |
146 | +} | |
147 | struct aac_dev *aac_init_adapter(struct aac_dev *dev) | |
148 | { | |
149 | u32 status[5]; | |
150 | @@ -508,79 +582,3 @@ struct aac_dev *aac_init_adapter(struct aac_dev *dev) | |
151 | return dev; | |
152 | } | |
153 | ||
154 | -static void aac_define_int_mode(struct aac_dev *dev) | |
155 | -{ | |
156 | - | |
157 | - int i, msi_count; | |
158 | - | |
159 | - msi_count = i = 0; | |
160 | - /* max. vectors from GET_COMM_PREFERRED_SETTINGS */ | |
161 | - if (dev->max_msix == 0 || | |
162 | - dev->pdev->device == PMC_DEVICE_S6 || | |
163 | - dev->sync_mode) { | |
164 | - dev->max_msix = 1; | |
165 | - dev->vector_cap = | |
166 | - dev->scsi_host_ptr->can_queue + | |
167 | - AAC_NUM_MGT_FIB; | |
168 | - return; | |
169 | - } | |
170 | - | |
171 | - msi_count = min(dev->max_msix, | |
172 | - (unsigned int)num_online_cpus()); | |
173 | - | |
174 | - dev->max_msix = msi_count; | |
175 | - | |
176 | - if (msi_count > AAC_MAX_MSIX) | |
177 | - msi_count = AAC_MAX_MSIX; | |
178 | - | |
179 | - for (i = 0; i < msi_count; i++) | |
180 | - dev->msixentry[i].entry = i; | |
181 | - | |
182 | - if (msi_count > 1 && | |
183 | - pci_find_capability(dev->pdev, PCI_CAP_ID_MSIX)) { | |
184 | - i = pci_enable_msix(dev->pdev, | |
185 | - dev->msixentry, | |
186 | - msi_count); | |
187 | - /* Check how many MSIX vectors are allocated */ | |
188 | - if (i >= 0) { | |
189 | - dev->msi_enabled = 1; | |
190 | - if (i) { | |
191 | - msi_count = i; | |
192 | - if (pci_enable_msix(dev->pdev, | |
193 | - dev->msixentry, | |
194 | - msi_count)) { | |
195 | - dev->msi_enabled = 0; | |
196 | - printk(KERN_ERR "%s%d: MSIX not supported!! Will try MSI 0x%x.\n", | |
197 | - dev->name, dev->id, i); | |
198 | - } | |
199 | - } | |
200 | - } else { | |
201 | - dev->msi_enabled = 0; | |
202 | - printk(KERN_ERR "%s%d: MSIX not supported!! Will try MSI 0x%x.\n", | |
203 | - dev->name, dev->id, i); | |
204 | - } | |
205 | - } | |
206 | - | |
207 | - if (!dev->msi_enabled) { | |
208 | - msi_count = 1; | |
209 | - i = pci_enable_msi(dev->pdev); | |
210 | - | |
211 | - if (!i) { | |
212 | - dev->msi_enabled = 1; | |
213 | - dev->msi = 1; | |
214 | - } else { | |
215 | - printk(KERN_ERR "%s%d: MSI not supported!! Will try INTx 0x%x.\n", | |
216 | - dev->name, dev->id, i); | |
217 | - } | |
218 | - } | |
219 | - | |
220 | - if (!dev->msi_enabled) | |
221 | - dev->max_msix = msi_count = 1; | |
222 | - else { | |
223 | - if (dev->max_msix > msi_count) | |
224 | - dev->max_msix = msi_count; | |
225 | - } | |
226 | - dev->vector_cap = | |
227 | - (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB) / | |
228 | - msi_count; | |
229 | -} | |
230 | diff --git a/drivers/scsi/aacraid/linit.c b/drivers/scsi/aacraid/linit.c | |
231 | index 9eec027..37375cf 100644 | |
232 | --- a/drivers/scsi/aacraid/linit.c | |
233 | +++ b/drivers/scsi/aacraid/linit.c | |
234 | @@ -1317,6 +1317,149 @@ static int aac_probe_one(struct pci_dev *pdev, const struct pci_device_id *id) | |
235 | return error; | |
236 | } | |
237 | ||
238 | +#if (defined(CONFIG_PM)) | |
239 | +void aac_release_resources(struct aac_dev *aac) | |
240 | +{ | |
241 | + int i; | |
242 | + | |
243 | + aac_adapter_disable_int(aac); | |
244 | + if (aac->pdev->device == PMC_DEVICE_S6 || | |
245 | + aac->pdev->device == PMC_DEVICE_S7 || | |
246 | + aac->pdev->device == PMC_DEVICE_S8 || | |
247 | + aac->pdev->device == PMC_DEVICE_S9) { | |
248 | + if (aac->max_msix > 1) { | |
249 | + for (i = 0; i < aac->max_msix; i++) | |
250 | + free_irq(aac->msixentry[i].vector, | |
251 | + &(aac->aac_msix[i])); | |
252 | + } else { | |
253 | + free_irq(aac->pdev->irq, &(aac->aac_msix[0])); | |
254 | + } | |
255 | + } else { | |
256 | + free_irq(aac->pdev->irq, aac); | |
257 | + } | |
258 | + if (aac->msi) | |
259 | + pci_disable_msi(aac->pdev); | |
260 | + else if (aac->max_msix > 1) | |
261 | + pci_disable_msix(aac->pdev); | |
262 | + | |
263 | +} | |
264 | + | |
265 | +static int aac_acquire_resources(struct aac_dev *dev) | |
266 | +{ | |
267 | + int i, j; | |
268 | + int instance = dev->id; | |
269 | + const char *name = dev->name; | |
270 | + unsigned long status; | |
271 | + /* | |
272 | + * First clear out all interrupts. Then enable the one's that we | |
273 | + * can handle. | |
274 | + */ | |
275 | + while (!((status = src_readl(dev, MUnit.OMR)) & KERNEL_UP_AND_RUNNING) | |
276 | + || status == 0xffffffff) | |
277 | + msleep(20); | |
278 | + | |
279 | + aac_adapter_disable_int(dev); | |
280 | + aac_adapter_enable_int(dev); | |
281 | + | |
282 | + | |
283 | + if ((dev->pdev->device == PMC_DEVICE_S7 || | |
284 | + dev->pdev->device == PMC_DEVICE_S8 || | |
285 | + dev->pdev->device == PMC_DEVICE_S9)) | |
286 | + aac_define_int_mode(dev); | |
287 | + | |
288 | + if (dev->msi_enabled) | |
289 | + aac_src_access_devreg(dev, AAC_ENABLE_MSIX); | |
290 | + | |
291 | + if (!dev->sync_mode && dev->msi_enabled && dev->max_msix > 1) { | |
292 | + for (i = 0; i < dev->max_msix; i++) { | |
293 | + dev->aac_msix[i].vector_no = i; | |
294 | + dev->aac_msix[i].dev = dev; | |
295 | + | |
296 | + if (request_irq(dev->msixentry[i].vector, | |
297 | + dev->a_ops.adapter_intr, | |
298 | + 0, "aacraid", &(dev->aac_msix[i]))) { | |
299 | + printk(KERN_ERR "%s%d: Failed to register IRQ for vector %d.\n", | |
300 | + name, instance, i); | |
301 | + for (j = 0 ; j < i ; j++) | |
302 | + free_irq(dev->msixentry[j].vector, | |
303 | + &(dev->aac_msix[j])); | |
304 | + pci_disable_msix(dev->pdev); | |
305 | + goto error_iounmap; | |
306 | + } | |
307 | + } | |
308 | + } else { | |
309 | + dev->aac_msix[0].vector_no = 0; | |
310 | + dev->aac_msix[0].dev = dev; | |
311 | + | |
312 | + if (request_irq(dev->pdev->irq, dev->a_ops.adapter_intr, | |
313 | + IRQF_SHARED, "aacraid", | |
314 | + &(dev->aac_msix[0])) < 0) { | |
315 | + if (dev->msi) | |
316 | + pci_disable_msi(dev->pdev); | |
317 | + printk(KERN_ERR "%s%d: Interrupt unavailable.\n", | |
318 | + name, instance); | |
319 | + goto error_iounmap; | |
320 | + } | |
321 | + } | |
322 | + | |
323 | + aac_adapter_enable_int(dev); | |
324 | + | |
325 | + if (!dev->sync_mode) | |
326 | + aac_adapter_start(dev); | |
327 | + return 0; | |
328 | + | |
329 | +error_iounmap: | |
330 | + return -1; | |
331 | + | |
332 | +} | |
333 | +static int aac_suspend(struct pci_dev *pdev, pm_message_t state) | |
334 | +{ | |
335 | + | |
336 | + struct Scsi_Host *shost = pci_get_drvdata(pdev); | |
337 | + struct aac_dev *aac = (struct aac_dev *)shost->hostdata; | |
338 | + | |
339 | + scsi_block_requests(shost); | |
340 | + aac_send_shutdown(aac); | |
341 | + | |
342 | + aac_release_resources(aac); | |
343 | + | |
344 | + pci_set_drvdata(pdev, shost); | |
345 | + pci_save_state(pdev); | |
346 | + pci_disable_device(pdev); | |
347 | + pci_set_power_state(pdev, pci_choose_state(pdev, state)); | |
348 | + | |
349 | + return 0; | |
350 | +} | |
351 | + | |
352 | +static int aac_resume(struct pci_dev *pdev) | |
353 | +{ | |
354 | + struct Scsi_Host *shost = pci_get_drvdata(pdev); | |
355 | + struct aac_dev *aac = (struct aac_dev *)shost->hostdata; | |
356 | + int r; | |
357 | + | |
358 | + pci_set_power_state(pdev, PCI_D0); | |
359 | + pci_enable_wake(pdev, PCI_D0, 0); | |
360 | + pci_restore_state(pdev); | |
361 | + r = pci_enable_device(pdev); | |
362 | + | |
363 | + if (r) | |
364 | + goto fail_device; | |
365 | + | |
366 | + pci_set_master(pdev); | |
367 | + if (aac_acquire_resources(aac)) | |
368 | + goto fail_device; | |
369 | + scsi_unblock_requests(shost); | |
370 | + | |
371 | + return 0; | |
372 | + | |
373 | +fail_device: | |
374 | + printk(KERN_INFO "%s%d: resume failed.\n", aac->name, aac->id); | |
375 | + scsi_host_put(shost); | |
376 | + pci_disable_device(pdev); | |
377 | + return -ENODEV; | |
378 | +} | |
379 | +#endif | |
380 | + | |
381 | static void aac_shutdown(struct pci_dev *dev) | |
382 | { | |
383 | struct Scsi_Host *shost = pci_get_drvdata(dev); | |
384 | @@ -1356,6 +1499,10 @@ static struct pci_driver aac_pci_driver = { | |
385 | .id_table = aac_pci_tbl, | |
386 | .probe = aac_probe_one, | |
387 | .remove = aac_remove_one, | |
388 | +#if (defined(CONFIG_PM)) | |
389 | + .suspend = aac_suspend, | |
390 | + .resume = aac_resume, | |
391 | +#endif | |
392 | .shutdown = aac_shutdown, | |
393 | }; | |
394 | ||
395 | diff --git a/drivers/scsi/aacraid/rx.c b/drivers/scsi/aacraid/rx.c | |
396 | index 9570612..ac16380 100644 | |
397 | --- a/drivers/scsi/aacraid/rx.c | |
398 | +++ b/drivers/scsi/aacraid/rx.c | |
399 | @@ -623,6 +623,7 @@ int _aac_rx_init(struct aac_dev *dev) | |
400 | dev->a_ops.adapter_sync_cmd = rx_sync_cmd; | |
401 | dev->a_ops.adapter_check_health = aac_rx_check_health; | |
402 | dev->a_ops.adapter_restart = aac_rx_restart_adapter; | |
403 | + dev->a_ops.adapter_start = aac_rx_start_adapter; | |
404 | ||
405 | /* | |
406 | * First clear out all interrupts. Then enable the one's that we | |
407 | diff --git a/drivers/scsi/aacraid/sa.c b/drivers/scsi/aacraid/sa.c | |
408 | index e66477c..869aea2 100644 | |
409 | --- a/drivers/scsi/aacraid/sa.c | |
410 | +++ b/drivers/scsi/aacraid/sa.c | |
411 | @@ -372,6 +372,7 @@ int aac_sa_init(struct aac_dev *dev) | |
412 | dev->a_ops.adapter_sync_cmd = sa_sync_cmd; | |
413 | dev->a_ops.adapter_check_health = aac_sa_check_health; | |
414 | dev->a_ops.adapter_restart = aac_sa_restart_adapter; | |
415 | + dev->a_ops.adapter_start = aac_sa_start_adapter; | |
416 | dev->a_ops.adapter_intr = aac_sa_intr; | |
417 | dev->a_ops.adapter_deliver = aac_rx_deliver_producer; | |
418 | dev->a_ops.adapter_ioremap = aac_sa_ioremap; | |
419 | diff --git a/drivers/scsi/aacraid/src.c b/drivers/scsi/aacraid/src.c | |
420 | index e63cf9f..b147341 100644 | |
421 | --- a/drivers/scsi/aacraid/src.c | |
422 | +++ b/drivers/scsi/aacraid/src.c | |
423 | @@ -726,6 +726,7 @@ int aac_src_init(struct aac_dev *dev) | |
424 | dev->a_ops.adapter_sync_cmd = src_sync_cmd; | |
425 | dev->a_ops.adapter_check_health = aac_src_check_health; | |
426 | dev->a_ops.adapter_restart = aac_src_restart_adapter; | |
427 | + dev->a_ops.adapter_start = aac_src_start_adapter; | |
428 | ||
429 | /* | |
430 | * First clear out all interrupts. Then enable the one's that we | |
431 | @@ -892,6 +893,7 @@ int aac_srcv_init(struct aac_dev *dev) | |
432 | dev->a_ops.adapter_sync_cmd = src_sync_cmd; | |
433 | dev->a_ops.adapter_check_health = aac_src_check_health; | |
434 | dev->a_ops.adapter_restart = aac_src_restart_adapter; | |
435 | + dev->a_ops.adapter_start = aac_src_start_adapter; | |
436 | ||
437 | /* | |
438 | * First clear out all interrupts. Then enable the one's that we | |
439 | -- | |
440 | cgit v0.11.2 | |
441 |