Lines Matching defs:isp116x
41 include/linux/usb-isp116x.h for more info. Some broken
67 #include <linux/usb/isp116x.h>
76 #include "isp116x.h"
84 static const char hcd_name[] = "isp116x-hcd";
91 static void write_ptddata_to_fifo(struct isp116x *isp116x, void *buf, int len)
107 isp116x_raw_write_data16(isp116x, w);
110 isp116x_write_data16(isp116x, (u16) * dp);
115 isp116x_raw_write_data16(isp116x, cpu_to_le16(*dp2++));
119 isp116x_write_data16(isp116x, 0xff & *((u8 *) dp2));
122 isp116x_raw_write_data16(isp116x, 0);
128 static void read_ptddata_from_fifo(struct isp116x *isp116x, void *buf, int len)
142 w = isp116x_raw_read_data16(isp116x);
148 *dp = 0xff & isp116x_read_data16(isp116x);
153 *dp2++ = le16_to_cpu(isp116x_raw_read_data16(isp116x));
157 *(u8 *) dp2 = 0xff & isp116x_read_data16(isp116x);
160 isp116x_raw_read_data16(isp116x);
167 static void pack_fifo(struct isp116x *isp116x)
171 int buflen = isp116x->atl_last_dir == PTD_DIR_IN
172 ? isp116x->atl_bufshrt : isp116x->atl_buflen;
174 isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT);
175 isp116x_write_reg16(isp116x, HCXFERCTR, buflen);
176 isp116x_write_addr(isp116x, HCATLPORT | ISP116x_WRITE_OFFSET);
177 for (ep = isp116x->atl_active; ep; ep = ep->active) {
181 isp116x_write_data16(isp116x, ptd->count);
182 isp116x_write_data16(isp116x, ptd->mps);
183 isp116x_write_data16(isp116x, ptd->len);
184 isp116x_write_data16(isp116x, ptd->faddr);
187 if (ep->active || (isp116x->atl_last_dir != PTD_DIR_IN)) {
188 write_ptddata_to_fifo(isp116x, ep->data, ep->length);
199 static void unpack_fifo(struct isp116x *isp116x)
203 int buflen = isp116x->atl_last_dir == PTD_DIR_IN
204 ? isp116x->atl_buflen : isp116x->atl_bufshrt;
206 isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT);
207 isp116x_write_reg16(isp116x, HCXFERCTR, buflen);
208 isp116x_write_addr(isp116x, HCATLPORT);
209 for (ep = isp116x->atl_active; ep; ep = ep->active) {
211 ptd->count = isp116x_read_data16(isp116x);
212 ptd->mps = isp116x_read_data16(isp116x);
213 ptd->len = isp116x_read_data16(isp116x);
214 ptd->faddr = isp116x_read_data16(isp116x);
217 if (ep->active || (isp116x->atl_last_dir == PTD_DIR_IN)) {
218 read_ptddata_from_fifo(isp116x, ep->data, ep->length);
232 static void preproc_atl_queue(struct isp116x *isp116x)
239 for (ep = isp116x->atl_active; ep; ep = ep->active) {
284 isp116x->atl_last_dir = dir;
286 isp116x->atl_bufshrt = sizeof(struct ptd) + isp116x->atl_buflen;
287 isp116x->atl_buflen = isp116x->atl_bufshrt + ALIGN(len, 4);
295 static void finish_request(struct isp116x *isp116x, struct isp116x_ep *ep,
297 __releases(isp116x->lock) __acquires(isp116x->lock)
308 usb_hcd_unlink_urb_from_ep(isp116x_to_hcd(isp116x), urb);
309 spin_unlock(&isp116x->lock);
310 usb_hcd_giveback_urb(isp116x_to_hcd(isp116x), urb, status);
311 spin_lock(&isp116x->lock);
327 struct isp116x_ep **prev = &isp116x->periodic[i];
333 isp116x->load[i] -= ep->load;
336 isp116x_to_hcd(isp116x)->self.bandwidth_allocated -=
340 if (!--isp116x->periodic_count) {
341 isp116x->irqenb &= ~HCuPINT_SOF;
342 isp116x->irqenb |= HCuPINT_ATL;
349 static void postproc_atl_queue(struct isp116x *isp116x)
359 for (ep = isp116x->atl_active; ep; ep = ep->active) {
413 /* Take into account idiosyncracies of the isp116x chip
473 finish_request(isp116x, ep, urb, status);
481 static void start_atl_transfers(struct isp116x *isp116x)
488 if (atomic_read(&isp116x->atl_finishing))
491 if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state))
495 if (isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_FULL)
498 isp116x->atl_active = NULL;
499 isp116x->atl_buflen = isp116x->atl_bufshrt = 0;
502 if (isp116x->periodic_count) {
503 isp116x->fmindex = index =
504 (isp116x->fmindex + 1) & (PERIODIC_SIZE - 1);
505 if ((load = isp116x->load[index])) {
508 isp116x->atl_active = last_ep =
509 isp116x->periodic[index];
517 list_for_each_entry(ep, &isp116x->async, schedule) {
560 isp116x->atl_active = ep;
565 if ((&isp116x->async)->next != (&isp116x->async)->prev)
566 list_move(&isp116x->async, (&isp116x->async)->next);
568 if (isp116x->atl_active) {
569 preproc_atl_queue(isp116x);
570 pack_fifo(isp116x);
577 static void finish_atl_transfers(struct isp116x *isp116x)
579 if (!isp116x->atl_active)
582 if (!(isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_DONE))
585 atomic_inc(&isp116x->atl_finishing);
586 unpack_fifo(isp116x);
587 postproc_atl_queue(isp116x);
588 atomic_dec(&isp116x->atl_finishing);
593 struct isp116x *isp116x = hcd_to_isp116x(hcd);
597 spin_lock(&isp116x->lock);
598 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
599 irqstat = isp116x_read_reg16(isp116x, HCuPINT);
600 isp116x_write_reg16(isp116x, HCuPINT, irqstat);
604 finish_atl_transfers(isp116x);
608 u32 intstat = isp116x_read_reg32(isp116x, HCINTSTAT);
609 isp116x_write_reg32(isp116x, HCINTSTAT, intstat);
633 start_atl_transfers(isp116x);
636 isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
638 spin_unlock(&isp116x->lock);
651 static int balance(struct isp116x *isp116x, u16 period, u16 load)
658 if (branch < 0 || isp116x->load[branch] > isp116x->load[i]) {
662 if ((isp116x->load[j] + load)
674 /* NB! ALL the code above this point runs with isp116x->lock
684 struct isp116x *isp116x = hcd_to_isp116x(hcd);
710 spin_lock_irqsave(&isp116x->lock, flags);
772 list_add_tail(&ep->schedule, &isp116x->async);
783 ep->branch = ret = balance(isp116x, ep->period, ep->load);
788 urb->start_frame = (isp116x->fmindex & (PERIODIC_SIZE - 1))
796 struct isp116x_ep **prev = &isp116x->periodic[i];
809 isp116x->load[i] += ep->load;
814 if (!isp116x->periodic_count++) {
815 isp116x->irqenb &= ~HCuPINT_ATL;
816 isp116x->irqenb |= HCuPINT_SOF;
817 isp116x_write_reg16(isp116x, HCuPINTENB,
818 isp116x->irqenb);
823 start_atl_transfers(isp116x);
829 spin_unlock_irqrestore(&isp116x->lock, flags);
839 struct isp116x *isp116x = hcd_to_isp116x(hcd);
845 spin_lock_irqsave(&isp116x->lock, flags);
857 for (ep_act = isp116x->atl_active; ep_act;
867 finish_request(isp116x, ep, urb, status);
869 spin_unlock_irqrestore(&isp116x->lock, flags);
894 struct isp116x *isp116x = hcd_to_isp116x(hcd);
898 spin_lock_irqsave(&isp116x->lock, flags);
899 fmnum = isp116x_read_reg32(isp116x, HCFMNUM);
900 spin_unlock_irqrestore(&isp116x->lock, flags);
909 struct isp116x *isp116x = hcd_to_isp116x(hcd);
921 ports = isp116x->rhdesca & RH_A_NDP;
922 spin_lock_irqsave(&isp116x->lock, flags);
923 isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
924 if (isp116x->rhstatus & (RH_HS_LPSC | RH_HS_OCIC))
930 u32 status = isp116x_read_reg32(isp116x, i ? HCRHPORT2 : HCRHPORT1);
938 spin_unlock_irqrestore(&isp116x->lock, flags);
942 static void isp116x_hub_descriptor(struct isp116x *isp116x,
945 u32 reg = isp116x->rhdesca;
966 static inline void root_port_reset(struct isp116x *isp116x, unsigned port)
976 spin_lock_irqsave(&isp116x->lock, flags);
979 tmp = isp116x_read_reg32(isp116x, port ?
987 spin_unlock_irqrestore(&isp116x->lock, flags);
991 isp116x_write_reg32(isp116x, port ? HCRHPORT2 :
993 spin_unlock_irqrestore(&isp116x->lock, flags);
1003 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1006 int ports = isp116x->rhdesca & RH_A_NDP;
1015 spin_lock_irqsave(&isp116x->lock, flags);
1016 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_OCIC);
1017 spin_unlock_irqrestore(&isp116x->lock, flags);
1038 isp116x_hub_descriptor(isp116x,
1049 spin_lock_irqsave(&isp116x->lock, flags);
1050 tmp = isp116x_read_reg32(isp116x, (--wIndex) ? HCRHPORT2 : HCRHPORT1);
1051 spin_unlock_irqrestore(&isp116x->lock, flags);
1097 spin_lock_irqsave(&isp116x->lock, flags);
1098 isp116x_write_reg32(isp116x, wIndex
1100 spin_unlock_irqrestore(&isp116x->lock, flags);
1110 spin_lock_irqsave(&isp116x->lock, flags);
1111 isp116x_write_reg32(isp116x, wIndex
1113 spin_unlock_irqrestore(&isp116x->lock, flags);
1117 spin_lock_irqsave(&isp116x->lock, flags);
1118 isp116x_write_reg32(isp116x, wIndex
1120 spin_unlock_irqrestore(&isp116x->lock, flags);
1124 root_port_reset(isp116x, wIndex);
1168 struct isp116x *isp116x = s->private;
1171 isp116x_to_hcd(isp116x)->product_desc, hcd_name,
1174 if (HC_IS_SUSPENDED(isp116x_to_hcd(isp116x)->state)) {
1178 if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state)) {
1183 spin_lock_irq(&isp116x->lock);
1184 dump_irq(s, "hc_irq_enable", isp116x_read_reg16(isp116x, HCuPINTENB));
1185 dump_irq(s, "hc_irq_status", isp116x_read_reg16(isp116x, HCuPINT));
1186 dump_int(s, "hc_int_enable", isp116x_read_reg32(isp116x, HCINTENB));
1187 dump_int(s, "hc_int_status", isp116x_read_reg32(isp116x, HCINTSTAT));
1188 isp116x_show_regs_seq(isp116x, s);
1189 spin_unlock_irq(&isp116x->lock);
1207 static int create_debug_file(struct isp116x *isp116x)
1209 isp116x->dentry = debugfs_create_file(hcd_name,
1210 S_IRUGO, NULL, isp116x,
1212 if (!isp116x->dentry)
1217 static void remove_debug_file(struct isp116x *isp116x)
1219 debugfs_remove(isp116x->dentry);
1234 static int isp116x_sw_reset(struct isp116x *isp116x)
1240 spin_lock_irqsave(&isp116x->lock, flags);
1241 isp116x_write_reg16(isp116x, HCSWRES, HCSWRES_MAGIC);
1242 isp116x_write_reg32(isp116x, HCCMDSTAT, HCCMDSTAT_HCR);
1246 if (!(isp116x_read_reg32(isp116x, HCCMDSTAT) & HCCMDSTAT_HCR))
1253 spin_unlock_irqrestore(&isp116x->lock, flags);
1259 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1264 ret = isp116x_sw_reset(isp116x);
1271 spin_lock_irq(&isp116x->lock);
1272 clkrdy = isp116x_read_reg16(isp116x, HCuPINT) & HCuPINT_CLKRDY;
1273 spin_unlock_irq(&isp116x->lock);
1289 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1293 spin_lock_irqsave(&isp116x->lock, flags);
1294 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1298 val = isp116x_read_reg32(isp116x, HCRHDESCA);
1300 isp116x_write_reg32(isp116x, HCRHDESCA, val);
1301 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_LPS);
1302 spin_unlock_irqrestore(&isp116x->lock, flags);
1304 isp116x_sw_reset(isp116x);
1312 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1313 struct isp116x_platform_data *board = isp116x->board;
1317 spin_lock_irqsave(&isp116x->lock, flags);
1320 isp116x_write_reg16(isp116x, HCuPINT, 0xff);
1321 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1323 val = isp116x_read_reg16(isp116x, HCCHIPID);
1326 spin_unlock_irqrestore(&isp116x->lock, flags);
1333 isp116x_write_reg16(isp116x, HCITLBUFLEN, ISP116x_ITL_BUFSIZE);
1334 isp116x_write_reg16(isp116x, HCATLBUFLEN, ISP116x_ATL_BUFSIZE);
1349 isp116x_write_reg16(isp116x, HCHWCFG, val);
1359 isp116x_write_reg32(isp116x, HCRHDESCA, val);
1360 isp116x->rhdesca = isp116x_read_reg32(isp116x, HCRHDESCA);
1363 isp116x_write_reg32(isp116x, HCRHDESCB, val);
1364 isp116x->rhdescb = isp116x_read_reg32(isp116x, HCRHDESCB);
1372 isp116x_write_reg32(isp116x, HCRHSTATUS, val);
1373 isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
1375 isp116x_write_reg32(isp116x, HCFMINTVL, 0x27782edf);
1380 isp116x->intenb = HCINT_MIE | HCINT_RHSC | HCINT_UE;
1382 isp116x->intenb |= HCINT_RD;
1383 isp116x->irqenb = HCuPINT_ATL | HCuPINT_OPR; /* | HCuPINT_SUSP; */
1384 isp116x_write_reg32(isp116x, HCINTENB, isp116x->intenb);
1385 isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
1391 isp116x_write_reg32(isp116x, HCCONTROL, val);
1394 isp116x_write_reg32(isp116x, HCRHPORT1, RH_PS_CCS);
1395 isp116x_write_reg32(isp116x, HCRHPORT2, RH_PS_CCS);
1397 isp116x_show_regs_log(isp116x);
1398 spin_unlock_irqrestore(&isp116x->lock, flags);
1406 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1411 spin_lock_irqsave(&isp116x->lock, flags);
1412 val = isp116x_read_reg32(isp116x, HCCONTROL);
1416 spin_unlock_irqrestore(&isp116x->lock, flags);
1423 spin_lock_irqsave(&isp116x->lock, flags);
1424 isp116x_write_reg32(isp116x, HCCONTROL, val);
1425 spin_unlock_irqrestore(&isp116x->lock, flags);
1430 isp116x_write_reg32(isp116x, HCCONTROL,
1436 spin_unlock_irqrestore(&isp116x->lock, flags);
1445 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1449 spin_lock_irq(&isp116x->lock);
1451 val = isp116x_read_reg32(isp116x, HCCONTROL);
1456 isp116x_write_reg32(isp116x, HCCONTROL, val);
1460 spin_unlock_irq(&isp116x->lock);
1465 spin_unlock_irq(&isp116x->lock);
1471 if ((isp116x->rhdesca & RH_A_NDP) == 2)
1477 val = isp116x->rhdesca & RH_A_NDP;
1480 isp116x_read_reg32(isp116x, val ? HCRHPORT2 : HCRHPORT1);
1485 isp116x_write_reg32(isp116x, RH_PS_POCI, val
1488 spin_unlock_irq(&isp116x->lock);
1494 spin_lock_irq(&isp116x->lock);
1495 val = isp116x_read_reg32(isp116x, HCCONTROL);
1496 isp116x_write_reg32(isp116x, HCCONTROL,
1498 spin_unlock_irq(&isp116x->lock);
1514 .hcd_priv_size = sizeof(struct isp116x),
1540 struct isp116x *isp116x;
1545 isp116x = hcd_to_isp116x(hcd);
1546 remove_debug_file(isp116x);
1549 iounmap(isp116x->data_reg);
1552 iounmap(isp116x->addr_reg);
1565 struct isp116x *isp116x;
1623 isp116x = hcd_to_isp116x(hcd);
1624 isp116x->data_reg = data_reg;
1625 isp116x->addr_reg = addr_reg;
1626 spin_lock_init(&isp116x->lock);
1627 INIT_LIST_HEAD(&isp116x->async);
1628 isp116x->board = pdev->dev.platform_data;
1630 if (!isp116x->board) {
1635 if (isp116x_check_platform_delay(isp116x)) {
1638 ERR("See comments in drivers/usb/host/isp116x-hcd.c\n");
1647 ret = create_debug_file(isp116x);
1699 MODULE_ALIAS("platform:isp116x-hcd");