1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44#include "esas2r.h"
45
46static bool esas2r_initmem_alloc(struct esas2r_adapter *a,
47 struct esas2r_mem_desc *mem_desc,
48 u32 align)
49{
50 mem_desc->esas2r_param = mem_desc->size + align;
51 mem_desc->virt_addr = NULL;
52 mem_desc->phys_addr = 0;
53 mem_desc->esas2r_data = dma_alloc_coherent(&a->pcid->dev,
54 (size_t)mem_desc->
55 esas2r_param,
56 (dma_addr_t *)&mem_desc->
57 phys_addr,
58 GFP_KERNEL);
59
60 if (mem_desc->esas2r_data == NULL) {
61 esas2r_log(ESAS2R_LOG_CRIT,
62 "failed to allocate %lu bytes of consistent memory!",
63 (long
64 unsigned
65 int)mem_desc->esas2r_param);
66 return false;
67 }
68
69 mem_desc->virt_addr = PTR_ALIGN(mem_desc->esas2r_data, align);
70 mem_desc->phys_addr = ALIGN(mem_desc->phys_addr, align);
71 memset(mem_desc->virt_addr, 0, mem_desc->size);
72 return true;
73}
74
75static void esas2r_initmem_free(struct esas2r_adapter *a,
76 struct esas2r_mem_desc *mem_desc)
77{
78 if (mem_desc->virt_addr == NULL)
79 return;
80
81
82
83
84
85
86
87
88 if (mem_desc->phys_addr) {
89 int unalign = ((u8 *)mem_desc->virt_addr) -
90 ((u8 *)mem_desc->esas2r_data);
91
92 dma_free_coherent(&a->pcid->dev,
93 (size_t)mem_desc->esas2r_param,
94 mem_desc->esas2r_data,
95 (dma_addr_t)(mem_desc->phys_addr - unalign));
96 } else {
97 kfree(mem_desc->esas2r_data);
98 }
99
100 mem_desc->virt_addr = NULL;
101}
102
103static bool alloc_vda_req(struct esas2r_adapter *a,
104 struct esas2r_request *rq)
105{
106 struct esas2r_mem_desc *memdesc = kzalloc(
107 sizeof(struct esas2r_mem_desc), GFP_KERNEL);
108
109 if (memdesc == NULL) {
110 esas2r_hdebug("could not alloc mem for vda request memdesc\n");
111 return false;
112 }
113
114 memdesc->size = sizeof(union atto_vda_req) +
115 ESAS2R_DATA_BUF_LEN;
116
117 if (!esas2r_initmem_alloc(a, memdesc, 256)) {
118 esas2r_hdebug("could not alloc mem for vda request\n");
119 kfree(memdesc);
120 return false;
121 }
122
123 a->num_vrqs++;
124 list_add(&memdesc->next_desc, &a->vrq_mds_head);
125
126 rq->vrq_md = memdesc;
127 rq->vrq = (union atto_vda_req *)memdesc->virt_addr;
128 rq->vrq->scsi.handle = a->num_vrqs;
129
130 return true;
131}
132
133static void esas2r_unmap_regions(struct esas2r_adapter *a)
134{
135 if (a->regs)
136 iounmap((void __iomem *)a->regs);
137
138 a->regs = NULL;
139
140 pci_release_region(a->pcid, 2);
141
142 if (a->data_window)
143 iounmap((void __iomem *)a->data_window);
144
145 a->data_window = NULL;
146
147 pci_release_region(a->pcid, 0);
148}
149
150static int esas2r_map_regions(struct esas2r_adapter *a)
151{
152 int error;
153
154 a->regs = NULL;
155 a->data_window = NULL;
156
157 error = pci_request_region(a->pcid, 2, a->name);
158 if (error != 0) {
159 esas2r_log(ESAS2R_LOG_CRIT,
160 "pci_request_region(2) failed, error %d",
161 error);
162
163 return error;
164 }
165
166 a->regs = (void __force *)ioremap(pci_resource_start(a->pcid, 2),
167 pci_resource_len(a->pcid, 2));
168 if (a->regs == NULL) {
169 esas2r_log(ESAS2R_LOG_CRIT,
170 "ioremap failed for regs mem region\n");
171 pci_release_region(a->pcid, 2);
172 return -EFAULT;
173 }
174
175 error = pci_request_region(a->pcid, 0, a->name);
176 if (error != 0) {
177 esas2r_log(ESAS2R_LOG_CRIT,
178 "pci_request_region(2) failed, error %d",
179 error);
180 esas2r_unmap_regions(a);
181 return error;
182 }
183
184 a->data_window = (void __force *)ioremap(pci_resource_start(a->pcid,
185 0),
186 pci_resource_len(a->pcid, 0));
187 if (a->data_window == NULL) {
188 esas2r_log(ESAS2R_LOG_CRIT,
189 "ioremap failed for data_window mem region\n");
190 esas2r_unmap_regions(a);
191 return -EFAULT;
192 }
193
194 return 0;
195}
196
197static void esas2r_setup_interrupts(struct esas2r_adapter *a, int intr_mode)
198{
199 int i;
200
201
202 switch (intr_mode) {
203 case INTR_MODE_LEGACY:
204use_legacy_interrupts:
205 a->intr_mode = INTR_MODE_LEGACY;
206 break;
207
208 case INTR_MODE_MSI:
209 i = pci_enable_msi(a->pcid);
210 if (i != 0) {
211 esas2r_log(ESAS2R_LOG_WARN,
212 "failed to enable MSI for adapter %d, "
213 "falling back to legacy interrupts "
214 "(err=%d)", a->index,
215 i);
216 goto use_legacy_interrupts;
217 }
218 a->intr_mode = INTR_MODE_MSI;
219 set_bit(AF2_MSI_ENABLED, &a->flags2);
220 break;
221
222
223 default:
224 esas2r_log(ESAS2R_LOG_WARN,
225 "unknown interrupt_mode %d requested, "
226 "falling back to legacy interrupt",
227 interrupt_mode);
228 goto use_legacy_interrupts;
229 }
230}
231
232static void esas2r_claim_interrupts(struct esas2r_adapter *a)
233{
234 unsigned long flags = 0;
235
236 if (a->intr_mode == INTR_MODE_LEGACY)
237 flags |= IRQF_SHARED;
238
239 esas2r_log(ESAS2R_LOG_INFO,
240 "esas2r_claim_interrupts irq=%d (%p, %s, %x)",
241 a->pcid->irq, a, a->name, flags);
242
243 if (request_irq(a->pcid->irq,
244 (a->intr_mode ==
245 INTR_MODE_LEGACY) ? esas2r_interrupt :
246 esas2r_msi_interrupt,
247 flags,
248 a->name,
249 a)) {
250 esas2r_log(ESAS2R_LOG_CRIT, "unable to request IRQ %02X",
251 a->pcid->irq);
252 return;
253 }
254
255 set_bit(AF2_IRQ_CLAIMED, &a->flags2);
256 esas2r_log(ESAS2R_LOG_INFO,
257 "claimed IRQ %d flags: 0x%lx",
258 a->pcid->irq, flags);
259}
260
261int esas2r_init_adapter(struct Scsi_Host *host, struct pci_dev *pcid,
262 int index)
263{
264 struct esas2r_adapter *a;
265 u64 bus_addr = 0;
266 int i;
267 void *next_uncached;
268 struct esas2r_request *first_request, *last_request;
269
270 if (index >= MAX_ADAPTERS) {
271 esas2r_log(ESAS2R_LOG_CRIT,
272 "tried to init invalid adapter index %u!",
273 index);
274 return 0;
275 }
276
277 if (esas2r_adapters[index]) {
278 esas2r_log(ESAS2R_LOG_CRIT,
279 "tried to init existing adapter index %u!",
280 index);
281 return 0;
282 }
283
284 a = (struct esas2r_adapter *)host->hostdata;
285 memset(a, 0, sizeof(struct esas2r_adapter));
286 a->pcid = pcid;
287 a->host = host;
288
289 if (sizeof(dma_addr_t) > 4) {
290 const uint64_t required_mask = dma_get_required_mask
291 (&pcid->dev);
292 if (required_mask > DMA_BIT_MASK(32)
293 && !pci_set_dma_mask(pcid, DMA_BIT_MASK(64))
294 && !pci_set_consistent_dma_mask(pcid,
295 DMA_BIT_MASK(64))) {
296 esas2r_log_dev(ESAS2R_LOG_INFO,
297 &(a->pcid->dev),
298 "64-bit PCI addressing enabled\n");
299 } else if (!pci_set_dma_mask(pcid, DMA_BIT_MASK(32))
300 && !pci_set_consistent_dma_mask(pcid,
301 DMA_BIT_MASK(32))) {
302 esas2r_log_dev(ESAS2R_LOG_INFO,
303 &(a->pcid->dev),
304 "32-bit PCI addressing enabled\n");
305 } else {
306 esas2r_log(ESAS2R_LOG_CRIT,
307 "failed to set DMA mask");
308 esas2r_kill_adapter(index);
309 return 0;
310 }
311 } else {
312 if (!pci_set_dma_mask(pcid, DMA_BIT_MASK(32))
313 && !pci_set_consistent_dma_mask(pcid,
314 DMA_BIT_MASK(32))) {
315 esas2r_log_dev(ESAS2R_LOG_INFO,
316 &(a->pcid->dev),
317 "32-bit PCI addressing enabled\n");
318 } else {
319 esas2r_log(ESAS2R_LOG_CRIT,
320 "failed to set DMA mask");
321 esas2r_kill_adapter(index);
322 return 0;
323 }
324 }
325 esas2r_adapters[index] = a;
326 sprintf(a->name, ESAS2R_DRVR_NAME "_%02d", index);
327 esas2r_debug("new adapter %p, name %s", a, a->name);
328 spin_lock_init(&a->request_lock);
329 spin_lock_init(&a->fw_event_lock);
330 sema_init(&a->fm_api_semaphore, 1);
331 sema_init(&a->fs_api_semaphore, 1);
332 sema_init(&a->nvram_semaphore, 1);
333
334 esas2r_fw_event_off(a);
335 snprintf(a->fw_event_q_name, ESAS2R_KOBJ_NAME_LEN, "esas2r/%d",
336 a->index);
337 a->fw_event_q = create_singlethread_workqueue(a->fw_event_q_name);
338
339 init_waitqueue_head(&a->buffered_ioctl_waiter);
340 init_waitqueue_head(&a->nvram_waiter);
341 init_waitqueue_head(&a->fm_api_waiter);
342 init_waitqueue_head(&a->fs_api_waiter);
343 init_waitqueue_head(&a->vda_waiter);
344
345 INIT_LIST_HEAD(&a->general_req.req_list);
346 INIT_LIST_HEAD(&a->active_list);
347 INIT_LIST_HEAD(&a->defer_list);
348 INIT_LIST_HEAD(&a->free_sg_list_head);
349 INIT_LIST_HEAD(&a->avail_request);
350 INIT_LIST_HEAD(&a->vrq_mds_head);
351 INIT_LIST_HEAD(&a->fw_event_list);
352
353 first_request = (struct esas2r_request *)((u8 *)(a + 1));
354
355 for (last_request = first_request, i = 1; i < num_requests;
356 last_request++, i++) {
357 INIT_LIST_HEAD(&last_request->req_list);
358 list_add_tail(&last_request->comp_list, &a->avail_request);
359 if (!alloc_vda_req(a, last_request)) {
360 esas2r_log(ESAS2R_LOG_CRIT,
361 "failed to allocate a VDA request!");
362 esas2r_kill_adapter(index);
363 return 0;
364 }
365 }
366
367 esas2r_debug("requests: %p to %p (%d, %d)", first_request,
368 last_request,
369 sizeof(*first_request),
370 num_requests);
371
372 if (esas2r_map_regions(a) != 0) {
373 esas2r_log(ESAS2R_LOG_CRIT, "could not map PCI regions!");
374 esas2r_kill_adapter(index);
375 return 0;
376 }
377
378 a->index = index;
379
380
381 atomic_inc(&a->dis_ints_cnt);
382 atomic_inc(&a->disable_cnt);
383 set_bit(AF_CHPRST_PENDING, &a->flags);
384 set_bit(AF_DISC_PENDING, &a->flags);
385 set_bit(AF_FIRST_INIT, &a->flags);
386 set_bit(AF_LEGACY_SGE_MODE, &a->flags);
387
388 a->init_msg = ESAS2R_INIT_MSG_START;
389 a->max_vdareq_size = 128;
390 a->build_sgl = esas2r_build_sg_list_sge;
391
392 esas2r_setup_interrupts(a, interrupt_mode);
393
394 a->uncached_size = esas2r_get_uncached_size(a);
395 a->uncached = dma_alloc_coherent(&pcid->dev,
396 (size_t)a->uncached_size,
397 (dma_addr_t *)&bus_addr,
398 GFP_KERNEL);
399 if (a->uncached == NULL) {
400 esas2r_log(ESAS2R_LOG_CRIT,
401 "failed to allocate %d bytes of consistent memory!",
402 a->uncached_size);
403 esas2r_kill_adapter(index);
404 return 0;
405 }
406
407 a->uncached_phys = bus_addr;
408
409 esas2r_debug("%d bytes uncached memory allocated @ %p (%x:%x)",
410 a->uncached_size,
411 a->uncached,
412 upper_32_bits(bus_addr),
413 lower_32_bits(bus_addr));
414 memset(a->uncached, 0, a->uncached_size);
415 next_uncached = a->uncached;
416
417 if (!esas2r_init_adapter_struct(a,
418 &next_uncached)) {
419 esas2r_log(ESAS2R_LOG_CRIT,
420 "failed to initialize adapter structure (2)!");
421 esas2r_kill_adapter(index);
422 return 0;
423 }
424
425 tasklet_init(&a->tasklet,
426 esas2r_adapter_tasklet,
427 (unsigned long)a);
428
429
430
431
432
433 esas2r_disable_chip_interrupts(a);
434 esas2r_check_adapter(a);
435
436 if (!esas2r_init_adapter_hw(a, true))
437 esas2r_log(ESAS2R_LOG_CRIT, "failed to initialize hardware!");
438 else
439 esas2r_debug("esas2r_init_adapter ok");
440
441 esas2r_claim_interrupts(a);
442
443 if (test_bit(AF2_IRQ_CLAIMED, &a->flags2))
444 esas2r_enable_chip_interrupts(a);
445
446 set_bit(AF2_INIT_DONE, &a->flags2);
447 if (!test_bit(AF_DEGRADED_MODE, &a->flags))
448 esas2r_kickoff_timer(a);
449 esas2r_debug("esas2r_init_adapter done for %p (%d)",
450 a, a->disable_cnt);
451
452 return 1;
453}
454
455static void esas2r_adapter_power_down(struct esas2r_adapter *a,
456 int power_management)
457{
458 struct esas2r_mem_desc *memdesc, *next;
459
460 if ((test_bit(AF2_INIT_DONE, &a->flags2))
461 && (!test_bit(AF_DEGRADED_MODE, &a->flags))) {
462 if (!power_management) {
463 del_timer_sync(&a->timer);
464 tasklet_kill(&a->tasklet);
465 }
466 esas2r_power_down(a);
467
468
469
470
471
472
473 mdelay(500);
474 esas2r_debug("chip halted");
475 }
476
477
478 if (a->sysfs_fw_created) {
479 sysfs_remove_bin_file(&a->host->shost_dev.kobj, &bin_attr_fw);
480 a->sysfs_fw_created = 0;
481 }
482
483 if (a->sysfs_fs_created) {
484 sysfs_remove_bin_file(&a->host->shost_dev.kobj, &bin_attr_fs);
485 a->sysfs_fs_created = 0;
486 }
487
488 if (a->sysfs_vda_created) {
489 sysfs_remove_bin_file(&a->host->shost_dev.kobj, &bin_attr_vda);
490 a->sysfs_vda_created = 0;
491 }
492
493 if (a->sysfs_hw_created) {
494 sysfs_remove_bin_file(&a->host->shost_dev.kobj, &bin_attr_hw);
495 a->sysfs_hw_created = 0;
496 }
497
498 if (a->sysfs_live_nvram_created) {
499 sysfs_remove_bin_file(&a->host->shost_dev.kobj,
500 &bin_attr_live_nvram);
501 a->sysfs_live_nvram_created = 0;
502 }
503
504 if (a->sysfs_default_nvram_created) {
505 sysfs_remove_bin_file(&a->host->shost_dev.kobj,
506 &bin_attr_default_nvram);
507 a->sysfs_default_nvram_created = 0;
508 }
509
510
511 if (test_bit(AF2_IRQ_CLAIMED, &a->flags2)) {
512 esas2r_log_dev(ESAS2R_LOG_INFO,
513 &(a->pcid->dev),
514 "free_irq(%d) called", a->pcid->irq);
515
516 free_irq(a->pcid->irq, a);
517 esas2r_debug("IRQ released");
518 clear_bit(AF2_IRQ_CLAIMED, &a->flags2);
519 }
520
521 if (test_bit(AF2_MSI_ENABLED, &a->flags2)) {
522 pci_disable_msi(a->pcid);
523 clear_bit(AF2_MSI_ENABLED, &a->flags2);
524 esas2r_debug("MSI disabled");
525 }
526
527 if (a->inbound_list_md.virt_addr)
528 esas2r_initmem_free(a, &a->inbound_list_md);
529
530 if (a->outbound_list_md.virt_addr)
531 esas2r_initmem_free(a, &a->outbound_list_md);
532
533 list_for_each_entry_safe(memdesc, next, &a->free_sg_list_head,
534 next_desc) {
535 esas2r_initmem_free(a, memdesc);
536 }
537
538
539 list_for_each_entry_safe(memdesc, next, &a->vrq_mds_head, next_desc) {
540 esas2r_initmem_free(a, memdesc);
541 list_del(&memdesc->next_desc);
542 kfree(memdesc);
543 }
544
545 kfree(a->first_ae_req);
546 a->first_ae_req = NULL;
547
548 kfree(a->sg_list_mds);
549 a->sg_list_mds = NULL;
550
551 kfree(a->req_table);
552 a->req_table = NULL;
553
554 if (a->regs) {
555 esas2r_unmap_regions(a);
556 a->regs = NULL;
557 a->data_window = NULL;
558 esas2r_debug("regions unmapped");
559 }
560}
561
562
563void esas2r_kill_adapter(int i)
564{
565 struct esas2r_adapter *a = esas2r_adapters[i];
566
567 if (a) {
568 unsigned long flags;
569 struct workqueue_struct *wq;
570 esas2r_debug("killing adapter %p [%d] ", a, i);
571 esas2r_fw_event_off(a);
572 esas2r_adapter_power_down(a, 0);
573 if (esas2r_buffered_ioctl &&
574 (a->pcid == esas2r_buffered_ioctl_pcid)) {
575 dma_free_coherent(&a->pcid->dev,
576 (size_t)esas2r_buffered_ioctl_size,
577 esas2r_buffered_ioctl,
578 esas2r_buffered_ioctl_addr);
579 esas2r_buffered_ioctl = NULL;
580 }
581
582 if (a->vda_buffer) {
583 dma_free_coherent(&a->pcid->dev,
584 (size_t)VDA_MAX_BUFFER_SIZE,
585 a->vda_buffer,
586 (dma_addr_t)a->ppvda_buffer);
587 a->vda_buffer = NULL;
588 }
589 if (a->fs_api_buffer) {
590 dma_free_coherent(&a->pcid->dev,
591 (size_t)a->fs_api_buffer_size,
592 a->fs_api_buffer,
593 (dma_addr_t)a->ppfs_api_buffer);
594 a->fs_api_buffer = NULL;
595 }
596
597 kfree(a->local_atto_ioctl);
598 a->local_atto_ioctl = NULL;
599
600 spin_lock_irqsave(&a->fw_event_lock, flags);
601 wq = a->fw_event_q;
602 a->fw_event_q = NULL;
603 spin_unlock_irqrestore(&a->fw_event_lock, flags);
604 if (wq)
605 destroy_workqueue(wq);
606
607 if (a->uncached) {
608 dma_free_coherent(&a->pcid->dev,
609 (size_t)a->uncached_size,
610 a->uncached,
611 (dma_addr_t)a->uncached_phys);
612 a->uncached = NULL;
613 esas2r_debug("uncached area freed");
614 }
615
616 esas2r_log_dev(ESAS2R_LOG_INFO,
617 &(a->pcid->dev),
618 "pci_disable_device() called. msix_enabled: %d "
619 "msi_enabled: %d irq: %d pin: %d",
620 a->pcid->msix_enabled,
621 a->pcid->msi_enabled,
622 a->pcid->irq,
623 a->pcid->pin);
624
625 esas2r_log_dev(ESAS2R_LOG_INFO,
626 &(a->pcid->dev),
627 "before pci_disable_device() enable_cnt: %d",
628 a->pcid->enable_cnt.counter);
629
630 pci_disable_device(a->pcid);
631 esas2r_log_dev(ESAS2R_LOG_INFO,
632 &(a->pcid->dev),
633 "after pci_disable_device() enable_cnt: %d",
634 a->pcid->enable_cnt.counter);
635
636 esas2r_log_dev(ESAS2R_LOG_INFO,
637 &(a->pcid->dev),
638 "pci_set_drv_data(%p, NULL) called",
639 a->pcid);
640
641 pci_set_drvdata(a->pcid, NULL);
642 esas2r_adapters[i] = NULL;
643
644 if (test_bit(AF2_INIT_DONE, &a->flags2)) {
645 clear_bit(AF2_INIT_DONE, &a->flags2);
646
647 set_bit(AF_DEGRADED_MODE, &a->flags);
648
649 esas2r_log_dev(ESAS2R_LOG_INFO,
650 &(a->host->shost_gendev),
651 "scsi_remove_host() called");
652
653 scsi_remove_host(a->host);
654
655 esas2r_log_dev(ESAS2R_LOG_INFO,
656 &(a->host->shost_gendev),
657 "scsi_host_put() called");
658
659 scsi_host_put(a->host);
660 }
661 }
662}
663
664int esas2r_cleanup(struct Scsi_Host *host)
665{
666 struct esas2r_adapter *a;
667 int index;
668
669 if (host == NULL) {
670 int i;
671
672 esas2r_debug("esas2r_cleanup everything");
673 for (i = 0; i < MAX_ADAPTERS; i++)
674 esas2r_kill_adapter(i);
675 return -1;
676 }
677
678 esas2r_debug("esas2r_cleanup called for host %p", host);
679 a = (struct esas2r_adapter *)host->hostdata;
680 index = a->index;
681 esas2r_kill_adapter(index);
682 return index;
683}
684
685int esas2r_suspend(struct pci_dev *pdev, pm_message_t state)
686{
687 struct Scsi_Host *host = pci_get_drvdata(pdev);
688 u32 device_state;
689 struct esas2r_adapter *a = (struct esas2r_adapter *)host->hostdata;
690
691 esas2r_log_dev(ESAS2R_LOG_INFO, &(pdev->dev), "suspending adapter()");
692 if (!a)
693 return -ENODEV;
694
695 esas2r_adapter_power_down(a, 1);
696 device_state = pci_choose_state(pdev, state);
697 esas2r_log_dev(ESAS2R_LOG_INFO, &(pdev->dev),
698 "pci_save_state() called");
699 pci_save_state(pdev);
700 esas2r_log_dev(ESAS2R_LOG_INFO, &(pdev->dev),
701 "pci_disable_device() called");
702 pci_disable_device(pdev);
703 esas2r_log_dev(ESAS2R_LOG_INFO, &(pdev->dev),
704 "pci_set_power_state() called");
705 pci_set_power_state(pdev, device_state);
706 esas2r_log_dev(ESAS2R_LOG_INFO, &(pdev->dev), "esas2r_suspend(): 0");
707 return 0;
708}
709
710int esas2r_resume(struct pci_dev *pdev)
711{
712 struct Scsi_Host *host = pci_get_drvdata(pdev);
713 struct esas2r_adapter *a = (struct esas2r_adapter *)host->hostdata;
714 int rez;
715
716 esas2r_log_dev(ESAS2R_LOG_INFO, &(pdev->dev), "resuming adapter()");
717 esas2r_log_dev(ESAS2R_LOG_INFO, &(pdev->dev),
718 "pci_set_power_state(PCI_D0) "
719 "called");
720 pci_set_power_state(pdev, PCI_D0);
721 esas2r_log_dev(ESAS2R_LOG_INFO, &(pdev->dev),
722 "pci_enable_wake(PCI_D0, 0) "
723 "called");
724 pci_enable_wake(pdev, PCI_D0, 0);
725 esas2r_log_dev(ESAS2R_LOG_INFO, &(pdev->dev),
726 "pci_restore_state() called");
727 pci_restore_state(pdev);
728 esas2r_log_dev(ESAS2R_LOG_INFO, &(pdev->dev),
729 "pci_enable_device() called");
730 rez = pci_enable_device(pdev);
731 pci_set_master(pdev);
732
733 if (!a) {
734 rez = -ENODEV;
735 goto error_exit;
736 }
737
738 if (esas2r_map_regions(a) != 0) {
739 esas2r_log(ESAS2R_LOG_CRIT, "could not re-map PCI regions!");
740 rez = -ENOMEM;
741 goto error_exit;
742 }
743
744
745 esas2r_setup_interrupts(a, a->intr_mode);
746
747
748
749
750
751 esas2r_disable_chip_interrupts(a);
752 if (!esas2r_power_up(a, true)) {
753 esas2r_debug("yikes, esas2r_power_up failed");
754 rez = -ENOMEM;
755 goto error_exit;
756 }
757
758 esas2r_claim_interrupts(a);
759
760 if (test_bit(AF2_IRQ_CLAIMED, &a->flags2)) {
761
762
763
764
765 esas2r_enable_chip_interrupts(a);
766 esas2r_kickoff_timer(a);
767 } else {
768 esas2r_debug("yikes, unable to claim IRQ");
769 esas2r_log(ESAS2R_LOG_CRIT, "could not re-claim IRQ!");
770 rez = -ENOMEM;
771 goto error_exit;
772 }
773
774error_exit:
775 esas2r_log_dev(ESAS2R_LOG_CRIT, &(pdev->dev), "esas2r_resume(): %d",
776 rez);
777 return rez;
778}
779
780bool esas2r_set_degraded_mode(struct esas2r_adapter *a, char *error_str)
781{
782 set_bit(AF_DEGRADED_MODE, &a->flags);
783 esas2r_log(ESAS2R_LOG_CRIT,
784 "setting adapter to degraded mode: %s\n", error_str);
785 return false;
786}
787
788u32 esas2r_get_uncached_size(struct esas2r_adapter *a)
789{
790 return sizeof(struct esas2r_sas_nvram)
791 + ALIGN(ESAS2R_DISC_BUF_LEN, 8)
792 + ALIGN(sizeof(u32), 8)
793 + 8
794 + (num_sg_lists * (u16)sgl_page_size)
795 + ALIGN((num_requests + num_ae_requests + 1 +
796 ESAS2R_LIST_EXTRA) *
797 sizeof(struct esas2r_inbound_list_source_entry),
798 8)
799 + ALIGN((num_requests + num_ae_requests + 1 +
800 ESAS2R_LIST_EXTRA) *
801 sizeof(struct atto_vda_ob_rsp), 8)
802 + 256;
803}
804
805static void esas2r_init_pci_cfg_space(struct esas2r_adapter *a)
806{
807 int pcie_cap_reg;
808
809 pcie_cap_reg = pci_find_capability(a->pcid, PCI_CAP_ID_EXP);
810 if (pcie_cap_reg) {
811 u16 devcontrol;
812
813 pci_read_config_word(a->pcid, pcie_cap_reg + PCI_EXP_DEVCTL,
814 &devcontrol);
815
816 if ((devcontrol & PCI_EXP_DEVCTL_READRQ) >
817 PCI_EXP_DEVCTL_READRQ_512B) {
818 esas2r_log(ESAS2R_LOG_INFO,
819 "max read request size > 512B");
820
821 devcontrol &= ~PCI_EXP_DEVCTL_READRQ;
822 devcontrol |= PCI_EXP_DEVCTL_READRQ_512B;
823 pci_write_config_word(a->pcid,
824 pcie_cap_reg + PCI_EXP_DEVCTL,
825 devcontrol);
826 }
827 }
828}
829
830
831
832
833
834bool esas2r_init_adapter_struct(struct esas2r_adapter *a,
835 void **uncached_area)
836{
837 u32 i;
838 u8 *high;
839 struct esas2r_inbound_list_source_entry *element;
840 struct esas2r_request *rq;
841 struct esas2r_mem_desc *sgl;
842
843 spin_lock_init(&a->sg_list_lock);
844 spin_lock_init(&a->mem_lock);
845 spin_lock_init(&a->queue_lock);
846
847 a->targetdb_end = &a->targetdb[ESAS2R_MAX_TARGETS];
848
849 if (!alloc_vda_req(a, &a->general_req)) {
850 esas2r_hdebug(
851 "failed to allocate a VDA request for the general req!");
852 return false;
853 }
854
855
856 a->first_ae_req =
857 kzalloc(num_ae_requests * sizeof(struct esas2r_request),
858 GFP_KERNEL);
859
860 if (a->first_ae_req == NULL) {
861 esas2r_log(ESAS2R_LOG_CRIT,
862 "failed to allocate memory for asynchronous events");
863 return false;
864 }
865
866
867 a->sg_list_mds = kzalloc(
868 num_sg_lists * sizeof(struct esas2r_mem_desc), GFP_KERNEL);
869
870 if (a->sg_list_mds == NULL) {
871 esas2r_log(ESAS2R_LOG_CRIT,
872 "failed to allocate memory for s/g list descriptors");
873 return false;
874 }
875
876
877 a->req_table =
878 kzalloc((num_requests + num_ae_requests +
879 1) * sizeof(struct esas2r_request *), GFP_KERNEL);
880
881 if (a->req_table == NULL) {
882 esas2r_log(ESAS2R_LOG_CRIT,
883 "failed to allocate memory for the request table");
884 return false;
885 }
886
887
888 esas2r_init_pci_cfg_space(a);
889
890
891
892
893
894 if ((a->pcid->subsystem_vendor == ATTO_VENDOR_ID)
895 && (a->pcid->subsystem_device & ATTO_SSDID_TBT))
896 a->flags2 |= AF2_THUNDERBOLT;
897
898 if (test_bit(AF2_THUNDERBOLT, &a->flags2))
899 a->flags2 |= AF2_SERIAL_FLASH;
900
901 if (a->pcid->subsystem_device == ATTO_TLSH_1068)
902 a->flags2 |= AF2_THUNDERLINK;
903
904
905 high = (u8 *)*uncached_area;
906
907
908
909 for (i = 0, sgl = a->sg_list_mds; i < num_sg_lists; i++, sgl++) {
910 sgl->size = sgl_page_size;
911
912 list_add_tail(&sgl->next_desc, &a->free_sg_list_head);
913
914 if (!esas2r_initmem_alloc(a, sgl, ESAS2R_SGL_ALIGN)) {
915
916 if (i < NUM_SGL_MIN)
917 return false;
918 break;
919 }
920 }
921
922
923 a->list_size = num_requests + ESAS2R_LIST_EXTRA;
924
925
926 a->inbound_list_md.size = a->list_size *
927 sizeof(struct
928 esas2r_inbound_list_source_entry);
929
930 if (!esas2r_initmem_alloc(a, &a->inbound_list_md, ESAS2R_LIST_ALIGN)) {
931 esas2r_hdebug("failed to allocate IB list");
932 return false;
933 }
934
935
936 a->outbound_list_md.size = a->list_size *
937 sizeof(struct atto_vda_ob_rsp);
938
939 if (!esas2r_initmem_alloc(a, &a->outbound_list_md,
940 ESAS2R_LIST_ALIGN)) {
941 esas2r_hdebug("failed to allocate IB list");
942 return false;
943 }
944
945
946 a->nvram = (struct esas2r_sas_nvram *)high;
947 high += sizeof(struct esas2r_sas_nvram);
948
949
950 a->disc_buffer = high;
951 high += ESAS2R_DISC_BUF_LEN;
952 high = PTR_ALIGN(high, 8);
953
954
955 a->outbound_copy = (u32 volatile *)high;
956 high += sizeof(u32);
957
958 if (!test_bit(AF_NVR_VALID, &a->flags))
959 esas2r_nvram_set_defaults(a);
960
961
962 *uncached_area = (void *)high;
963
964
965 if (test_bit(AF_FIRST_INIT, &a->flags)) {
966 memset(a->req_table, 0,
967 (num_requests + num_ae_requests +
968 1) * sizeof(struct esas2r_request *));
969
970 esas2r_targ_db_initialize(a);
971
972
973 element =
974 (struct esas2r_inbound_list_source_entry *)a->
975 inbound_list_md.
976 virt_addr;
977
978 for (i = 0; i < a->list_size; i++) {
979 element->address = 0;
980 element->reserved = 0;
981 element->length = cpu_to_le32(HWILSE_INTERFACE_F0
982 | (sizeof(union
983 atto_vda_req)
984 /
985 sizeof(u32)));
986 element++;
987 }
988
989
990 for (rq = a->first_ae_req, i = 0; i < num_ae_requests; rq++,
991 i++) {
992 INIT_LIST_HEAD(&rq->req_list);
993 if (!alloc_vda_req(a, rq)) {
994 esas2r_hdebug(
995 "failed to allocate a VDA request!");
996 return false;
997 }
998
999 esas2r_rq_init_request(rq, a);
1000
1001
1002 rq->comp_cb = esas2r_ae_complete;
1003 }
1004 }
1005
1006 return true;
1007}
1008
1009
1010bool esas2r_check_adapter(struct esas2r_adapter *a)
1011{
1012 u32 starttime;
1013 u32 doorbell;
1014 u64 ppaddr;
1015 u32 dw;
1016
1017
1018
1019
1020
1021 if (test_bit(AF_CHPRST_DETECTED, &a->flags))
1022 goto skip_chip_reset;
1023
1024
1025
1026
1027
1028 esas2r_write_register_dword(a, MU_INT_MASK_OUT, ESAS2R_INT_DIS_MASK);
1029 esas2r_flush_register_dword(a, MU_INT_MASK_OUT);
1030
1031
1032
1033
1034
1035 starttime = jiffies_to_msecs(jiffies);
1036
1037 while (true) {
1038 esas2r_force_interrupt(a);
1039 doorbell = esas2r_read_register_dword(a, MU_DOORBELL_OUT);
1040 if (doorbell == 0xFFFFFFFF) {
1041
1042
1043
1044
1045 if ((jiffies_to_msecs(jiffies) - starttime) > 2000)
1046 return esas2r_set_degraded_mode(a,
1047 "unable to access registers");
1048 } else if (doorbell & DRBL_FORCE_INT) {
1049 u32 ver = (doorbell & DRBL_FW_VER_MSK);
1050
1051
1052
1053
1054
1055 esas2r_write_register_dword(a, MU_DOORBELL_OUT,
1056 doorbell);
1057
1058 if (ver == DRBL_FW_VER_0) {
1059 set_bit(AF_LEGACY_SGE_MODE, &a->flags);
1060
1061 a->max_vdareq_size = 128;
1062 a->build_sgl = esas2r_build_sg_list_sge;
1063 } else if (ver == DRBL_FW_VER_1) {
1064 clear_bit(AF_LEGACY_SGE_MODE, &a->flags);
1065
1066 a->max_vdareq_size = 1024;
1067 a->build_sgl = esas2r_build_sg_list_prd;
1068 } else {
1069 return esas2r_set_degraded_mode(a,
1070 "unknown firmware version");
1071 }
1072 break;
1073 }
1074
1075 schedule_timeout_interruptible(msecs_to_jiffies(100));
1076
1077 if ((jiffies_to_msecs(jiffies) - starttime) > 180000) {
1078 esas2r_hdebug("FW ready TMO");
1079 esas2r_bugon();
1080
1081 return esas2r_set_degraded_mode(a,
1082 "firmware start has timed out");
1083 }
1084 }
1085
1086
1087 esas2r_write_register_dword(a, MU_DOORBELL_IN, DRBL_MSG_IFC_DOWN);
1088 starttime = jiffies_to_msecs(jiffies);
1089
1090 while (true) {
1091 doorbell = esas2r_read_register_dword(a, MU_DOORBELL_OUT);
1092 if (doorbell & DRBL_MSG_IFC_DOWN) {
1093 esas2r_write_register_dword(a, MU_DOORBELL_OUT,
1094 doorbell);
1095 break;
1096 }
1097
1098 schedule_timeout_interruptible(msecs_to_jiffies(50));
1099
1100 if ((jiffies_to_msecs(jiffies) - starttime) > 3000) {
1101 esas2r_hdebug("timeout waiting for interface down");
1102 break;
1103 }
1104 }
1105skip_chip_reset:
1106
1107
1108
1109
1110 dw = esas2r_read_register_dword(a, MU_IN_LIST_CONFIG);
1111 dw &= ~MU_ILC_ENABLE;
1112 esas2r_write_register_dword(a, MU_IN_LIST_CONFIG, dw);
1113 dw = esas2r_read_register_dword(a, MU_OUT_LIST_CONFIG);
1114 dw &= ~MU_OLC_ENABLE;
1115 esas2r_write_register_dword(a, MU_OUT_LIST_CONFIG, dw);
1116
1117
1118 ppaddr = a->inbound_list_md.phys_addr;
1119 esas2r_write_register_dword(a, MU_IN_LIST_ADDR_LO,
1120 lower_32_bits(ppaddr));
1121 esas2r_write_register_dword(a, MU_IN_LIST_ADDR_HI,
1122 upper_32_bits(ppaddr));
1123 ppaddr = a->outbound_list_md.phys_addr;
1124 esas2r_write_register_dword(a, MU_OUT_LIST_ADDR_LO,
1125 lower_32_bits(ppaddr));
1126 esas2r_write_register_dword(a, MU_OUT_LIST_ADDR_HI,
1127 upper_32_bits(ppaddr));
1128 ppaddr = a->uncached_phys +
1129 ((u8 *)a->outbound_copy - a->uncached);
1130 esas2r_write_register_dword(a, MU_OUT_LIST_COPY_PTR_LO,
1131 lower_32_bits(ppaddr));
1132 esas2r_write_register_dword(a, MU_OUT_LIST_COPY_PTR_HI,
1133 upper_32_bits(ppaddr));
1134
1135
1136 *a->outbound_copy =
1137 a->last_write =
1138 a->last_read = a->list_size - 1;
1139 set_bit(AF_COMM_LIST_TOGGLE, &a->flags);
1140 esas2r_write_register_dword(a, MU_IN_LIST_WRITE, MU_ILW_TOGGLE |
1141 a->last_write);
1142 esas2r_write_register_dword(a, MU_OUT_LIST_COPY, MU_OLC_TOGGLE |
1143 a->last_write);
1144 esas2r_write_register_dword(a, MU_IN_LIST_READ, MU_ILR_TOGGLE |
1145 a->last_write);
1146 esas2r_write_register_dword(a, MU_OUT_LIST_WRITE,
1147 MU_OLW_TOGGLE | a->last_write);
1148
1149
1150 dw = esas2r_read_register_dword(a, MU_IN_LIST_IFC_CONFIG);
1151 dw &= ~(MU_ILIC_LIST | MU_ILIC_DEST);
1152 esas2r_write_register_dword(a, MU_IN_LIST_IFC_CONFIG,
1153 (dw | MU_ILIC_LIST_F0 | MU_ILIC_DEST_DDR));
1154 dw = esas2r_read_register_dword(a, MU_OUT_LIST_IFC_CONFIG);
1155 dw &= ~(MU_OLIC_LIST | MU_OLIC_SOURCE);
1156 esas2r_write_register_dword(a, MU_OUT_LIST_IFC_CONFIG,
1157 (dw | MU_OLIC_LIST_F0 |
1158 MU_OLIC_SOURCE_DDR));
1159
1160
1161 dw = esas2r_read_register_dword(a, MU_IN_LIST_CONFIG);
1162 dw &= ~(MU_ILC_ENTRY_MASK | MU_ILC_NUMBER_MASK);
1163 dw |= MU_ILC_ENTRY_4_DW | MU_ILC_DYNAMIC_SRC
1164 | (a->list_size << MU_ILC_NUMBER_SHIFT);
1165 esas2r_write_register_dword(a, MU_IN_LIST_CONFIG, dw);
1166 dw = esas2r_read_register_dword(a, MU_OUT_LIST_CONFIG);
1167 dw &= ~(MU_OLC_ENTRY_MASK | MU_OLC_NUMBER_MASK);
1168 dw |= MU_OLC_ENTRY_4_DW | (a->list_size << MU_OLC_NUMBER_SHIFT);
1169 esas2r_write_register_dword(a, MU_OUT_LIST_CONFIG, dw);
1170
1171
1172
1173
1174
1175
1176 esas2r_write_register_dword(a, MU_DOORBELL_IN, DRBL_MSG_IFC_INIT);
1177 starttime = jiffies_to_msecs(jiffies);
1178
1179 while (true) {
1180 doorbell = esas2r_read_register_dword(a, MU_DOORBELL_OUT);
1181 if (doorbell & DRBL_MSG_IFC_INIT) {
1182 esas2r_write_register_dword(a, MU_DOORBELL_OUT,
1183 doorbell);
1184 break;
1185 }
1186
1187 schedule_timeout_interruptible(msecs_to_jiffies(100));
1188
1189 if ((jiffies_to_msecs(jiffies) - starttime) > 3000) {
1190 esas2r_hdebug(
1191 "timeout waiting for communication list init");
1192 esas2r_bugon();
1193 return esas2r_set_degraded_mode(a,
1194 "timeout waiting for communication list init");
1195 }
1196 }
1197
1198
1199
1200
1201
1202 doorbell = esas2r_read_register_dword(a, MU_DOORBELL_IN_ENB);
1203 if (doorbell & DRBL_POWER_DOWN)
1204 set_bit(AF2_VDA_POWER_DOWN, &a->flags2);
1205 else
1206 clear_bit(AF2_VDA_POWER_DOWN, &a->flags2);
1207
1208
1209
1210
1211
1212 esas2r_write_register_dword(a, MU_OUT_LIST_INT_MASK, MU_OLIS_MASK);
1213 esas2r_write_register_dword(a, MU_DOORBELL_OUT_ENB, DRBL_ENB_MASK);
1214 return true;
1215}
1216
1217
1218static bool esas2r_format_init_msg(struct esas2r_adapter *a,
1219 struct esas2r_request *rq)
1220{
1221 u32 msg = a->init_msg;
1222 struct atto_vda_cfg_init *ci;
1223
1224 a->init_msg = 0;
1225
1226 switch (msg) {
1227 case ESAS2R_INIT_MSG_START:
1228 case ESAS2R_INIT_MSG_REINIT:
1229 {
1230 struct timeval now;
1231 do_gettimeofday(&now);
1232 esas2r_hdebug("CFG init");
1233 esas2r_build_cfg_req(a,
1234 rq,
1235 VDA_CFG_INIT,
1236 0,
1237 NULL);
1238 ci = (struct atto_vda_cfg_init *)&rq->vrq->cfg.data.init;
1239 ci->sgl_page_size = cpu_to_le32(sgl_page_size);
1240 ci->epoch_time = cpu_to_le32(now.tv_sec);
1241 rq->flags |= RF_FAILURE_OK;
1242 a->init_msg = ESAS2R_INIT_MSG_INIT;
1243 break;
1244 }
1245
1246 case ESAS2R_INIT_MSG_INIT:
1247 if (rq->req_stat == RS_SUCCESS) {
1248 u32 major;
1249 u32 minor;
1250 u16 fw_release;
1251
1252 a->fw_version = le16_to_cpu(
1253 rq->func_rsp.cfg_rsp.vda_version);
1254 a->fw_build = rq->func_rsp.cfg_rsp.fw_build;
1255 fw_release = le16_to_cpu(
1256 rq->func_rsp.cfg_rsp.fw_release);
1257 major = LOBYTE(fw_release);
1258 minor = HIBYTE(fw_release);
1259 a->fw_version += (major << 16) + (minor << 24);
1260 } else {
1261 esas2r_hdebug("FAILED");
1262 }
1263
1264
1265
1266
1267
1268
1269 if ((test_bit(AF2_THUNDERBOLT, &a->flags2))
1270 || (be32_to_cpu(a->fw_version) > 0x00524702)) {
1271 esas2r_hdebug("CFG get init");
1272 esas2r_build_cfg_req(a,
1273 rq,
1274 VDA_CFG_GET_INIT2,
1275 sizeof(struct atto_vda_cfg_init),
1276 NULL);
1277
1278 rq->vrq->cfg.sg_list_offset = offsetof(
1279 struct atto_vda_cfg_req,
1280 data.sge);
1281 rq->vrq->cfg.data.prde.ctl_len =
1282 cpu_to_le32(sizeof(struct atto_vda_cfg_init));
1283 rq->vrq->cfg.data.prde.address = cpu_to_le64(
1284 rq->vrq_md->phys_addr +
1285 sizeof(union atto_vda_req));
1286 rq->flags |= RF_FAILURE_OK;
1287 a->init_msg = ESAS2R_INIT_MSG_GET_INIT;
1288 break;
1289 }
1290
1291 case ESAS2R_INIT_MSG_GET_INIT:
1292 if (msg == ESAS2R_INIT_MSG_GET_INIT) {
1293 ci = (struct atto_vda_cfg_init *)rq->data_buf;
1294 if (rq->req_stat == RS_SUCCESS) {
1295 a->num_targets_backend =
1296 le32_to_cpu(ci->num_targets_backend);
1297 a->ioctl_tunnel =
1298 le32_to_cpu(ci->ioctl_tunnel);
1299 } else {
1300 esas2r_hdebug("FAILED");
1301 }
1302 }
1303
1304
1305 default:
1306 rq->req_stat = RS_SUCCESS;
1307 return false;
1308 }
1309 return true;
1310}
1311
1312
1313
1314
1315
1316bool esas2r_init_msgs(struct esas2r_adapter *a)
1317{
1318 bool success = true;
1319 struct esas2r_request *rq = &a->general_req;
1320
1321 esas2r_rq_init_request(rq, a);
1322 rq->comp_cb = esas2r_dummy_complete;
1323
1324 if (a->init_msg == 0)
1325 a->init_msg = ESAS2R_INIT_MSG_REINIT;
1326
1327 while (a->init_msg) {
1328 if (esas2r_format_init_msg(a, rq)) {
1329 unsigned long flags;
1330 while (true) {
1331 spin_lock_irqsave(&a->queue_lock, flags);
1332 esas2r_start_vda_request(a, rq);
1333 spin_unlock_irqrestore(&a->queue_lock, flags);
1334 esas2r_wait_request(a, rq);
1335 if (rq->req_stat != RS_PENDING)
1336 break;
1337 }
1338 }
1339
1340 if (rq->req_stat == RS_SUCCESS
1341 || ((rq->flags & RF_FAILURE_OK)
1342 && rq->req_stat != RS_TIMEOUT))
1343 continue;
1344
1345 esas2r_log(ESAS2R_LOG_CRIT, "init message %x failed (%x, %x)",
1346 a->init_msg, rq->req_stat, rq->flags);
1347 a->init_msg = ESAS2R_INIT_MSG_START;
1348 success = false;
1349 break;
1350 }
1351
1352 esas2r_rq_destroy_request(rq, a);
1353 return success;
1354}
1355
1356
1357bool esas2r_init_adapter_hw(struct esas2r_adapter *a, bool init_poll)
1358{
1359 bool rslt = false;
1360 struct esas2r_request *rq;
1361 u32 i;
1362
1363 if (test_bit(AF_DEGRADED_MODE, &a->flags))
1364 goto exit;
1365
1366 if (!test_bit(AF_NVR_VALID, &a->flags)) {
1367 if (!esas2r_nvram_read_direct(a))
1368 esas2r_log(ESAS2R_LOG_WARN,
1369 "invalid/missing NVRAM parameters");
1370 }
1371
1372 if (!esas2r_init_msgs(a)) {
1373 esas2r_set_degraded_mode(a, "init messages failed");
1374 goto exit;
1375 }
1376
1377
1378 clear_bit(AF_DEGRADED_MODE, &a->flags);
1379 clear_bit(AF_CHPRST_PENDING, &a->flags);
1380
1381
1382 for (i = 0, rq = a->first_ae_req; i < num_ae_requests; i++, rq++)
1383 esas2r_start_ae_request(a, rq);
1384
1385 if (!a->flash_rev[0])
1386 esas2r_read_flash_rev(a);
1387
1388 if (!a->image_type[0])
1389 esas2r_read_image_type(a);
1390
1391 if (a->fw_version == 0)
1392 a->fw_rev[0] = 0;
1393 else
1394 sprintf(a->fw_rev, "%1d.%02d",
1395 (int)LOBYTE(HIWORD(a->fw_version)),
1396 (int)HIBYTE(HIWORD(a->fw_version)));
1397
1398 esas2r_hdebug("firmware revision: %s", a->fw_rev);
1399
1400 if (test_bit(AF_CHPRST_DETECTED, &a->flags)
1401 && (test_bit(AF_FIRST_INIT, &a->flags))) {
1402 esas2r_enable_chip_interrupts(a);
1403 return true;
1404 }
1405
1406
1407 esas2r_disc_initialize(a);
1408
1409
1410
1411
1412
1413
1414
1415
1416 if (init_poll) {
1417 u32 currtime = a->disc_start_time;
1418 u32 nexttick = 100;
1419 u32 deltatime;
1420
1421
1422
1423
1424
1425 set_bit(AF_TASKLET_SCHEDULED, &a->flags);
1426 set_bit(AF_DISC_POLLED, &a->flags);
1427
1428
1429
1430
1431
1432
1433 if (test_bit(AF_FIRST_INIT, &a->flags))
1434 atomic_dec(&a->disable_cnt);
1435
1436 while (test_bit(AF_DISC_PENDING, &a->flags)) {
1437 schedule_timeout_interruptible(msecs_to_jiffies(100));
1438
1439
1440
1441
1442
1443
1444
1445
1446 deltatime = jiffies_to_msecs(jiffies) - currtime;
1447 currtime += deltatime;
1448
1449
1450
1451
1452
1453
1454
1455 if (!test_bit(AF_CHPRST_PENDING, &a->flags))
1456 esas2r_disc_check_for_work(a);
1457
1458
1459 if (nexttick <= deltatime) {
1460
1461
1462 nexttick += 100;
1463 esas2r_timer_tick(a);
1464 }
1465
1466 if (nexttick > deltatime)
1467 nexttick -= deltatime;
1468
1469
1470 if (esas2r_is_tasklet_pending(a))
1471 esas2r_do_tasklet_tasks(a);
1472
1473 }
1474
1475 if (test_bit(AF_FIRST_INIT, &a->flags))
1476 atomic_inc(&a->disable_cnt);
1477
1478 clear_bit(AF_DISC_POLLED, &a->flags);
1479 clear_bit(AF_TASKLET_SCHEDULED, &a->flags);
1480 }
1481
1482
1483 esas2r_targ_db_report_changes(a);
1484
1485
1486
1487
1488
1489
1490
1491
1492 esas2r_disc_start_waiting(a);
1493
1494
1495 a->int_mask = ESAS2R_INT_STS_MASK;
1496 esas2r_enable_chip_interrupts(a);
1497 esas2r_enable_heartbeat(a);
1498 rslt = true;
1499
1500exit:
1501
1502
1503
1504
1505
1506 if (test_bit(AF_CHPRST_DETECTED, &a->flags) &&
1507 test_bit(AF_FIRST_INIT, &a->flags)) {
1508
1509
1510
1511
1512
1513 if (!rslt)
1514 clear_bit(AF_CHPRST_PENDING, &a->flags);
1515 } else {
1516
1517 if (!rslt) {
1518 clear_bit(AF_CHPRST_PENDING, &a->flags);
1519 clear_bit(AF_DISC_PENDING, &a->flags);
1520 }
1521
1522
1523
1524 if (test_bit(AF_FIRST_INIT, &a->flags)) {
1525 clear_bit(AF_FIRST_INIT, &a->flags);
1526
1527 if (atomic_dec_return(&a->disable_cnt) == 0)
1528 esas2r_do_deferred_processes(a);
1529 }
1530 }
1531
1532 return rslt;
1533}
1534
1535void esas2r_reset_adapter(struct esas2r_adapter *a)
1536{
1537 set_bit(AF_OS_RESET, &a->flags);
1538 esas2r_local_reset_adapter(a);
1539 esas2r_schedule_tasklet(a);
1540}
1541
1542void esas2r_reset_chip(struct esas2r_adapter *a)
1543{
1544 if (!esas2r_is_adapter_present(a))
1545 return;
1546
1547
1548
1549
1550
1551
1552 if (test_bit(AF2_COREDUMP_AVAIL, &a->flags2) &&
1553 !test_bit(AF2_COREDUMP_SAVED, &a->flags2)) {
1554 esas2r_read_mem_block(a,
1555 a->fw_coredump_buff,
1556 MW_DATA_ADDR_SRAM + 0x80000,
1557 ESAS2R_FWCOREDUMP_SZ);
1558
1559 set_bit(AF2_COREDUMP_SAVED, &a->flags2);
1560 }
1561
1562 clear_bit(AF2_COREDUMP_AVAIL, &a->flags2);
1563
1564
1565 if (a->pcid->revision == MVR_FREY_B2)
1566 esas2r_write_register_dword(a, MU_CTL_STATUS_IN_B2,
1567 MU_CTL_IN_FULL_RST2);
1568 else
1569 esas2r_write_register_dword(a, MU_CTL_STATUS_IN,
1570 MU_CTL_IN_FULL_RST);
1571
1572
1573
1574 mdelay(10);
1575}
1576
1577static void esas2r_power_down_notify_firmware(struct esas2r_adapter *a)
1578{
1579 u32 starttime;
1580 u32 doorbell;
1581
1582 esas2r_write_register_dword(a, MU_DOORBELL_IN, DRBL_POWER_DOWN);
1583 starttime = jiffies_to_msecs(jiffies);
1584
1585 while (true) {
1586 doorbell = esas2r_read_register_dword(a, MU_DOORBELL_OUT);
1587 if (doorbell & DRBL_POWER_DOWN) {
1588 esas2r_write_register_dword(a, MU_DOORBELL_OUT,
1589 doorbell);
1590 break;
1591 }
1592
1593 schedule_timeout_interruptible(msecs_to_jiffies(100));
1594
1595 if ((jiffies_to_msecs(jiffies) - starttime) > 30000) {
1596 esas2r_hdebug("Timeout waiting for power down");
1597 break;
1598 }
1599 }
1600}
1601
1602
1603
1604
1605
1606void esas2r_power_down(struct esas2r_adapter *a)
1607{
1608 set_bit(AF_POWER_MGT, &a->flags);
1609 set_bit(AF_POWER_DOWN, &a->flags);
1610
1611 if (!test_bit(AF_DEGRADED_MODE, &a->flags)) {
1612 u32 starttime;
1613 u32 doorbell;
1614
1615
1616
1617
1618
1619
1620
1621 esas2r_disable_chip_interrupts(a);
1622 esas2r_disable_heartbeat(a);
1623
1624
1625 esas2r_write_register_dword(a, MU_DOORBELL_IN,
1626 DRBL_MSG_IFC_DOWN);
1627 starttime = jiffies_to_msecs(jiffies);
1628
1629 while (true) {
1630 doorbell =
1631 esas2r_read_register_dword(a, MU_DOORBELL_OUT);
1632 if (doorbell & DRBL_MSG_IFC_DOWN) {
1633 esas2r_write_register_dword(a, MU_DOORBELL_OUT,
1634 doorbell);
1635 break;
1636 }
1637
1638 schedule_timeout_interruptible(msecs_to_jiffies(100));
1639
1640 if ((jiffies_to_msecs(jiffies) - starttime) > 3000) {
1641 esas2r_hdebug(
1642 "timeout waiting for interface down");
1643 break;
1644 }
1645 }
1646
1647
1648
1649
1650
1651 if (test_bit(AF2_VDA_POWER_DOWN, &a->flags2))
1652 esas2r_power_down_notify_firmware(a);
1653 }
1654
1655
1656 set_bit(AF_OS_RESET, &a->flags);
1657 set_bit(AF_DISC_PENDING, &a->flags);
1658 set_bit(AF_CHPRST_PENDING, &a->flags);
1659
1660 esas2r_process_adapter_reset(a);
1661
1662
1663 a->prev_dev_cnt = esas2r_targ_db_get_tgt_cnt(a);
1664 esas2r_targ_db_remove_all(a, false);
1665}
1666
1667
1668
1669
1670
1671bool esas2r_power_up(struct esas2r_adapter *a, bool init_poll)
1672{
1673 bool ret;
1674
1675 clear_bit(AF_POWER_DOWN, &a->flags);
1676 esas2r_init_pci_cfg_space(a);
1677 set_bit(AF_FIRST_INIT, &a->flags);
1678 atomic_inc(&a->disable_cnt);
1679
1680
1681 ret = esas2r_check_adapter(a);
1682 if (!esas2r_init_adapter_hw(a, init_poll))
1683 ret = false;
1684
1685
1686 esas2r_send_reset_ae(a, true);
1687
1688
1689 clear_bit(AF_POWER_MGT, &a->flags);
1690 return ret;
1691}
1692
1693bool esas2r_is_adapter_present(struct esas2r_adapter *a)
1694{
1695 if (test_bit(AF_NOT_PRESENT, &a->flags))
1696 return false;
1697
1698 if (esas2r_read_register_dword(a, MU_DOORBELL_OUT) == 0xFFFFFFFF) {
1699 set_bit(AF_NOT_PRESENT, &a->flags);
1700
1701 return false;
1702 }
1703 return true;
1704}
1705
1706const char *esas2r_get_model_name(struct esas2r_adapter *a)
1707{
1708 switch (a->pcid->subsystem_device) {
1709 case ATTO_ESAS_R680:
1710 return "ATTO ExpressSAS R680";
1711
1712 case ATTO_ESAS_R608:
1713 return "ATTO ExpressSAS R608";
1714
1715 case ATTO_ESAS_R60F:
1716 return "ATTO ExpressSAS R60F";
1717
1718 case ATTO_ESAS_R6F0:
1719 return "ATTO ExpressSAS R6F0";
1720
1721 case ATTO_ESAS_R644:
1722 return "ATTO ExpressSAS R644";
1723
1724 case ATTO_ESAS_R648:
1725 return "ATTO ExpressSAS R648";
1726
1727 case ATTO_TSSC_3808:
1728 return "ATTO ThunderStream SC 3808D";
1729
1730 case ATTO_TSSC_3808E:
1731 return "ATTO ThunderStream SC 3808E";
1732
1733 case ATTO_TLSH_1068:
1734 return "ATTO ThunderLink SH 1068";
1735 }
1736
1737 return "ATTO SAS Controller";
1738}
1739
1740const char *esas2r_get_model_name_short(struct esas2r_adapter *a)
1741{
1742 switch (a->pcid->subsystem_device) {
1743 case ATTO_ESAS_R680:
1744 return "R680";
1745
1746 case ATTO_ESAS_R608:
1747 return "R608";
1748
1749 case ATTO_ESAS_R60F:
1750 return "R60F";
1751
1752 case ATTO_ESAS_R6F0:
1753 return "R6F0";
1754
1755 case ATTO_ESAS_R644:
1756 return "R644";
1757
1758 case ATTO_ESAS_R648:
1759 return "R648";
1760
1761 case ATTO_TSSC_3808:
1762 return "SC 3808D";
1763
1764 case ATTO_TSSC_3808E:
1765 return "SC 3808E";
1766
1767 case ATTO_TLSH_1068:
1768 return "SH 1068";
1769 }
1770
1771 return "unknown";
1772}
1773
