2 * This file is part of the Chelsio T4/T5/T6 Ethernet driver for Linux.
4 * Copyright (C) 2011-2016 Chelsio Communications. All rights reserved.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation.
10 * Written and Maintained by:
11 * Manoj Malviya (manojmalviya@chelsio.com)
12 * Atul Gupta (atul.gupta@chelsio.com)
13 * Jitendra Lulla (jlulla@chelsio.com)
14 * Yeshaswi M R Gowda (yeshaswi@chelsio.com)
15 * Harsh Jain (harsh@chelsio.com)
18 #include <linux/kernel.h>
19 #include <linux/module.h>
20 #include <linux/skbuff.h>
22 #include <crypto/aes.h>
23 #include <crypto/hash.h>
26 #include "chcr_core.h"
27 #include "cxgb4_uld.h"
29 static LIST_HEAD(uld_ctx_list
);
30 static DEFINE_MUTEX(dev_mutex
);
31 static atomic_t dev_count
;
33 typedef int (*chcr_handler_func
)(struct chcr_dev
*dev
, unsigned char *input
);
34 static int cpl_fw6_pld_handler(struct chcr_dev
*dev
, unsigned char *input
);
35 static void *chcr_uld_add(const struct cxgb4_lld_info
*lld
);
36 static int chcr_uld_state_change(void *handle
, enum cxgb4_state state
);
38 static chcr_handler_func work_handlers
[NUM_CPL_CMDS
] = {
39 [CPL_FW6_PLD
] = cpl_fw6_pld_handler
,
42 static struct cxgb4_pci_uld_info chcr_uld_info
= {
43 .name
= DRV_MODULE_NAME
,
49 .state_change
= chcr_uld_state_change
,
50 .rx_handler
= chcr_uld_rx_handler
,
53 int assign_chcr_device(struct chcr_dev
**dev
)
55 struct uld_ctx
*u_ctx
;
58 * Which device to use if multiple devices are available TODO
59 * May be select the device based on round robin. One session
60 * must go to the same device to maintain the ordering.
62 mutex_lock(&dev_mutex
); /* TODO ? */
63 u_ctx
= list_first_entry(&uld_ctx_list
, struct uld_ctx
, entry
);
65 mutex_unlock(&dev_mutex
);
70 mutex_unlock(&dev_mutex
);
74 static int chcr_dev_add(struct uld_ctx
*u_ctx
)
78 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
82 spin_lock_init(&dev
->lock_chcr_dev
);
85 atomic_inc(&dev_count
);
89 static int chcr_dev_remove(struct uld_ctx
*u_ctx
)
93 atomic_dec(&dev_count
);
97 static int cpl_fw6_pld_handler(struct chcr_dev
*dev
,
100 struct crypto_async_request
*req
;
101 struct cpl_fw6_pld
*fw6_pld
;
102 u32 ack_err_status
= 0;
103 int error_status
= 0;
105 fw6_pld
= (struct cpl_fw6_pld
*)input
;
106 req
= (struct crypto_async_request
*)(uintptr_t)be64_to_cpu(
110 ntohl(*(__be32
*)((unsigned char *)&fw6_pld
->data
[0] + 4));
111 if (ack_err_status
) {
112 if (CHK_MAC_ERR_BIT(ack_err_status
) ||
113 CHK_PAD_ERR_BIT(ack_err_status
))
114 error_status
= -EINVAL
;
116 /* call completion callback with failure status */
118 if (!chcr_handle_resp(req
, input
, error_status
))
119 req
->complete(req
, error_status
);
123 pr_err("Incorrect request address from the firmware\n");
129 int chcr_send_wr(struct sk_buff
*skb
)
131 return cxgb4_ofld_send(skb
->dev
, skb
);
134 static void *chcr_uld_add(const struct cxgb4_lld_info
*lld
)
136 struct uld_ctx
*u_ctx
;
138 /* Create the device and add it in the device list */
139 u_ctx
= kzalloc(sizeof(*u_ctx
), GFP_KERNEL
);
141 u_ctx
= ERR_PTR(-ENOMEM
);
145 mutex_lock(&dev_mutex
);
146 list_add_tail(&u_ctx
->entry
, &uld_ctx_list
);
147 mutex_unlock(&dev_mutex
);
152 int chcr_uld_rx_handler(void *handle
, const __be64
*rsp
,
153 const struct pkt_gl
*pgl
)
155 struct uld_ctx
*u_ctx
= (struct uld_ctx
*)handle
;
156 struct chcr_dev
*dev
= u_ctx
->dev
;
157 const struct cpl_act_establish
*rpl
= (struct cpl_act_establish
160 if (rpl
->ot
.opcode
!= CPL_FW6_PLD
) {
161 pr_err("Unsupported opcode\n");
166 work_handlers
[rpl
->ot
.opcode
](dev
, (unsigned char *)&rsp
[1]);
168 work_handlers
[rpl
->ot
.opcode
](dev
, pgl
->va
);
172 static int chcr_uld_state_change(void *handle
, enum cxgb4_state state
)
174 struct uld_ctx
*u_ctx
= handle
;
180 ret
= chcr_dev_add(u_ctx
);
184 if (atomic_read(&dev_count
) == 1)
185 ret
= start_crypto();
188 case CXGB4_STATE_DETACH
:
190 mutex_lock(&dev_mutex
);
191 chcr_dev_remove(u_ctx
);
192 mutex_unlock(&dev_mutex
);
194 if (!atomic_read(&dev_count
))
198 case CXGB4_STATE_START_RECOVERY
:
199 case CXGB4_STATE_DOWN
:
206 static int __init
chcr_crypto_init(void)
208 if (cxgb4_register_pci_uld(CXGB4_PCI_ULD1
, &chcr_uld_info
)) {
209 pr_err("ULD register fail: No chcr crypto support in cxgb4");
216 static void __exit
chcr_crypto_exit(void)
218 struct uld_ctx
*u_ctx
, *tmp
;
220 if (atomic_read(&dev_count
))
223 /* Remove all devices from list */
224 mutex_lock(&dev_mutex
);
225 list_for_each_entry_safe(u_ctx
, tmp
, &uld_ctx_list
, entry
) {
227 chcr_dev_remove(u_ctx
);
230 mutex_unlock(&dev_mutex
);
231 cxgb4_unregister_pci_uld(CXGB4_PCI_ULD1
);
234 module_init(chcr_crypto_init
);
235 module_exit(chcr_crypto_exit
);
237 MODULE_DESCRIPTION("Crypto Co-processor for Chelsio Terminator cards.");
238 MODULE_LICENSE("GPL");
239 MODULE_AUTHOR("Chelsio Communications");
240 MODULE_VERSION(DRV_VERSION
);