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