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
13static DEFINE_IDR(parport_list);
14static DEFINE_IDR(protocols);
15static DEFINE_IDA(pata_parport_bus_dev_ids);
16static DEFINE_MUTEX(pi_mutex);
17
18static bool probe = true;
19module_param(probe, bool, 0644);
20MODULE_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 */
28static void pi_connect(struct pi_adapter *pi)
29{
30 parport_claim_or_block(dev: pi->pardev);
31 pi->proto->connect(pi);
32}
33
34static void pi_disconnect(struct pi_adapter *pi)
35{
36 pi->proto->disconnect(pi);
37 parport_release(dev: pi->pardev);
38}
39
40static 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
54static 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
61static 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
83static 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, msecs: 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, device: 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, msecs: 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, device: 0);
141 if (dev1)
142 pata_parport_dev_select(ap, device: 1);
143 if (dev0)
144 pata_parport_dev_select(ap, device: 0);
145
146 return ret;
147}
148
149static 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(link: &ap->link, devmask, deadline);
164}
165
166static 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, device: 0))
176 devmask |= (1 << 0);
177 if (pata_parport_devchk(ap, device: 1))
178 devmask |= (1 << 1);
179
180 /* select device 0 again */
181 pata_parport_dev_select(ap, device: 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(dev: &link->device[0],
192 present: devmask & (1 << 0), r_err: &err);
193 if (err != 0x81)
194 classes[1] = ata_sff_dev_classify(dev: &link->device[1],
195 present: devmask & (1 << 1), r_err: &err);
196
197 return 0;
198}
199
200static 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
207static 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
214static 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
251static 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
275static 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
284static 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
298static 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
321static 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
338static 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
345static void pi_release(struct pi_adapter *pi)
346{
347 parport_unregister_device(dev: pi->pardev);
348 if (pi->proto->release_proto)
349 pi->proto->release_proto(pi);
350 module_put(module: pi->proto->owner);
351}
352
353static 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
377static int pi_test_proto(struct pi_adapter *pi)
378{
379 int res;
380
381 parport_claim_or_block(dev: 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(dev: pi->pardev);
387
388 return res;
389}
390
391static 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
419static 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(dev: pi->pardev);
433 max = pi->proto->test_port(pi);
434 parport_release(dev: pi->pardev);
435 } else {
436 max = pi->proto->max_mode;
437 }
438
439 if (pi->proto->probe_unit) {
440 parport_claim_or_block(dev: pi->pardev);
441 for (pi->unit = s; pi->unit < e; pi->unit++) {
442 if (pi->proto->probe_unit(pi)) {
443 parport_release(dev: pi->pardev);
444 return pi_probe_mode(pi, max);
445 }
446 }
447 parport_release(dev: pi->pardev);
448 return false;
449 }
450
451 return pi_probe_mode(pi, max);
452}
453
454static 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, id: dev->id);
459 kfree(objp: pi);
460}
461
462static void pata_parport_bus_release(struct device *dev)
463{
464 /* nothing to do here but required to avoid warning on device removal */
465}
466
467static const struct bus_type pata_parport_bus_type = {
468 .name = DRV_NAME,
469};
470
471static struct device pata_parport_bus = {
472 .init_name = DRV_NAME,
473 .release = pata_parport_bus_release,
474};
475
476static const struct scsi_host_template pata_parport_sht = {
477 PATA_PARPORT_SHT("pata_parport")
478};
479
480struct pi_device_match {
481 struct parport *parport;
482 struct pi_protocol *proto;
483};
484
485static 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
493static 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(bus: &pata_parport_bus_type, NULL, data: &match, fn: pi_find_dev))
508 return NULL;
509
510 id = ida_alloc(ida: &pata_parport_bus_dev_ids, GFP_KERNEL);
511 if (id < 0)
512 return NULL;
513
514 pi = kzalloc(size: 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(dev: &pi->dev, name: "pata_parport.%u", pi->dev.id);
527 if (device_register(dev: &pi->dev)) {
528 put_device(dev: &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(module: 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(port: parport, DRV_NAME, par_dev_cb: &par_cb, cnt: 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(dev: &pi->pardev->dev, ppi, n_ports: 1);
557 if (!host)
558 goto out_unreg_parport;
559 dev_set_drvdata(dev: &pi->dev, data: host);
560 host->private_data = pi;
561
562 ata_port_desc(ap: host->ports[0], fmt: "port %s", pi->pardev->port->name);
563 ata_port_desc(ap: host->ports[0], fmt: "protocol %s", pi->proto->name);
564
565 pi_connect(pi);
566 if (ata_host_activate(host, irq: 0, NULL, irq_flags: 0, sht: &pata_parport_sht))
567 goto out_disconnect;
568
569 return pi;
570
571out_disconnect:
572 pi_disconnect(pi);
573out_unreg_parport:
574 parport_unregister_device(dev: pi->pardev);
575 if (pi->proto->release_proto)
576 pi->proto->release_proto(pi);
577out_module_put:
578 module_put(module: pi->proto->owner);
579out_unreg_dev:
580 device_unregister(dev: &pi->dev);
581 /* pata_parport_dev_release will do ida_free(dev->id) and kfree(pi) */
582 return NULL;
583}
584
585int 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(drv: &pr->driver);
594 if (error)
595 return error;
596
597 mutex_lock(&pi_mutex);
598 error = idr_alloc(&protocols, ptr: pr, start: 0, end: 0, GFP_KERNEL);
599 if (error < 0) {
600 driver_unregister(drv: &pr->driver);
601 mutex_unlock(lock: &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, mode: -1, unit: -1, delay: -1);
611 }
612 mutex_unlock(lock: &pi_mutex);
613
614 return 0;
615}
616EXPORT_SYMBOL_GPL(pata_parport_register_driver);
617
618void 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(lock: &pi_mutex);
630 driver_unregister(drv: &pr->driver);
631}
632EXPORT_SYMBOL_GPL(pata_parport_unregister_driver);
633
634static 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(name: protocol, bus: &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(lock: &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(lock: &pi_mutex);
689 if (!ok)
690 return -ENODEV;
691
692 return count;
693}
694static BUS_ATTR_WO(new_device);
695
696static 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
708static 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, name: buf);
714 if (!dev) {
715 mutex_unlock(lock: &pi_mutex);
716 return -ENODEV;
717 }
718
719 pi_remove_one(dev);
720 put_device(dev);
721 mutex_unlock(lock: &pi_mutex);
722
723 return count;
724}
725static BUS_ATTR_WO(delete_device);
726
727static 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, ptr: port, start: port->number, end: port->number,
734 GFP_KERNEL);
735 if (id < 0) {
736 mutex_unlock(lock: &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(parport: port, pr, mode: -1, unit: -1, delay: -1);
744 }
745 mutex_unlock(lock: &pi_mutex);
746}
747
748static 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
759static void pata_parport_detach(struct parport *port)
760{
761 mutex_lock(&pi_mutex);
762 bus_for_each_dev(bus: &pata_parport_bus_type, NULL, data: port, fn: pi_remove_port);
763 idr_remove(&parport_list, id: port->number);
764 mutex_unlock(lock: &pi_mutex);
765}
766
767static 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
774static __init int pata_parport_init(void)
775{
776 int error;
777
778 error = bus_register(bus: &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(dev: &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(bus: &pata_parport_bus_type, attr: &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(bus: &pata_parport_bus_type, attr: &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
810out_remove_del:
811 bus_remove_file(bus: &pata_parport_bus_type, attr: &bus_attr_delete_device);
812out_remove_new:
813 bus_remove_file(bus: &pata_parport_bus_type, attr: &bus_attr_new_device);
814out_unregister_dev:
815 device_unregister(dev: &pata_parport_bus);
816out_unregister_bus:
817 bus_unregister(bus: &pata_parport_bus_type);
818 return error;
819}
820
821static __exit void pata_parport_exit(void)
822{
823 parport_unregister_driver(&pata_parport_driver);
824 bus_remove_file(bus: &pata_parport_bus_type, attr: &bus_attr_new_device);
825 bus_remove_file(bus: &pata_parport_bus_type, attr: &bus_attr_delete_device);
826 device_unregister(dev: &pata_parport_bus);
827 bus_unregister(bus: &pata_parport_bus_type);
828}
829
830MODULE_AUTHOR("Ondrej Zary");
831MODULE_DESCRIPTION("driver for parallel port ATA adapters");
832MODULE_LICENSE("GPL");
833MODULE_ALIAS("paride");
834
835module_init(pata_parport_init);
836module_exit(pata_parport_exit);
837

source code of linux/drivers/ata/pata_parport/pata_parport.c