Commit | Line | Data |
---|---|---|
cf4e6363 MC |
1 | /* bnx2i.c: Broadcom NetXtreme II iSCSI driver. |
2 | * | |
9ebd99c5 | 3 | * Copyright (c) 2006 - 2012 Broadcom Corporation |
cf4e6363 MC |
4 | * Copyright (c) 2007, 2008 Red Hat, Inc. All rights reserved. |
5 | * Copyright (c) 2007, 2008 Mike Christie | |
6 | * | |
7 | * This program is free software; you can redistribute it and/or modify | |
8 | * it under the terms of the GNU General Public License as published by | |
9 | * the Free Software Foundation. | |
10 | * | |
11 | * Written by: Anil Veerabhadrappa (anilgv@broadcom.com) | |
11cec1e2 | 12 | * Maintained by: Eddie Wai (eddie.wai@broadcom.com) |
cf4e6363 MC |
13 | */ |
14 | ||
15 | #include "bnx2i.h" | |
16 | ||
17 | static struct list_head adapter_list = LIST_HEAD_INIT(adapter_list); | |
18 | static u32 adapter_count; | |
cf4e6363 MC |
19 | |
20 | #define DRV_MODULE_NAME "bnx2i" | |
9ebd99c5 EW |
21 | #define DRV_MODULE_VERSION "2.7.2.2" |
22 | #define DRV_MODULE_RELDATE "Apr 25, 2012" | |
cf4e6363 MC |
23 | |
24 | static char version[] __devinitdata = | |
25 | "Broadcom NetXtreme II iSCSI Driver " DRV_MODULE_NAME \ | |
26 | " v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n"; | |
27 | ||
28 | ||
fc91961c EW |
29 | MODULE_AUTHOR("Anil Veerabhadrappa <anilgv@broadcom.com> and " |
30 | "Eddie Wai <eddie.wai@broadcom.com>"); | |
31 | ||
8a4a0f3a | 32 | MODULE_DESCRIPTION("Broadcom NetXtreme II BCM5706/5708/5709/57710/57711/57712" |
f4b5ad26 | 33 | "/57800/57810/57840 iSCSI Driver"); |
cf4e6363 MC |
34 | MODULE_LICENSE("GPL"); |
35 | MODULE_VERSION(DRV_MODULE_VERSION); | |
36 | ||
3be924fb | 37 | static DEFINE_MUTEX(bnx2i_dev_lock); |
cf4e6363 | 38 | |
8776193b AV |
39 | unsigned int event_coal_min = 24; |
40 | module_param(event_coal_min, int, 0664); | |
41 | MODULE_PARM_DESC(event_coal_min, "Event Coalescing Minimum Commands"); | |
42 | ||
b5cf6b63 | 43 | unsigned int event_coal_div = 2; |
cf4e6363 MC |
44 | module_param(event_coal_div, int, 0664); |
45 | MODULE_PARM_DESC(event_coal_div, "Event Coalescing Divide Factor"); | |
46 | ||
47 | unsigned int en_tcp_dack = 1; | |
48 | module_param(en_tcp_dack, int, 0664); | |
49 | MODULE_PARM_DESC(en_tcp_dack, "Enable TCP Delayed ACK"); | |
50 | ||
51 | unsigned int error_mask1 = 0x00; | |
70fc872c | 52 | module_param(error_mask1, uint, 0664); |
cf4e6363 MC |
53 | MODULE_PARM_DESC(error_mask1, "Config FW iSCSI Error Mask #1"); |
54 | ||
55 | unsigned int error_mask2 = 0x00; | |
70fc872c | 56 | module_param(error_mask2, uint, 0664); |
cf4e6363 MC |
57 | MODULE_PARM_DESC(error_mask2, "Config FW iSCSI Error Mask #2"); |
58 | ||
59 | unsigned int sq_size; | |
60 | module_param(sq_size, int, 0664); | |
61 | MODULE_PARM_DESC(sq_size, "Configure SQ size"); | |
62 | ||
63 | unsigned int rq_size = BNX2I_RQ_WQES_DEFAULT; | |
64 | module_param(rq_size, int, 0664); | |
65 | MODULE_PARM_DESC(rq_size, "Configure RQ size"); | |
66 | ||
67 | u64 iscsi_error_mask = 0x00; | |
68 | ||
b5cf6b63 EW |
69 | DEFINE_PER_CPU(struct bnx2i_percpu_s, bnx2i_percpu); |
70 | ||
71 | static int bnx2i_cpu_callback(struct notifier_block *nfb, | |
72 | unsigned long action, void *hcpu); | |
73 | /* notification function for CPU hotplug events */ | |
74 | static struct notifier_block bnx2i_cpu_notifier = { | |
75 | .notifier_call = bnx2i_cpu_callback, | |
76 | }; | |
77 | ||
cf4e6363 MC |
78 | |
79 | /** | |
80 | * bnx2i_identify_device - identifies NetXtreme II device type | |
81 | * @hba: Adapter structure pointer | |
82 | * | |
83 | * This function identifies the NX2 device type and sets appropriate | |
84 | * queue mailbox register access method, 5709 requires driver to | |
85 | * access MBOX regs using *bin* mode | |
86 | */ | |
87 | void bnx2i_identify_device(struct bnx2i_hba *hba) | |
88 | { | |
89 | hba->cnic_dev_type = 0; | |
90 | if ((hba->pci_did == PCI_DEVICE_ID_NX2_5706) || | |
91 | (hba->pci_did == PCI_DEVICE_ID_NX2_5706S)) | |
92 | set_bit(BNX2I_NX2_DEV_5706, &hba->cnic_dev_type); | |
93 | else if ((hba->pci_did == PCI_DEVICE_ID_NX2_5708) || | |
94 | (hba->pci_did == PCI_DEVICE_ID_NX2_5708S)) | |
95 | set_bit(BNX2I_NX2_DEV_5708, &hba->cnic_dev_type); | |
96 | else if ((hba->pci_did == PCI_DEVICE_ID_NX2_5709) || | |
97 | (hba->pci_did == PCI_DEVICE_ID_NX2_5709S)) { | |
98 | set_bit(BNX2I_NX2_DEV_5709, &hba->cnic_dev_type); | |
99 | hba->mail_queue_access = BNX2I_MQ_BIN_MODE; | |
f4b5ad26 MC |
100 | } else if (hba->pci_did == PCI_DEVICE_ID_NX2_57710 || |
101 | hba->pci_did == PCI_DEVICE_ID_NX2_57711 || | |
102 | hba->pci_did == PCI_DEVICE_ID_NX2_57711E || | |
103 | hba->pci_did == PCI_DEVICE_ID_NX2_57712 || | |
104 | hba->pci_did == PCI_DEVICE_ID_NX2_57712E || | |
105 | hba->pci_did == PCI_DEVICE_ID_NX2_57800 || | |
106 | hba->pci_did == PCI_DEVICE_ID_NX2_57800_MF || | |
107 | hba->pci_did == PCI_DEVICE_ID_NX2_57800_VF || | |
108 | hba->pci_did == PCI_DEVICE_ID_NX2_57810 || | |
109 | hba->pci_did == PCI_DEVICE_ID_NX2_57810_MF || | |
110 | hba->pci_did == PCI_DEVICE_ID_NX2_57810_VF || | |
111 | hba->pci_did == PCI_DEVICE_ID_NX2_57840 || | |
112 | hba->pci_did == PCI_DEVICE_ID_NX2_57840_MF || | |
113 | hba->pci_did == PCI_DEVICE_ID_NX2_57840_VF) | |
cf4e6363 | 114 | set_bit(BNX2I_NX2_DEV_57710, &hba->cnic_dev_type); |
5d9e1fa9 AV |
115 | else |
116 | printk(KERN_ALERT "bnx2i: unknown device, 0x%x\n", | |
117 | hba->pci_did); | |
cf4e6363 MC |
118 | } |
119 | ||
120 | ||
121 | /** | |
122 | * get_adapter_list_head - returns head of adapter list | |
123 | */ | |
124 | struct bnx2i_hba *get_adapter_list_head(void) | |
125 | { | |
126 | struct bnx2i_hba *hba = NULL; | |
127 | struct bnx2i_hba *tmp_hba; | |
128 | ||
129 | if (!adapter_count) | |
130 | goto hba_not_found; | |
131 | ||
3be924fb | 132 | mutex_lock(&bnx2i_dev_lock); |
cf4e6363 MC |
133 | list_for_each_entry(tmp_hba, &adapter_list, link) { |
134 | if (tmp_hba->cnic && tmp_hba->cnic->cm_select_dev) { | |
135 | hba = tmp_hba; | |
136 | break; | |
137 | } | |
138 | } | |
3be924fb | 139 | mutex_unlock(&bnx2i_dev_lock); |
cf4e6363 MC |
140 | hba_not_found: |
141 | return hba; | |
142 | } | |
143 | ||
144 | ||
145 | /** | |
146 | * bnx2i_find_hba_for_cnic - maps cnic device instance to bnx2i adapter instance | |
147 | * @cnic: pointer to cnic device instance | |
148 | * | |
149 | */ | |
150 | struct bnx2i_hba *bnx2i_find_hba_for_cnic(struct cnic_dev *cnic) | |
151 | { | |
152 | struct bnx2i_hba *hba, *temp; | |
153 | ||
3be924fb | 154 | mutex_lock(&bnx2i_dev_lock); |
cf4e6363 MC |
155 | list_for_each_entry_safe(hba, temp, &adapter_list, link) { |
156 | if (hba->cnic == cnic) { | |
3be924fb | 157 | mutex_unlock(&bnx2i_dev_lock); |
cf4e6363 MC |
158 | return hba; |
159 | } | |
160 | } | |
3be924fb | 161 | mutex_unlock(&bnx2i_dev_lock); |
cf4e6363 MC |
162 | return NULL; |
163 | } | |
164 | ||
165 | ||
166 | /** | |
167 | * bnx2i_start - cnic callback to initialize & start adapter instance | |
168 | * @handle: transparent handle pointing to adapter structure | |
169 | * | |
170 | * This function maps adapter structure to pcidev structure and initiates | |
171 | * firmware handshake to enable/initialize on chip iscsi components | |
172 | * This bnx2i - cnic interface api callback is issued after following | |
173 | * 2 conditions are met - | |
174 | * a) underlying network interface is up (marked by event 'NETDEV_UP' | |
175 | * from netdev | |
176 | * b) bnx2i adapter instance is registered | |
177 | */ | |
178 | void bnx2i_start(void *handle) | |
179 | { | |
180 | #define BNX2I_INIT_POLL_TIME (1000 / HZ) | |
181 | struct bnx2i_hba *hba = handle; | |
182 | int i = HZ; | |
183 | ||
3601b531 EW |
184 | /* |
185 | * We should never register devices that don't support iSCSI | |
186 | * (see bnx2i_init_one), so something is wrong if we try to | |
187 | * start a iSCSI adapter on hardware with 0 supported iSCSI | |
188 | * connections | |
189 | */ | |
190 | BUG_ON(!hba->cnic->max_iscsi_conn); | |
a977d2c9 | 191 | |
cf4e6363 MC |
192 | bnx2i_send_fw_iscsi_init_msg(hba); |
193 | while (!test_bit(ADAPTER_STATE_UP, &hba->adapter_state) && i--) | |
194 | msleep(BNX2I_INIT_POLL_TIME); | |
195 | } | |
196 | ||
197 | ||
250ae982 EW |
198 | /** |
199 | * bnx2i_chip_cleanup - local routine to handle chip cleanup | |
200 | * @hba: Adapter instance to register | |
201 | * | |
202 | * Driver checks if adapter still has any active connections before | |
203 | * executing the cleanup process | |
204 | */ | |
205 | static void bnx2i_chip_cleanup(struct bnx2i_hba *hba) | |
206 | { | |
207 | struct bnx2i_endpoint *bnx2i_ep; | |
208 | struct list_head *pos, *tmp; | |
209 | ||
210 | if (hba->ofld_conns_active) { | |
211 | /* Stage to force the disconnection | |
212 | * This is the case where the daemon is either slow or | |
213 | * not present | |
214 | */ | |
215 | printk(KERN_ALERT "bnx2i: (%s) chip cleanup for %d active " | |
216 | "connections\n", hba->netdev->name, | |
217 | hba->ofld_conns_active); | |
218 | mutex_lock(&hba->net_dev_lock); | |
219 | list_for_each_safe(pos, tmp, &hba->ep_active_list) { | |
220 | bnx2i_ep = list_entry(pos, struct bnx2i_endpoint, link); | |
221 | /* Clean up the chip only */ | |
222 | bnx2i_hw_ep_disconnect(bnx2i_ep); | |
223 | bnx2i_ep->cm_sk = NULL; | |
224 | } | |
225 | mutex_unlock(&hba->net_dev_lock); | |
226 | } | |
227 | } | |
228 | ||
229 | ||
cf4e6363 MC |
230 | /** |
231 | * bnx2i_stop - cnic callback to shutdown adapter instance | |
232 | * @handle: transparent handle pointing to adapter structure | |
233 | * | |
234 | * driver checks if adapter is already in shutdown mode, if not start | |
235 | * the shutdown process | |
236 | */ | |
237 | void bnx2i_stop(void *handle) | |
238 | { | |
239 | struct bnx2i_hba *hba = handle; | |
55e15c97 | 240 | int conns_active; |
842158d7 | 241 | int wait_delay = 1 * HZ; |
cf4e6363 MC |
242 | |
243 | /* check if cleanup happened in GOING_DOWN context */ | |
842158d7 EW |
244 | if (!test_and_set_bit(ADAPTER_STATE_GOING_DOWN, |
245 | &hba->adapter_state)) { | |
cf4e6363 MC |
246 | iscsi_host_for_each_session(hba->shost, |
247 | bnx2i_drop_session); | |
842158d7 EW |
248 | wait_delay = hba->hba_shutdown_tmo; |
249 | } | |
250 | /* Wait for inflight offload connection tasks to complete before | |
251 | * proceeding. Forcefully terminate all connection recovery in | |
252 | * progress at the earliest, either in bind(), send_pdu(LOGIN), | |
253 | * or conn_start() | |
254 | */ | |
255 | wait_event_interruptible_timeout(hba->eh_wait, | |
256 | (list_empty(&hba->ep_ofld_list) && | |
257 | list_empty(&hba->ep_destroy_list)), | |
d5307a07 | 258 | 2 * HZ); |
490475a9 AV |
259 | /* Wait for all endpoints to be torn down, Chip will be reset once |
260 | * control returns to network driver. So it is required to cleanup and | |
261 | * release all connection resources before returning from this routine. | |
262 | */ | |
55e15c97 EW |
263 | while (hba->ofld_conns_active) { |
264 | conns_active = hba->ofld_conns_active; | |
265 | wait_event_interruptible_timeout(hba->eh_wait, | |
266 | (hba->ofld_conns_active != conns_active), | |
842158d7 | 267 | wait_delay); |
55e15c97 EW |
268 | if (hba->ofld_conns_active == conns_active) |
269 | break; | |
270 | } | |
250ae982 | 271 | bnx2i_chip_cleanup(hba); |
55e15c97 | 272 | |
490475a9 AV |
273 | /* This flag should be cleared last so that ep_disconnect() gracefully |
274 | * cleans up connection context | |
275 | */ | |
842158d7 | 276 | clear_bit(ADAPTER_STATE_GOING_DOWN, &hba->adapter_state); |
490475a9 | 277 | clear_bit(ADAPTER_STATE_UP, &hba->adapter_state); |
cf4e6363 MC |
278 | } |
279 | ||
842158d7 | 280 | |
cf4e6363 MC |
281 | /** |
282 | * bnx2i_init_one - initialize an adapter instance and allocate memory resources | |
283 | * @hba: bnx2i adapter instance | |
284 | * @cnic: cnic device handle | |
285 | * | |
3be924fb AV |
286 | * Global resource lock is held during critical sections below. This routine is |
287 | * called from either cnic_register_driver() or device hot plug context and | |
288 | * and does majority of device specific initialization | |
cf4e6363 MC |
289 | */ |
290 | static int bnx2i_init_one(struct bnx2i_hba *hba, struct cnic_dev *cnic) | |
291 | { | |
292 | int rc; | |
293 | ||
3be924fb | 294 | mutex_lock(&bnx2i_dev_lock); |
3601b531 EW |
295 | if (!cnic->max_iscsi_conn) { |
296 | printk(KERN_ALERT "bnx2i: dev %s does not support " | |
297 | "iSCSI\n", hba->netdev->name); | |
298 | rc = -EOPNOTSUPP; | |
299 | goto out; | |
300 | } | |
301 | ||
ce2d763a | 302 | hba->cnic = cnic; |
4e85f151 AV |
303 | rc = cnic->register_device(cnic, CNIC_ULP_ISCSI, hba); |
304 | if (!rc) { | |
cf4e6363 | 305 | hba->age++; |
cf4e6363 | 306 | set_bit(BNX2I_CNIC_REGISTERED, &hba->reg_with_cnic); |
3be924fb AV |
307 | list_add_tail(&hba->link, &adapter_list); |
308 | adapter_count++; | |
4e85f151 AV |
309 | } else if (rc == -EBUSY) /* duplicate registration */ |
310 | printk(KERN_ALERT "bnx2i, duplicate registration" | |
311 | "hba=%p, cnic=%p\n", hba, cnic); | |
312 | else if (rc == -EAGAIN) | |
313 | printk(KERN_ERR "bnx2i, driver not registered\n"); | |
314 | else if (rc == -EINVAL) | |
315 | printk(KERN_ERR "bnx2i, invalid type %d\n", CNIC_ULP_ISCSI); | |
316 | else | |
317 | printk(KERN_ERR "bnx2i dev reg, unknown error, %d\n", rc); | |
cf4e6363 | 318 | |
3601b531 | 319 | out: |
3be924fb | 320 | mutex_unlock(&bnx2i_dev_lock); |
4e85f151 AV |
321 | |
322 | return rc; | |
cf4e6363 MC |
323 | } |
324 | ||
325 | ||
326 | /** | |
327 | * bnx2i_ulp_init - initialize an adapter instance | |
328 | * @dev: cnic device handle | |
329 | * | |
330 | * Called from cnic_register_driver() context to initialize all enumerated | |
331 | * cnic devices. This routine allocate adapter structure and other | |
332 | * device specific resources. | |
333 | */ | |
334 | void bnx2i_ulp_init(struct cnic_dev *dev) | |
335 | { | |
336 | struct bnx2i_hba *hba; | |
337 | ||
338 | /* Allocate a HBA structure for this device */ | |
339 | hba = bnx2i_alloc_hba(dev); | |
340 | if (!hba) { | |
341 | printk(KERN_ERR "bnx2i init: hba initialization failed\n"); | |
342 | return; | |
343 | } | |
344 | ||
345 | /* Get PCI related information and update hba struct members */ | |
346 | clear_bit(BNX2I_CNIC_REGISTERED, &hba->reg_with_cnic); | |
347 | if (bnx2i_init_one(hba, dev)) { | |
348 | printk(KERN_ERR "bnx2i - hba %p init failed\n", hba); | |
349 | bnx2i_free_hba(hba); | |
ce2d763a | 350 | } |
cf4e6363 MC |
351 | } |
352 | ||
353 | ||
354 | /** | |
355 | * bnx2i_ulp_exit - shuts down adapter instance and frees all resources | |
356 | * @dev: cnic device handle | |
357 | * | |
358 | */ | |
359 | void bnx2i_ulp_exit(struct cnic_dev *dev) | |
360 | { | |
361 | struct bnx2i_hba *hba; | |
362 | ||
363 | hba = bnx2i_find_hba_for_cnic(dev); | |
364 | if (!hba) { | |
365 | printk(KERN_INFO "bnx2i_ulp_exit: hba not " | |
366 | "found, dev 0x%p\n", dev); | |
367 | return; | |
368 | } | |
3be924fb | 369 | mutex_lock(&bnx2i_dev_lock); |
cf4e6363 MC |
370 | list_del_init(&hba->link); |
371 | adapter_count--; | |
372 | ||
373 | if (test_bit(BNX2I_CNIC_REGISTERED, &hba->reg_with_cnic)) { | |
374 | hba->cnic->unregister_device(hba->cnic, CNIC_ULP_ISCSI); | |
375 | clear_bit(BNX2I_CNIC_REGISTERED, &hba->reg_with_cnic); | |
cf4e6363 | 376 | } |
3be924fb | 377 | mutex_unlock(&bnx2i_dev_lock); |
cf4e6363 MC |
378 | |
379 | bnx2i_free_hba(hba); | |
380 | } | |
381 | ||
382 | ||
b5cf6b63 EW |
383 | /** |
384 | * bnx2i_percpu_thread_create - Create a receive thread for an | |
385 | * online CPU | |
386 | * | |
387 | * @cpu: cpu index for the online cpu | |
388 | */ | |
389 | static void bnx2i_percpu_thread_create(unsigned int cpu) | |
390 | { | |
391 | struct bnx2i_percpu_s *p; | |
392 | struct task_struct *thread; | |
393 | ||
394 | p = &per_cpu(bnx2i_percpu, cpu); | |
395 | ||
93713f3b ED |
396 | thread = kthread_create_on_node(bnx2i_percpu_io_thread, (void *)p, |
397 | cpu_to_node(cpu), | |
398 | "bnx2i_thread/%d", cpu); | |
b5cf6b63 EW |
399 | /* bind thread to the cpu */ |
400 | if (likely(!IS_ERR(thread))) { | |
401 | kthread_bind(thread, cpu); | |
402 | p->iothread = thread; | |
403 | wake_up_process(thread); | |
404 | } | |
405 | } | |
406 | ||
407 | ||
408 | static void bnx2i_percpu_thread_destroy(unsigned int cpu) | |
409 | { | |
410 | struct bnx2i_percpu_s *p; | |
411 | struct task_struct *thread; | |
412 | struct bnx2i_work *work, *tmp; | |
413 | ||
414 | /* Prevent any new work from being queued for this CPU */ | |
415 | p = &per_cpu(bnx2i_percpu, cpu); | |
416 | spin_lock_bh(&p->p_work_lock); | |
417 | thread = p->iothread; | |
418 | p->iothread = NULL; | |
419 | ||
420 | /* Free all work in the list */ | |
421 | list_for_each_entry_safe(work, tmp, &p->work_list, list) { | |
422 | list_del_init(&work->list); | |
423 | bnx2i_process_scsi_cmd_resp(work->session, | |
424 | work->bnx2i_conn, &work->cqe); | |
425 | kfree(work); | |
426 | } | |
427 | ||
428 | spin_unlock_bh(&p->p_work_lock); | |
429 | if (thread) | |
430 | kthread_stop(thread); | |
431 | } | |
432 | ||
433 | ||
434 | /** | |
435 | * bnx2i_cpu_callback - Handler for CPU hotplug events | |
436 | * | |
437 | * @nfb: The callback data block | |
438 | * @action: The event triggering the callback | |
439 | * @hcpu: The index of the CPU that the event is for | |
440 | * | |
441 | * This creates or destroys per-CPU data for iSCSI | |
442 | * | |
443 | * Returns NOTIFY_OK always. | |
444 | */ | |
445 | static int bnx2i_cpu_callback(struct notifier_block *nfb, | |
446 | unsigned long action, void *hcpu) | |
447 | { | |
448 | unsigned cpu = (unsigned long)hcpu; | |
449 | ||
450 | switch (action) { | |
451 | case CPU_ONLINE: | |
452 | case CPU_ONLINE_FROZEN: | |
453 | printk(KERN_INFO "bnx2i: CPU %x online: Create Rx thread\n", | |
454 | cpu); | |
455 | bnx2i_percpu_thread_create(cpu); | |
456 | break; | |
457 | case CPU_DEAD: | |
458 | case CPU_DEAD_FROZEN: | |
459 | printk(KERN_INFO "CPU %x offline: Remove Rx thread\n", cpu); | |
460 | bnx2i_percpu_thread_destroy(cpu); | |
461 | break; | |
462 | default: | |
463 | break; | |
464 | } | |
465 | return NOTIFY_OK; | |
466 | } | |
467 | ||
468 | ||
cf4e6363 MC |
469 | /** |
470 | * bnx2i_mod_init - module init entry point | |
471 | * | |
472 | * initialize any driver wide global data structures such as endpoint pool, | |
473 | * tcp port manager/queue, sysfs. finally driver will register itself | |
474 | * with the cnic module | |
475 | */ | |
476 | static int __init bnx2i_mod_init(void) | |
477 | { | |
478 | int err; | |
b5cf6b63 EW |
479 | unsigned cpu = 0; |
480 | struct bnx2i_percpu_s *p; | |
cf4e6363 MC |
481 | |
482 | printk(KERN_INFO "%s", version); | |
483 | ||
f8c9abe7 | 484 | if (sq_size && !is_power_of_2(sq_size)) |
cf4e6363 MC |
485 | sq_size = roundup_pow_of_two(sq_size); |
486 | ||
3be924fb AV |
487 | mutex_init(&bnx2i_dev_lock); |
488 | ||
cf4e6363 MC |
489 | bnx2i_scsi_xport_template = |
490 | iscsi_register_transport(&bnx2i_iscsi_transport); | |
491 | if (!bnx2i_scsi_xport_template) { | |
492 | printk(KERN_ERR "Could not register bnx2i transport.\n"); | |
493 | err = -ENOMEM; | |
494 | goto out; | |
495 | } | |
496 | ||
497 | err = cnic_register_driver(CNIC_ULP_ISCSI, &bnx2i_cnic_cb); | |
498 | if (err) { | |
499 | printk(KERN_ERR "Could not register bnx2i cnic driver.\n"); | |
500 | goto unreg_xport; | |
501 | } | |
502 | ||
b5cf6b63 EW |
503 | /* Create percpu kernel threads to handle iSCSI I/O completions */ |
504 | for_each_possible_cpu(cpu) { | |
505 | p = &per_cpu(bnx2i_percpu, cpu); | |
506 | INIT_LIST_HEAD(&p->work_list); | |
507 | spin_lock_init(&p->p_work_lock); | |
508 | p->iothread = NULL; | |
509 | } | |
510 | ||
511 | for_each_online_cpu(cpu) | |
512 | bnx2i_percpu_thread_create(cpu); | |
513 | ||
514 | /* Initialize per CPU interrupt thread */ | |
515 | register_hotcpu_notifier(&bnx2i_cpu_notifier); | |
516 | ||
cf4e6363 MC |
517 | return 0; |
518 | ||
519 | unreg_xport: | |
520 | iscsi_unregister_transport(&bnx2i_iscsi_transport); | |
521 | out: | |
522 | return err; | |
523 | } | |
524 | ||
525 | ||
526 | /** | |
527 | * bnx2i_mod_exit - module cleanup/exit entry point | |
528 | * | |
529 | * Global resource lock and host adapter lock is held during critical sections | |
530 | * in this function. Driver will browse through the adapter list, cleans-up | |
531 | * each instance, unregisters iscsi transport name and finally driver will | |
532 | * unregister itself with the cnic module | |
533 | */ | |
534 | static void __exit bnx2i_mod_exit(void) | |
535 | { | |
536 | struct bnx2i_hba *hba; | |
b5cf6b63 | 537 | unsigned cpu = 0; |
cf4e6363 | 538 | |
3be924fb | 539 | mutex_lock(&bnx2i_dev_lock); |
cf4e6363 MC |
540 | while (!list_empty(&adapter_list)) { |
541 | hba = list_entry(adapter_list.next, struct bnx2i_hba, link); | |
542 | list_del(&hba->link); | |
543 | adapter_count--; | |
544 | ||
545 | if (test_bit(BNX2I_CNIC_REGISTERED, &hba->reg_with_cnic)) { | |
250ae982 | 546 | bnx2i_chip_cleanup(hba); |
cf4e6363 MC |
547 | hba->cnic->unregister_device(hba->cnic, CNIC_ULP_ISCSI); |
548 | clear_bit(BNX2I_CNIC_REGISTERED, &hba->reg_with_cnic); | |
cf4e6363 MC |
549 | } |
550 | ||
cf4e6363 | 551 | bnx2i_free_hba(hba); |
cf4e6363 | 552 | } |
3be924fb | 553 | mutex_unlock(&bnx2i_dev_lock); |
cf4e6363 | 554 | |
b5cf6b63 EW |
555 | unregister_hotcpu_notifier(&bnx2i_cpu_notifier); |
556 | ||
557 | for_each_online_cpu(cpu) | |
558 | bnx2i_percpu_thread_destroy(cpu); | |
559 | ||
cf4e6363 MC |
560 | iscsi_unregister_transport(&bnx2i_iscsi_transport); |
561 | cnic_unregister_driver(CNIC_ULP_ISCSI); | |
562 | } | |
563 | ||
564 | module_init(bnx2i_mod_init); | |
565 | module_exit(bnx2i_mod_exit); |