[SCSI] bnx2i: bug fixes in bnx2i_init_one to handle error conditions
[linux-2.6.git] / drivers / scsi / bnx2i / bnx2i_init.c
1 /* bnx2i.c: Broadcom NetXtreme II iSCSI driver.
2  *
3  * Copyright (c) 2006 - 2009 Broadcom Corporation
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)
12  */
13
14 #include "bnx2i.h"
15
16 static struct list_head adapter_list = LIST_HEAD_INIT(adapter_list);
17 static u32 adapter_count;
18
19 #define DRV_MODULE_NAME         "bnx2i"
20 #define DRV_MODULE_VERSION      "2.0.1d"
21 #define DRV_MODULE_RELDATE      "Mar 25, 2009"
22
23 static char version[] __devinitdata =
24                 "Broadcom NetXtreme II iSCSI Driver " DRV_MODULE_NAME \
25                 " v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
26
27
28 MODULE_AUTHOR("Anil Veerabhadrappa <anilgv@broadcom.com>");
29 MODULE_DESCRIPTION("Broadcom NetXtreme II BCM5706/5708/5709 iSCSI Driver");
30 MODULE_LICENSE("GPL");
31 MODULE_VERSION(DRV_MODULE_VERSION);
32
33 static DEFINE_RWLOCK(bnx2i_dev_lock);
34
35 unsigned int event_coal_div = 1;
36 module_param(event_coal_div, int, 0664);
37 MODULE_PARM_DESC(event_coal_div, "Event Coalescing Divide Factor");
38
39 unsigned int en_tcp_dack = 1;
40 module_param(en_tcp_dack, int, 0664);
41 MODULE_PARM_DESC(en_tcp_dack, "Enable TCP Delayed ACK");
42
43 unsigned int error_mask1 = 0x00;
44 module_param(error_mask1, int, 0664);
45 MODULE_PARM_DESC(error_mask1, "Config FW iSCSI Error Mask #1");
46
47 unsigned int error_mask2 = 0x00;
48 module_param(error_mask2, int, 0664);
49 MODULE_PARM_DESC(error_mask2, "Config FW iSCSI Error Mask #2");
50
51 unsigned int sq_size;
52 module_param(sq_size, int, 0664);
53 MODULE_PARM_DESC(sq_size, "Configure SQ size");
54
55 unsigned int rq_size = BNX2I_RQ_WQES_DEFAULT;
56 module_param(rq_size, int, 0664);
57 MODULE_PARM_DESC(rq_size, "Configure RQ size");
58
59 u64 iscsi_error_mask = 0x00;
60
61 static void bnx2i_unreg_one_device(struct bnx2i_hba *hba) ;
62
63
64 /**
65  * bnx2i_identify_device - identifies NetXtreme II device type
66  * @hba:                Adapter structure pointer
67  *
68  * This function identifies the NX2 device type and sets appropriate
69  *      queue mailbox register access method, 5709 requires driver to
70  *      access MBOX regs using *bin* mode
71  */
72 void bnx2i_identify_device(struct bnx2i_hba *hba)
73 {
74         hba->cnic_dev_type = 0;
75         if ((hba->pci_did == PCI_DEVICE_ID_NX2_5706) ||
76             (hba->pci_did == PCI_DEVICE_ID_NX2_5706S))
77                 set_bit(BNX2I_NX2_DEV_5706, &hba->cnic_dev_type);
78         else if ((hba->pci_did == PCI_DEVICE_ID_NX2_5708) ||
79             (hba->pci_did == PCI_DEVICE_ID_NX2_5708S))
80                 set_bit(BNX2I_NX2_DEV_5708, &hba->cnic_dev_type);
81         else if ((hba->pci_did == PCI_DEVICE_ID_NX2_5709) ||
82             (hba->pci_did == PCI_DEVICE_ID_NX2_5709S)) {
83                 set_bit(BNX2I_NX2_DEV_5709, &hba->cnic_dev_type);
84                 hba->mail_queue_access = BNX2I_MQ_BIN_MODE;
85         } else if (hba->pci_did == PCI_DEVICE_ID_NX2_57710 ||
86                    hba->pci_did == PCI_DEVICE_ID_NX2_57711)
87                 set_bit(BNX2I_NX2_DEV_57710, &hba->cnic_dev_type);
88 }
89
90
91 /**
92  * get_adapter_list_head - returns head of adapter list
93  */
94 struct bnx2i_hba *get_adapter_list_head(void)
95 {
96         struct bnx2i_hba *hba = NULL;
97         struct bnx2i_hba *tmp_hba;
98
99         if (!adapter_count)
100                 goto hba_not_found;
101
102         read_lock(&bnx2i_dev_lock);
103         list_for_each_entry(tmp_hba, &adapter_list, link) {
104                 if (tmp_hba->cnic && tmp_hba->cnic->cm_select_dev) {
105                         hba = tmp_hba;
106                         break;
107                 }
108         }
109         read_unlock(&bnx2i_dev_lock);
110 hba_not_found:
111         return hba;
112 }
113
114
115 /**
116  * bnx2i_find_hba_for_cnic - maps cnic device instance to bnx2i adapter instance
117  * @cnic:       pointer to cnic device instance
118  *
119  */
120 struct bnx2i_hba *bnx2i_find_hba_for_cnic(struct cnic_dev *cnic)
121 {
122         struct bnx2i_hba *hba, *temp;
123
124         read_lock(&bnx2i_dev_lock);
125         list_for_each_entry_safe(hba, temp, &adapter_list, link) {
126                 if (hba->cnic == cnic) {
127                         read_unlock(&bnx2i_dev_lock);
128                         return hba;
129                 }
130         }
131         read_unlock(&bnx2i_dev_lock);
132         return NULL;
133 }
134
135
136 /**
137  * bnx2i_start - cnic callback to initialize & start adapter instance
138  * @handle:     transparent handle pointing to adapter structure
139  *
140  * This function maps adapter structure to pcidev structure and initiates
141  *      firmware handshake to enable/initialize on chip iscsi components
142  *      This bnx2i - cnic interface api callback is issued after following
143  *      2 conditions are met -
144  *        a) underlying network interface is up (marked by event 'NETDEV_UP'
145  *              from netdev
146  *        b) bnx2i adapter instance is registered
147  */
148 void bnx2i_start(void *handle)
149 {
150 #define BNX2I_INIT_POLL_TIME    (1000 / HZ)
151         struct bnx2i_hba *hba = handle;
152         int i = HZ;
153
154         bnx2i_send_fw_iscsi_init_msg(hba);
155         while (!test_bit(ADAPTER_STATE_UP, &hba->adapter_state) && i--)
156                 msleep(BNX2I_INIT_POLL_TIME);
157 }
158
159
160 /**
161  * bnx2i_stop - cnic callback to shutdown adapter instance
162  * @handle:     transparent handle pointing to adapter structure
163  *
164  * driver checks if adapter is already in shutdown mode, if not start
165  *      the shutdown process
166  */
167 void bnx2i_stop(void *handle)
168 {
169         struct bnx2i_hba *hba = handle;
170
171         /* check if cleanup happened in GOING_DOWN context */
172         clear_bit(ADAPTER_STATE_UP, &hba->adapter_state);
173         if (!test_and_clear_bit(ADAPTER_STATE_GOING_DOWN,
174                                 &hba->adapter_state))
175                 iscsi_host_for_each_session(hba->shost,
176                                             bnx2i_drop_session);
177 }
178
179 /**
180  * bnx2i_register_device - register bnx2i adapter instance with the cnic driver
181  * @hba:        Adapter instance to register
182  *
183  * registers bnx2i adapter instance with the cnic driver while holding the
184  *      adapter structure lock
185  */
186 void bnx2i_register_device(struct bnx2i_hba *hba)
187 {
188         if (test_bit(ADAPTER_STATE_GOING_DOWN, &hba->adapter_state) ||
189             test_bit(BNX2I_CNIC_REGISTERED, &hba->reg_with_cnic)) {
190                 return;
191         }
192
193         hba->cnic->register_device(hba->cnic, CNIC_ULP_ISCSI, hba);
194
195         set_bit(BNX2I_CNIC_REGISTERED, &hba->reg_with_cnic);
196 }
197
198
199 /**
200  * bnx2i_reg_dev_all - registers all adapter instances with the cnic driver
201  *
202  * registers all bnx2i adapter instances with the cnic driver while holding
203  *      the global resource lock
204  */
205 void bnx2i_reg_dev_all(void)
206 {
207         struct bnx2i_hba *hba, *temp;
208
209         read_lock(&bnx2i_dev_lock);
210         list_for_each_entry_safe(hba, temp, &adapter_list, link)
211                 bnx2i_register_device(hba);
212         read_unlock(&bnx2i_dev_lock);
213 }
214
215
216 /**
217  * bnx2i_unreg_one_device - unregister adapter instance with the cnic driver
218  * @hba:        Adapter instance to unregister
219  *
220  * registers bnx2i adapter instance with the cnic driver while holding
221  *      the adapter structure lock
222  */
223 static void bnx2i_unreg_one_device(struct bnx2i_hba *hba)
224 {
225         if (hba->ofld_conns_active ||
226             !test_bit(BNX2I_CNIC_REGISTERED, &hba->reg_with_cnic) ||
227             test_bit(ADAPTER_STATE_GOING_DOWN, &hba->adapter_state))
228                 return;
229
230         hba->cnic->unregister_device(hba->cnic, CNIC_ULP_ISCSI);
231
232         /* ep_disconnect could come before NETDEV_DOWN, driver won't
233          * see NETDEV_DOWN as it already unregistered itself.
234          */
235         hba->adapter_state = 0;
236         clear_bit(BNX2I_CNIC_REGISTERED, &hba->reg_with_cnic);
237 }
238
239 /**
240  * bnx2i_unreg_dev_all - unregisters all bnx2i instances with the cnic driver
241  *
242  * unregisters all bnx2i adapter instances with the cnic driver while holding
243  *      the global resource lock
244  */
245 void bnx2i_unreg_dev_all(void)
246 {
247         struct bnx2i_hba *hba, *temp;
248
249         read_lock(&bnx2i_dev_lock);
250         list_for_each_entry_safe(hba, temp, &adapter_list, link)
251                 bnx2i_unreg_one_device(hba);
252         read_unlock(&bnx2i_dev_lock);
253 }
254
255
256 /**
257  * bnx2i_init_one - initialize an adapter instance and allocate memory resources
258  * @hba:        bnx2i adapter instance
259  * @cnic:       cnic device handle
260  *
261  * Global resource lock and host adapter lock is held during critical sections
262  *      below. This routine is called from cnic_register_driver() context and
263  *      work horse thread which does majority of device specific initialization
264  */
265 static int bnx2i_init_one(struct bnx2i_hba *hba, struct cnic_dev *cnic)
266 {
267         int rc;
268
269         read_lock(&bnx2i_dev_lock);
270         rc = cnic->register_device(cnic, CNIC_ULP_ISCSI, hba);
271         if (!rc) {
272                 hba->age++;
273                 set_bit(BNX2I_CNIC_REGISTERED, &hba->reg_with_cnic);
274         } else if (rc == -EBUSY)        /* duplicate registration */
275                 printk(KERN_ALERT "bnx2i, duplicate registration"
276                                   "hba=%p, cnic=%p\n", hba, cnic);
277         else if (rc == -EAGAIN)
278                 printk(KERN_ERR "bnx2i, driver not registered\n");
279         else if (rc == -EINVAL)
280                 printk(KERN_ERR "bnx2i, invalid type %d\n", CNIC_ULP_ISCSI);
281         else
282                 printk(KERN_ERR "bnx2i dev reg, unknown error, %d\n", rc);
283         read_unlock(&bnx2i_dev_lock);
284
285         if (!rc) {
286                 write_lock(&bnx2i_dev_lock);
287                 list_add_tail(&hba->link, &adapter_list);
288                 adapter_count++;
289                 write_unlock(&bnx2i_dev_lock);
290         }
291
292         return rc;
293 }
294
295
296 /**
297  * bnx2i_ulp_init - initialize an adapter instance
298  * @dev:        cnic device handle
299  *
300  * Called from cnic_register_driver() context to initialize all enumerated
301  *      cnic devices. This routine allocate adapter structure and other
302  *      device specific resources.
303  */
304 void bnx2i_ulp_init(struct cnic_dev *dev)
305 {
306         struct bnx2i_hba *hba;
307
308         /* Allocate a HBA structure for this device */
309         hba = bnx2i_alloc_hba(dev);
310         if (!hba) {
311                 printk(KERN_ERR "bnx2i init: hba initialization failed\n");
312                 return;
313         }
314
315         /* Get PCI related information and update hba struct members */
316         clear_bit(BNX2I_CNIC_REGISTERED, &hba->reg_with_cnic);
317         if (bnx2i_init_one(hba, dev)) {
318                 printk(KERN_ERR "bnx2i - hba %p init failed\n", hba);
319                 bnx2i_free_hba(hba);
320         } else
321                 hba->cnic = dev;
322 }
323
324
325 /**
326  * bnx2i_ulp_exit - shuts down adapter instance and frees all resources
327  * @dev:        cnic device handle
328  *
329  */
330 void bnx2i_ulp_exit(struct cnic_dev *dev)
331 {
332         struct bnx2i_hba *hba;
333
334         hba = bnx2i_find_hba_for_cnic(dev);
335         if (!hba) {
336                 printk(KERN_INFO "bnx2i_ulp_exit: hba not "
337                                  "found, dev 0x%p\n", dev);
338                 return;
339         }
340         write_lock(&bnx2i_dev_lock);
341         list_del_init(&hba->link);
342         adapter_count--;
343
344         if (test_bit(BNX2I_CNIC_REGISTERED, &hba->reg_with_cnic)) {
345                 hba->cnic->unregister_device(hba->cnic, CNIC_ULP_ISCSI);
346                 clear_bit(BNX2I_CNIC_REGISTERED, &hba->reg_with_cnic);
347         }
348         write_unlock(&bnx2i_dev_lock);
349
350         bnx2i_free_hba(hba);
351 }
352
353
354 /**
355  * bnx2i_mod_init - module init entry point
356  *
357  * initialize any driver wide global data structures such as endpoint pool,
358  *      tcp port manager/queue, sysfs. finally driver will register itself
359  *      with the cnic module
360  */
361 static int __init bnx2i_mod_init(void)
362 {
363         int err;
364
365         printk(KERN_INFO "%s", version);
366
367         if (!is_power_of_2(sq_size))
368                 sq_size = roundup_pow_of_two(sq_size);
369
370         bnx2i_scsi_xport_template =
371                         iscsi_register_transport(&bnx2i_iscsi_transport);
372         if (!bnx2i_scsi_xport_template) {
373                 printk(KERN_ERR "Could not register bnx2i transport.\n");
374                 err = -ENOMEM;
375                 goto out;
376         }
377
378         err = cnic_register_driver(CNIC_ULP_ISCSI, &bnx2i_cnic_cb);
379         if (err) {
380                 printk(KERN_ERR "Could not register bnx2i cnic driver.\n");
381                 goto unreg_xport;
382         }
383
384         return 0;
385
386 unreg_xport:
387         iscsi_unregister_transport(&bnx2i_iscsi_transport);
388 out:
389         return err;
390 }
391
392
393 /**
394  * bnx2i_mod_exit - module cleanup/exit entry point
395  *
396  * Global resource lock and host adapter lock is held during critical sections
397  *      in this function. Driver will browse through the adapter list, cleans-up
398  *      each instance, unregisters iscsi transport name and finally driver will
399  *      unregister itself with the cnic module
400  */
401 static void __exit bnx2i_mod_exit(void)
402 {
403         struct bnx2i_hba *hba;
404
405         write_lock(&bnx2i_dev_lock);
406         while (!list_empty(&adapter_list)) {
407                 hba = list_entry(adapter_list.next, struct bnx2i_hba, link);
408                 list_del(&hba->link);
409                 adapter_count--;
410
411                 if (test_bit(BNX2I_CNIC_REGISTERED, &hba->reg_with_cnic)) {
412                         hba->cnic->unregister_device(hba->cnic, CNIC_ULP_ISCSI);
413                         clear_bit(BNX2I_CNIC_REGISTERED, &hba->reg_with_cnic);
414                 }
415
416                 write_unlock(&bnx2i_dev_lock);
417                 bnx2i_free_hba(hba);
418                 write_lock(&bnx2i_dev_lock);
419         }
420         write_unlock(&bnx2i_dev_lock);
421
422         iscsi_unregister_transport(&bnx2i_iscsi_transport);
423         cnic_unregister_driver(CNIC_ULP_ISCSI);
424 }
425
426 module_init(bnx2i_mod_init);
427 module_exit(bnx2i_mod_exit);