Advertisement
Guest User

hpsa_kernel_compat.h with Debian Lenny Mod

a guest
Jun 29th, 2012
944
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 16.84 KB | None | 0 0
  1. /*
  2. * Disk Array driver for HP Smart Array SAS controllers
  3. * Copyright 2011, Hewlett-Packard Development Company, L.P.
  4. *
  5. * This program is free software; you can redistribute it and/or modify
  6. * it under the terms of the GNU General Public License as published by
  7. * the Free Software Foundation; version 2 of the License.
  8. *
  9. * This program is distributed in the hope that it will be useful,
  10. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
  12. * NON INFRINGEMENT. See the GNU General Public License for more details.
  13. *
  14. * You should have received a copy of the GNU General Public License
  15. * along with this program; if not, write to the Free Software
  16. * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17. *
  18. * Questions/Comments/Bugfixes to iss_storagedev@hp.com
  19. *
  20. */
  21.  
  22. /**DEBIAN_LENNY Section added with help from hp's iss_storagedev team for use on Alienvault OSSIM **/
  23.  
  24. #define DEBIAN_LENNY
  25. /* #define SLES11sp1 */
  26. /* #define SLES11sp2plus */
  27. /* #define RHEL5 */
  28. /* #define RHEL5u2 */
  29. /* #define RHEL6 */
  30. /* Default is kernel.org */
  31.  
  32.  
  33. #ifdef DEBIAN_LENNY /************* DEBIAN_LENNY ********/
  34. #define KFEATURE_HAS_2011_03_INTERRUPT_HANDLER 1
  35. #define KFEATURE_CHANGE_QDEPTH_HAS_REASON 0
  36. #define KFEATURE_HAS_2011_03_STYLE_DEVICE_ATTR 1
  37. #define KFEATURE_HAS_SCSI_QDEPTH_DEFAULT 1
  38. #define KFEATURE_HAS_SCSI_FOR_EACH_SG 1
  39. #define KFEATURE_HAS_SCSI_DEVICE_TYPE 1
  40. #define KFEATURE_SCAN_START_PRESENT 1
  41. #define KFEATURE_SCAN_START_IMPLEMENTED 1
  42. #define KFEATURE_HAS_2011_03_QUEUECOMMAND 0
  43. #define KFEATURE_HAS_SHOST_PRIV 1
  44. #define KFEATURE_HAS_SCSI_DMA_FUNCTIONS 1
  45. #define KFEATURE_HAS_SCSI_SET_RESID 1
  46. #define KFEATURE_HAS_UACCESS_H_FILE 1
  47. #define KFEATURE_HAS_SMP_LOCK_H 1
  48. #define HPSA_SUPPORTS_MSA2XXX 0
  49. #define SA_CONTROLLERS_GEN8 1
  50. #define SA_CONTROLLERS_GEN6 0
  51.  
  52. #else
  53.  
  54. #ifdef RHEL5 /************ RHEL5 *********/
  55. #define KFEATURE_HAS_2011_03_INTERRUPT_HANDLER 0
  56. #define KFEATURE_CHANGE_QDEPTH_HAS_REASON 0
  57. #define KFEATURE_HAS_2011_03_STYLE_DEVICE_ATTR 0
  58. #define KFEATURE_HAS_SCSI_QDEPTH_DEFAULT 0
  59. #define KFEATURE_HAS_SCSI_FOR_EACH_SG 0
  60. #define KFEATURE_HAS_SCSI_DEVICE_TYPE 0
  61. #define KFEATURE_SCAN_START_PRESENT 1
  62. #define KFEATURE_SCAN_START_IMPLEMENTED 0
  63. #define KFEATURE_HAS_2011_03_QUEUECOMMAND 0
  64. #define KFEATURE_HAS_SHOST_PRIV 1
  65. #define KFEATURE_HAS_SCSI_DMA_FUNCTIONS 1
  66. #define KFEATURE_HAS_SCSI_SET_RESID 1
  67. #define KFEATURE_HAS_UACCESS_H_FILE 1
  68. #define KFEATURE_HAS_SMP_LOCK_H 1
  69. #define HPSA_SUPPORTS_MSA2XXX 1
  70. #define SA_CONTROLLERS_GEN8 1
  71. #define SA_CONTROLLERS_GEN6 1
  72.  
  73. #else
  74.  
  75. #ifdef RHEL5u2 /************ RHEL5u2 ************/
  76. #define KFEATURE_HAS_2011_03_INTERRUPT_HANDLER 0
  77. #define KFEATURE_CHANGE_QDEPTH_HAS_REASON 0
  78. #define KFEATURE_HAS_2011_03_STYLE_DEVICE_ATTR 0
  79. #define KFEATURE_HAS_SCSI_QDEPTH_DEFAULT 0
  80. #define KFEATURE_HAS_SCSI_FOR_EACH_SG 0
  81. #define KFEATURE_HAS_SCSI_DEVICE_TYPE 0
  82. #define KFEATURE_SCAN_START_PRESENT 1
  83. #define KFEATURE_SCAN_START_IMPLEMENTED 0
  84. #define KFEATURE_HAS_2011_03_QUEUECOMMAND 0
  85. #define KFEATURE_HAS_SHOST_PRIV 1
  86. #define KFEATURE_HAS_SCSI_DMA_FUNCTIONS 0
  87. #define KFEATURE_HAS_SCSI_SET_RESID 1
  88. #define KFEATURE_HAS_UACCESS_H_FILE 1
  89. #define KFEATURE_HAS_SMP_LOCK_H 1
  90. #define HPSA_SUPPORTS_MSA2XXX 1
  91. #define SA_CONTROLLERS_GEN8 0
  92. #define SA_CONTROLLERS_GEN6 0
  93.  
  94. #else
  95.  
  96. #ifdef RHEL6 /************ RHEL 6 ************/
  97. #define KFEATURE_HAS_2011_03_INTERRUPT_HANDLER 1
  98. #define KFEATURE_CHANGE_QDEPTH_HAS_REASON 1
  99. #define KFEATURE_HAS_2011_03_STYLE_DEVICE_ATTR 1
  100. #define KFEATURE_HAS_SCSI_QDEPTH_DEFAULT 1
  101. #define KFEATURE_HAS_SCSI_FOR_EACH_SG 1
  102. #define KFEATURE_HAS_SCSI_DEVICE_TYPE 1
  103. #define KFEATURE_SCAN_START_PRESENT 1
  104. #define KFEATURE_SCAN_START_IMPLEMENTED 1
  105. #define KFEATURE_HAS_2011_03_QUEUECOMMAND 0
  106. #define KFEATURE_HAS_SHOST_PRIV 1
  107. #define KFEATURE_HAS_SCSI_DMA_FUNCTIONS 1
  108. #define KFEATURE_HAS_SCSI_SET_RESID 1
  109. #define KFEATURE_HAS_UACCESS_H_FILE 1
  110. #define KFEATURE_HAS_SMP_LOCK_H 1
  111. #define HPSA_SUPPORTS_MSA2XXX 0
  112. #define SA_CONTROLLERS_GEN8 1
  113. #define SA_CONTROLLERS_GEN6 1
  114.  
  115. #else
  116.  
  117. #ifdef SLES11sp1 /************* SLES11 sp1 ********/
  118. #define KFEATURE_HAS_2011_03_INTERRUPT_HANDLER 1
  119. #define KFEATURE_CHANGE_QDEPTH_HAS_REASON 0
  120. #define KFEATURE_HAS_2011_03_STYLE_DEVICE_ATTR 1
  121. #define KFEATURE_HAS_SCSI_QDEPTH_DEFAULT 1
  122. #define KFEATURE_HAS_SCSI_FOR_EACH_SG 1
  123. #define KFEATURE_HAS_SCSI_DEVICE_TYPE 1
  124. #define KFEATURE_SCAN_START_PRESENT 1
  125. #define KFEATURE_SCAN_START_IMPLEMENTED 1
  126. #define KFEATURE_HAS_2011_03_QUEUECOMMAND 0
  127. #define KFEATURE_HAS_SHOST_PRIV 1
  128. #define KFEATURE_HAS_SCSI_DMA_FUNCTIONS 1
  129. #define KFEATURE_HAS_SCSI_SET_RESID 1
  130. #define KFEATURE_HAS_UACCESS_H_FILE 1
  131. #define KFEATURE_HAS_SMP_LOCK_H 1
  132. #define HPSA_SUPPORTS_MSA2XXX 0
  133. #define SA_CONTROLLERS_GEN8 1
  134. #define SA_CONTROLLERS_GEN6 0
  135.  
  136. #else
  137. #ifdef SLES11sp2plus /************* SLES11 sp2 and after ********/
  138. #define KFEATURE_HAS_2011_03_INTERRUPT_HANDLER 1
  139. #define KFEATURE_CHANGE_QDEPTH_HAS_REASON 1
  140. #define KFEATURE_HAS_2011_03_STYLE_DEVICE_ATTR 1
  141. #define KFEATURE_HAS_SCSI_QDEPTH_DEFAULT 1
  142. #define KFEATURE_HAS_SCSI_FOR_EACH_SG 1
  143. #define KFEATURE_HAS_SCSI_DEVICE_TYPE 1
  144. #define KFEATURE_SCAN_START_PRESENT 1
  145. #define KFEATURE_SCAN_START_IMPLEMENTED 1
  146. #define KFEATURE_HAS_2011_03_QUEUECOMMAND 1
  147. #define KFEATURE_HAS_SHOST_PRIV 1
  148. #define KFEATURE_HAS_SCSI_DMA_FUNCTIONS 1
  149. #define KFEATURE_HAS_SCSI_SET_RESID 1
  150. #define KFEATURE_HAS_UACCESS_H_FILE 1
  151. #define KFEATURE_HAS_SMP_LOCK_H 0
  152. #define HPSA_SUPPORTS_MSA2XXX 0
  153. #define SA_CONTROLLERS_GEN8 1
  154. #define SA_CONTROLLERS_GEN6 0
  155.  
  156. #else /* Default, kernel.org */
  157. #define KFEATURE_HAS_2011_03_INTERRUPT_HANDLER 1
  158. #define KFEATURE_CHANGE_QDEPTH_HAS_REASON 1
  159. #define KFEATURE_HAS_2011_03_STYLE_DEVICE_ATTR 1
  160. #define KFEATURE_HAS_SCSI_QDEPTH_DEFAULT 1
  161. #define KFEATURE_HAS_SCSI_FOR_EACH_SG 1
  162. #define KFEATURE_HAS_SCSI_DEVICE_TYPE 1
  163. #define KFEATURE_SCAN_START_PRESENT 1
  164. #define KFEATURE_SCAN_START_IMPLEMENTED 1
  165. #define KFEATURE_HAS_2011_03_QUEUECOMMAND 1
  166. #define KFEATURE_HAS_SHOST_PRIV 1
  167. #define KFEATURE_HAS_SCSI_DMA_FUNCTIONS 1
  168. #define KFEATURE_HAS_SCSI_SET_RESID 1
  169. #define KFEATURE_HAS_UACCESS_H_FILE 1
  170. #define KFEATURE_HAS_SMP_LOCK_H 0 /* include/linux/smp_lock.h removed between 2.6.38 and 2.6.39 */
  171. #define HPSA_SUPPORTS_MSA2XXX 0
  172. #define SA_CONTROLLERS_GEN8 1
  173. #define SA_CONTROLLERS_GEN6 1
  174.  
  175. #endif /* SLES11sp2plus */
  176. #endif /* SLES11sp1 */
  177. #endif /* RHEL6 */
  178. #endif /* RHEL5u2 */
  179. #endif /* RHEL5 */
  180. #endif /* DEBIAN_LENNY */
  181.  
  182. #if KFEATURE_HAS_2011_03_INTERRUPT_HANDLER
  183. /* new style interrupt handler */
  184. # define DECLARE_INTERRUPT_HANDLER(handler) \
  185. static irqreturn_t handler(int irq, void *dev_id)
  186. # define INTERRUPT_HANDLER_TYPE(handler) \
  187. irqreturn_t (*handler)(int, void *)
  188. #else
  189. /* old style interrupt handler */
  190. # define DECLARE_INTERRUPT_HANDLER(handler) \
  191. static irqreturn_t handler(int irq, void *dev_id, \
  192. struct pt_regs *regs)
  193. # define INTERRUPT_HANDLER_TYPE(handler) \
  194. irqreturn_t (*handler)(int, void *, struct pt_regs *)
  195. #endif
  196.  
  197.  
  198. #if KFEATURE_CHANGE_QDEPTH_HAS_REASON
  199. # define DECLARE_CHANGE_QUEUE_DEPTH(func) \
  200. static int func(struct scsi_device *sdev, \
  201. int qdepth, int reason)
  202. # define BAIL_ON_BAD_REASON \
  203. { if (reason != SCSI_QDEPTH_DEFAULT) \
  204. return -ENOTSUPP; }
  205. #else
  206. # define DECLARE_CHANGE_QUEUE_DEPTH(func) \
  207. static int func(struct scsi_device *sdev, int qdepth)
  208. # define BAIL_ON_BAD_REASON
  209. #endif
  210.  
  211.  
  212. #if KFEATURE_HAS_2011_03_STYLE_DEVICE_ATTR
  213.  
  214. # define DECLARE_DEVATTR_SHOW_FUNC(func) \
  215. static ssize_t func(struct device *dev, \
  216. struct device_attribute *attr, char *buf)
  217.  
  218. # define DECLARE_DEVATTR_STORE_FUNC(func) \
  219. static ssize_t func(struct device *dev, \
  220. struct device_attribute *attr, const char *buf, size_t count)
  221.  
  222. # define DECLARE_HOST_DEVICE_ATTR(xname, xmode, xshow, xstore) \
  223. DEVICE_ATTR(xname, xmode, xshow, xstore)
  224.  
  225. # define DECLARE_HOST_ATTR_LIST(xlist) \
  226. static struct device_attribute *xlist[]
  227. #else /* not KFEATURE_HAS_2011_03_STYLE_DEVICE_ATTR */
  228.  
  229. # define DECLARE_DEVATTR_SHOW_FUNC(func) \
  230. static ssize_t func(struct class_device *dev, char *buf)
  231.  
  232. # define DECLARE_DEVATTR_STORE_FUNC(func) \
  233. static ssize_t func(struct class_device *dev, \
  234. const char *buf, size_t count)
  235.  
  236. # define DECLARE_HOST_DEVICE_ATTR(xname, xmode, xshow, xstore) \
  237. struct class_device_attribute dev_attr_##xname = {\
  238. .attr = { \
  239. .name = #xname, \
  240. .mode = xmode, \
  241. }, \
  242. .show = xshow, \
  243. .store = xstore, \
  244. };
  245.  
  246. # define DECLARE_HOST_ATTR_LIST(xlist) \
  247. static struct class_device_attribute *xlist[]
  248.  
  249. #endif /* KFEATURE_HAS_2011_03_STYLE_DEVICE_ATTR */
  250.  
  251. #ifndef SCSI_QDEPTH_DEFAULT
  252. # define SCSI_QDEPTH_DEFAULT 0
  253. #endif
  254.  
  255. #if !KFEATURE_HAS_SCSI_FOR_EACH_SG
  256. # define scsi_for_each_sg(cmd, sg, nseg, __i) \
  257. for (__i = 0, sg = scsi_sglist(cmd); __i < (nseg); __i++, (sg)++)
  258. #endif
  259.  
  260. #if !KFEATURE_HAS_SHOST_PRIV
  261. static inline void *shost_priv(struct Scsi_Host *shost)
  262. {
  263. return (void *) shost->hostdata;
  264. }
  265. #endif
  266.  
  267. #if !KFEATURE_HAS_SCSI_DMA_FUNCTIONS
  268. /* Does not have things like scsi_dma_map, scsi_dma_unmap, scsi_sg_count,
  269. * sg_dma_address, sg_dma_len...
  270. */
  271.  
  272. static void hpsa_map_sg_chain_block(struct ctlr_info *h,
  273. struct CommandList *c);
  274.  
  275. /* It is not reasonably possible to retrofit the new scsi dma interfaces
  276. * onto the old code. So we retrofit at a higher level, at the dma mapping
  277. * function of the hpsa driver itself.
  278. *
  279. * hpsa_scatter_gather takes a struct scsi_cmnd, (cmd), and does the pci
  280. * dma mapping and fills in the scatter gather entries of the
  281. * hpsa command, cp.
  282. */
  283. static int hpsa_scatter_gather(struct ctlr_info *h,
  284. struct CommandList *cp,
  285. struct scsi_cmnd *cmd)
  286. {
  287. unsigned int len;
  288. u64 addr64;
  289. int use_sg, i, sg_index, chained = 0;
  290. struct SGDescriptor *curr_sg;
  291. struct scatterlist *sg = (struct scatterlist *) cmd->request_buffer;
  292.  
  293. if (!cmd->use_sg) {
  294. if (cmd->request_bufflen) { /* Just one scatter gather entry */
  295. addr64 = (__u64) pci_map_single(h->pdev,
  296. cmd->request_buffer, cmd->request_bufflen,
  297. cmd->sc_data_direction);
  298.  
  299. cp->SG[0].Addr.lower =
  300. (__u32) (addr64 & (__u64) 0x0FFFFFFFF);
  301. cp->SG[0].Addr.upper =
  302. (__u32) ((addr64 >> 32) & (__u64) 0x0FFFFFFFF);
  303. cp->SG[0].Len = cmd->request_bufflen;
  304. use_sg = 1;
  305. } else /* Zero sg entries */
  306. use_sg = 0;
  307. } else {
  308. BUG_ON(cmd->use_sg > h->maxsgentries);
  309.  
  310. /* Many sg entries */
  311. use_sg = pci_map_sg(h->pdev, cmd->request_buffer, cmd->use_sg,
  312. cmd->sc_data_direction);
  313.  
  314. if (use_sg < 0)
  315. return use_sg;
  316.  
  317. sg_index = 0;
  318. curr_sg = cp->SG;
  319. use_sg = cmd->use_sg;
  320.  
  321. for (i = 0; i < use_sg; i++) {
  322. if (i == h->max_cmd_sg_entries - 1 &&
  323. use_sg > h->max_cmd_sg_entries) {
  324. chained = 1;
  325. curr_sg = h->cmd_sg_list[cp->cmdindex];
  326. sg_index = 0;
  327. }
  328. addr64 = (__u64) sg_dma_address(&sg[i]);
  329. len = sg_dma_len(&sg[i]);
  330. curr_sg->Addr.lower =
  331. (u32) (addr64 & 0x0FFFFFFFFULL);
  332. curr_sg->Addr.upper =
  333. (u32) ((addr64 >> 32) & 0x0FFFFFFFFULL);
  334. curr_sg->Len = len;
  335. curr_sg->Ext = 0; /* we are not chaining */
  336. curr_sg++;
  337. }
  338. }
  339.  
  340. if (use_sg + chained > h->maxSG)
  341. h->maxSG = use_sg + chained;
  342.  
  343. if (chained) {
  344. cp->Header.SGList = h->max_cmd_sg_entries;
  345. cp->Header.SGTotal = (u16) (use_sg + 1);
  346. hpsa_map_sg_chain_block(h, cp);
  347. return 0;
  348. }
  349.  
  350. cp->Header.SGList = (u8) use_sg; /* no. SGs contig in this cmd */
  351. cp->Header.SGTotal = (u16) use_sg; /* total sgs in this cmd list */
  352. return 0;
  353. }
  354.  
  355. static void hpsa_unmap_sg_chain_block(struct ctlr_info *h,
  356. struct CommandList *c);
  357. static void hpsa_scatter_gather_unmap(struct ctlr_info *h,
  358. struct CommandList *c, struct scsi_cmnd *cmd)
  359. {
  360. union u64bit addr64;
  361.  
  362. if (cmd->use_sg) {
  363. pci_unmap_sg(h->pdev, cmd->request_buffer, cmd->use_sg,
  364. cmd->sc_data_direction);
  365. if (c->Header.SGTotal > h->max_cmd_sg_entries)
  366. hpsa_unmap_sg_chain_block(h, c);
  367. return;
  368. }
  369. if (cmd->request_bufflen) {
  370. addr64.val32.lower = c->SG[0].Addr.lower;
  371. addr64.val32.upper = c->SG[0].Addr.upper;
  372. pci_unmap_single(h->pdev, (dma_addr_t) addr64.val,
  373. cmd->request_bufflen, cmd->sc_data_direction);
  374. }
  375. }
  376.  
  377. static inline void scsi_dma_unmap(struct scsi_cmnd *cmd)
  378. {
  379. struct CommandList *c = (struct CommandList *) cmd->host_scribble;
  380.  
  381. hpsa_scatter_gather_unmap(c->h, c, cmd);
  382. }
  383.  
  384. #endif
  385.  
  386. #if !KFEATURE_HAS_SCSI_DEVICE_TYPE
  387. /**
  388. * scsi_device_type - Return 17 char string indicating device type.
  389. * @type: type number to look up
  390. */
  391. const char *scsi_device_type(unsigned type)
  392. {
  393. if (type == 0x1e)
  394. return "Well-known LUN ";
  395. if (type == 0x1f)
  396. return "No Device ";
  397. if (type >= ARRAY_SIZE(scsi_device_types))
  398. return "Unknown ";
  399. return scsi_device_types[type];
  400. }
  401. #endif
  402.  
  403. #if KFEATURE_SCAN_START_IMPLEMENTED
  404. /* .scan_start is present in scsi host template AND implemented.
  405. * Used to bail out of queuecommand if no scan_start and REPORT_LUNS
  406. * encountered
  407. */
  408. static inline int bail_on_report_luns_if_no_scan_start(
  409. __attribute__((unused)) struct scsi_cmnd *cmd,
  410. __attribute__((unused)) void (*done)(struct scsi_cmnd *))
  411. {
  412. return 0;
  413. }
  414.  
  415. /* RHEL6, kernel.org have functioning ->scan_start() method in kernel
  416. * so this is no-op.
  417. */
  418. static inline void hpsa_initial_update_scsi_devices(
  419. __attribute__((unused)) struct ctlr_info *h)
  420. {
  421. return;
  422. }
  423. #else /* not KFEATURE_SCAN_START_IMPLEMENTED */
  424. static inline int bail_on_report_luns_if_no_scan_start(
  425. struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
  426. {
  427. /*
  428. * This thing bails out of our queue command early on SCSI
  429. * REPORT_LUNS This is needed when the kernel doesn't really
  430. * support the scan_start method of the scsi host template.
  431. *
  432. * Since we do our own mapping in our driver, and we handle
  433. * adding/removing of our own devices.
  434. *
  435. * We want to prevent the mid-layer from doing it's own
  436. * adding/removing of drives which is what it would do
  437. * if we allow REPORT_LUNS to be processed.
  438. *
  439. * On RHEL5, scsi mid-layer never calls scan_start and
  440. * scan_finished even though they exist in scsi_host_template.
  441. *
  442. * On RHEL6 we use scan_start and scan_finished to tell
  443. * mid-layer that we do our own device adding/removing
  444. * therefore we can handle REPORT_LUNS.
  445. */
  446.  
  447. if (cmd->cmnd[0] == REPORT_LUNS) {
  448. cmd->result = (DID_OK << 16); /* host byte */
  449. cmd->result |= (COMMAND_COMPLETE << 8); /* msg byte */
  450. cmd->result |= SAM_STAT_CHECK_CONDITION;
  451. memset(cmd->sense_buffer, 0, sizeof(cmd->sense_buffer));
  452. cmd->sense_buffer[2] = ILLEGAL_REQUEST;
  453. done(cmd);
  454. return 1;
  455. }
  456. return 0;
  457. }
  458.  
  459. /* Need this if no functioning ->scan_start() method in kernel. */
  460. static void hpsa_update_scsi_devices(struct ctlr_info *h, int hostno);
  461. static inline void hpsa_initial_update_scsi_devices(
  462. struct ctlr_info *h)
  463. {
  464. hpsa_update_scsi_devices(h, -1);
  465. }
  466. #endif /* KFEATURE_SCAN_START_IMPLEMENTED */
  467.  
  468. #if KFEATURE_SCAN_START_PRESENT
  469. /* .scan_start is present in scsi host template */
  470. #define INITIALIZE_SCAN_START(funcptr) .scan_start = funcptr,
  471. #define INITIALIZE_SCAN_FINISHED(funcptr) .scan_finished = funcptr,
  472. #else /* .scan start is not even present in scsi host template */
  473. #define INITIALIZE_SCAN_START(funcptr)
  474. #define INITIALIZE_SCAN_FINISHED(funcptr)
  475. #endif
  476.  
  477. #if KFEATURE_HAS_2011_03_QUEUECOMMAND
  478. # define DECLARE_QUEUECOMMAND(func) \
  479. static int func##_lck(struct scsi_cmnd *cmd, \
  480. void (*done)(struct scsi_cmnd *))
  481. # define DECLARE_QUEUECOMMAND_WRAPPER(func) static DEF_SCSI_QCMD(func)
  482. #else
  483. # define DECLARE_QUEUECOMMAND(func) \
  484. static int func(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
  485. # define DECLARE_QUEUECOMMAND_WRAPPER(func)
  486. #endif
  487.  
  488. #if !KFEATURE_HAS_SCSI_SET_RESID
  489. static inline void scsi_set_resid(struct scsi_cmnd *cmd, int resid)
  490. {
  491. cmd->resid = resid;
  492. }
  493. #endif
  494.  
  495. #ifndef DMA_BIT_MASK
  496. #define DMA_BIT_MASK(n) (((n) == 64) ? ~0ULL : ((1ULL<<(n))-1))
  497. #endif
  498.  
  499. /* Define old style irq flags SA_* if the IRQF_* ones are missing. */
  500. #ifndef IRQF_DISABLED
  501. #define IRQF_DISABLED (SA_INTERRUPT | SA_SAMPLE_RANDOM)
  502. #endif
  503.  
  504. #if KFEATURE_HAS_UACCESS_H_FILE
  505. #include <linux/uaccess.h>
  506. #endif
  507.  
  508. #if KFEATURE_HAS_SMP_LOCK_H
  509. #include <linux/smp_lock.h>
  510. #endif
  511.  
  512. #if HPSA_SUPPORTS_MSA2XXX
  513. #define HPSA_MSA2XXX_PCI_IDS \
  514. {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSE, 0x103C, 0x3233}, \
  515. {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSF, 0x103C, 0x333F},
  516.  
  517. #define HPSA_MSA2XXX_PRODUCT_ENTRIES \
  518. {0x3233103C, "HP StorageWorks 1210m", &SA5_access}, \
  519. {0x333F103C, "HP StorageWorks 1210m", &SA5_access},
  520.  
  521. #else
  522. #define HPSA_MSA2XXX_PCI_IDS
  523. #define HPSA_MSA2XXX_PRODUCT_ENTRIES
  524. #endif
  525.  
  526. /* sles10sp4 apparently doesn't have DIV_ROUND_UP. Normally it comes
  527. * from include/linux/kernel.h. Other sles10's have it I think.
  528. */
  529. #if !defined(DIV_ROUND_UP)
  530. #define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d))
  531. #endif
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement