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