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