1 /*- 2 * Written by: David Jeffery 3 * Copyright (c) 2002 Adaptec Inc. 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 * 27 * $FreeBSD: src/sys/dev/ips/ips_disk.c,v 1.4 2003/09/22 04:59:07 njl Exp $ 28 * $DragonFly: src/sys/dev/raid/ips/ips_disk.c,v 1.11 2006/12/22 23:26:23 swildner Exp $ 29 */ 30 31 #include <sys/devicestat.h> 32 #include <dev/raid/ips/ips.h> 33 #include <dev/raid/ips/ips_disk.h> 34 #include <sys/stat.h> 35 36 #include <vm/vm.h> 37 #include <vm/pmap.h> 38 #include <machine/md_var.h> 39 40 static int ipsd_probe(device_t dev); 41 static int ipsd_attach(device_t dev); 42 static int ipsd_detach(device_t dev); 43 44 #if 0 45 static int ipsd_dump(void *arg, void *virtual, vm_offset_t physical, off_t offset, size_t length); 46 static void ipsd_dump_map_sg(void *arg, bus_dma_segment_t *segs, int nsegs, 47 int error); 48 static void ipsd_dump_block_complete(ips_command_t *command); 49 #endif 50 51 static d_open_t ipsd_open; 52 static d_close_t ipsd_close; 53 static d_strategy_t ipsd_strategy; 54 static d_dump_t ipsd_dump_helper; 55 56 static struct dev_ops ipsd_ops = { 57 { "ipsd", IPSD_CDEV_MAJOR, D_DISK }, 58 .d_open = ipsd_open, 59 .d_close = ipsd_close, 60 .d_strategy = ipsd_strategy, 61 .d_read = physread, 62 .d_write = physwrite, 63 .d_dump = ipsd_dump_helper, 64 }; 65 66 static device_method_t ipsd_methods[] = { 67 DEVMETHOD(device_probe, ipsd_probe), 68 DEVMETHOD(device_attach, ipsd_attach), 69 DEVMETHOD(device_detach, ipsd_detach), 70 { 0, 0 } 71 }; 72 73 74 static driver_t ipsd_driver = { 75 "ipsd", 76 ipsd_methods, 77 sizeof(ipsdisk_softc_t) 78 }; 79 80 static devclass_t ipsd_devclass; 81 DRIVER_MODULE(ipsd, ips, ipsd_driver, ipsd_devclass, 0, 0); 82 83 /* 84 * handle opening of disk device. It must set up all information about 85 * the geometry and size of the disk 86 */ 87 static int 88 ipsd_open(struct dev_open_args *ap) 89 { 90 cdev_t dev = ap->a_head.a_dev; 91 ipsdisk_softc_t *dsc = dev->si_drv1; 92 93 if (dsc == NULL) 94 return (ENXIO); 95 dsc->state |= IPS_DEV_OPEN; 96 DEVICE_PRINTF(2, dsc->dev, "I'm open\n"); 97 return 0; 98 } 99 100 static int 101 ipsd_close(struct dev_close_args *ap) 102 { 103 cdev_t dev = ap->a_head.a_dev; 104 ipsdisk_softc_t *dsc = dev->si_drv1; 105 106 dsc->state &= ~IPS_DEV_OPEN; 107 DEVICE_PRINTF(2, dsc->dev, "I'm closed for the day\n"); 108 return 0; 109 } 110 111 /* ipsd_finish is called to clean up and return a completed IO request */ 112 void 113 ipsd_finish(struct bio *bio) 114 { 115 struct buf *bp = bio->bio_buf; 116 ipsdisk_softc_t *dsc; 117 118 dsc = bio->bio_driver_info; 119 if (bp->b_flags & B_ERROR) { 120 device_printf(dsc->dev, "iobuf error %d\n", bp->b_error); 121 } else { 122 bp->b_resid = 0; 123 } 124 devstat_end_transaction_buf(&dsc->stats, bp); 125 biodone(bio); 126 ips_start_io_request(dsc->sc); 127 } 128 129 130 static int 131 ipsd_strategy(struct dev_strategy_args *ap) 132 { 133 cdev_t dev = ap->a_head.a_dev; 134 struct bio *bio = ap->a_bio; 135 ipsdisk_softc_t *dsc; 136 137 dsc = dev->si_drv1; 138 DEVICE_PRINTF(8, dsc->dev, "in strategy\n"); 139 bio->bio_driver_info = dsc; 140 devstat_start_transaction(&dsc->stats); 141 lockmgr(&dsc->sc->queue_lock, LK_EXCLUSIVE|LK_RETRY); 142 bioq_insert_tail(&dsc->sc->bio_queue, bio); 143 ips_start_io_request(dsc->sc); 144 lockmgr(&dsc->sc->queue_lock, LK_RELEASE); 145 return(0); 146 } 147 148 static int 149 ipsd_probe(device_t dev) 150 { 151 DEVICE_PRINTF(2, dev, "in probe\n"); 152 device_set_desc(dev, "Logical Drive"); 153 return 0; 154 } 155 156 static int 157 ipsd_attach(device_t dev) 158 { 159 device_t adapter; 160 ipsdisk_softc_t *dsc; 161 struct disklabel *label; 162 u_int totalsectors; 163 u_int nheads, nsectors; 164 165 DEVICE_PRINTF(2, dev, "in attach\n"); 166 dsc = (ipsdisk_softc_t *)device_get_softc(dev); 167 bzero(dsc, sizeof(ipsdisk_softc_t)); 168 adapter = device_get_parent(dev); 169 dsc->dev = dev; 170 dsc->sc = device_get_softc(adapter); 171 dsc->unit = device_get_unit(dev); 172 dsc->disk_number = (uintptr_t) device_get_ivars(dev); 173 totalsectors = dsc->sc->drives[dsc->disk_number].sector_count; 174 if ((totalsectors > 0x400000) && 175 ((dsc->sc->adapter_info.miscflags & 0x8) == 0)) { 176 nheads = IPS_NORM_HEADS; 177 nsectors = IPS_NORM_SECTORS; 178 } else { 179 nheads = IPS_COMP_HEADS; 180 nsectors = IPS_COMP_SECTORS; 181 } 182 devstat_add_entry(&dsc->stats, "ipsd", dsc->unit, DEV_BSIZE, 183 DEVSTAT_NO_ORDERED_TAGS, 184 DEVSTAT_TYPE_DIRECT | DEVSTAT_TYPE_IF_SCSI, 185 DEVSTAT_PRIORITY_DISK); 186 dsc->ipsd_dev_t = disk_create(dsc->unit, &dsc->ipsd_disk, 0, &ipsd_ops); 187 dsc->ipsd_dev_t->si_drv1 = dsc; 188 dsc->ipsd_dev_t->si_iosize_max = IPS_MAX_IO_SIZE; 189 label = &dsc->ipsd_disk.d_label; 190 bzero(label, sizeof(*label)); 191 label->d_ntracks = nheads; 192 label->d_nsectors = nsectors; 193 label->d_type = DTYPE_ESDI; 194 label->d_secsize = IPS_BLKSIZE; 195 label->d_ncylinders = totalsectors / nheads / nsectors; 196 label->d_secpercyl = nsectors / nheads; 197 label->d_secperunit = totalsectors; 198 device_printf(dev, "Logical Drive (%dMB)\n", 199 dsc->sc->drives[dsc->disk_number].sector_count >> 11); 200 return 0; 201 } 202 203 static int 204 ipsd_detach(device_t dev) 205 { 206 ipsdisk_softc_t *dsc; 207 208 DEVICE_PRINTF(2, dev, "in detach\n"); 209 dsc = (ipsdisk_softc_t *)device_get_softc(dev); 210 if (dsc->state & IPS_DEV_OPEN) 211 return (EBUSY); 212 devstat_remove_entry(&dsc->stats); 213 disk_destroy(&dsc->ipsd_disk); 214 return 0; 215 } 216 217 static int 218 ipsd_dump_helper(struct dev_dump_args *ap) 219 { 220 kprintf("dump support for IPS not yet working, will not dump\n"); 221 return (ENODEV); 222 223 #if 0 224 long blkcnt; 225 caddr_t va; 226 vm_offset_t addr, a; 227 int dumppages = MAXDUMPPGS; 228 int i; 229 230 addr = 0; 231 blkcnt = howmany(PAGE_SIZE, secsize); 232 while (count > 0) { 233 va = NULL; 234 if (count / blkcnt < dumppages) 235 dumppages = count / blkcnt; 236 for (i = 0; i < dumppages; i++) { 237 a = addr + (i * PAGE_SIZE); 238 if (!is_physical_memory(a)) 239 a = 0; 240 va = pmap_kenter_temporary(trunc_page(a), i); 241 } 242 243 ipsd_dump(dev, va, 0, blkno, PAGE_SIZE * dumppages); 244 if (dumpstatus(addr, (off_t)count * DEV_BSIZE) < 0) 245 return (EINTR); 246 blkno += blkcnt * dumppages; 247 count -= blkcnt * dumppages; 248 addr += PAGE_SIZE * dumppages; 249 } 250 return (0); 251 #endif 252 } 253 254 #if 0 255 256 static int 257 ipsd_dump(void *arg, void *virtual, vm_offset_t physical, off_t offset, 258 size_t length) 259 { 260 cdev_t dev = arg; 261 ips_softc_t *sc; 262 ips_command_t *command; 263 ips_io_cmd *command_struct; 264 ipsdisk_softc_t *dsc; 265 off_t off; 266 uint8_t *va; 267 int len; 268 int error = 0; 269 270 dsc = dev->si_drv1; 271 if (dsc == NULL) 272 return (EINVAL); 273 sc = dsc->sc; 274 275 if (ips_get_free_cmd(sc, &command, 0) != 0) { 276 kprintf("ipsd: failed to get cmd for dump\n"); 277 return (ENOMEM); 278 } 279 280 command->data_dmatag = sc->sg_dmatag; 281 command->callback = ipsd_dump_block_complete; 282 283 command_struct = (ips_io_cmd *)command->command_buffer; 284 command_struct->id = command->id; 285 command_struct->drivenum = sc->drives[dsc->disk_number].drivenum; 286 287 off = offset; 288 va = virtual; 289 290 while (length > 0) { 291 len = length > IPS_MAX_IO_SIZE ? IPS_MAX_IO_SIZE : length; 292 command_struct->lba = off / IPS_BLKSIZE; 293 if (bus_dmamap_load(command->data_dmatag, command->data_dmamap, 294 va, len, ipsd_dump_map_sg, command, 0) != 0) { 295 error = EIO; 296 break; 297 } 298 if (COMMAND_ERROR(&command->status)) { 299 error = EIO; 300 break; 301 } 302 303 length -= len; 304 off += len; 305 va += len; 306 } 307 ips_insert_free_cmd(command->sc, command); 308 return(error); 309 } 310 311 static void 312 ipsd_dump_map_sg(void *arg, bus_dma_segment_t *segs, int nsegs, int error) 313 { 314 ips_softc_t *sc; 315 ips_command_t *command; 316 ips_sg_element_t *sg_list; 317 ips_io_cmd *command_struct; 318 int i, length; 319 320 command = (ips_command_t *)arg; 321 sc = command->sc; 322 length = 0; 323 324 if (error) { 325 kprintf("ipsd_dump_map_sg: error %d\n", error); 326 command->status.value = IPS_ERROR_STATUS; 327 return; 328 } 329 330 command_struct = (ips_io_cmd *)command->command_buffer; 331 332 if (nsegs != 1) { 333 command_struct->segnum = nsegs; 334 sg_list = (ips_sg_element_t *)((uint8_t *) 335 command->command_buffer + IPS_COMMAND_LEN); 336 for (i = 0; i < nsegs; i++) { 337 sg_list[i].addr = segs[i].ds_addr; 338 sg_list[i].len = segs[i].ds_len; 339 length += segs[i].ds_len; 340 } 341 command_struct->buffaddr = 342 (uint32_t)command->command_phys_addr + IPS_COMMAND_LEN; 343 command_struct->command = IPS_SG_WRITE_CMD; 344 } else { 345 command_struct->buffaddr = segs[0].ds_addr; 346 length = segs[0].ds_len; 347 command_struct->segnum = 0; 348 command_struct->command = IPS_WRITE_CMD; 349 } 350 351 length = (length + IPS_BLKSIZE - 1) / IPS_BLKSIZE; 352 command_struct->length = length; 353 bus_dmamap_sync(sc->command_dmatag, command->command_dmamap, 354 BUS_DMASYNC_PREWRITE); 355 bus_dmamap_sync(command->data_dmatag, command->data_dmamap, 356 BUS_DMASYNC_PREWRITE); 357 358 sc->ips_issue_cmd(command); 359 sc->ips_poll_cmd(command); 360 return; 361 } 362 363 static void 364 ipsd_dump_block_complete(ips_command_t *command) 365 { 366 if (COMMAND_ERROR(&command->status)) { 367 kprintf("ipsd_dump completion error= 0x%x\n", 368 command->status.value); 369 } 370 bus_dmamap_sync(command->data_dmatag, command->data_dmamap, 371 BUS_DMASYNC_POSTWRITE); 372 bus_dmamap_unload(command->data_dmatag, command->data_dmamap); 373 } 374 375 #endif 376