/drivers/scsi/qla2xxx/qla_nx.c

http://github.com/mirrors/linux · C · 4531 lines · 3642 code · 547 blank · 342 comment · 553 complexity · 8078b80f2ba2d20db6e51aba3912ce64 MD5 · raw file

Large files are truncated click here to view the full file

  1. /*
  2. * QLogic Fibre Channel HBA Driver
  3. * Copyright (c) 2003-2014 QLogic Corporation
  4. *
  5. * See LICENSE.qla2xxx for copyright and licensing details.
  6. */
  7. #include "qla_def.h"
  8. #include <linux/delay.h>
  9. #include <linux/io-64-nonatomic-lo-hi.h>
  10. #include <linux/pci.h>
  11. #include <linux/ratelimit.h>
  12. #include <linux/vmalloc.h>
  13. #include <scsi/scsi_tcq.h>
  14. #define MASK(n) ((1ULL<<(n))-1)
  15. #define MN_WIN(addr) (((addr & 0x1fc0000) >> 1) | \
  16. ((addr >> 25) & 0x3ff))
  17. #define OCM_WIN(addr) (((addr & 0x1ff0000) >> 1) | \
  18. ((addr >> 25) & 0x3ff))
  19. #define MS_WIN(addr) (addr & 0x0ffc0000)
  20. #define QLA82XX_PCI_MN_2M (0)
  21. #define QLA82XX_PCI_MS_2M (0x80000)
  22. #define QLA82XX_PCI_OCM0_2M (0xc0000)
  23. #define VALID_OCM_ADDR(addr) (((addr) & 0x3f800) != 0x3f800)
  24. #define GET_MEM_OFFS_2M(addr) (addr & MASK(18))
  25. #define BLOCK_PROTECT_BITS 0x0F
  26. /* CRB window related */
  27. #define CRB_BLK(off) ((off >> 20) & 0x3f)
  28. #define CRB_SUBBLK(off) ((off >> 16) & 0xf)
  29. #define CRB_WINDOW_2M (0x130060)
  30. #define QLA82XX_PCI_CAMQM_2M_END (0x04800800UL)
  31. #define CRB_HI(off) ((qla82xx_crb_hub_agt[CRB_BLK(off)] << 20) | \
  32. ((off) & 0xf0000))
  33. #define QLA82XX_PCI_CAMQM_2M_BASE (0x000ff800UL)
  34. #define CRB_INDIRECT_2M (0x1e0000UL)
  35. #define MAX_CRB_XFORM 60
  36. static unsigned long crb_addr_xform[MAX_CRB_XFORM];
  37. static int qla82xx_crb_table_initialized;
  38. #define qla82xx_crb_addr_transform(name) \
  39. (crb_addr_xform[QLA82XX_HW_PX_MAP_CRB_##name] = \
  40. QLA82XX_HW_CRB_HUB_AGT_ADR_##name << 20)
  41. const int MD_MIU_TEST_AGT_RDDATA[] = {
  42. 0x410000A8, 0x410000AC,
  43. 0x410000B8, 0x410000BC
  44. };
  45. static void qla82xx_crb_addr_transform_setup(void)
  46. {
  47. qla82xx_crb_addr_transform(XDMA);
  48. qla82xx_crb_addr_transform(TIMR);
  49. qla82xx_crb_addr_transform(SRE);
  50. qla82xx_crb_addr_transform(SQN3);
  51. qla82xx_crb_addr_transform(SQN2);
  52. qla82xx_crb_addr_transform(SQN1);
  53. qla82xx_crb_addr_transform(SQN0);
  54. qla82xx_crb_addr_transform(SQS3);
  55. qla82xx_crb_addr_transform(SQS2);
  56. qla82xx_crb_addr_transform(SQS1);
  57. qla82xx_crb_addr_transform(SQS0);
  58. qla82xx_crb_addr_transform(RPMX7);
  59. qla82xx_crb_addr_transform(RPMX6);
  60. qla82xx_crb_addr_transform(RPMX5);
  61. qla82xx_crb_addr_transform(RPMX4);
  62. qla82xx_crb_addr_transform(RPMX3);
  63. qla82xx_crb_addr_transform(RPMX2);
  64. qla82xx_crb_addr_transform(RPMX1);
  65. qla82xx_crb_addr_transform(RPMX0);
  66. qla82xx_crb_addr_transform(ROMUSB);
  67. qla82xx_crb_addr_transform(SN);
  68. qla82xx_crb_addr_transform(QMN);
  69. qla82xx_crb_addr_transform(QMS);
  70. qla82xx_crb_addr_transform(PGNI);
  71. qla82xx_crb_addr_transform(PGND);
  72. qla82xx_crb_addr_transform(PGN3);
  73. qla82xx_crb_addr_transform(PGN2);
  74. qla82xx_crb_addr_transform(PGN1);
  75. qla82xx_crb_addr_transform(PGN0);
  76. qla82xx_crb_addr_transform(PGSI);
  77. qla82xx_crb_addr_transform(PGSD);
  78. qla82xx_crb_addr_transform(PGS3);
  79. qla82xx_crb_addr_transform(PGS2);
  80. qla82xx_crb_addr_transform(PGS1);
  81. qla82xx_crb_addr_transform(PGS0);
  82. qla82xx_crb_addr_transform(PS);
  83. qla82xx_crb_addr_transform(PH);
  84. qla82xx_crb_addr_transform(NIU);
  85. qla82xx_crb_addr_transform(I2Q);
  86. qla82xx_crb_addr_transform(EG);
  87. qla82xx_crb_addr_transform(MN);
  88. qla82xx_crb_addr_transform(MS);
  89. qla82xx_crb_addr_transform(CAS2);
  90. qla82xx_crb_addr_transform(CAS1);
  91. qla82xx_crb_addr_transform(CAS0);
  92. qla82xx_crb_addr_transform(CAM);
  93. qla82xx_crb_addr_transform(C2C1);
  94. qla82xx_crb_addr_transform(C2C0);
  95. qla82xx_crb_addr_transform(SMB);
  96. qla82xx_crb_addr_transform(OCM0);
  97. /*
  98. * Used only in P3 just define it for P2 also.
  99. */
  100. qla82xx_crb_addr_transform(I2C0);
  101. qla82xx_crb_table_initialized = 1;
  102. }
  103. static struct crb_128M_2M_block_map crb_128M_2M_map[64] = {
  104. {{{0, 0, 0, 0} } },
  105. {{{1, 0x0100000, 0x0102000, 0x120000},
  106. {1, 0x0110000, 0x0120000, 0x130000},
  107. {1, 0x0120000, 0x0122000, 0x124000},
  108. {1, 0x0130000, 0x0132000, 0x126000},
  109. {1, 0x0140000, 0x0142000, 0x128000},
  110. {1, 0x0150000, 0x0152000, 0x12a000},
  111. {1, 0x0160000, 0x0170000, 0x110000},
  112. {1, 0x0170000, 0x0172000, 0x12e000},
  113. {0, 0x0000000, 0x0000000, 0x000000},
  114. {0, 0x0000000, 0x0000000, 0x000000},
  115. {0, 0x0000000, 0x0000000, 0x000000},
  116. {0, 0x0000000, 0x0000000, 0x000000},
  117. {0, 0x0000000, 0x0000000, 0x000000},
  118. {0, 0x0000000, 0x0000000, 0x000000},
  119. {1, 0x01e0000, 0x01e0800, 0x122000},
  120. {0, 0x0000000, 0x0000000, 0x000000} } } ,
  121. {{{1, 0x0200000, 0x0210000, 0x180000} } },
  122. {{{0, 0, 0, 0} } },
  123. {{{1, 0x0400000, 0x0401000, 0x169000} } },
  124. {{{1, 0x0500000, 0x0510000, 0x140000} } },
  125. {{{1, 0x0600000, 0x0610000, 0x1c0000} } },
  126. {{{1, 0x0700000, 0x0704000, 0x1b8000} } },
  127. {{{1, 0x0800000, 0x0802000, 0x170000},
  128. {0, 0x0000000, 0x0000000, 0x000000},
  129. {0, 0x0000000, 0x0000000, 0x000000},
  130. {0, 0x0000000, 0x0000000, 0x000000},
  131. {0, 0x0000000, 0x0000000, 0x000000},
  132. {0, 0x0000000, 0x0000000, 0x000000},
  133. {0, 0x0000000, 0x0000000, 0x000000},
  134. {0, 0x0000000, 0x0000000, 0x000000},
  135. {0, 0x0000000, 0x0000000, 0x000000},
  136. {0, 0x0000000, 0x0000000, 0x000000},
  137. {0, 0x0000000, 0x0000000, 0x000000},
  138. {0, 0x0000000, 0x0000000, 0x000000},
  139. {0, 0x0000000, 0x0000000, 0x000000},
  140. {0, 0x0000000, 0x0000000, 0x000000},
  141. {0, 0x0000000, 0x0000000, 0x000000},
  142. {1, 0x08f0000, 0x08f2000, 0x172000} } },
  143. {{{1, 0x0900000, 0x0902000, 0x174000},
  144. {0, 0x0000000, 0x0000000, 0x000000},
  145. {0, 0x0000000, 0x0000000, 0x000000},
  146. {0, 0x0000000, 0x0000000, 0x000000},
  147. {0, 0x0000000, 0x0000000, 0x000000},
  148. {0, 0x0000000, 0x0000000, 0x000000},
  149. {0, 0x0000000, 0x0000000, 0x000000},
  150. {0, 0x0000000, 0x0000000, 0x000000},
  151. {0, 0x0000000, 0x0000000, 0x000000},
  152. {0, 0x0000000, 0x0000000, 0x000000},
  153. {0, 0x0000000, 0x0000000, 0x000000},
  154. {0, 0x0000000, 0x0000000, 0x000000},
  155. {0, 0x0000000, 0x0000000, 0x000000},
  156. {0, 0x0000000, 0x0000000, 0x000000},
  157. {0, 0x0000000, 0x0000000, 0x000000},
  158. {1, 0x09f0000, 0x09f2000, 0x176000} } },
  159. {{{0, 0x0a00000, 0x0a02000, 0x178000},
  160. {0, 0x0000000, 0x0000000, 0x000000},
  161. {0, 0x0000000, 0x0000000, 0x000000},
  162. {0, 0x0000000, 0x0000000, 0x000000},
  163. {0, 0x0000000, 0x0000000, 0x000000},
  164. {0, 0x0000000, 0x0000000, 0x000000},
  165. {0, 0x0000000, 0x0000000, 0x000000},
  166. {0, 0x0000000, 0x0000000, 0x000000},
  167. {0, 0x0000000, 0x0000000, 0x000000},
  168. {0, 0x0000000, 0x0000000, 0x000000},
  169. {0, 0x0000000, 0x0000000, 0x000000},
  170. {0, 0x0000000, 0x0000000, 0x000000},
  171. {0, 0x0000000, 0x0000000, 0x000000},
  172. {0, 0x0000000, 0x0000000, 0x000000},
  173. {0, 0x0000000, 0x0000000, 0x000000},
  174. {1, 0x0af0000, 0x0af2000, 0x17a000} } },
  175. {{{0, 0x0b00000, 0x0b02000, 0x17c000},
  176. {0, 0x0000000, 0x0000000, 0x000000},
  177. {0, 0x0000000, 0x0000000, 0x000000},
  178. {0, 0x0000000, 0x0000000, 0x000000},
  179. {0, 0x0000000, 0x0000000, 0x000000},
  180. {0, 0x0000000, 0x0000000, 0x000000},
  181. {0, 0x0000000, 0x0000000, 0x000000},
  182. {0, 0x0000000, 0x0000000, 0x000000},
  183. {0, 0x0000000, 0x0000000, 0x000000},
  184. {0, 0x0000000, 0x0000000, 0x000000},
  185. {0, 0x0000000, 0x0000000, 0x000000},
  186. {0, 0x0000000, 0x0000000, 0x000000},
  187. {0, 0x0000000, 0x0000000, 0x000000},
  188. {0, 0x0000000, 0x0000000, 0x000000},
  189. {0, 0x0000000, 0x0000000, 0x000000},
  190. {1, 0x0bf0000, 0x0bf2000, 0x17e000} } },
  191. {{{1, 0x0c00000, 0x0c04000, 0x1d4000} } },
  192. {{{1, 0x0d00000, 0x0d04000, 0x1a4000} } },
  193. {{{1, 0x0e00000, 0x0e04000, 0x1a0000} } },
  194. {{{1, 0x0f00000, 0x0f01000, 0x164000} } },
  195. {{{0, 0x1000000, 0x1004000, 0x1a8000} } },
  196. {{{1, 0x1100000, 0x1101000, 0x160000} } },
  197. {{{1, 0x1200000, 0x1201000, 0x161000} } },
  198. {{{1, 0x1300000, 0x1301000, 0x162000} } },
  199. {{{1, 0x1400000, 0x1401000, 0x163000} } },
  200. {{{1, 0x1500000, 0x1501000, 0x165000} } },
  201. {{{1, 0x1600000, 0x1601000, 0x166000} } },
  202. {{{0, 0, 0, 0} } },
  203. {{{0, 0, 0, 0} } },
  204. {{{0, 0, 0, 0} } },
  205. {{{0, 0, 0, 0} } },
  206. {{{0, 0, 0, 0} } },
  207. {{{0, 0, 0, 0} } },
  208. {{{1, 0x1d00000, 0x1d10000, 0x190000} } },
  209. {{{1, 0x1e00000, 0x1e01000, 0x16a000} } },
  210. {{{1, 0x1f00000, 0x1f10000, 0x150000} } },
  211. {{{0} } },
  212. {{{1, 0x2100000, 0x2102000, 0x120000},
  213. {1, 0x2110000, 0x2120000, 0x130000},
  214. {1, 0x2120000, 0x2122000, 0x124000},
  215. {1, 0x2130000, 0x2132000, 0x126000},
  216. {1, 0x2140000, 0x2142000, 0x128000},
  217. {1, 0x2150000, 0x2152000, 0x12a000},
  218. {1, 0x2160000, 0x2170000, 0x110000},
  219. {1, 0x2170000, 0x2172000, 0x12e000},
  220. {0, 0x0000000, 0x0000000, 0x000000},
  221. {0, 0x0000000, 0x0000000, 0x000000},
  222. {0, 0x0000000, 0x0000000, 0x000000},
  223. {0, 0x0000000, 0x0000000, 0x000000},
  224. {0, 0x0000000, 0x0000000, 0x000000},
  225. {0, 0x0000000, 0x0000000, 0x000000},
  226. {0, 0x0000000, 0x0000000, 0x000000},
  227. {0, 0x0000000, 0x0000000, 0x000000} } },
  228. {{{1, 0x2200000, 0x2204000, 0x1b0000} } },
  229. {{{0} } },
  230. {{{0} } },
  231. {{{0} } },
  232. {{{0} } },
  233. {{{0} } },
  234. {{{1, 0x2800000, 0x2804000, 0x1a4000} } },
  235. {{{1, 0x2900000, 0x2901000, 0x16b000} } },
  236. {{{1, 0x2a00000, 0x2a00400, 0x1ac400} } },
  237. {{{1, 0x2b00000, 0x2b00400, 0x1ac800} } },
  238. {{{1, 0x2c00000, 0x2c00400, 0x1acc00} } },
  239. {{{1, 0x2d00000, 0x2d00400, 0x1ad000} } },
  240. {{{1, 0x2e00000, 0x2e00400, 0x1ad400} } },
  241. {{{1, 0x2f00000, 0x2f00400, 0x1ad800} } },
  242. {{{1, 0x3000000, 0x3000400, 0x1adc00} } },
  243. {{{0, 0x3100000, 0x3104000, 0x1a8000} } },
  244. {{{1, 0x3200000, 0x3204000, 0x1d4000} } },
  245. {{{1, 0x3300000, 0x3304000, 0x1a0000} } },
  246. {{{0} } },
  247. {{{1, 0x3500000, 0x3500400, 0x1ac000} } },
  248. {{{1, 0x3600000, 0x3600400, 0x1ae000} } },
  249. {{{1, 0x3700000, 0x3700400, 0x1ae400} } },
  250. {{{1, 0x3800000, 0x3804000, 0x1d0000} } },
  251. {{{1, 0x3900000, 0x3904000, 0x1b4000} } },
  252. {{{1, 0x3a00000, 0x3a04000, 0x1d8000} } },
  253. {{{0} } },
  254. {{{0} } },
  255. {{{1, 0x3d00000, 0x3d04000, 0x1dc000} } },
  256. {{{1, 0x3e00000, 0x3e01000, 0x167000} } },
  257. {{{1, 0x3f00000, 0x3f01000, 0x168000} } }
  258. };
  259. /*
  260. * top 12 bits of crb internal address (hub, agent)
  261. */
  262. static unsigned qla82xx_crb_hub_agt[64] = {
  263. 0,
  264. QLA82XX_HW_CRB_HUB_AGT_ADR_PS,
  265. QLA82XX_HW_CRB_HUB_AGT_ADR_MN,
  266. QLA82XX_HW_CRB_HUB_AGT_ADR_MS,
  267. 0,
  268. QLA82XX_HW_CRB_HUB_AGT_ADR_SRE,
  269. QLA82XX_HW_CRB_HUB_AGT_ADR_NIU,
  270. QLA82XX_HW_CRB_HUB_AGT_ADR_QMN,
  271. QLA82XX_HW_CRB_HUB_AGT_ADR_SQN0,
  272. QLA82XX_HW_CRB_HUB_AGT_ADR_SQN1,
  273. QLA82XX_HW_CRB_HUB_AGT_ADR_SQN2,
  274. QLA82XX_HW_CRB_HUB_AGT_ADR_SQN3,
  275. QLA82XX_HW_CRB_HUB_AGT_ADR_I2Q,
  276. QLA82XX_HW_CRB_HUB_AGT_ADR_TIMR,
  277. QLA82XX_HW_CRB_HUB_AGT_ADR_ROMUSB,
  278. QLA82XX_HW_CRB_HUB_AGT_ADR_PGN4,
  279. QLA82XX_HW_CRB_HUB_AGT_ADR_XDMA,
  280. QLA82XX_HW_CRB_HUB_AGT_ADR_PGN0,
  281. QLA82XX_HW_CRB_HUB_AGT_ADR_PGN1,
  282. QLA82XX_HW_CRB_HUB_AGT_ADR_PGN2,
  283. QLA82XX_HW_CRB_HUB_AGT_ADR_PGN3,
  284. QLA82XX_HW_CRB_HUB_AGT_ADR_PGND,
  285. QLA82XX_HW_CRB_HUB_AGT_ADR_PGNI,
  286. QLA82XX_HW_CRB_HUB_AGT_ADR_PGS0,
  287. QLA82XX_HW_CRB_HUB_AGT_ADR_PGS1,
  288. QLA82XX_HW_CRB_HUB_AGT_ADR_PGS2,
  289. QLA82XX_HW_CRB_HUB_AGT_ADR_PGS3,
  290. 0,
  291. QLA82XX_HW_CRB_HUB_AGT_ADR_PGSI,
  292. QLA82XX_HW_CRB_HUB_AGT_ADR_SN,
  293. 0,
  294. QLA82XX_HW_CRB_HUB_AGT_ADR_EG,
  295. 0,
  296. QLA82XX_HW_CRB_HUB_AGT_ADR_PS,
  297. QLA82XX_HW_CRB_HUB_AGT_ADR_CAM,
  298. 0,
  299. 0,
  300. 0,
  301. 0,
  302. 0,
  303. QLA82XX_HW_CRB_HUB_AGT_ADR_TIMR,
  304. 0,
  305. QLA82XX_HW_CRB_HUB_AGT_ADR_RPMX1,
  306. QLA82XX_HW_CRB_HUB_AGT_ADR_RPMX2,
  307. QLA82XX_HW_CRB_HUB_AGT_ADR_RPMX3,
  308. QLA82XX_HW_CRB_HUB_AGT_ADR_RPMX4,
  309. QLA82XX_HW_CRB_HUB_AGT_ADR_RPMX5,
  310. QLA82XX_HW_CRB_HUB_AGT_ADR_RPMX6,
  311. QLA82XX_HW_CRB_HUB_AGT_ADR_RPMX7,
  312. QLA82XX_HW_CRB_HUB_AGT_ADR_XDMA,
  313. QLA82XX_HW_CRB_HUB_AGT_ADR_I2Q,
  314. QLA82XX_HW_CRB_HUB_AGT_ADR_ROMUSB,
  315. 0,
  316. QLA82XX_HW_CRB_HUB_AGT_ADR_RPMX0,
  317. QLA82XX_HW_CRB_HUB_AGT_ADR_RPMX8,
  318. QLA82XX_HW_CRB_HUB_AGT_ADR_RPMX9,
  319. QLA82XX_HW_CRB_HUB_AGT_ADR_OCM0,
  320. 0,
  321. QLA82XX_HW_CRB_HUB_AGT_ADR_SMB,
  322. QLA82XX_HW_CRB_HUB_AGT_ADR_I2C0,
  323. QLA82XX_HW_CRB_HUB_AGT_ADR_I2C1,
  324. 0,
  325. QLA82XX_HW_CRB_HUB_AGT_ADR_PGNC,
  326. 0,
  327. };
  328. /* Device states */
  329. static char *q_dev_state[] = {
  330. "Unknown",
  331. "Cold",
  332. "Initializing",
  333. "Ready",
  334. "Need Reset",
  335. "Need Quiescent",
  336. "Failed",
  337. "Quiescent",
  338. };
  339. char *qdev_state(uint32_t dev_state)
  340. {
  341. return q_dev_state[dev_state];
  342. }
  343. /*
  344. * In: 'off_in' is offset from CRB space in 128M pci map
  345. * Out: 'off_out' is 2M pci map addr
  346. * side effect: lock crb window
  347. */
  348. static void
  349. qla82xx_pci_set_crbwindow_2M(struct qla_hw_data *ha, ulong off_in,
  350. void __iomem **off_out)
  351. {
  352. u32 win_read;
  353. scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
  354. ha->crb_win = CRB_HI(off_in);
  355. writel(ha->crb_win, CRB_WINDOW_2M + ha->nx_pcibase);
  356. /* Read back value to make sure write has gone through before trying
  357. * to use it.
  358. */
  359. win_read = RD_REG_DWORD(CRB_WINDOW_2M + ha->nx_pcibase);
  360. if (win_read != ha->crb_win) {
  361. ql_dbg(ql_dbg_p3p, vha, 0xb000,
  362. "%s: Written crbwin (0x%x) "
  363. "!= Read crbwin (0x%x), off=0x%lx.\n",
  364. __func__, ha->crb_win, win_read, off_in);
  365. }
  366. *off_out = (off_in & MASK(16)) + CRB_INDIRECT_2M + ha->nx_pcibase;
  367. }
  368. static inline unsigned long
  369. qla82xx_pci_set_crbwindow(struct qla_hw_data *ha, u64 off)
  370. {
  371. scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
  372. /* See if we are currently pointing to the region we want to use next */
  373. if ((off >= QLA82XX_CRB_PCIX_HOST) && (off < QLA82XX_CRB_DDR_NET)) {
  374. /* No need to change window. PCIX and PCIEregs are in both
  375. * regs are in both windows.
  376. */
  377. return off;
  378. }
  379. if ((off >= QLA82XX_CRB_PCIX_HOST) && (off < QLA82XX_CRB_PCIX_HOST2)) {
  380. /* We are in first CRB window */
  381. if (ha->curr_window != 0)
  382. WARN_ON(1);
  383. return off;
  384. }
  385. if ((off > QLA82XX_CRB_PCIX_HOST2) && (off < QLA82XX_CRB_MAX)) {
  386. /* We are in second CRB window */
  387. off = off - QLA82XX_CRB_PCIX_HOST2 + QLA82XX_CRB_PCIX_HOST;
  388. if (ha->curr_window != 1)
  389. return off;
  390. /* We are in the QM or direct access
  391. * register region - do nothing
  392. */
  393. if ((off >= QLA82XX_PCI_DIRECT_CRB) &&
  394. (off < QLA82XX_PCI_CAMQM_MAX))
  395. return off;
  396. }
  397. /* strange address given */
  398. ql_dbg(ql_dbg_p3p, vha, 0xb001,
  399. "%s: Warning: unm_nic_pci_set_crbwindow "
  400. "called with an unknown address(%llx).\n",
  401. QLA2XXX_DRIVER_NAME, off);
  402. return off;
  403. }
  404. static int
  405. qla82xx_pci_get_crb_addr_2M(struct qla_hw_data *ha, ulong off_in,
  406. void __iomem **off_out)
  407. {
  408. struct crb_128M_2M_sub_block_map *m;
  409. if (off_in >= QLA82XX_CRB_MAX)
  410. return -1;
  411. if (off_in >= QLA82XX_PCI_CAMQM && off_in < QLA82XX_PCI_CAMQM_2M_END) {
  412. *off_out = (off_in - QLA82XX_PCI_CAMQM) +
  413. QLA82XX_PCI_CAMQM_2M_BASE + ha->nx_pcibase;
  414. return 0;
  415. }
  416. if (off_in < QLA82XX_PCI_CRBSPACE)
  417. return -1;
  418. off_in -= QLA82XX_PCI_CRBSPACE;
  419. /* Try direct map */
  420. m = &crb_128M_2M_map[CRB_BLK(off_in)].sub_block[CRB_SUBBLK(off_in)];
  421. if (m->valid && (m->start_128M <= off_in) && (m->end_128M > off_in)) {
  422. *off_out = off_in + m->start_2M - m->start_128M + ha->nx_pcibase;
  423. return 0;
  424. }
  425. /* Not in direct map, use crb window */
  426. *off_out = (void __iomem *)off_in;
  427. return 1;
  428. }
  429. #define CRB_WIN_LOCK_TIMEOUT 100000000
  430. static int qla82xx_crb_win_lock(struct qla_hw_data *ha)
  431. {
  432. int done = 0, timeout = 0;
  433. while (!done) {
  434. /* acquire semaphore3 from PCI HW block */
  435. done = qla82xx_rd_32(ha, QLA82XX_PCIE_REG(PCIE_SEM7_LOCK));
  436. if (done == 1)
  437. break;
  438. if (timeout >= CRB_WIN_LOCK_TIMEOUT)
  439. return -1;
  440. timeout++;
  441. }
  442. qla82xx_wr_32(ha, QLA82XX_CRB_WIN_LOCK_ID, ha->portnum);
  443. return 0;
  444. }
  445. int
  446. qla82xx_wr_32(struct qla_hw_data *ha, ulong off_in, u32 data)
  447. {
  448. void __iomem *off;
  449. unsigned long flags = 0;
  450. int rv;
  451. rv = qla82xx_pci_get_crb_addr_2M(ha, off_in, &off);
  452. BUG_ON(rv == -1);
  453. if (rv == 1) {
  454. #ifndef __CHECKER__
  455. write_lock_irqsave(&ha->hw_lock, flags);
  456. #endif
  457. qla82xx_crb_win_lock(ha);
  458. qla82xx_pci_set_crbwindow_2M(ha, off_in, &off);
  459. }
  460. writel(data, (void __iomem *)off);
  461. if (rv == 1) {
  462. qla82xx_rd_32(ha, QLA82XX_PCIE_REG(PCIE_SEM7_UNLOCK));
  463. #ifndef __CHECKER__
  464. write_unlock_irqrestore(&ha->hw_lock, flags);
  465. #endif
  466. }
  467. return 0;
  468. }
  469. int
  470. qla82xx_rd_32(struct qla_hw_data *ha, ulong off_in)
  471. {
  472. void __iomem *off;
  473. unsigned long flags = 0;
  474. int rv;
  475. u32 data;
  476. rv = qla82xx_pci_get_crb_addr_2M(ha, off_in, &off);
  477. BUG_ON(rv == -1);
  478. if (rv == 1) {
  479. #ifndef __CHECKER__
  480. write_lock_irqsave(&ha->hw_lock, flags);
  481. #endif
  482. qla82xx_crb_win_lock(ha);
  483. qla82xx_pci_set_crbwindow_2M(ha, off_in, &off);
  484. }
  485. data = RD_REG_DWORD(off);
  486. if (rv == 1) {
  487. qla82xx_rd_32(ha, QLA82XX_PCIE_REG(PCIE_SEM7_UNLOCK));
  488. #ifndef __CHECKER__
  489. write_unlock_irqrestore(&ha->hw_lock, flags);
  490. #endif
  491. }
  492. return data;
  493. }
  494. #define IDC_LOCK_TIMEOUT 100000000
  495. int qla82xx_idc_lock(struct qla_hw_data *ha)
  496. {
  497. int i;
  498. int done = 0, timeout = 0;
  499. while (!done) {
  500. /* acquire semaphore5 from PCI HW block */
  501. done = qla82xx_rd_32(ha, QLA82XX_PCIE_REG(PCIE_SEM5_LOCK));
  502. if (done == 1)
  503. break;
  504. if (timeout >= IDC_LOCK_TIMEOUT)
  505. return -1;
  506. timeout++;
  507. /* Yield CPU */
  508. if (!in_interrupt())
  509. schedule();
  510. else {
  511. for (i = 0; i < 20; i++)
  512. cpu_relax();
  513. }
  514. }
  515. return 0;
  516. }
  517. void qla82xx_idc_unlock(struct qla_hw_data *ha)
  518. {
  519. qla82xx_rd_32(ha, QLA82XX_PCIE_REG(PCIE_SEM5_UNLOCK));
  520. }
  521. /*
  522. * check memory access boundary.
  523. * used by test agent. support ddr access only for now
  524. */
  525. static unsigned long
  526. qla82xx_pci_mem_bound_check(struct qla_hw_data *ha,
  527. unsigned long long addr, int size)
  528. {
  529. if (!addr_in_range(addr, QLA82XX_ADDR_DDR_NET,
  530. QLA82XX_ADDR_DDR_NET_MAX) ||
  531. !addr_in_range(addr + size - 1, QLA82XX_ADDR_DDR_NET,
  532. QLA82XX_ADDR_DDR_NET_MAX) ||
  533. ((size != 1) && (size != 2) && (size != 4) && (size != 8)))
  534. return 0;
  535. else
  536. return 1;
  537. }
  538. static int qla82xx_pci_set_window_warning_count;
  539. static unsigned long
  540. qla82xx_pci_set_window(struct qla_hw_data *ha, unsigned long long addr)
  541. {
  542. int window;
  543. u32 win_read;
  544. scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
  545. if (addr_in_range(addr, QLA82XX_ADDR_DDR_NET,
  546. QLA82XX_ADDR_DDR_NET_MAX)) {
  547. /* DDR network side */
  548. window = MN_WIN(addr);
  549. ha->ddr_mn_window = window;
  550. qla82xx_wr_32(ha,
  551. ha->mn_win_crb | QLA82XX_PCI_CRBSPACE, window);
  552. win_read = qla82xx_rd_32(ha,
  553. ha->mn_win_crb | QLA82XX_PCI_CRBSPACE);
  554. if ((win_read << 17) != window) {
  555. ql_dbg(ql_dbg_p3p, vha, 0xb003,
  556. "%s: Written MNwin (0x%x) != Read MNwin (0x%x).\n",
  557. __func__, window, win_read);
  558. }
  559. addr = GET_MEM_OFFS_2M(addr) + QLA82XX_PCI_DDR_NET;
  560. } else if (addr_in_range(addr, QLA82XX_ADDR_OCM0,
  561. QLA82XX_ADDR_OCM0_MAX)) {
  562. unsigned int temp1;
  563. if ((addr & 0x00ff800) == 0xff800) {
  564. ql_log(ql_log_warn, vha, 0xb004,
  565. "%s: QM access not handled.\n", __func__);
  566. addr = -1UL;
  567. }
  568. window = OCM_WIN(addr);
  569. ha->ddr_mn_window = window;
  570. qla82xx_wr_32(ha,
  571. ha->mn_win_crb | QLA82XX_PCI_CRBSPACE, window);
  572. win_read = qla82xx_rd_32(ha,
  573. ha->mn_win_crb | QLA82XX_PCI_CRBSPACE);
  574. temp1 = ((window & 0x1FF) << 7) |
  575. ((window & 0x0FFFE0000) >> 17);
  576. if (win_read != temp1) {
  577. ql_log(ql_log_warn, vha, 0xb005,
  578. "%s: Written OCMwin (0x%x) != Read OCMwin (0x%x).\n",
  579. __func__, temp1, win_read);
  580. }
  581. addr = GET_MEM_OFFS_2M(addr) + QLA82XX_PCI_OCM0_2M;
  582. } else if (addr_in_range(addr, QLA82XX_ADDR_QDR_NET,
  583. QLA82XX_P3_ADDR_QDR_NET_MAX)) {
  584. /* QDR network side */
  585. window = MS_WIN(addr);
  586. ha->qdr_sn_window = window;
  587. qla82xx_wr_32(ha,
  588. ha->ms_win_crb | QLA82XX_PCI_CRBSPACE, window);
  589. win_read = qla82xx_rd_32(ha,
  590. ha->ms_win_crb | QLA82XX_PCI_CRBSPACE);
  591. if (win_read != window) {
  592. ql_log(ql_log_warn, vha, 0xb006,
  593. "%s: Written MSwin (0x%x) != Read MSwin (0x%x).\n",
  594. __func__, window, win_read);
  595. }
  596. addr = GET_MEM_OFFS_2M(addr) + QLA82XX_PCI_QDR_NET;
  597. } else {
  598. /*
  599. * peg gdb frequently accesses memory that doesn't exist,
  600. * this limits the chit chat so debugging isn't slowed down.
  601. */
  602. if ((qla82xx_pci_set_window_warning_count++ < 8) ||
  603. (qla82xx_pci_set_window_warning_count%64 == 0)) {
  604. ql_log(ql_log_warn, vha, 0xb007,
  605. "%s: Warning:%s Unknown address range!.\n",
  606. __func__, QLA2XXX_DRIVER_NAME);
  607. }
  608. addr = -1UL;
  609. }
  610. return addr;
  611. }
  612. /* check if address is in the same windows as the previous access */
  613. static int qla82xx_pci_is_same_window(struct qla_hw_data *ha,
  614. unsigned long long addr)
  615. {
  616. int window;
  617. unsigned long long qdr_max;
  618. qdr_max = QLA82XX_P3_ADDR_QDR_NET_MAX;
  619. /* DDR network side */
  620. if (addr_in_range(addr, QLA82XX_ADDR_DDR_NET,
  621. QLA82XX_ADDR_DDR_NET_MAX))
  622. BUG();
  623. else if (addr_in_range(addr, QLA82XX_ADDR_OCM0,
  624. QLA82XX_ADDR_OCM0_MAX))
  625. return 1;
  626. else if (addr_in_range(addr, QLA82XX_ADDR_OCM1,
  627. QLA82XX_ADDR_OCM1_MAX))
  628. return 1;
  629. else if (addr_in_range(addr, QLA82XX_ADDR_QDR_NET, qdr_max)) {
  630. /* QDR network side */
  631. window = ((addr - QLA82XX_ADDR_QDR_NET) >> 22) & 0x3f;
  632. if (ha->qdr_sn_window == window)
  633. return 1;
  634. }
  635. return 0;
  636. }
  637. static int qla82xx_pci_mem_read_direct(struct qla_hw_data *ha,
  638. u64 off, void *data, int size)
  639. {
  640. unsigned long flags;
  641. void __iomem *addr = NULL;
  642. int ret = 0;
  643. u64 start;
  644. uint8_t __iomem *mem_ptr = NULL;
  645. unsigned long mem_base;
  646. unsigned long mem_page;
  647. scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
  648. write_lock_irqsave(&ha->hw_lock, flags);
  649. /*
  650. * If attempting to access unknown address or straddle hw windows,
  651. * do not access.
  652. */
  653. start = qla82xx_pci_set_window(ha, off);
  654. if ((start == -1UL) ||
  655. (qla82xx_pci_is_same_window(ha, off + size - 1) == 0)) {
  656. write_unlock_irqrestore(&ha->hw_lock, flags);
  657. ql_log(ql_log_fatal, vha, 0xb008,
  658. "%s out of bound pci memory "
  659. "access, offset is 0x%llx.\n",
  660. QLA2XXX_DRIVER_NAME, off);
  661. return -1;
  662. }
  663. write_unlock_irqrestore(&ha->hw_lock, flags);
  664. mem_base = pci_resource_start(ha->pdev, 0);
  665. mem_page = start & PAGE_MASK;
  666. /* Map two pages whenever user tries to access addresses in two
  667. * consecutive pages.
  668. */
  669. if (mem_page != ((start + size - 1) & PAGE_MASK))
  670. mem_ptr = ioremap(mem_base + mem_page, PAGE_SIZE * 2);
  671. else
  672. mem_ptr = ioremap(mem_base + mem_page, PAGE_SIZE);
  673. if (mem_ptr == NULL) {
  674. *(u8 *)data = 0;
  675. return -1;
  676. }
  677. addr = mem_ptr;
  678. addr += start & (PAGE_SIZE - 1);
  679. write_lock_irqsave(&ha->hw_lock, flags);
  680. switch (size) {
  681. case 1:
  682. *(u8 *)data = readb(addr);
  683. break;
  684. case 2:
  685. *(u16 *)data = readw(addr);
  686. break;
  687. case 4:
  688. *(u32 *)data = readl(addr);
  689. break;
  690. case 8:
  691. *(u64 *)data = readq(addr);
  692. break;
  693. default:
  694. ret = -1;
  695. break;
  696. }
  697. write_unlock_irqrestore(&ha->hw_lock, flags);
  698. if (mem_ptr)
  699. iounmap(mem_ptr);
  700. return ret;
  701. }
  702. static int
  703. qla82xx_pci_mem_write_direct(struct qla_hw_data *ha,
  704. u64 off, void *data, int size)
  705. {
  706. unsigned long flags;
  707. void __iomem *addr = NULL;
  708. int ret = 0;
  709. u64 start;
  710. uint8_t __iomem *mem_ptr = NULL;
  711. unsigned long mem_base;
  712. unsigned long mem_page;
  713. scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
  714. write_lock_irqsave(&ha->hw_lock, flags);
  715. /*
  716. * If attempting to access unknown address or straddle hw windows,
  717. * do not access.
  718. */
  719. start = qla82xx_pci_set_window(ha, off);
  720. if ((start == -1UL) ||
  721. (qla82xx_pci_is_same_window(ha, off + size - 1) == 0)) {
  722. write_unlock_irqrestore(&ha->hw_lock, flags);
  723. ql_log(ql_log_fatal, vha, 0xb009,
  724. "%s out of bound memory "
  725. "access, offset is 0x%llx.\n",
  726. QLA2XXX_DRIVER_NAME, off);
  727. return -1;
  728. }
  729. write_unlock_irqrestore(&ha->hw_lock, flags);
  730. mem_base = pci_resource_start(ha->pdev, 0);
  731. mem_page = start & PAGE_MASK;
  732. /* Map two pages whenever user tries to access addresses in two
  733. * consecutive pages.
  734. */
  735. if (mem_page != ((start + size - 1) & PAGE_MASK))
  736. mem_ptr = ioremap(mem_base + mem_page, PAGE_SIZE*2);
  737. else
  738. mem_ptr = ioremap(mem_base + mem_page, PAGE_SIZE);
  739. if (mem_ptr == NULL)
  740. return -1;
  741. addr = mem_ptr;
  742. addr += start & (PAGE_SIZE - 1);
  743. write_lock_irqsave(&ha->hw_lock, flags);
  744. switch (size) {
  745. case 1:
  746. writeb(*(u8 *)data, addr);
  747. break;
  748. case 2:
  749. writew(*(u16 *)data, addr);
  750. break;
  751. case 4:
  752. writel(*(u32 *)data, addr);
  753. break;
  754. case 8:
  755. writeq(*(u64 *)data, addr);
  756. break;
  757. default:
  758. ret = -1;
  759. break;
  760. }
  761. write_unlock_irqrestore(&ha->hw_lock, flags);
  762. if (mem_ptr)
  763. iounmap(mem_ptr);
  764. return ret;
  765. }
  766. #define MTU_FUDGE_FACTOR 100
  767. static unsigned long
  768. qla82xx_decode_crb_addr(unsigned long addr)
  769. {
  770. int i;
  771. unsigned long base_addr, offset, pci_base;
  772. if (!qla82xx_crb_table_initialized)
  773. qla82xx_crb_addr_transform_setup();
  774. pci_base = ADDR_ERROR;
  775. base_addr = addr & 0xfff00000;
  776. offset = addr & 0x000fffff;
  777. for (i = 0; i < MAX_CRB_XFORM; i++) {
  778. if (crb_addr_xform[i] == base_addr) {
  779. pci_base = i << 20;
  780. break;
  781. }
  782. }
  783. if (pci_base == ADDR_ERROR)
  784. return pci_base;
  785. return pci_base + offset;
  786. }
  787. static long rom_max_timeout = 100;
  788. static long qla82xx_rom_lock_timeout = 100;
  789. static int
  790. qla82xx_rom_lock(struct qla_hw_data *ha)
  791. {
  792. int done = 0, timeout = 0;
  793. uint32_t lock_owner = 0;
  794. scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
  795. while (!done) {
  796. /* acquire semaphore2 from PCI HW block */
  797. done = qla82xx_rd_32(ha, QLA82XX_PCIE_REG(PCIE_SEM2_LOCK));
  798. if (done == 1)
  799. break;
  800. if (timeout >= qla82xx_rom_lock_timeout) {
  801. lock_owner = qla82xx_rd_32(ha, QLA82XX_ROM_LOCK_ID);
  802. ql_dbg(ql_dbg_p3p, vha, 0xb157,
  803. "%s: Simultaneous flash access by following ports, active port = %d: accessing port = %d",
  804. __func__, ha->portnum, lock_owner);
  805. return -1;
  806. }
  807. timeout++;
  808. }
  809. qla82xx_wr_32(ha, QLA82XX_ROM_LOCK_ID, ha->portnum);
  810. return 0;
  811. }
  812. static void
  813. qla82xx_rom_unlock(struct qla_hw_data *ha)
  814. {
  815. qla82xx_wr_32(ha, QLA82XX_ROM_LOCK_ID, 0xffffffff);
  816. qla82xx_rd_32(ha, QLA82XX_PCIE_REG(PCIE_SEM2_UNLOCK));
  817. }
  818. static int
  819. qla82xx_wait_rom_busy(struct qla_hw_data *ha)
  820. {
  821. long timeout = 0;
  822. long done = 0 ;
  823. scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
  824. while (done == 0) {
  825. done = qla82xx_rd_32(ha, QLA82XX_ROMUSB_GLB_STATUS);
  826. done &= 4;
  827. timeout++;
  828. if (timeout >= rom_max_timeout) {
  829. ql_dbg(ql_dbg_p3p, vha, 0xb00a,
  830. "%s: Timeout reached waiting for rom busy.\n",
  831. QLA2XXX_DRIVER_NAME);
  832. return -1;
  833. }
  834. }
  835. return 0;
  836. }
  837. static int
  838. qla82xx_wait_rom_done(struct qla_hw_data *ha)
  839. {
  840. long timeout = 0;
  841. long done = 0 ;
  842. scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
  843. while (done == 0) {
  844. done = qla82xx_rd_32(ha, QLA82XX_ROMUSB_GLB_STATUS);
  845. done &= 2;
  846. timeout++;
  847. if (timeout >= rom_max_timeout) {
  848. ql_dbg(ql_dbg_p3p, vha, 0xb00b,
  849. "%s: Timeout reached waiting for rom done.\n",
  850. QLA2XXX_DRIVER_NAME);
  851. return -1;
  852. }
  853. }
  854. return 0;
  855. }
  856. static int
  857. qla82xx_md_rw_32(struct qla_hw_data *ha, uint32_t off, u32 data, uint8_t flag)
  858. {
  859. uint32_t off_value, rval = 0;
  860. WRT_REG_DWORD(CRB_WINDOW_2M + ha->nx_pcibase, off & 0xFFFF0000);
  861. /* Read back value to make sure write has gone through */
  862. RD_REG_DWORD(CRB_WINDOW_2M + ha->nx_pcibase);
  863. off_value = (off & 0x0000FFFF);
  864. if (flag)
  865. WRT_REG_DWORD(off_value + CRB_INDIRECT_2M + ha->nx_pcibase,
  866. data);
  867. else
  868. rval = RD_REG_DWORD(off_value + CRB_INDIRECT_2M +
  869. ha->nx_pcibase);
  870. return rval;
  871. }
  872. static int
  873. qla82xx_do_rom_fast_read(struct qla_hw_data *ha, int addr, int *valp)
  874. {
  875. /* Dword reads to flash. */
  876. qla82xx_md_rw_32(ha, MD_DIRECT_ROM_WINDOW, (addr & 0xFFFF0000), 1);
  877. *valp = qla82xx_md_rw_32(ha, MD_DIRECT_ROM_READ_BASE +
  878. (addr & 0x0000FFFF), 0, 0);
  879. return 0;
  880. }
  881. static int
  882. qla82xx_rom_fast_read(struct qla_hw_data *ha, int addr, int *valp)
  883. {
  884. int ret, loops = 0;
  885. uint32_t lock_owner = 0;
  886. scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
  887. while ((qla82xx_rom_lock(ha) != 0) && (loops < 50000)) {
  888. udelay(100);
  889. schedule();
  890. loops++;
  891. }
  892. if (loops >= 50000) {
  893. lock_owner = qla82xx_rd_32(ha, QLA82XX_ROM_LOCK_ID);
  894. ql_log(ql_log_fatal, vha, 0x00b9,
  895. "Failed to acquire SEM2 lock, Lock Owner %u.\n",
  896. lock_owner);
  897. return -1;
  898. }
  899. ret = qla82xx_do_rom_fast_read(ha, addr, valp);
  900. qla82xx_rom_unlock(ha);
  901. return ret;
  902. }
  903. static int
  904. qla82xx_read_status_reg(struct qla_hw_data *ha, uint32_t *val)
  905. {
  906. scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
  907. qla82xx_wr_32(ha, QLA82XX_ROMUSB_ROM_INSTR_OPCODE, M25P_INSTR_RDSR);
  908. qla82xx_wait_rom_busy(ha);
  909. if (qla82xx_wait_rom_done(ha)) {
  910. ql_log(ql_log_warn, vha, 0xb00c,
  911. "Error waiting for rom done.\n");
  912. return -1;
  913. }
  914. *val = qla82xx_rd_32(ha, QLA82XX_ROMUSB_ROM_RDATA);
  915. return 0;
  916. }
  917. static int
  918. qla82xx_flash_wait_write_finish(struct qla_hw_data *ha)
  919. {
  920. long timeout = 0;
  921. uint32_t done = 1 ;
  922. uint32_t val;
  923. int ret = 0;
  924. scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
  925. qla82xx_wr_32(ha, QLA82XX_ROMUSB_ROM_ABYTE_CNT, 0);
  926. while ((done != 0) && (ret == 0)) {
  927. ret = qla82xx_read_status_reg(ha, &val);
  928. done = val & 1;
  929. timeout++;
  930. udelay(10);
  931. cond_resched();
  932. if (timeout >= 50000) {
  933. ql_log(ql_log_warn, vha, 0xb00d,
  934. "Timeout reached waiting for write finish.\n");
  935. return -1;
  936. }
  937. }
  938. return ret;
  939. }
  940. static int
  941. qla82xx_flash_set_write_enable(struct qla_hw_data *ha)
  942. {
  943. uint32_t val;
  944. qla82xx_wait_rom_busy(ha);
  945. qla82xx_wr_32(ha, QLA82XX_ROMUSB_ROM_ABYTE_CNT, 0);
  946. qla82xx_wr_32(ha, QLA82XX_ROMUSB_ROM_INSTR_OPCODE, M25P_INSTR_WREN);
  947. qla82xx_wait_rom_busy(ha);
  948. if (qla82xx_wait_rom_done(ha))
  949. return -1;
  950. if (qla82xx_read_status_reg(ha, &val) != 0)
  951. return -1;
  952. if ((val & 2) != 2)
  953. return -1;
  954. return 0;
  955. }
  956. static int
  957. qla82xx_write_status_reg(struct qla_hw_data *ha, uint32_t val)
  958. {
  959. scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
  960. if (qla82xx_flash_set_write_enable(ha))
  961. return -1;
  962. qla82xx_wr_32(ha, QLA82XX_ROMUSB_ROM_WDATA, val);
  963. qla82xx_wr_32(ha, QLA82XX_ROMUSB_ROM_INSTR_OPCODE, 0x1);
  964. if (qla82xx_wait_rom_done(ha)) {
  965. ql_log(ql_log_warn, vha, 0xb00e,
  966. "Error waiting for rom done.\n");
  967. return -1;
  968. }
  969. return qla82xx_flash_wait_write_finish(ha);
  970. }
  971. static int
  972. qla82xx_write_disable_flash(struct qla_hw_data *ha)
  973. {
  974. scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
  975. qla82xx_wr_32(ha, QLA82XX_ROMUSB_ROM_INSTR_OPCODE, M25P_INSTR_WRDI);
  976. if (qla82xx_wait_rom_done(ha)) {
  977. ql_log(ql_log_warn, vha, 0xb00f,
  978. "Error waiting for rom done.\n");
  979. return -1;
  980. }
  981. return 0;
  982. }
  983. static int
  984. ql82xx_rom_lock_d(struct qla_hw_data *ha)
  985. {
  986. int loops = 0;
  987. uint32_t lock_owner = 0;
  988. scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
  989. while ((qla82xx_rom_lock(ha) != 0) && (loops < 50000)) {
  990. udelay(100);
  991. cond_resched();
  992. loops++;
  993. }
  994. if (loops >= 50000) {
  995. lock_owner = qla82xx_rd_32(ha, QLA82XX_ROM_LOCK_ID);
  996. ql_log(ql_log_warn, vha, 0xb010,
  997. "ROM lock failed, Lock Owner %u.\n", lock_owner);
  998. return -1;
  999. }
  1000. return 0;
  1001. }
  1002. static int
  1003. qla82xx_write_flash_dword(struct qla_hw_data *ha, uint32_t flashaddr,
  1004. uint32_t data)
  1005. {
  1006. int ret = 0;
  1007. scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
  1008. ret = ql82xx_rom_lock_d(ha);
  1009. if (ret < 0) {
  1010. ql_log(ql_log_warn, vha, 0xb011,
  1011. "ROM lock failed.\n");
  1012. return ret;
  1013. }
  1014. if (qla82xx_flash_set_write_enable(ha))
  1015. goto done_write;
  1016. qla82xx_wr_32(ha, QLA82XX_ROMUSB_ROM_WDATA, data);
  1017. qla82xx_wr_32(ha, QLA82XX_ROMUSB_ROM_ADDRESS, flashaddr);
  1018. qla82xx_wr_32(ha, QLA82XX_ROMUSB_ROM_ABYTE_CNT, 3);
  1019. qla82xx_wr_32(ha, QLA82XX_ROMUSB_ROM_INSTR_OPCODE, M25P_INSTR_PP);
  1020. qla82xx_wait_rom_busy(ha);
  1021. if (qla82xx_wait_rom_done(ha)) {
  1022. ql_log(ql_log_warn, vha, 0xb012,
  1023. "Error waiting for rom done.\n");
  1024. ret = -1;
  1025. goto done_write;
  1026. }
  1027. ret = qla82xx_flash_wait_write_finish(ha);
  1028. done_write:
  1029. qla82xx_rom_unlock(ha);
  1030. return ret;
  1031. }
  1032. /* This routine does CRB initialize sequence
  1033. * to put the ISP into operational state
  1034. */
  1035. static int
  1036. qla82xx_pinit_from_rom(scsi_qla_host_t *vha)
  1037. {
  1038. int addr, val;
  1039. int i ;
  1040. struct crb_addr_pair *buf;
  1041. unsigned long off;
  1042. unsigned offset, n;
  1043. struct qla_hw_data *ha = vha->hw;
  1044. struct crb_addr_pair {
  1045. long addr;
  1046. long data;
  1047. };
  1048. /* Halt all the individual PEGs and other blocks of the ISP */
  1049. qla82xx_rom_lock(ha);
  1050. /* disable all I2Q */
  1051. qla82xx_wr_32(ha, QLA82XX_CRB_I2Q + 0x10, 0x0);
  1052. qla82xx_wr_32(ha, QLA82XX_CRB_I2Q + 0x14, 0x0);
  1053. qla82xx_wr_32(ha, QLA82XX_CRB_I2Q + 0x18, 0x0);
  1054. qla82xx_wr_32(ha, QLA82XX_CRB_I2Q + 0x1c, 0x0);
  1055. qla82xx_wr_32(ha, QLA82XX_CRB_I2Q + 0x20, 0x0);
  1056. qla82xx_wr_32(ha, QLA82XX_CRB_I2Q + 0x24, 0x0);
  1057. /* disable all niu interrupts */
  1058. qla82xx_wr_32(ha, QLA82XX_CRB_NIU + 0x40, 0xff);
  1059. /* disable xge rx/tx */
  1060. qla82xx_wr_32(ha, QLA82XX_CRB_NIU + 0x70000, 0x00);
  1061. /* disable xg1 rx/tx */
  1062. qla82xx_wr_32(ha, QLA82XX_CRB_NIU + 0x80000, 0x00);
  1063. /* disable sideband mac */
  1064. qla82xx_wr_32(ha, QLA82XX_CRB_NIU + 0x90000, 0x00);
  1065. /* disable ap0 mac */
  1066. qla82xx_wr_32(ha, QLA82XX_CRB_NIU + 0xa0000, 0x00);
  1067. /* disable ap1 mac */
  1068. qla82xx_wr_32(ha, QLA82XX_CRB_NIU + 0xb0000, 0x00);
  1069. /* halt sre */
  1070. val = qla82xx_rd_32(ha, QLA82XX_CRB_SRE + 0x1000);
  1071. qla82xx_wr_32(ha, QLA82XX_CRB_SRE + 0x1000, val & (~(0x1)));
  1072. /* halt epg */
  1073. qla82xx_wr_32(ha, QLA82XX_CRB_EPG + 0x1300, 0x1);
  1074. /* halt timers */
  1075. qla82xx_wr_32(ha, QLA82XX_CRB_TIMER + 0x0, 0x0);
  1076. qla82xx_wr_32(ha, QLA82XX_CRB_TIMER + 0x8, 0x0);
  1077. qla82xx_wr_32(ha, QLA82XX_CRB_TIMER + 0x10, 0x0);
  1078. qla82xx_wr_32(ha, QLA82XX_CRB_TIMER + 0x18, 0x0);
  1079. qla82xx_wr_32(ha, QLA82XX_CRB_TIMER + 0x100, 0x0);
  1080. qla82xx_wr_32(ha, QLA82XX_CRB_TIMER + 0x200, 0x0);
  1081. /* halt pegs */
  1082. qla82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_0 + 0x3c, 1);
  1083. qla82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_1 + 0x3c, 1);
  1084. qla82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_2 + 0x3c, 1);
  1085. qla82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_3 + 0x3c, 1);
  1086. qla82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_4 + 0x3c, 1);
  1087. msleep(20);
  1088. /* big hammer */
  1089. if (test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags))
  1090. /* don't reset CAM block on reset */
  1091. qla82xx_wr_32(ha, QLA82XX_ROMUSB_GLB_SW_RESET, 0xfeffffff);
  1092. else
  1093. qla82xx_wr_32(ha, QLA82XX_ROMUSB_GLB_SW_RESET, 0xffffffff);
  1094. qla82xx_rom_unlock(ha);
  1095. /* Read the signature value from the flash.
  1096. * Offset 0: Contain signature (0xcafecafe)
  1097. * Offset 4: Offset and number of addr/value pairs
  1098. * that present in CRB initialize sequence
  1099. */
  1100. if (qla82xx_rom_fast_read(ha, 0, &n) != 0 || n != 0xcafecafeUL ||
  1101. qla82xx_rom_fast_read(ha, 4, &n) != 0) {
  1102. ql_log(ql_log_fatal, vha, 0x006e,
  1103. "Error Reading crb_init area: n: %08x.\n", n);
  1104. return -1;
  1105. }
  1106. /* Offset in flash = lower 16 bits
  1107. * Number of entries = upper 16 bits
  1108. */
  1109. offset = n & 0xffffU;
  1110. n = (n >> 16) & 0xffffU;
  1111. /* number of addr/value pair should not exceed 1024 entries */
  1112. if (n >= 1024) {
  1113. ql_log(ql_log_fatal, vha, 0x0071,
  1114. "Card flash not initialized:n=0x%x.\n", n);
  1115. return -1;
  1116. }
  1117. ql_log(ql_log_info, vha, 0x0072,
  1118. "%d CRB init values found in ROM.\n", n);
  1119. buf = kmalloc_array(n, sizeof(struct crb_addr_pair), GFP_KERNEL);
  1120. if (buf == NULL) {
  1121. ql_log(ql_log_fatal, vha, 0x010c,
  1122. "Unable to allocate memory.\n");
  1123. return -ENOMEM;
  1124. }
  1125. for (i = 0; i < n; i++) {
  1126. if (qla82xx_rom_fast_read(ha, 8*i + 4*offset, &val) != 0 ||
  1127. qla82xx_rom_fast_read(ha, 8*i + 4*offset + 4, &addr) != 0) {
  1128. kfree(buf);
  1129. return -1;
  1130. }
  1131. buf[i].addr = addr;
  1132. buf[i].data = val;
  1133. }
  1134. for (i = 0; i < n; i++) {
  1135. /* Translate internal CRB initialization
  1136. * address to PCI bus address
  1137. */
  1138. off = qla82xx_decode_crb_addr((unsigned long)buf[i].addr) +
  1139. QLA82XX_PCI_CRBSPACE;
  1140. /* Not all CRB addr/value pair to be written,
  1141. * some of them are skipped
  1142. */
  1143. /* skipping cold reboot MAGIC */
  1144. if (off == QLA82XX_CAM_RAM(0x1fc))
  1145. continue;
  1146. /* do not reset PCI */
  1147. if (off == (ROMUSB_GLB + 0xbc))
  1148. continue;
  1149. /* skip core clock, so that firmware can increase the clock */
  1150. if (off == (ROMUSB_GLB + 0xc8))
  1151. continue;
  1152. /* skip the function enable register */
  1153. if (off == QLA82XX_PCIE_REG(PCIE_SETUP_FUNCTION))
  1154. continue;
  1155. if (off == QLA82XX_PCIE_REG(PCIE_SETUP_FUNCTION2))
  1156. continue;
  1157. if ((off & 0x0ff00000) == QLA82XX_CRB_SMB)
  1158. continue;
  1159. if ((off & 0x0ff00000) == QLA82XX_CRB_DDR_NET)
  1160. continue;
  1161. if (off == ADDR_ERROR) {
  1162. ql_log(ql_log_fatal, vha, 0x0116,
  1163. "Unknown addr: 0x%08lx.\n", buf[i].addr);
  1164. continue;
  1165. }
  1166. qla82xx_wr_32(ha, off, buf[i].data);
  1167. /* ISP requires much bigger delay to settle down,
  1168. * else crb_window returns 0xffffffff
  1169. */
  1170. if (off == QLA82XX_ROMUSB_GLB_SW_RESET)
  1171. msleep(1000);
  1172. /* ISP requires millisec delay between
  1173. * successive CRB register updation
  1174. */
  1175. msleep(1);
  1176. }
  1177. kfree(buf);
  1178. /* Resetting the data and instruction cache */
  1179. qla82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_D+0xec, 0x1e);
  1180. qla82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_D+0x4c, 8);
  1181. qla82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_I+0x4c, 8);
  1182. /* Clear all protocol processing engines */
  1183. qla82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_0+0x8, 0);
  1184. qla82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_0+0xc, 0);
  1185. qla82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_1+0x8, 0);
  1186. qla82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_1+0xc, 0);
  1187. qla82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_2+0x8, 0);
  1188. qla82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_2+0xc, 0);
  1189. qla82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_3+0x8, 0);
  1190. qla82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_3+0xc, 0);
  1191. return 0;
  1192. }
  1193. static int
  1194. qla82xx_pci_mem_write_2M(struct qla_hw_data *ha,
  1195. u64 off, void *data, int size)
  1196. {
  1197. int i, j, ret = 0, loop, sz[2], off0;
  1198. int scale, shift_amount, startword;
  1199. uint32_t temp;
  1200. uint64_t off8, mem_crb, tmpw, word[2] = {0, 0};
  1201. /*
  1202. * If not MN, go check for MS or invalid.
  1203. */
  1204. if (off >= QLA82XX_ADDR_QDR_NET && off <= QLA82XX_P3_ADDR_QDR_NET_MAX)
  1205. mem_crb = QLA82XX_CRB_QDR_NET;
  1206. else {
  1207. mem_crb = QLA82XX_CRB_DDR_NET;
  1208. if (qla82xx_pci_mem_bound_check(ha, off, size) == 0)
  1209. return qla82xx_pci_mem_write_direct(ha,
  1210. off, data, size);
  1211. }
  1212. off0 = off & 0x7;
  1213. sz[0] = (size < (8 - off0)) ? size : (8 - off0);
  1214. sz[1] = size - sz[0];
  1215. off8 = off & 0xfffffff0;
  1216. loop = (((off & 0xf) + size - 1) >> 4) + 1;
  1217. shift_amount = 4;
  1218. scale = 2;
  1219. startword = (off & 0xf)/8;
  1220. for (i = 0; i < loop; i++) {
  1221. if (qla82xx_pci_mem_read_2M(ha, off8 +
  1222. (i << shift_amount), &word[i * scale], 8))
  1223. return -1;
  1224. }
  1225. switch (size) {
  1226. case 1:
  1227. tmpw = *((uint8_t *)data);
  1228. break;
  1229. case 2:
  1230. tmpw = *((uint16_t *)data);
  1231. break;
  1232. case 4:
  1233. tmpw = *((uint32_t *)data);
  1234. break;
  1235. case 8:
  1236. default:
  1237. tmpw = *((uint64_t *)data);
  1238. break;
  1239. }
  1240. if (sz[0] == 8) {
  1241. word[startword] = tmpw;
  1242. } else {
  1243. word[startword] &=
  1244. ~((~(~0ULL << (sz[0] * 8))) << (off0 * 8));
  1245. word[startword] |= tmpw << (off0 * 8);
  1246. }
  1247. if (sz[1] != 0) {
  1248. word[startword+1] &= ~(~0ULL << (sz[1] * 8));
  1249. word[startword+1] |= tmpw >> (sz[0] * 8);
  1250. }
  1251. for (i = 0; i < loop; i++) {
  1252. temp = off8 + (i << shift_amount);
  1253. qla82xx_wr_32(ha, mem_crb+MIU_TEST_AGT_ADDR_LO, temp);
  1254. temp = 0;
  1255. qla82xx_wr_32(ha, mem_crb+MIU_TEST_AGT_ADDR_HI, temp);
  1256. temp = word[i * scale] & 0xffffffff;
  1257. qla82xx_wr_32(ha, mem_crb+MIU_TEST_AGT_WRDATA_LO, temp);
  1258. temp = (word[i * scale] >> 32) & 0xffffffff;
  1259. qla82xx_wr_32(ha, mem_crb+MIU_TEST_AGT_WRDATA_HI, temp);
  1260. temp = word[i*scale + 1] & 0xffffffff;
  1261. qla82xx_wr_32(ha, mem_crb +
  1262. MIU_TEST_AGT_WRDATA_UPPER_LO, temp);
  1263. temp = (word[i*scale + 1] >> 32) & 0xffffffff;
  1264. qla82xx_wr_32(ha, mem_crb +
  1265. MIU_TEST_AGT_WRDATA_UPPER_HI, temp);
  1266. temp = MIU_TA_CTL_ENABLE | MIU_TA_CTL_WRITE;
  1267. qla82xx_wr_32(ha, mem_crb + MIU_TEST_AGT_CTRL, temp);
  1268. temp = MIU_TA_CTL_START | MIU_TA_CTL_ENABLE | MIU_TA_CTL_WRITE;
  1269. qla82xx_wr_32(ha, mem_crb + MIU_TEST_AGT_CTRL, temp);
  1270. for (j = 0; j < MAX_CTL_CHECK; j++) {
  1271. temp = qla82xx_rd_32(ha, mem_crb + MIU_TEST_AGT_CTRL);
  1272. if ((temp & MIU_TA_CTL_BUSY) == 0)
  1273. break;
  1274. }
  1275. if (j >= MAX_CTL_CHECK) {
  1276. if (printk_ratelimit())
  1277. dev_err(&ha->pdev->dev,
  1278. "failed to write through agent.\n");
  1279. ret = -1;
  1280. break;
  1281. }
  1282. }
  1283. return ret;
  1284. }
  1285. static int
  1286. qla82xx_fw_load_from_flash(struct qla_hw_data *ha)
  1287. {
  1288. int i;
  1289. long size = 0;
  1290. long flashaddr = ha->flt_region_bootload << 2;
  1291. long memaddr = BOOTLD_START;
  1292. u64 data;
  1293. u32 high, low;
  1294. size = (IMAGE_START - BOOTLD_START) / 8;
  1295. for (i = 0; i < size; i++) {
  1296. if ((qla82xx_rom_fast_read(ha, flashaddr, (int *)&low)) ||
  1297. (qla82xx_rom_fast_read(ha, flashaddr + 4, (int *)&high))) {
  1298. return -1;
  1299. }
  1300. data = ((u64)high << 32) | low ;
  1301. qla82xx_pci_mem_write_2M(ha, memaddr, &data, 8);
  1302. flashaddr += 8;
  1303. memaddr += 8;
  1304. if (i % 0x1000 == 0)
  1305. msleep(1);
  1306. }
  1307. udelay(100);
  1308. read_lock(&ha->hw_lock);
  1309. qla82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_0 + 0x18, 0x1020);
  1310. qla82xx_wr_32(ha, QLA82XX_ROMUSB_GLB_SW_RESET, 0x80001e);
  1311. read_unlock(&ha->hw_lock);
  1312. return 0;
  1313. }
  1314. int
  1315. qla82xx_pci_mem_read_2M(struct qla_hw_data *ha,
  1316. u64 off, void *data, int size)
  1317. {
  1318. int i, j = 0, k, start, end, loop, sz[2], off0[2];
  1319. int shift_amount;
  1320. uint32_t temp;
  1321. uint64_t off8, val, mem_crb, word[2] = {0, 0};
  1322. /*
  1323. * If not MN, go check for MS or invalid.
  1324. */
  1325. if (off >= QLA82XX_ADDR_QDR_NET && off <= QLA82XX_P3_ADDR_QDR_NET_MAX)
  1326. mem_crb = QLA82XX_CRB_QDR_NET;
  1327. else {
  1328. mem_crb = QLA82XX_CRB_DDR_NET;
  1329. if (qla82xx_pci_mem_bound_check(ha, off, size) == 0)
  1330. return qla82xx_pci_mem_read_direct(ha,
  1331. off, data, size);
  1332. }
  1333. off8 = off & 0xfffffff0;
  1334. off0[0] = off & 0xf;
  1335. sz[0] = (size < (16 - off0[0])) ? size : (16 - off0[0]);
  1336. shift_amount = 4;
  1337. loop = ((off0[0] + size - 1) >> shift_amount) + 1;
  1338. off0[1] = 0;
  1339. sz[1] = size - sz[0];
  1340. for (i = 0; i < loop; i++) {
  1341. temp = off8 + (i << shift_amount);
  1342. qla82xx_wr_32(ha, mem_crb + MIU_TEST_AGT_ADDR_LO, temp);
  1343. temp = 0;
  1344. qla82xx_wr_32(ha, mem_crb + MIU_TEST_AGT_ADDR_HI, temp);
  1345. temp = MIU_TA_CTL_ENABLE;
  1346. qla82xx_wr_32(ha, mem_crb + MIU_TEST_AGT_CTRL, temp);
  1347. temp = MIU_TA_CTL_START | MIU_TA_CTL_ENABLE;
  1348. qla82xx_wr_32(ha, mem_crb + MIU_TEST_AGT_CTRL, temp);
  1349. for (j = 0; j < MAX_CTL_CHECK; j++) {
  1350. temp = qla82xx_rd_32(ha, mem_crb + MIU_TEST_AGT_CTRL);
  1351. if ((temp & MIU_TA_CTL_BUSY) == 0)
  1352. break;
  1353. }
  1354. if (j >= MAX_CTL_CHECK) {
  1355. if (printk_ratelimit())
  1356. dev_err(&ha->pdev->dev,
  1357. "failed to read through agent.\n");
  1358. break;
  1359. }
  1360. start = off0[i] >> 2;
  1361. end = (off0[i] + sz[i] - 1) >> 2;
  1362. for (k = start; k <= end; k++) {
  1363. temp = qla82xx_rd_32(ha,
  1364. mem_crb + MIU_TEST_AGT_RDDATA(k));
  1365. word[i] |= ((uint64_t)temp << (32 * (k & 1)));
  1366. }
  1367. }
  1368. if (j >= MAX_CTL_CHECK)
  1369. return -1;
  1370. if ((off0[0] & 7) == 0) {
  1371. val = word[0];
  1372. } else {
  1373. val = ((word[0] >> (off0[0] * 8)) & (~(~0ULL << (sz[0] * 8)))) |
  1374. ((word[1] & (~(~0ULL << (sz[1] * 8)))) << (sz[0] * 8));
  1375. }
  1376. switch (size) {
  1377. case 1:
  1378. *(uint8_t *)data = val;
  1379. break;
  1380. case 2:
  1381. *(uint16_t *)data = val;
  1382. break;
  1383. case 4:
  1384. *(uint32_t *)data = val;
  1385. break;
  1386. case 8:
  1387. *(uint64_t *)data = val;
  1388. break;
  1389. }
  1390. return 0;
  1391. }
  1392. static struct qla82xx_uri_table_desc *
  1393. qla82xx_get_table_desc(const u8 *unirom, int section)
  1394. {
  1395. uint32_t i;
  1396. struct qla82xx_uri_table_desc *directory =
  1397. (struct qla82xx_uri_table_desc *)&unirom[0];
  1398. __le32 offset;
  1399. __le32 tab_type;
  1400. __le32 entries = cpu_to_le32(directory->num_entries);
  1401. for (i = 0; i < entries; i++) {
  1402. offset = cpu_to_le32(directory->findex) +
  1403. (i * cpu_to_le32(directory->entry_size));
  1404. tab_type = cpu_to_le32(*((u32 *)&unirom[offset] + 8));
  1405. if (tab_type == section)
  1406. return (struct qla82xx_uri_table_desc *)&unirom[offset];
  1407. }
  1408. return NULL;
  1409. }
  1410. static struct qla82xx_uri_data_desc *
  1411. qla82xx_get_data_desc(struct qla_hw_data *ha,
  1412. u32 section, u32 idx_offset)
  1413. {
  1414. const u8 *unirom = ha->hablob->fw->data;
  1415. int idx = cpu_to_le32(*((int *)&unirom[ha->file_prd_off] + idx_offset));
  1416. struct qla82xx_uri_table_desc *tab_desc = NULL;
  1417. __le32 offset;
  1418. tab_desc = qla82xx_get_table_desc(unirom, section);
  1419. if (!tab_desc)
  1420. return NULL;
  1421. offset = cpu_to_le32(tab_desc->findex) +
  1422. (cpu_to_le32(tab_desc->entry_size) * idx);
  1423. return (struct qla82xx_uri_data_desc *)&unirom[offset];
  1424. }
  1425. static u8 *
  1426. qla82xx_get_bootld_offset(struct qla_hw_data *ha)
  1427. {
  1428. u32 offset = BOOTLD_START;
  1429. struct qla82xx_uri_data_desc *uri_desc = NULL;
  1430. if (ha->fw_type == QLA82XX_UNIFIED_ROMIMAGE) {
  1431. uri_desc = qla82xx_get_data_desc(ha,
  1432. QLA82XX_URI_DIR_SECT_BOOTLD, QLA82XX_URI_BOOTLD_IDX_OFF);
  1433. if (uri_desc)
  1434. offset = cpu_to_le32(uri_desc->findex);
  1435. }
  1436. return (u8 *)&ha->hablob->fw->data[offset];
  1437. }
  1438. static u32 qla82xx_get_fw_size(struct qla_hw_data *ha)
  1439. {
  1440. struct qla82xx_uri_data_desc *uri_desc = NULL;
  1441. if (ha->fw_type == QLA82XX_UNIFIED_ROMIMAGE) {
  1442. uri_desc = qla82xx_get_data_desc(ha, QLA82XX_URI_DIR_SECT_FW,
  1443. QLA82XX_URI_FIRMWARE_IDX_OFF);
  1444. if (uri_desc)
  1445. return cpu_to_le32(uri_desc->size);
  1446. }
  1447. return get_unaligned_le32(&ha->hablob->fw->data[FW_SIZE_OFFSET]);
  1448. }
  1449. static u8 *
  1450. qla82xx_get_fw_offs(struct qla_hw_data *ha)
  1451. {
  1452. u32 offset = IMAGE_START;
  1453. struct qla82xx_uri_data_desc *uri_desc = NULL;
  1454. if (ha->fw_type == QLA82XX_UNIFIED_ROMIMAGE) {
  1455. uri_desc = qla82xx_get_data_desc(ha, QLA82XX_URI_DIR_SECT_FW,
  1456. QLA82XX_URI_FIRMWARE_IDX_OFF);
  1457. if (uri_desc)
  1458. offset = cpu_to_le32(uri_desc->findex);
  1459. }
  1460. return (u8 *)&ha->hablob->fw->data[offset];
  1461. }
  1462. /* PCI related functions */
  1463. int qla82xx_pci_region_offset(struct pci_dev *pdev, int region)
  1464. {
  1465. unsigned long val = 0;
  1466. u32 control;
  1467. switch (region) {
  1468. case 0:
  1469. val = 0;
  1470. break;
  1471. case 1:
  1472. pci_read_config_dword(pdev, QLA82XX_PCI_REG_MSIX_TBL, &control);
  1473. val = control + QLA82XX_MSIX_TBL_SPACE;
  1474. break;
  1475. }
  1476. return val;
  1477. }
  1478. int
  1479. qla82xx_iospace_config(struct qla_hw_data *ha)
  1480. {
  1481. uint32_t len = 0;
  1482. if (pci_request_regions(ha->pdev, QLA2XXX_DRIVER_NAME)) {
  1483. ql_log_pci(ql_log_fatal, ha->pdev, 0x000c,
  1484. "Failed to reserver selected regions.\n");
  1485. goto iospace_error_exit;
  1486. }
  1487. /* Use MMIO operations for all accesses. */
  1488. if (!(pci_resource_flags(ha->pdev, 0) & IORESOURCE_MEM)) {
  1489. ql_log_pci(ql_log_fatal, ha->pdev, 0x000d,
  1490. "Region #0 not an MMIO resource, aborting.\n");
  1491. goto iospace_error_exit;
  1492. }
  1493. len = pci_resource_len(ha->pdev, 0);
  1494. ha->nx_pcibase = ioremap(pci_resource_start(ha->pdev, 0), len);
  1495. if (!ha->nx_pcibase) {
  1496. ql_log_pci(ql_log_fatal, ha->pdev, 0x000e,
  1497. "Cannot remap pcibase MMIO, aborting.\n");
  1498. goto iospace_error_exit;
  1499. }
  1500. /* Mapping of IO base pointer */
  1501. if (IS_QLA8044(ha)) {
  1502. ha->iobase = ha->nx_pcibase;
  1503. } else if (IS_QLA82XX(ha)) {
  1504. ha->iobase = ha->nx_pcibase + 0xbc000 + (ha->pdev->devfn << 11);
  1505. }
  1506. if (!ql2xdbwr) {
  1507. ha->nxdb_wr_ptr = ioremap((pci_resource_start(ha->pdev, 4) +
  1508. (ha->pdev->devfn << 12)), 4);
  1509. if (!ha->nxdb_wr_ptr) {
  1510. ql_log_pci(ql_log_fatal, ha->pdev, 0x000f,
  1511. "Cannot remap MMIO, aborting.\n");
  1512. goto iospace_error_exit;
  1513. }
  1514. /* Mapping of IO base pointer,
  1515. * door bell read and write pointer
  1516. */
  1517. ha->nxdb_rd_ptr = ha->nx_pcibase + (512 * 1024) +
  1518. (ha->pdev->devfn * 8);
  1519. } else {
  1520. ha->nxdb_wr_ptr = (void __iomem *)(ha->pdev->devfn == 6 ?
  1521. QLA82XX_CAMRAM_DB1 :
  1522. QLA82XX_CAMRAM_DB2);
  1523. }
  1524. ha->max_req_queues = ha->max_rsp_queues = 1;
  1525. ha->msix_count = ha->max_rsp_queues + 1;
  1526. ql_dbg_pci(ql_dbg_multiq, ha->pdev, 0xc006,
  1527. "nx_pci_base=%p iobase=%p "
  1528. "max_req_queues=%d msix_count=%d.\n",
  1529. ha->nx_pcibase, ha->iobase,
  1530. ha->max_req_queues, ha->msix_count);
  1531. ql_dbg_pci(ql_dbg_init, ha->pdev, 0x0010,
  1532. "nx_pci_base=%p iobase=%p "
  1533. "max_req_queues=%d msix_count=%d.\n",
  1534. ha->nx_pcibase, ha->iobase,
  1535. ha->max_req_queues, ha->msix_count);
  1536. return 0;
  1537. iospace_error_exit:
  1538. return -ENOMEM;
  1539. }
  1540. /* GS related functions */
  1541. /* Initialization related functions */
  1542. /**
  1543. * qla82xx_pci_config() - Setup ISP82xx PCI configuration registers.
  1544. * @vha: HA context
  1545. *
  1546. * Returns 0 on success.
  1547. */
  1548. int
  1549. qla82xx_pci_config(scsi_qla_host_t *vha)
  1550. {
  1551. struct qla_hw_data *ha = vha->hw;
  1552. int ret;
  1553. pci_set_master(ha->pdev);
  1554. ret = pci_set_mwi(ha->pdev);
  1555. ha->chip_revision = ha->pdev->revision;
  1556. ql_dbg(ql_dbg_init, vha, 0x0043,
  1557. "Chip revision:%d; pci_set_mwi() returned %d.\n",
  1558. ha->chip_revision, ret);
  1559. return 0;
  1560. }
  1561. /**
  1562. * qla82xx_reset_chip() - Setup ISP82xx PCI configuration registers.
  1563. * @vha: HA context
  1564. *
  1565. * Returns 0 on success.
  1566. */
  1567. int
  1568. qla82xx_reset_chip(scsi_qla_host_t *vha)
  1569. {
  1570. struct qla_hw_data *ha = vha->hw;
  1571. ha->isp_ops->disable_intrs(ha);
  1572. return QLA_SUCCESS;
  1573. }
  1574. void qla82xx_config_rings(struct scsi_qla_host *vha)
  1575. {
  1576. struct qla_hw_data *ha = vha->hw;
  1577. struct device_reg_82xx __iomem *reg = &ha->iobase->isp82;
  1578. struct init_cb_81xx *icb;
  1579. struct req_que *req = ha->req_q_map[0];
  1580. struct rsp_que *rsp = ha->rsp_q_map[0];
  1581. /* Setup ring parameters in initialization control block. */
  1582. icb = (struct init_cb_81xx *)ha->init_cb;
  1583. icb->request_q_outpointer = cpu_to_le16(0);
  1584. icb->response_q_inpointer = cpu_to_le16(0);
  1585. icb->request_q_length = cpu_to_le16(req->length);
  1586. icb->response_q_length = cpu_to_le16(rsp->length);
  1587. put_unaligned_le64(req->dma, &icb->request_q_address);
  1588. put_unaligned_le64(rsp->dma, &icb->response_q_address);
  1589. WRT_REG_DWORD(&reg->req_q_out[0], 0);
  1590. WRT_REG_DWORD(&reg->rsp_q_in[0], 0);
  1591. WRT_REG_DWORD(&reg->rsp_q_out[0], 0);
  1592. }
  1593. static int
  1594. qla82xx_fw_load_from_blob(struct qla_hw_data *ha)
  1595. {
  1596. u64 *ptr64;
  1597. u32 i, flashaddr, size;
  1598. __le64 data;
  1599. size = (IMAGE_START - BOOTLD_START) / 8;
  1600. ptr64 = (u64 *)qla82xx_get_bootld_offset(ha);
  1601. flashaddr = BOOTLD_START;
  1602. for (i = 0; i < size; i++) {
  1603. data = cpu_to_le64(ptr64[i]);
  1604. if (qla82xx_pci_mem_write_2M(ha, flashaddr, &data, 8))
  1605. return -EIO;
  1606. flashaddr += 8;
  1607. }
  1608. flashaddr = FLASH_ADDR_START;
  1609. size = qla82xx_get_fw_size(ha) / 8;
  1610. ptr64 = (u64 *)qla82xx_get_fw_offs(ha);
  1611. for (i = 0; i < size; i++) {
  1612. data = cpu_to_le64(ptr64[i]);
  1613. if (qla82xx_pci_mem_write_2M(ha, flashaddr, &data, 8))
  1614. return -EIO;
  1615. flashaddr += 8;
  1616. }
  1617. udelay(100);
  1618. /* Write a magic value to CAMRAM register
  1619. * at a specified offset to indicate
  1620. * that all data is written and
  1621. * ready for firmware to initialize.
  1622. */
  1623. qla82xx_wr_32(ha, QLA82XX_CAM_RAM(0x1fc), QLA82XX_BDINFO_MAGIC);
  1624. read_lock(&ha->hw_lock);
  1625. qla82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_0 + 0x18, 0x1020);
  1626. qla82xx_wr_32(ha, QLA82XX_ROMUSB_GLB_SW_RESET, 0x80001e);
  1627. read_unlock(&ha->hw_lock);
  1628. return 0;
  1629. }
  1630. static int
  1631. qla82xx_set_product_offset(struct qla_hw_data *ha)
  1632. {
  1633. struct qla82xx_uri_table_desc *ptab_desc = NULL;
  1634. const uint8_t *unirom = ha->hablob->fw->data;
  1635. uint32_t i;
  1636. __le32 entries;
  1637. __le32 flags, file_chiprev, offset;
  1638. uint8_t chiprev = ha->chip_revision;
  1639. /* Hardcoding mn_present flag for P3P */
  1640. int mn_present = 0;
  1641. uint32_t flagbit;
  1642. ptab_desc = qla82xx_get_table_desc(unirom,
  1643. QLA82XX_URI_DIR_SECT_PRODUCT_TBL);
  1644. if (!ptab_desc)
  1645. return -1;
  1646. entries = cpu_to_le32(ptab_desc->num_entries);
  1647. for (i = 0; i < entries; i++) {
  1648. offset = cpu_to_le32(ptab_desc->findex) +
  1649. (i * cpu_to_le32(ptab_desc->entry_size));
  1650. flags = cpu_to_le32(*((int *)&unirom[offset] +
  1651. QLA82XX_URI_FLAGS_OFF));
  1652. file_chiprev = cpu_to_le32(*((int *)&unirom[offset] +
  1653. QLA82XX_URI_CHIP_REV_OFF));
  1654. flagbit = mn_present ? 1 : 2;
  1655. if ((chiprev == file_chiprev) && ((1ULL << flagbit) & flags)) {
  1656. ha->file_prd_off = offset;
  1657. return 0;
  1658. }
  1659. }
  1660. return -1;
  1661. }
  1662. static int
  1663. qla82xx_validate_firmware_blob(scsi_qla_host_t *vha, uint8_t fw_type)
  1664. {
  1665. uint32_t val;
  1666. uint32_t min_size;
  1667. struct qla_hw_data *ha = vha->hw;
  1668. const struct firmware *fw = ha->hablob->fw;
  1669. ha->fw_