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(dev: 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(dev: pi->pardev); |
38 | } |
39 | |
40 | static void pata_parport_dev_select(struct ata_port *ap, unsigned int device) |
41 | { |
42 | struct pi_adapter *pi = ap->host->private_data; |
43 | u8 tmp; |
44 | |
45 | if (device == 0) |
46 | tmp = ATA_DEVICE_OBS; |
47 | else |
48 | tmp = ATA_DEVICE_OBS | ATA_DEV1; |
49 | |
50 | pi->proto->write_regr(pi, 0, ATA_REG_DEVICE, tmp); |
51 | ata_sff_pause(ap); |
52 | } |
53 | |
54 | static void pata_parport_set_devctl(struct ata_port *ap, u8 ctl) |
55 | { |
56 | struct pi_adapter *pi = ap->host->private_data; |
57 | |
58 | pi->proto->write_regr(pi, 1, 6, ctl); |
59 | } |
60 | |
61 | static bool pata_parport_devchk(struct ata_port *ap, unsigned int device) |
62 | { |
63 | struct pi_adapter *pi = ap->host->private_data; |
64 | u8 nsect, lbal; |
65 | |
66 | pata_parport_dev_select(ap, device); |
67 | |
68 | pi->proto->write_regr(pi, 0, ATA_REG_NSECT, 0x55); |
69 | pi->proto->write_regr(pi, 0, ATA_REG_LBAL, 0xaa); |
70 | |
71 | pi->proto->write_regr(pi, 0, ATA_REG_NSECT, 0xaa); |
72 | pi->proto->write_regr(pi, 0, ATA_REG_LBAL, 0x55); |
73 | |
74 | pi->proto->write_regr(pi, 0, ATA_REG_NSECT, 0x55); |
75 | pi->proto->write_regr(pi, 0, ATA_REG_LBAL, 0xaa); |
76 | |
77 | nsect = pi->proto->read_regr(pi, 0, ATA_REG_NSECT); |
78 | lbal = pi->proto->read_regr(pi, 0, ATA_REG_LBAL); |
79 | |
80 | return (nsect == 0x55) && (lbal == 0xaa); |
81 | } |
82 | |
83 | static int pata_parport_wait_after_reset(struct ata_link *link, |
84 | unsigned int devmask, |
85 | unsigned long deadline) |
86 | { |
87 | struct ata_port *ap = link->ap; |
88 | struct pi_adapter *pi = ap->host->private_data; |
89 | unsigned int dev0 = devmask & (1 << 0); |
90 | unsigned int dev1 = devmask & (1 << 1); |
91 | int rc, ret = 0; |
92 | |
93 | ata_msleep(ap, 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 | |
149 | static int pata_parport_bus_softreset(struct ata_port *ap, unsigned int devmask, |
150 | unsigned long deadline) |
151 | { |
152 | struct pi_adapter *pi = ap->host->private_data; |
153 | |
154 | /* software reset. causes dev0 to be selected */ |
155 | pi->proto->write_regr(pi, 1, 6, ap->ctl); |
156 | udelay(20); |
157 | pi->proto->write_regr(pi, 1, 6, ap->ctl | ATA_SRST); |
158 | udelay(20); |
159 | pi->proto->write_regr(pi, 1, 6, ap->ctl); |
160 | ap->last_ctl = ap->ctl; |
161 | |
162 | /* wait the port to become ready */ |
163 | return pata_parport_wait_after_reset(link: &ap->link, devmask, deadline); |
164 | } |
165 | |
166 | static int pata_parport_softreset(struct ata_link *link, unsigned int *classes, |
167 | unsigned long deadline) |
168 | { |
169 | struct ata_port *ap = link->ap; |
170 | unsigned int devmask = 0; |
171 | int rc; |
172 | u8 err; |
173 | |
174 | /* determine if device 0/1 are present */ |
175 | if (pata_parport_devchk(ap, 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 | |
200 | static u8 pata_parport_check_status(struct ata_port *ap) |
201 | { |
202 | struct pi_adapter *pi = ap->host->private_data; |
203 | |
204 | return pi->proto->read_regr(pi, 0, ATA_REG_STATUS); |
205 | } |
206 | |
207 | static u8 pata_parport_check_altstatus(struct ata_port *ap) |
208 | { |
209 | struct pi_adapter *pi = ap->host->private_data; |
210 | |
211 | return pi->proto->read_regr(pi, 1, 6); |
212 | } |
213 | |
214 | static void pata_parport_tf_load(struct ata_port *ap, |
215 | const struct ata_taskfile *tf) |
216 | { |
217 | struct pi_adapter *pi = ap->host->private_data; |
218 | |
219 | if (tf->ctl != ap->last_ctl) { |
220 | pi->proto->write_regr(pi, 1, 6, tf->ctl); |
221 | ap->last_ctl = tf->ctl; |
222 | ata_wait_idle(ap); |
223 | } |
224 | |
225 | if (tf->flags & ATA_TFLAG_ISADDR) { |
226 | if (tf->flags & ATA_TFLAG_LBA48) { |
227 | pi->proto->write_regr(pi, 0, ATA_REG_FEATURE, |
228 | tf->hob_feature); |
229 | pi->proto->write_regr(pi, 0, ATA_REG_NSECT, |
230 | tf->hob_nsect); |
231 | pi->proto->write_regr(pi, 0, ATA_REG_LBAL, |
232 | tf->hob_lbal); |
233 | pi->proto->write_regr(pi, 0, ATA_REG_LBAM, |
234 | tf->hob_lbam); |
235 | pi->proto->write_regr(pi, 0, ATA_REG_LBAH, |
236 | tf->hob_lbah); |
237 | } |
238 | pi->proto->write_regr(pi, 0, ATA_REG_FEATURE, tf->feature); |
239 | pi->proto->write_regr(pi, 0, ATA_REG_NSECT, tf->nsect); |
240 | pi->proto->write_regr(pi, 0, ATA_REG_LBAL, tf->lbal); |
241 | pi->proto->write_regr(pi, 0, ATA_REG_LBAM, tf->lbam); |
242 | pi->proto->write_regr(pi, 0, ATA_REG_LBAH, tf->lbah); |
243 | } |
244 | |
245 | if (tf->flags & ATA_TFLAG_DEVICE) |
246 | pi->proto->write_regr(pi, 0, ATA_REG_DEVICE, tf->device); |
247 | |
248 | ata_wait_idle(ap); |
249 | } |
250 | |
251 | static void pata_parport_tf_read(struct ata_port *ap, struct ata_taskfile *tf) |
252 | { |
253 | struct pi_adapter *pi = ap->host->private_data; |
254 | |
255 | tf->status = pi->proto->read_regr(pi, 0, ATA_REG_STATUS); |
256 | tf->error = pi->proto->read_regr(pi, 0, ATA_REG_ERR); |
257 | tf->nsect = pi->proto->read_regr(pi, 0, ATA_REG_NSECT); |
258 | tf->lbal = pi->proto->read_regr(pi, 0, ATA_REG_LBAL); |
259 | tf->lbam = pi->proto->read_regr(pi, 0, ATA_REG_LBAM); |
260 | tf->lbah = pi->proto->read_regr(pi, 0, ATA_REG_LBAH); |
261 | tf->device = pi->proto->read_regr(pi, 0, ATA_REG_DEVICE); |
262 | |
263 | if (tf->flags & ATA_TFLAG_LBA48) { |
264 | pi->proto->write_regr(pi, 1, 6, tf->ctl | ATA_HOB); |
265 | tf->hob_feature = pi->proto->read_regr(pi, 0, ATA_REG_ERR); |
266 | tf->hob_nsect = pi->proto->read_regr(pi, 0, ATA_REG_NSECT); |
267 | tf->hob_lbal = pi->proto->read_regr(pi, 0, ATA_REG_LBAL); |
268 | tf->hob_lbam = pi->proto->read_regr(pi, 0, ATA_REG_LBAM); |
269 | tf->hob_lbah = pi->proto->read_regr(pi, 0, ATA_REG_LBAH); |
270 | pi->proto->write_regr(pi, 1, 6, tf->ctl); |
271 | ap->last_ctl = tf->ctl; |
272 | } |
273 | } |
274 | |
275 | static void pata_parport_exec_command(struct ata_port *ap, |
276 | const struct ata_taskfile *tf) |
277 | { |
278 | struct pi_adapter *pi = ap->host->private_data; |
279 | |
280 | pi->proto->write_regr(pi, 0, ATA_REG_CMD, tf->command); |
281 | ata_sff_pause(ap); |
282 | } |
283 | |
284 | static unsigned int pata_parport_data_xfer(struct ata_queued_cmd *qc, |
285 | unsigned char *buf, unsigned int buflen, int rw) |
286 | { |
287 | struct ata_port *ap = qc->dev->link->ap; |
288 | struct pi_adapter *pi = ap->host->private_data; |
289 | |
290 | if (rw == READ) |
291 | pi->proto->read_block(pi, buf, buflen); |
292 | else |
293 | pi->proto->write_block(pi, buf, buflen); |
294 | |
295 | return buflen; |
296 | } |
297 | |
298 | static void pata_parport_drain_fifo(struct ata_queued_cmd *qc) |
299 | { |
300 | int count; |
301 | struct ata_port *ap; |
302 | struct pi_adapter *pi; |
303 | char junk[2]; |
304 | |
305 | /* We only need to flush incoming data when a command was running */ |
306 | if (qc == NULL || qc->dma_dir == DMA_TO_DEVICE) |
307 | return; |
308 | |
309 | ap = qc->ap; |
310 | pi = ap->host->private_data; |
311 | /* Drain up to 64K of data before we give up this recovery method */ |
312 | for (count = 0; (pata_parport_check_status(ap) & ATA_DRQ) |
313 | && count < 65536; count += 2) { |
314 | pi->proto->read_block(pi, junk, 2); |
315 | } |
316 | |
317 | if (count) |
318 | ata_port_dbg(ap, "drained %d bytes to clear DRQ\n" , count); |
319 | } |
320 | |
321 | static struct ata_port_operations pata_parport_port_ops = { |
322 | .inherits = &ata_sff_port_ops, |
323 | |
324 | .softreset = pata_parport_softreset, |
325 | .hardreset = NULL, |
326 | |
327 | .sff_dev_select = pata_parport_dev_select, |
328 | .sff_set_devctl = pata_parport_set_devctl, |
329 | .sff_check_status = pata_parport_check_status, |
330 | .sff_check_altstatus = pata_parport_check_altstatus, |
331 | .sff_tf_load = pata_parport_tf_load, |
332 | .sff_tf_read = pata_parport_tf_read, |
333 | .sff_exec_command = pata_parport_exec_command, |
334 | .sff_data_xfer = pata_parport_data_xfer, |
335 | .sff_drain_fifo = pata_parport_drain_fifo, |
336 | }; |
337 | |
338 | static const struct ata_port_info pata_parport_port_info = { |
339 | .flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_PIO_POLLING, |
340 | .pio_mask = ATA_PIO0, |
341 | /* No DMA */ |
342 | .port_ops = &pata_parport_port_ops, |
343 | }; |
344 | |
345 | static void pi_release(struct pi_adapter *pi) |
346 | { |
347 | parport_unregister_device(dev: pi->pardev); |
348 | if (pi->proto->release_proto) |
349 | pi->proto->release_proto(pi); |
350 | module_put(module: pi->proto->owner); |
351 | } |
352 | |
353 | static int default_test_proto(struct pi_adapter *pi) |
354 | { |
355 | int j, k; |
356 | int e[2] = { 0, 0 }; |
357 | |
358 | pi->proto->connect(pi); |
359 | |
360 | for (j = 0; j < 2; j++) { |
361 | pi->proto->write_regr(pi, 0, 6, 0xa0 + j * 0x10); |
362 | for (k = 0; k < 256; k++) { |
363 | pi->proto->write_regr(pi, 0, 2, k ^ 0xaa); |
364 | pi->proto->write_regr(pi, 0, 3, k ^ 0x55); |
365 | if (pi->proto->read_regr(pi, 0, 2) != (k ^ 0xaa)) |
366 | e[j]++; |
367 | } |
368 | } |
369 | pi->proto->disconnect(pi); |
370 | |
371 | dev_dbg(&pi->dev, "%s: port 0x%x, mode %d, test=(%d,%d)\n" , |
372 | pi->proto->name, pi->port, pi->mode, e[0], e[1]); |
373 | |
374 | return e[0] && e[1]; /* not here if both > 0 */ |
375 | } |
376 | |
377 | static int pi_test_proto(struct pi_adapter *pi) |
378 | { |
379 | int res; |
380 | |
381 | parport_claim_or_block(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 | |
391 | static bool pi_probe_mode(struct pi_adapter *pi, int max) |
392 | { |
393 | int best, range; |
394 | |
395 | if (pi->mode != -1) { |
396 | if (pi->mode >= max) |
397 | return false; |
398 | range = 3; |
399 | if (pi->mode >= pi->proto->epp_first) |
400 | range = 8; |
401 | if (range == 8 && pi->port % 8) |
402 | return false; |
403 | return !pi_test_proto(pi); |
404 | } |
405 | best = -1; |
406 | for (pi->mode = 0; pi->mode < max; pi->mode++) { |
407 | range = 3; |
408 | if (pi->mode >= pi->proto->epp_first) |
409 | range = 8; |
410 | if (range == 8 && pi->port % 8) |
411 | break; |
412 | if (!pi_test_proto(pi)) |
413 | best = pi->mode; |
414 | } |
415 | pi->mode = best; |
416 | return best > -1; |
417 | } |
418 | |
419 | static bool pi_probe_unit(struct pi_adapter *pi, int unit) |
420 | { |
421 | int max, s, e; |
422 | |
423 | s = unit; |
424 | e = s + 1; |
425 | |
426 | if (s == -1) { |
427 | s = 0; |
428 | e = pi->proto->max_units; |
429 | } |
430 | |
431 | if (pi->proto->test_port) { |
432 | parport_claim_or_block(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 | |
454 | static void pata_parport_dev_release(struct device *dev) |
455 | { |
456 | struct pi_adapter *pi = container_of(dev, struct pi_adapter, dev); |
457 | |
458 | ida_free(&pata_parport_bus_dev_ids, id: dev->id); |
459 | kfree(objp: pi); |
460 | } |
461 | |
462 | static void pata_parport_bus_release(struct device *dev) |
463 | { |
464 | /* nothing to do here but required to avoid warning on device removal */ |
465 | } |
466 | |
467 | static const struct bus_type pata_parport_bus_type = { |
468 | .name = DRV_NAME, |
469 | }; |
470 | |
471 | static struct device pata_parport_bus = { |
472 | .init_name = DRV_NAME, |
473 | .release = pata_parport_bus_release, |
474 | }; |
475 | |
476 | static const struct scsi_host_template pata_parport_sht = { |
477 | PATA_PARPORT_SHT("pata_parport" ) |
478 | }; |
479 | |
480 | struct pi_device_match { |
481 | struct parport *parport; |
482 | struct pi_protocol *proto; |
483 | }; |
484 | |
485 | static int pi_find_dev(struct device *dev, void *data) |
486 | { |
487 | struct pi_adapter *pi = container_of(dev, struct pi_adapter, dev); |
488 | struct pi_device_match *match = data; |
489 | |
490 | return pi->pardev->port == match->parport && pi->proto == match->proto; |
491 | } |
492 | |
493 | static struct pi_adapter *pi_init_one(struct parport *parport, |
494 | struct pi_protocol *pr, int mode, int unit, int delay) |
495 | { |
496 | struct pardev_cb par_cb = { }; |
497 | const struct ata_port_info *ppi[] = { &pata_parport_port_info }; |
498 | struct ata_host *host; |
499 | struct pi_adapter *pi; |
500 | struct pi_device_match match = { .parport = parport, .proto = pr }; |
501 | int id; |
502 | |
503 | /* |
504 | * Abort if there's a device already registered on the same parport |
505 | * using the same protocol. |
506 | */ |
507 | if (bus_for_each_dev(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 | |
571 | out_disconnect: |
572 | pi_disconnect(pi); |
573 | out_unreg_parport: |
574 | parport_unregister_device(dev: pi->pardev); |
575 | if (pi->proto->release_proto) |
576 | pi->proto->release_proto(pi); |
577 | out_module_put: |
578 | module_put(module: pi->proto->owner); |
579 | out_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 | |
585 | int pata_parport_register_driver(struct pi_protocol *pr) |
586 | { |
587 | int error; |
588 | struct parport *parport; |
589 | int port_num; |
590 | |
591 | pr->driver.bus = &pata_parport_bus_type; |
592 | pr->driver.name = pr->name; |
593 | error = driver_register(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 | } |
616 | EXPORT_SYMBOL_GPL(pata_parport_register_driver); |
617 | |
618 | void pata_parport_unregister_driver(struct pi_protocol *pr) |
619 | { |
620 | struct pi_protocol *pr_iter; |
621 | int id = -1; |
622 | |
623 | mutex_lock(&pi_mutex); |
624 | idr_for_each_entry(&protocols, pr_iter, id) { |
625 | if (pr_iter == pr) |
626 | break; |
627 | } |
628 | idr_remove(&protocols, id); |
629 | mutex_unlock(lock: &pi_mutex); |
630 | driver_unregister(drv: &pr->driver); |
631 | } |
632 | EXPORT_SYMBOL_GPL(pata_parport_unregister_driver); |
633 | |
634 | static ssize_t new_device_store(const struct bus_type *bus, const char *buf, size_t count) |
635 | { |
636 | char port[12] = "auto" ; |
637 | char protocol[8] = "auto" ; |
638 | int mode = -1, unit = -1, delay = -1; |
639 | struct pi_protocol *pr, *pr_wanted; |
640 | struct device_driver *drv; |
641 | struct parport *parport; |
642 | int port_num, port_wanted, pr_num; |
643 | bool ok = false; |
644 | |
645 | if (sscanf(buf, "%11s %7s %d %d %d" , |
646 | port, protocol, &mode, &unit, &delay) < 1) |
647 | return -EINVAL; |
648 | |
649 | if (sscanf(port, "parport%u" , &port_wanted) < 1) { |
650 | if (strcmp(port, "auto" )) { |
651 | pr_err("invalid port name %s\n" , port); |
652 | return -EINVAL; |
653 | } |
654 | port_wanted = -1; |
655 | } |
656 | |
657 | drv = driver_find(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 | } |
694 | static BUS_ATTR_WO(new_device); |
695 | |
696 | static void pi_remove_one(struct device *dev) |
697 | { |
698 | struct ata_host *host = dev_get_drvdata(dev); |
699 | struct pi_adapter *pi = host->private_data; |
700 | |
701 | ata_host_detach(host); |
702 | pi_disconnect(pi); |
703 | pi_release(pi); |
704 | device_unregister(dev); |
705 | /* pata_parport_dev_release will do ida_free(dev->id) and kfree(pi) */ |
706 | } |
707 | |
708 | static ssize_t delete_device_store(const struct bus_type *bus, const char *buf, size_t count) |
709 | { |
710 | struct device *dev; |
711 | |
712 | mutex_lock(&pi_mutex); |
713 | dev = bus_find_device_by_name(bus, NULL, 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 | } |
725 | static BUS_ATTR_WO(delete_device); |
726 | |
727 | static void pata_parport_attach(struct parport *port) |
728 | { |
729 | struct pi_protocol *pr; |
730 | int pr_num, id; |
731 | |
732 | mutex_lock(&pi_mutex); |
733 | id = idr_alloc(&parport_list, 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 | |
748 | static int pi_remove_port(struct device *dev, void *p) |
749 | { |
750 | struct ata_host *host = dev_get_drvdata(dev); |
751 | struct pi_adapter *pi = host->private_data; |
752 | |
753 | if (pi->pardev->port == p) |
754 | pi_remove_one(dev); |
755 | |
756 | return 0; |
757 | } |
758 | |
759 | static void pata_parport_detach(struct parport *port) |
760 | { |
761 | mutex_lock(&pi_mutex); |
762 | bus_for_each_dev(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 | |
767 | static struct parport_driver pata_parport_driver = { |
768 | .name = DRV_NAME, |
769 | .match_port = pata_parport_attach, |
770 | .detach = pata_parport_detach, |
771 | .devmodel = true, |
772 | }; |
773 | |
774 | static __init int pata_parport_init(void) |
775 | { |
776 | int error; |
777 | |
778 | error = bus_register(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 | |
810 | out_remove_del: |
811 | bus_remove_file(bus: &pata_parport_bus_type, attr: &bus_attr_delete_device); |
812 | out_remove_new: |
813 | bus_remove_file(bus: &pata_parport_bus_type, attr: &bus_attr_new_device); |
814 | out_unregister_dev: |
815 | device_unregister(dev: &pata_parport_bus); |
816 | out_unregister_bus: |
817 | bus_unregister(bus: &pata_parport_bus_type); |
818 | return error; |
819 | } |
820 | |
821 | static __exit void pata_parport_exit(void) |
822 | { |
823 | parport_unregister_driver(&pata_parport_driver); |
824 | bus_remove_file(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 | |
830 | MODULE_AUTHOR("Ondrej Zary" ); |
831 | MODULE_DESCRIPTION("driver for parallel port ATA adapters" ); |
832 | MODULE_LICENSE("GPL" ); |
833 | MODULE_ALIAS("paride" ); |
834 | |
835 | module_init(pata_parport_init); |
836 | module_exit(pata_parport_exit); |
837 | |