Lines Matching defs:ace
37 * 1. obtain the ace->lock spinlock.
38 * 2. loop on ace_fsm_dostate() until the ace->fsm_continue flag is
224 u16(*in) (struct ace_device * ace, int reg);
225 void (*out) (struct ace_device * ace, int reg, u16 val);
226 void (*datain) (struct ace_device * ace);
227 void (*dataout) (struct ace_device * ace);
231 static u16 ace_in_8(struct ace_device *ace, int reg)
233 void __iomem *r = ace->baseaddr + reg;
237 static void ace_out_8(struct ace_device *ace, int reg, u16 val)
239 void __iomem *r = ace->baseaddr + reg;
244 static void ace_datain_8(struct ace_device *ace)
246 void __iomem *r = ace->baseaddr + 0x40;
247 u8 *dst = ace->data_ptr;
251 ace->data_ptr = dst;
254 static void ace_dataout_8(struct ace_device *ace)
256 void __iomem *r = ace->baseaddr + 0x40;
257 u8 *src = ace->data_ptr;
261 ace->data_ptr = src;
272 static u16 ace_in_be16(struct ace_device *ace, int reg)
274 return in_be16(ace->baseaddr + reg);
277 static void ace_out_be16(struct ace_device *ace, int reg, u16 val)
279 out_be16(ace->baseaddr + reg, val);
282 static void ace_datain_be16(struct ace_device *ace)
285 u16 *dst = ace->data_ptr;
287 *dst++ = in_le16(ace->baseaddr + 0x40);
288 ace->data_ptr = dst;
291 static void ace_dataout_be16(struct ace_device *ace)
294 u16 *src = ace->data_ptr;
296 out_le16(ace->baseaddr + 0x40, *src++);
297 ace->data_ptr = src;
301 static u16 ace_in_le16(struct ace_device *ace, int reg)
303 return in_le16(ace->baseaddr + reg);
306 static void ace_out_le16(struct ace_device *ace, int reg, u16 val)
308 out_le16(ace->baseaddr + reg, val);
311 static void ace_datain_le16(struct ace_device *ace)
314 u16 *dst = ace->data_ptr;
316 *dst++ = in_be16(ace->baseaddr + 0x40);
317 ace->data_ptr = dst;
320 static void ace_dataout_le16(struct ace_device *ace)
323 u16 *src = ace->data_ptr;
325 out_be16(ace->baseaddr + 0x40, *src++);
326 ace->data_ptr = src;
343 static inline u16 ace_in(struct ace_device *ace, int reg)
345 return ace->reg_ops->in(ace, reg);
348 static inline u32 ace_in32(struct ace_device *ace, int reg)
350 return ace_in(ace, reg) | (ace_in(ace, reg + 2) << 16);
353 static inline void ace_out(struct ace_device *ace, int reg, u16 val)
355 ace->reg_ops->out(ace, reg, val);
358 static inline void ace_out32(struct ace_device *ace, int reg, u32 val)
360 ace_out(ace, reg, val);
361 ace_out(ace, reg + 2, val >> 16);
393 static void ace_dump_regs(struct ace_device *ace)
395 dev_info(ace->dev,
399 ace_in32(ace, ACE_CTRL),
400 ace_in(ace, ACE_SECCNTCMD),
401 ace_in(ace, ACE_VERSION),
402 ace_in32(ace, ACE_STATUS),
403 ace_in32(ace, ACE_MPULBA),
404 ace_in(ace, ACE_BUSMODE),
405 ace_in32(ace, ACE_ERROR),
406 ace_in32(ace, ACE_CFGLBA), ace_in(ace, ACE_FATSTAT));
446 static inline void ace_fsm_yieldpoll(struct ace_device *ace)
448 tasklet_schedule(&ace->fsm_tasklet);
449 ace->fsm_continue_flag = 0;
452 static inline void ace_fsm_yield(struct ace_device *ace)
454 dev_dbg(ace->dev, "%s()\n", __func__);
455 ace_fsm_yieldpoll(ace);
459 static inline void ace_fsm_yieldirq(struct ace_device *ace)
461 dev_dbg(ace->dev, "ace_fsm_yieldirq()\n");
463 if (ace->irq > 0)
464 ace->fsm_continue_flag = 0;
466 ace_fsm_yieldpoll(ace);
471 struct ace_device *ace = q->queuedata;
473 return !list_empty(&ace->rq_list);
479 struct ace_device *ace = q->queuedata;
482 rq = list_first_entry_or_null(&ace->rq_list, struct request, queuelist);
491 static void ace_fsm_dostate(struct ace_device *ace)
499 dev_dbg(ace->dev, "fsm_state=%i, id_req_count=%i\n",
500 ace->fsm_state, ace->id_req_count);
505 status = ace_in32(ace, ACE_STATUS);
507 ace->fsm_state = ACE_FSM_STATE_IDLE;
508 ace->media_change = 1;
509 set_capacity(ace->gd, 0);
510 dev_info(ace->dev, "No CF in slot\n");
513 if (ace->req) {
514 blk_mq_end_request(ace->req, BLK_STS_IOERR);
515 ace->req = NULL;
517 while ((req = ace_get_next_request(ace->queue)) != NULL)
521 ace->fsm_state = ACE_FSM_STATE_IDLE;
522 ace->id_result = -EIO;
523 while (ace->id_req_count) {
524 complete(&ace->id_completion);
525 ace->id_req_count--;
529 switch (ace->fsm_state) {
532 if (ace->id_req_count || ace_has_next_request(ace->queue)) {
533 ace->fsm_iter_num++;
534 ace->fsm_state = ACE_FSM_STATE_REQ_LOCK;
535 mod_timer(&ace->stall_timer, jiffies + HZ);
536 if (!timer_pending(&ace->stall_timer))
537 add_timer(&ace->stall_timer);
540 del_timer(&ace->stall_timer);
541 ace->fsm_continue_flag = 0;
545 if (ace_in(ace, ACE_STATUS) & ACE_STATUS_MPULOCK) {
547 ace->fsm_state = ACE_FSM_STATE_WAIT_CFREADY;
552 val = ace_in(ace, ACE_CTRL);
553 ace_out(ace, ACE_CTRL, val | ACE_CTRL_LOCKREQ);
554 ace->fsm_state = ACE_FSM_STATE_WAIT_LOCK;
558 if (ace_in(ace, ACE_STATUS) & ACE_STATUS_MPULOCK) {
560 ace->fsm_state = ACE_FSM_STATE_WAIT_CFREADY;
565 ace_fsm_yield(ace);
569 status = ace_in32(ace, ACE_STATUS);
573 ace_fsm_yield(ace);
578 if (ace->id_req_count)
579 ace->fsm_state = ACE_FSM_STATE_IDENTIFY_PREPARE;
581 ace->fsm_state = ACE_FSM_STATE_REQ_PREPARE;
586 ace->fsm_task = ACE_TASK_IDENTIFY;
587 ace->data_ptr = ace->cf_id;
588 ace->data_count = ACE_BUF_PER_SECTOR;
589 ace_out(ace, ACE_SECCNTCMD, ACE_SECCNTCMD_IDENTIFY);
592 val = ace_in(ace, ACE_CTRL);
593 ace_out(ace, ACE_CTRL, val | ACE_CTRL_CFGRESET);
597 ace->fsm_state = ACE_FSM_STATE_IDENTIFY_TRANSFER;
598 ace_fsm_yieldirq(ace);
603 status = ace_in32(ace, ACE_STATUS);
605 dev_dbg(ace->dev, "CFBSY set; t=%i iter=%i dc=%i\n",
606 ace->fsm_task, ace->fsm_iter_num,
607 ace->data_count);
608 ace_fsm_yield(ace);
612 ace_fsm_yield(ace);
617 ace->reg_ops->datain(ace);
618 ace->data_count--;
621 if (ace->data_count != 0) {
622 ace_fsm_yieldirq(ace);
627 dev_dbg(ace->dev, "identify finished\n");
628 ace->fsm_state = ACE_FSM_STATE_IDENTIFY_COMPLETE;
632 ace_fix_driveid(ace->cf_id);
633 ace_dump_mem(ace->cf_id, 512); /* Debug: Dump out disk ID */
635 if (ace->data_result) {
637 ace->media_change = 1;
638 set_capacity(ace->gd, 0);
639 dev_err(ace->dev, "error fetching CF id (%i)\n",
640 ace->data_result);
642 ace->media_change = 0;
645 set_capacity(ace->gd,
646 ata_id_u32(ace->cf_id, ATA_ID_LBA_CAPACITY));
647 dev_info(ace->dev, "capacity: %i sectors\n",
648 ata_id_u32(ace->cf_id, ATA_ID_LBA_CAPACITY));
652 ace->fsm_state = ACE_FSM_STATE_IDLE;
653 ace->id_result = ace->data_result;
654 while (ace->id_req_count) {
655 complete(&ace->id_completion);
656 ace->id_req_count--;
661 req = ace_get_next_request(ace->queue);
663 ace->fsm_state = ACE_FSM_STATE_IDLE;
668 dev_dbg(ace->dev,
674 ace->req = req;
675 ace->data_ptr = bio_data(req->bio);
676 ace->data_count = blk_rq_cur_sectors(req) * ACE_BUF_PER_SECTOR;
677 ace_out32(ace, ACE_MPULBA, blk_rq_pos(req) & 0x0FFFFFFF);
682 dev_dbg(ace->dev, "write data\n");
683 ace->fsm_task = ACE_TASK_WRITE;
684 ace_out(ace, ACE_SECCNTCMD,
688 dev_dbg(ace->dev, "read data\n");
689 ace->fsm_task = ACE_TASK_READ;
690 ace_out(ace, ACE_SECCNTCMD,
695 val = ace_in(ace, ACE_CTRL);
696 ace_out(ace, ACE_CTRL, val | ACE_CTRL_CFGRESET);
701 ace->fsm_state = ACE_FSM_STATE_REQ_TRANSFER;
702 if (ace->fsm_task == ACE_TASK_READ)
703 ace_fsm_yieldirq(ace); /* wait for data ready */
708 status = ace_in32(ace, ACE_STATUS);
710 dev_dbg(ace->dev,
712 ace->fsm_task, ace->fsm_iter_num,
713 blk_rq_cur_sectors(ace->req) * 16,
714 ace->data_count, ace->in_irq);
715 ace_fsm_yield(ace); /* need to poll CFBSY bit */
719 dev_dbg(ace->dev,
721 ace->fsm_task, ace->fsm_iter_num,
722 blk_rq_cur_sectors(ace->req) * 16,
723 ace->data_count, ace->in_irq);
724 ace_fsm_yieldirq(ace);
729 if (ace->fsm_task == ACE_TASK_WRITE)
730 ace->reg_ops->dataout(ace);
732 ace->reg_ops->datain(ace);
733 ace->data_count--;
736 if (ace->data_count != 0) {
737 ace_fsm_yieldirq(ace);
742 if (blk_update_request(ace->req, BLK_STS_OK,
743 blk_rq_cur_bytes(ace->req))) {
744 /* dev_dbg(ace->dev, "next block; h=%u c=%u\n",
745 * blk_rq_sectors(ace->req),
746 * blk_rq_cur_sectors(ace->req));
748 ace->data_ptr = bio_data(ace->req->bio);
749 ace->data_count = blk_rq_cur_sectors(ace->req) * 16;
750 ace_fsm_yieldirq(ace);
754 ace->fsm_state = ACE_FSM_STATE_REQ_COMPLETE;
758 ace->req = NULL;
761 ace->fsm_state = ACE_FSM_STATE_IDLE;
765 ace->fsm_state = ACE_FSM_STATE_IDLE;
772 struct ace_device *ace = (void *)data;
775 spin_lock_irqsave(&ace->lock, flags);
778 ace->fsm_continue_flag = 1;
779 while (ace->fsm_continue_flag)
780 ace_fsm_dostate(ace);
782 spin_unlock_irqrestore(&ace->lock, flags);
787 struct ace_device *ace = from_timer(ace, t, stall_timer);
790 dev_warn(ace->dev,
792 ace->fsm_state, ace->fsm_task, ace->fsm_iter_num,
793 ace->data_count);
794 spin_lock_irqsave(&ace->lock, flags);
798 mod_timer(&ace->stall_timer, jiffies + HZ);
801 ace->fsm_continue_flag = 1;
802 while (ace->fsm_continue_flag)
803 ace_fsm_dostate(ace);
805 spin_unlock_irqrestore(&ace->lock, flags);
811 static int ace_interrupt_checkstate(struct ace_device *ace)
813 u32 sreg = ace_in32(ace, ACE_STATUS);
814 u16 creg = ace_in(ace, ACE_CTRL);
819 dev_err(ace->dev, "transfer failure\n");
820 ace_dump_regs(ace);
830 struct ace_device *ace = dev_id;
833 spin_lock(&ace->lock);
834 ace->in_irq = 1;
837 creg = ace_in(ace, ACE_CTRL);
838 ace_out(ace, ACE_CTRL, creg | ACE_CTRL_RESETIRQ);
839 ace_out(ace, ACE_CTRL, creg);
842 if (ace_interrupt_checkstate(ace))
843 ace->data_result = -EIO;
845 if (ace->fsm_task == 0) {
846 dev_err(ace->dev,
848 ace_in32(ace, ACE_STATUS), ace_in32(ace, ACE_CTRL),
849 ace_in(ace, ACE_SECCNTCMD));
850 dev_err(ace->dev, "fsm_task=%i fsm_state=%i data_count=%i\n",
851 ace->fsm_task, ace->fsm_state, ace->data_count);
855 ace->fsm_continue_flag = 1;
856 while (ace->fsm_continue_flag)
857 ace_fsm_dostate(ace);
860 ace->in_irq = 0;
861 spin_unlock(&ace->lock);
872 struct ace_device *ace = hctx->queue->queuedata;
880 spin_lock_irq(&ace->lock);
881 list_add_tail(&req->queuelist, &ace->rq_list);
882 spin_unlock_irq(&ace->lock);
884 tasklet_schedule(&ace->fsm_tasklet);
890 struct ace_device *ace = gd->private_data;
891 dev_dbg(ace->dev, "ace_check_events(): %i\n", ace->media_change);
893 return ace->media_change ? DISK_EVENT_MEDIA_CHANGE : 0;
896 static void ace_media_changed(struct ace_device *ace)
900 dev_dbg(ace->dev, "requesting cf id and scheduling tasklet\n");
902 spin_lock_irqsave(&ace->lock, flags);
903 ace->id_req_count++;
904 spin_unlock_irqrestore(&ace->lock, flags);
906 tasklet_schedule(&ace->fsm_tasklet);
907 wait_for_completion(&ace->id_completion);
909 dev_dbg(ace->dev, "revalidate complete\n");
914 struct ace_device *ace = bdev->bd_disk->private_data;
917 dev_dbg(ace->dev, "ace_open() users=%i\n", ace->users + 1);
920 spin_lock_irqsave(&ace->lock, flags);
921 ace->users++;
922 spin_unlock_irqrestore(&ace->lock, flags);
924 if (bdev_check_media_change(bdev) && ace->media_change)
925 ace_media_changed(ace);
933 struct ace_device *ace = disk->private_data;
937 dev_dbg(ace->dev, "ace_release() users=%i\n", ace->users - 1);
940 spin_lock_irqsave(&ace->lock, flags);
941 ace->users--;
942 if (ace->users == 0) {
943 val = ace_in(ace, ACE_CTRL);
944 ace_out(ace, ACE_CTRL, val & ~ACE_CTRL_LOCKREQ);
946 spin_unlock_irqrestore(&ace->lock, flags);
952 struct ace_device *ace = bdev->bd_disk->private_data;
953 u16 *cf_id = ace->cf_id;
955 dev_dbg(ace->dev, "ace_getgeo()\n");
979 static int ace_setup(struct ace_device *ace)
985 dev_dbg(ace->dev, "ace_setup(ace=0x%p)\n", ace);
986 dev_dbg(ace->dev, "physaddr=0x%llx irq=%i\n",
987 (unsigned long long)ace->physaddr, ace->irq);
989 spin_lock_init(&ace->lock);
990 init_completion(&ace->id_completion);
991 INIT_LIST_HEAD(&ace->rq_list);
996 ace->baseaddr = ioremap(ace->physaddr, 0x80);
997 if (!ace->baseaddr)
1003 tasklet_init(&ace->fsm_tasklet, ace_fsm_tasklet, (unsigned long)ace);
1004 timer_setup(&ace->stall_timer, ace_stall_timer, 0);
1009 ace->queue = blk_mq_init_sq_queue(&ace->tag_set, &ace_mq_ops, 2,
1011 if (IS_ERR(ace->queue)) {
1012 rc = PTR_ERR(ace->queue);
1013 ace->queue = NULL;
1016 ace->queue->queuedata = ace;
1018 blk_queue_logical_block_size(ace->queue, 512);
1019 blk_queue_bounce_limit(ace->queue, BLK_BOUNCE_HIGH);
1024 ace->gd = alloc_disk(ACE_NUM_MINORS);
1025 if (!ace->gd)
1028 ace->gd->major = ace_major;
1029 ace->gd->first_minor = ace->id * ACE_NUM_MINORS;
1030 ace->gd->fops = &ace_fops;
1031 ace->gd->events = DISK_EVENT_MEDIA_CHANGE;
1032 ace->gd->queue = ace->queue;
1033 ace->gd->private_data = ace;
1034 snprintf(ace->gd->disk_name, 32, "xs%c", ace->id + 'a');
1037 if (ace->bus_width == ACE_BUS_WIDTH_16) {
1039 ace_out_le16(ace, ACE_BUSMODE, 0x0101);
1042 if (ace_in_le16(ace, ACE_BUSMODE) == 0x0001)
1043 ace->reg_ops = &ace_reg_le16_ops;
1045 ace->reg_ops = &ace_reg_be16_ops;
1047 ace_out_8(ace, ACE_BUSMODE, 0x00);
1048 ace->reg_ops = &ace_reg_8_ops;
1052 version = ace_in(ace, ACE_VERSION);
1057 ace_out(ace, ACE_CTRL, ACE_CTRL_FORCECFGMODE |
1061 if (ace->irq > 0) {
1062 rc = request_irq(ace->irq, ace_interrupt, 0, "systemace", ace);
1065 dev_err(ace->dev, "request_irq failed\n");
1066 ace->irq = rc;
1071 val = ace_in(ace, ACE_CTRL);
1073 ace_out(ace, ACE_CTRL, val);
1076 dev_info(ace->dev, "Xilinx SystemACE revision %i.%i.%i\n",
1078 dev_dbg(ace->dev, "physaddr 0x%llx, mapped to 0x%p, irq=%i\n",
1079 (unsigned long long) ace->physaddr, ace->baseaddr, ace->irq);
1081 ace->media_change = 1;
1082 ace_media_changed(ace);
1085 add_disk(ace->gd);
1091 ace->gd->queue = NULL;
1092 put_disk(ace->gd);
1094 blk_cleanup_queue(ace->queue);
1095 blk_mq_free_tag_set(&ace->tag_set);
1097 iounmap(ace->baseaddr);
1099 dev_info(ace->dev, "xsysace: error initializing device at 0x%llx\n",
1100 (unsigned long long) ace->physaddr);
1104 static void ace_teardown(struct ace_device *ace)
1106 if (ace->gd) {
1107 del_gendisk(ace->gd);
1108 put_disk(ace->gd);
1111 if (ace->queue) {
1112 blk_cleanup_queue(ace->queue);
1113 blk_mq_free_tag_set(&ace->tag_set);
1116 tasklet_kill(&ace->fsm_tasklet);
1118 if (ace->irq > 0)
1119 free_irq(ace->irq, ace);
1121 iounmap(ace->baseaddr);
1127 struct ace_device *ace;
1131 /* Allocate and initialize the ace device structure */
1132 ace = kzalloc(sizeof(struct ace_device), GFP_KERNEL);
1133 if (!ace) {
1138 ace->dev = dev;
1139 ace->id = id;
1140 ace->physaddr = physaddr;
1141 ace->irq = irq;
1142 ace->bus_width = bus_width;
1145 rc = ace_setup(ace);
1149 dev_set_drvdata(dev, ace);
1154 kfree(ace);
1162 struct ace_device *ace = dev_get_drvdata(dev);
1165 if (ace) {
1166 ace_teardown(ace);
1168 kfree(ace);