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