tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

[SCSI] remove use_sg_chaining

With the sg table code, every SCSI driver is now either chain capable
or broken (or has sg_tablesize set so chaining is never activated), so
there's no need to have a check in the host template.

Also tidy up the code by moving the scatterlist size defines into the
SCSI includes and permit the last entry of the scatterlist pools not
to be a power of two.
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>

James Bottomley d3f46f39 b8de1631

+37 -111
-1
arch/ia64/hp/sim/simscsi.c
··· 360 360 .max_sectors = 1024, 361 361 .cmd_per_lun = SIMSCSI_REQ_QUEUE_LEN, 362 362 .use_clustering = DISABLE_CLUSTERING, 363 - .use_sg_chaining = ENABLE_SG_CHAINING, 364 363 }; 365 364 366 365 static int __init
-1
drivers/infiniband/ulp/srp/ib_srp.c
··· 1571 1571 .this_id = -1, 1572 1572 .cmd_per_lun = SRP_SQ_SIZE, 1573 1573 .use_clustering = ENABLE_CLUSTERING, 1574 - .use_sg_chaining = ENABLE_SG_CHAINING, 1575 1574 .shost_attrs = srp_host_attrs 1576 1575 }; 1577 1576
-1
drivers/scsi/3w-9xxx.c
··· 1990 1990 .max_sectors = TW_MAX_SECTORS, 1991 1991 .cmd_per_lun = TW_MAX_CMDS_PER_LUN, 1992 1992 .use_clustering = ENABLE_CLUSTERING, 1993 - .use_sg_chaining = ENABLE_SG_CHAINING, 1994 1993 .shost_attrs = twa_host_attrs, 1995 1994 .emulated = 1 1996 1995 };
-1
drivers/scsi/3w-xxxx.c
··· 2261 2261 .max_sectors = TW_MAX_SECTORS, 2262 2262 .cmd_per_lun = TW_MAX_CMDS_PER_LUN, 2263 2263 .use_clustering = ENABLE_CLUSTERING, 2264 - .use_sg_chaining = ENABLE_SG_CHAINING, 2265 2264 .shost_attrs = tw_host_attrs, 2266 2265 .emulated = 1 2267 2266 };
-1
drivers/scsi/BusLogic.c
··· 3575 3575 .unchecked_isa_dma = 1, 3576 3576 .max_sectors = 128, 3577 3577 .use_clustering = ENABLE_CLUSTERING, 3578 - .use_sg_chaining = ENABLE_SG_CHAINING, 3579 3578 }; 3580 3579 3581 3580 /*
-1
drivers/scsi/NCR53c406a.c
··· 1065 1065 .cmd_per_lun = 1 /* commands per lun */, 1066 1066 .unchecked_isa_dma = 1 /* unchecked_isa_dma */, 1067 1067 .use_clustering = ENABLE_CLUSTERING, 1068 - .use_sg_chaining = ENABLE_SG_CHAINING, 1069 1068 }; 1070 1069 1071 1070 #include "scsi_module.c"
-1
drivers/scsi/a100u2w.c
··· 1071 1071 .sg_tablesize = SG_ALL, 1072 1072 .cmd_per_lun = 1, 1073 1073 .use_clustering = ENABLE_CLUSTERING, 1074 - .use_sg_chaining = ENABLE_SG_CHAINING, 1075 1074 }; 1076 1075 1077 1076 static int __devinit inia100_probe_one(struct pci_dev *pdev,
-1
drivers/scsi/aacraid/linit.c
··· 1032 1032 .cmd_per_lun = AAC_NUM_IO_FIB, 1033 1033 #endif 1034 1034 .use_clustering = ENABLE_CLUSTERING, 1035 - .use_sg_chaining = ENABLE_SG_CHAINING, 1036 1035 .emulated = 1, 1037 1036 }; 1038 1037
-1
drivers/scsi/aha1740.c
··· 563 563 .sg_tablesize = AHA1740_SCATTER, 564 564 .cmd_per_lun = AHA1740_CMDLUN, 565 565 .use_clustering = ENABLE_CLUSTERING, 566 - .use_sg_chaining = ENABLE_SG_CHAINING, 567 566 .eh_abort_handler = aha1740_eh_abort_handler, 568 567 }; 569 568
-1
drivers/scsi/aic7xxx/aic79xx_osm.c
··· 766 766 .max_sectors = 8192, 767 767 .cmd_per_lun = 2, 768 768 .use_clustering = ENABLE_CLUSTERING, 769 - .use_sg_chaining = ENABLE_SG_CHAINING, 770 769 .slave_alloc = ahd_linux_slave_alloc, 771 770 .slave_configure = ahd_linux_slave_configure, 772 771 .target_alloc = ahd_linux_target_alloc,
-1
drivers/scsi/aic7xxx/aic7xxx_osm.c
··· 747 747 .max_sectors = 8192, 748 748 .cmd_per_lun = 2, 749 749 .use_clustering = ENABLE_CLUSTERING, 750 - .use_sg_chaining = ENABLE_SG_CHAINING, 751 750 .slave_alloc = ahc_linux_slave_alloc, 752 751 .slave_configure = ahc_linux_slave_configure, 753 752 .target_alloc = ahc_linux_target_alloc,
-1
drivers/scsi/aic7xxx_old.c
··· 11141 11141 .max_sectors = 2048, 11142 11142 .cmd_per_lun = 3, 11143 11143 .use_clustering = ENABLE_CLUSTERING, 11144 - .use_sg_chaining = ENABLE_SG_CHAINING, 11145 11144 }; 11146 11145 11147 11146 #include "scsi_module.c"
-1
drivers/scsi/arcmsr/arcmsr_hba.c
··· 122 122 .max_sectors = ARCMSR_MAX_XFER_SECTORS, 123 123 .cmd_per_lun = ARCMSR_MAX_CMD_PERLUN, 124 124 .use_clustering = ENABLE_CLUSTERING, 125 - .use_sg_chaining = ENABLE_SG_CHAINING, 126 125 .shost_attrs = arcmsr_host_attrs, 127 126 }; 128 127 #ifdef CONFIG_SCSI_ARCMSR_AER
-1
drivers/scsi/dc395x.c
··· 4763 4763 .eh_bus_reset_handler = dc395x_eh_bus_reset, 4764 4764 .unchecked_isa_dma = 0, 4765 4765 .use_clustering = DISABLE_CLUSTERING, 4766 - .use_sg_chaining = ENABLE_SG_CHAINING, 4767 4766 }; 4768 4767 4769 4768
-1
drivers/scsi/dpt_i2o.c
··· 3340 3340 .this_id = 7, 3341 3341 .cmd_per_lun = 1, 3342 3342 .use_clustering = ENABLE_CLUSTERING, 3343 - .use_sg_chaining = ENABLE_SG_CHAINING, 3344 3343 }; 3345 3344 #include "scsi_module.c" 3346 3345 MODULE_LICENSE("GPL");
-1
drivers/scsi/eata.c
··· 524 524 .this_id = 7, 525 525 .unchecked_isa_dma = 1, 526 526 .use_clustering = ENABLE_CLUSTERING, 527 - .use_sg_chaining = ENABLE_SG_CHAINING, 528 527 }; 529 528 530 529 #if !defined(__BIG_ENDIAN_BITFIELD) && !defined(__LITTLE_ENDIAN_BITFIELD)
-1
drivers/scsi/hosts.c
··· 342 342 shost->use_clustering = sht->use_clustering; 343 343 shost->ordered_tag = sht->ordered_tag; 344 344 shost->active_mode = sht->supported_mode; 345 - shost->use_sg_chaining = sht->use_sg_chaining; 346 345 347 346 if (sht->supported_mode == MODE_UNKNOWN) 348 347 /* means we didn't set it ... default to INITIATOR */
-1
drivers/scsi/hptiop.c
··· 906 906 .unchecked_isa_dma = 0, 907 907 .emulated = 0, 908 908 .use_clustering = ENABLE_CLUSTERING, 909 - .use_sg_chaining = ENABLE_SG_CHAINING, 910 909 .proc_name = driver_name, 911 910 .shost_attrs = hptiop_attrs, 912 911 .this_id = -1,
-1
drivers/scsi/ibmmca.c
··· 1501 1501 .sg_tablesize = 16, 1502 1502 .cmd_per_lun = 1, 1503 1503 .use_clustering = ENABLE_CLUSTERING, 1504 - .use_sg_chaining = ENABLE_SG_CHAINING, 1505 1504 }; 1506 1505 1507 1506 static int ibmmca_probe(struct device *dev)
-1
drivers/scsi/ibmvscsi/ibmvscsi.c
··· 1600 1600 .this_id = -1, 1601 1601 .sg_tablesize = SG_ALL, 1602 1602 .use_clustering = ENABLE_CLUSTERING, 1603 - .use_sg_chaining = ENABLE_SG_CHAINING, 1604 1603 .shost_attrs = ibmvscsi_attrs, 1605 1604 }; 1606 1605
-1
drivers/scsi/initio.c
··· 2833 2833 .sg_tablesize = SG_ALL, 2834 2834 .cmd_per_lun = 1, 2835 2835 .use_clustering = ENABLE_CLUSTERING, 2836 - .use_sg_chaining = ENABLE_SG_CHAINING, 2837 2836 }; 2838 2837 2839 2838 static int initio_probe_one(struct pci_dev *pdev,
-1
drivers/scsi/iscsi_tcp.c
··· 1933 1933 .eh_device_reset_handler= iscsi_eh_device_reset, 1934 1934 .eh_host_reset_handler = iscsi_eh_host_reset, 1935 1935 .use_clustering = DISABLE_CLUSTERING, 1936 - .use_sg_chaining = ENABLE_SG_CHAINING, 1937 1936 .slave_configure = iscsi_tcp_slave_configure, 1938 1937 .proc_name = "iscsi_tcp", 1939 1938 .this_id = -1,
-2
drivers/scsi/lpfc/lpfc_scsi.c
··· 1459 1459 .scan_finished = lpfc_scan_finished, 1460 1460 .this_id = -1, 1461 1461 .sg_tablesize = LPFC_DEFAULT_SG_SEG_CNT, 1462 - .use_sg_chaining = ENABLE_SG_CHAINING, 1463 1462 .cmd_per_lun = LPFC_CMD_PER_LUN, 1464 1463 .use_clustering = ENABLE_CLUSTERING, 1465 1464 .shost_attrs = lpfc_hba_attrs, ··· 1481 1482 .sg_tablesize = LPFC_DEFAULT_SG_SEG_CNT, 1482 1483 .cmd_per_lun = LPFC_CMD_PER_LUN, 1483 1484 .use_clustering = ENABLE_CLUSTERING, 1484 - .use_sg_chaining = ENABLE_SG_CHAINING, 1485 1485 .shost_attrs = lpfc_vport_attrs, 1486 1486 .max_sectors = 0xFFFF, 1487 1487 };
-1
drivers/scsi/mac53c94.c
··· 402 402 .sg_tablesize = SG_ALL, 403 403 .cmd_per_lun = 1, 404 404 .use_clustering = DISABLE_CLUSTERING, 405 - .use_sg_chaining = ENABLE_SG_CHAINING, 406 405 }; 407 406 408 407 static int mac53c94_probe(struct macio_dev *mdev, const struct of_device_id *match)
-1
drivers/scsi/megaraid.c
··· 4490 4490 .sg_tablesize = MAX_SGLIST, 4491 4491 .cmd_per_lun = DEF_CMD_PER_LUN, 4492 4492 .use_clustering = ENABLE_CLUSTERING, 4493 - .use_sg_chaining = ENABLE_SG_CHAINING, 4494 4493 .eh_abort_handler = megaraid_abort, 4495 4494 .eh_device_reset_handler = megaraid_reset, 4496 4495 .eh_bus_reset_handler = megaraid_reset,
-1
drivers/scsi/megaraid/megaraid_mbox.c
··· 361 361 .eh_host_reset_handler = megaraid_reset_handler, 362 362 .change_queue_depth = megaraid_change_queue_depth, 363 363 .use_clustering = ENABLE_CLUSTERING, 364 - .use_sg_chaining = ENABLE_SG_CHAINING, 365 364 .sdev_attrs = megaraid_sdev_attrs, 366 365 .shost_attrs = megaraid_shost_attrs, 367 366 };
-1
drivers/scsi/megaraid/megaraid_sas.c
··· 1192 1192 .eh_timed_out = megasas_reset_timer, 1193 1193 .bios_param = megasas_bios_param, 1194 1194 .use_clustering = ENABLE_CLUSTERING, 1195 - .use_sg_chaining = ENABLE_SG_CHAINING, 1196 1195 }; 1197 1196 1198 1197 /**
-1
drivers/scsi/mesh.c
··· 1843 1843 .sg_tablesize = SG_ALL, 1844 1844 .cmd_per_lun = 2, 1845 1845 .use_clustering = DISABLE_CLUSTERING, 1846 - .use_sg_chaining = ENABLE_SG_CHAINING, 1847 1846 }; 1848 1847 1849 1848 static int mesh_probe(struct macio_dev *mdev, const struct of_device_id *match)
-1
drivers/scsi/nsp32.c
··· 281 281 .cmd_per_lun = 1, 282 282 .this_id = NSP32_HOST_SCSIID, 283 283 .use_clustering = DISABLE_CLUSTERING, 284 - .use_sg_chaining = ENABLE_SG_CHAINING, 285 284 .eh_abort_handler = nsp32_eh_abort, 286 285 .eh_bus_reset_handler = nsp32_eh_bus_reset, 287 286 .eh_host_reset_handler = nsp32_eh_host_reset,
-1
drivers/scsi/pcmcia/sym53c500_cs.c
··· 692 692 .sg_tablesize = 32, 693 693 .cmd_per_lun = 1, 694 694 .use_clustering = ENABLE_CLUSTERING, 695 - .use_sg_chaining = ENABLE_SG_CHAINING, 696 695 .shost_attrs = SYM53C500_shost_attrs 697 696 }; 698 697
-1
drivers/scsi/qla1280.c
··· 4204 4204 .sg_tablesize = SG_ALL, 4205 4205 .cmd_per_lun = 1, 4206 4206 .use_clustering = ENABLE_CLUSTERING, 4207 - .use_sg_chaining = ENABLE_SG_CHAINING, 4208 4207 }; 4209 4208 4210 4209
-2
drivers/scsi/qla2xxx/qla_os.c
··· 131 131 .this_id = -1, 132 132 .cmd_per_lun = 3, 133 133 .use_clustering = ENABLE_CLUSTERING, 134 - .use_sg_chaining = ENABLE_SG_CHAINING, 135 134 .sg_tablesize = SG_ALL, 136 135 137 136 /* ··· 162 163 .this_id = -1, 163 164 .cmd_per_lun = 3, 164 165 .use_clustering = ENABLE_CLUSTERING, 165 - .use_sg_chaining = ENABLE_SG_CHAINING, 166 166 .sg_tablesize = SG_ALL, 167 167 168 168 .max_sectors = 0xFFFF,
-1
drivers/scsi/qla4xxx/ql4_os.c
··· 94 94 .this_id = -1, 95 95 .cmd_per_lun = 3, 96 96 .use_clustering = ENABLE_CLUSTERING, 97 - .use_sg_chaining = ENABLE_SG_CHAINING, 98 97 .sg_tablesize = SG_ALL, 99 98 100 99 .max_sectors = 0xFFFF,
-1
drivers/scsi/qlogicfas.c
··· 197 197 .sg_tablesize = SG_ALL, 198 198 .cmd_per_lun = 1, 199 199 .use_clustering = DISABLE_CLUSTERING, 200 - .use_sg_chaining = ENABLE_SG_CHAINING, 201 200 }; 202 201 203 202 static __init int qlogicfas_init(void)
+18 -56
drivers/scsi/scsi_lib.c
··· 8 8 */ 9 9 10 10 #include <linux/bio.h> 11 + #include <linux/bitops.h> 11 12 #include <linux/blkdev.h> 12 13 #include <linux/completion.h> 13 14 #include <linux/kernel.h> ··· 35 34 #define SG_MEMPOOL_NR ARRAY_SIZE(scsi_sg_pools) 36 35 #define SG_MEMPOOL_SIZE 2 37 36 38 - /* 39 - * The maximum number of SG segments that we will put inside a scatterlist 40 - * (unless chaining is used). Should ideally fit inside a single page, to 41 - * avoid a higher order allocation. 42 - */ 43 - #define SCSI_MAX_SG_SEGMENTS 128 44 - 45 37 struct scsi_host_sg_pool { 46 38 size_t size; 47 39 char *name; ··· 42 48 mempool_t *pool; 43 49 }; 44 50 45 - #define SP(x) { x, "sgpool-" #x } 51 + #define SP(x) { x, "sgpool-" __stringify(x) } 52 + #if (SCSI_MAX_SG_SEGMENTS < 32) 53 + #error SCSI_MAX_SG_SEGMENTS is too small (must be 32 or greater) 54 + #endif 46 55 static struct scsi_host_sg_pool scsi_sg_pools[] = { 47 56 SP(8), 48 57 SP(16), 49 - #if (SCSI_MAX_SG_SEGMENTS > 16) 50 - SP(32), 51 58 #if (SCSI_MAX_SG_SEGMENTS > 32) 52 - SP(64), 59 + SP(32), 53 60 #if (SCSI_MAX_SG_SEGMENTS > 64) 61 + SP(64), 62 + #if (SCSI_MAX_SG_SEGMENTS > 128) 54 63 SP(128), 64 + #if (SCSI_MAX_SG_SEGMENTS > 256) 65 + #error SCSI_MAX_SG_SEGMENTS is too large (256 MAX) 55 66 #endif 56 67 #endif 57 68 #endif 69 + #endif 70 + SP(SCSI_MAX_SG_SEGMENTS) 58 71 }; 59 72 #undef SP 60 73 ··· 693 692 return NULL; 694 693 } 695 694 696 - /* 697 - * Like SCSI_MAX_SG_SEGMENTS, but for archs that have sg chaining. This limit 698 - * is totally arbitrary, a setting of 2048 will get you at least 8mb ios. 699 - */ 700 - #define SCSI_MAX_SG_CHAIN_SEGMENTS 2048 701 - 702 695 static inline unsigned int scsi_sgtable_index(unsigned short nents) 703 696 { 704 697 unsigned int index; 705 698 706 - switch (nents) { 707 - case 1 ... 8: 699 + BUG_ON(nents > SCSI_MAX_SG_SEGMENTS); 700 + 701 + if (nents <= 8) 708 702 index = 0; 709 - break; 710 - case 9 ... 16: 711 - index = 1; 712 - break; 713 - #if (SCSI_MAX_SG_SEGMENTS > 16) 714 - case 17 ... 32: 715 - index = 2; 716 - break; 717 - #if (SCSI_MAX_SG_SEGMENTS > 32) 718 - case 33 ... 64: 719 - index = 3; 720 - break; 721 - #if (SCSI_MAX_SG_SEGMENTS > 64) 722 - case 65 ... 128: 723 - index = 4; 724 - break; 725 - #endif 726 - #endif 727 - #endif 728 - default: 729 - printk(KERN_ERR "scsi: bad segment count=%d\n", nents); 730 - BUG(); 731 - } 703 + else 704 + index = get_count_order(nents) - 3; 732 705 733 706 return index; 734 707 } ··· 1578 1603 * this limit is imposed by hardware restrictions 1579 1604 */ 1580 1605 blk_queue_max_hw_segments(q, shost->sg_tablesize); 1581 - 1582 - /* 1583 - * In the future, sg chaining support will be mandatory and this 1584 - * ifdef can then go away. Right now we don't have all archs 1585 - * converted, so better keep it safe. 1586 - */ 1587 - #ifdef ARCH_HAS_SG_CHAIN 1588 - if (shost->use_sg_chaining) 1589 - blk_queue_max_phys_segments(q, SCSI_MAX_SG_CHAIN_SEGMENTS); 1590 - else 1591 - blk_queue_max_phys_segments(q, SCSI_MAX_SG_SEGMENTS); 1592 - #else 1593 - blk_queue_max_phys_segments(q, SCSI_MAX_SG_SEGMENTS); 1594 - #endif 1606 + blk_queue_max_phys_segments(q, SCSI_MAX_SG_CHAIN_SEGMENTS); 1595 1607 1596 1608 blk_queue_max_sectors(q, shost->max_sectors); 1597 1609 blk_queue_bounce_limit(q, scsi_calculate_bounce_limit(shost));
-1
drivers/scsi/stex.c
··· 1123 1123 .this_id = -1, 1124 1124 .sg_tablesize = ST_MAX_SG, 1125 1125 .cmd_per_lun = ST_CMD_PER_LUN, 1126 - .use_sg_chaining = ENABLE_SG_CHAINING, 1127 1126 }; 1128 1127 1129 1128 static int stex_set_dma_mask(struct pci_dev * pdev)
-1
drivers/scsi/sym53c416.c
··· 840 840 .cmd_per_lun = 1, 841 841 .unchecked_isa_dma = 1, 842 842 .use_clustering = ENABLE_CLUSTERING, 843 - .use_sg_chaining = ENABLE_SG_CHAINING, 844 843 }; 845 844 #include "scsi_module.c"
-1
drivers/scsi/sym53c8xx_2/sym_glue.c
··· 1681 1681 .eh_host_reset_handler = sym53c8xx_eh_host_reset_handler, 1682 1682 .this_id = 7, 1683 1683 .use_clustering = ENABLE_CLUSTERING, 1684 - .use_sg_chaining = ENABLE_SG_CHAINING, 1685 1684 .max_sectors = 0xFFFF, 1686 1685 #ifdef SYM_LINUX_PROC_INFO_SUPPORT 1687 1686 .proc_info = sym53c8xx_proc_info,
-1
drivers/scsi/u14-34f.c
··· 451 451 .this_id = 7, 452 452 .unchecked_isa_dma = 1, 453 453 .use_clustering = ENABLE_CLUSTERING, 454 - .use_sg_chaining = ENABLE_SG_CHAINING, 455 454 }; 456 455 457 456 #if !defined(__BIG_ENDIAN_BITFIELD) && !defined(__LITTLE_ENDIAN_BITFIELD)
-1
drivers/scsi/ultrastor.c
··· 1204 1204 .cmd_per_lun = ULTRASTOR_MAX_CMDS_PER_LUN, 1205 1205 .unchecked_isa_dma = 1, 1206 1206 .use_clustering = ENABLE_CLUSTERING, 1207 - .use_sg_chaining = ENABLE_SG_CHAINING, 1208 1207 }; 1209 1208 #include "scsi_module.c"
-1
drivers/scsi/wd7000.c
··· 1671 1671 .cmd_per_lun = 1, 1672 1672 .unchecked_isa_dma = 1, 1673 1673 .use_clustering = ENABLE_CLUSTERING, 1674 - .use_sg_chaining = ENABLE_SG_CHAINING, 1675 1674 }; 1676 1675 1677 1676 #include "scsi_module.c"
+19
include/scsi/scsi.h
··· 11 11 #include <linux/types.h> 12 12 13 13 /* 14 + * The maximum number of SG segments that we will put inside a 15 + * scatterlist (unless chaining is used). Should ideally fit inside a 16 + * single page, to avoid a higher order allocation. We could define this 17 + * to SG_MAX_SINGLE_ALLOC to pack correctly at the highest order. The 18 + * minimum value is 32 19 + */ 20 + #define SCSI_MAX_SG_SEGMENTS 128 21 + 22 + /* 23 + * Like SCSI_MAX_SG_SEGMENTS, but for archs that have sg chaining. This limit 24 + * is totally arbitrary, a setting of 2048 will get you at least 8mb ios. 25 + */ 26 + #ifdef ARCH_HAS_SG_CHAIN 27 + #define SCSI_MAX_SG_CHAIN_SEGMENTS 2048 28 + #else 29 + #define SCSI_MAX_SG_CHAIN_SEGMENTS SCSI_MAX_SG_SEGMENTS 30 + #endif 31 + 32 + /* 14 33 * SCSI command lengths 15 34 */ 16 35
-13
include/scsi/scsi_host.h
··· 39 39 #define DISABLE_CLUSTERING 0 40 40 #define ENABLE_CLUSTERING 1 41 41 42 - #define DISABLE_SG_CHAINING 0 43 - #define ENABLE_SG_CHAINING 1 44 - 45 42 enum scsi_eh_timer_return { 46 43 EH_NOT_HANDLED, 47 44 EH_HANDLED, ··· 443 446 unsigned ordered_tag:1; 444 447 445 448 /* 446 - * true if the low-level driver can support sg chaining. this 447 - * will be removed eventually when all the drivers are 448 - * converted to support sg chaining. 449 - * 450 - * Status: OBSOLETE 451 - */ 452 - unsigned use_sg_chaining:1; 453 - 454 - /* 455 449 * Countdown for host blocking with no commands outstanding 456 450 */ 457 451 unsigned int max_host_blocked; ··· 586 598 unsigned unchecked_isa_dma:1; 587 599 unsigned use_clustering:1; 588 600 unsigned use_blk_tcq:1; 589 - unsigned use_sg_chaining:1; 590 601 591 602 /* 592 603 * Host has requested that no further requests come through for the