drivers/ata/pata_parport/pata_parport.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright 2023 Ondrej Zary
   4  * based on paride.c by Grant R. Guenther <grant@torque.net>
   5  */
   6 #include <linux/kernel.h>
   7 #include <linux/module.h>
   8 #include <linux/parport.h>
   9 #include "pata_parport.h"
  10
  11 #define DRV_NAME "pata_parport"
  12
  13 static DEFINE_IDR(parport_list);
  14 static DEFINE_IDR(protocols);
  15 static DEFINE_IDA(pata_parport_bus_dev_ids);
  16 static DEFINE_MUTEX(pi_mutex);
  17
  18 static bool probe = true;
  19 module_param(probe, bool, 0644);
  20 MODULE_PARM_DESC(probe, "Enable automatic device probing (0=off, 1=on [default])");
  21
  22 /*
  23  * libata drivers cannot sleep so this driver claims parport before activating
  24  * the ata host and keeps it claimed (and protocol connected) until the ata
  25  * host is removed. Unfortunately, this means that you cannot use any chained
  26  * devices (neither other pata_parport devices nor a printer).
  27  */
  28 static void pi_connect(struct pi_adapter *pi)
  29 {
  30         parport_claim_or_block(pi->pardev);
  31         pi->proto->connect(pi);
  32 }
  33
  34 static void pi_disconnect(struct pi_adapter *pi)
  35 {
  36         pi->proto->disconnect(pi);
  37         parport_release(pi->pardev);
  38 }
  39
  40 static void pata_parport_dev_select(struct ata_port *ap, unsigned int device)
  41 {
  42         struct pi_adapter *pi = ap->host->private_data;
  43         u8 tmp;
  44
  45         if (device == 0)
  46                 tmp = ATA_DEVICE_OBS;
  47         else
  48                 tmp = ATA_DEVICE_OBS | ATA_DEV1;
  49
  50         pi->proto->write_regr(pi, 0, ATA_REG_DEVICE, tmp);
  51         ata_sff_pause(ap);
  52 }
  53
  54 static void pata_parport_set_devctl(struct ata_port *ap, u8 ctl)
  55 {
  56         struct pi_adapter *pi = ap->host->private_data;
  57
  58         pi->proto->write_regr(pi, 1, 6, ctl);
  59 }
  60
  61 static bool pata_parport_devchk(struct ata_port *ap, unsigned int device)
  62 {
  63         struct pi_adapter *pi = ap->host->private_data;
  64         u8 nsect, lbal;
  65
  66         pata_parport_dev_select(ap, device);
  67
  68         pi->proto->write_regr(pi, 0, ATA_REG_NSECT, 0x55);
  69         pi->proto->write_regr(pi, 0, ATA_REG_LBAL, 0xaa);
  70
  71         pi->proto->write_regr(pi, 0, ATA_REG_NSECT, 0xaa);
  72         pi->proto->write_regr(pi, 0, ATA_REG_LBAL, 0x55);
  73
  74         pi->proto->write_regr(pi, 0, ATA_REG_NSECT, 0x55);
  75         pi->proto->write_regr(pi, 0, ATA_REG_LBAL, 0xaa);
  76
  77         nsect = pi->proto->read_regr(pi, 0, ATA_REG_NSECT);
  78         lbal = pi->proto->read_regr(pi, 0, ATA_REG_LBAL);
  79
  80         return (nsect == 0x55) && (lbal == 0xaa);
  81 }
  82
  83 static int pata_parport_wait_after_reset(struct ata_link *link,
  84                                          unsigned int devmask,
  85                                          unsigned long deadline)
  86 {
  87         struct ata_port *ap = link->ap;
  88         struct pi_adapter *pi = ap->host->private_data;
  89         unsigned int dev0 = devmask & (1 << 0);
  90         unsigned int dev1 = devmask & (1 << 1);
  91         int rc, ret = 0;
  92
  93         ata_msleep(ap, ATA_WAIT_AFTER_RESET);
  94
  95         /* always check readiness of the master device */
  96         rc = ata_sff_wait_ready(link, deadline);
  97         if (rc) {
  98                 /*
  99                  * some adapters return bogus values if master device is not
 100                  * present, so don't abort now if a slave device is present
 101                  */
 102                 if (!dev1)
 103                         return rc;
 104                 ret = -ENODEV;
 105         }
 106
 107         /*
 108          * if device 1 was found in ata_devchk, wait for register
 109          * access briefly, then wait for BSY to clear.
 110          */
 111         if (dev1) {
 112                 int i;
 113
 114                 pata_parport_dev_select(ap, 1);
 115
 116                 /*
 117                  * Wait for register access.  Some ATAPI devices fail
 118                  * to set nsect/lbal after reset, so don't waste too
 119                  * much time on it.  We're gonna wait for !BSY anyway.
 120                  */
 121                 for (i = 0; i < 2; i++) {
 122                         u8 nsect, lbal;
 123
 124                         nsect = pi->proto->read_regr(pi, 0, ATA_REG_NSECT);
 125                         lbal = pi->proto->read_regr(pi, 0, ATA_REG_LBAL);
 126                         if (nsect == 1 && lbal == 1)
 127                                 break;
 128                         /* give drive a breather */
 129                         ata_msleep(ap, 50);
 130                 }
 131
 132                 rc = ata_sff_wait_ready(link, deadline);
 133                 if (rc) {
 134                         if (rc != -ENODEV)
 135                                 return rc;
 136                         ret = rc;
 137                 }
 138         }
 139
 140         pata_parport_dev_select(ap, 0);
 141         if (dev1)
 142                 pata_parport_dev_select(ap, 1);
 143         if (dev0)
 144                 pata_parport_dev_select(ap, 0);
 145
 146         return ret;
 147 }
 148
 149 static int pata_parport_bus_softreset(struct ata_port *ap, unsigned int devmask,
 150                                       unsigned long deadline)
 151 {
 152         struct pi_adapter *pi = ap->host->private_data;
 153
 154         /* software reset.  causes dev0 to be selected */
 155         pi->proto->write_regr(pi, 1, 6, ap->ctl);
 156         udelay(20);
 157         pi->proto->write_regr(pi, 1, 6, ap->ctl | ATA_SRST);
 158         udelay(20);
 159         pi->proto->write_regr(pi, 1, 6, ap->ctl);
 160         ap->last_ctl = ap->ctl;
 161
 162         /* wait the port to become ready */
 163         return pata_parport_wait_after_reset(&ap->link, devmask, deadline);
 164 }
 165
 166 static int pata_parport_softreset(struct ata_link *link, unsigned int *classes,
 167                                   unsigned long deadline)
 168 {
 169         struct ata_port *ap = link->ap;
 170         unsigned int devmask = 0;
 171         int rc;
 172         u8 err;
 173
 174         /* determine if device 0/1 are present */
 175         if (pata_parport_devchk(ap, 0))
 176                 devmask |= (1 << 0);
 177         if (pata_parport_devchk(ap, 1))
 178                 devmask |= (1 << 1);
 179
 180         /* select device 0 again */
 181         pata_parport_dev_select(ap, 0);
 182
 183         /* issue bus reset */
 184         rc = pata_parport_bus_softreset(ap, devmask, deadline);
 185         if (rc && rc != -ENODEV) {
 186                 ata_link_err(link, "SRST failed (errno=%d)\n", rc);
 187                 return rc;
 188         }
 189
 190         /* determine by signature whether we have ATA or ATAPI devices */
 191         classes[0] = ata_sff_dev_classify(&link->device[0],
 192                                           devmask & (1 << 0), &err);
 193         if (err != 0x81)
 194                 classes[1] = ata_sff_dev_classify(&link->device[1],
 195                                                   devmask & (1 << 1), &err);
 196
 197         return 0;
 198 }
 199
 200 static u8 pata_parport_check_status(struct ata_port *ap)
 201 {
 202         struct pi_adapter *pi = ap->host->private_data;
 203
 204         return pi->proto->read_regr(pi, 0, ATA_REG_STATUS);
 205 }
 206
 207 static u8 pata_parport_check_altstatus(struct ata_port *ap)
 208 {
 209         struct pi_adapter *pi = ap->host->private_data;
 210
 211         return pi->proto->read_regr(pi, 1, 6);
 212 }
 213
 214 static void pata_parport_tf_load(struct ata_port *ap,
 215                                  const struct ata_taskfile *tf)
 216 {
 217         struct pi_adapter *pi = ap->host->private_data;
 218
 219         if (tf->ctl != ap->last_ctl) {
 220                 pi->proto->write_regr(pi, 1, 6, tf->ctl);
 221                 ap->last_ctl = tf->ctl;
 222                 ata_wait_idle(ap);
 223         }
 224
 225         if (tf->flags & ATA_TFLAG_ISADDR) {
 226                 if (tf->flags & ATA_TFLAG_LBA48) {
 227                         pi->proto->write_regr(pi, 0, ATA_REG_FEATURE,
 228                                               tf->hob_feature);
 229                         pi->proto->write_regr(pi, 0, ATA_REG_NSECT,
 230                                               tf->hob_nsect);
 231                         pi->proto->write_regr(pi, 0, ATA_REG_LBAL,
 232                                               tf->hob_lbal);
 233                         pi->proto->write_regr(pi, 0, ATA_REG_LBAM,
 234                                               tf->hob_lbam);
 235                         pi->proto->write_regr(pi, 0, ATA_REG_LBAH,
 236                                               tf->hob_lbah);
 237                 }
 238                 pi->proto->write_regr(pi, 0, ATA_REG_FEATURE, tf->feature);
 239                 pi->proto->write_regr(pi, 0, ATA_REG_NSECT, tf->nsect);
 240                 pi->proto->write_regr(pi, 0, ATA_REG_LBAL, tf->lbal);
 241                 pi->proto->write_regr(pi, 0, ATA_REG_LBAM, tf->lbam);
 242                 pi->proto->write_regr(pi, 0, ATA_REG_LBAH, tf->lbah);
 243         }
 244
 245         if (tf->flags & ATA_TFLAG_DEVICE)
 246                 pi->proto->write_regr(pi, 0, ATA_REG_DEVICE, tf->device);
 247
 248         ata_wait_idle(ap);
 249 }
 250
 251 static void pata_parport_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
 252 {
 253         struct pi_adapter *pi = ap->host->private_data;
 254
 255         tf->status = pi->proto->read_regr(pi, 0, ATA_REG_STATUS);
 256         tf->error = pi->proto->read_regr(pi, 0, ATA_REG_ERR);
 257         tf->nsect = pi->proto->read_regr(pi, 0, ATA_REG_NSECT);
 258         tf->lbal = pi->proto->read_regr(pi, 0, ATA_REG_LBAL);
 259         tf->lbam = pi->proto->read_regr(pi, 0, ATA_REG_LBAM);
 260         tf->lbah = pi->proto->read_regr(pi, 0, ATA_REG_LBAH);
 261         tf->device = pi->proto->read_regr(pi, 0, ATA_REG_DEVICE);
 262
 263         if (tf->flags & ATA_TFLAG_LBA48) {
 264                 pi->proto->write_regr(pi, 1, 6, tf->ctl | ATA_HOB);
 265                 tf->hob_feature = pi->proto->read_regr(pi, 0, ATA_REG_ERR);
 266                 tf->hob_nsect = pi->proto->read_regr(pi, 0, ATA_REG_NSECT);
 267                 tf->hob_lbal = pi->proto->read_regr(pi, 0, ATA_REG_LBAL);
 268                 tf->hob_lbam = pi->proto->read_regr(pi, 0, ATA_REG_LBAM);
 269                 tf->hob_lbah = pi->proto->read_regr(pi, 0, ATA_REG_LBAH);
 270                 pi->proto->write_regr(pi, 1, 6, tf->ctl);
 271                 ap->last_ctl = tf->ctl;
 272         }
 273 }
 274
 275 static void pata_parport_exec_command(struct ata_port *ap,
 276                                       const struct ata_taskfile *tf)
 277 {
 278         struct pi_adapter *pi = ap->host->private_data;
 279
 280         pi->proto->write_regr(pi, 0, ATA_REG_CMD, tf->command);
 281         ata_sff_pause(ap);
 282 }
 283
 284 static unsigned int pata_parport_data_xfer(struct ata_queued_cmd *qc,
 285                                 unsigned char *buf, unsigned int buflen, int rw)
 286 {
 287         struct ata_port *ap = qc->dev->link->ap;
 288         struct pi_adapter *pi = ap->host->private_data;
 289
 290         if (rw == READ)
 291                 pi->proto->read_block(pi, buf, buflen);
 292         else
 293                 pi->proto->write_block(pi, buf, buflen);
 294
 295         return buflen;
 296 }
 297
 298 static void pata_parport_drain_fifo(struct ata_queued_cmd *qc)
 299 {
 300         int count;
 301         struct ata_port *ap;
 302         struct pi_adapter *pi;
 303         char junk[2];
 304
 305         /* We only need to flush incoming data when a command was running */
 306         if (qc == NULL || qc->dma_dir == DMA_TO_DEVICE)
 307                 return;
 308
 309         ap = qc->ap;
 310         pi = ap->host->private_data;
 311         /* Drain up to 64K of data before we give up this recovery method */
 312         for (count = 0; (pata_parport_check_status(ap) & ATA_DRQ)
 313                                                 && count < 65536; count += 2) {
 314                 pi->proto->read_block(pi, junk, 2);
 315         }
 316
 317         if (count)
 318                 ata_port_dbg(ap, "drained %d bytes to clear DRQ\n", count);
 319 }
 320
 321 static struct ata_port_operations pata_parport_port_ops = {
 322         .inherits               = &ata_sff_port_ops,
 323
 324         .softreset              = pata_parport_softreset,
 325         .hardreset              = NULL,
 326
 327         .sff_dev_select         = pata_parport_dev_select,
 328         .sff_set_devctl         = pata_parport_set_devctl,
 329         .sff_check_status       = pata_parport_check_status,
 330         .sff_check_altstatus    = pata_parport_check_altstatus,
 331         .sff_tf_load            = pata_parport_tf_load,
 332         .sff_tf_read            = pata_parport_tf_read,
 333         .sff_exec_command       = pata_parport_exec_command,
 334         .sff_data_xfer          = pata_parport_data_xfer,
 335         .sff_drain_fifo         = pata_parport_drain_fifo,
 336 };
 337
 338 static const struct ata_port_info pata_parport_port_info = {
 339         .flags          = ATA_FLAG_SLAVE_POSS | ATA_FLAG_PIO_POLLING,
 340         .pio_mask       = ATA_PIO0,
 341         /* No DMA */
 342         .port_ops       = &pata_parport_port_ops,
 343 };
 344
 345 static void pi_release(struct pi_adapter *pi)
 346 {
 347         parport_unregister_device(pi->pardev);
 348         if (pi->proto->release_proto)
 349                 pi->proto->release_proto(pi);
 350         module_put(pi->proto->owner);
 351 }
 352
 353 static int default_test_proto(struct pi_adapter *pi)
 354 {
 355         int j, k;
 356         int e[2] = { 0, 0 };
 357
 358         pi->proto->connect(pi);
 359
 360         for (j = 0; j < 2; j++) {
 361                 pi->proto->write_regr(pi, 0, 6, 0xa0 + j * 0x10);
 362                 for (k = 0; k < 256; k++) {
 363                         pi->proto->write_regr(pi, 0, 2, k ^ 0xaa);
 364                         pi->proto->write_regr(pi, 0, 3, k ^ 0x55);
 365                         if (pi->proto->read_regr(pi, 0, 2) != (k ^ 0xaa))
 366                                 e[j]++;
 367                 }
 368         }
 369         pi->proto->disconnect(pi);
 370
 371         dev_dbg(&pi->dev, "%s: port 0x%x, mode %d, test=(%d,%d)\n",
 372                 pi->proto->name, pi->port, pi->mode, e[0], e[1]);
 373
 374         return e[0] && e[1];    /* not here if both > 0 */
 375 }
 376
 377 static int pi_test_proto(struct pi_adapter *pi)
 378 {
 379         int res;
 380
 381         parport_claim_or_block(pi->pardev);
 382         if (pi->proto->test_proto)
 383                 res = pi->proto->test_proto(pi);
 384         else
 385                 res = default_test_proto(pi);
 386         parport_release(pi->pardev);
 387
 388         return res;
 389 }
 390
 391 static bool pi_probe_mode(struct pi_adapter *pi, int max)
 392 {
 393         int best, range;
 394
 395         if (pi->mode != -1) {
 396                 if (pi->mode >= max)
 397                         return false;
 398                 range = 3;
 399                 if (pi->mode >= pi->proto->epp_first)
 400                         range = 8;
 401                 if (range == 8 && pi->port % 8)
 402                         return false;
 403                 return !pi_test_proto(pi);
 404         }
 405         best = -1;
 406         for (pi->mode = 0; pi->mode < max; pi->mode++) {
 407                 range = 3;
 408                 if (pi->mode >= pi->proto->epp_first)
 409                         range = 8;
 410                 if (range == 8 && pi->port % 8)
 411                         break;
 412                 if (!pi_test_proto(pi))
 413                         best = pi->mode;
 414         }
 415         pi->mode = best;
 416         return best > -1;
 417 }
 418
 419 static bool pi_probe_unit(struct pi_adapter *pi, int unit)
 420 {
 421         int max, s, e;
 422
 423         s = unit;
 424         e = s + 1;
 425
 426         if (s == -1) {
 427                 s = 0;
 428                 e = pi->proto->max_units;
 429         }
 430
 431         if (pi->proto->test_port) {
 432                 parport_claim_or_block(pi->pardev);
 433                 max = pi->proto->test_port(pi);
 434                 parport_release(pi->pardev);
 435         } else {
 436                 max = pi->proto->max_mode;
 437         }
 438
 439         if (pi->proto->probe_unit) {
 440                 parport_claim_or_block(pi->pardev);
 441                 for (pi->unit = s; pi->unit < e; pi->unit++) {
 442                         if (pi->proto->probe_unit(pi)) {
 443                                 parport_release(pi->pardev);
 444                                 return pi_probe_mode(pi, max);
 445                         }
 446                 }
 447                 parport_release(pi->pardev);
 448                 return false;
 449         }
 450
 451         return pi_probe_mode(pi, max);
 452 }
 453
 454 static void pata_parport_dev_release(struct device *dev)
 455 {
 456         struct pi_adapter *pi = container_of(dev, struct pi_adapter, dev);
 457
 458         ida_free(&pata_parport_bus_dev_ids, dev->id);
 459         kfree(pi);
 460 }
 461
 462 static void pata_parport_bus_release(struct device *dev)
 463 {
 464         /* nothing to do here but required to avoid warning on device removal */
 465 }
 466
 467 static struct bus_type pata_parport_bus_type = {
 468         .name = DRV_NAME,
 469 };
 470
 471 static struct device pata_parport_bus = {
 472         .init_name = DRV_NAME,
 473         .release = pata_parport_bus_release,
 474 };
 475
 476 static const struct scsi_host_template pata_parport_sht = {
 477         PATA_PARPORT_SHT("pata_parport")
 478 };
 479
 480 struct pi_device_match {
 481         struct parport *parport;
 482         struct pi_protocol *proto;
 483 };
 484
 485 static int pi_find_dev(struct device *dev, void *data)
 486 {
 487         struct pi_adapter *pi = container_of(dev, struct pi_adapter, dev);
 488         struct pi_device_match *match = data;
 489
 490         return pi->pardev->port == match->parport && pi->proto == match->proto;
 491 }
 492
 493 static struct pi_adapter *pi_init_one(struct parport *parport,
 494                         struct pi_protocol *pr, int mode, int unit, int delay)
 495 {
 496         struct pardev_cb par_cb = { };
 497         const struct ata_port_info *ppi[] = { &pata_parport_port_info };
 498         struct ata_host *host;
 499         struct pi_adapter *pi;
 500         struct pi_device_match match = { .parport = parport, .proto = pr };
 501         int id;
 502
 503         /*
 504          * Abort if there's a device already registered on the same parport
 505          * using the same protocol.
 506          */
 507         if (bus_for_each_dev(&pata_parport_bus_type, NULL, &match, pi_find_dev))
 508                 return NULL;
 509
 510         id = ida_alloc(&pata_parport_bus_dev_ids, GFP_KERNEL);
 511         if (id < 0)
 512                 return NULL;
 513
 514         pi = kzalloc(sizeof(struct pi_adapter), GFP_KERNEL);
 515         if (!pi) {
 516                 ida_free(&pata_parport_bus_dev_ids, id);
 517                 return NULL;
 518         }
 519
 520         /* set up pi->dev before pi_probe_unit() so it can use dev_printk() */
 521         pi->dev.parent = &pata_parport_bus;
 522         pi->dev.bus = &pata_parport_bus_type;
 523         pi->dev.driver = &pr->driver;
 524         pi->dev.release = pata_parport_dev_release;
 525         pi->dev.id = id;
 526         dev_set_name(&pi->dev, "pata_parport.%u", pi->dev.id);
 527         if (device_register(&pi->dev)) {
 528                 put_device(&pi->dev);
 529                 /* pata_parport_dev_release will do ida_free(dev->id) and kfree(pi) */
 530                 return NULL;
 531         }
 532
 533         pi->proto = pr;
 534
 535         if (!try_module_get(pi->proto->owner))
 536                 goto out_unreg_dev;
 537         if (pi->proto->init_proto && pi->proto->init_proto(pi) < 0)
 538                 goto out_module_put;
 539
 540         pi->delay = (delay == -1) ? pi->proto->default_delay : delay;
 541         pi->mode = mode;
 542         pi->port = parport->base;
 543
 544         par_cb.private = pi;
 545         pi->pardev = parport_register_dev_model(parport, DRV_NAME, &par_cb, id);
 546         if (!pi->pardev)
 547                 goto out_module_put;
 548
 549         if (!pi_probe_unit(pi, unit)) {
 550                 dev_info(&pi->dev, "Adapter not found\n");
 551                 goto out_unreg_parport;
 552         }
 553
 554         pi->proto->log_adapter(pi);
 555
 556         host = ata_host_alloc_pinfo(&pi->pardev->dev, ppi, 1);
 557         if (!host)
 558                 goto out_unreg_parport;
 559         dev_set_drvdata(&pi->dev, host);
 560         host->private_data = pi;
 561
 562         ata_port_desc(host->ports[0], "port %s", pi->pardev->port->name);
 563         ata_port_desc(host->ports[0], "protocol %s", pi->proto->name);
 564
 565         pi_connect(pi);
 566         if (ata_host_activate(host, 0, NULL, 0, &pata_parport_sht))
 567                 goto out_disconnect;
 568
 569         return pi;
 570
 571 out_disconnect:
 572         pi_disconnect(pi);
 573 out_unreg_parport:
 574         parport_unregister_device(pi->pardev);
 575         if (pi->proto->release_proto)
 576                 pi->proto->release_proto(pi);
 577 out_module_put:
 578         module_put(pi->proto->owner);
 579 out_unreg_dev:
 580         device_unregister(&pi->dev);
 581         /* pata_parport_dev_release will do ida_free(dev->id) and kfree(pi) */
 582         return NULL;
 583 }
 584
 585 int pata_parport_register_driver(struct pi_protocol *pr)
 586 {
 587         int error;
 588         struct parport *parport;
 589         int port_num;
 590
 591         pr->driver.bus = &pata_parport_bus_type;
 592         pr->driver.name = pr->name;
 593         error = driver_register(&pr->driver);
 594         if (error)
 595                 return error;
 596
 597         mutex_lock(&pi_mutex);
 598         error = idr_alloc(&protocols, pr, 0, 0, GFP_KERNEL);
 599         if (error < 0) {
 600                 driver_unregister(&pr->driver);
 601                 mutex_unlock(&pi_mutex);
 602                 return error;
 603         }
 604
 605         pr_info("pata_parport: protocol %s registered\n", pr->name);
 606
 607         if (probe) {
 608                 /* probe all parports using this protocol */
 609                 idr_for_each_entry(&parport_list, parport, port_num)
 610                         pi_init_one(parport, pr, -1, -1, -1);
 611         }
 612         mutex_unlock(&pi_mutex);
 613
 614         return 0;
 615 }
 616 EXPORT_SYMBOL_GPL(pata_parport_register_driver);
 617
 618 void pata_parport_unregister_driver(struct pi_protocol *pr)
 619 {
 620         struct pi_protocol *pr_iter;
 621         int id = -1;
 622
 623         mutex_lock(&pi_mutex);
 624         idr_for_each_entry(&protocols, pr_iter, id) {
 625                 if (pr_iter == pr)
 626                         break;
 627         }
 628         idr_remove(&protocols, id);
 629         mutex_unlock(&pi_mutex);
 630         driver_unregister(&pr->driver);
 631 }
 632 EXPORT_SYMBOL_GPL(pata_parport_unregister_driver);
 633
 634 static ssize_t new_device_store(const struct bus_type *bus, const char *buf, size_t count)
 635 {
 636         char port[12] = "auto";
 637         char protocol[8] = "auto";
 638         int mode = -1, unit = -1, delay = -1;
 639         struct pi_protocol *pr, *pr_wanted;
 640         struct device_driver *drv;
 641         struct parport *parport;
 642         int port_num, port_wanted, pr_num;
 643         bool ok = false;
 644
 645         if (sscanf(buf, "%11s %7s %d %d %d",
 646                         port, protocol, &mode, &unit, &delay) < 1)
 647                 return -EINVAL;
 648
 649         if (sscanf(port, "parport%u", &port_wanted) < 1) {
 650                 if (strcmp(port, "auto")) {
 651                         pr_err("invalid port name %s\n", port);
 652                         return -EINVAL;
 653                 }
 654                 port_wanted = -1;
 655         }
 656
 657         drv = driver_find(protocol, &pata_parport_bus_type);
 658         if (!drv) {
 659                 if (strcmp(protocol, "auto")) {
 660                         pr_err("protocol %s not found\n", protocol);
 661                         return -EINVAL;
 662                 }
 663                 pr_wanted = NULL;
 664         } else {
 665                 pr_wanted = container_of(drv, struct pi_protocol, driver);
 666         }
 667
 668         mutex_lock(&pi_mutex);
 669         /* walk all parports */
 670         idr_for_each_entry(&parport_list, parport, port_num) {
 671                 if (port_num == port_wanted || port_wanted == -1) {
 672                         parport = parport_find_number(port_num);
 673                         if (!parport) {
 674                                 pr_err("no such port %s\n", port);
 675                                 mutex_unlock(&pi_mutex);
 676                                 return -ENODEV;
 677                         }
 678                         /* walk all protocols */
 679                         idr_for_each_entry(&protocols, pr, pr_num) {
 680                                 if (pr == pr_wanted || !pr_wanted)
 681                                         if (pi_init_one(parport, pr, mode, unit,
 682                                                         delay))
 683                                                 ok = true;
 684                         }
 685                         parport_put_port(parport);
 686                 }
 687         }
 688         mutex_unlock(&pi_mutex);
 689         if (!ok)
 690                 return -ENODEV;
 691
 692         return count;
 693 }
 694 static BUS_ATTR_WO(new_device);
 695
 696 static void pi_remove_one(struct device *dev)
 697 {
 698         struct ata_host *host = dev_get_drvdata(dev);
 699         struct pi_adapter *pi = host->private_data;
 700
 701         ata_host_detach(host);
 702         pi_disconnect(pi);
 703         pi_release(pi);
 704         device_unregister(dev);
 705         /* pata_parport_dev_release will do ida_free(dev->id) and kfree(pi) */
 706 }
 707
 708 static ssize_t delete_device_store(const struct bus_type *bus, const char *buf, size_t count)
 709 {
 710         struct device *dev;
 711
 712         mutex_lock(&pi_mutex);
 713         dev = bus_find_device_by_name(bus, NULL, buf);
 714         if (!dev) {
 715                 mutex_unlock(&pi_mutex);
 716                 return -ENODEV;
 717         }
 718
 719         pi_remove_one(dev);
 720         put_device(dev);
 721         mutex_unlock(&pi_mutex);
 722
 723         return count;
 724 }
 725 static BUS_ATTR_WO(delete_device);
 726
 727 static void pata_parport_attach(struct parport *port)
 728 {
 729         struct pi_protocol *pr;
 730         int pr_num, id;
 731
 732         mutex_lock(&pi_mutex);
 733         id = idr_alloc(&parport_list, port, port->number, port->number,
 734                        GFP_KERNEL);
 735         if (id < 0) {
 736                 mutex_unlock(&pi_mutex);
 737                 return;
 738         }
 739
 740         if (probe) {
 741                 /* probe this port using all protocols */
 742                 idr_for_each_entry(&protocols, pr, pr_num)
 743                         pi_init_one(port, pr, -1, -1, -1);
 744         }
 745         mutex_unlock(&pi_mutex);
 746 }
 747
 748 static int pi_remove_port(struct device *dev, void *p)
 749 {
 750         struct ata_host *host = dev_get_drvdata(dev);
 751         struct pi_adapter *pi = host->private_data;
 752
 753         if (pi->pardev->port == p)
 754                 pi_remove_one(dev);
 755
 756         return 0;
 757 }
 758
 759 static void pata_parport_detach(struct parport *port)
 760 {
 761         mutex_lock(&pi_mutex);
 762         bus_for_each_dev(&pata_parport_bus_type, NULL, port, pi_remove_port);
 763         idr_remove(&parport_list, port->number);
 764         mutex_unlock(&pi_mutex);
 765 }
 766
 767 static struct parport_driver pata_parport_driver = {
 768         .name = DRV_NAME,
 769         .match_port = pata_parport_attach,
 770         .detach = pata_parport_detach,
 771         .devmodel = true,
 772 };
 773
 774 static __init int pata_parport_init(void)
 775 {
 776         int error;
 777
 778         error = bus_register(&pata_parport_bus_type);
 779         if (error) {
 780                 pr_err("failed to register pata_parport bus, error: %d\n", error);
 781                 return error;
 782         }
 783
 784         error = device_register(&pata_parport_bus);
 785         if (error) {
 786                 pr_err("failed to register pata_parport bus, error: %d\n", error);
 787                 goto out_unregister_bus;
 788         }
 789
 790         error = bus_create_file(&pata_parport_bus_type, &bus_attr_new_device);
 791         if (error) {
 792                 pr_err("unable to create sysfs file, error: %d\n", error);
 793                 goto out_unregister_dev;
 794         }
 795
 796         error = bus_create_file(&pata_parport_bus_type, &bus_attr_delete_device);
 797         if (error) {
 798                 pr_err("unable to create sysfs file, error: %d\n", error);
 799                 goto out_remove_new;
 800         }
 801
 802         error = parport_register_driver(&pata_parport_driver);
 803         if (error) {
 804                 pr_err("unable to register parport driver, error: %d\n", error);
 805                 goto out_remove_del;
 806         }
 807
 808         return 0;
 809
 810 out_remove_del:
 811         bus_remove_file(&pata_parport_bus_type, &bus_attr_delete_device);
 812 out_remove_new:
 813         bus_remove_file(&pata_parport_bus_type, &bus_attr_new_device);
 814 out_unregister_dev:
 815         device_unregister(&pata_parport_bus);
 816 out_unregister_bus:
 817         bus_unregister(&pata_parport_bus_type);
 818         return error;
 819 }
 820
 821 static __exit void pata_parport_exit(void)
 822 {
 823         parport_unregister_driver(&pata_parport_driver);
 824         bus_remove_file(&pata_parport_bus_type, &bus_attr_new_device);
 825         bus_remove_file(&pata_parport_bus_type, &bus_attr_delete_device);
 826         device_unregister(&pata_parport_bus);
 827         bus_unregister(&pata_parport_bus_type);
 828 }
 829
 830 MODULE_AUTHOR("Ondrej Zary");
 831 MODULE_DESCRIPTION("driver for parallel port ATA adapters");
 832 MODULE_LICENSE("GPL");
 833 MODULE_ALIAS("paride");
 834
 835 module_init(pata_parport_init);
 836 module_exit(pata_parport_exit);