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 ida_free(&pata_parport_bus_dev_ids, dev->id); 385 kfree(pi); 386 } 387 388 static void pata_parport_bus_release(struct device *dev) 389 { 390 /* nothing to do here but required to avoid warning on device removal */ 391 } 392 393 static struct bus_type pata_parport_bus_type = { 394 .name = DRV_NAME, 395 }; 396 397 static struct device pata_parport_bus = { 398 .init_name = DRV_NAME, 399 .release = pata_parport_bus_release, 400 }; 401 402 static struct scsi_host_template pata_parport_sht = { 403 PATA_PARPORT_SHT("pata_parport") 404 }; 405 406 struct pi_device_match { 407 struct parport *parport; 408 struct pi_protocol *proto; 409 }; 410 411 static int pi_find_dev(struct device *dev, void *data) 412 { 413 struct pi_adapter *pi = container_of(dev, struct pi_adapter, dev); 414 struct pi_device_match *match = data; 415 416 return pi->pardev->port == match->parport && pi->proto == match->proto; 417 } 418 419 static struct pi_adapter *pi_init_one(struct parport *parport, 420 struct pi_protocol *pr, int mode, int unit, int delay) 421 { 422 struct pardev_cb par_cb = { }; 423 char scratch[512]; 424 const struct ata_port_info *ppi[] = { &pata_parport_port_info }; 425 struct ata_host *host; 426 struct pi_adapter *pi; 427 struct pi_device_match match = { .parport = parport, .proto = pr }; 428 int id; 429 430 /* 431 * Abort if there's a device already registered on the same parport 432 * using the same protocol. 433 */ 434 if (bus_for_each_dev(&pata_parport_bus_type, NULL, &match, pi_find_dev)) 435 return NULL; 436 437 id = ida_alloc(&pata_parport_bus_dev_ids, GFP_KERNEL); 438 if (id < 0) 439 return NULL; 440 441 pi = kzalloc(sizeof(struct pi_adapter), GFP_KERNEL); 442 if (!pi) { 443 ida_free(&pata_parport_bus_dev_ids, id); 444 return NULL; 445 } 446 447 /* set up pi->dev before pi_probe_unit() so it can use dev_printk() */ 448 pi->dev.parent = &pata_parport_bus; 449 pi->dev.bus = &pata_parport_bus_type; 450 pi->dev.driver = &pr->driver; 451 pi->dev.release = pata_parport_dev_release; 452 pi->dev.id = id; 453 dev_set_name(&pi->dev, "pata_parport.%u", pi->dev.id); 454 if (device_register(&pi->dev)) { 455 put_device(&pi->dev); 456 /* pata_parport_dev_release will do ida_free(dev->id) and kfree(pi) */ 457 return NULL; 458 } 459 460 pi->proto = pr; 461 462 if (!try_module_get(pi->proto->owner)) 463 goto out_unreg_dev; 464 if (pi->proto->init_proto && pi->proto->init_proto(pi) < 0) 465 goto out_module_put; 466 467 pi->delay = (delay == -1) ? pi->proto->default_delay : delay; 468 pi->mode = mode; 469 pi->port = parport->base; 470 471 par_cb.private = pi; 472 pi->pardev = parport_register_dev_model(parport, DRV_NAME, &par_cb, id); 473 if (!pi->pardev) 474 goto out_module_put; 475 476 if (!pi_probe_unit(pi, unit, scratch)) { 477 dev_info(&pi->dev, "Adapter not found\n"); 478 goto out_unreg_parport; 479 } 480 481 pi->proto->log_adapter(pi, scratch, 1); 482 483 host = ata_host_alloc_pinfo(&pi->pardev->dev, ppi, 1); 484 if (!host) 485 goto out_unreg_parport; 486 dev_set_drvdata(&pi->dev, host); 487 host->private_data = pi; 488 489 ata_port_desc(host->ports[0], "port %s", pi->pardev->port->name); 490 ata_port_desc(host->ports[0], "protocol %s", pi->proto->name); 491 492 pi_connect(pi); 493 if (ata_host_activate(host, 0, NULL, 0, &pata_parport_sht)) 494 goto out_disconnect; 495 496 return pi; 497 498 out_disconnect: 499 pi_disconnect(pi); 500 out_unreg_parport: 501 parport_unregister_device(pi->pardev); 502 if (pi->proto->release_proto) 503 pi->proto->release_proto(pi); 504 out_module_put: 505 module_put(pi->proto->owner); 506 out_unreg_dev: 507 device_unregister(&pi->dev); 508 /* pata_parport_dev_release will do ida_free(dev->id) and kfree(pi) */ 509 return NULL; 510 } 511 512 int pata_parport_register_driver(struct pi_protocol *pr) 513 { 514 int error; 515 struct parport *parport; 516 int port_num; 517 518 pr->driver.bus = &pata_parport_bus_type; 519 pr->driver.name = pr->name; 520 error = driver_register(&pr->driver); 521 if (error) 522 return error; 523 524 mutex_lock(&pi_mutex); 525 error = idr_alloc(&protocols, pr, 0, 0, GFP_KERNEL); 526 if (error < 0) { 527 driver_unregister(&pr->driver); 528 mutex_unlock(&pi_mutex); 529 return error; 530 } 531 532 pr_info("pata_parport: protocol %s registered\n", pr->name); 533 534 if (probe) { 535 /* probe all parports using this protocol */ 536 idr_for_each_entry(&parport_list, parport, port_num) 537 pi_init_one(parport, pr, -1, 0, -1); 538 } 539 mutex_unlock(&pi_mutex); 540 541 return 0; 542 } 543 EXPORT_SYMBOL_GPL(pata_parport_register_driver); 544 545 void pata_parport_unregister_driver(struct pi_protocol *pr) 546 { 547 struct pi_protocol *pr_iter; 548 int id = -1; 549 550 mutex_lock(&pi_mutex); 551 idr_for_each_entry(&protocols, pr_iter, id) { 552 if (pr_iter == pr) 553 break; 554 } 555 idr_remove(&protocols, id); 556 mutex_unlock(&pi_mutex); 557 driver_unregister(&pr->driver); 558 } 559 EXPORT_SYMBOL_GPL(pata_parport_unregister_driver); 560 561 static ssize_t new_device_store(struct bus_type *bus, const char *buf, 562 size_t count) 563 { 564 char port[12] = "auto"; 565 char protocol[8] = "auto"; 566 int mode = -1, unit = -1, delay = -1; 567 struct pi_protocol *pr, *pr_wanted; 568 struct device_driver *drv; 569 struct parport *parport; 570 int port_num, port_wanted, pr_num; 571 bool ok = false; 572 573 if (sscanf(buf, "%11s %7s %d %d %d", 574 port, protocol, &mode, &unit, &delay) < 1) 575 return -EINVAL; 576 577 if (sscanf(port, "parport%u", &port_wanted) < 1) { 578 if (strcmp(port, "auto")) { 579 pr_err("invalid port name %s\n", port); 580 return -EINVAL; 581 } 582 port_wanted = -1; 583 } 584 585 drv = driver_find(protocol, &pata_parport_bus_type); 586 if (!drv) { 587 if (strcmp(protocol, "auto")) { 588 pr_err("protocol %s not found\n", protocol); 589 return -EINVAL; 590 } 591 pr_wanted = NULL; 592 } else { 593 pr_wanted = container_of(drv, struct pi_protocol, driver); 594 } 595 596 mutex_lock(&pi_mutex); 597 /* walk all parports */ 598 idr_for_each_entry(&parport_list, parport, port_num) { 599 if (port_num == port_wanted || port_wanted == -1) { 600 parport = parport_find_number(port_num); 601 if (!parport) { 602 pr_err("no such port %s\n", port); 603 mutex_unlock(&pi_mutex); 604 return -ENODEV; 605 } 606 /* walk all protocols */ 607 idr_for_each_entry(&protocols, pr, pr_num) { 608 if (pr == pr_wanted || !pr_wanted) 609 if (pi_init_one(parport, pr, mode, unit, 610 delay)) 611 ok = true; 612 } 613 parport_put_port(parport); 614 } 615 } 616 mutex_unlock(&pi_mutex); 617 if (!ok) 618 return -ENODEV; 619 620 return count; 621 } 622 static BUS_ATTR_WO(new_device); 623 624 static void pi_remove_one(struct device *dev) 625 { 626 struct ata_host *host = dev_get_drvdata(dev); 627 struct pi_adapter *pi = host->private_data; 628 629 ata_host_detach(host); 630 pi_disconnect(pi); 631 pi_release(pi); 632 device_unregister(dev); 633 /* pata_parport_dev_release will do ida_free(dev->id) and kfree(pi) */ 634 } 635 636 static ssize_t delete_device_store(struct bus_type *bus, const char *buf, 637 size_t count) 638 { 639 struct device *dev; 640 641 mutex_lock(&pi_mutex); 642 dev = bus_find_device_by_name(bus, NULL, buf); 643 if (!dev) { 644 mutex_unlock(&pi_mutex); 645 return -ENODEV; 646 } 647 648 pi_remove_one(dev); 649 put_device(dev); 650 mutex_unlock(&pi_mutex); 651 652 return count; 653 } 654 static BUS_ATTR_WO(delete_device); 655 656 static void pata_parport_attach(struct parport *port) 657 { 658 struct pi_protocol *pr; 659 int pr_num, id; 660 661 mutex_lock(&pi_mutex); 662 id = idr_alloc(&parport_list, port, port->number, port->number, 663 GFP_KERNEL); 664 if (id < 0) { 665 mutex_unlock(&pi_mutex); 666 return; 667 } 668 669 if (probe) { 670 /* probe this port using all protocols */ 671 idr_for_each_entry(&protocols, pr, pr_num) 672 pi_init_one(port, pr, -1, 0, -1); 673 } 674 mutex_unlock(&pi_mutex); 675 } 676 677 static int pi_remove_port(struct device *dev, void *p) 678 { 679 struct ata_host *host = dev_get_drvdata(dev); 680 struct pi_adapter *pi = host->private_data; 681 682 if (pi->pardev->port == p) 683 pi_remove_one(dev); 684 685 return 0; 686 } 687 688 static void pata_parport_detach(struct parport *port) 689 { 690 mutex_lock(&pi_mutex); 691 bus_for_each_dev(&pata_parport_bus_type, NULL, port, pi_remove_port); 692 idr_remove(&parport_list, port->number); 693 mutex_unlock(&pi_mutex); 694 } 695 696 static struct parport_driver pata_parport_driver = { 697 .name = DRV_NAME, 698 .match_port = pata_parport_attach, 699 .detach = pata_parport_detach, 700 .devmodel = true, 701 }; 702 703 static __init int pata_parport_init(void) 704 { 705 int error; 706 707 error = bus_register(&pata_parport_bus_type); 708 if (error) { 709 pr_err("failed to register pata_parport bus, error: %d\n", error); 710 return error; 711 } 712 713 error = device_register(&pata_parport_bus); 714 if (error) { 715 pr_err("failed to register pata_parport bus, error: %d\n", error); 716 goto out_unregister_bus; 717 } 718 719 error = bus_create_file(&pata_parport_bus_type, &bus_attr_new_device); 720 if (error) { 721 pr_err("unable to create sysfs file, error: %d\n", error); 722 goto out_unregister_dev; 723 } 724 725 error = bus_create_file(&pata_parport_bus_type, &bus_attr_delete_device); 726 if (error) { 727 pr_err("unable to create sysfs file, error: %d\n", error); 728 goto out_remove_new; 729 } 730 731 error = parport_register_driver(&pata_parport_driver); 732 if (error) { 733 pr_err("unable to register parport driver, error: %d\n", error); 734 goto out_remove_del; 735 } 736 737 return 0; 738 739 out_remove_del: 740 bus_remove_file(&pata_parport_bus_type, &bus_attr_delete_device); 741 out_remove_new: 742 bus_remove_file(&pata_parport_bus_type, &bus_attr_new_device); 743 out_unregister_dev: 744 device_unregister(&pata_parport_bus); 745 out_unregister_bus: 746 bus_unregister(&pata_parport_bus_type); 747 return error; 748 } 749 750 static __exit void pata_parport_exit(void) 751 { 752 parport_unregister_driver(&pata_parport_driver); 753 bus_remove_file(&pata_parport_bus_type, &bus_attr_new_device); 754 bus_remove_file(&pata_parport_bus_type, &bus_attr_delete_device); 755 device_unregister(&pata_parport_bus); 756 bus_unregister(&pata_parport_bus_type); 757 } 758 759 MODULE_AUTHOR("Ondrej Zary"); 760 MODULE_DESCRIPTION("driver for parallel port ATA adapters"); 761 MODULE_LICENSE("GPL"); 762 MODULE_ALIAS("paride"); 763 764 module_init(pata_parport_init); 765 module_exit(pata_parport_exit); 766