sys/dev/ips/ips_commands.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Written by: David Jeffery
   5  * Copyright (c) 2002 Adaptec Inc.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 #include <sys/cdefs.h>
  31 __FBSDID("$FreeBSD$");
  32
  33 #include <dev/ips/ipsreg.h>
  34 #include <dev/ips/ips.h>
  35
  36 /*
  37  * This is an interrupt callback.  It is called from
  38  * interrupt context when the adapter has completed the
  39  * command.  This very generic callback simply stores
  40  * the command's return value in command->arg and wake's
  41  * up anyone waiting on the command.
  42  */
  43 static void ips_wakeup_callback(ips_command_t *command)
  44 {
  45         bus_dmamap_sync(command->sc->command_dmatag, command->command_dmamap,
  46                         BUS_DMASYNC_POSTWRITE);
  47         sema_post(&command->sc->cmd_sema);
  48 }
  49 /* Below are a series of functions for sending an IO request
  50  * to the adapter.  The flow order is: start, send, callback, finish.
  51  * The caller must have already assembled an iorequest struct to hold
  52  * the details of the IO request. */
  53 static void ips_io_request_finish(ips_command_t *command)
  54 {
  55
  56         struct bio *iobuf = command->arg;
  57         if(ips_read_request(iobuf)) {
  58                 bus_dmamap_sync(command->data_dmatag, command->data_dmamap,
  59                                 BUS_DMASYNC_POSTREAD);
  60         } else {
  61                 bus_dmamap_sync(command->data_dmatag, command->data_dmamap,
  62                                 BUS_DMASYNC_POSTWRITE);
  63         }
  64         bus_dmamap_unload(command->data_dmatag, command->data_dmamap);
  65         if(COMMAND_ERROR(command)){
  66                 iobuf->bio_flags |=BIO_ERROR;
  67                 iobuf->bio_error = EIO;
  68                 printf("ips: io error, status= 0x%x\n", command->status.value);
  69         }
  70         ips_insert_free_cmd(command->sc, command);
  71         ipsd_finish(iobuf);
  72 }
  73
  74 static void ips_io_request_callback(void *cmdptr, bus_dma_segment_t *segments,int segnum, int error)
  75 {
  76         ips_softc_t *sc;
  77         ips_command_t *command = cmdptr;
  78         ips_sg_element_t *sg_list;
  79         ips_io_cmd *command_struct;
  80         struct bio *iobuf = command->arg;
  81         int i, length = 0;
  82         u_int8_t cmdtype;
  83
  84         sc = command->sc;
  85         if(error){
  86                 printf("ips: error = %d in ips_sg_request_callback\n", error);
  87                 bus_dmamap_unload(command->data_dmatag, command->data_dmamap);
  88                 iobuf->bio_flags |= BIO_ERROR;
  89                 iobuf->bio_error = ENOMEM;
  90                 ips_insert_free_cmd(sc, command);
  91                 ipsd_finish(iobuf);
  92                 return;
  93         }
  94         command_struct = (ips_io_cmd *)command->command_buffer;
  95         command_struct->id = command->id;
  96         command_struct->drivenum = (uintptr_t)iobuf->bio_driver1;
  97         if(segnum != 1){
  98                 if(ips_read_request(iobuf))
  99                         cmdtype = IPS_SG_READ_CMD;
 100                 else
 101                         cmdtype = IPS_SG_WRITE_CMD;
 102                 command_struct->segnum = segnum;
 103                 sg_list = (ips_sg_element_t *)((u_int8_t *)
 104                            command->command_buffer + IPS_COMMAND_LEN);
 105                 for(i = 0; i < segnum; i++){
 106                         sg_list[i].addr = segments[i].ds_addr;
 107                         sg_list[i].len = segments[i].ds_len;
 108                         length += segments[i].ds_len;
 109                 }
 110                 command_struct->buffaddr =
 111                     (u_int32_t)command->command_phys_addr + IPS_COMMAND_LEN;
 112         } else {
 113                 if(ips_read_request(iobuf))
 114                         cmdtype = IPS_READ_CMD;
 115                 else
 116                         cmdtype = IPS_WRITE_CMD;
 117                 command_struct->buffaddr = segments[0].ds_addr;
 118                 length = segments[0].ds_len;
 119         }
 120         command_struct->command = cmdtype;
 121         command_struct->lba = iobuf->bio_pblkno;
 122         length = (length + IPS_BLKSIZE - 1)/IPS_BLKSIZE;
 123         command_struct->length = length;
 124         bus_dmamap_sync(sc->command_dmatag, command->command_dmamap,
 125                         BUS_DMASYNC_PREWRITE);
 126         if(ips_read_request(iobuf)) {
 127                 bus_dmamap_sync(command->data_dmatag, command->data_dmamap,
 128                                 BUS_DMASYNC_PREREAD);
 129         } else {
 130                 bus_dmamap_sync(command->data_dmatag, command->data_dmamap,
 131                                 BUS_DMASYNC_PREWRITE);
 132         }
 133         PRINTF(10, "ips test: command id: %d segments: %d "
 134                 "pblkno: %lld length: %d, ds_len: %d\n", command->id, segnum,
 135                 iobuf->bio_pblkno,
 136                 length, segments[0].ds_len);
 137
 138         sc->ips_issue_cmd(command);
 139         return;
 140 }
 141
 142 static int ips_send_io_request(ips_command_t *command, struct bio *iobuf)
 143 {
 144         command->callback = ips_io_request_finish;
 145         command->arg = iobuf;
 146         PRINTF(10, "ips test: : bcount %ld\n", iobuf->bio_bcount);
 147         bus_dmamap_load(command->data_dmatag, command->data_dmamap,
 148                         iobuf->bio_data, iobuf->bio_bcount,
 149                         ips_io_request_callback, command, 0);
 150         return 0;
 151 }
 152
 153 void ips_start_io_request(ips_softc_t *sc)
 154 {
 155         struct bio *iobuf;
 156         ips_command_t *command;
 157
 158         iobuf = bioq_first(&sc->queue);
 159         if(!iobuf)
 160                 return;
 161
 162         if (ips_get_free_cmd(sc, &command, 0))
 163                 return;
 164
 165         bioq_remove(&sc->queue, iobuf);
 166         ips_send_io_request(command, iobuf);
 167         return;
 168 }
 169
 170 /* Below are a series of functions for sending an adapter info request
 171  * to the adapter.  The flow order is: get, send, callback. It uses
 172  * the generic finish callback at the top of this file.
 173  * This can be used to get configuration/status info from the card */
 174 static void ips_adapter_info_callback(void *cmdptr, bus_dma_segment_t *segments,int segnum, int error)
 175 {
 176         ips_softc_t *sc;
 177         ips_command_t *command = cmdptr;
 178         ips_adapter_info_cmd *command_struct;
 179         sc = command->sc;
 180         if(error){
 181                 ips_set_error(command, error);
 182                 printf("ips: error = %d in ips_get_adapter_info\n", error);
 183                 return;
 184         }
 185         command_struct = (ips_adapter_info_cmd *)command->command_buffer;
 186         command_struct->command = IPS_ADAPTER_INFO_CMD;
 187         command_struct->id = command->id;
 188         command_struct->buffaddr = segments[0].ds_addr;
 189
 190         bus_dmamap_sync(sc->command_dmatag, command->command_dmamap,
 191                         BUS_DMASYNC_PREWRITE);
 192         bus_dmamap_sync(command->data_dmatag, command->data_dmamap,
 193                         BUS_DMASYNC_PREREAD);
 194         sc->ips_issue_cmd(command);
 195         if (sema_timedwait(&sc->cmd_sema, 30*hz) != 0) {
 196                 ips_set_error(command, ETIMEDOUT);
 197                 return;
 198         }
 199
 200         bus_dmamap_sync(command->data_dmatag, command->data_dmamap,
 201                         BUS_DMASYNC_POSTREAD);
 202         memcpy(&(sc->adapter_info), command->data_buffer, IPS_ADAPTER_INFO_LEN);
 203 }
 204
 205
 206
 207 static int ips_send_adapter_info_cmd(ips_command_t *command)
 208 {
 209         int error = 0;
 210         ips_softc_t *sc = command->sc;
 211
 212         if (bus_dma_tag_create( /* parent    */ sc->adapter_dmatag,
 213                                 /* alignemnt */ 1,
 214                                 /* boundary  */ 0,
 215                                 /* lowaddr   */ BUS_SPACE_MAXADDR_32BIT,
 216                                 /* highaddr  */ BUS_SPACE_MAXADDR,
 217                                 /* filter    */ NULL,
 218                                 /* filterarg */ NULL,
 219                                 /* maxsize   */ IPS_ADAPTER_INFO_LEN,
 220                                 /* numsegs   */ 1,
 221                                 /* maxsegsize*/ IPS_ADAPTER_INFO_LEN,
 222                                 /* flags     */ 0,
 223                                 /* lockfunc  */ NULL,
 224                                 /* lockarg   */ NULL,
 225                                 &command->data_dmatag) != 0) {
 226                 printf("ips: can't alloc dma tag for adapter status\n");
 227                 error = ENOMEM;
 228                 goto exit;
 229         }
 230         if(bus_dmamem_alloc(command->data_dmatag, &command->data_buffer,
 231            BUS_DMA_NOWAIT, &command->data_dmamap)){
 232                 error = ENOMEM;
 233                 goto exit;
 234         }
 235         command->callback = ips_wakeup_callback;
 236         error = bus_dmamap_load(command->data_dmatag, command->data_dmamap,
 237                                 command->data_buffer,IPS_ADAPTER_INFO_LEN,
 238                                 ips_adapter_info_callback, command,
 239                                 BUS_DMA_NOWAIT);
 240
 241         if (error == 0)
 242                 bus_dmamap_unload(command->data_dmatag, command->data_dmamap);
 243
 244 exit:
 245         /* I suppose I should clean up my memory allocations */
 246         bus_dmamem_free(command->data_dmatag, command->data_buffer,
 247                         command->data_dmamap);
 248         bus_dma_tag_destroy(command->data_dmatag);
 249         ips_insert_free_cmd(sc, command);
 250         return error;
 251 }
 252
 253 int ips_get_adapter_info(ips_softc_t *sc)
 254 {
 255         ips_command_t *command;
 256         int error = 0;
 257
 258         if (ips_get_free_cmd(sc, &command, IPS_STATIC_FLAG) > 0){
 259                 device_printf(sc->dev, "unable to get adapter configuration\n");
 260                 return ENXIO;
 261         }
 262         ips_send_adapter_info_cmd(command);
 263         if (COMMAND_ERROR(command)){
 264                 error = ENXIO;
 265         }
 266         return error;
 267 }
 268
 269 /* Below are a series of functions for sending a drive info request
 270  * to the adapter.  The flow order is: get, send, callback. It uses
 271  * the generic finish callback at the top of this file.
 272  * This can be used to get drive status info from the card */
 273 static void ips_drive_info_callback(void *cmdptr, bus_dma_segment_t *segments,int segnum, int error)
 274 {
 275         ips_softc_t *sc;
 276         ips_command_t *command = cmdptr;
 277         ips_drive_cmd *command_struct;
 278         ips_drive_info_t *driveinfo;
 279
 280         sc = command->sc;
 281         if(error){
 282                 ips_set_error(command, error);
 283                 printf("ips: error = %d in ips_get_drive_info\n", error);
 284                 return;
 285         }
 286         command_struct = (ips_drive_cmd *)command->command_buffer;
 287         command_struct->command = IPS_DRIVE_INFO_CMD;
 288         command_struct->id = command->id;
 289         command_struct->buffaddr = segments[0].ds_addr;
 290
 291         bus_dmamap_sync(sc->command_dmatag, command->command_dmamap,
 292                         BUS_DMASYNC_PREWRITE);
 293         bus_dmamap_sync(command->data_dmatag, command->data_dmamap,
 294                         BUS_DMASYNC_PREREAD);
 295         sc->ips_issue_cmd(command);
 296         if (sema_timedwait(&sc->cmd_sema, 10*hz) != 0) {
 297                 ips_set_error(command, ETIMEDOUT);
 298                 return;
 299         }
 300
 301         bus_dmamap_sync(command->data_dmatag, command->data_dmamap,
 302                         BUS_DMASYNC_POSTREAD);
 303         driveinfo = command->data_buffer;
 304         memcpy(sc->drives, driveinfo->drives, sizeof(ips_drive_t) * 8);
 305         sc->drivecount = driveinfo->drivecount;
 306         device_printf(sc->dev, "logical drives: %d\n",sc->drivecount);
 307 }
 308
 309 static int ips_send_drive_info_cmd(ips_command_t *command)
 310 {
 311         int error = 0;
 312         ips_softc_t *sc = command->sc;
 313
 314         if (bus_dma_tag_create( /* parent    */ sc->adapter_dmatag,
 315                                 /* alignemnt */ 1,
 316                                 /* boundary  */ 0,
 317                                 /* lowaddr   */ BUS_SPACE_MAXADDR_32BIT,
 318                                 /* highaddr  */ BUS_SPACE_MAXADDR,
 319                                 /* filter    */ NULL,
 320                                 /* filterarg */ NULL,
 321                                 /* maxsize   */ IPS_DRIVE_INFO_LEN,
 322                                 /* numsegs   */ 1,
 323                                 /* maxsegsize*/ IPS_DRIVE_INFO_LEN,
 324                                 /* flags     */ 0,
 325                                 /* lockfunc  */ NULL,
 326                                 /* lockarg   */ NULL,
 327                                 &command->data_dmatag) != 0) {
 328                 printf("ips: can't alloc dma tag for drive status\n");
 329                 error = ENOMEM;
 330                 goto exit;
 331         }
 332         if(bus_dmamem_alloc(command->data_dmatag, &command->data_buffer,
 333                             BUS_DMA_NOWAIT, &command->data_dmamap)){
 334                 error = ENOMEM;
 335                 goto exit;
 336         }
 337         command->callback = ips_wakeup_callback;
 338         error = bus_dmamap_load(command->data_dmatag, command->data_dmamap,
 339                                 command->data_buffer,IPS_DRIVE_INFO_LEN,
 340                                 ips_drive_info_callback, command,
 341                                 BUS_DMA_NOWAIT);
 342         if (error == 0)
 343                 bus_dmamap_unload(command->data_dmatag, command->data_dmamap);
 344
 345 exit:
 346         /* I suppose I should clean up my memory allocations */
 347         bus_dmamem_free(command->data_dmatag, command->data_buffer,
 348                         command->data_dmamap);
 349         bus_dma_tag_destroy(command->data_dmatag);
 350         ips_insert_free_cmd(sc, command);
 351         return error;
 352
 353 }
 354 int ips_get_drive_info(ips_softc_t *sc)
 355 {
 356         int error = 0;
 357         ips_command_t *command;
 358
 359         if (ips_get_free_cmd(sc, &command, IPS_STATIC_FLAG) > 0){
 360                 device_printf(sc->dev, "unable to get drive configuration\n");
 361                 return ENXIO;
 362         }
 363         ips_send_drive_info_cmd(command);
 364         if(COMMAND_ERROR(command)){
 365                 error = ENXIO;
 366         }
 367         return error;
 368 }
 369
 370 /* Below is a pair of functions for making sure data is safely
 371  * on disk by flushing the adapter's cache. */
 372 static int ips_send_flush_cache_cmd(ips_command_t *command)
 373 {
 374         ips_softc_t *sc = command->sc;
 375         ips_generic_cmd *command_struct;
 376
 377         PRINTF(10,"ips test: got a command, building flush command\n");
 378         command->callback = ips_wakeup_callback;
 379         command_struct = (ips_generic_cmd *)command->command_buffer;
 380         command_struct->command = IPS_CACHE_FLUSH_CMD;
 381         command_struct->id = command->id;
 382         bus_dmamap_sync(sc->command_dmatag, command->command_dmamap,
 383                         BUS_DMASYNC_PREWRITE);
 384         sc->ips_issue_cmd(command);
 385         if (COMMAND_ERROR(command) == 0)
 386                 sema_wait(&sc->cmd_sema);
 387         ips_insert_free_cmd(sc, command);
 388         return 0;
 389 }
 390
 391 int ips_flush_cache(ips_softc_t *sc)
 392 {
 393         ips_command_t *command;
 394
 395         device_printf(sc->dev, "flushing cache\n");
 396         if (ips_get_free_cmd(sc, &command, IPS_STATIC_FLAG)){
 397                 device_printf(sc->dev, "ERROR: unable to get a command! can't flush cache!\n");
 398         }
 399         ips_send_flush_cache_cmd(command);
 400         if(COMMAND_ERROR(command)){
 401                 device_printf(sc->dev, "ERROR: cache flush command failed!\n");
 402         }
 403         return 0;
 404 }
 405
 406 /* Simplified localtime to provide timevalues for ffdc.
 407  * Taken from libc/stdtime/localtime.c
 408  */
 409 void static ips_ffdc_settime(ips_adapter_ffdc_cmd *command, time_t sctime)
 410 {
 411         long    days, rem, y;
 412         int     yleap, *ip, month;
 413         int     year_lengths[2] = { IPS_DAYSPERNYEAR, IPS_DAYSPERLYEAR };
 414         int     mon_lengths[2][IPS_MONSPERYEAR] = {
 415                 { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
 416                 { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
 417         };
 418
 419         days = sctime / IPS_SECSPERDAY;
 420         rem  = sctime % IPS_SECSPERDAY;
 421
 422         command->hour = rem / IPS_SECSPERHOUR;
 423         rem           = rem % IPS_SECSPERHOUR;
 424
 425         command->minute = rem / IPS_SECSPERMIN;
 426         command->second = rem % IPS_SECSPERMIN;
 427
 428         y = IPS_EPOCH_YEAR;
 429         while (days < 0 || days >= (long) year_lengths[yleap = ips_isleap(y)]) {
 430                 long    newy;
 431
 432                 newy = y + days / IPS_DAYSPERNYEAR;
 433                 if (days < 0)
 434                         --newy;
 435                 days -= (newy - y) * IPS_DAYSPERNYEAR +
 436                         IPS_LEAPS_THRU_END_OF(newy - 1) -
 437                         IPS_LEAPS_THRU_END_OF(y - 1);
 438                 y = newy;
 439         }
 440         command->yearH = y / 100;
 441         command->yearL = y % 100;
 442         ip = mon_lengths[yleap];
 443         for(month = 0; days >= (long) ip[month]; ++month)
 444                 days = days - (long) ip[month];
 445         command->month = month + 1;
 446         command->day = days + 1;
 447 }
 448
 449 static int ips_send_ffdc_reset_cmd(ips_command_t *command)
 450 {
 451         ips_softc_t *sc = command->sc;
 452         ips_adapter_ffdc_cmd *command_struct;
 453
 454         PRINTF(10,"ips test: got a command, building ffdc reset command\n");
 455         command->callback = ips_wakeup_callback;
 456         command_struct = (ips_adapter_ffdc_cmd *)command->command_buffer;
 457         command_struct->command = IPS_FFDC_CMD;
 458         command_struct->id = command->id;
 459         command_struct->reset_count = sc->ffdc_resetcount;
 460         command_struct->reset_type  = 0x0;
 461         ips_ffdc_settime(command_struct, sc->ffdc_resettime.tv_sec);
 462
 463         bus_dmamap_sync(sc->command_dmatag, command->command_dmamap,
 464                         BUS_DMASYNC_PREWRITE);
 465         sc->ips_issue_cmd(command);
 466         if (COMMAND_ERROR(command) == 0)
 467                 sema_wait(&sc->cmd_sema);
 468         ips_insert_free_cmd(sc, command);
 469         return 0;
 470 }
 471
 472 int ips_ffdc_reset(ips_softc_t *sc)
 473 {
 474         ips_command_t *command;
 475
 476         if (ips_get_free_cmd(sc, &command, IPS_STATIC_FLAG)){
 477                 device_printf(sc->dev, "ERROR: unable to get a command! can't send ffdc reset!\n");
 478         }
 479         ips_send_ffdc_reset_cmd(command);
 480         if(COMMAND_ERROR(command)){
 481                 device_printf(sc->dev, "ERROR: ffdc reset command failed!\n");
 482         }
 483         return 0;
 484 }
 485
 486 static void ips_write_nvram(ips_command_t *command){
 487         ips_softc_t *sc = command->sc;
 488         ips_rw_nvram_cmd *command_struct;
 489         ips_nvram_page5 *nvram;
 490
 491         /*FIXME check for error */
 492         command->callback = ips_wakeup_callback;
 493         command_struct = (ips_rw_nvram_cmd *)command->command_buffer;
 494         command_struct->command = IPS_RW_NVRAM_CMD;
 495         command_struct->id = command->id;
 496         command_struct->pagenum = 5;
 497         command_struct->rw      = 1; /*write*/
 498         bus_dmamap_sync(command->data_dmatag, command->data_dmamap,
 499                                 BUS_DMASYNC_POSTREAD);
 500         nvram = command->data_buffer;
 501         /* retrieve adapter info and save in sc */
 502         sc->adapter_type = nvram->adapter_type;
 503
 504         strncpy(nvram->driver_high, IPS_VERSION_MAJOR, 4);
 505         strncpy(nvram->driver_low, IPS_VERSION_MINOR, 4);
 506         nvram->operating_system = IPS_OS_FREEBSD;
 507         bus_dmamap_sync(sc->command_dmatag, command->command_dmamap,
 508                         BUS_DMASYNC_PREWRITE);
 509         sc->ips_issue_cmd(command);
 510 }
 511
 512 static void ips_read_nvram_callback(void *cmdptr, bus_dma_segment_t *segments,int segnum, int error)
 513 {
 514         ips_softc_t *sc;
 515         ips_command_t *command = cmdptr;
 516         ips_rw_nvram_cmd *command_struct;
 517         sc = command->sc;
 518         if(error){
 519                 ips_set_error(command, error);
 520                 printf("ips: error = %d in ips_read_nvram_callback\n", error);
 521                 return;
 522         }
 523         command_struct = (ips_rw_nvram_cmd *)command->command_buffer;
 524         command_struct->command = IPS_RW_NVRAM_CMD;
 525         command_struct->id = command->id;
 526         command_struct->pagenum = 5;
 527         command_struct->rw = 0;
 528         command_struct->buffaddr = segments[0].ds_addr;
 529
 530         bus_dmamap_sync(sc->command_dmatag, command->command_dmamap,
 531                         BUS_DMASYNC_PREWRITE);
 532         bus_dmamap_sync(command->data_dmatag, command->data_dmamap,
 533                         BUS_DMASYNC_PREREAD);
 534         sc->ips_issue_cmd(command);
 535         if (sema_timedwait(&sc->cmd_sema, 30*hz) != 0) {
 536                 ips_set_error(command, ETIMEDOUT);
 537                 return;
 538         }
 539         bus_dmamap_sync(command->data_dmatag, command->data_dmamap,
 540                         BUS_DMASYNC_POSTWRITE);
 541 }
 542
 543 static int ips_read_nvram(ips_command_t *command)
 544 {
 545         int error = 0;
 546         ips_softc_t *sc = command->sc;
 547
 548         if (bus_dma_tag_create( /* parent    */ sc->adapter_dmatag,
 549                                 /* alignemnt */ 1,
 550                                 /* boundary  */ 0,
 551                                 /* lowaddr   */ BUS_SPACE_MAXADDR_32BIT,
 552                                 /* highaddr  */ BUS_SPACE_MAXADDR,
 553                                 /* filter    */ NULL,
 554                                 /* filterarg */ NULL,
 555                                 /* maxsize   */ IPS_NVRAM_PAGE_SIZE,
 556                                 /* numsegs   */ 1,
 557                                 /* maxsegsize*/ IPS_NVRAM_PAGE_SIZE,
 558                                 /* flags     */ 0,
 559                                 /* lockfunc  */ NULL,
 560                                 /* lockarg   */ NULL,
 561                                 &command->data_dmatag) != 0) {
 562                 printf("ips: can't alloc dma tag for nvram\n");
 563                 error = ENOMEM;
 564                 goto exit;
 565         }
 566         if(bus_dmamem_alloc(command->data_dmatag, &command->data_buffer,
 567                             BUS_DMA_NOWAIT, &command->data_dmamap)){
 568                 error = ENOMEM;
 569                 goto exit;
 570         }
 571         command->callback = ips_write_nvram;
 572         error = bus_dmamap_load(command->data_dmatag, command->data_dmamap,
 573                                 command->data_buffer,IPS_NVRAM_PAGE_SIZE,
 574                                 ips_read_nvram_callback, command,
 575                                 BUS_DMA_NOWAIT);
 576         if (error == 0)
 577                 bus_dmamap_unload(command->data_dmatag, command->data_dmamap);
 578
 579 exit:
 580         bus_dmamem_free(command->data_dmatag, command->data_buffer,
 581                         command->data_dmamap);
 582         bus_dma_tag_destroy(command->data_dmatag);
 583         ips_insert_free_cmd(sc, command);
 584         return error;
 585 }
 586
 587 int ips_update_nvram(ips_softc_t *sc)
 588 {
 589         ips_command_t *command;
 590
 591         if (ips_get_free_cmd(sc, &command, IPS_STATIC_FLAG)){
 592                 device_printf(sc->dev, "ERROR: unable to get a command! can't update nvram\n");
 593                 return 1;
 594         }
 595         ips_read_nvram(command);
 596         if(COMMAND_ERROR(command)){
 597                 device_printf(sc->dev, "ERROR: nvram update command failed!\n");
 598         }
 599         return 0;
 600
 601
 602 }
 603
 604
 605 static int ips_send_config_sync_cmd(ips_command_t *command)
 606 {
 607         ips_softc_t *sc = command->sc;
 608         ips_generic_cmd *command_struct;
 609
 610         PRINTF(10,"ips test: got a command, building flush command\n");
 611         command->callback = ips_wakeup_callback;
 612         command_struct = (ips_generic_cmd *)command->command_buffer;
 613         command_struct->command = IPS_CONFIG_SYNC_CMD;
 614         command_struct->id = command->id;
 615         command_struct->reserve2 = IPS_POCL;
 616         bus_dmamap_sync(sc->command_dmatag, command->command_dmamap,
 617                         BUS_DMASYNC_PREWRITE);
 618         sc->ips_issue_cmd(command);
 619         if (COMMAND_ERROR(command) == 0)
 620                 sema_wait(&sc->cmd_sema);
 621         ips_insert_free_cmd(sc, command);
 622         return 0;
 623 }
 624
 625 static int ips_send_error_table_cmd(ips_command_t *command)
 626 {
 627         ips_softc_t *sc = command->sc;
 628         ips_generic_cmd *command_struct;
 629
 630         PRINTF(10,"ips test: got a command, building errortable command\n");
 631         command->callback = ips_wakeup_callback;
 632         command_struct = (ips_generic_cmd *)command->command_buffer;
 633         command_struct->command = IPS_ERROR_TABLE_CMD;
 634         command_struct->id = command->id;
 635         command_struct->reserve2 = IPS_CSL;
 636         bus_dmamap_sync(sc->command_dmatag, command->command_dmamap,
 637                         BUS_DMASYNC_PREWRITE);
 638         sc->ips_issue_cmd(command);
 639         if (COMMAND_ERROR(command) == 0)
 640                 sema_wait(&sc->cmd_sema);
 641         ips_insert_free_cmd(sc, command);
 642         return 0;
 643 }
 644
 645
 646 int ips_clear_adapter(ips_softc_t *sc)
 647 {
 648         ips_command_t *command;
 649
 650         device_printf(sc->dev, "syncing config\n");
 651         if (ips_get_free_cmd(sc, &command, IPS_STATIC_FLAG)){
 652                 device_printf(sc->dev, "ERROR: unable to get a command! can't sync cache!\n");
 653                 return 1;
 654         }
 655         ips_send_config_sync_cmd(command);
 656         if(COMMAND_ERROR(command)){
 657                 device_printf(sc->dev, "ERROR: cache sync command failed!\n");
 658                 return 1;
 659         }
 660
 661         device_printf(sc->dev, "clearing error table\n");
 662         if(ips_get_free_cmd(sc, &command, IPS_STATIC_FLAG)){
 663                 device_printf(sc->dev, "ERROR: unable to get a command! can't sync cache!\n");
 664                 return 1;
 665         }
 666         ips_send_error_table_cmd(command);
 667         if(COMMAND_ERROR(command)){
 668                 device_printf(sc->dev, "ERROR: etable command failed!\n");
 669                 return 1;
 670         }
 671
 672         return 0;
 673 }