Lines Matching defs:a
38 * You should have received a copy of the GNU General Public License
50 * allocate a DMA-able memory area to communicate with the firmware. In
52 * we will allocate a global buffer the first time we need it and re-use
70 struct esas2r_adapter *a;
84 static void complete_fm_api_req(struct esas2r_adapter *a,
87 a->fm_api_command_done = 1;
88 wake_up_interruptible(&a->fm_api_waiter);
94 struct esas2r_adapter *a = (struct esas2r_adapter *)sgc->adapter;
95 int offset = sgc->cur_offset - a->save_offset;
97 (*addr) = a->firmware.phys + offset;
98 return a->firmware.orig_len - offset;
103 struct esas2r_adapter *a = (struct esas2r_adapter *)sgc->adapter;
104 int offset = sgc->cur_offset - a->save_offset;
106 (*addr) = a->firmware.header_buff_phys + offset;
111 static void do_fm_api(struct esas2r_adapter *a, struct esas2r_flash_img *fi)
115 if (mutex_lock_interruptible(&a->fm_api_mutex)) {
120 rq = esas2r_alloc_request(a);
126 if (fi == &a->firmware.header) {
127 a->firmware.header_buff = dma_alloc_coherent(&a->pcid->dev,
131 (dma_addr_t *)&a->
136 if (a->firmware.header_buff == NULL) {
142 memcpy(a->firmware.header_buff, fi,
144 a->save_offset = a->firmware.header_buff;
145 a->fm_api_sgc.get_phys_addr =
148 a->save_offset = (u8 *)fi;
149 a->fm_api_sgc.get_phys_addr =
154 a->fm_api_command_done = 0;
155 a->fm_api_sgc.cur_offset = a->save_offset;
157 if (!esas2r_fm_api(a, (struct esas2r_flash_img *)a->save_offset, rq,
158 &a->fm_api_sgc))
162 while (!a->fm_api_command_done)
163 wait_event_interruptible(a->fm_api_waiter,
164 a->fm_api_command_done);
166 if (fi == &a->firmware.header) {
167 memcpy(fi, a->firmware.header_buff,
170 dma_free_coherent(&a->pcid->dev,
172 a->firmware.header_buff,
173 (dma_addr_t)a->firmware.header_buff_phys);
176 esas2r_free_request(a, (struct esas2r_request *)rq);
178 mutex_unlock(&a->fm_api_mutex);
183 static void complete_nvr_req(struct esas2r_adapter *a,
186 a->nvram_command_done = 1;
187 wake_up_interruptible(&a->nvram_waiter);
200 static void complete_buffered_ioctl_req(struct esas2r_adapter *a,
203 a->buffered_ioctl_done = 1;
204 wake_up_interruptible(&a->buffered_ioctl_waiter);
209 struct esas2r_adapter *a = bi->a;
217 /* allocate a buffer or use the existing buffer. */
220 /* free the too-small buffer and get a new one */
221 dma_free_coherent(&a->pcid->dev,
231 esas2r_buffered_ioctl_pcid = a->pcid;
232 esas2r_buffered_ioctl = dma_alloc_coherent(&a->pcid->dev,
243 "for a buffered ioctl!",
253 rq = esas2r_alloc_request(a);
263 a->buffered_ioctl_done = 0;
269 if (!(*bi->callback)(a, rq, &sgc, bi->context)) {
271 a->buffered_ioctl_done = 0;
276 while (!a->buffered_ioctl_done)
277 wait_event_interruptible(a->buffered_ioctl_waiter,
278 a->buffered_ioctl_done);
282 (*bi->done_callback)(a, rq, bi->done_context);
284 esas2r_free_request(a, rq);
295 static int smp_ioctl_callback(struct esas2r_adapter *a,
302 esas2r_sgc_init(sgc, a, rq, rq->vrq->ioctl.sge);
303 esas2r_build_ioctl_req(a, rq, sgc->length, VDA_IOCTL_SMP);
305 if (!esas2r_build_sg_list(a, rq, sgc)) {
310 esas2r_start_request(a, rq);
314 static u8 handle_smp_ioctl(struct esas2r_adapter *a, struct atto_ioctl_smp *si)
320 bi.a = a;
332 static void esas2r_csmi_ioctl_tunnel_comp_cb(struct esas2r_adapter *a,
339 (*rq->aux_req_cb)(a, rq);
342 /* Tunnel a CSMI IOCTL to the back end driver for processing. */
343 static bool csmi_ioctl_tunnel(struct esas2r_adapter *a,
352 if (test_bit(AF_DEGRADED_MODE, &a->flags))
355 esas2r_sgc_init(sgc, a, rq, rq->vrq->ioctl.sge);
356 esas2r_build_ioctl_req(a, rq, sgc->length, VDA_IOCTL_CSMI);
369 if (!esas2r_build_sg_list(a, rq, sgc))
372 esas2r_start_request(a, rq);
392 static int csmi_ioctl_callback(struct esas2r_adapter *a,
434 strcpy(gdi->description, esas2r_get_model_name(a));
445 pci_read_config_dword(a->pcid, PCI_BASE_ADDRESS_2,
447 pci_read_config_dword(a->pcid, PCI_BASE_ADDRESS_3,
449 gcc->board_id = MAKEDWORD(a->pcid->subsystem_device,
450 a->pcid->subsystem_vendor);
454 gcc->pci_addr.bus_num = a->pcid->bus->number;
455 gcc->pci_addr.device_num = PCI_SLOT(a->pcid->devfn);
456 gcc->pci_addr.function_num = PCI_FUNC(a->pcid->devfn);
460 gcc->major_rev = LOBYTE(LOWORD(a->fw_version));
461 gcc->minor_rev = HIBYTE(LOWORD(a->fw_version));
462 gcc->build_rev = LOBYTE(HIWORD(a->fw_version));
463 gcc->release_rev = HIBYTE(HIWORD(a->fw_version));
464 gcc->bios_major_rev = HIBYTE(HIWORD(a->flash_ver));
465 gcc->bios_minor_rev = LOBYTE(HIWORD(a->flash_ver));
466 gcc->bios_build_rev = LOWORD(a->flash_ver);
468 if (test_bit(AF2_THUNDERLINK, &a->flags2))
490 if (test_bit(AF_DEGRADED_MODE, &a->flags))
516 if (!csmi_ioctl_tunnel(a, ioctl_csmi, rq, sgc,
539 spin_lock_irqsave(&a->mem_lock, flags);
540 t = esas2r_targ_db_find_by_sas_addr(a, (u64 *)gsa->sas_addr);
541 spin_unlock_irqrestore(&a->mem_lock, flags);
550 rq->target_id = esas2r_targ_get_id(t, a);
559 t = a->targetdb + rq->target_id;
561 if (t >= a->targetdb_end
578 t = a->targetdb + rq->target_id;
580 if (t >= a->targetdb_end
587 if (!csmi_ioctl_tunnel(a, ioctl_csmi, rq, sgc,
608 static void csmi_ioctl_done_callback(struct esas2r_adapter *a,
648 static u8 handle_csmi_ioctl(struct esas2r_adapter *a, struct atto_csmi *ci)
654 bi.a = a;
669 static bool hba_ioctl_tunnel(struct esas2r_adapter *a,
674 esas2r_sgc_init(sgc, a, rq, rq->vrq->ioctl.sge);
676 esas2r_build_ioctl_req(a, rq, sgc->length, VDA_IOCTL_HBA);
678 if (!esas2r_build_sg_list(a, rq, sgc)) {
684 esas2r_start_request(a, rq);
689 static void scsi_passthru_comp_cb(struct esas2r_adapter *a,
740 esas2r_targ_db_find_next_present(a, (u16)spt->target_id);
743 (*rq->aux_req_cb)(a, rq);
746 static int hba_ioctl_callback(struct esas2r_adapter *a,
758 u8 *class_code = (u8 *)&a->pcid->class;
776 gai->pci.vendor_id = a->pcid->vendor;
777 gai->pci.device_id = a->pcid->device;
778 gai->pci.ss_vendor_id = a->pcid->subsystem_vendor;
779 gai->pci.ss_device_id = a->pcid->subsystem_device;
783 gai->pci.rev_id = a->pcid->revision;
784 gai->pci.bus_num = a->pcid->bus->number;
785 gai->pci.dev_num = PCI_SLOT(a->pcid->devfn);
786 gai->pci.func_num = PCI_FUNC(a->pcid->devfn);
788 if (pci_is_pcie(a->pcid)) {
792 pcie_capability_read_word(a->pcid, PCI_EXP_LNKSTA,
794 pcie_capability_read_dword(a->pcid, PCI_EXP_LNKCAP,
805 if (a->pcid->msix_enabled)
807 else if (a->pcid->msi_enabled)
814 if (test_bit(AF2_THUNDERLINK, &a->flags2))
817 if (test_bit(AF_DEGRADED_MODE, &a->flags))
823 if (a->pcid->subsystem_device == ATTO_ESAS_R60F
824 || a->pcid->subsystem_device == ATTO_ESAS_R608
825 || a->pcid->subsystem_device == ATTO_ESAS_R644
826 || a->pcid->subsystem_device == ATTO_TSSC_3808E)
832 strcpy(gai->firmware_rev, a->fw_rev);
833 strcpy(gai->flash_rev, a->flash_rev);
834 strcpy(gai->model_name_short, esas2r_get_model_name_short(a));
835 strcpy(gai->model_name, esas2r_get_model_name(a));
843 if (a->pcid->subsystem_device == ATTO_ESAS_R6F0
844 || a->pcid->subsystem_device == ATTO_ESAS_R60F)
851 gai->num_targets_backend = a->num_targets_backend;
853 gai->tunnel_flags = a->ioctl_tunnel
884 &a->nvram->sas_addr[0], sizeof(u64));
897 if (hba_ioctl_tunnel(a, hi, rq, sgc))
913 if (hba_ioctl_tunnel(a, hi, rq, sgc))
932 /* Size is zero if a core dump isn't present */
933 if (!test_bit(AF2_COREDUMP_SAVED, &a->flags2))
947 a->fw_coredump_buff + offset,
951 memset(a->fw_coredump_buff, 0,
954 clear_bit(AF2_COREDUMP_SAVED, &a->flags2);
966 if (!test_bit(AF2_COREDUMP_SAVED, &a->flags2))
983 if (hba_ioctl_tunnel(a, hi, rq, sgc))
1000 esas2r_sgc_init(sgc, a, rq, NULL);
1042 if (!esas2r_build_sg_list(a, rq, sgc)) {
1047 esas2r_start_request(a, rq);
1059 if (hba_ioctl_tunnel(a, hi, rq, sgc))
1076 t = a->targetdb + (u16)gda->target_id;
1097 esas2r_targ_db_find_next_present(a,
1105 if (hba_ioctl_tunnel(a, hi, rq, sgc))
1127 esas2r_reset_adapter(a);
1133 if (test_bit(AF_CHPRST_NEEDED, &a->flags))
1135 else if (test_bit(AF_CHPRST_PENDING, &a->flags))
1137 else if (test_bit(AF_DISC_PENDING, &a->flags))
1139 else if (test_bit(AF_DISABLED, &a->flags))
1141 else if (test_bit(AF_DEGRADED_MODE, &a->flags))
1155 if (hba_ioctl_tunnel(a, hi, rq, sgc))
1172 t = a->targetdb + (u16)gdi->target_id;
1177 esas2r_targ_db_find_next_present(a,
1198 static void hba_ioctl_done_callback(struct esas2r_adapter *a,
1204 esas2r_debug("hba_ioctl_done_callback %d", a->index);
1224 u8 handle_hba_ioctl(struct esas2r_adapter *a,
1231 bi.a = a;
1244 int esas2r_write_params(struct esas2r_adapter *a, struct esas2r_request *rq,
1249 a->nvram_command_done = 0;
1252 if (esas2r_nvram_write(a, rq, data)) {
1254 while (!a->nvram_command_done)
1255 wait_event_interruptible(a->nvram_waiter,
1256 a->nvram_command_done);
1271 struct esas2r_adapter *a;
1332 a = (struct esas2r_adapter *)hostdata;
1342 a = esas2r_adapters[ioctl->header.channel];
1349 err = esas2r_write_fw(a,
1356 err = esas2r_read_fw(a,
1364 err = esas2r_write_fs(a,
1371 err = esas2r_read_fs(a,
1386 memcpy(ioctl->data.prw.data_buffer, a->nvram,
1393 rq = esas2r_alloc_request(a);
1401 code = esas2r_write_params(a, rq,
1405 esas2r_free_request(a, rq);
1411 esas2r_nvram_get_defaults(a,
1420 ioctl->data.chaninfo.IRQ = a->pcid->irq;
1421 ioctl->data.chaninfo.device_id = a->pcid->device;
1422 ioctl->data.chaninfo.vendor_id = a->pcid->vendor;
1423 ioctl->data.chaninfo.ven_dev_id = a->pcid->subsystem_device;
1424 ioctl->data.chaninfo.revision_id = a->pcid->revision;
1425 ioctl->data.chaninfo.pci_bus = a->pcid->bus->number;
1426 ioctl->data.chaninfo.pci_dev_func = a->pcid->devfn;
1428 ioctl->data.chaninfo.host_no = a->host->host_no;
1433 ioctl->header.return_code = handle_smp_ioctl(a,
1440 handle_csmi_ioctl(a, &ioctl->data.csmi);
1444 ioctl->header.return_code = handle_hba_ioctl(a,
1450 err = esas2r_write_vda(a,
1457 err = esas2r_read_vda(a,
1471 ioctl->data.modinfo.adapter = a;
1472 ioctl->data.modinfo.pci_dev = a->pcid;
1473 ioctl->data.modinfo.scsi_host = a->host;
1474 ioctl->data.modinfo.host_no = a->host->host_no;
1528 static void free_fw_buffers(struct esas2r_adapter *a)
1530 if (a->firmware.data) {
1531 dma_free_coherent(&a->pcid->dev,
1532 (size_t)a->firmware.orig_len,
1533 a->firmware.data,
1534 (dma_addr_t)a->firmware.phys);
1536 a->firmware.data = NULL;
1540 static int allocate_fw_buffers(struct esas2r_adapter *a, u32 length)
1542 free_fw_buffers(a);
1544 a->firmware.orig_len = length;
1546 a->firmware.data = dma_alloc_coherent(&a->pcid->dev,
1548 (dma_addr_t *)&a->firmware.phys,
1551 if (!a->firmware.data) {
1559 /* Handle a call to read firmware. */
1560 int esas2r_read_fw(struct esas2r_adapter *a, char *buf, long off, int count)
1563 /* if the cached header is a status, simply copy it over and return. */
1564 if (a->firmware.state == FW_STATUS_ST) {
1565 int size = min_t(int, count, sizeof(a->firmware.header));
1567 memcpy(buf, &a->firmware.header, size);
1573 * if the cached header is a command, do it if at
1577 if (a->firmware.state == FW_COMMAND_ST) {
1578 u32 length = a->firmware.header.length;
1586 if (a->firmware.header.action == FI_ACT_UP) {
1587 if (!allocate_fw_buffers(a, length))
1593 memcpy(a->firmware.data,
1594 &a->firmware.header,
1595 sizeof(a->firmware.header));
1597 do_fm_api(a,
1598 (struct esas2r_flash_img *)a->firmware.data);
1599 } else if (a->firmware.header.action == FI_ACT_UPSZ) {
1602 (int)sizeof(a->firmware.header));
1603 do_fm_api(a, &a->firmware.header);
1604 memcpy(buf, &a->firmware.header, size);
1609 a->firmware.header.action);
1620 if (!a->firmware.data) {
1630 memcpy(buf, &a->firmware.data[off], count);
1637 free_fw_buffers(a);
1645 a->firmware.state);
1650 /* Handle a call to write firmware. */
1651 int esas2r_write_fw(struct esas2r_adapter *a, const char *buf, long off,
1664 a->firmware.state = FW_INVALID_ST;
1675 /* See if its a version 1 flash image */
1697 * If this is a write command, allocate memory because
1703 if (!allocate_fw_buffers(a, length))
1710 memcpy(&a->firmware.header,
1716 memcpy(&a->firmware.header,
1720 a->firmware.state = FW_COMMAND_ST;
1734 a->firmware.header.action);
1738 length = a->firmware.header.length;
1742 * We only get here on a download command, regardless of offset.
1756 * On a full upload, the system tries sending the whole buffer.
1760 if (a->firmware.header.action == FI_ACT_UP)
1763 if (!a->firmware.data) {
1769 memcpy(&a->firmware.data[off], buf, count);
1772 do_fm_api(a,
1773 (struct esas2r_flash_img *)a->firmware.data);
1779 memcpy(&a->firmware.header,
1780 a->firmware.data,
1781 sizeof(a->firmware.header));
1783 a->firmware.state = FW_STATUS_ST;
1789 * this can leak is if a root user writes a program
1790 * that writes a shorter buffer than it claims, and the
1793 free_fw_buffers(a);
1800 /* Callback for the completion of a VDA request. */
1801 static void vda_complete_req(struct esas2r_adapter *a,
1804 a->vda_command_done = 1;
1805 wake_up_interruptible(&a->vda_waiter);
1811 struct esas2r_adapter *a = (struct esas2r_adapter *)sgc->adapter;
1812 int offset = (u8 *)sgc->cur_offset - (u8 *)a->vda_buffer;
1814 (*addr) = a->ppvda_buffer + offset;
1818 /* Handle a call to read a VDA command. */
1819 int esas2r_read_vda(struct esas2r_adapter *a, char *buf, long off, int count)
1821 if (!a->vda_buffer)
1827 (struct atto_ioctl_vda *)a->vda_buffer;
1837 /* allocate a request */
1838 rq = esas2r_alloc_request(a);
1847 sgc.adapter = a;
1848 sgc.cur_offset = a->vda_buffer + VDA_BUFFER_HEADER_SZ;
1851 a->vda_command_done = 0;
1854 esas2r_process_vda_ioctl(a, vi, rq, &sgc);
1859 while (!a->vda_command_done)
1860 wait_event_interruptible(a->vda_waiter,
1861 a->vda_command_done);
1864 esas2r_free_request(a, (struct esas2r_request *)rq);
1876 memcpy(buf, a->vda_buffer + off, count);
1881 /* Handle a call to write a VDA command. */
1882 int esas2r_write_vda(struct esas2r_adapter *a, const char *buf, long off,
1890 if (!a->vda_buffer) {
1892 a->vda_buffer = dma_alloc_coherent(&a->pcid->dev,
1898 a->ppvda_buffer = dma_addr;
1901 if (!a->vda_buffer)
1913 memcpy(a->vda_buffer + off, buf, count);
1919 static void fs_api_complete_req(struct esas2r_adapter *a,
1922 a->fs_api_command_done = 1;
1924 wake_up_interruptible(&a->fs_api_waiter);
1930 struct esas2r_adapter *a = (struct esas2r_adapter *)sgc->adapter;
1932 (struct esas2r_ioctl_fs *)a->fs_api_buffer;
1935 (*addr) = a->ppfs_api_buffer + offset;
1937 return a->fs_api_buffer_size - offset;
1940 /* Handle a call to read firmware via FS_API. */
1941 int esas2r_read_fs(struct esas2r_adapter *a, char *buf, long off, int count)
1943 if (!a->fs_api_buffer)
1950 (struct esas2r_ioctl_fs *)a->fs_api_buffer;
1953 if (mutex_lock_interruptible(&a->fs_api_mutex)) {
1963 * chip and reply. Allocate a request
1966 rq = esas2r_alloc_request(a);
1969 mutex_unlock(&a->fs_api_mutex);
1980 a->fs_api_command_done = 0;
1982 if (!esas2r_process_fs_ioctl(a, fs, rq, &sgc)) {
1991 while (!a->fs_api_command_done)
1992 wait_event_interruptible(a->fs_api_waiter,
1993 a->fs_api_command_done);
1997 mutex_unlock(&a->fs_api_mutex);
1998 esas2r_free_request(a, (struct esas2r_request *)rq);
2005 if (off > a->fs_api_buffer_size)
2008 if (count + off > a->fs_api_buffer_size)
2009 count = a->fs_api_buffer_size - off;
2014 memcpy(buf, a->fs_api_buffer + off, count);
2019 /* Handle a call to write firmware via FS_API. */
2020 int esas2r_write_fs(struct esas2r_adapter *a, const char *buf, long off,
2038 * Beginning a command. We assume we'll get at least
2046 /* Allocate a buffer or use the existing buffer. */
2047 if (a->fs_api_buffer) {
2048 if (a->fs_api_buffer_size < length) {
2049 /* Free too-small buffer and get a new one */
2050 dma_free_coherent(&a->pcid->dev,
2051 (size_t)a->fs_api_buffer_size,
2052 a->fs_api_buffer,
2053 (dma_addr_t)a->ppfs_api_buffer);
2059 a->fs_api_buffer_size = length;
2061 a->fs_api_buffer = dma_alloc_coherent(&a->pcid->dev,
2062 (size_t)a->fs_api_buffer_size,
2063 (dma_addr_t *)&a->ppfs_api_buffer,
2068 if (!a->fs_api_buffer)
2071 if (off > a->fs_api_buffer_size)
2074 if (count + off > a->fs_api_buffer_size)
2075 count = a->fs_api_buffer_size - off;
2080 memcpy(a->fs_api_buffer + off, buf, count);