Merge rsync://rsync.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6
[linux-2.6] / drivers / scsi / aic94xx / aic94xx_sds.c
1 /*
2  * Aic94xx SAS/SATA driver access to shared data structures and memory
3  * maps.
4  *
5  * Copyright (C) 2005 Adaptec, Inc.  All rights reserved.
6  * Copyright (C) 2005 Luben Tuikov <luben_tuikov@adaptec.com>
7  *
8  * This file is licensed under GPLv2.
9  *
10  * This file is part of the aic94xx driver.
11  *
12  * The aic94xx driver is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU General Public License as
14  * published by the Free Software Foundation; version 2 of the
15  * License.
16  *
17  * The aic94xx driver is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
20  * General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with the aic94xx driver; if not, write to the Free Software
24  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
25  *
26  */
27
28 #include <linux/pci.h>
29 #include <linux/delay.h>
30
31 #include "aic94xx.h"
32 #include "aic94xx_reg.h"
33
34 /* ---------- OCM stuff ---------- */
35
36 struct asd_ocm_dir_ent {
37         u8 type;
38         u8 offs[3];
39         u8 _r1;
40         u8 size[3];
41 } __attribute__ ((packed));
42
43 struct asd_ocm_dir {
44         char sig[2];
45         u8   _r1[2];
46         u8   major;          /* 0 */
47         u8   minor;          /* 0 */
48         u8   _r2;
49         u8   num_de;
50         struct asd_ocm_dir_ent entry[15];
51 } __attribute__ ((packed));
52
53 #define OCM_DE_OCM_DIR                  0x00
54 #define OCM_DE_WIN_DRVR                 0x01
55 #define OCM_DE_BIOS_CHIM                0x02
56 #define OCM_DE_RAID_ENGN                0x03
57 #define OCM_DE_BIOS_INTL                0x04
58 #define OCM_DE_BIOS_CHIM_OSM            0x05
59 #define OCM_DE_BIOS_CHIM_DYNAMIC        0x06
60 #define OCM_DE_ADDC2C_RES0              0x07
61 #define OCM_DE_ADDC2C_RES1              0x08
62 #define OCM_DE_ADDC2C_RES2              0x09
63 #define OCM_DE_ADDC2C_RES3              0x0A
64
65 #define OCM_INIT_DIR_ENTRIES    5
66 /***************************************************************************
67 *  OCM dircetory default
68 ***************************************************************************/
69 static struct asd_ocm_dir OCMDirInit =
70 {
71         .sig = {0x4D, 0x4F},    /* signature */
72         .num_de = OCM_INIT_DIR_ENTRIES, /* no. of directory entries */
73 };
74
75 /***************************************************************************
76 *  OCM dircetory Entries default
77 ***************************************************************************/
78 static struct asd_ocm_dir_ent OCMDirEntriesInit[OCM_INIT_DIR_ENTRIES] =
79 {
80         {
81                 .type = (OCM_DE_ADDC2C_RES0),   /* Entry type  */
82                 .offs = {128},                  /* Offset */
83                 .size = {0, 4},                 /* size */
84         },
85         {
86                 .type = (OCM_DE_ADDC2C_RES1),   /* Entry type  */
87                 .offs = {128, 4},               /* Offset */
88                 .size = {0, 4},                 /* size */
89         },
90         {
91                 .type = (OCM_DE_ADDC2C_RES2),   /* Entry type  */
92                 .offs = {128, 8},               /* Offset */
93                 .size = {0, 4},                 /* size */
94         },
95         {
96                 .type = (OCM_DE_ADDC2C_RES3),   /* Entry type  */
97                 .offs = {128, 12},              /* Offset */
98                 .size = {0, 4},                 /* size */
99         },
100         {
101                 .type = (OCM_DE_WIN_DRVR),      /* Entry type  */
102                 .offs = {128, 16},              /* Offset */
103                 .size = {128, 235, 1},          /* size */
104         },
105 };
106
107 struct asd_bios_chim_struct {
108         char sig[4];
109         u8   major;          /* 1 */
110         u8   minor;          /* 0 */
111         u8   bios_major;
112         u8   bios_minor;
113         __le32  bios_build;
114         u8   flags;
115         u8   pci_slot;
116         __le16  ue_num;
117         __le16  ue_size;
118         u8  _r[14];
119         /* The unit element array is right here.
120          */
121 } __attribute__ ((packed));
122
123 /**
124  * asd_read_ocm_seg - read an on chip memory (OCM) segment
125  * @asd_ha: pointer to the host adapter structure
126  * @buffer: where to write the read data
127  * @offs: offset into OCM where to read from
128  * @size: how many bytes to read
129  *
130  * Return the number of bytes not read. Return 0 on success.
131  */
132 static int asd_read_ocm_seg(struct asd_ha_struct *asd_ha, void *buffer,
133                             u32 offs, int size)
134 {
135         u8 *p = buffer;
136         if (unlikely(asd_ha->iospace))
137                 asd_read_reg_string(asd_ha, buffer, offs+OCM_BASE_ADDR, size);
138         else {
139                 for ( ; size > 0; size--, offs++, p++)
140                         *p = asd_read_ocm_byte(asd_ha, offs);
141         }
142         return size;
143 }
144
145 static int asd_read_ocm_dir(struct asd_ha_struct *asd_ha,
146                             struct asd_ocm_dir *dir, u32 offs)
147 {
148         int err = asd_read_ocm_seg(asd_ha, dir, offs, sizeof(*dir));
149         if (err) {
150                 ASD_DPRINTK("couldn't read ocm segment\n");
151                 return err;
152         }
153
154         if (dir->sig[0] != 'M' || dir->sig[1] != 'O') {
155                 ASD_DPRINTK("no valid dir signature(%c%c) at start of OCM\n",
156                             dir->sig[0], dir->sig[1]);
157                 return -ENOENT;
158         }
159         if (dir->major != 0) {
160                 asd_printk("unsupported major version of ocm dir:0x%x\n",
161                            dir->major);
162                 return -ENOENT;
163         }
164         dir->num_de &= 0xf;
165         return 0;
166 }
167
168 /**
169  * asd_write_ocm_seg - write an on chip memory (OCM) segment
170  * @asd_ha: pointer to the host adapter structure
171  * @buffer: where to read the write data
172  * @offs: offset into OCM to write to
173  * @size: how many bytes to write
174  *
175  * Return the number of bytes not written. Return 0 on success.
176  */
177 static void asd_write_ocm_seg(struct asd_ha_struct *asd_ha, void *buffer,
178                             u32 offs, int size)
179 {
180         u8 *p = buffer;
181         if (unlikely(asd_ha->iospace))
182                 asd_write_reg_string(asd_ha, buffer, offs+OCM_BASE_ADDR, size);
183         else {
184                 for ( ; size > 0; size--, offs++, p++)
185                         asd_write_ocm_byte(asd_ha, offs, *p);
186         }
187         return;
188 }
189
190 #define THREE_TO_NUM(X) ((X)[0] | ((X)[1] << 8) | ((X)[2] << 16))
191
192 static int asd_find_dir_entry(struct asd_ocm_dir *dir, u8 type,
193                               u32 *offs, u32 *size)
194 {
195         int i;
196         struct asd_ocm_dir_ent *ent;
197
198         for (i = 0; i < dir->num_de; i++) {
199                 if (dir->entry[i].type == type)
200                         break;
201         }
202         if (i >= dir->num_de)
203                 return -ENOENT;
204         ent = &dir->entry[i];
205         *offs = (u32) THREE_TO_NUM(ent->offs);
206         *size = (u32) THREE_TO_NUM(ent->size);
207         return 0;
208 }
209
210 #define OCM_BIOS_CHIM_DE  2
211 #define BC_BIOS_PRESENT   1
212
213 static int asd_get_bios_chim(struct asd_ha_struct *asd_ha,
214                              struct asd_ocm_dir *dir)
215 {
216         int err;
217         struct asd_bios_chim_struct *bc_struct;
218         u32 offs, size;
219
220         err = asd_find_dir_entry(dir, OCM_BIOS_CHIM_DE, &offs, &size);
221         if (err) {
222                 ASD_DPRINTK("couldn't find BIOS_CHIM dir ent\n");
223                 goto out;
224         }
225         err = -ENOMEM;
226         bc_struct = kmalloc(sizeof(*bc_struct), GFP_KERNEL);
227         if (!bc_struct) {
228                 asd_printk("no memory for bios_chim struct\n");
229                 goto out;
230         }
231         err = asd_read_ocm_seg(asd_ha, (void *)bc_struct, offs,
232                                sizeof(*bc_struct));
233         if (err) {
234                 ASD_DPRINTK("couldn't read ocm segment\n");
235                 goto out2;
236         }
237         if (strncmp(bc_struct->sig, "SOIB", 4)
238             && strncmp(bc_struct->sig, "IPSA", 4)) {
239                 ASD_DPRINTK("BIOS_CHIM entry has no valid sig(%c%c%c%c)\n",
240                             bc_struct->sig[0], bc_struct->sig[1],
241                             bc_struct->sig[2], bc_struct->sig[3]);
242                 err = -ENOENT;
243                 goto out2;
244         }
245         if (bc_struct->major != 1) {
246                 asd_printk("BIOS_CHIM unsupported major version:0x%x\n",
247                            bc_struct->major);
248                 err = -ENOENT;
249                 goto out2;
250         }
251         if (bc_struct->flags & BC_BIOS_PRESENT) {
252                 asd_ha->hw_prof.bios.present = 1;
253                 asd_ha->hw_prof.bios.maj = bc_struct->bios_major;
254                 asd_ha->hw_prof.bios.min = bc_struct->bios_minor;
255                 asd_ha->hw_prof.bios.bld = le32_to_cpu(bc_struct->bios_build);
256                 ASD_DPRINTK("BIOS present (%d,%d), %d\n",
257                             asd_ha->hw_prof.bios.maj,
258                             asd_ha->hw_prof.bios.min,
259                             asd_ha->hw_prof.bios.bld);
260         }
261         asd_ha->hw_prof.ue.num = le16_to_cpu(bc_struct->ue_num);
262         asd_ha->hw_prof.ue.size= le16_to_cpu(bc_struct->ue_size);
263         ASD_DPRINTK("ue num:%d, ue size:%d\n", asd_ha->hw_prof.ue.num,
264                     asd_ha->hw_prof.ue.size);
265         size = asd_ha->hw_prof.ue.num * asd_ha->hw_prof.ue.size;
266         if (size > 0) {
267                 err = -ENOMEM;
268                 asd_ha->hw_prof.ue.area = kmalloc(size, GFP_KERNEL);
269                 if (!asd_ha->hw_prof.ue.area)
270                         goto out2;
271                 err = asd_read_ocm_seg(asd_ha, (void *)asd_ha->hw_prof.ue.area,
272                                        offs + sizeof(*bc_struct), size);
273                 if (err) {
274                         kfree(asd_ha->hw_prof.ue.area);
275                         asd_ha->hw_prof.ue.area = NULL;
276                         asd_ha->hw_prof.ue.num  = 0;
277                         asd_ha->hw_prof.ue.size = 0;
278                         ASD_DPRINTK("couldn't read ue entries(%d)\n", err);
279                 }
280         }
281 out2:
282         kfree(bc_struct);
283 out:
284         return err;
285 }
286
287 static void
288 asd_hwi_initialize_ocm_dir (struct asd_ha_struct *asd_ha)
289 {
290         int i;
291
292         /* Zero OCM */
293         for (i = 0; i < OCM_MAX_SIZE; i += 4)
294                 asd_write_ocm_dword(asd_ha, i, 0);
295
296         /* Write Dir */
297         asd_write_ocm_seg(asd_ha, &OCMDirInit, 0,
298                           sizeof(struct asd_ocm_dir));
299
300         /* Write Dir Entries */
301         for (i = 0; i < OCM_INIT_DIR_ENTRIES; i++)
302                 asd_write_ocm_seg(asd_ha, &OCMDirEntriesInit[i],
303                                   sizeof(struct asd_ocm_dir) +
304                                   (i * sizeof(struct asd_ocm_dir_ent))
305                                   , sizeof(struct asd_ocm_dir_ent));
306
307 }
308
309 static int
310 asd_hwi_check_ocm_access (struct asd_ha_struct *asd_ha)
311 {
312         struct pci_dev *pcidev = asd_ha->pcidev;
313         u32 reg;
314         int err = 0;
315         u32 v;
316
317         /* check if OCM has been initialized by BIOS */
318         reg = asd_read_reg_dword(asd_ha, EXSICNFGR);
319
320         if (!(reg & OCMINITIALIZED)) {
321                 err = pci_read_config_dword(pcidev, PCIC_INTRPT_STAT, &v);
322                 if (err) {
323                         asd_printk("couldn't access PCIC_INTRPT_STAT of %s\n",
324                                         pci_name(pcidev));
325                         goto out;
326                 }
327
328                 printk(KERN_INFO "OCM is not initialized by BIOS,"
329                        "reinitialize it and ignore it, current IntrptStatus"
330                        "is 0x%x\n", v);
331
332                 if (v)
333                         err = pci_write_config_dword(pcidev,
334                                                      PCIC_INTRPT_STAT, v);
335                 if (err) {
336                         asd_printk("couldn't write PCIC_INTRPT_STAT of %s\n",
337                                         pci_name(pcidev));
338                         goto out;
339                 }
340
341                 asd_hwi_initialize_ocm_dir(asd_ha);
342
343         }
344 out:
345         return err;
346 }
347
348 /**
349  * asd_read_ocm - read on chip memory (OCM)
350  * @asd_ha: pointer to the host adapter structure
351  */
352 int asd_read_ocm(struct asd_ha_struct *asd_ha)
353 {
354         int err;
355         struct asd_ocm_dir *dir;
356
357         if (asd_hwi_check_ocm_access(asd_ha))
358                 return -1;
359
360         dir = kmalloc(sizeof(*dir), GFP_KERNEL);
361         if (!dir) {
362                 asd_printk("no memory for ocm dir\n");
363                 return -ENOMEM;
364         }
365
366         err = asd_read_ocm_dir(asd_ha, dir, 0);
367         if (err)
368                 goto out;
369
370         err = asd_get_bios_chim(asd_ha, dir);
371 out:
372         kfree(dir);
373         return err;
374 }
375
376 /* ---------- FLASH stuff ---------- */
377
378 #define FLASH_RESET                     0xF0
379
380 #define FLASH_SIZE                      0x200000
381 #define FLASH_DIR_COOKIE                "*** ADAPTEC FLASH DIRECTORY *** "
382 #define FLASH_NEXT_ENTRY_OFFS           0x2000
383 #define FLASH_MAX_DIR_ENTRIES           32
384
385 #define FLASH_DE_TYPE_MASK              0x3FFFFFFF
386 #define FLASH_DE_MS                     0x120
387 #define FLASH_DE_CTRL_A_USER            0xE0
388
389 struct asd_flash_de {
390         __le32   type;
391         __le32   offs;
392         __le32   pad_size;
393         __le32   image_size;
394         __le32   chksum;
395         u8       _r[12];
396         u8       version[32];
397 } __attribute__ ((packed));
398
399 struct asd_flash_dir {
400         u8    cookie[32];
401         __le32   rev;             /* 2 */
402         __le32   chksum;
403         __le32   chksum_antidote;
404         __le32   bld;
405         u8    bld_id[32];         /* build id data */
406         u8    ver_data[32];       /* date and time of build */
407         __le32   ae_mask;
408         __le32   v_mask;
409         __le32   oc_mask;
410         u8    _r[20];
411         struct asd_flash_de dir_entry[FLASH_MAX_DIR_ENTRIES];
412 } __attribute__ ((packed));
413
414 struct asd_manuf_sec {
415         char  sig[2];             /* 'S', 'M' */
416         u16   offs_next;
417         u8    maj;           /* 0 */
418         u8    min;           /* 0 */
419         u16   chksum;
420         u16   size;
421         u8    _r[6];
422         u8    sas_addr[SAS_ADDR_SIZE];
423         u8    pcba_sn[ASD_PCBA_SN_SIZE];
424         /* Here start the other segments */
425         u8    linked_list[0];
426 } __attribute__ ((packed));
427
428 struct asd_manuf_phy_desc {
429         u8    state;         /* low 4 bits */
430 #define MS_PHY_STATE_ENABLEABLE 0
431 #define MS_PHY_STATE_REPORTED   1
432 #define MS_PHY_STATE_HIDDEN     2
433         u8    phy_id;
434         u16   _r;
435         u8    phy_control_0; /* mode 5 reg 0x160 */
436         u8    phy_control_1; /* mode 5 reg 0x161 */
437         u8    phy_control_2; /* mode 5 reg 0x162 */
438         u8    phy_control_3; /* mode 5 reg 0x163 */
439 } __attribute__ ((packed));
440
441 struct asd_manuf_phy_param {
442         char  sig[2];             /* 'P', 'M' */
443         u16   next;
444         u8    maj;           /* 0 */
445         u8    min;           /* 2 */
446         u8    num_phy_desc;  /* 8 */
447         u8    phy_desc_size; /* 8 */
448         u8    _r[3];
449         u8    usage_model_id;
450         u32   _r2;
451         struct asd_manuf_phy_desc phy_desc[ASD_MAX_PHYS];
452 } __attribute__ ((packed));
453
454 #if 0
455 static const char *asd_sb_type[] = {
456         "unknown",
457         "SGPIO",
458         [2 ... 0x7F] = "unknown",
459         [0x80] = "ADPT_I2C",
460         [0x81 ... 0xFF] = "VENDOR_UNIQUExx"
461 };
462 #endif
463
464 struct asd_ms_sb_desc {
465         u8    type;
466         u8    node_desc_index;
467         u8    conn_desc_index;
468         u8    _recvd[0];
469 } __attribute__ ((packed));
470
471 #if 0
472 static const char *asd_conn_type[] = {
473         [0 ... 7] = "unknown",
474         "SFF8470",
475         "SFF8482",
476         "SFF8484",
477         [0x80] = "PCIX_DAUGHTER0",
478         [0x81] = "SAS_DAUGHTER0",
479         [0x82 ... 0xFF] = "VENDOR_UNIQUExx"
480 };
481
482 static const char *asd_conn_location[] = {
483         "unknown",
484         "internal",
485         "external",
486         "board_to_board",
487 };
488 #endif
489
490 struct asd_ms_conn_desc {
491         u8    type;
492         u8    location;
493         u8    num_sideband_desc;
494         u8    size_sideband_desc;
495         u32   _resvd;
496         u8    name[16];
497         struct asd_ms_sb_desc sb_desc[0];
498 } __attribute__ ((packed));
499
500 struct asd_nd_phy_desc {
501         u8    vp_attch_type;
502         u8    attch_specific[0];
503 } __attribute__ ((packed));
504
505 #if 0
506 static const char *asd_node_type[] = {
507         "IOP",
508         "IO_CONTROLLER",
509         "EXPANDER",
510         "PORT_MULTIPLIER",
511         "PORT_MULTIPLEXER",
512         "MULTI_DROP_I2C_BUS",
513 };
514 #endif
515
516 struct asd_ms_node_desc {
517         u8    type;
518         u8    num_phy_desc;
519         u8    size_phy_desc;
520         u8    _resvd;
521         u8    name[16];
522         struct asd_nd_phy_desc phy_desc[0];
523 } __attribute__ ((packed));
524
525 struct asd_ms_conn_map {
526         char  sig[2];             /* 'M', 'C' */
527         __le16 next;
528         u8    maj;                /* 0 */
529         u8    min;                /* 0 */
530         __le16 cm_size;           /* size of this struct */
531         u8    num_conn;
532         u8    conn_size;
533         u8    num_nodes;
534         u8    usage_model_id;
535         u32   _resvd;
536         struct asd_ms_conn_desc conn_desc[0];
537         struct asd_ms_node_desc node_desc[0];
538 } __attribute__ ((packed));
539
540 struct asd_ctrla_phy_entry {
541         u8    sas_addr[SAS_ADDR_SIZE];
542         u8    sas_link_rates;  /* max in hi bits, min in low bits */
543         u8    flags;
544         u8    sata_link_rates;
545         u8    _r[5];
546 } __attribute__ ((packed));
547
548 struct asd_ctrla_phy_settings {
549         u8    id0;                /* P'h'y */
550         u8    _r;
551         u16   next;
552         u8    num_phys;       /* number of PHYs in the PCI function */
553         u8    _r2[3];
554         struct asd_ctrla_phy_entry phy_ent[ASD_MAX_PHYS];
555 } __attribute__ ((packed));
556
557 struct asd_ll_el {
558         u8   id0;
559         u8   id1;
560         __le16  next;
561         u8   something_here[0];
562 } __attribute__ ((packed));
563
564 static int asd_poll_flash(struct asd_ha_struct *asd_ha)
565 {
566         int c;
567         u8 d;
568
569         for (c = 5000; c > 0; c--) {
570                 d  = asd_read_reg_byte(asd_ha, asd_ha->hw_prof.flash.bar);
571                 d ^= asd_read_reg_byte(asd_ha, asd_ha->hw_prof.flash.bar);
572                 if (!d)
573                         return 0;
574                 udelay(5);
575         }
576         return -ENOENT;
577 }
578
579 static int asd_reset_flash(struct asd_ha_struct *asd_ha)
580 {
581         int err;
582
583         err = asd_poll_flash(asd_ha);
584         if (err)
585                 return err;
586         asd_write_reg_byte(asd_ha, asd_ha->hw_prof.flash.bar, FLASH_RESET);
587         err = asd_poll_flash(asd_ha);
588
589         return err;
590 }
591
592 static inline int asd_read_flash_seg(struct asd_ha_struct *asd_ha,
593                                      void *buffer, u32 offs, int size)
594 {
595         asd_read_reg_string(asd_ha, buffer, asd_ha->hw_prof.flash.bar+offs,
596                             size);
597         return 0;
598 }
599
600 /**
601  * asd_find_flash_dir - finds and reads the flash directory
602  * @asd_ha: pointer to the host adapter structure
603  * @flash_dir: pointer to flash directory structure
604  *
605  * If found, the flash directory segment will be copied to
606  * @flash_dir.  Return 1 if found, 0 if not.
607  */
608 static int asd_find_flash_dir(struct asd_ha_struct *asd_ha,
609                               struct asd_flash_dir *flash_dir)
610 {
611         u32 v;
612         for (v = 0; v < FLASH_SIZE; v += FLASH_NEXT_ENTRY_OFFS) {
613                 asd_read_flash_seg(asd_ha, flash_dir, v,
614                                    sizeof(FLASH_DIR_COOKIE)-1);
615                 if (memcmp(flash_dir->cookie, FLASH_DIR_COOKIE,
616                            sizeof(FLASH_DIR_COOKIE)-1) == 0) {
617                         asd_ha->hw_prof.flash.dir_offs = v;
618                         asd_read_flash_seg(asd_ha, flash_dir, v,
619                                            sizeof(*flash_dir));
620                         return 1;
621                 }
622         }
623         return 0;
624 }
625
626 static int asd_flash_getid(struct asd_ha_struct *asd_ha)
627 {
628         int err = 0;
629         u32 reg;
630
631         reg = asd_read_reg_dword(asd_ha, EXSICNFGR);
632
633         if (pci_read_config_dword(asd_ha->pcidev, PCI_CONF_FLSH_BAR,
634                                   &asd_ha->hw_prof.flash.bar)) {
635                 asd_printk("couldn't read PCI_CONF_FLSH_BAR of %s\n",
636                            pci_name(asd_ha->pcidev));
637                 return -ENOENT;
638         }
639         asd_ha->hw_prof.flash.present = 1;
640         asd_ha->hw_prof.flash.wide = reg & FLASHW ? 1 : 0;
641         err = asd_reset_flash(asd_ha);
642         if (err) {
643                 ASD_DPRINTK("couldn't reset flash(%d)\n", err);
644                 return err;
645         }
646         return 0;
647 }
648
649 static u16 asd_calc_flash_chksum(u16 *p, int size)
650 {
651         u16 chksum = 0;
652
653         while (size-- > 0)
654                 chksum += *p++;
655
656         return chksum;
657 }
658
659
660 static int asd_find_flash_de(struct asd_flash_dir *flash_dir, u32 entry_type,
661                              u32 *offs, u32 *size)
662 {
663         int i;
664         struct asd_flash_de *de;
665
666         for (i = 0; i < FLASH_MAX_DIR_ENTRIES; i++) {
667                 u32 type = le32_to_cpu(flash_dir->dir_entry[i].type);
668
669                 type &= FLASH_DE_TYPE_MASK;
670                 if (type == entry_type)
671                         break;
672         }
673         if (i >= FLASH_MAX_DIR_ENTRIES)
674                 return -ENOENT;
675         de = &flash_dir->dir_entry[i];
676         *offs = le32_to_cpu(de->offs);
677         *size = le32_to_cpu(de->pad_size);
678         return 0;
679 }
680
681 static int asd_validate_ms(struct asd_manuf_sec *ms)
682 {
683         if (ms->sig[0] != 'S' || ms->sig[1] != 'M') {
684                 ASD_DPRINTK("manuf sec: no valid sig(%c%c)\n",
685                             ms->sig[0], ms->sig[1]);
686                 return -ENOENT;
687         }
688         if (ms->maj != 0) {
689                 asd_printk("unsupported manuf. sector. major version:%x\n",
690                            ms->maj);
691                 return -ENOENT;
692         }
693         ms->offs_next = le16_to_cpu((__force __le16) ms->offs_next);
694         ms->chksum = le16_to_cpu((__force __le16) ms->chksum);
695         ms->size = le16_to_cpu((__force __le16) ms->size);
696
697         if (asd_calc_flash_chksum((u16 *)ms, ms->size/2)) {
698                 asd_printk("failed manuf sector checksum\n");
699         }
700
701         return 0;
702 }
703
704 static int asd_ms_get_sas_addr(struct asd_ha_struct *asd_ha,
705                                struct asd_manuf_sec *ms)
706 {
707         memcpy(asd_ha->hw_prof.sas_addr, ms->sas_addr, SAS_ADDR_SIZE);
708         return 0;
709 }
710
711 static int asd_ms_get_pcba_sn(struct asd_ha_struct *asd_ha,
712                               struct asd_manuf_sec *ms)
713 {
714         memcpy(asd_ha->hw_prof.pcba_sn, ms->pcba_sn, ASD_PCBA_SN_SIZE);
715         asd_ha->hw_prof.pcba_sn[ASD_PCBA_SN_SIZE] = '\0';
716         return 0;
717 }
718
719 /**
720  * asd_find_ll_by_id - find a linked list entry by its id
721  * @start: void pointer to the first element in the linked list
722  * @id0: the first byte of the id  (offs 0)
723  * @id1: the second byte of the id (offs 1)
724  *
725  * @start has to be the _base_ element start, since the
726  * linked list entries's offset is from this pointer.
727  * Some linked list entries use only the first id, in which case
728  * you can pass 0xFF for the second.
729  */
730 static void *asd_find_ll_by_id(void * const start, const u8 id0, const u8 id1)
731 {
732         struct asd_ll_el *el = start;
733
734         do {
735                 switch (id1) {
736                 default:
737                         if (el->id1 == id1)
738                 case 0xFF:
739                                 if (el->id0 == id0)
740                                         return el;
741                 }
742                 el = start + le16_to_cpu(el->next);
743         } while (el != start);
744
745         return NULL;
746 }
747
748 /**
749  * asd_ms_get_phy_params - get phy parameters from the manufacturing sector
750  * @asd_ha: pointer to the host adapter structure
751  * @manuf_sec: pointer to the manufacturing sector
752  *
753  * The manufacturing sector contans also the linked list of sub-segments,
754  * since when it was read, its size was taken from the flash directory,
755  * not from the structure size.
756  *
757  * HIDDEN phys do not count in the total count.  REPORTED phys cannot
758  * be enabled but are reported and counted towards the total.
759  * ENEBLEABLE phys are enabled by default and count towards the total.
760  * The absolute total phy number is ASD_MAX_PHYS.  hw_prof->num_phys
761  * merely specifies the number of phys the host adapter decided to
762  * report.  E.g., it is possible for phys 0, 1 and 2 to be HIDDEN,
763  * phys 3, 4 and 5 to be REPORTED and phys 6 and 7 to be ENEBLEABLE.
764  * In this case ASD_MAX_PHYS is 8, hw_prof->num_phys is 5, and only 2
765  * are actually enabled (enabled by default, max number of phys
766  * enableable in this case).
767  */
768 static int asd_ms_get_phy_params(struct asd_ha_struct *asd_ha,
769                                  struct asd_manuf_sec *manuf_sec)
770 {
771         int i;
772         int en_phys = 0;
773         int rep_phys = 0;
774         struct asd_manuf_phy_param *phy_param;
775         struct asd_manuf_phy_param dflt_phy_param;
776
777         phy_param = asd_find_ll_by_id(manuf_sec, 'P', 'M');
778         if (!phy_param) {
779                 ASD_DPRINTK("ms: no phy parameters found\n");
780                 ASD_DPRINTK("ms: Creating default phy parameters\n");
781                 dflt_phy_param.sig[0] = 'P';
782                 dflt_phy_param.sig[1] = 'M';
783                 dflt_phy_param.maj = 0;
784                 dflt_phy_param.min = 2;
785                 dflt_phy_param.num_phy_desc = 8;
786                 dflt_phy_param.phy_desc_size = sizeof(struct asd_manuf_phy_desc);
787                 for (i =0; i < ASD_MAX_PHYS; i++) {
788                         dflt_phy_param.phy_desc[i].state = 0;
789                         dflt_phy_param.phy_desc[i].phy_id = i;
790                         dflt_phy_param.phy_desc[i].phy_control_0 = 0xf6;
791                         dflt_phy_param.phy_desc[i].phy_control_1 = 0x10;
792                         dflt_phy_param.phy_desc[i].phy_control_2 = 0x43;
793                         dflt_phy_param.phy_desc[i].phy_control_3 = 0xeb;
794                 }
795
796                 phy_param = &dflt_phy_param;
797
798         }
799
800         if (phy_param->maj != 0) {
801                 asd_printk("unsupported manuf. phy param major version:0x%x\n",
802                            phy_param->maj);
803                 return -ENOENT;
804         }
805
806         ASD_DPRINTK("ms: num_phy_desc: %d\n", phy_param->num_phy_desc);
807         asd_ha->hw_prof.enabled_phys = 0;
808         for (i = 0; i < phy_param->num_phy_desc; i++) {
809                 struct asd_manuf_phy_desc *pd = &phy_param->phy_desc[i];
810                 switch (pd->state & 0xF) {
811                 case MS_PHY_STATE_HIDDEN:
812                         ASD_DPRINTK("ms: phy%d: HIDDEN\n", i);
813                         continue;
814                 case MS_PHY_STATE_REPORTED:
815                         ASD_DPRINTK("ms: phy%d: REPORTED\n", i);
816                         asd_ha->hw_prof.enabled_phys &= ~(1 << i);
817                         rep_phys++;
818                         continue;
819                 case MS_PHY_STATE_ENABLEABLE:
820                         ASD_DPRINTK("ms: phy%d: ENEBLEABLE\n", i);
821                         asd_ha->hw_prof.enabled_phys |= (1 << i);
822                         en_phys++;
823                         break;
824                 }
825                 asd_ha->hw_prof.phy_desc[i].phy_control_0 = pd->phy_control_0;
826                 asd_ha->hw_prof.phy_desc[i].phy_control_1 = pd->phy_control_1;
827                 asd_ha->hw_prof.phy_desc[i].phy_control_2 = pd->phy_control_2;
828                 asd_ha->hw_prof.phy_desc[i].phy_control_3 = pd->phy_control_3;
829         }
830         asd_ha->hw_prof.max_phys = rep_phys + en_phys;
831         asd_ha->hw_prof.num_phys = en_phys;
832         ASD_DPRINTK("ms: max_phys:0x%x, num_phys:0x%x\n",
833                     asd_ha->hw_prof.max_phys, asd_ha->hw_prof.num_phys);
834         ASD_DPRINTK("ms: enabled_phys:0x%x\n", asd_ha->hw_prof.enabled_phys);
835         return 0;
836 }
837
838 static int asd_ms_get_connector_map(struct asd_ha_struct *asd_ha,
839                                     struct asd_manuf_sec *manuf_sec)
840 {
841         struct asd_ms_conn_map *cm;
842
843         cm = asd_find_ll_by_id(manuf_sec, 'M', 'C');
844         if (!cm) {
845                 ASD_DPRINTK("ms: no connector map found\n");
846                 return 0;
847         }
848
849         if (cm->maj != 0) {
850                 ASD_DPRINTK("ms: unsupported: connector map major version 0x%x"
851                             "\n", cm->maj);
852                 return -ENOENT;
853         }
854
855         /* XXX */
856
857         return 0;
858 }
859
860
861 /**
862  * asd_process_ms - find and extract information from the manufacturing sector
863  * @asd_ha: pointer to the host adapter structure
864  * @flash_dir: pointer to the flash directory
865  */
866 static int asd_process_ms(struct asd_ha_struct *asd_ha,
867                           struct asd_flash_dir *flash_dir)
868 {
869         int err;
870         struct asd_manuf_sec *manuf_sec;
871         u32 offs, size;
872
873         err = asd_find_flash_de(flash_dir, FLASH_DE_MS, &offs, &size);
874         if (err) {
875                 ASD_DPRINTK("Couldn't find the manuf. sector\n");
876                 goto out;
877         }
878
879         if (size == 0)
880                 goto out;
881
882         err = -ENOMEM;
883         manuf_sec = kmalloc(size, GFP_KERNEL);
884         if (!manuf_sec) {
885                 ASD_DPRINTK("no mem for manuf sector\n");
886                 goto out;
887         }
888
889         err = asd_read_flash_seg(asd_ha, (void *)manuf_sec, offs, size);
890         if (err) {
891                 ASD_DPRINTK("couldn't read manuf sector at 0x%x, size 0x%x\n",
892                             offs, size);
893                 goto out2;
894         }
895
896         err = asd_validate_ms(manuf_sec);
897         if (err) {
898                 ASD_DPRINTK("couldn't validate manuf sector\n");
899                 goto out2;
900         }
901
902         err = asd_ms_get_sas_addr(asd_ha, manuf_sec);
903         if (err) {
904                 ASD_DPRINTK("couldn't read the SAS_ADDR\n");
905                 goto out2;
906         }
907         ASD_DPRINTK("manuf sect SAS_ADDR %llx\n",
908                     SAS_ADDR(asd_ha->hw_prof.sas_addr));
909
910         err = asd_ms_get_pcba_sn(asd_ha, manuf_sec);
911         if (err) {
912                 ASD_DPRINTK("couldn't read the PCBA SN\n");
913                 goto out2;
914         }
915         ASD_DPRINTK("manuf sect PCBA SN %s\n", asd_ha->hw_prof.pcba_sn);
916
917         err = asd_ms_get_phy_params(asd_ha, manuf_sec);
918         if (err) {
919                 ASD_DPRINTK("ms: couldn't get phy parameters\n");
920                 goto out2;
921         }
922
923         err = asd_ms_get_connector_map(asd_ha, manuf_sec);
924         if (err) {
925                 ASD_DPRINTK("ms: couldn't get connector map\n");
926                 goto out2;
927         }
928
929 out2:
930         kfree(manuf_sec);
931 out:
932         return err;
933 }
934
935 static int asd_process_ctrla_phy_settings(struct asd_ha_struct *asd_ha,
936                                           struct asd_ctrla_phy_settings *ps)
937 {
938         int i;
939         for (i = 0; i < ps->num_phys; i++) {
940                 struct asd_ctrla_phy_entry *pe = &ps->phy_ent[i];
941
942                 if (!PHY_ENABLED(asd_ha, i))
943                         continue;
944                 if (*(u64 *)pe->sas_addr == 0) {
945                         asd_ha->hw_prof.enabled_phys &= ~(1 << i);
946                         continue;
947                 }
948                 /* This is the SAS address which should be sent in IDENTIFY. */
949                 memcpy(asd_ha->hw_prof.phy_desc[i].sas_addr, pe->sas_addr,
950                        SAS_ADDR_SIZE);
951                 asd_ha->hw_prof.phy_desc[i].max_sas_lrate =
952                         (pe->sas_link_rates & 0xF0) >> 4;
953                 asd_ha->hw_prof.phy_desc[i].min_sas_lrate =
954                         (pe->sas_link_rates & 0x0F);
955                 asd_ha->hw_prof.phy_desc[i].max_sata_lrate =
956                         (pe->sata_link_rates & 0xF0) >> 4;
957                 asd_ha->hw_prof.phy_desc[i].min_sata_lrate =
958                         (pe->sata_link_rates & 0x0F);
959                 asd_ha->hw_prof.phy_desc[i].flags = pe->flags;
960                 ASD_DPRINTK("ctrla: phy%d: sas_addr: %llx, sas rate:0x%x-0x%x,"
961                             " sata rate:0x%x-0x%x, flags:0x%x\n",
962                             i,
963                             SAS_ADDR(asd_ha->hw_prof.phy_desc[i].sas_addr),
964                             asd_ha->hw_prof.phy_desc[i].max_sas_lrate,
965                             asd_ha->hw_prof.phy_desc[i].min_sas_lrate,
966                             asd_ha->hw_prof.phy_desc[i].max_sata_lrate,
967                             asd_ha->hw_prof.phy_desc[i].min_sata_lrate,
968                             asd_ha->hw_prof.phy_desc[i].flags);
969         }
970
971         return 0;
972 }
973
974 /**
975  * asd_process_ctrl_a_user - process CTRL-A user settings
976  * @asd_ha: pointer to the host adapter structure
977  * @flash_dir: pointer to the flash directory
978  */
979 static int asd_process_ctrl_a_user(struct asd_ha_struct *asd_ha,
980                                    struct asd_flash_dir *flash_dir)
981 {
982         int err, i;
983         u32 offs, size;
984         struct asd_ll_el *el;
985         struct asd_ctrla_phy_settings *ps;
986         struct asd_ctrla_phy_settings dflt_ps;
987
988         err = asd_find_flash_de(flash_dir, FLASH_DE_CTRL_A_USER, &offs, &size);
989         if (err) {
990                 ASD_DPRINTK("couldn't find CTRL-A user settings section\n");
991                 ASD_DPRINTK("Creating default CTRL-A user settings section\n");
992
993                 dflt_ps.id0 = 'h';
994                 dflt_ps.num_phys = 8;
995                 for (i =0; i < ASD_MAX_PHYS; i++) {
996                         memcpy(dflt_ps.phy_ent[i].sas_addr,
997                                asd_ha->hw_prof.sas_addr, SAS_ADDR_SIZE);
998                         dflt_ps.phy_ent[i].sas_link_rates = 0x98;
999                         dflt_ps.phy_ent[i].flags = 0x0;
1000                         dflt_ps.phy_ent[i].sata_link_rates = 0x0;
1001                 }
1002
1003                 size = sizeof(struct asd_ctrla_phy_settings);
1004                 ps = &dflt_ps;
1005         }
1006
1007         if (size == 0)
1008                 goto out;
1009
1010         err = -ENOMEM;
1011         el = kmalloc(size, GFP_KERNEL);
1012         if (!el) {
1013                 ASD_DPRINTK("no mem for ctrla user settings section\n");
1014                 goto out;
1015         }
1016
1017         err = asd_read_flash_seg(asd_ha, (void *)el, offs, size);
1018         if (err) {
1019                 ASD_DPRINTK("couldn't read ctrla phy settings section\n");
1020                 goto out2;
1021         }
1022
1023         err = -ENOENT;
1024         ps = asd_find_ll_by_id(el, 'h', 0xFF);
1025         if (!ps) {
1026                 ASD_DPRINTK("couldn't find ctrla phy settings struct\n");
1027                 goto out2;
1028         }
1029
1030         err = asd_process_ctrla_phy_settings(asd_ha, ps);
1031         if (err) {
1032                 ASD_DPRINTK("couldn't process ctrla phy settings\n");
1033                 goto out2;
1034         }
1035 out2:
1036         kfree(el);
1037 out:
1038         return err;
1039 }
1040
1041 /**
1042  * asd_read_flash - read flash memory
1043  * @asd_ha: pointer to the host adapter structure
1044  */
1045 int asd_read_flash(struct asd_ha_struct *asd_ha)
1046 {
1047         int err;
1048         struct asd_flash_dir *flash_dir;
1049
1050         err = asd_flash_getid(asd_ha);
1051         if (err)
1052                 return err;
1053
1054         flash_dir = kmalloc(sizeof(*flash_dir), GFP_KERNEL);
1055         if (!flash_dir)
1056                 return -ENOMEM;
1057
1058         err = -ENOENT;
1059         if (!asd_find_flash_dir(asd_ha, flash_dir)) {
1060                 ASD_DPRINTK("couldn't find flash directory\n");
1061                 goto out;
1062         }
1063
1064         if (le32_to_cpu(flash_dir->rev) != 2) {
1065                 asd_printk("unsupported flash dir version:0x%x\n",
1066                            le32_to_cpu(flash_dir->rev));
1067                 goto out;
1068         }
1069
1070         err = asd_process_ms(asd_ha, flash_dir);
1071         if (err) {
1072                 ASD_DPRINTK("couldn't process manuf sector settings\n");
1073                 goto out;
1074         }
1075
1076         err = asd_process_ctrl_a_user(asd_ha, flash_dir);
1077         if (err) {
1078                 ASD_DPRINTK("couldn't process CTRL-A user settings\n");
1079                 goto out;
1080         }
1081
1082 out:
1083         kfree(flash_dir);
1084         return err;
1085 }