drivers/scsi/hosts.c

   1 /*
   2  *  hosts.c Copyright (C) 1992 Drew Eckhardt
   3  *          Copyright (C) 1993, 1994, 1995 Eric Youngdale
   4  *          Copyright (C) 2002-2003 Christoph Hellwig
   5  *
   6  *  mid to lowlevel SCSI driver interface
   7  *      Initial versions: Drew Eckhardt
   8  *      Subsequent revisions: Eric Youngdale
   9  *
  10  *  <drew@colorado.edu>
  11  *
  12  *  Jiffies wrap fixes (host->resetting), 3 Dec 1998 Andrea Arcangeli
  13  *  Added QLOGIC QLA1280 SCSI controller kernel host support.
  14  *     August 4, 1999 Fred Lewis, Intel DuPont
  15  *
  16  *  Updated to reflect the new initialization scheme for the higher
  17  *  level of scsi drivers (sd/sr/st)
  18  *  September 17, 2000 Torben Mathiasen <tmm@image.dk>
  19  *
  20  *  Restructured scsi_host lists and associated functions.
  21  *  September 04, 2002 Mike Anderson (andmike@us.ibm.com)
  22  */
  23
  24 #include <linux/module.h>
  25 #include <linux/blkdev.h>
  26 #include <linux/kernel.h>
  27 #include <linux/string.h>
  28 #include <linux/mm.h>
  29 #include <linux/init.h>
  30 #include <linux/completion.h>
  31 #include <linux/transport_class.h>
  32
  33 #include <scsi/scsi_device.h>
  34 #include <scsi/scsi_host.h>
  35 #include <scsi/scsi_transport.h>
  36
  37 #include "scsi_priv.h"
  38 #include "scsi_logging.h"
  39
  40
  41 static int scsi_host_next_hn;           /* host_no for next new host */
  42
  43
  44 static void scsi_host_cls_release(struct class_device *class_dev)
  45 {
  46         put_device(&class_to_shost(class_dev)->shost_gendev);
  47 }
  48
  49 static struct class shost_class = {
  50         .name           = "scsi_host",
  51         .release        = scsi_host_cls_release,
  52 };
  53
  54 /**
  55  *      scsi_host_set_state - Take the given host through the host
  56  *              state model.
  57  *      @shost: scsi host to change the state of.
  58  *      @state: state to change to.
  59  *
  60  *      Returns zero if unsuccessful or an error if the requested
  61  *      transition is illegal.
  62  **/
  63 int scsi_host_set_state(struct Scsi_Host *shost, enum scsi_host_state state)
  64 {
  65         enum scsi_host_state oldstate = shost->shost_state;
  66
  67         if (state == oldstate)
  68                 return 0;
  69
  70         switch (state) {
  71         case SHOST_CREATED:
  72                 /* There are no legal states that come back to
  73                  * created.  This is the manually initialised start
  74                  * state */
  75                 goto illegal;
  76
  77         case SHOST_RUNNING:
  78                 switch (oldstate) {
  79                 case SHOST_CREATED:
  80                 case SHOST_RECOVERY:
  81                         break;
  82                 default:
  83                         goto illegal;
  84                 }
  85                 break;
  86
  87         case SHOST_RECOVERY:
  88                 switch (oldstate) {
  89                 case SHOST_RUNNING:
  90                         break;
  91                 default:
  92                         goto illegal;
  93                 }
  94                 break;
  95
  96         case SHOST_CANCEL:
  97                 switch (oldstate) {
  98                 case SHOST_CREATED:
  99                 case SHOST_RUNNING:
 100                         break;
 101                 default:
 102                         goto illegal;
 103                 }
 104                 break;
 105
 106         case SHOST_DEL:
 107                 switch (oldstate) {
 108                 case SHOST_CANCEL:
 109                         break;
 110                 default:
 111                         goto illegal;
 112                 }
 113                 break;
 114
 115         }
 116         shost->shost_state = state;
 117         return 0;
 118
 119  illegal:
 120         SCSI_LOG_ERROR_RECOVERY(1,
 121                                 dev_printk(KERN_ERR, &shost->shost_gendev,
 122                                            "Illegal host state transition"
 123                                            "%s->%s\n",
 124                                            scsi_host_state_name(oldstate),
 125                                            scsi_host_state_name(state)));
 126         return -EINVAL;
 127 }
 128 EXPORT_SYMBOL(scsi_host_set_state);
 129
 130 /**
 131  * scsi_remove_host - remove a scsi host
 132  * @shost:      a pointer to a scsi host to remove
 133  **/
 134 void scsi_remove_host(struct Scsi_Host *shost)
 135 {
 136         scsi_host_set_state(shost, SHOST_CANCEL);
 137         scsi_forget_host(shost);
 138         scsi_proc_host_rm(shost);
 139
 140         scsi_host_set_state(shost, SHOST_DEL);
 141
 142         transport_unregister_device(&shost->shost_gendev);
 143         class_device_unregister(&shost->shost_classdev);
 144         device_del(&shost->shost_gendev);
 145 }
 146 EXPORT_SYMBOL(scsi_remove_host);
 147
 148 /**
 149  * scsi_add_host - add a scsi host
 150  * @shost:      scsi host pointer to add
 151  * @dev:        a struct device of type scsi class
 152  *
 153  * Return value:
 154  *      0 on success / != 0 for error
 155  **/
 156 int scsi_add_host(struct Scsi_Host *shost, struct device *dev)
 157 {
 158         struct scsi_host_template *sht = shost->hostt;
 159         int error = -EINVAL;
 160
 161         printk(KERN_INFO "scsi%d : %s\n", shost->host_no,
 162                         sht->info ? sht->info(shost) : sht->name);
 163
 164         if (!shost->can_queue) {
 165                 printk(KERN_ERR "%s: can_queue = 0 no longer supported\n",
 166                                 sht->name);
 167                 goto out;
 168         }
 169
 170         if (!shost->shost_gendev.parent)
 171                 shost->shost_gendev.parent = dev ? dev : &platform_bus;
 172
 173         error = device_add(&shost->shost_gendev);
 174         if (error)
 175                 goto out;
 176
 177         scsi_host_set_state(shost, SHOST_RUNNING);
 178         get_device(shost->shost_gendev.parent);
 179
 180         error = class_device_add(&shost->shost_classdev);
 181         if (error)
 182                 goto out_del_gendev;
 183
 184         get_device(&shost->shost_gendev);
 185
 186         if (shost->transportt->host_size &&
 187             (shost->shost_data = kmalloc(shost->transportt->host_size,
 188                                          GFP_KERNEL)) == NULL)
 189                 goto out_del_classdev;
 190
 191         if (shost->transportt->create_work_queue) {
 192                 snprintf(shost->work_q_name, KOBJ_NAME_LEN, "scsi_wq_%d",
 193                         shost->host_no);
 194                 shost->work_q = create_singlethread_workqueue(
 195                                         shost->work_q_name);
 196                 if (!shost->work_q)
 197                         goto out_free_shost_data;
 198         }
 199
 200         error = scsi_sysfs_add_host(shost);
 201         if (error)
 202                 goto out_destroy_host;
 203
 204         scsi_proc_host_add(shost);
 205         return error;
 206
 207  out_destroy_host:
 208         if (shost->work_q)
 209                 destroy_workqueue(shost->work_q);
 210  out_free_shost_data:
 211         kfree(shost->shost_data);
 212  out_del_classdev:
 213         class_device_del(&shost->shost_classdev);
 214  out_del_gendev:
 215         device_del(&shost->shost_gendev);
 216  out:
 217         return error;
 218 }
 219 EXPORT_SYMBOL(scsi_add_host);
 220
 221 static void scsi_host_dev_release(struct device *dev)
 222 {
 223         struct Scsi_Host *shost = dev_to_shost(dev);
 224         struct device *parent = dev->parent;
 225
 226         if (shost->ehandler) {
 227                 DECLARE_COMPLETION(sem);
 228                 shost->eh_notify = &sem;
 229                 shost->eh_kill = 1;
 230                 up(shost->eh_wait);
 231                 wait_for_completion(&sem);
 232                 shost->eh_notify = NULL;
 233         }
 234
 235         if (shost->work_q)
 236                 destroy_workqueue(shost->work_q);
 237
 238         scsi_proc_hostdir_rm(shost->hostt);
 239         scsi_destroy_command_freelist(shost);
 240         kfree(shost->shost_data);
 241
 242         if (parent)
 243                 put_device(parent);
 244         kfree(shost);
 245 }
 246
 247 /**
 248  * scsi_host_alloc - register a scsi host adapter instance.
 249  * @sht:        pointer to scsi host template
 250  * @privsize:   extra bytes to allocate for driver
 251  *
 252  * Note:
 253  *      Allocate a new Scsi_Host and perform basic initialization.
 254  *      The host is not published to the scsi midlayer until scsi_add_host
 255  *      is called.
 256  *
 257  * Return value:
 258  *      Pointer to a new Scsi_Host
 259  **/
 260 struct Scsi_Host *scsi_host_alloc(struct scsi_host_template *sht, int privsize)
 261 {
 262         struct Scsi_Host *shost;
 263         int gfp_mask = GFP_KERNEL, rval;
 264         DECLARE_COMPLETION(complete);
 265
 266         if (sht->unchecked_isa_dma && privsize)
 267                 gfp_mask |= __GFP_DMA;
 268
 269         /* Check to see if this host has any error handling facilities */
 270         if (!sht->eh_strategy_handler && !sht->eh_abort_handler &&
 271             !sht->eh_device_reset_handler && !sht->eh_bus_reset_handler &&
 272             !sht->eh_host_reset_handler) {
 273                 printk(KERN_ERR "ERROR: SCSI host `%s' has no error handling\n"
 274                                 "ERROR: This is not a safe way to run your "
 275                                         "SCSI host\n"
 276                                 "ERROR: The error handling must be added to "
 277                                 "this driver\n", sht->proc_name);
 278                 dump_stack();
 279         }
 280
 281         shost = kmalloc(sizeof(struct Scsi_Host) + privsize, gfp_mask);
 282         if (!shost)
 283                 return NULL;
 284         memset(shost, 0, sizeof(struct Scsi_Host) + privsize);
 285
 286         spin_lock_init(&shost->default_lock);
 287         scsi_assign_lock(shost, &shost->default_lock);
 288         shost->shost_state = SHOST_CREATED;
 289         INIT_LIST_HEAD(&shost->__devices);
 290         INIT_LIST_HEAD(&shost->__targets);
 291         INIT_LIST_HEAD(&shost->eh_cmd_q);
 292         INIT_LIST_HEAD(&shost->starved_list);
 293         init_waitqueue_head(&shost->host_wait);
 294
 295         init_MUTEX(&shost->scan_mutex);
 296
 297         shost->host_no = scsi_host_next_hn++; /* XXX(hch): still racy */
 298         shost->dma_channel = 0xff;
 299
 300         /* These three are default values which can be overridden */
 301         shost->max_channel = 0;
 302         shost->max_id = 8;
 303         shost->max_lun = 8;
 304
 305         /* Give each shost a default transportt */
 306         shost->transportt = &blank_transport_template;
 307
 308         /*
 309          * All drivers right now should be able to handle 12 byte
 310          * commands.  Every so often there are requests for 16 byte
 311          * commands, but individual low-level drivers need to certify that
 312          * they actually do something sensible with such commands.
 313          */
 314         shost->max_cmd_len = 12;
 315         shost->hostt = sht;
 316         shost->this_id = sht->this_id;
 317         shost->can_queue = sht->can_queue;
 318         shost->sg_tablesize = sht->sg_tablesize;
 319         shost->cmd_per_lun = sht->cmd_per_lun;
 320         shost->unchecked_isa_dma = sht->unchecked_isa_dma;
 321         shost->use_clustering = sht->use_clustering;
 322         shost->ordered_flush = sht->ordered_flush;
 323         shost->ordered_tag = sht->ordered_tag;
 324
 325         /*
 326          * hosts/devices that do queueing must support ordered tags
 327          */
 328         if (shost->can_queue > 1 && shost->ordered_flush) {
 329                 printk(KERN_ERR "scsi: ordered flushes don't support queueing\n");
 330                 shost->ordered_flush = 0;
 331         }
 332
 333         if (sht->max_host_blocked)
 334                 shost->max_host_blocked = sht->max_host_blocked;
 335         else
 336                 shost->max_host_blocked = SCSI_DEFAULT_HOST_BLOCKED;
 337
 338         /*
 339          * If the driver imposes no hard sector transfer limit, start at
 340          * machine infinity initially.
 341          */
 342         if (sht->max_sectors)
 343                 shost->max_sectors = sht->max_sectors;
 344         else
 345                 shost->max_sectors = SCSI_DEFAULT_MAX_SECTORS;
 346
 347         /*
 348          * assume a 4GB boundary, if not set
 349          */
 350         if (sht->dma_boundary)
 351                 shost->dma_boundary = sht->dma_boundary;
 352         else
 353                 shost->dma_boundary = 0xffffffff;
 354
 355         rval = scsi_setup_command_freelist(shost);
 356         if (rval)
 357                 goto fail_kfree;
 358
 359         device_initialize(&shost->shost_gendev);
 360         snprintf(shost->shost_gendev.bus_id, BUS_ID_SIZE, "host%d",
 361                 shost->host_no);
 362         shost->shost_gendev.release = scsi_host_dev_release;
 363
 364         class_device_initialize(&shost->shost_classdev);
 365         shost->shost_classdev.dev = &shost->shost_gendev;
 366         shost->shost_classdev.class = &shost_class;
 367         snprintf(shost->shost_classdev.class_id, BUS_ID_SIZE, "host%d",
 368                   shost->host_no);
 369
 370         shost->eh_notify = &complete;
 371         rval = kernel_thread(scsi_error_handler, shost, 0);
 372         if (rval < 0)
 373                 goto fail_destroy_freelist;
 374         wait_for_completion(&complete);
 375         shost->eh_notify = NULL;
 376
 377         scsi_proc_hostdir_add(shost->hostt);
 378         return shost;
 379
 380  fail_destroy_freelist:
 381         scsi_destroy_command_freelist(shost);
 382  fail_kfree:
 383         kfree(shost);
 384         return NULL;
 385 }
 386 EXPORT_SYMBOL(scsi_host_alloc);
 387
 388 struct Scsi_Host *scsi_register(struct scsi_host_template *sht, int privsize)
 389 {
 390         struct Scsi_Host *shost = scsi_host_alloc(sht, privsize);
 391
 392         if (!sht->detect) {
 393                 printk(KERN_WARNING "scsi_register() called on new-style "
 394                                     "template for driver %s\n", sht->name);
 395                 dump_stack();
 396         }
 397
 398         if (shost)
 399                 list_add_tail(&shost->sht_legacy_list, &sht->legacy_hosts);
 400         return shost;
 401 }
 402 EXPORT_SYMBOL(scsi_register);
 403
 404 void scsi_unregister(struct Scsi_Host *shost)
 405 {
 406         list_del(&shost->sht_legacy_list);
 407         scsi_host_put(shost);
 408 }
 409 EXPORT_SYMBOL(scsi_unregister);
 410
 411 /**
 412  * scsi_host_lookup - get a reference to a Scsi_Host by host no
 413  *
 414  * @hostnum:    host number to locate
 415  *
 416  * Return value:
 417  *      A pointer to located Scsi_Host or NULL.
 418  **/
 419 struct Scsi_Host *scsi_host_lookup(unsigned short hostnum)
 420 {
 421         struct class *class = &shost_class;
 422         struct class_device *cdev;
 423         struct Scsi_Host *shost = ERR_PTR(-ENXIO), *p;
 424
 425         down_read(&class->subsys.rwsem);
 426         list_for_each_entry(cdev, &class->children, node) {
 427                 p = class_to_shost(cdev);
 428                 if (p->host_no == hostnum) {
 429                         shost = scsi_host_get(p);
 430                         break;
 431                 }
 432         }
 433         up_read(&class->subsys.rwsem);
 434
 435         return shost;
 436 }
 437 EXPORT_SYMBOL(scsi_host_lookup);
 438
 439 /**
 440  * scsi_host_get - inc a Scsi_Host ref count
 441  * @shost:      Pointer to Scsi_Host to inc.
 442  **/
 443 struct Scsi_Host *scsi_host_get(struct Scsi_Host *shost)
 444 {
 445         if ((shost->shost_state == SHOST_DEL) ||
 446                 !get_device(&shost->shost_gendev))
 447                 return NULL;
 448         return shost;
 449 }
 450 EXPORT_SYMBOL(scsi_host_get);
 451
 452 /**
 453  * scsi_host_put - dec a Scsi_Host ref count
 454  * @shost:      Pointer to Scsi_Host to dec.
 455  **/
 456 void scsi_host_put(struct Scsi_Host *shost)
 457 {
 458         put_device(&shost->shost_gendev);
 459 }
 460 EXPORT_SYMBOL(scsi_host_put);
 461
 462 int scsi_init_hosts(void)
 463 {
 464         return class_register(&shost_class);
 465 }
 466
 467 void scsi_exit_hosts(void)
 468 {
 469         class_unregister(&shost_class);
 470 }
 471
 472 int scsi_is_host_device(const struct device *dev)
 473 {
 474         return dev->release == scsi_host_dev_release;
 475 }
 476 EXPORT_SYMBOL(scsi_is_host_device);
 477
 478 /**
 479  * scsi_queue_work - Queue work to the Scsi_Host workqueue.
 480  * @shost:      Pointer to Scsi_Host.
 481  * @work:       Work to queue for execution.
 482  *
 483  * Return value:
 484  *      0 on success / != 0 for error
 485  **/
 486 int scsi_queue_work(struct Scsi_Host *shost, struct work_struct *work)
 487 {
 488         if (unlikely(!shost->work_q)) {
 489                 printk(KERN_ERR
 490                         "ERROR: Scsi host '%s' attempted to queue scsi-work, "
 491                         "when no workqueue created.\n", shost->hostt->name);
 492                 dump_stack();
 493
 494                 return -EINVAL;
 495         }
 496
 497         return queue_work(shost->work_q, work);
 498 }
 499 EXPORT_SYMBOL_GPL(scsi_queue_work);
 500
 501 /**
 502  * scsi_flush_work - Flush a Scsi_Host's workqueue.
 503  * @shost:      Pointer to Scsi_Host.
 504  **/
 505 void scsi_flush_work(struct Scsi_Host *shost)
 506 {
 507         if (!shost->work_q) {
 508                 printk(KERN_ERR
 509                         "ERROR: Scsi host '%s' attempted to flush scsi-work, "
 510                         "when no workqueue created.\n", shost->hostt->name);
 511                 dump_stack();
 512                 return;
 513         }
 514
 515         flush_workqueue(shost->work_q);
 516 }
 517 EXPORT_SYMBOL_GPL(scsi_flush_work);