This source file includes following definitions.
- generic_id
- ide_disk_init_chs
- ide_disk_init_mult_count
- ide_classify_ata_dev
- ide_classify_atapi_dev
- do_identify
- ide_dev_read_id
- ide_busy_sleep
- ide_read_device
- do_probe
- probe_for_drive
- hwif_release_dev
- ide_register_port
- ide_port_wait_ready
- ide_undecoded_slave
- ide_probe_port
- ide_port_tune_devices
- ide_initialize_rq
- ide_init_queue
- ide_port_setup_devices
- ide_host_enable_irqs
- init_irq
- ata_lock
- ata_probe
- exact_match
- exact_lock
- ide_register_region
- ide_unregister_region
- ide_init_disk
- drive_release_dev
- hwif_init
- hwif_register_devices
- ide_port_init_devices
- ide_init_port
- ide_port_cable_detect
- drive_rq_insert_work
- ide_port_init_devices_data
- ide_init_port_data
- ide_init_port_hw
- ide_find_port_slot
- ide_free_port_slot
- ide_port_free_devices
- ide_port_alloc_devices
- ide_host_alloc
- ide_port_free
- ide_disable_port
- ide_host_register
- ide_host_add
- __ide_port_unregister_devices
- ide_port_unregister_devices
- ide_unregister
- ide_host_free
- ide_host_remove
- ide_port_scan
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 #include <linux/module.h>
21 #include <linux/types.h>
22 #include <linux/string.h>
23 #include <linux/kernel.h>
24 #include <linux/timer.h>
25 #include <linux/mm.h>
26 #include <linux/interrupt.h>
27 #include <linux/major.h>
28 #include <linux/errno.h>
29 #include <linux/genhd.h>
30 #include <linux/slab.h>
31 #include <linux/delay.h>
32 #include <linux/ide.h>
33 #include <linux/spinlock.h>
34 #include <linux/kmod.h>
35 #include <linux/pci.h>
36 #include <linux/scatterlist.h>
37
38 #include <asm/byteorder.h>
39 #include <asm/irq.h>
40 #include <linux/uaccess.h>
41 #include <asm/io.h>
42
43
44
45
46
47
48
49
50
51
52 static void generic_id(ide_drive_t *drive)
53 {
54 u16 *id = drive->id;
55
56 id[ATA_ID_CUR_CYLS] = id[ATA_ID_CYLS] = drive->cyl;
57 id[ATA_ID_CUR_HEADS] = id[ATA_ID_HEADS] = drive->head;
58 id[ATA_ID_CUR_SECTORS] = id[ATA_ID_SECTORS] = drive->sect;
59 }
60
61 static void ide_disk_init_chs(ide_drive_t *drive)
62 {
63 u16 *id = drive->id;
64
65
66 if (!drive->cyl || !drive->head || !drive->sect) {
67 drive->cyl = drive->bios_cyl = id[ATA_ID_CYLS];
68 drive->head = drive->bios_head = id[ATA_ID_HEADS];
69 drive->sect = drive->bios_sect = id[ATA_ID_SECTORS];
70 }
71
72
73 if (ata_id_current_chs_valid(id)) {
74 drive->cyl = id[ATA_ID_CUR_CYLS];
75 drive->head = id[ATA_ID_CUR_HEADS];
76 drive->sect = id[ATA_ID_CUR_SECTORS];
77 }
78
79
80 if (drive->head > 16 && id[ATA_ID_HEADS] && id[ATA_ID_HEADS] <= 16) {
81 drive->cyl = id[ATA_ID_CYLS];
82 drive->head = id[ATA_ID_HEADS];
83 drive->sect = id[ATA_ID_SECTORS];
84 }
85 }
86
87 static void ide_disk_init_mult_count(ide_drive_t *drive)
88 {
89 u16 *id = drive->id;
90 u8 max_multsect = id[ATA_ID_MAX_MULTSECT] & 0xff;
91
92 if (max_multsect) {
93 if ((max_multsect / 2) > 1)
94 id[ATA_ID_MULTSECT] = max_multsect | 0x100;
95 else
96 id[ATA_ID_MULTSECT] &= ~0x1ff;
97
98 drive->mult_req = id[ATA_ID_MULTSECT] & 0xff;
99
100 if (drive->mult_req)
101 drive->special_flags |= IDE_SFLAG_SET_MULTMODE;
102 }
103 }
104
105 static void ide_classify_ata_dev(ide_drive_t *drive)
106 {
107 u16 *id = drive->id;
108 char *m = (char *)&id[ATA_ID_PROD];
109 int is_cfa = ata_id_is_cfa(id);
110
111
112 if (is_cfa == 0 && (id[ATA_ID_CONFIG] & (1 << 7)))
113 drive->dev_flags |= IDE_DFLAG_REMOVABLE;
114
115 drive->media = ide_disk;
116
117 if (!ata_id_has_unload(drive->id))
118 drive->dev_flags |= IDE_DFLAG_NO_UNLOAD;
119
120 printk(KERN_INFO "%s: %s, %s DISK drive\n", drive->name, m,
121 is_cfa ? "CFA" : "ATA");
122 }
123
124 static void ide_classify_atapi_dev(ide_drive_t *drive)
125 {
126 u16 *id = drive->id;
127 char *m = (char *)&id[ATA_ID_PROD];
128 u8 type = (id[ATA_ID_CONFIG] >> 8) & 0x1f;
129
130 printk(KERN_INFO "%s: %s, ATAPI ", drive->name, m);
131 switch (type) {
132 case ide_floppy:
133 if (!strstr(m, "CD-ROM")) {
134 if (!strstr(m, "oppy") &&
135 !strstr(m, "poyp") &&
136 !strstr(m, "ZIP"))
137 printk(KERN_CONT "cdrom or floppy?, assuming ");
138 if (drive->media != ide_cdrom) {
139 printk(KERN_CONT "FLOPPY");
140 drive->dev_flags |= IDE_DFLAG_REMOVABLE;
141 break;
142 }
143 }
144
145 type = ide_cdrom;
146
147 case ide_cdrom:
148 drive->dev_flags |= IDE_DFLAG_REMOVABLE;
149 #ifdef CONFIG_PPC
150
151 if (!strstr(m, "CD-ROM") && strstr(m, "ZIP")) {
152 printk(KERN_CONT "FLOPPY");
153 type = ide_floppy;
154 break;
155 }
156 #endif
157 printk(KERN_CONT "CD/DVD-ROM");
158 break;
159 case ide_tape:
160 printk(KERN_CONT "TAPE");
161 break;
162 case ide_optical:
163 printk(KERN_CONT "OPTICAL");
164 drive->dev_flags |= IDE_DFLAG_REMOVABLE;
165 break;
166 default:
167 printk(KERN_CONT "UNKNOWN (type %d)", type);
168 break;
169 }
170
171 printk(KERN_CONT " drive\n");
172 drive->media = type;
173
174 drive->ready_stat = 0;
175 if (ata_id_cdb_intr(id))
176 drive->atapi_flags |= IDE_AFLAG_DRQ_INTERRUPT;
177 drive->dev_flags |= IDE_DFLAG_DOORLOCKING;
178
179 drive->dev_flags |= IDE_DFLAG_NO_UNLOAD;
180 }
181
182
183
184
185
186
187
188
189
190
191
192
193 static void do_identify(ide_drive_t *drive, u8 cmd, u16 *id)
194 {
195 ide_hwif_t *hwif = drive->hwif;
196 char *m = (char *)&id[ATA_ID_PROD];
197 unsigned long flags;
198 int bswap = 1;
199
200
201 local_irq_save(flags);
202
203 hwif->tp_ops->input_data(drive, NULL, id, SECTOR_SIZE);
204 local_irq_restore(flags);
205
206 drive->dev_flags |= IDE_DFLAG_ID_READ;
207 #ifdef DEBUG
208 printk(KERN_INFO "%s: dumping identify data\n", drive->name);
209 ide_dump_identify((u8 *)id);
210 #endif
211 ide_fix_driveid(id);
212
213
214
215
216
217 if (cmd == ATA_CMD_ID_ATAPI) {
218 if ((m[0] == 'N' && m[1] == 'E') ||
219 (m[0] == 'F' && m[1] == 'X') ||
220 (m[0] == 'P' && m[1] == 'i'))
221
222 bswap ^= 1;
223 }
224
225 ide_fixstring(m, ATA_ID_PROD_LEN, bswap);
226 ide_fixstring((char *)&id[ATA_ID_FW_REV], ATA_ID_FW_REV_LEN, bswap);
227 ide_fixstring((char *)&id[ATA_ID_SERNO], ATA_ID_SERNO_LEN, bswap);
228
229
230 m[ATA_ID_PROD_LEN - 1] = '\0';
231
232 if (strstr(m, "E X A B Y T E N E S T"))
233 drive->dev_flags &= ~IDE_DFLAG_PRESENT;
234 else
235 drive->dev_flags |= IDE_DFLAG_PRESENT;
236 }
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252 int ide_dev_read_id(ide_drive_t *drive, u8 cmd, u16 *id, int irq_ctx)
253 {
254 ide_hwif_t *hwif = drive->hwif;
255 struct ide_io_ports *io_ports = &hwif->io_ports;
256 const struct ide_tp_ops *tp_ops = hwif->tp_ops;
257 int use_altstatus = 0, rc;
258 unsigned long timeout;
259 u8 s = 0, a = 0;
260
261
262
263
264
265 if (io_ports->ctl_addr)
266 tp_ops->write_devctl(hwif, ATA_NIEN | ATA_DEVCTL_OBS);
267
268
269 if (irq_ctx)
270 mdelay(50);
271 else
272 msleep(50);
273
274 if (io_ports->ctl_addr &&
275 (hwif->host_flags & IDE_HFLAG_BROKEN_ALTSTATUS) == 0) {
276 a = tp_ops->read_altstatus(hwif);
277 s = tp_ops->read_status(hwif);
278 if ((a ^ s) & ~ATA_SENSE)
279
280 printk(KERN_INFO "%s: probing with STATUS(0x%02x) "
281 "instead of ALTSTATUS(0x%02x)\n",
282 drive->name, s, a);
283 else
284
285 use_altstatus = 1;
286 }
287
288
289
290
291 if (cmd == ATA_CMD_ID_ATAPI) {
292 struct ide_taskfile tf;
293
294 memset(&tf, 0, sizeof(tf));
295
296 tp_ops->tf_load(drive, &tf, IDE_VALID_FEATURE);
297 }
298
299
300 tp_ops->exec_command(hwif, cmd);
301
302 timeout = ((cmd == ATA_CMD_ID_ATA) ? WAIT_WORSTCASE : WAIT_PIDENTIFY) / 2;
303
304
305 if (irq_ctx) {
306 rc = __ide_wait_stat(drive, ATA_DRQ, BAD_R_STAT, timeout, &s);
307 if (rc)
308 return 1;
309 } else {
310 rc = ide_busy_sleep(drive, timeout, use_altstatus);
311 if (rc)
312 return 1;
313
314 msleep(50);
315 s = tp_ops->read_status(hwif);
316 }
317
318 if (OK_STAT(s, ATA_DRQ, BAD_R_STAT)) {
319
320 do_identify(drive, cmd, id);
321
322 rc = 0;
323
324 (void)tp_ops->read_status(hwif);
325 } else {
326
327 rc = 2;
328 }
329 return rc;
330 }
331
332 int ide_busy_sleep(ide_drive_t *drive, unsigned long timeout, int altstatus)
333 {
334 ide_hwif_t *hwif = drive->hwif;
335 u8 stat;
336
337 timeout += jiffies;
338
339 do {
340 msleep(50);
341 stat = altstatus ? hwif->tp_ops->read_altstatus(hwif)
342 : hwif->tp_ops->read_status(hwif);
343 if ((stat & ATA_BUSY) == 0)
344 return 0;
345 } while (time_before(jiffies, timeout));
346
347 printk(KERN_ERR "%s: timeout in %s\n", drive->name, __func__);
348
349 return 1;
350 }
351
352 static u8 ide_read_device(ide_drive_t *drive)
353 {
354 struct ide_taskfile tf;
355
356 drive->hwif->tp_ops->tf_read(drive, &tf, IDE_VALID_DEVICE);
357
358 return tf.device;
359 }
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382 static int do_probe (ide_drive_t *drive, u8 cmd)
383 {
384 ide_hwif_t *hwif = drive->hwif;
385 const struct ide_tp_ops *tp_ops = hwif->tp_ops;
386 u16 *id = drive->id;
387 int rc;
388 u8 present = !!(drive->dev_flags & IDE_DFLAG_PRESENT), stat;
389
390
391 if (present && drive->media != ide_disk && cmd == ATA_CMD_ID_ATA)
392 return 4;
393
394 #ifdef DEBUG
395 printk(KERN_INFO "probing for %s: present=%d, media=%d, probetype=%s\n",
396 drive->name, present, drive->media,
397 (cmd == ATA_CMD_ID_ATA) ? "ATA" : "ATAPI");
398 #endif
399
400
401
402
403 msleep(50);
404 tp_ops->dev_select(drive);
405 msleep(50);
406
407 if (ide_read_device(drive) != drive->select && present == 0) {
408 if (drive->dn & 1) {
409
410 tp_ops->dev_select(hwif->devices[0]);
411
412 msleep(50);
413 }
414
415 return 3;
416 }
417
418 stat = tp_ops->read_status(hwif);
419
420 if (OK_STAT(stat, ATA_DRDY, ATA_BUSY) ||
421 present || cmd == ATA_CMD_ID_ATAPI) {
422 rc = ide_dev_read_id(drive, cmd, id, 0);
423 if (rc)
424
425 rc = ide_dev_read_id(drive, cmd, id, 0);
426
427 stat = tp_ops->read_status(hwif);
428
429 if (stat == (ATA_BUSY | ATA_DRDY))
430 return 4;
431
432 if (rc == 1 && cmd == ATA_CMD_ID_ATAPI) {
433 printk(KERN_ERR "%s: no response (status = 0x%02x), "
434 "resetting drive\n", drive->name, stat);
435 msleep(50);
436 tp_ops->dev_select(drive);
437 msleep(50);
438 tp_ops->exec_command(hwif, ATA_CMD_DEV_RESET);
439 (void)ide_busy_sleep(drive, WAIT_WORSTCASE, 0);
440 rc = ide_dev_read_id(drive, cmd, id, 0);
441 }
442
443
444 stat = tp_ops->read_status(hwif);
445
446 if (rc == 1)
447 printk(KERN_ERR "%s: no response (status = 0x%02x)\n",
448 drive->name, stat);
449 } else {
450
451 rc = 3;
452 }
453 if (drive->dn & 1) {
454
455 tp_ops->dev_select(hwif->devices[0]);
456 msleep(50);
457
458 (void)tp_ops->read_status(hwif);
459 }
460 return rc;
461 }
462
463
464
465
466
467
468
469
470
471
472
473
474
475 static u8 probe_for_drive(ide_drive_t *drive)
476 {
477 char *m;
478 int rc;
479 u8 cmd;
480
481 drive->dev_flags &= ~IDE_DFLAG_ID_READ;
482
483 m = (char *)&drive->id[ATA_ID_PROD];
484 strcpy(m, "UNKNOWN");
485
486
487 if ((drive->dev_flags & IDE_DFLAG_NOPROBE) == 0) {
488
489 cmd = ATA_CMD_ID_ATA;
490 rc = do_probe(drive, cmd);
491 if (rc >= 2) {
492
493 cmd = ATA_CMD_ID_ATAPI;
494 rc = do_probe(drive, cmd);
495 }
496
497 if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
498 return 0;
499
500
501 if ((drive->dev_flags & IDE_DFLAG_ID_READ) == 0) {
502 if (drive->media == ide_disk) {
503 printk(KERN_INFO "%s: non-IDE drive, CHS=%d/%d/%d\n",
504 drive->name, drive->cyl,
505 drive->head, drive->sect);
506 } else if (drive->media == ide_cdrom) {
507 printk(KERN_INFO "%s: ATAPI cdrom (?)\n", drive->name);
508 } else {
509
510 printk(KERN_WARNING "%s: Unknown device on bus refused identification. Ignoring.\n", drive->name);
511 drive->dev_flags &= ~IDE_DFLAG_PRESENT;
512 }
513 } else {
514 if (cmd == ATA_CMD_ID_ATAPI)
515 ide_classify_atapi_dev(drive);
516 else
517 ide_classify_ata_dev(drive);
518 }
519 }
520
521 if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
522 return 0;
523
524
525 if ((drive->dev_flags & IDE_DFLAG_ID_READ) == 0) {
526 generic_id(drive);
527 return 1;
528 }
529
530 if (drive->media == ide_disk) {
531 ide_disk_init_chs(drive);
532 ide_disk_init_mult_count(drive);
533 }
534
535 return 1;
536 }
537
538 static void hwif_release_dev(struct device *dev)
539 {
540 ide_hwif_t *hwif = container_of(dev, ide_hwif_t, gendev);
541
542 complete(&hwif->gendev_rel_comp);
543 }
544
545 static int ide_register_port(ide_hwif_t *hwif)
546 {
547 int ret;
548
549
550 dev_set_name(&hwif->gendev, "%s", hwif->name);
551 dev_set_drvdata(&hwif->gendev, hwif);
552 if (hwif->gendev.parent == NULL)
553 hwif->gendev.parent = hwif->dev;
554 hwif->gendev.release = hwif_release_dev;
555
556 ret = device_register(&hwif->gendev);
557 if (ret < 0) {
558 printk(KERN_WARNING "IDE: %s: device_register error: %d\n",
559 __func__, ret);
560 goto out;
561 }
562
563 hwif->portdev = device_create(ide_port_class, &hwif->gendev,
564 MKDEV(0, 0), hwif, "%s", hwif->name);
565 if (IS_ERR(hwif->portdev)) {
566 ret = PTR_ERR(hwif->portdev);
567 device_unregister(&hwif->gendev);
568 }
569 out:
570 return ret;
571 }
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599 static int ide_port_wait_ready(ide_hwif_t *hwif)
600 {
601 const struct ide_tp_ops *tp_ops = hwif->tp_ops;
602 ide_drive_t *drive;
603 int i, rc;
604
605 printk(KERN_DEBUG "Probing IDE interface %s...\n", hwif->name);
606
607
608
609 mdelay(2);
610
611
612
613
614
615 rc = ide_wait_not_busy(hwif, 35000);
616 if (rc)
617 return rc;
618
619
620 ide_port_for_each_dev(i, drive, hwif) {
621
622 if ((drive->dev_flags & IDE_DFLAG_NOPROBE) == 0 ||
623 (drive->dev_flags & IDE_DFLAG_PRESENT)) {
624 tp_ops->dev_select(drive);
625 tp_ops->write_devctl(hwif, ATA_DEVCTL_OBS);
626 mdelay(2);
627 rc = ide_wait_not_busy(hwif, 35000);
628 if (rc)
629 goto out;
630 } else
631 printk(KERN_DEBUG "%s: ide_wait_not_busy() skipped\n",
632 drive->name);
633 }
634 out:
635
636 if (i)
637 tp_ops->dev_select(hwif->devices[0]);
638
639 return rc;
640 }
641
642
643
644
645
646
647
648
649
650
651 void ide_undecoded_slave(ide_drive_t *dev1)
652 {
653 ide_drive_t *dev0 = dev1->hwif->devices[0];
654
655 if ((dev1->dn & 1) == 0 || (dev0->dev_flags & IDE_DFLAG_PRESENT) == 0)
656 return;
657
658
659 if (strcmp((char *)&dev0->id[ATA_ID_PROD],
660 (char *)&dev1->id[ATA_ID_PROD]))
661 return;
662
663
664 if (strncmp((char *)&dev0->id[ATA_ID_SERNO],
665 (char *)&dev1->id[ATA_ID_SERNO], ATA_ID_SERNO_LEN))
666 return;
667
668
669 if (*(char *)&dev0->id[ATA_ID_SERNO] == 0)
670 return;
671
672
673 printk(KERN_WARNING "ide-probe: ignoring undecoded slave\n");
674
675 dev1->dev_flags &= ~IDE_DFLAG_PRESENT;
676 }
677
678 EXPORT_SYMBOL_GPL(ide_undecoded_slave);
679
680 static int ide_probe_port(ide_hwif_t *hwif)
681 {
682 ide_drive_t *drive;
683 unsigned int irqd;
684 int i, rc = -ENODEV;
685
686 BUG_ON(hwif->present);
687
688 if ((hwif->devices[0]->dev_flags & IDE_DFLAG_NOPROBE) &&
689 (hwif->devices[1]->dev_flags & IDE_DFLAG_NOPROBE))
690 return -EACCES;
691
692
693
694
695
696 irqd = hwif->irq;
697 if (irqd)
698 disable_irq(hwif->irq);
699
700 if (ide_port_wait_ready(hwif) == -EBUSY)
701 printk(KERN_DEBUG "%s: Wait for ready failed before probe !\n", hwif->name);
702
703
704
705
706
707 ide_port_for_each_dev(i, drive, hwif) {
708 (void) probe_for_drive(drive);
709 if (drive->dev_flags & IDE_DFLAG_PRESENT)
710 rc = 0;
711 }
712
713
714
715
716
717 if (irqd)
718 enable_irq(irqd);
719
720 return rc;
721 }
722
723 static void ide_port_tune_devices(ide_hwif_t *hwif)
724 {
725 const struct ide_port_ops *port_ops = hwif->port_ops;
726 ide_drive_t *drive;
727 int i;
728
729 ide_port_for_each_present_dev(i, drive, hwif) {
730 ide_check_nien_quirk_list(drive);
731
732 if (port_ops && port_ops->quirkproc)
733 port_ops->quirkproc(drive);
734 }
735
736 ide_port_for_each_present_dev(i, drive, hwif) {
737 ide_set_max_pio(drive);
738
739 drive->dev_flags |= IDE_DFLAG_NICE1;
740
741 if (hwif->dma_ops)
742 ide_set_dma(drive);
743 }
744 }
745
746 static void ide_initialize_rq(struct request *rq)
747 {
748 struct ide_request *req = blk_mq_rq_to_pdu(rq);
749
750 req->special = NULL;
751 scsi_req_init(&req->sreq);
752 req->sreq.sense = req->sense;
753 }
754
755 static const struct blk_mq_ops ide_mq_ops = {
756 .queue_rq = ide_queue_rq,
757 .initialize_rq_fn = ide_initialize_rq,
758 };
759
760
761
762
763 static int ide_init_queue(ide_drive_t *drive)
764 {
765 struct request_queue *q;
766 ide_hwif_t *hwif = drive->hwif;
767 int max_sectors = 256;
768 int max_sg_entries = PRD_ENTRIES;
769 struct blk_mq_tag_set *set;
770
771
772
773
774
775
776
777
778
779 set = &drive->tag_set;
780 set->ops = &ide_mq_ops;
781 set->nr_hw_queues = 1;
782 set->queue_depth = 32;
783 set->reserved_tags = 1;
784 set->cmd_size = sizeof(struct ide_request);
785 set->numa_node = hwif_to_node(hwif);
786 set->flags = BLK_MQ_F_SHOULD_MERGE | BLK_MQ_F_BLOCKING;
787 if (blk_mq_alloc_tag_set(set))
788 return 1;
789
790 q = blk_mq_init_queue(set);
791 if (IS_ERR(q)) {
792 blk_mq_free_tag_set(set);
793 return 1;
794 }
795
796 blk_queue_flag_set(QUEUE_FLAG_SCSI_PASSTHROUGH, q);
797
798 q->queuedata = drive;
799 blk_queue_segment_boundary(q, 0xffff);
800
801 if (hwif->rqsize < max_sectors)
802 max_sectors = hwif->rqsize;
803 blk_queue_max_hw_sectors(q, max_sectors);
804
805 #ifdef CONFIG_PCI
806
807
808
809
810
811
812
813
814
815 max_sg_entries >>= 1;
816 #endif
817
818 blk_queue_max_segments(q, max_sg_entries);
819
820
821 drive->queue = q;
822
823 return 0;
824 }
825
826 static DEFINE_MUTEX(ide_cfg_mtx);
827
828
829
830
831
832 static int ide_port_setup_devices(ide_hwif_t *hwif)
833 {
834 ide_drive_t *drive;
835 int i, j = 0;
836
837 mutex_lock(&ide_cfg_mtx);
838 ide_port_for_each_present_dev(i, drive, hwif) {
839 if (ide_init_queue(drive)) {
840 printk(KERN_ERR "ide: failed to init %s\n",
841 drive->name);
842 drive->dev_flags &= ~IDE_DFLAG_PRESENT;
843 continue;
844 }
845
846 j++;
847 }
848 mutex_unlock(&ide_cfg_mtx);
849
850 return j;
851 }
852
853 static void ide_host_enable_irqs(struct ide_host *host)
854 {
855 ide_hwif_t *hwif;
856 int i;
857
858 ide_host_for_each_port(i, hwif, host) {
859 if (hwif == NULL)
860 continue;
861
862
863 hwif->tp_ops->read_status(hwif);
864
865
866 if (hwif->io_ports.ctl_addr)
867 hwif->tp_ops->write_devctl(hwif, ATA_DEVCTL_OBS);
868 }
869 }
870
871
872
873
874 static int init_irq (ide_hwif_t *hwif)
875 {
876 struct ide_io_ports *io_ports = &hwif->io_ports;
877 struct ide_host *host = hwif->host;
878 irq_handler_t irq_handler = host->irq_handler;
879 int sa = host->irq_flags;
880
881 if (irq_handler == NULL)
882 irq_handler = ide_intr;
883
884 if (!host->get_lock)
885 if (request_irq(hwif->irq, irq_handler, sa, hwif->name, hwif))
886 goto out_up;
887
888 #if !defined(__mc68000__)
889 printk(KERN_INFO "%s at 0x%03lx-0x%03lx,0x%03lx on irq %d", hwif->name,
890 io_ports->data_addr, io_ports->status_addr,
891 io_ports->ctl_addr, hwif->irq);
892 #else
893 printk(KERN_INFO "%s at 0x%08lx on irq %d", hwif->name,
894 io_ports->data_addr, hwif->irq);
895 #endif
896 if (hwif->host->host_flags & IDE_HFLAG_SERIALIZE)
897 printk(KERN_CONT " (serialized)");
898 printk(KERN_CONT "\n");
899
900 return 0;
901 out_up:
902 return 1;
903 }
904
905 static int ata_lock(dev_t dev, void *data)
906 {
907
908 return 0;
909 }
910
911 static struct kobject *ata_probe(dev_t dev, int *part, void *data)
912 {
913 ide_hwif_t *hwif = data;
914 int unit = *part >> PARTN_BITS;
915 ide_drive_t *drive = hwif->devices[unit];
916
917 if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
918 return NULL;
919
920 if (drive->media == ide_disk)
921 request_module("ide-disk");
922 if (drive->media == ide_cdrom || drive->media == ide_optical)
923 request_module("ide-cd");
924 if (drive->media == ide_tape)
925 request_module("ide-tape");
926 if (drive->media == ide_floppy)
927 request_module("ide-floppy");
928
929 return NULL;
930 }
931
932 static struct kobject *exact_match(dev_t dev, int *part, void *data)
933 {
934 struct gendisk *p = data;
935 *part &= (1 << PARTN_BITS) - 1;
936 return &disk_to_dev(p)->kobj;
937 }
938
939 static int exact_lock(dev_t dev, void *data)
940 {
941 struct gendisk *p = data;
942
943 if (!get_disk_and_module(p))
944 return -1;
945 return 0;
946 }
947
948 void ide_register_region(struct gendisk *disk)
949 {
950 blk_register_region(MKDEV(disk->major, disk->first_minor),
951 disk->minors, NULL, exact_match, exact_lock, disk);
952 }
953
954 EXPORT_SYMBOL_GPL(ide_register_region);
955
956 void ide_unregister_region(struct gendisk *disk)
957 {
958 blk_unregister_region(MKDEV(disk->major, disk->first_minor),
959 disk->minors);
960 }
961
962 EXPORT_SYMBOL_GPL(ide_unregister_region);
963
964 void ide_init_disk(struct gendisk *disk, ide_drive_t *drive)
965 {
966 ide_hwif_t *hwif = drive->hwif;
967 unsigned int unit = drive->dn & 1;
968
969 disk->major = hwif->major;
970 disk->first_minor = unit << PARTN_BITS;
971 sprintf(disk->disk_name, "hd%c", 'a' + hwif->index * MAX_DRIVES + unit);
972 disk->queue = drive->queue;
973 }
974
975 EXPORT_SYMBOL_GPL(ide_init_disk);
976
977 static void drive_release_dev (struct device *dev)
978 {
979 ide_drive_t *drive = container_of(dev, ide_drive_t, gendev);
980
981 ide_proc_unregister_device(drive);
982
983 if (drive->sense_rq)
984 blk_mq_free_request(drive->sense_rq);
985
986 blk_cleanup_queue(drive->queue);
987 drive->queue = NULL;
988 blk_mq_free_tag_set(&drive->tag_set);
989
990 drive->dev_flags &= ~IDE_DFLAG_PRESENT;
991
992 complete(&drive->gendev_rel_comp);
993 }
994
995 static int hwif_init(ide_hwif_t *hwif)
996 {
997 if (!hwif->irq) {
998 printk(KERN_ERR "%s: disabled, no IRQ\n", hwif->name);
999 return 0;
1000 }
1001
1002 if (register_blkdev(hwif->major, hwif->name))
1003 return 0;
1004
1005 if (!hwif->sg_max_nents)
1006 hwif->sg_max_nents = PRD_ENTRIES;
1007
1008 hwif->sg_table = kmalloc_array(hwif->sg_max_nents,
1009 sizeof(struct scatterlist),
1010 GFP_KERNEL);
1011 if (!hwif->sg_table) {
1012 printk(KERN_ERR "%s: unable to allocate SG table.\n", hwif->name);
1013 goto out;
1014 }
1015
1016 sg_init_table(hwif->sg_table, hwif->sg_max_nents);
1017
1018 if (init_irq(hwif)) {
1019 printk(KERN_ERR "%s: disabled, unable to get IRQ %d\n",
1020 hwif->name, hwif->irq);
1021 goto out;
1022 }
1023
1024 blk_register_region(MKDEV(hwif->major, 0), MAX_DRIVES << PARTN_BITS,
1025 THIS_MODULE, ata_probe, ata_lock, hwif);
1026 return 1;
1027
1028 out:
1029 unregister_blkdev(hwif->major, hwif->name);
1030 return 0;
1031 }
1032
1033 static void hwif_register_devices(ide_hwif_t *hwif)
1034 {
1035 ide_drive_t *drive;
1036 unsigned int i;
1037
1038 ide_port_for_each_present_dev(i, drive, hwif) {
1039 struct device *dev = &drive->gendev;
1040 int ret;
1041
1042 dev_set_name(dev, "%u.%u", hwif->index, i);
1043 dev_set_drvdata(dev, drive);
1044 dev->parent = &hwif->gendev;
1045 dev->bus = &ide_bus_type;
1046 dev->release = drive_release_dev;
1047
1048 ret = device_register(dev);
1049 if (ret < 0)
1050 printk(KERN_WARNING "IDE: %s: device_register error: "
1051 "%d\n", __func__, ret);
1052 }
1053 }
1054
1055 static void ide_port_init_devices(ide_hwif_t *hwif)
1056 {
1057 const struct ide_port_ops *port_ops = hwif->port_ops;
1058 ide_drive_t *drive;
1059 int i;
1060
1061 ide_port_for_each_dev(i, drive, hwif) {
1062 drive->dn = i + hwif->channel * 2;
1063
1064 if (hwif->host_flags & IDE_HFLAG_IO_32BIT)
1065 drive->io_32bit = 1;
1066 if (hwif->host_flags & IDE_HFLAG_NO_IO_32BIT)
1067 drive->dev_flags |= IDE_DFLAG_NO_IO_32BIT;
1068 if (hwif->host_flags & IDE_HFLAG_UNMASK_IRQS)
1069 drive->dev_flags |= IDE_DFLAG_UNMASK;
1070 if (hwif->host_flags & IDE_HFLAG_NO_UNMASK_IRQS)
1071 drive->dev_flags |= IDE_DFLAG_NO_UNMASK;
1072
1073 drive->pio_mode = XFER_PIO_0;
1074
1075 if (port_ops && port_ops->init_dev)
1076 port_ops->init_dev(drive);
1077 }
1078 }
1079
1080 static void ide_init_port(ide_hwif_t *hwif, unsigned int port,
1081 const struct ide_port_info *d)
1082 {
1083 hwif->channel = port;
1084
1085 hwif->chipset = d->chipset ? d->chipset : ide_pci;
1086
1087 if (d->init_iops)
1088 d->init_iops(hwif);
1089
1090
1091 hwif->host_flags |= d->host_flags;
1092 hwif->pio_mask = d->pio_mask;
1093
1094 if (d->tp_ops)
1095 hwif->tp_ops = d->tp_ops;
1096
1097
1098 if ((hwif->host_flags & IDE_HFLAG_DTC2278) == 0 || hwif->channel == 0)
1099 hwif->port_ops = d->port_ops;
1100
1101 hwif->swdma_mask = d->swdma_mask;
1102 hwif->mwdma_mask = d->mwdma_mask;
1103 hwif->ultra_mask = d->udma_mask;
1104
1105 if ((d->host_flags & IDE_HFLAG_NO_DMA) == 0) {
1106 int rc;
1107
1108 hwif->dma_ops = d->dma_ops;
1109
1110 if (d->init_dma)
1111 rc = d->init_dma(hwif, d);
1112 else
1113 rc = ide_hwif_setup_dma(hwif, d);
1114
1115 if (rc < 0) {
1116 printk(KERN_INFO "%s: DMA disabled\n", hwif->name);
1117
1118 hwif->dma_ops = NULL;
1119 hwif->dma_base = 0;
1120 hwif->swdma_mask = 0;
1121 hwif->mwdma_mask = 0;
1122 hwif->ultra_mask = 0;
1123 }
1124 }
1125
1126 if ((d->host_flags & IDE_HFLAG_SERIALIZE) ||
1127 ((d->host_flags & IDE_HFLAG_SERIALIZE_DMA) && hwif->dma_base))
1128 hwif->host->host_flags |= IDE_HFLAG_SERIALIZE;
1129
1130 if (d->max_sectors)
1131 hwif->rqsize = d->max_sectors;
1132 else {
1133 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48) ||
1134 (hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA))
1135 hwif->rqsize = 256;
1136 else
1137 hwif->rqsize = 65536;
1138 }
1139
1140
1141 if (d->init_hwif)
1142 d->init_hwif(hwif);
1143 }
1144
1145 static void ide_port_cable_detect(ide_hwif_t *hwif)
1146 {
1147 const struct ide_port_ops *port_ops = hwif->port_ops;
1148
1149 if (port_ops && port_ops->cable_detect && (hwif->ultra_mask & 0x78)) {
1150 if (hwif->cbl != ATA_CBL_PATA40_SHORT)
1151 hwif->cbl = port_ops->cable_detect(hwif);
1152 }
1153 }
1154
1155
1156
1157
1158 static void drive_rq_insert_work(struct work_struct *work)
1159 {
1160 ide_drive_t *drive = container_of(work, ide_drive_t, rq_work);
1161 ide_hwif_t *hwif = drive->hwif;
1162 struct request *rq;
1163 blk_status_t ret;
1164 LIST_HEAD(list);
1165
1166 blk_mq_quiesce_queue(drive->queue);
1167
1168 ret = BLK_STS_OK;
1169 spin_lock_irq(&hwif->lock);
1170 while (!list_empty(&drive->rq_list)) {
1171 rq = list_first_entry(&drive->rq_list, struct request, queuelist);
1172 list_del_init(&rq->queuelist);
1173
1174 spin_unlock_irq(&hwif->lock);
1175 ret = ide_issue_rq(drive, rq, true);
1176 spin_lock_irq(&hwif->lock);
1177 }
1178 spin_unlock_irq(&hwif->lock);
1179
1180 blk_mq_unquiesce_queue(drive->queue);
1181
1182 if (ret != BLK_STS_OK)
1183 kblockd_schedule_work(&drive->rq_work);
1184 }
1185
1186 static const u8 ide_hwif_to_major[] =
1187 { IDE0_MAJOR, IDE1_MAJOR, IDE2_MAJOR, IDE3_MAJOR, IDE4_MAJOR,
1188 IDE5_MAJOR, IDE6_MAJOR, IDE7_MAJOR, IDE8_MAJOR, IDE9_MAJOR };
1189
1190 static void ide_port_init_devices_data(ide_hwif_t *hwif)
1191 {
1192 ide_drive_t *drive;
1193 int i;
1194
1195 ide_port_for_each_dev(i, drive, hwif) {
1196 u8 j = (hwif->index * MAX_DRIVES) + i;
1197 u16 *saved_id = drive->id;
1198
1199 memset(drive, 0, sizeof(*drive));
1200 memset(saved_id, 0, SECTOR_SIZE);
1201 drive->id = saved_id;
1202
1203 drive->media = ide_disk;
1204 drive->select = (i << 4) | ATA_DEVICE_OBS;
1205 drive->hwif = hwif;
1206 drive->ready_stat = ATA_DRDY;
1207 drive->bad_wstat = BAD_W_STAT;
1208 drive->special_flags = IDE_SFLAG_RECALIBRATE |
1209 IDE_SFLAG_SET_GEOMETRY;
1210 drive->name[0] = 'h';
1211 drive->name[1] = 'd';
1212 drive->name[2] = 'a' + j;
1213 drive->max_failures = IDE_DEFAULT_MAX_FAILURES;
1214
1215 INIT_LIST_HEAD(&drive->list);
1216 init_completion(&drive->gendev_rel_comp);
1217
1218 INIT_WORK(&drive->rq_work, drive_rq_insert_work);
1219 INIT_LIST_HEAD(&drive->rq_list);
1220 }
1221 }
1222
1223 static void ide_init_port_data(ide_hwif_t *hwif, unsigned int index)
1224 {
1225
1226 hwif->index = index;
1227 hwif->major = ide_hwif_to_major[index];
1228
1229 hwif->name[0] = 'i';
1230 hwif->name[1] = 'd';
1231 hwif->name[2] = 'e';
1232 hwif->name[3] = '0' + index;
1233
1234 spin_lock_init(&hwif->lock);
1235
1236 timer_setup(&hwif->timer, ide_timer_expiry, 0);
1237
1238 init_completion(&hwif->gendev_rel_comp);
1239
1240 hwif->tp_ops = &default_tp_ops;
1241
1242 ide_port_init_devices_data(hwif);
1243 }
1244
1245 static void ide_init_port_hw(ide_hwif_t *hwif, struct ide_hw *hw)
1246 {
1247 memcpy(&hwif->io_ports, &hw->io_ports, sizeof(hwif->io_ports));
1248 hwif->irq = hw->irq;
1249 hwif->dev = hw->dev;
1250 hwif->gendev.parent = hw->parent ? hw->parent : hw->dev;
1251 hwif->config_data = hw->config;
1252 }
1253
1254 static unsigned int ide_indexes;
1255
1256
1257
1258
1259
1260
1261
1262
1263 static int ide_find_port_slot(const struct ide_port_info *d)
1264 {
1265 int idx = -ENOENT;
1266 u8 bootable = (d && (d->host_flags & IDE_HFLAG_NON_BOOTABLE)) ? 0 : 1;
1267 u8 i = (d && (d->host_flags & IDE_HFLAG_QD_2ND_PORT)) ? 1 : 0;
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279 mutex_lock(&ide_cfg_mtx);
1280 if (bootable) {
1281 if ((ide_indexes | i) != (1 << MAX_HWIFS) - 1)
1282 idx = ffz(ide_indexes | i);
1283 } else {
1284 if ((ide_indexes | 3) != (1 << MAX_HWIFS) - 1)
1285 idx = ffz(ide_indexes | 3);
1286 else if ((ide_indexes & 3) != 3)
1287 idx = ffz(ide_indexes);
1288 }
1289 if (idx >= 0)
1290 ide_indexes |= (1 << idx);
1291 mutex_unlock(&ide_cfg_mtx);
1292
1293 return idx;
1294 }
1295
1296 static void ide_free_port_slot(int idx)
1297 {
1298 mutex_lock(&ide_cfg_mtx);
1299 ide_indexes &= ~(1 << idx);
1300 mutex_unlock(&ide_cfg_mtx);
1301 }
1302
1303 static void ide_port_free_devices(ide_hwif_t *hwif)
1304 {
1305 ide_drive_t *drive;
1306 int i;
1307
1308 ide_port_for_each_dev(i, drive, hwif) {
1309 kfree(drive->id);
1310 kfree(drive);
1311 }
1312 }
1313
1314 static int ide_port_alloc_devices(ide_hwif_t *hwif, int node)
1315 {
1316 ide_drive_t *drive;
1317 int i;
1318
1319 for (i = 0; i < MAX_DRIVES; i++) {
1320 drive = kzalloc_node(sizeof(*drive), GFP_KERNEL, node);
1321 if (drive == NULL)
1322 goto out_nomem;
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332 drive->id = kzalloc_node(SECTOR_SIZE, GFP_KERNEL, node);
1333 if (drive->id == NULL)
1334 goto out_free_drive;
1335
1336 hwif->devices[i] = drive;
1337 }
1338 return 0;
1339
1340 out_free_drive:
1341 kfree(drive);
1342 out_nomem:
1343 ide_port_free_devices(hwif);
1344 return -ENOMEM;
1345 }
1346
1347 struct ide_host *ide_host_alloc(const struct ide_port_info *d,
1348 struct ide_hw **hws, unsigned int n_ports)
1349 {
1350 struct ide_host *host;
1351 struct device *dev = hws[0] ? hws[0]->dev : NULL;
1352 int node = dev ? dev_to_node(dev) : -1;
1353 int i;
1354
1355 host = kzalloc_node(sizeof(*host), GFP_KERNEL, node);
1356 if (host == NULL)
1357 return NULL;
1358
1359 for (i = 0; i < n_ports; i++) {
1360 ide_hwif_t *hwif;
1361 int idx;
1362
1363 if (hws[i] == NULL)
1364 continue;
1365
1366 hwif = kzalloc_node(sizeof(*hwif), GFP_KERNEL, node);
1367 if (hwif == NULL)
1368 continue;
1369
1370 if (ide_port_alloc_devices(hwif, node) < 0) {
1371 kfree(hwif);
1372 continue;
1373 }
1374
1375 idx = ide_find_port_slot(d);
1376 if (idx < 0) {
1377 printk(KERN_ERR "%s: no free slot for interface\n",
1378 d ? d->name : "ide");
1379 ide_port_free_devices(hwif);
1380 kfree(hwif);
1381 continue;
1382 }
1383
1384 ide_init_port_data(hwif, idx);
1385
1386 hwif->host = host;
1387
1388 host->ports[i] = hwif;
1389 host->n_ports++;
1390 }
1391
1392 if (host->n_ports == 0) {
1393 kfree(host);
1394 return NULL;
1395 }
1396
1397 host->dev[0] = dev;
1398
1399 if (d) {
1400 host->init_chipset = d->init_chipset;
1401 host->get_lock = d->get_lock;
1402 host->release_lock = d->release_lock;
1403 host->host_flags = d->host_flags;
1404 host->irq_flags = d->irq_flags;
1405 }
1406
1407 return host;
1408 }
1409 EXPORT_SYMBOL_GPL(ide_host_alloc);
1410
1411 static void ide_port_free(ide_hwif_t *hwif)
1412 {
1413 ide_port_free_devices(hwif);
1414 ide_free_port_slot(hwif->index);
1415 kfree(hwif);
1416 }
1417
1418 static void ide_disable_port(ide_hwif_t *hwif)
1419 {
1420 struct ide_host *host = hwif->host;
1421 int i;
1422
1423 printk(KERN_INFO "%s: disabling port\n", hwif->name);
1424
1425 for (i = 0; i < MAX_HOST_PORTS; i++) {
1426 if (host->ports[i] == hwif) {
1427 host->ports[i] = NULL;
1428 host->n_ports--;
1429 }
1430 }
1431
1432 ide_port_free(hwif);
1433 }
1434
1435 int ide_host_register(struct ide_host *host, const struct ide_port_info *d,
1436 struct ide_hw **hws)
1437 {
1438 ide_hwif_t *hwif, *mate = NULL;
1439 int i, j = 0;
1440
1441 pr_warn("legacy IDE will be removed in 2021, please switch to libata\n"
1442 "Report any missing HW support to linux-ide@vger.kernel.org\n");
1443
1444 ide_host_for_each_port(i, hwif, host) {
1445 if (hwif == NULL) {
1446 mate = NULL;
1447 continue;
1448 }
1449
1450 ide_init_port_hw(hwif, hws[i]);
1451 ide_port_apply_params(hwif);
1452
1453 if ((i & 1) && mate) {
1454 hwif->mate = mate;
1455 mate->mate = hwif;
1456 }
1457
1458 mate = (i & 1) ? NULL : hwif;
1459
1460 ide_init_port(hwif, i & 1, d);
1461 ide_port_cable_detect(hwif);
1462
1463 hwif->port_flags |= IDE_PFLAG_PROBING;
1464
1465 ide_port_init_devices(hwif);
1466 }
1467
1468 ide_host_for_each_port(i, hwif, host) {
1469 if (hwif == NULL)
1470 continue;
1471
1472 if (ide_probe_port(hwif) == 0)
1473 hwif->present = 1;
1474
1475 hwif->port_flags &= ~IDE_PFLAG_PROBING;
1476
1477 if ((hwif->host_flags & IDE_HFLAG_4DRIVES) == 0 ||
1478 hwif->mate == NULL || hwif->mate->present == 0) {
1479 if (ide_register_port(hwif)) {
1480 ide_disable_port(hwif);
1481 continue;
1482 }
1483 }
1484
1485 if (hwif->present)
1486 ide_port_tune_devices(hwif);
1487 }
1488
1489 ide_host_enable_irqs(host);
1490
1491 ide_host_for_each_port(i, hwif, host) {
1492 if (hwif == NULL)
1493 continue;
1494
1495 if (hwif_init(hwif) == 0) {
1496 printk(KERN_INFO "%s: failed to initialize IDE "
1497 "interface\n", hwif->name);
1498 device_unregister(hwif->portdev);
1499 device_unregister(&hwif->gendev);
1500 ide_disable_port(hwif);
1501 continue;
1502 }
1503
1504 if (hwif->present)
1505 if (ide_port_setup_devices(hwif) == 0) {
1506 hwif->present = 0;
1507 continue;
1508 }
1509
1510 j++;
1511
1512 ide_acpi_init_port(hwif);
1513
1514 if (hwif->present)
1515 ide_acpi_port_init_devices(hwif);
1516 }
1517
1518 ide_host_for_each_port(i, hwif, host) {
1519 if (hwif == NULL)
1520 continue;
1521
1522 ide_sysfs_register_port(hwif);
1523 ide_proc_register_port(hwif);
1524
1525 if (hwif->present) {
1526 ide_proc_port_register_devices(hwif);
1527 hwif_register_devices(hwif);
1528 }
1529 }
1530
1531 return j ? 0 : -1;
1532 }
1533 EXPORT_SYMBOL_GPL(ide_host_register);
1534
1535 int ide_host_add(const struct ide_port_info *d, struct ide_hw **hws,
1536 unsigned int n_ports, struct ide_host **hostp)
1537 {
1538 struct ide_host *host;
1539 int rc;
1540
1541 host = ide_host_alloc(d, hws, n_ports);
1542 if (host == NULL)
1543 return -ENOMEM;
1544
1545 rc = ide_host_register(host, d, hws);
1546 if (rc) {
1547 ide_host_free(host);
1548 return rc;
1549 }
1550
1551 if (hostp)
1552 *hostp = host;
1553
1554 return 0;
1555 }
1556 EXPORT_SYMBOL_GPL(ide_host_add);
1557
1558 static void __ide_port_unregister_devices(ide_hwif_t *hwif)
1559 {
1560 ide_drive_t *drive;
1561 int i;
1562
1563 ide_port_for_each_present_dev(i, drive, hwif) {
1564 device_unregister(&drive->gendev);
1565 wait_for_completion(&drive->gendev_rel_comp);
1566 }
1567 }
1568
1569 void ide_port_unregister_devices(ide_hwif_t *hwif)
1570 {
1571 mutex_lock(&ide_cfg_mtx);
1572 __ide_port_unregister_devices(hwif);
1573 hwif->present = 0;
1574 ide_port_init_devices_data(hwif);
1575 mutex_unlock(&ide_cfg_mtx);
1576 }
1577 EXPORT_SYMBOL_GPL(ide_port_unregister_devices);
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593 static void ide_unregister(ide_hwif_t *hwif)
1594 {
1595 BUG_ON(in_interrupt());
1596 BUG_ON(irqs_disabled());
1597
1598 mutex_lock(&ide_cfg_mtx);
1599
1600 if (hwif->present) {
1601 __ide_port_unregister_devices(hwif);
1602 hwif->present = 0;
1603 }
1604
1605 ide_proc_unregister_port(hwif);
1606
1607 if (!hwif->host->get_lock)
1608 free_irq(hwif->irq, hwif);
1609
1610 device_unregister(hwif->portdev);
1611 device_unregister(&hwif->gendev);
1612 wait_for_completion(&hwif->gendev_rel_comp);
1613
1614
1615
1616
1617 blk_unregister_region(MKDEV(hwif->major, 0), MAX_DRIVES<<PARTN_BITS);
1618 kfree(hwif->sg_table);
1619 unregister_blkdev(hwif->major, hwif->name);
1620
1621 ide_release_dma_engine(hwif);
1622
1623 mutex_unlock(&ide_cfg_mtx);
1624 }
1625
1626 void ide_host_free(struct ide_host *host)
1627 {
1628 ide_hwif_t *hwif;
1629 int i;
1630
1631 ide_host_for_each_port(i, hwif, host) {
1632 if (hwif)
1633 ide_port_free(hwif);
1634 }
1635
1636 kfree(host);
1637 }
1638 EXPORT_SYMBOL_GPL(ide_host_free);
1639
1640 void ide_host_remove(struct ide_host *host)
1641 {
1642 ide_hwif_t *hwif;
1643 int i;
1644
1645 ide_host_for_each_port(i, hwif, host) {
1646 if (hwif)
1647 ide_unregister(hwif);
1648 }
1649
1650 ide_host_free(host);
1651 }
1652 EXPORT_SYMBOL_GPL(ide_host_remove);
1653
1654 void ide_port_scan(ide_hwif_t *hwif)
1655 {
1656 int rc;
1657
1658 ide_port_apply_params(hwif);
1659 ide_port_cable_detect(hwif);
1660
1661 hwif->port_flags |= IDE_PFLAG_PROBING;
1662
1663 ide_port_init_devices(hwif);
1664
1665 rc = ide_probe_port(hwif);
1666
1667 hwif->port_flags &= ~IDE_PFLAG_PROBING;
1668
1669 if (rc < 0)
1670 return;
1671
1672 hwif->present = 1;
1673
1674 ide_port_tune_devices(hwif);
1675 ide_port_setup_devices(hwif);
1676 ide_acpi_port_init_devices(hwif);
1677 hwif_register_devices(hwif);
1678 ide_proc_port_register_devices(hwif);
1679 }
1680 EXPORT_SYMBOL_GPL(ide_port_scan);