[SCSI] mvsas: misc improvements
[linux-2.6.git] / drivers / scsi / mvsas / mv_init.c
1 /*
2  * Marvell 88SE64xx/88SE94xx pci init
3  *
4  * Copyright 2007 Red Hat, Inc.
5  * Copyright 2008 Marvell. <kewei@marvell.com>
6  * Copyright 2009-2011 Marvell. <yuxiangl@marvell.com>
7  *
8  * This file is licensed under GPLv2.
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License as
12  * published by the Free Software Foundation; version 2 of the
13  * License.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
23  * USA
24 */
25
26
27 #include "mv_sas.h"
28
29 static int lldd_max_execute_num = 1;
30 module_param_named(collector, lldd_max_execute_num, int, S_IRUGO);
31 MODULE_PARM_DESC(collector, "\n"
32         "\tIf greater than one, tells the SAS Layer to run in Task Collector\n"
33         "\tMode.  If 1 or 0, tells the SAS Layer to run in Direct Mode.\n"
34         "\tThe mvsas SAS LLDD supports both modes.\n"
35         "\tDefault: 1 (Direct Mode).\n");
36
37 int interrupt_coalescing = 0x80;
38
39 static struct scsi_transport_template *mvs_stt;
40 struct kmem_cache *mvs_task_list_cache;
41 static const struct mvs_chip_info mvs_chips[] = {
42         [chip_6320] =   { 1, 2, 0x400, 17, 16, 6,  9, &mvs_64xx_dispatch, },
43         [chip_6440] =   { 1, 4, 0x400, 17, 16, 6,  9, &mvs_64xx_dispatch, },
44         [chip_6485] =   { 1, 8, 0x800, 33, 32, 6, 10, &mvs_64xx_dispatch, },
45         [chip_9180] =   { 2, 4, 0x800, 17, 64, 8,  9, &mvs_94xx_dispatch, },
46         [chip_9480] =   { 2, 4, 0x800, 17, 64, 8,  9, &mvs_94xx_dispatch, },
47         [chip_9445] =   { 1, 4, 0x800, 17, 64, 8, 11, &mvs_94xx_dispatch, },
48         [chip_9485] =   { 2, 4, 0x800, 17, 64, 8, 11, &mvs_94xx_dispatch, },
49         [chip_1300] =   { 1, 4, 0x400, 17, 16, 6,  9, &mvs_64xx_dispatch, },
50         [chip_1320] =   { 2, 4, 0x800, 17, 64, 8,  9, &mvs_94xx_dispatch, },
51 };
52
53 struct device_attribute *mvst_host_attrs[];
54
55 #define SOC_SAS_NUM 2
56
57 static struct scsi_host_template mvs_sht = {
58         .module                 = THIS_MODULE,
59         .name                   = DRV_NAME,
60         .queuecommand           = sas_queuecommand,
61         .target_alloc           = sas_target_alloc,
62         .slave_configure        = mvs_slave_configure,
63         .slave_destroy          = sas_slave_destroy,
64         .scan_finished          = mvs_scan_finished,
65         .scan_start             = mvs_scan_start,
66         .change_queue_depth     = sas_change_queue_depth,
67         .change_queue_type      = sas_change_queue_type,
68         .bios_param             = sas_bios_param,
69         .can_queue              = 1,
70         .cmd_per_lun            = 1,
71         .this_id                = -1,
72         .sg_tablesize           = SG_ALL,
73         .max_sectors            = SCSI_DEFAULT_MAX_SECTORS,
74         .use_clustering         = ENABLE_CLUSTERING,
75         .eh_device_reset_handler = sas_eh_device_reset_handler,
76         .eh_bus_reset_handler   = sas_eh_bus_reset_handler,
77         .slave_alloc            = mvs_slave_alloc,
78         .target_destroy         = sas_target_destroy,
79         .ioctl                  = sas_ioctl,
80         .shost_attrs            = mvst_host_attrs,
81 };
82
83 static struct sas_domain_function_template mvs_transport_ops = {
84         .lldd_dev_found         = mvs_dev_found,
85         .lldd_dev_gone          = mvs_dev_gone,
86         .lldd_execute_task      = mvs_queue_command,
87         .lldd_control_phy       = mvs_phy_control,
88
89         .lldd_abort_task        = mvs_abort_task,
90         .lldd_abort_task_set    = mvs_abort_task_set,
91         .lldd_clear_aca         = mvs_clear_aca,
92         .lldd_clear_task_set    = mvs_clear_task_set,
93         .lldd_I_T_nexus_reset   = mvs_I_T_nexus_reset,
94         .lldd_lu_reset          = mvs_lu_reset,
95         .lldd_query_task        = mvs_query_task,
96         .lldd_port_formed       = mvs_port_formed,
97         .lldd_port_deformed     = mvs_port_deformed,
98
99 };
100
101 static void __devinit mvs_phy_init(struct mvs_info *mvi, int phy_id)
102 {
103         struct mvs_phy *phy = &mvi->phy[phy_id];
104         struct asd_sas_phy *sas_phy = &phy->sas_phy;
105
106         phy->mvi = mvi;
107         phy->port = NULL;
108         init_timer(&phy->timer);
109         sas_phy->enabled = (phy_id < mvi->chip->n_phy) ? 1 : 0;
110         sas_phy->class = SAS;
111         sas_phy->iproto = SAS_PROTOCOL_ALL;
112         sas_phy->tproto = 0;
113         sas_phy->type = PHY_TYPE_PHYSICAL;
114         sas_phy->role = PHY_ROLE_INITIATOR;
115         sas_phy->oob_mode = OOB_NOT_CONNECTED;
116         sas_phy->linkrate = SAS_LINK_RATE_UNKNOWN;
117
118         sas_phy->id = phy_id;
119         sas_phy->sas_addr = &mvi->sas_addr[0];
120         sas_phy->frame_rcvd = &phy->frame_rcvd[0];
121         sas_phy->ha = (struct sas_ha_struct *)mvi->shost->hostdata;
122         sas_phy->lldd_phy = phy;
123 }
124
125 static void mvs_free(struct mvs_info *mvi)
126 {
127         struct mvs_wq *mwq;
128         int slot_nr;
129
130         if (!mvi)
131                 return;
132
133         if (mvi->flags & MVF_FLAG_SOC)
134                 slot_nr = MVS_SOC_SLOTS;
135         else
136                 slot_nr = MVS_CHIP_SLOT_SZ;
137
138         if (mvi->dma_pool)
139                 pci_pool_destroy(mvi->dma_pool);
140
141         if (mvi->tx)
142                 dma_free_coherent(mvi->dev,
143                                   sizeof(*mvi->tx) * MVS_CHIP_SLOT_SZ,
144                                   mvi->tx, mvi->tx_dma);
145         if (mvi->rx_fis)
146                 dma_free_coherent(mvi->dev, MVS_RX_FISL_SZ,
147                                   mvi->rx_fis, mvi->rx_fis_dma);
148         if (mvi->rx)
149                 dma_free_coherent(mvi->dev,
150                                   sizeof(*mvi->rx) * (MVS_RX_RING_SZ + 1),
151                                   mvi->rx, mvi->rx_dma);
152         if (mvi->slot)
153                 dma_free_coherent(mvi->dev,
154                                   sizeof(*mvi->slot) * slot_nr,
155                                   mvi->slot, mvi->slot_dma);
156
157         if (mvi->bulk_buffer)
158                 dma_free_coherent(mvi->dev, TRASH_BUCKET_SIZE,
159                                   mvi->bulk_buffer, mvi->bulk_buffer_dma);
160         if (mvi->bulk_buffer1)
161                 dma_free_coherent(mvi->dev, TRASH_BUCKET_SIZE,
162                                   mvi->bulk_buffer1, mvi->bulk_buffer_dma1);
163
164         MVS_CHIP_DISP->chip_iounmap(mvi);
165         if (mvi->shost)
166                 scsi_host_put(mvi->shost);
167         list_for_each_entry(mwq, &mvi->wq_list, entry)
168                 cancel_delayed_work(&mwq->work_q);
169         kfree(mvi->tags);
170         kfree(mvi);
171 }
172
173 #ifdef MVS_USE_TASKLET
174 struct tasklet_struct   mv_tasklet;
175 static void mvs_tasklet(unsigned long opaque)
176 {
177         unsigned long flags;
178         u32 stat;
179         u16 core_nr, i = 0;
180
181         struct mvs_info *mvi;
182         struct sas_ha_struct *sha = (struct sas_ha_struct *)opaque;
183
184         core_nr = ((struct mvs_prv_info *)sha->lldd_ha)->n_host;
185         mvi = ((struct mvs_prv_info *)sha->lldd_ha)->mvi[0];
186
187         if (unlikely(!mvi))
188                 BUG_ON(1);
189
190         for (i = 0; i < core_nr; i++) {
191                 mvi = ((struct mvs_prv_info *)sha->lldd_ha)->mvi[i];
192                 stat = MVS_CHIP_DISP->isr_status(mvi, mvi->irq);
193                 if (stat)
194                         MVS_CHIP_DISP->isr(mvi, mvi->irq, stat);
195         }
196
197 }
198 #endif
199
200 static irqreturn_t mvs_interrupt(int irq, void *opaque)
201 {
202         u32 core_nr, i = 0;
203         u32 stat;
204         struct mvs_info *mvi;
205         struct sas_ha_struct *sha = opaque;
206
207         core_nr = ((struct mvs_prv_info *)sha->lldd_ha)->n_host;
208         mvi = ((struct mvs_prv_info *)sha->lldd_ha)->mvi[0];
209
210         if (unlikely(!mvi))
211                 return IRQ_NONE;
212
213         stat = MVS_CHIP_DISP->isr_status(mvi, irq);
214         if (!stat)
215                 return IRQ_NONE;
216
217 #ifdef MVS_USE_TASKLET
218         tasklet_schedule(&mv_tasklet);
219 #else
220         for (i = 0; i < core_nr; i++) {
221                 mvi = ((struct mvs_prv_info *)sha->lldd_ha)->mvi[i];
222                 MVS_CHIP_DISP->isr(mvi, irq, stat);
223         }
224 #endif
225         return IRQ_HANDLED;
226 }
227
228 static int __devinit mvs_alloc(struct mvs_info *mvi, struct Scsi_Host *shost)
229 {
230         int i = 0, slot_nr;
231         char pool_name[32];
232
233         if (mvi->flags & MVF_FLAG_SOC)
234                 slot_nr = MVS_SOC_SLOTS;
235         else
236                 slot_nr = MVS_CHIP_SLOT_SZ;
237
238         spin_lock_init(&mvi->lock);
239         for (i = 0; i < mvi->chip->n_phy; i++) {
240                 mvs_phy_init(mvi, i);
241                 mvi->port[i].wide_port_phymap = 0;
242                 mvi->port[i].port_attached = 0;
243                 INIT_LIST_HEAD(&mvi->port[i].list);
244         }
245         for (i = 0; i < MVS_MAX_DEVICES; i++) {
246                 mvi->devices[i].taskfileset = MVS_ID_NOT_MAPPED;
247                 mvi->devices[i].dev_type = NO_DEVICE;
248                 mvi->devices[i].device_id = i;
249                 mvi->devices[i].dev_status = MVS_DEV_NORMAL;
250                 init_timer(&mvi->devices[i].timer);
251         }
252
253         /*
254          * alloc and init our DMA areas
255          */
256         mvi->tx = dma_alloc_coherent(mvi->dev,
257                                      sizeof(*mvi->tx) * MVS_CHIP_SLOT_SZ,
258                                      &mvi->tx_dma, GFP_KERNEL);
259         if (!mvi->tx)
260                 goto err_out;
261         memset(mvi->tx, 0, sizeof(*mvi->tx) * MVS_CHIP_SLOT_SZ);
262         mvi->rx_fis = dma_alloc_coherent(mvi->dev, MVS_RX_FISL_SZ,
263                                          &mvi->rx_fis_dma, GFP_KERNEL);
264         if (!mvi->rx_fis)
265                 goto err_out;
266         memset(mvi->rx_fis, 0, MVS_RX_FISL_SZ);
267
268         mvi->rx = dma_alloc_coherent(mvi->dev,
269                                      sizeof(*mvi->rx) * (MVS_RX_RING_SZ + 1),
270                                      &mvi->rx_dma, GFP_KERNEL);
271         if (!mvi->rx)
272                 goto err_out;
273         memset(mvi->rx, 0, sizeof(*mvi->rx) * (MVS_RX_RING_SZ + 1));
274         mvi->rx[0] = cpu_to_le32(0xfff);
275         mvi->rx_cons = 0xfff;
276
277         mvi->slot = dma_alloc_coherent(mvi->dev,
278                                        sizeof(*mvi->slot) * slot_nr,
279                                        &mvi->slot_dma, GFP_KERNEL);
280         if (!mvi->slot)
281                 goto err_out;
282         memset(mvi->slot, 0, sizeof(*mvi->slot) * slot_nr);
283
284         mvi->bulk_buffer = dma_alloc_coherent(mvi->dev,
285                                        TRASH_BUCKET_SIZE,
286                                        &mvi->bulk_buffer_dma, GFP_KERNEL);
287         if (!mvi->bulk_buffer)
288                 goto err_out;
289
290         mvi->bulk_buffer1 = dma_alloc_coherent(mvi->dev,
291                                        TRASH_BUCKET_SIZE,
292                                        &mvi->bulk_buffer_dma1, GFP_KERNEL);
293         if (!mvi->bulk_buffer1)
294                 goto err_out;
295
296         sprintf(pool_name, "%s%d", "mvs_dma_pool", mvi->id);
297         mvi->dma_pool = pci_pool_create(pool_name, mvi->pdev, MVS_SLOT_BUF_SZ, 16, 0);
298         if (!mvi->dma_pool) {
299                         printk(KERN_DEBUG "failed to create dma pool %s.\n", pool_name);
300                         goto err_out;
301         }
302         mvi->tags_num = slot_nr;
303
304         /* Initialize tags */
305         mvs_tag_init(mvi);
306         return 0;
307 err_out:
308         return 1;
309 }
310
311
312 int mvs_ioremap(struct mvs_info *mvi, int bar, int bar_ex)
313 {
314         unsigned long res_start, res_len, res_flag, res_flag_ex = 0;
315         struct pci_dev *pdev = mvi->pdev;
316         if (bar_ex != -1) {
317                 /*
318                  * ioremap main and peripheral registers
319                  */
320                 res_start = pci_resource_start(pdev, bar_ex);
321                 res_len = pci_resource_len(pdev, bar_ex);
322                 if (!res_start || !res_len)
323                         goto err_out;
324
325                 res_flag_ex = pci_resource_flags(pdev, bar_ex);
326                 if (res_flag_ex & IORESOURCE_MEM) {
327                         if (res_flag_ex & IORESOURCE_CACHEABLE)
328                                 mvi->regs_ex = ioremap(res_start, res_len);
329                         else
330                                 mvi->regs_ex = ioremap_nocache(res_start,
331                                                 res_len);
332                 } else
333                         mvi->regs_ex = (void *)res_start;
334                 if (!mvi->regs_ex)
335                         goto err_out;
336         }
337
338         res_start = pci_resource_start(pdev, bar);
339         res_len = pci_resource_len(pdev, bar);
340         if (!res_start || !res_len)
341                 goto err_out;
342
343         res_flag = pci_resource_flags(pdev, bar);
344         if (res_flag & IORESOURCE_CACHEABLE)
345                 mvi->regs = ioremap(res_start, res_len);
346         else
347                 mvi->regs = ioremap_nocache(res_start, res_len);
348
349         if (!mvi->regs) {
350                 if (mvi->regs_ex && (res_flag_ex & IORESOURCE_MEM))
351                         iounmap(mvi->regs_ex);
352                 mvi->regs_ex = NULL;
353                 goto err_out;
354         }
355
356         return 0;
357 err_out:
358         return -1;
359 }
360
361 void mvs_iounmap(void __iomem *regs)
362 {
363         iounmap(regs);
364 }
365
366 static struct mvs_info *__devinit mvs_pci_alloc(struct pci_dev *pdev,
367                                 const struct pci_device_id *ent,
368                                 struct Scsi_Host *shost, unsigned int id)
369 {
370         struct mvs_info *mvi = NULL;
371         struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
372
373         mvi = kzalloc(sizeof(*mvi) +
374                 (1L << mvs_chips[ent->driver_data].slot_width) *
375                 sizeof(struct mvs_slot_info), GFP_KERNEL);
376         if (!mvi)
377                 return NULL;
378
379         mvi->pdev = pdev;
380         mvi->dev = &pdev->dev;
381         mvi->chip_id = ent->driver_data;
382         mvi->chip = &mvs_chips[mvi->chip_id];
383         INIT_LIST_HEAD(&mvi->wq_list);
384
385         ((struct mvs_prv_info *)sha->lldd_ha)->mvi[id] = mvi;
386         ((struct mvs_prv_info *)sha->lldd_ha)->n_phy = mvi->chip->n_phy;
387
388         mvi->id = id;
389         mvi->sas = sha;
390         mvi->shost = shost;
391 #ifdef MVS_USE_TASKLET
392         tasklet_init(&mv_tasklet, mvs_tasklet, (unsigned long)sha);
393 #endif
394
395         mvi->tags = kzalloc(MVS_CHIP_SLOT_SZ>>3, GFP_KERNEL);
396         if (!mvi->tags)
397                 goto err_out;
398
399         if (MVS_CHIP_DISP->chip_ioremap(mvi))
400                 goto err_out;
401         if (!mvs_alloc(mvi, shost))
402                 return mvi;
403 err_out:
404         mvs_free(mvi);
405         return NULL;
406 }
407
408 /* move to PCI layer or libata core? */
409 static int pci_go_64(struct pci_dev *pdev)
410 {
411         int rc;
412
413         if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
414                 rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
415                 if (rc) {
416                         rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
417                         if (rc) {
418                                 dev_printk(KERN_ERR, &pdev->dev,
419                                            "64-bit DMA enable failed\n");
420                                 return rc;
421                         }
422                 }
423         } else {
424                 rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
425                 if (rc) {
426                         dev_printk(KERN_ERR, &pdev->dev,
427                                    "32-bit DMA enable failed\n");
428                         return rc;
429                 }
430                 rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
431                 if (rc) {
432                         dev_printk(KERN_ERR, &pdev->dev,
433                                    "32-bit consistent DMA enable failed\n");
434                         return rc;
435                 }
436         }
437
438         return rc;
439 }
440
441 static int __devinit mvs_prep_sas_ha_init(struct Scsi_Host *shost,
442                                 const struct mvs_chip_info *chip_info)
443 {
444         int phy_nr, port_nr; unsigned short core_nr;
445         struct asd_sas_phy **arr_phy;
446         struct asd_sas_port **arr_port;
447         struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
448
449         core_nr = chip_info->n_host;
450         phy_nr  = core_nr * chip_info->n_phy;
451         port_nr = phy_nr;
452
453         memset(sha, 0x00, sizeof(struct sas_ha_struct));
454         arr_phy  = kcalloc(phy_nr, sizeof(void *), GFP_KERNEL);
455         arr_port = kcalloc(port_nr, sizeof(void *), GFP_KERNEL);
456         if (!arr_phy || !arr_port)
457                 goto exit_free;
458
459         sha->sas_phy = arr_phy;
460         sha->sas_port = arr_port;
461         sha->core.shost = shost;
462
463         sha->lldd_ha = kzalloc(sizeof(struct mvs_prv_info), GFP_KERNEL);
464         if (!sha->lldd_ha)
465                 goto exit_free;
466
467         ((struct mvs_prv_info *)sha->lldd_ha)->n_host = core_nr;
468
469         shost->transportt = mvs_stt;
470         shost->max_id = MVS_MAX_DEVICES;
471         shost->max_lun = ~0;
472         shost->max_channel = 1;
473         shost->max_cmd_len = 16;
474
475         return 0;
476 exit_free:
477         kfree(arr_phy);
478         kfree(arr_port);
479         return -1;
480
481 }
482
483 static void  __devinit mvs_post_sas_ha_init(struct Scsi_Host *shost,
484                         const struct mvs_chip_info *chip_info)
485 {
486         int can_queue, i = 0, j = 0;
487         struct mvs_info *mvi = NULL;
488         struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
489         unsigned short nr_core = ((struct mvs_prv_info *)sha->lldd_ha)->n_host;
490
491         for (j = 0; j < nr_core; j++) {
492                 mvi = ((struct mvs_prv_info *)sha->lldd_ha)->mvi[j];
493                 for (i = 0; i < chip_info->n_phy; i++) {
494                         sha->sas_phy[j * chip_info->n_phy  + i] =
495                                 &mvi->phy[i].sas_phy;
496                         sha->sas_port[j * chip_info->n_phy + i] =
497                                 &mvi->port[i].sas_port;
498                 }
499         }
500
501         sha->sas_ha_name = DRV_NAME;
502         sha->dev = mvi->dev;
503         sha->lldd_module = THIS_MODULE;
504         sha->sas_addr = &mvi->sas_addr[0];
505
506         sha->num_phys = nr_core * chip_info->n_phy;
507
508         sha->lldd_max_execute_num = lldd_max_execute_num;
509
510         if (mvi->flags & MVF_FLAG_SOC)
511                 can_queue = MVS_SOC_CAN_QUEUE;
512         else
513                 can_queue = MVS_CHIP_SLOT_SZ;
514
515         sha->lldd_queue_size = can_queue;
516         shost->sg_tablesize = min_t(u16, SG_ALL, MVS_MAX_SG);
517         shost->can_queue = can_queue;
518         mvi->shost->cmd_per_lun = MVS_QUEUE_SIZE;
519         sha->core.shost = mvi->shost;
520 }
521
522 static void mvs_init_sas_add(struct mvs_info *mvi)
523 {
524         u8 i;
525         for (i = 0; i < mvi->chip->n_phy; i++) {
526                 mvi->phy[i].dev_sas_addr = 0x5005043011ab0000ULL;
527                 mvi->phy[i].dev_sas_addr =
528                         cpu_to_be64((u64)(*(u64 *)&mvi->phy[i].dev_sas_addr));
529         }
530
531         memcpy(mvi->sas_addr, &mvi->phy[0].dev_sas_addr, SAS_ADDR_SIZE);
532 }
533
534 static int __devinit mvs_pci_init(struct pci_dev *pdev,
535                                   const struct pci_device_id *ent)
536 {
537         unsigned int rc, nhost = 0;
538         struct mvs_info *mvi;
539         irq_handler_t irq_handler = mvs_interrupt;
540         struct Scsi_Host *shost = NULL;
541         const struct mvs_chip_info *chip;
542
543         dev_printk(KERN_INFO, &pdev->dev,
544                 "mvsas: driver version %s\n", DRV_VERSION);
545         rc = pci_enable_device(pdev);
546         if (rc)
547                 goto err_out_enable;
548
549         pci_set_master(pdev);
550
551         rc = pci_request_regions(pdev, DRV_NAME);
552         if (rc)
553                 goto err_out_disable;
554
555         rc = pci_go_64(pdev);
556         if (rc)
557                 goto err_out_regions;
558
559         shost = scsi_host_alloc(&mvs_sht, sizeof(void *));
560         if (!shost) {
561                 rc = -ENOMEM;
562                 goto err_out_regions;
563         }
564
565         chip = &mvs_chips[ent->driver_data];
566         SHOST_TO_SAS_HA(shost) =
567                 kcalloc(1, sizeof(struct sas_ha_struct), GFP_KERNEL);
568         if (!SHOST_TO_SAS_HA(shost)) {
569                 kfree(shost);
570                 rc = -ENOMEM;
571                 goto err_out_regions;
572         }
573
574         rc = mvs_prep_sas_ha_init(shost, chip);
575         if (rc) {
576                 kfree(shost);
577                 rc = -ENOMEM;
578                 goto err_out_regions;
579         }
580
581         pci_set_drvdata(pdev, SHOST_TO_SAS_HA(shost));
582
583         do {
584                 mvi = mvs_pci_alloc(pdev, ent, shost, nhost);
585                 if (!mvi) {
586                         rc = -ENOMEM;
587                         goto err_out_regions;
588                 }
589
590                 memset(&mvi->hba_info_param, 0xFF,
591                         sizeof(struct hba_info_page));
592
593                 mvs_init_sas_add(mvi);
594
595                 mvi->instance = nhost;
596                 rc = MVS_CHIP_DISP->chip_init(mvi);
597                 if (rc) {
598                         mvs_free(mvi);
599                         goto err_out_regions;
600                 }
601                 nhost++;
602         } while (nhost < chip->n_host);
603 #ifdef MVS_USE_TASKLET
604         tasklet_init(&mv_tasklet, mvs_tasklet,
605                      (unsigned long)SHOST_TO_SAS_HA(shost));
606 #endif
607
608         mvs_post_sas_ha_init(shost, chip);
609
610         rc = scsi_add_host(shost, &pdev->dev);
611         if (rc)
612                 goto err_out_shost;
613
614         rc = sas_register_ha(SHOST_TO_SAS_HA(shost));
615         if (rc)
616                 goto err_out_shost;
617         rc = request_irq(pdev->irq, irq_handler, IRQF_SHARED,
618                 DRV_NAME, SHOST_TO_SAS_HA(shost));
619         if (rc)
620                 goto err_not_sas;
621
622         MVS_CHIP_DISP->interrupt_enable(mvi);
623
624         scsi_scan_host(mvi->shost);
625
626         return 0;
627
628 err_not_sas:
629         sas_unregister_ha(SHOST_TO_SAS_HA(shost));
630 err_out_shost:
631         scsi_remove_host(mvi->shost);
632 err_out_regions:
633         pci_release_regions(pdev);
634 err_out_disable:
635         pci_disable_device(pdev);
636 err_out_enable:
637         return rc;
638 }
639
640 static void __devexit mvs_pci_remove(struct pci_dev *pdev)
641 {
642         unsigned short core_nr, i = 0;
643         struct sas_ha_struct *sha = pci_get_drvdata(pdev);
644         struct mvs_info *mvi = NULL;
645
646         core_nr = ((struct mvs_prv_info *)sha->lldd_ha)->n_host;
647         mvi = ((struct mvs_prv_info *)sha->lldd_ha)->mvi[0];
648
649 #ifdef MVS_USE_TASKLET
650         tasklet_kill(&mv_tasklet);
651 #endif
652
653         pci_set_drvdata(pdev, NULL);
654         sas_unregister_ha(sha);
655         sas_remove_host(mvi->shost);
656         scsi_remove_host(mvi->shost);
657
658         MVS_CHIP_DISP->interrupt_disable(mvi);
659         free_irq(mvi->pdev->irq, sha);
660         for (i = 0; i < core_nr; i++) {
661                 mvi = ((struct mvs_prv_info *)sha->lldd_ha)->mvi[i];
662                 mvs_free(mvi);
663         }
664         kfree(sha->sas_phy);
665         kfree(sha->sas_port);
666         kfree(sha);
667         pci_release_regions(pdev);
668         pci_disable_device(pdev);
669         return;
670 }
671
672 static struct pci_device_id __devinitdata mvs_pci_table[] = {
673         { PCI_VDEVICE(MARVELL, 0x6320), chip_6320 },
674         { PCI_VDEVICE(MARVELL, 0x6340), chip_6440 },
675         {
676                 .vendor         = PCI_VENDOR_ID_MARVELL,
677                 .device         = 0x6440,
678                 .subvendor      = PCI_ANY_ID,
679                 .subdevice      = 0x6480,
680                 .class          = 0,
681                 .class_mask     = 0,
682                 .driver_data    = chip_6485,
683         },
684         { PCI_VDEVICE(MARVELL, 0x6440), chip_6440 },
685         { PCI_VDEVICE(MARVELL, 0x6485), chip_6485 },
686         { PCI_VDEVICE(MARVELL, 0x9480), chip_9480 },
687         { PCI_VDEVICE(MARVELL, 0x9180), chip_9180 },
688         { PCI_VDEVICE(ARECA, PCI_DEVICE_ID_ARECA_1300), chip_1300 },
689         { PCI_VDEVICE(ARECA, PCI_DEVICE_ID_ARECA_1320), chip_1320 },
690         { PCI_VDEVICE(ADAPTEC2, 0x0450), chip_6440 },
691         { PCI_VDEVICE(TTI, 0x2710), chip_9480 },
692         { PCI_VDEVICE(TTI, 0x2720), chip_9480 },
693         { PCI_VDEVICE(TTI, 0x2721), chip_9480 },
694         { PCI_VDEVICE(TTI, 0x2722), chip_9480 },
695         { PCI_VDEVICE(TTI, 0x2740), chip_9480 },
696         { PCI_VDEVICE(TTI, 0x2744), chip_9480 },
697         { PCI_VDEVICE(TTI, 0x2760), chip_9480 },
698         {
699                 .vendor         = 0x1b4b,
700                 .device         = 0x9445,
701                 .subvendor      = PCI_ANY_ID,
702                 .subdevice      = 0x9480,
703                 .class          = 0,
704                 .class_mask     = 0,
705                 .driver_data    = chip_9445,
706         },
707         {
708                 .vendor         = 0x1b4b,
709                 .device         = 0x9485,
710                 .subvendor      = PCI_ANY_ID,
711                 .subdevice      = 0x9480,
712                 .class          = 0,
713                 .class_mask     = 0,
714                 .driver_data    = chip_9485,
715         },
716
717         { }     /* terminate list */
718 };
719
720 static struct pci_driver mvs_pci_driver = {
721         .name           = DRV_NAME,
722         .id_table       = mvs_pci_table,
723         .probe          = mvs_pci_init,
724         .remove         = __devexit_p(mvs_pci_remove),
725 };
726
727 static ssize_t
728 mvs_show_driver_version(struct device *cdev,
729                 struct device_attribute *attr,  char *buffer)
730 {
731         return snprintf(buffer, PAGE_SIZE, "%s\n", DRV_VERSION);
732 }
733
734 static DEVICE_ATTR(driver_version,
735                          S_IRUGO,
736                          mvs_show_driver_version,
737                          NULL);
738
739 static ssize_t
740 mvs_store_interrupt_coalescing(struct device *cdev,
741                         struct device_attribute *attr,
742                         const char *buffer, size_t size)
743 {
744         int val = 0;
745         struct mvs_info *mvi = NULL;
746         struct Scsi_Host *shost = class_to_shost(cdev);
747         struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
748         u8 i, core_nr;
749         if (buffer == NULL)
750                 return size;
751
752         if (sscanf(buffer, "%d", &val) != 1)
753                 return -EINVAL;
754
755         if (val >= 0x10000) {
756                 mv_dprintk("interrupt coalescing timer %d us is"
757                         "too long\n", val);
758                 return strlen(buffer);
759         }
760
761         interrupt_coalescing = val;
762
763         core_nr = ((struct mvs_prv_info *)sha->lldd_ha)->n_host;
764         mvi = ((struct mvs_prv_info *)sha->lldd_ha)->mvi[0];
765
766         if (unlikely(!mvi))
767                 return -EINVAL;
768
769         for (i = 0; i < core_nr; i++) {
770                 mvi = ((struct mvs_prv_info *)sha->lldd_ha)->mvi[i];
771                 if (MVS_CHIP_DISP->tune_interrupt)
772                         MVS_CHIP_DISP->tune_interrupt(mvi,
773                                 interrupt_coalescing);
774         }
775         mv_dprintk("set interrupt coalescing time to %d us\n",
776                 interrupt_coalescing);
777         return strlen(buffer);
778 }
779
780 static ssize_t mvs_show_interrupt_coalescing(struct device *cdev,
781                         struct device_attribute *attr, char *buffer)
782 {
783         return snprintf(buffer, PAGE_SIZE, "%d\n", interrupt_coalescing);
784 }
785
786 static DEVICE_ATTR(interrupt_coalescing,
787                          S_IRUGO|S_IWUSR,
788                          mvs_show_interrupt_coalescing,
789                          mvs_store_interrupt_coalescing);
790
791 /* task handler */
792 struct task_struct *mvs_th;
793 static int __init mvs_init(void)
794 {
795         int rc;
796         mvs_stt = sas_domain_attach_transport(&mvs_transport_ops);
797         if (!mvs_stt)
798                 return -ENOMEM;
799
800         mvs_task_list_cache = kmem_cache_create("mvs_task_list", sizeof(struct mvs_task_list),
801                                                          0, SLAB_HWCACHE_ALIGN, NULL);
802         if (!mvs_task_list_cache) {
803                 rc = -ENOMEM;
804                 mv_printk("%s: mvs_task_list_cache alloc failed! \n", __func__);
805                 goto err_out;
806         }
807
808         rc = pci_register_driver(&mvs_pci_driver);
809
810         if (rc)
811                 goto err_out;
812
813         return 0;
814
815 err_out:
816         sas_release_transport(mvs_stt);
817         return rc;
818 }
819
820 static void __exit mvs_exit(void)
821 {
822         pci_unregister_driver(&mvs_pci_driver);
823         sas_release_transport(mvs_stt);
824         kmem_cache_destroy(mvs_task_list_cache);
825 }
826
827 struct device_attribute *mvst_host_attrs[] = {
828         &dev_attr_driver_version,
829         &dev_attr_interrupt_coalescing,
830         NULL,
831 };
832
833 module_init(mvs_init);
834 module_exit(mvs_exit);
835
836 MODULE_AUTHOR("Jeff Garzik <jgarzik@pobox.com>");
837 MODULE_DESCRIPTION("Marvell 88SE6440 SAS/SATA controller driver");
838 MODULE_VERSION(DRV_VERSION);
839 MODULE_LICENSE("GPL");
840 #ifdef CONFIG_PCI
841 MODULE_DEVICE_TABLE(pci, mvs_pci_table);
842 #endif