static void zfcp_qdio_int_resp(struct ccw_device *cdev, unsigned int qdio_err, int queue_no, int idx, int count, unsigned long parm) { struct zfcp_qdio *qdio = (struct zfcp_qdio *) parm; int sbal_idx, sbal_no; if (unlikely(qdio_err)) { zfcp_qdio_handler_error(qdio, "qdires1", qdio_err); return; } /* * go through all SBALs from input queue currently * returned by QDIO layer */ for (sbal_no = 0; sbal_no < count; sbal_no++) { sbal_idx = (idx + sbal_no) % QDIO_MAX_BUFFERS_PER_Q; /* go through all SBALEs of SBAL */ zfcp_fsf_reqid_check(qdio, sbal_idx); } /* * put SBALs back to response queue */ if (do_QDIO(cdev, QDIO_FLAG_SYNC_INPUT, 0, idx, count)) zfcp_erp_adapter_reopen(qdio->adapter, 0, "qdires2"); }
/** * zfcp_qdio_send - set PCI flag in first SBALE and send req to QDIO * @qdio: pointer to struct zfcp_qdio * @q_req: pointer to struct zfcp_qdio_req * Returns: 0 on success, error otherwise */ int zfcp_qdio_send(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req) { int retval; u8 sbal_number = q_req->sbal_number; spin_lock(&qdio->stat_lock); zfcp_qdio_account(qdio); spin_unlock(&qdio->stat_lock); retval = do_QDIO(qdio->adapter->ccw_device, QDIO_FLAG_SYNC_OUTPUT, 0, q_req->sbal_first, sbal_number); if (unlikely(retval)) { zfcp_qdio_zero_sbals(qdio->req_q, q_req->sbal_first, sbal_number); return retval; } /* account for transferred buffers */ atomic_sub(sbal_number, &qdio->req_q_free); qdio->req_q_idx += sbal_number; qdio->req_q_idx %= QDIO_MAX_BUFFERS_PER_Q; return 0; }
/** * zfcp_qdio_send - set PCI flag in first SBALE and send req to QDIO * @fsf_req: pointer to struct zfcp_fsf_req * Returns: 0 on success, error otherwise */ int zfcp_qdio_send(struct zfcp_fsf_req *fsf_req) { struct zfcp_adapter *adapter = fsf_req->adapter; struct zfcp_qdio_queue *req_q = &adapter->req_q; int first = fsf_req->sbal_first; int count = fsf_req->sbal_number; int retval, pci, pci_batch; struct qdio_buffer_element *sbale; /* acknowledgements for transferred buffers */ pci_batch = adapter->req_q_pci_batch + count; if (unlikely(pci_batch >= ZFCP_QDIO_PCI_INTERVAL)) { pci_batch %= ZFCP_QDIO_PCI_INTERVAL; pci = first + count - (pci_batch + 1); pci %= QDIO_MAX_BUFFERS_PER_Q; sbale = zfcp_qdio_sbale(req_q, pci, 0); sbale->flags |= SBAL_FLAGS0_PCI; } retval = do_QDIO(adapter->ccw_device, QDIO_FLAG_SYNC_OUTPUT, 0, first, count); if (unlikely(retval)) { zfcp_qdio_zero_sbals(req_q->sbal, first, count); return retval; } /* account for transferred buffers */ atomic_sub(count, &req_q->count); req_q->first += count; req_q->first %= QDIO_MAX_BUFFERS_PER_Q; adapter->req_q_pci_batch = pci_batch; return 0; }
/** * zfcp_qdio_open - prepare and initialize response queue * @qdio: pointer to struct zfcp_qdio * Returns: 0 on success, otherwise -EIO */ int zfcp_qdio_open(struct zfcp_qdio *qdio) { struct qdio_buffer_element *sbale; struct qdio_initialize init_data; struct zfcp_adapter *adapter = qdio->adapter; struct ccw_device *cdev = adapter->ccw_device; struct qdio_ssqd_desc ssqd; int cc; if (atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP) return -EIO; atomic_clear_mask(ZFCP_STATUS_ADAPTER_SIOSL_ISSUED, &qdio->adapter->status); zfcp_qdio_setup_init_data(&init_data, qdio); if (qdio_establish(&init_data)) goto failed_establish; if (qdio_get_ssqd_desc(init_data.cdev, &ssqd)) goto failed_qdio; if (ssqd.qdioac2 & CHSC_AC2_DATA_DIV_ENABLED) atomic_set_mask(ZFCP_STATUS_ADAPTER_DATA_DIV_ENABLED, &qdio->adapter->status); if (qdio_activate(cdev)) goto failed_qdio; for (cc = 0; cc < QDIO_MAX_BUFFERS_PER_Q; cc++) { sbale = &(qdio->res_q[cc]->element[0]); sbale->length = 0; sbale->eflags = SBAL_EFLAGS_LAST_ENTRY; sbale->sflags = 0; sbale->addr = NULL; } if (do_QDIO(cdev, QDIO_FLAG_SYNC_INPUT, 0, 0, QDIO_MAX_BUFFERS_PER_Q)) goto failed_qdio; /* set index of first available SBALS / number of available SBALS */ qdio->req_q_idx = 0; atomic_set(&qdio->req_q_free, QDIO_MAX_BUFFERS_PER_Q); atomic_set_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &qdio->adapter->status); return 0; failed_qdio: qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR); failed_establish: dev_err(&cdev->dev, "Setting up the QDIO connection to the FCP adapter failed\n"); return -EIO; }
static void zfcp_qdio_int_resp(struct ccw_device *cdev, unsigned int qdio_err, int queue_no, int idx, int count, unsigned long parm) { struct zfcp_qdio *qdio = (struct zfcp_qdio *) parm; struct zfcp_adapter *adapter = qdio->adapter; int sbal_no, sbal_idx; if (unlikely(qdio_err)) { if (zfcp_adapter_multi_buffer_active(adapter)) { void *pl[ZFCP_QDIO_MAX_SBALS_PER_REQ + 1]; struct qdio_buffer_element *sbale; u64 req_id; u8 scount; memset(pl, 0, ZFCP_QDIO_MAX_SBALS_PER_REQ * sizeof(void *)); sbale = qdio->res_q[idx]->element; req_id = (u64) sbale->addr; scount = min(sbale->scount + 1, ZFCP_QDIO_MAX_SBALS_PER_REQ + 1); /* incl. signaling SBAL */ for (sbal_no = 0; sbal_no < scount; sbal_no++) { sbal_idx = (idx + sbal_no) % QDIO_MAX_BUFFERS_PER_Q; pl[sbal_no] = qdio->res_q[sbal_idx]; } zfcp_dbf_hba_def_err(adapter, req_id, scount, pl); } zfcp_qdio_handler_error(qdio, "qdires1", qdio_err); return; } /* * go through all SBALs from input queue currently * returned by QDIO layer */ for (sbal_no = 0; sbal_no < count; sbal_no++) { sbal_idx = (idx + sbal_no) % QDIO_MAX_BUFFERS_PER_Q; /* go through all SBALEs of SBAL */ zfcp_fsf_reqid_check(qdio, sbal_idx); } /* * put SBALs back to response queue */ if (do_QDIO(cdev, QDIO_FLAG_SYNC_INPUT, 0, idx, count)) zfcp_erp_adapter_reopen(qdio->adapter, 0, "qdires2"); }
static void zfcp_qdio_resp_put_back(struct zfcp_qdio *qdio, int processed) { struct zfcp_qdio_queue *queue = &qdio->resp_q; struct ccw_device *cdev = qdio->adapter->ccw_device; u8 count, start = queue->first; unsigned int retval; count = atomic_read(&queue->count) + processed; retval = do_QDIO(cdev, QDIO_FLAG_SYNC_INPUT, 0, start, count); if (unlikely(retval)) { atomic_set(&queue->count, count); /* FIXME: Recover this with an adapter reopen? */ } else { queue->first += count; queue->first %= QDIO_MAX_BUFFERS_PER_Q; atomic_set(&queue->count, 0); } }
/** * zfcp_qdio_open - prepare and initialize response queue * @adapter: pointer to struct zfcp_adapter * Returns: 0 on success, otherwise -EIO */ int zfcp_qdio_open(struct zfcp_adapter *adapter) { struct qdio_buffer_element *sbale; int cc; if (atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP) return -EIO; if (qdio_establish(&adapter->qdio_init_data)) goto failed_establish; if (qdio_activate(adapter->ccw_device)) goto failed_qdio; for (cc = 0; cc < QDIO_MAX_BUFFERS_PER_Q; cc++) { sbale = &(adapter->resp_q.sbal[cc]->element[0]); sbale->length = 0; sbale->flags = SBAL_FLAGS_LAST_ENTRY; sbale->addr = NULL; } if (do_QDIO(adapter->ccw_device, QDIO_FLAG_SYNC_INPUT, 0, 0, QDIO_MAX_BUFFERS_PER_Q)) goto failed_qdio; /* set index of first avalable SBALS / number of available SBALS */ adapter->req_q.first = 0; atomic_set(&adapter->req_q.count, QDIO_MAX_BUFFERS_PER_Q); adapter->req_q_pci_batch = 0; return 0; failed_qdio: qdio_shutdown(adapter->ccw_device, QDIO_FLAG_CLEANUP_USING_CLEAR); failed_establish: dev_err(&adapter->ccw_device->dev, "Setting up the QDIO connection to the FCP adapter failed\n"); return -EIO; }
/** * zfcp_qdio_send - set PCI flag in first SBALE and send req to QDIO * @qdio: pointer to struct zfcp_qdio * @q_req: pointer to struct zfcp_queue_req * Returns: 0 on success, error otherwise */ int zfcp_qdio_send(struct zfcp_qdio *qdio, struct zfcp_queue_req *q_req) { struct zfcp_qdio_queue *req_q = &qdio->req_q; int first = q_req->sbal_first; int count = q_req->sbal_number; int retval; unsigned int qdio_flags = QDIO_FLAG_SYNC_OUTPUT; zfcp_qdio_account(qdio); retval = do_QDIO(qdio->adapter->ccw_device, qdio_flags, 0, first, count); if (unlikely(retval)) { zfcp_qdio_zero_sbals(req_q->sbal, first, count); return retval; } /* account for transferred buffers */ atomic_sub(count, &req_q->count); req_q->first += count; req_q->first %= QDIO_MAX_BUFFERS_PER_Q; return 0; }
/* * function: zfcp_qdio_response_handler * * purpose: is called by QDIO layer for completed SBALs in response queue * * returns: (void) */ static void zfcp_qdio_response_handler(struct ccw_device *ccw_device, unsigned int status, unsigned int qdio_error, unsigned int siga_error, unsigned int queue_number, int first_element, int elements_processed, unsigned long int_parm) { struct zfcp_adapter *adapter; struct zfcp_qdio_queue *queue; int buffer_index; int i; struct qdio_buffer *buffer; int retval = 0; u8 count; u8 start; volatile struct qdio_buffer_element *buffere = NULL; int buffere_index; adapter = (struct zfcp_adapter *) int_parm; queue = &adapter->response_queue; if (unlikely(zfcp_qdio_handler_error_check(adapter, status, qdio_error, siga_error))) goto out; /* * we stored address of struct zfcp_adapter data structure * associated with irq in int_parm */ buffere = &(queue->buffer[first_element]->element[0]); ZFCP_LOG_DEBUG("first BUFFERE flags=0x%x\n", buffere->flags); /* * go through all SBALs from input queue currently * returned by QDIO layer */ for (i = 0; i < elements_processed; i++) { buffer_index = first_element + i; buffer_index %= QDIO_MAX_BUFFERS_PER_Q; buffer = queue->buffer[buffer_index]; /* go through all SBALEs of SBAL */ for (buffere_index = 0; buffere_index < QDIO_MAX_ELEMENTS_PER_BUFFER; buffere_index++) { /* look for QDIO request identifiers in SB */ buffere = &buffer->element[buffere_index]; retval = zfcp_qdio_reqid_check(adapter, (void *) buffere->addr); if (retval) { ZFCP_LOG_NORMAL("bug: unexpected inbound " "packet on adapter %s " "(reqid=0x%lx, " "first_element=%d, " "elements_processed=%d)\n", zfcp_get_busid_by_adapter(adapter), (unsigned long) buffere->addr, first_element, elements_processed); ZFCP_LOG_NORMAL("hex dump of inbound buffer " "at address %p " "(buffer_index=%d, " "buffere_index=%d)\n", buffer, buffer_index, buffere_index); ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_NORMAL, (char *) buffer, SBAL_SIZE); } /* * A single used SBALE per inbound SBALE has been * implemented by QDIO so far. Hope they will * do some optimisation. Will need to change to * unlikely() then. */ if (likely(buffere->flags & SBAL_FLAGS_LAST_ENTRY)) break; }; if (unlikely(!(buffere->flags & SBAL_FLAGS_LAST_ENTRY))) { ZFCP_LOG_NORMAL("bug: End of inbound data " "not marked!\n"); } } /* * put range of SBALs back to response queue * (including SBALs which have already been free before) */ count = atomic_read(&queue->free_count) + elements_processed; start = queue->free_index; ZFCP_LOG_TRACE("calling do_QDIO on adapter %s (flags=0x%x, " "queue_no=%i, index_in_queue=%i, count=%i, " "buffers=0x%lx\n", zfcp_get_busid_by_adapter(adapter), QDIO_FLAG_SYNC_INPUT | QDIO_FLAG_UNDER_INTERRUPT, 0, start, count, (unsigned long) &queue->buffer[start]); retval = do_QDIO(ccw_device, QDIO_FLAG_SYNC_INPUT | QDIO_FLAG_UNDER_INTERRUPT, 0, start, count, NULL); if (unlikely(retval)) { atomic_set(&queue->free_count, count); ZFCP_LOG_DEBUG("clearing of inbound data regions failed, " "queues may be down " "(count=%d, start=%d, retval=%d)\n", count, start, retval); } else { queue->free_index += count; queue->free_index %= QDIO_MAX_BUFFERS_PER_Q; atomic_set(&queue->free_count, 0); ZFCP_LOG_TRACE("%i buffers enqueued to response " "queue at position %i\n", count, start); } out: return; }