Don't like ads? PRO users don't see any ads ;-)
Public Pastes
Guest

hpsa_kernel_compat.h with Debian Lenny Mod

By: a guest on Jun 29th, 2012  |  syntax: None  |  size: 16.84 KB  |  hits: 404  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  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
create a new version of this paste RAW Paste Data