forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
896 lines
23 KiB
896 lines
23 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
/* |
|
* Copyright IBM Corp. 2016 |
|
* Author(s): Martin Schwidefsky <[email protected]> |
|
* |
|
* Adjunct processor bus, queue related code. |
|
*/ |
|
|
|
#define KMSG_COMPONENT "ap" |
|
#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt |
|
|
|
#include <linux/init.h> |
|
#include <linux/slab.h> |
|
#include <asm/facility.h> |
|
|
|
#include "ap_bus.h" |
|
#include "ap_debug.h" |
|
|
|
static void __ap_flush_queue(struct ap_queue *aq); |
|
|
|
/** |
|
* ap_queue_enable_interruption(): Enable interruption on an AP queue. |
|
* @qid: The AP queue number |
|
* @ind: the notification indicator byte |
|
* |
|
* Enables interruption on AP queue via ap_aqic(). Based on the return |
|
* value it waits a while and tests the AP queue if interrupts |
|
* have been switched on using ap_test_queue(). |
|
*/ |
|
static int ap_queue_enable_interruption(struct ap_queue *aq, void *ind) |
|
{ |
|
struct ap_queue_status status; |
|
struct ap_qirq_ctrl qirqctrl = { 0 }; |
|
|
|
qirqctrl.ir = 1; |
|
qirqctrl.isc = AP_ISC; |
|
status = ap_aqic(aq->qid, qirqctrl, ind); |
|
switch (status.response_code) { |
|
case AP_RESPONSE_NORMAL: |
|
case AP_RESPONSE_OTHERWISE_CHANGED: |
|
return 0; |
|
case AP_RESPONSE_Q_NOT_AVAIL: |
|
case AP_RESPONSE_DECONFIGURED: |
|
case AP_RESPONSE_CHECKSTOPPED: |
|
case AP_RESPONSE_INVALID_ADDRESS: |
|
pr_err("Registering adapter interrupts for AP device %02x.%04x failed\n", |
|
AP_QID_CARD(aq->qid), |
|
AP_QID_QUEUE(aq->qid)); |
|
return -EOPNOTSUPP; |
|
case AP_RESPONSE_RESET_IN_PROGRESS: |
|
case AP_RESPONSE_BUSY: |
|
default: |
|
return -EBUSY; |
|
} |
|
} |
|
|
|
/** |
|
* __ap_send(): Send message to adjunct processor queue. |
|
* @qid: The AP queue number |
|
* @psmid: The program supplied message identifier |
|
* @msg: The message text |
|
* @length: The message length |
|
* @special: Special Bit |
|
* |
|
* Returns AP queue status structure. |
|
* Condition code 1 on NQAP can't happen because the L bit is 1. |
|
* Condition code 2 on NQAP also means the send is incomplete, |
|
* because a segment boundary was reached. The NQAP is repeated. |
|
*/ |
|
static inline struct ap_queue_status |
|
__ap_send(ap_qid_t qid, unsigned long long psmid, void *msg, size_t length, |
|
int special) |
|
{ |
|
if (special) |
|
qid |= 0x400000UL; |
|
return ap_nqap(qid, psmid, msg, length); |
|
} |
|
|
|
int ap_send(ap_qid_t qid, unsigned long long psmid, void *msg, size_t length) |
|
{ |
|
struct ap_queue_status status; |
|
|
|
status = __ap_send(qid, psmid, msg, length, 0); |
|
switch (status.response_code) { |
|
case AP_RESPONSE_NORMAL: |
|
return 0; |
|
case AP_RESPONSE_Q_FULL: |
|
case AP_RESPONSE_RESET_IN_PROGRESS: |
|
return -EBUSY; |
|
case AP_RESPONSE_REQ_FAC_NOT_INST: |
|
return -EINVAL; |
|
default: /* Device is gone. */ |
|
return -ENODEV; |
|
} |
|
} |
|
EXPORT_SYMBOL(ap_send); |
|
|
|
int ap_recv(ap_qid_t qid, unsigned long long *psmid, void *msg, size_t length) |
|
{ |
|
struct ap_queue_status status; |
|
|
|
if (msg == NULL) |
|
return -EINVAL; |
|
status = ap_dqap(qid, psmid, msg, length); |
|
switch (status.response_code) { |
|
case AP_RESPONSE_NORMAL: |
|
return 0; |
|
case AP_RESPONSE_NO_PENDING_REPLY: |
|
if (status.queue_empty) |
|
return -ENOENT; |
|
return -EBUSY; |
|
case AP_RESPONSE_RESET_IN_PROGRESS: |
|
return -EBUSY; |
|
default: |
|
return -ENODEV; |
|
} |
|
} |
|
EXPORT_SYMBOL(ap_recv); |
|
|
|
/* State machine definitions and helpers */ |
|
|
|
static enum ap_sm_wait ap_sm_nop(struct ap_queue *aq) |
|
{ |
|
return AP_SM_WAIT_NONE; |
|
} |
|
|
|
/** |
|
* ap_sm_recv(): Receive pending reply messages from an AP queue but do |
|
* not change the state of the device. |
|
* @aq: pointer to the AP queue |
|
* |
|
* Returns AP_SM_WAIT_NONE, AP_SM_WAIT_AGAIN, or AP_SM_WAIT_INTERRUPT |
|
*/ |
|
static struct ap_queue_status ap_sm_recv(struct ap_queue *aq) |
|
{ |
|
struct ap_queue_status status; |
|
struct ap_message *ap_msg; |
|
bool found = false; |
|
|
|
status = ap_dqap(aq->qid, &aq->reply->psmid, |
|
aq->reply->msg, aq->reply->len); |
|
switch (status.response_code) { |
|
case AP_RESPONSE_NORMAL: |
|
aq->queue_count = max_t(int, 0, aq->queue_count - 1); |
|
if (aq->queue_count > 0) |
|
mod_timer(&aq->timeout, |
|
jiffies + aq->request_timeout); |
|
list_for_each_entry(ap_msg, &aq->pendingq, list) { |
|
if (ap_msg->psmid != aq->reply->psmid) |
|
continue; |
|
list_del_init(&ap_msg->list); |
|
aq->pendingq_count--; |
|
ap_msg->receive(aq, ap_msg, aq->reply); |
|
found = true; |
|
break; |
|
} |
|
if (!found) { |
|
AP_DBF_WARN("%s unassociated reply psmid=0x%016llx on 0x%02x.%04x\n", |
|
__func__, aq->reply->psmid, |
|
AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); |
|
} |
|
fallthrough; |
|
case AP_RESPONSE_NO_PENDING_REPLY: |
|
if (!status.queue_empty || aq->queue_count <= 0) |
|
break; |
|
/* The card shouldn't forget requests but who knows. */ |
|
aq->queue_count = 0; |
|
list_splice_init(&aq->pendingq, &aq->requestq); |
|
aq->requestq_count += aq->pendingq_count; |
|
aq->pendingq_count = 0; |
|
break; |
|
default: |
|
break; |
|
} |
|
return status; |
|
} |
|
|
|
/** |
|
* ap_sm_read(): Receive pending reply messages from an AP queue. |
|
* @aq: pointer to the AP queue |
|
* |
|
* Returns AP_SM_WAIT_NONE, AP_SM_WAIT_AGAIN, or AP_SM_WAIT_INTERRUPT |
|
*/ |
|
static enum ap_sm_wait ap_sm_read(struct ap_queue *aq) |
|
{ |
|
struct ap_queue_status status; |
|
|
|
if (!aq->reply) |
|
return AP_SM_WAIT_NONE; |
|
status = ap_sm_recv(aq); |
|
switch (status.response_code) { |
|
case AP_RESPONSE_NORMAL: |
|
if (aq->queue_count > 0) { |
|
aq->sm_state = AP_SM_STATE_WORKING; |
|
return AP_SM_WAIT_AGAIN; |
|
} |
|
aq->sm_state = AP_SM_STATE_IDLE; |
|
return AP_SM_WAIT_NONE; |
|
case AP_RESPONSE_NO_PENDING_REPLY: |
|
if (aq->queue_count > 0) |
|
return AP_SM_WAIT_INTERRUPT; |
|
aq->sm_state = AP_SM_STATE_IDLE; |
|
return AP_SM_WAIT_NONE; |
|
default: |
|
aq->dev_state = AP_DEV_STATE_ERROR; |
|
aq->last_err_rc = status.response_code; |
|
AP_DBF_WARN("%s RC 0x%02x on 0x%02x.%04x -> AP_DEV_STATE_ERROR\n", |
|
__func__, status.response_code, |
|
AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); |
|
return AP_SM_WAIT_NONE; |
|
} |
|
} |
|
|
|
/** |
|
* ap_sm_write(): Send messages from the request queue to an AP queue. |
|
* @aq: pointer to the AP queue |
|
* |
|
* Returns AP_SM_WAIT_NONE, AP_SM_WAIT_AGAIN, or AP_SM_WAIT_INTERRUPT |
|
*/ |
|
static enum ap_sm_wait ap_sm_write(struct ap_queue *aq) |
|
{ |
|
struct ap_queue_status status; |
|
struct ap_message *ap_msg; |
|
ap_qid_t qid = aq->qid; |
|
|
|
if (aq->requestq_count <= 0) |
|
return AP_SM_WAIT_NONE; |
|
/* Start the next request on the queue. */ |
|
ap_msg = list_entry(aq->requestq.next, struct ap_message, list); |
|
#ifdef CONFIG_ZCRYPT_DEBUG |
|
if (ap_msg->fi.action == AP_FI_ACTION_NQAP_QID_INVAL) { |
|
AP_DBF_WARN("%s fi cmd 0x%04x: forcing invalid qid 0xFF00\n", |
|
__func__, ap_msg->fi.cmd); |
|
qid = 0xFF00; |
|
} |
|
#endif |
|
status = __ap_send(qid, ap_msg->psmid, |
|
ap_msg->msg, ap_msg->len, |
|
ap_msg->flags & AP_MSG_FLAG_SPECIAL); |
|
switch (status.response_code) { |
|
case AP_RESPONSE_NORMAL: |
|
aq->queue_count = max_t(int, 1, aq->queue_count + 1); |
|
if (aq->queue_count == 1) |
|
mod_timer(&aq->timeout, jiffies + aq->request_timeout); |
|
list_move_tail(&ap_msg->list, &aq->pendingq); |
|
aq->requestq_count--; |
|
aq->pendingq_count++; |
|
if (aq->queue_count < aq->card->queue_depth) { |
|
aq->sm_state = AP_SM_STATE_WORKING; |
|
return AP_SM_WAIT_AGAIN; |
|
} |
|
fallthrough; |
|
case AP_RESPONSE_Q_FULL: |
|
aq->sm_state = AP_SM_STATE_QUEUE_FULL; |
|
return AP_SM_WAIT_INTERRUPT; |
|
case AP_RESPONSE_RESET_IN_PROGRESS: |
|
aq->sm_state = AP_SM_STATE_RESET_WAIT; |
|
return AP_SM_WAIT_TIMEOUT; |
|
case AP_RESPONSE_INVALID_DOMAIN: |
|
AP_DBF(DBF_WARN, "AP_RESPONSE_INVALID_DOMAIN on NQAP\n"); |
|
fallthrough; |
|
case AP_RESPONSE_MESSAGE_TOO_BIG: |
|
case AP_RESPONSE_REQ_FAC_NOT_INST: |
|
list_del_init(&ap_msg->list); |
|
aq->requestq_count--; |
|
ap_msg->rc = -EINVAL; |
|
ap_msg->receive(aq, ap_msg, NULL); |
|
return AP_SM_WAIT_AGAIN; |
|
default: |
|
aq->dev_state = AP_DEV_STATE_ERROR; |
|
aq->last_err_rc = status.response_code; |
|
AP_DBF_WARN("%s RC 0x%02x on 0x%02x.%04x -> AP_DEV_STATE_ERROR\n", |
|
__func__, status.response_code, |
|
AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); |
|
return AP_SM_WAIT_NONE; |
|
} |
|
} |
|
|
|
/** |
|
* ap_sm_read_write(): Send and receive messages to/from an AP queue. |
|
* @aq: pointer to the AP queue |
|
* |
|
* Returns AP_SM_WAIT_NONE, AP_SM_WAIT_AGAIN, or AP_SM_WAIT_INTERRUPT |
|
*/ |
|
static enum ap_sm_wait ap_sm_read_write(struct ap_queue *aq) |
|
{ |
|
return min(ap_sm_read(aq), ap_sm_write(aq)); |
|
} |
|
|
|
/** |
|
* ap_sm_reset(): Reset an AP queue. |
|
* @qid: The AP queue number |
|
* |
|
* Submit the Reset command to an AP queue. |
|
*/ |
|
static enum ap_sm_wait ap_sm_reset(struct ap_queue *aq) |
|
{ |
|
struct ap_queue_status status; |
|
|
|
status = ap_rapq(aq->qid); |
|
switch (status.response_code) { |
|
case AP_RESPONSE_NORMAL: |
|
case AP_RESPONSE_RESET_IN_PROGRESS: |
|
aq->sm_state = AP_SM_STATE_RESET_WAIT; |
|
aq->interrupt = AP_INTR_DISABLED; |
|
return AP_SM_WAIT_TIMEOUT; |
|
default: |
|
aq->dev_state = AP_DEV_STATE_ERROR; |
|
aq->last_err_rc = status.response_code; |
|
AP_DBF_WARN("%s RC 0x%02x on 0x%02x.%04x -> AP_DEV_STATE_ERROR\n", |
|
__func__, status.response_code, |
|
AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); |
|
return AP_SM_WAIT_NONE; |
|
} |
|
} |
|
|
|
/** |
|
* ap_sm_reset_wait(): Test queue for completion of the reset operation |
|
* @aq: pointer to the AP queue |
|
* |
|
* Returns AP_POLL_IMMEDIATELY, AP_POLL_AFTER_TIMEROUT or 0. |
|
*/ |
|
static enum ap_sm_wait ap_sm_reset_wait(struct ap_queue *aq) |
|
{ |
|
struct ap_queue_status status; |
|
void *lsi_ptr; |
|
|
|
if (aq->queue_count > 0 && aq->reply) |
|
/* Try to read a completed message and get the status */ |
|
status = ap_sm_recv(aq); |
|
else |
|
/* Get the status with TAPQ */ |
|
status = ap_tapq(aq->qid, NULL); |
|
|
|
switch (status.response_code) { |
|
case AP_RESPONSE_NORMAL: |
|
lsi_ptr = ap_airq_ptr(); |
|
if (lsi_ptr && ap_queue_enable_interruption(aq, lsi_ptr) == 0) |
|
aq->sm_state = AP_SM_STATE_SETIRQ_WAIT; |
|
else |
|
aq->sm_state = (aq->queue_count > 0) ? |
|
AP_SM_STATE_WORKING : AP_SM_STATE_IDLE; |
|
return AP_SM_WAIT_AGAIN; |
|
case AP_RESPONSE_BUSY: |
|
case AP_RESPONSE_RESET_IN_PROGRESS: |
|
return AP_SM_WAIT_TIMEOUT; |
|
case AP_RESPONSE_Q_NOT_AVAIL: |
|
case AP_RESPONSE_DECONFIGURED: |
|
case AP_RESPONSE_CHECKSTOPPED: |
|
default: |
|
aq->dev_state = AP_DEV_STATE_ERROR; |
|
aq->last_err_rc = status.response_code; |
|
AP_DBF_WARN("%s RC 0x%02x on 0x%02x.%04x -> AP_DEV_STATE_ERROR\n", |
|
__func__, status.response_code, |
|
AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); |
|
return AP_SM_WAIT_NONE; |
|
} |
|
} |
|
|
|
/** |
|
* ap_sm_setirq_wait(): Test queue for completion of the irq enablement |
|
* @aq: pointer to the AP queue |
|
* |
|
* Returns AP_POLL_IMMEDIATELY, AP_POLL_AFTER_TIMEROUT or 0. |
|
*/ |
|
static enum ap_sm_wait ap_sm_setirq_wait(struct ap_queue *aq) |
|
{ |
|
struct ap_queue_status status; |
|
|
|
if (aq->queue_count > 0 && aq->reply) |
|
/* Try to read a completed message and get the status */ |
|
status = ap_sm_recv(aq); |
|
else |
|
/* Get the status with TAPQ */ |
|
status = ap_tapq(aq->qid, NULL); |
|
|
|
if (status.irq_enabled == 1) { |
|
/* Irqs are now enabled */ |
|
aq->interrupt = AP_INTR_ENABLED; |
|
aq->sm_state = (aq->queue_count > 0) ? |
|
AP_SM_STATE_WORKING : AP_SM_STATE_IDLE; |
|
} |
|
|
|
switch (status.response_code) { |
|
case AP_RESPONSE_NORMAL: |
|
if (aq->queue_count > 0) |
|
return AP_SM_WAIT_AGAIN; |
|
fallthrough; |
|
case AP_RESPONSE_NO_PENDING_REPLY: |
|
return AP_SM_WAIT_TIMEOUT; |
|
default: |
|
aq->dev_state = AP_DEV_STATE_ERROR; |
|
aq->last_err_rc = status.response_code; |
|
AP_DBF_WARN("%s RC 0x%02x on 0x%02x.%04x -> AP_DEV_STATE_ERROR\n", |
|
__func__, status.response_code, |
|
AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); |
|
return AP_SM_WAIT_NONE; |
|
} |
|
} |
|
|
|
/* |
|
* AP state machine jump table |
|
*/ |
|
static ap_func_t *ap_jumptable[NR_AP_SM_STATES][NR_AP_SM_EVENTS] = { |
|
[AP_SM_STATE_RESET_START] = { |
|
[AP_SM_EVENT_POLL] = ap_sm_reset, |
|
[AP_SM_EVENT_TIMEOUT] = ap_sm_nop, |
|
}, |
|
[AP_SM_STATE_RESET_WAIT] = { |
|
[AP_SM_EVENT_POLL] = ap_sm_reset_wait, |
|
[AP_SM_EVENT_TIMEOUT] = ap_sm_nop, |
|
}, |
|
[AP_SM_STATE_SETIRQ_WAIT] = { |
|
[AP_SM_EVENT_POLL] = ap_sm_setirq_wait, |
|
[AP_SM_EVENT_TIMEOUT] = ap_sm_nop, |
|
}, |
|
[AP_SM_STATE_IDLE] = { |
|
[AP_SM_EVENT_POLL] = ap_sm_write, |
|
[AP_SM_EVENT_TIMEOUT] = ap_sm_nop, |
|
}, |
|
[AP_SM_STATE_WORKING] = { |
|
[AP_SM_EVENT_POLL] = ap_sm_read_write, |
|
[AP_SM_EVENT_TIMEOUT] = ap_sm_reset, |
|
}, |
|
[AP_SM_STATE_QUEUE_FULL] = { |
|
[AP_SM_EVENT_POLL] = ap_sm_read, |
|
[AP_SM_EVENT_TIMEOUT] = ap_sm_reset, |
|
}, |
|
}; |
|
|
|
enum ap_sm_wait ap_sm_event(struct ap_queue *aq, enum ap_sm_event event) |
|
{ |
|
if (aq->dev_state > AP_DEV_STATE_UNINITIATED) |
|
return ap_jumptable[aq->sm_state][event](aq); |
|
else |
|
return AP_SM_WAIT_NONE; |
|
} |
|
|
|
enum ap_sm_wait ap_sm_event_loop(struct ap_queue *aq, enum ap_sm_event event) |
|
{ |
|
enum ap_sm_wait wait; |
|
|
|
while ((wait = ap_sm_event(aq, event)) == AP_SM_WAIT_AGAIN) |
|
; |
|
return wait; |
|
} |
|
|
|
/* |
|
* AP queue related attributes. |
|
*/ |
|
static ssize_t request_count_show(struct device *dev, |
|
struct device_attribute *attr, |
|
char *buf) |
|
{ |
|
struct ap_queue *aq = to_ap_queue(dev); |
|
bool valid = false; |
|
u64 req_cnt; |
|
|
|
spin_lock_bh(&aq->lock); |
|
if (aq->dev_state > AP_DEV_STATE_UNINITIATED) { |
|
req_cnt = aq->total_request_count; |
|
valid = true; |
|
} |
|
spin_unlock_bh(&aq->lock); |
|
|
|
if (valid) |
|
return scnprintf(buf, PAGE_SIZE, "%llu\n", req_cnt); |
|
else |
|
return scnprintf(buf, PAGE_SIZE, "-\n"); |
|
} |
|
|
|
static ssize_t request_count_store(struct device *dev, |
|
struct device_attribute *attr, |
|
const char *buf, size_t count) |
|
{ |
|
struct ap_queue *aq = to_ap_queue(dev); |
|
|
|
spin_lock_bh(&aq->lock); |
|
aq->total_request_count = 0; |
|
spin_unlock_bh(&aq->lock); |
|
|
|
return count; |
|
} |
|
|
|
static DEVICE_ATTR_RW(request_count); |
|
|
|
static ssize_t requestq_count_show(struct device *dev, |
|
struct device_attribute *attr, char *buf) |
|
{ |
|
struct ap_queue *aq = to_ap_queue(dev); |
|
unsigned int reqq_cnt = 0; |
|
|
|
spin_lock_bh(&aq->lock); |
|
if (aq->dev_state > AP_DEV_STATE_UNINITIATED) |
|
reqq_cnt = aq->requestq_count; |
|
spin_unlock_bh(&aq->lock); |
|
return scnprintf(buf, PAGE_SIZE, "%d\n", reqq_cnt); |
|
} |
|
|
|
static DEVICE_ATTR_RO(requestq_count); |
|
|
|
static ssize_t pendingq_count_show(struct device *dev, |
|
struct device_attribute *attr, char *buf) |
|
{ |
|
struct ap_queue *aq = to_ap_queue(dev); |
|
unsigned int penq_cnt = 0; |
|
|
|
spin_lock_bh(&aq->lock); |
|
if (aq->dev_state > AP_DEV_STATE_UNINITIATED) |
|
penq_cnt = aq->pendingq_count; |
|
spin_unlock_bh(&aq->lock); |
|
return scnprintf(buf, PAGE_SIZE, "%d\n", penq_cnt); |
|
} |
|
|
|
static DEVICE_ATTR_RO(pendingq_count); |
|
|
|
static ssize_t reset_show(struct device *dev, |
|
struct device_attribute *attr, char *buf) |
|
{ |
|
struct ap_queue *aq = to_ap_queue(dev); |
|
int rc = 0; |
|
|
|
spin_lock_bh(&aq->lock); |
|
switch (aq->sm_state) { |
|
case AP_SM_STATE_RESET_START: |
|
case AP_SM_STATE_RESET_WAIT: |
|
rc = scnprintf(buf, PAGE_SIZE, "Reset in progress.\n"); |
|
break; |
|
case AP_SM_STATE_WORKING: |
|
case AP_SM_STATE_QUEUE_FULL: |
|
rc = scnprintf(buf, PAGE_SIZE, "Reset Timer armed.\n"); |
|
break; |
|
default: |
|
rc = scnprintf(buf, PAGE_SIZE, "No Reset Timer set.\n"); |
|
} |
|
spin_unlock_bh(&aq->lock); |
|
return rc; |
|
} |
|
|
|
static ssize_t reset_store(struct device *dev, |
|
struct device_attribute *attr, |
|
const char *buf, size_t count) |
|
{ |
|
struct ap_queue *aq = to_ap_queue(dev); |
|
|
|
spin_lock_bh(&aq->lock); |
|
__ap_flush_queue(aq); |
|
aq->sm_state = AP_SM_STATE_RESET_START; |
|
ap_wait(ap_sm_event(aq, AP_SM_EVENT_POLL)); |
|
spin_unlock_bh(&aq->lock); |
|
|
|
AP_DBF(DBF_INFO, "reset queue=%02x.%04x triggered by user\n", |
|
AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); |
|
|
|
return count; |
|
} |
|
|
|
static DEVICE_ATTR_RW(reset); |
|
|
|
static ssize_t interrupt_show(struct device *dev, |
|
struct device_attribute *attr, char *buf) |
|
{ |
|
struct ap_queue *aq = to_ap_queue(dev); |
|
int rc = 0; |
|
|
|
spin_lock_bh(&aq->lock); |
|
if (aq->sm_state == AP_SM_STATE_SETIRQ_WAIT) |
|
rc = scnprintf(buf, PAGE_SIZE, "Enable Interrupt pending.\n"); |
|
else if (aq->interrupt == AP_INTR_ENABLED) |
|
rc = scnprintf(buf, PAGE_SIZE, "Interrupts enabled.\n"); |
|
else |
|
rc = scnprintf(buf, PAGE_SIZE, "Interrupts disabled.\n"); |
|
spin_unlock_bh(&aq->lock); |
|
return rc; |
|
} |
|
|
|
static DEVICE_ATTR_RO(interrupt); |
|
|
|
static ssize_t config_show(struct device *dev, |
|
struct device_attribute *attr, char *buf) |
|
{ |
|
struct ap_queue *aq = to_ap_queue(dev); |
|
int rc; |
|
|
|
spin_lock_bh(&aq->lock); |
|
rc = scnprintf(buf, PAGE_SIZE, "%d\n", aq->config ? 1 : 0); |
|
spin_unlock_bh(&aq->lock); |
|
return rc; |
|
} |
|
|
|
static DEVICE_ATTR_RO(config); |
|
|
|
#ifdef CONFIG_ZCRYPT_DEBUG |
|
static ssize_t states_show(struct device *dev, |
|
struct device_attribute *attr, char *buf) |
|
{ |
|
struct ap_queue *aq = to_ap_queue(dev); |
|
int rc = 0; |
|
|
|
spin_lock_bh(&aq->lock); |
|
/* queue device state */ |
|
switch (aq->dev_state) { |
|
case AP_DEV_STATE_UNINITIATED: |
|
rc = scnprintf(buf, PAGE_SIZE, "UNINITIATED\n"); |
|
break; |
|
case AP_DEV_STATE_OPERATING: |
|
rc = scnprintf(buf, PAGE_SIZE, "OPERATING"); |
|
break; |
|
case AP_DEV_STATE_SHUTDOWN: |
|
rc = scnprintf(buf, PAGE_SIZE, "SHUTDOWN"); |
|
break; |
|
case AP_DEV_STATE_ERROR: |
|
rc = scnprintf(buf, PAGE_SIZE, "ERROR"); |
|
break; |
|
default: |
|
rc = scnprintf(buf, PAGE_SIZE, "UNKNOWN"); |
|
} |
|
/* state machine state */ |
|
if (aq->dev_state) { |
|
switch (aq->sm_state) { |
|
case AP_SM_STATE_RESET_START: |
|
rc += scnprintf(buf + rc, PAGE_SIZE - rc, |
|
" [RESET_START]\n"); |
|
break; |
|
case AP_SM_STATE_RESET_WAIT: |
|
rc += scnprintf(buf + rc, PAGE_SIZE - rc, |
|
" [RESET_WAIT]\n"); |
|
break; |
|
case AP_SM_STATE_SETIRQ_WAIT: |
|
rc += scnprintf(buf + rc, PAGE_SIZE - rc, |
|
" [SETIRQ_WAIT]\n"); |
|
break; |
|
case AP_SM_STATE_IDLE: |
|
rc += scnprintf(buf + rc, PAGE_SIZE - rc, |
|
" [IDLE]\n"); |
|
break; |
|
case AP_SM_STATE_WORKING: |
|
rc += scnprintf(buf + rc, PAGE_SIZE - rc, |
|
" [WORKING]\n"); |
|
break; |
|
case AP_SM_STATE_QUEUE_FULL: |
|
rc += scnprintf(buf + rc, PAGE_SIZE - rc, |
|
" [FULL]\n"); |
|
break; |
|
default: |
|
rc += scnprintf(buf + rc, PAGE_SIZE - rc, |
|
" [UNKNOWN]\n"); |
|
} |
|
} |
|
spin_unlock_bh(&aq->lock); |
|
|
|
return rc; |
|
} |
|
static DEVICE_ATTR_RO(states); |
|
|
|
static ssize_t last_err_rc_show(struct device *dev, |
|
struct device_attribute *attr, char *buf) |
|
{ |
|
struct ap_queue *aq = to_ap_queue(dev); |
|
int rc; |
|
|
|
spin_lock_bh(&aq->lock); |
|
rc = aq->last_err_rc; |
|
spin_unlock_bh(&aq->lock); |
|
|
|
switch (rc) { |
|
case AP_RESPONSE_NORMAL: |
|
return scnprintf(buf, PAGE_SIZE, "NORMAL\n"); |
|
case AP_RESPONSE_Q_NOT_AVAIL: |
|
return scnprintf(buf, PAGE_SIZE, "Q_NOT_AVAIL\n"); |
|
case AP_RESPONSE_RESET_IN_PROGRESS: |
|
return scnprintf(buf, PAGE_SIZE, "RESET_IN_PROGRESS\n"); |
|
case AP_RESPONSE_DECONFIGURED: |
|
return scnprintf(buf, PAGE_SIZE, "DECONFIGURED\n"); |
|
case AP_RESPONSE_CHECKSTOPPED: |
|
return scnprintf(buf, PAGE_SIZE, "CHECKSTOPPED\n"); |
|
case AP_RESPONSE_BUSY: |
|
return scnprintf(buf, PAGE_SIZE, "BUSY\n"); |
|
case AP_RESPONSE_INVALID_ADDRESS: |
|
return scnprintf(buf, PAGE_SIZE, "INVALID_ADDRESS\n"); |
|
case AP_RESPONSE_OTHERWISE_CHANGED: |
|
return scnprintf(buf, PAGE_SIZE, "OTHERWISE_CHANGED\n"); |
|
case AP_RESPONSE_Q_FULL: |
|
return scnprintf(buf, PAGE_SIZE, "Q_FULL/NO_PENDING_REPLY\n"); |
|
case AP_RESPONSE_INDEX_TOO_BIG: |
|
return scnprintf(buf, PAGE_SIZE, "INDEX_TOO_BIG\n"); |
|
case AP_RESPONSE_NO_FIRST_PART: |
|
return scnprintf(buf, PAGE_SIZE, "NO_FIRST_PART\n"); |
|
case AP_RESPONSE_MESSAGE_TOO_BIG: |
|
return scnprintf(buf, PAGE_SIZE, "MESSAGE_TOO_BIG\n"); |
|
case AP_RESPONSE_REQ_FAC_NOT_INST: |
|
return scnprintf(buf, PAGE_SIZE, "REQ_FAC_NOT_INST\n"); |
|
default: |
|
return scnprintf(buf, PAGE_SIZE, "response code %d\n", rc); |
|
} |
|
} |
|
static DEVICE_ATTR_RO(last_err_rc); |
|
#endif |
|
|
|
static struct attribute *ap_queue_dev_attrs[] = { |
|
&dev_attr_request_count.attr, |
|
&dev_attr_requestq_count.attr, |
|
&dev_attr_pendingq_count.attr, |
|
&dev_attr_reset.attr, |
|
&dev_attr_interrupt.attr, |
|
&dev_attr_config.attr, |
|
#ifdef CONFIG_ZCRYPT_DEBUG |
|
&dev_attr_states.attr, |
|
&dev_attr_last_err_rc.attr, |
|
#endif |
|
NULL |
|
}; |
|
|
|
static struct attribute_group ap_queue_dev_attr_group = { |
|
.attrs = ap_queue_dev_attrs |
|
}; |
|
|
|
static const struct attribute_group *ap_queue_dev_attr_groups[] = { |
|
&ap_queue_dev_attr_group, |
|
NULL |
|
}; |
|
|
|
static struct device_type ap_queue_type = { |
|
.name = "ap_queue", |
|
.groups = ap_queue_dev_attr_groups, |
|
}; |
|
|
|
static void ap_queue_device_release(struct device *dev) |
|
{ |
|
struct ap_queue *aq = to_ap_queue(dev); |
|
|
|
spin_lock_bh(&ap_queues_lock); |
|
hash_del(&aq->hnode); |
|
spin_unlock_bh(&ap_queues_lock); |
|
|
|
kfree(aq); |
|
} |
|
|
|
struct ap_queue *ap_queue_create(ap_qid_t qid, int device_type) |
|
{ |
|
struct ap_queue *aq; |
|
|
|
aq = kzalloc(sizeof(*aq), GFP_KERNEL); |
|
if (!aq) |
|
return NULL; |
|
aq->ap_dev.device.release = ap_queue_device_release; |
|
aq->ap_dev.device.type = &ap_queue_type; |
|
aq->ap_dev.device_type = device_type; |
|
aq->qid = qid; |
|
aq->interrupt = AP_INTR_DISABLED; |
|
spin_lock_init(&aq->lock); |
|
INIT_LIST_HEAD(&aq->pendingq); |
|
INIT_LIST_HEAD(&aq->requestq); |
|
timer_setup(&aq->timeout, ap_request_timeout, 0); |
|
|
|
return aq; |
|
} |
|
|
|
void ap_queue_init_reply(struct ap_queue *aq, struct ap_message *reply) |
|
{ |
|
aq->reply = reply; |
|
|
|
spin_lock_bh(&aq->lock); |
|
ap_wait(ap_sm_event(aq, AP_SM_EVENT_POLL)); |
|
spin_unlock_bh(&aq->lock); |
|
} |
|
EXPORT_SYMBOL(ap_queue_init_reply); |
|
|
|
/** |
|
* ap_queue_message(): Queue a request to an AP device. |
|
* @aq: The AP device to queue the message to |
|
* @ap_msg: The message that is to be added |
|
*/ |
|
int ap_queue_message(struct ap_queue *aq, struct ap_message *ap_msg) |
|
{ |
|
int rc = 0; |
|
|
|
/* msg needs to have a valid receive-callback */ |
|
BUG_ON(!ap_msg->receive); |
|
|
|
spin_lock_bh(&aq->lock); |
|
|
|
/* only allow to queue new messages if device state is ok */ |
|
if (aq->dev_state == AP_DEV_STATE_OPERATING) { |
|
list_add_tail(&ap_msg->list, &aq->requestq); |
|
aq->requestq_count++; |
|
aq->total_request_count++; |
|
atomic64_inc(&aq->card->total_request_count); |
|
} else |
|
rc = -ENODEV; |
|
|
|
/* Send/receive as many request from the queue as possible. */ |
|
ap_wait(ap_sm_event_loop(aq, AP_SM_EVENT_POLL)); |
|
|
|
spin_unlock_bh(&aq->lock); |
|
|
|
return rc; |
|
} |
|
EXPORT_SYMBOL(ap_queue_message); |
|
|
|
/** |
|
* ap_cancel_message(): Cancel a crypto request. |
|
* @aq: The AP device that has the message queued |
|
* @ap_msg: The message that is to be removed |
|
* |
|
* Cancel a crypto request. This is done by removing the request |
|
* from the device pending or request queue. Note that the |
|
* request stays on the AP queue. When it finishes the message |
|
* reply will be discarded because the psmid can't be found. |
|
*/ |
|
void ap_cancel_message(struct ap_queue *aq, struct ap_message *ap_msg) |
|
{ |
|
struct ap_message *tmp; |
|
|
|
spin_lock_bh(&aq->lock); |
|
if (!list_empty(&ap_msg->list)) { |
|
list_for_each_entry(tmp, &aq->pendingq, list) |
|
if (tmp->psmid == ap_msg->psmid) { |
|
aq->pendingq_count--; |
|
goto found; |
|
} |
|
aq->requestq_count--; |
|
found: |
|
list_del_init(&ap_msg->list); |
|
} |
|
spin_unlock_bh(&aq->lock); |
|
} |
|
EXPORT_SYMBOL(ap_cancel_message); |
|
|
|
/** |
|
* __ap_flush_queue(): Flush requests. |
|
* @aq: Pointer to the AP queue |
|
* |
|
* Flush all requests from the request/pending queue of an AP device. |
|
*/ |
|
static void __ap_flush_queue(struct ap_queue *aq) |
|
{ |
|
struct ap_message *ap_msg, *next; |
|
|
|
list_for_each_entry_safe(ap_msg, next, &aq->pendingq, list) { |
|
list_del_init(&ap_msg->list); |
|
aq->pendingq_count--; |
|
ap_msg->rc = -EAGAIN; |
|
ap_msg->receive(aq, ap_msg, NULL); |
|
} |
|
list_for_each_entry_safe(ap_msg, next, &aq->requestq, list) { |
|
list_del_init(&ap_msg->list); |
|
aq->requestq_count--; |
|
ap_msg->rc = -EAGAIN; |
|
ap_msg->receive(aq, ap_msg, NULL); |
|
} |
|
aq->queue_count = 0; |
|
} |
|
|
|
void ap_flush_queue(struct ap_queue *aq) |
|
{ |
|
spin_lock_bh(&aq->lock); |
|
__ap_flush_queue(aq); |
|
spin_unlock_bh(&aq->lock); |
|
} |
|
EXPORT_SYMBOL(ap_flush_queue); |
|
|
|
void ap_queue_prepare_remove(struct ap_queue *aq) |
|
{ |
|
spin_lock_bh(&aq->lock); |
|
/* flush queue */ |
|
__ap_flush_queue(aq); |
|
/* move queue device state to SHUTDOWN in progress */ |
|
aq->dev_state = AP_DEV_STATE_SHUTDOWN; |
|
spin_unlock_bh(&aq->lock); |
|
del_timer_sync(&aq->timeout); |
|
} |
|
|
|
void ap_queue_remove(struct ap_queue *aq) |
|
{ |
|
/* |
|
* all messages have been flushed and the device state |
|
* is SHUTDOWN. Now reset with zero which also clears |
|
* the irq registration and move the device state |
|
* to the initial value AP_DEV_STATE_UNINITIATED. |
|
*/ |
|
spin_lock_bh(&aq->lock); |
|
ap_zapq(aq->qid); |
|
aq->dev_state = AP_DEV_STATE_UNINITIATED; |
|
spin_unlock_bh(&aq->lock); |
|
} |
|
|
|
void ap_queue_init_state(struct ap_queue *aq) |
|
{ |
|
spin_lock_bh(&aq->lock); |
|
aq->dev_state = AP_DEV_STATE_OPERATING; |
|
aq->sm_state = AP_SM_STATE_RESET_START; |
|
ap_wait(ap_sm_event(aq, AP_SM_EVENT_POLL)); |
|
spin_unlock_bh(&aq->lock); |
|
} |
|
EXPORT_SYMBOL(ap_queue_init_state);
|
|
|