Lines Matching defs:hp_sdc
49 * Busy polling for IBF clear wastes CPU cycles and bus cycles. hp_sdc.ibf
53 * hp_sdc state. Whenever a register is written hp_sdc.ibf is set to 1.
56 * starting at 0x70 are kept track of in hp_sdc.wi, and .r7[], respectively,
64 #include <linux/hp_sdc.h>
111 static hp_i8042_sdc hp_sdc; /* All driver state is kept in here. */
119 write_lock_irqsave(&hp_sdc.ibf_lock, flags);
120 status = sdc_readb(hp_sdc.status_io);
122 hp_sdc.ibf = 0;
123 write_unlock_irqrestore(&hp_sdc.ibf_lock, flags);
130 return sdc_readb(hp_sdc.data_io);
137 write_lock_irqsave(&hp_sdc.ibf_lock, flags);
138 hp_sdc.ibf = 1;
140 hp_sdc.wi = 0xff;
141 sdc_writeb(val, hp_sdc.status_io);
142 write_unlock_irqrestore(&hp_sdc.ibf_lock, flags);
149 write_lock_irqsave(&hp_sdc.ibf_lock, flags);
150 hp_sdc.ibf = 1;
151 sdc_writeb(val, hp_sdc.data_io);
152 write_unlock_irqrestore(&hp_sdc.ibf_lock, flags);
164 lock = &hp_sdc.ibf_lock;
167 if (!hp_sdc.ibf) {
173 while (sdc_readb(hp_sdc.status_io) & HP_SDC_STATUS_IBF)
175 hp_sdc.ibf = 0;
185 read_lock(&hp_sdc.rtq_lock);
186 if (hp_sdc.rcurr < 0) {
187 read_unlock(&hp_sdc.rtq_lock);
190 curr = hp_sdc.tq[hp_sdc.rcurr];
191 read_unlock(&hp_sdc.rtq_lock);
195 hp_sdc.rqty -= 2;
196 hp_sdc.rtime = ktime_get();
198 if (hp_sdc.rqty <= 0) {
211 write_lock(&hp_sdc.rtq_lock);
212 hp_sdc.rcurr = -1;
213 hp_sdc.rqty = 0;
214 write_unlock(&hp_sdc.rtq_lock);
215 tasklet_schedule(&hp_sdc.task);
238 read_lock(&hp_sdc.hook_lock);
239 if (hp_sdc.timer != NULL)
240 hp_sdc.timer(irq, dev_id, status, data);
241 read_unlock(&hp_sdc.hook_lock);
250 read_lock(&hp_sdc.hook_lock);
251 if (hp_sdc.hil != NULL)
252 hp_sdc.hil(irq, dev_id, status, data);
253 read_unlock(&hp_sdc.hook_lock);
257 read_lock(&hp_sdc.hook_lock);
258 if (hp_sdc.pup != NULL)
259 hp_sdc.pup(irq, dev_id, status, data);
262 read_unlock(&hp_sdc.hook_lock);
266 read_lock(&hp_sdc.hook_lock);
267 if (hp_sdc.cooked != NULL)
268 hp_sdc.cooked(irq, dev_id, status, data);
269 read_unlock(&hp_sdc.hook_lock);
286 read_lock(&hp_sdc.hook_lock);
287 if (hp_sdc.timer != NULL)
288 hp_sdc.timer(irq, dev_id, status, 0);
289 read_unlock(&hp_sdc.hook_lock);
306 write_lock_irq(&hp_sdc.rtq_lock);
308 if (hp_sdc.rcurr >= 0) {
311 if (ktime_after(now, ktime_add_us(hp_sdc.rtime,
316 curr = hp_sdc.tq[hp_sdc.rcurr];
322 ktime_us_delta(now, hp_sdc.rtime));
323 curr->idx += hp_sdc.rqty;
324 hp_sdc.rqty = 0;
341 hp_sdc.rcurr = -1;
344 write_unlock_irq(&hp_sdc.rtq_lock);
356 write_lock(&hp_sdc.lock);
360 if (hp_sdc.ibf) {
362 if (hp_sdc.ibf)
368 if (hp_sdc.wcurr < 0)
369 hp_sdc.wcurr = 0;
370 read_lock_irq(&hp_sdc.rtq_lock);
371 if (hp_sdc.rcurr == hp_sdc.wcurr)
372 hp_sdc.wcurr++;
373 read_unlock_irq(&hp_sdc.rtq_lock);
374 if (hp_sdc.wcurr >= HP_SDC_QUEUE_LEN)
375 hp_sdc.wcurr = 0;
376 curridx = hp_sdc.wcurr;
378 if (hp_sdc.tq[curridx] != NULL)
381 while (++curridx != hp_sdc.wcurr) {
386 read_lock_irq(&hp_sdc.rtq_lock);
387 if (hp_sdc.rcurr == curridx) {
388 read_unlock_irq(&hp_sdc.rtq_lock);
391 read_unlock_irq(&hp_sdc.rtq_lock);
392 if (hp_sdc.tq[curridx] != NULL)
395 if (curridx == hp_sdc.wcurr) { /* There's nothing queued to do. */
398 hp_sdc.wcurr = curridx;
403 if (hp_sdc.set_im) {
404 hp_sdc_status_out8(hp_sdc.im | HP_SDC_CMD_SET_IM);
405 hp_sdc.set_im = 0;
409 if (hp_sdc.wcurr == -1)
412 curr = hp_sdc.tq[curridx];
416 hp_sdc.tq[curridx] = NULL;
418 hp_sdc.wcurr++;
419 if (hp_sdc.wcurr >= HP_SDC_QUEUE_LEN)
420 hp_sdc.wcurr = 0;
430 hp_sdc.tq[curridx] = NULL;
432 hp_sdc.wcurr++;
433 if (hp_sdc.wcurr >= HP_SDC_QUEUE_LEN)
434 hp_sdc.wcurr = 0;
486 w7[0] = (mask & 1) ? curr->seq[++idx] : hp_sdc.r7[0];
487 w7[1] = (mask & 2) ? curr->seq[++idx] : hp_sdc.r7[1];
488 w7[2] = (mask & 4) ? curr->seq[++idx] : hp_sdc.r7[2];
489 w7[3] = (mask & 8) ? curr->seq[++idx] : hp_sdc.r7[3];
491 if (hp_sdc.wi > 0x73 || hp_sdc.wi < 0x70 ||
492 w7[hp_sdc.wi - 0x70] == hp_sdc.r7[hp_sdc.wi - 0x70]) {
496 while (i < 4 && w7[i] == hp_sdc.r7[i])
501 hp_sdc.wi = 0x70 + i;
514 hp_sdc_data_out8(w7[hp_sdc.wi - 0x70]);
515 hp_sdc.r7[hp_sdc.wi - 0x70] = w7[hp_sdc.wi - 0x70];
516 hp_sdc.wi++; /* write index register autoincrements */
520 while ((i < 4) && w7[i] == hp_sdc.r7[i])
533 read_lock_irq(&hp_sdc.rtq_lock);
534 if (hp_sdc.rcurr >= 0) {
535 read_unlock_irq(&hp_sdc.rtq_lock);
538 read_unlock_irq(&hp_sdc.rtq_lock);
550 hp_sdc.rqty = curr->seq[curr->idx];
551 hp_sdc.rtime = ktime_get();
554 write_lock_irq(&hp_sdc.rtq_lock);
555 hp_sdc.rcurr = curridx;
556 write_unlock_irq(&hp_sdc.rtq_lock);
573 hp_sdc.tq[curridx] = NULL;
579 hp_sdc.wcurr++;
580 if (hp_sdc.wcurr >= HP_SDC_QUEUE_LEN)
581 hp_sdc.wcurr = 0;
586 if (!hp_sdc.ibf && limit++ < 20)
590 if (hp_sdc.wcurr >= 0)
591 tasklet_schedule(&hp_sdc.task);
592 write_unlock(&hp_sdc.lock);
609 if (hp_sdc.tq[i] == this)
617 if (hp_sdc.tq[i] == NULL) {
618 hp_sdc.tq[i] = this;
619 tasklet_schedule(&hp_sdc.task);
635 write_lock_irqsave(&hp_sdc.lock, flags);
637 write_unlock_irqrestore(&hp_sdc.lock,flags);
647 write_lock_irqsave(&hp_sdc.lock, flags);
652 if (hp_sdc.tq[i] == this)
653 hp_sdc.tq[i] = NULL;
655 write_unlock_irqrestore(&hp_sdc.lock, flags);
664 if (callback == NULL || hp_sdc.dev == NULL)
667 write_lock_irq(&hp_sdc.hook_lock);
668 if (hp_sdc.timer != NULL) {
669 write_unlock_irq(&hp_sdc.hook_lock);
673 hp_sdc.timer = callback;
675 hp_sdc.im &= ~HP_SDC_IM_FH;
676 hp_sdc.im &= ~HP_SDC_IM_PT;
677 hp_sdc.im &= ~HP_SDC_IM_TIMERS;
678 hp_sdc.set_im = 1;
679 write_unlock_irq(&hp_sdc.hook_lock);
681 tasklet_schedule(&hp_sdc.task);
688 if (callback == NULL || hp_sdc.dev == NULL)
691 write_lock_irq(&hp_sdc.hook_lock);
692 if (hp_sdc.hil != NULL) {
693 write_unlock_irq(&hp_sdc.hook_lock);
697 hp_sdc.hil = callback;
698 hp_sdc.im &= ~(HP_SDC_IM_HIL | HP_SDC_IM_RESET);
699 hp_sdc.set_im = 1;
700 write_unlock_irq(&hp_sdc.hook_lock);
702 tasklet_schedule(&hp_sdc.task);
709 if (callback == NULL || hp_sdc.dev == NULL)
712 write_lock_irq(&hp_sdc.hook_lock);
713 if (hp_sdc.cooked != NULL) {
714 write_unlock_irq(&hp_sdc.hook_lock);
719 hp_sdc.cooked = callback;
720 hp_sdc.im &= ~(HP_SDC_IM_HIL | HP_SDC_IM_RESET);
721 hp_sdc.set_im = 1;
722 write_unlock_irq(&hp_sdc.hook_lock);
724 tasklet_schedule(&hp_sdc.task);
731 write_lock_irq(&hp_sdc.hook_lock);
732 if ((callback != hp_sdc.timer) ||
733 (hp_sdc.timer == NULL)) {
734 write_unlock_irq(&hp_sdc.hook_lock);
739 hp_sdc.timer = NULL;
740 hp_sdc.im |= HP_SDC_IM_TIMERS;
741 hp_sdc.im |= HP_SDC_IM_FH;
742 hp_sdc.im |= HP_SDC_IM_PT;
743 hp_sdc.set_im = 1;
744 write_unlock_irq(&hp_sdc.hook_lock);
745 tasklet_schedule(&hp_sdc.task);
752 write_lock_irq(&hp_sdc.hook_lock);
753 if ((callback != hp_sdc.hil) ||
754 (hp_sdc.hil == NULL)) {
755 write_unlock_irq(&hp_sdc.hook_lock);
759 hp_sdc.hil = NULL;
761 if(hp_sdc.cooked == NULL) {
762 hp_sdc.im |= (HP_SDC_IM_HIL | HP_SDC_IM_RESET);
763 hp_sdc.set_im = 1;
765 write_unlock_irq(&hp_sdc.hook_lock);
766 tasklet_schedule(&hp_sdc.task);
773 write_lock_irq(&hp_sdc.hook_lock);
774 if ((callback != hp_sdc.cooked) ||
775 (hp_sdc.cooked == NULL)) {
776 write_unlock_irq(&hp_sdc.hook_lock);
780 hp_sdc.cooked = NULL;
782 if(hp_sdc.hil == NULL) {
783 hp_sdc.im |= (HP_SDC_IM_HIL | HP_SDC_IM_RESET);
784 hp_sdc.set_im = 1;
786 write_unlock_irq(&hp_sdc.hook_lock);
787 tasklet_schedule(&hp_sdc.task);
796 tasklet_schedule(&hp_sdc.task);
798 mod_timer(&hp_sdc.kicker, jiffies + HZ);
821 .name = "hp_sdc",
835 rwlock_init(&hp_sdc.lock);
836 rwlock_init(&hp_sdc.ibf_lock);
837 rwlock_init(&hp_sdc.rtq_lock);
838 rwlock_init(&hp_sdc.hook_lock);
840 hp_sdc.timer = NULL;
841 hp_sdc.hil = NULL;
842 hp_sdc.pup = NULL;
843 hp_sdc.cooked = NULL;
844 hp_sdc.im = HP_SDC_IM_MASK; /* Mask maskable irqs */
845 hp_sdc.set_im = 1;
846 hp_sdc.wi = 0xff;
847 hp_sdc.r7[0] = 0xff;
848 hp_sdc.r7[1] = 0xff;
849 hp_sdc.r7[2] = 0xff;
850 hp_sdc.r7[3] = 0xff;
851 hp_sdc.ibf = 1;
853 memset(&hp_sdc.tq, 0, sizeof(hp_sdc.tq));
855 hp_sdc.wcurr = -1;
856 hp_sdc.rcurr = -1;
857 hp_sdc.rqty = 0;
859 hp_sdc.dev_err = -ENODEV;
862 if (!hp_sdc.base_io)
866 if (!hp_sdc.irq)
869 hp_sdc.dev_err = -EBUSY;
873 if (request_region(hp_sdc.data_io, 2, hp_sdc_driver.name))
878 if (request_irq(hp_sdc.irq, &hp_sdc_isr, IRQF_SHARED,
879 "HP SDC", &hp_sdc))
883 if (request_irq(hp_sdc.nmi, &hp_sdc_nmisr, IRQF_SHARED,
884 "HP SDC NMI", &hp_sdc))
888 hp_sdc.base_io, hp_sdc.irq, hp_sdc.nmi);
893 tasklet_init(&hp_sdc.task, hp_sdc_tasklet, 0);
909 timer_setup(&hp_sdc.kicker, hp_sdc_kicker, 0);
910 hp_sdc.kicker.expires = jiffies + HZ;
911 add_timer(&hp_sdc.kicker);
913 hp_sdc.dev_err = 0;
916 free_irq(hp_sdc.irq, &hp_sdc);
918 release_region(hp_sdc.data_io, 2);
921 errstr, (void *)hp_sdc.base_io, hp_sdc.irq, hp_sdc.nmi);
922 hp_sdc.dev = NULL;
924 return hp_sdc.dev_err;
940 if (hp_sdc.dev != NULL)
943 hp_sdc.dev = d;
944 hp_sdc.irq = d->irq;
945 hp_sdc.nmi = d->aux_irq;
946 hp_sdc.base_io = d->hpa.start;
947 hp_sdc.data_io = d->hpa.start + 0x800;
948 hp_sdc.status_io = d->hpa.start + 0x801;
967 if (!hp_sdc.dev)
970 write_lock_irq(&hp_sdc.lock);
974 sdc_writeb(HP_SDC_CMD_SET_IM | HP_SDC_IM_MASK, hp_sdc.status_io);
979 free_irq(hp_sdc.nmi, &hp_sdc);
980 free_irq(hp_sdc.irq, &hp_sdc);
981 write_unlock_irq(&hp_sdc.lock);
983 del_timer_sync(&hp_sdc.kicker);
985 tasklet_kill(&hp_sdc.task);
1008 hp_sdc.dev = NULL;
1009 hp_sdc.dev_err = 0;
1019 hp_sdc.irq = 1;
1020 hp_sdc.nmi = 7;
1021 hp_sdc.base_io = (unsigned long) 0xf0428000;
1022 hp_sdc.data_io = (unsigned long) hp_sdc.base_io + 1;
1023 hp_sdc.status_io = (unsigned long) hp_sdc.base_io + 3;
1024 if (!copy_from_kernel_nofault(&i, (unsigned char *)hp_sdc.data_io, 1))
1025 hp_sdc.dev = (void *)1;
1026 hp_sdc.dev_err = hp_sdc_init();
1028 if (hp_sdc.dev == NULL) {
1030 return hp_sdc.dev_err;
1058 hp_sdc.r11 = tq_init_seq[4];
1059 if (hp_sdc.r11 & HP_SDC_CFG_NEW) {
1073 hp_sdc.r7e = tq_init_seq[4];
1074 HP_SDC_XTD_REV_STRINGS(hp_sdc.r7e & HP_SDC_XTD_REV, str)
1076 if (hp_sdc.r7e & HP_SDC_XTD_BEEPER)
1078 if (hp_sdc.r7e & HP_SDC_XTD_BBRTC)
1096 (hp_sdc.r11 & HP_SDC_CFG_REV) ? "3300" : "2564/3087");