static int initialize_device(struct usb_device *dev) { libusb_device *newlib_dev = dev->dev; int num_configurations; size_t alloc_size; int r; int i; /* device descriptor is identical in both libs */ r = libusb_get_device_descriptor(newlib_dev, (struct libusb_device_descriptor *) &dev->descriptor); if (r < 0) { usbi_err("error %d getting device descriptor", r); return compat_err(r); } num_configurations = dev->descriptor.bNumConfigurations; alloc_size = sizeof(struct usb_config_descriptor) * num_configurations; dev->config = malloc(alloc_size); if (!dev->config) return -ENOMEM; memset(dev->config, 0, alloc_size); /* even though structures are identical, we can't just use libusb-1.0's * config descriptors because we have to store all configurations in * a single flat memory area (libusb-1.0 provides separate allocations). * we hand-copy libusb-1.0's descriptors into our own structures. */ for (i = 0; i < num_configurations; i++) { struct libusb_config_descriptor *newlib_config; r = libusb_get_config_descriptor(newlib_dev, i, &newlib_config); if (r < 0) { clear_device(dev); free(dev->config); return compat_err(r); } r = copy_config_descriptor(dev->config + i, newlib_config); libusb_free_config_descriptor(newlib_config); if (r < 0) { clear_device(dev); free(dev->config); return r; } } /* libusb doesn't implement this and it doesn't seem that important. If * someone asks for it, we can implement it in v1.1 or later. */ dev->num_children = 0; dev->children = NULL; libusb_ref_device(newlib_dev); return 0; }
/* Print a statement for copying an array to or from the device, * or for initializing or clearing the device. * The statement identifier of a copying node is called * "to_device_<array name>" or "from_device_<array name>" and * its user pointer points to the gpu_array_info of the array * that needs to be copied. * The node for initializing the device is called "init_device". * The node for clearing the device is called "clear_device". * * Extract the array (if any) from the identifier and call * init_device, clear_device, copy_array_to_device or copy_array_from_device. */ static __isl_give isl_printer *print_device_node(__isl_take isl_printer *p, __isl_keep isl_ast_node *node, struct gpu_prog *prog) { isl_ast_expr *expr, *arg; isl_id *id; const char *name; struct gpu_array_info *array; expr = isl_ast_node_user_get_expr(node); arg = isl_ast_expr_get_op_arg(expr, 0); id = isl_ast_expr_get_id(arg); name = isl_id_get_name(id); array = isl_id_get_user(id); isl_id_free(id); isl_ast_expr_free(arg); isl_ast_expr_free(expr); if (!name) return isl_printer_free(p); if (!strcmp(name, "init_device")) return init_device(p, prog); if (!strcmp(name, "clear_device")) return clear_device(p, prog); if (!array) return isl_printer_free(p); if (!prefixcmp(name, "to_device")) return copy_array_to_device(p, array); else return copy_array_from_device(p, array); }
static void ilo_remove(struct pci_dev *pdev) { int i, minor; struct ilo_hwinfo *ilo_hw = pci_get_drvdata(pdev); clear_device(ilo_hw); minor = MINOR(ilo_hw->cdev.dev); for (i = minor; i < minor + MAX_CCB; i++) device_destroy(ilo_class, MKDEV(ilo_major, i)); cdev_del(&ilo_hw->cdev); ilo_disable_interrupts(ilo_hw); free_irq(pdev->irq, ilo_hw); ilo_unmap_device(pdev, ilo_hw); pci_release_regions(pdev); /* * pci_disable_device(pdev) used to be here. But this PCI device has * two functions with interrupt lines connected to a single pin. The * other one is a USB host controller. So when we disable the PIN here * e.g. by rmmod hpilo, the controller stops working. It is because * the interrupt link is disabled in ACPI since it is not refcounted * yet. See acpi_pci_link_free_irq called from acpi_pci_irq_disable. */ kfree(ilo_hw); ilo_hwdev[(minor / MAX_CCB)] = 0; }
static void ilo_remove(struct pci_dev *pdev) { int i, minor; struct ilo_hwinfo *ilo_hw = pci_get_drvdata(pdev); clear_device(ilo_hw); minor = MINOR(ilo_hw->cdev.dev); for (i = minor; i < minor + MAX_CCB; i++) device_destroy(ilo_class, MKDEV(ilo_major, i)); cdev_del(&ilo_hw->cdev); ilo_disable_interrupts(ilo_hw); free_irq(pdev->irq, ilo_hw); ilo_unmap_device(pdev, ilo_hw); pci_release_regions(pdev); pci_disable_device(pdev); kfree(ilo_hw); ilo_hwdev[(minor / MAX_CCB)] = 0; }
// // Clean up the device then add it to the interrupt list and enable it. // void ser_attach_intr(DEV_OMAP *dev) { uintptr_t *port = dev->port; // interrupt sources except transmit and modem status interrupt unsigned ier = OMAP_IER_RHR|OMAP_IER_LS; // According to the National bug sheet you must wait for the transmit // holding register to be empty. do { } while((read_omap(port[OMAP_UART_LSR]) & OMAP_LSR_TXRDY) == 0); clear_device(port); dev->iid = InterruptAttach(dev->intr, ser_intr, dev, 0, 0); // Enable modem status interrupt (default) if (!dev->no_msr_int) { ier |= OMAP_IER_MS; } // Enable interrupt sources. write_omap(port[OMAP_UART_IER], ier); }
PairGPUDeviceT::~PairGPUDevice() { clear_device(); }
static int __devinit ilo_probe(struct pci_dev *pdev, const struct pci_device_id *ent) { int devnum, minor, start, error; struct ilo_hwinfo *ilo_hw; /* find a free range for device files */ for (devnum = 0; devnum < MAX_ILO_DEV; devnum++) { if (ilo_hwdev[devnum] == 0) { ilo_hwdev[devnum] = 1; break; } } if (devnum == MAX_ILO_DEV) { dev_err(&pdev->dev, "Error finding free device\n"); return -ENODEV; } /* track global allocations for this device */ error = -ENOMEM; ilo_hw = kzalloc(sizeof(*ilo_hw), GFP_KERNEL); if (!ilo_hw) goto out; ilo_hw->ilo_dev = pdev; spin_lock_init(&ilo_hw->alloc_lock); spin_lock_init(&ilo_hw->fifo_lock); spin_lock_init(&ilo_hw->open_lock); error = pci_enable_device(pdev); if (error) goto free; pci_set_master(pdev); error = pci_request_regions(pdev, ILO_NAME); if (error) goto disable; error = ilo_map_device(pdev, ilo_hw); if (error) goto free_regions; pci_set_drvdata(pdev, ilo_hw); clear_device(ilo_hw); error = request_irq(pdev->irq, ilo_isr, IRQF_SHARED, "hpilo", ilo_hw); if (error) goto unmap; ilo_enable_interrupts(ilo_hw); cdev_init(&ilo_hw->cdev, &ilo_fops); ilo_hw->cdev.owner = THIS_MODULE; start = devnum * MAX_CCB; error = cdev_add(&ilo_hw->cdev, MKDEV(ilo_major, start), MAX_CCB); if (error) { dev_err(&pdev->dev, "Could not add cdev\n"); goto remove_isr; } for (minor = 0 ; minor < MAX_CCB; minor++) { struct device *dev; dev = device_create(ilo_class, &pdev->dev, MKDEV(ilo_major, minor), NULL, "hpilo!d%dccb%d", devnum, minor); if (IS_ERR(dev)) dev_err(&pdev->dev, "Could not create files\n"); } return 0; remove_isr: ilo_disable_interrupts(ilo_hw); free_irq(pdev->irq, ilo_hw); unmap: ilo_unmap_device(pdev, ilo_hw); free_regions: pci_release_regions(pdev); disable: /* pci_disable_device(pdev); see comment in ilo_remove */ free: kfree(ilo_hw); out: ilo_hwdev[devnum] = 0; return error; }
/* ----------------===============----------------------- */ int main(int argnum, char **argval) { HANDLE PlxHandle[N_SURF+1] ; DEVICE_LOCATION Device[N_SURF+1] ; PLX_INTR PlxIntr, Plxstate ; RETURN_CODE rc ; unsigned short dataByte=0;//,d_out; unsigned short evNo=0; unsigned short rawDataArray[N_SURF][N_CHN][N_SCA]; // Read only one chip per trigger. PM float calibDataArray[N_SURF][N_CHN][N_SCA]; unsigned short data_scl[N_RF]; unsigned short data_rfpw[N_RF]; unsigned long numChipEvents[N_CHP]; TURFIO_struct data_turf; int i, j, boardIndex, ftmo=0,tmo=0,doingEvent=0 ; int numDevices, n_ev=0 ; float mean_dt=0; int testVal; char *outputDir ; int tmpGPIO; int selftrig=0; int value=0; printf(" Start dacSet program !!\n") ; if (verbose) printf(" size of buffer is %d bytes.\n", sizeof(dataByte)) ; // Initialize devices if ((numDevices = init_device(PlxHandle, Device)) < 0) { printf("Problem initializing devices\n"); return 0 ; } for(i=0;i<4;i++) { if (verbose) printf("RJN: now, %.4x %.4x [%s - bus %.2x slot %.2x]\n", Device[i].DeviceId, Device[i].VendorId, Device[i].SerialNumber, Device[i].BusNumber, Device[i].SlotNumber); } // Clear devices clear_device(PlxHandle,numDevices); /* initialize interrupt structure. */ memset(&PlxIntr, 0, sizeof(PLX_INTR)) ; memset(&Plxstate, 0, sizeof(PLX_INTR)) ; /* ----------- despite of "Prog.Ref." manual description, IopToPciInt did not change LINT select enable (level/edge trigger sw.) bits. 10-Nov-04 ----------- */ PlxIntr.IopToPciInt = 1 ; /* LINT1 interrupt line */ PlxIntr.IopToPciInt_2 = 1 ; /* LINT2 interrupt line */ PlxIntr.PciMainInt = 1 ; while ((doingEvent++ < n_ev) || (n_ev == 0)) { setDAC(PlxHandle,numDevices,value); value++; if (selftrig){ /* --- send a trigger ---- */ printf(" try to trigger it locally.\n") ; for(i=0;i<numDevices-1;++i) if (cntl_set_SURF(PlxHandle[i], LTrig) != ApiSuccess) printf(" failed to set LTrig flag on SURF %d.\n",i) ; } /* Wait for ready to read (Evt_F) */ tmo=0; if(verbose) printf("Sitting here about to wait\n"); /* RJN change PlxHandle[numDevices-2] to PlxHandle[0] */ while (!((tmpGPIO=PlxRegisterRead(PlxHandle[0], PCI9030_GP_IO_CTRL, &rc)) & 0x800) && (selftrig?(++tmo<N_TMO):1)){ if(verbose>3) printf("SURF 1 GPIO: 0x%x %d\n",tmpGPIO,tmpGPIO); if(selftrig) usleep(1000); /*RJN put it back in for selftrig */ usleep(1000); /*GV removed, RJN put it back in as it completely abuses the CPU*/ } if (tmo == N_TMO){ printf(" Timed out (%d ms) while waiting for Evt_F flag in self trigger mode.\n", N_TMO) ; continue; } if(verbose) printf("Triggered, event %d (by software counter).\n",doingEvent); //usleep (100) ; /* I doubt Evt_f is issued in proper timing. SM */ /* Loop over SURF boards and read out */ for(boardIndex=0;boardIndex<numDevices-1;boardIndex++){ printf("What is boardIndex %d\n",boardIndex); if(verbose) printf(" GPIO register contents SURF %d = %x\n",boardIndex, PlxRegisterRead(PlxHandle[boardIndex], PCI9030_GP_IO_CTRL, &rc)) ; if(verbose) printf(" int reg contents SURF %d = %x\n",boardIndex, PlxRegisterRead(PlxHandle[boardIndex], PCI9030_INT_CTRL_STAT, &rc)) ; // Readout event number if (PlxBusIopRead(PlxHandle[boardIndex], IopSpace0, 0x0, TRUE, &dataByte, 2, BitSize16) != ApiSuccess) printf(" failed to read event number on SURF %d\n", boardIndex) ; if(verbose) printf("SURF %d, ID %d, event no %d\n",boardIndex,dataByte>>14,dataByte); if(boardIndex==0) evNo=dataByte; if(cntl_set_SURF(PlxHandle[boardIndex],EvNoD)!=ApiSuccess) printf("Failed to set EvNoD on SURF %d\n",boardIndex); // still too short!?! usleep(1000000000); // wait a bit according to Jing // Wait for Lab_F ftmo=0; if(verbose) printf("SURF %d, waiting for Lab_F\n",boardIndex); testVal=PlxRegisterRead(PlxHandle[boardIndex], PCI9030_GP_IO_CTRL, &rc); while(!(testVal & 0x4000) && (++ftmo<N_FTMO)){ /* printf("testVal %x\n",testVal); */ usleep(1); /* RJN/GV changed from usleep(1000) */ testVal=PlxRegisterRead(PlxHandle[boardIndex], PCI9030_GP_IO_CTRL, &rc); } if (ftmo == N_FTMO){ printf("No Lab_F flag for %d ms, bailing on the event\n",N_FTMO); continue; } if(cntl_set_SURF(PlxHandle[boardIndex],LabD)!=ApiSuccess) printf("Failed to set LabD on SURF %d\n",boardIndex); // Read trigger scalars for(i=0;i<N_RF;++i){ if (PlxBusIopRead(PlxHandle[boardIndex], IopSpace0, 0x0, TRUE, &dataByte, 2, BitSize16) != ApiSuccess) printf(" failed to read IO. surf=%d, rf scl=%d\n", boardIndex, i) ; data_scl[i]=dataByte; if(verbose>2) printf("SURF %d, SCL %d: %d\n",boardIndex,i,dataByte); } if(cntl_set_SURF(PlxHandle[boardIndex],SclD)!=ApiSuccess) printf("Failed to set SclD on SURF %d\n",boardIndex); // Read RF power for(i=0;i<N_RF;++i){ if (PlxBusIopRead(PlxHandle[boardIndex], IopSpace0, 0x0, TRUE, &dataByte, 2, BitSize16) != ApiSuccess) printf(" failed to read IO. surf=%d, rf pw=%d\n", boardIndex, i) ; data_rfpw[i]=dataByte; if(verbose>2) printf("SURF %d, RF %d: %d\n",boardIndex,i,dataByte); } if(cntl_set_SURF(PlxHandle[boardIndex],RFpwD)!=ApiSuccess) printf("Failed to set RFpwD on SURF %d\n",boardIndex); } /* this is closing for(numDevices) loop. */ /* Readout TURFIO */ boardIndex=numDevices-1; /* RJN Hack */ /* boardIndex=1; */ if(verbose) printf(" GPIO register contents TURFIO = %x\n", PlxRegisterRead(PlxHandle[boardIndex], PCI9030_GP_IO_CTRL, &rc)) ; if(verbose) printf(" int reg contents TURFIO = %x\n", PlxRegisterRead(PlxHandle[boardIndex], PCI9030_INT_CTRL_STAT, &rc)) ; // Burn one TURFIO read if (PlxBusIopRead(PlxHandle[boardIndex], IopSpace0, 0x0, TRUE, &dataByte, 2, BitSize16) != ApiSuccess) printf(" failed to read TURF IO port. Burn read.\n"); data_turf.interval=0; data_turf.time=10; data_turf.rawtrig=10; if(verbose) printf("TURF Handle number: %d\n",boardIndex); for (j=0 ; j<16 ; j++) { // Loop 16 times over return structure for (i=0; i<16 ; i++) { if (PlxBusIopRead(PlxHandle[boardIndex], IopSpace0, 0x0, TRUE, &dataByte, 2, BitSize16) != ApiSuccess) printf(" failed to read TURF IO port. loop %d, word %d.\n",j,i) ; // Need to byteswap TURFIO words. This might get changed in hardware, so beware. PM 04/01/05 dataByte=byteswap_uh(dataByte); if((verbose>2 && j==0) || verbose>3) printf("TURFIO %d (%d): %hu\n",i,j,dataByte); if(j==0){ //Interpret on the first pass only switch(i){ case 0: data_turf.rawtrig=dataByte; break; case 1: data_turf.L3Atrig=dataByte; break; case 2: data_turf.pps1=dataByte; break; case 3: data_turf.pps1+=dataByte*65536; break; case 4: data_turf.time=dataByte; break; case 5: data_turf.time+=dataByte*65536; break; case 6: data_turf.interval=dataByte; break; case 7: data_turf.interval+=dataByte*65536; break; default: data_turf.rate[i/4-2][i%4]=dataByte; break; } } } } if(verbose>2){ printf("raw: %hu\nL3A: %hu\n1PPS: %lu\ntime: %lu\nint: %lu\n", data_turf.rawtrig,data_turf.L3Atrig,data_turf.pps1,data_turf.time, data_turf.interval); for(i=8;i<16;++i) printf("Rate[%d][%d]=%d\n",i/4-2,i%4,data_turf.rate[i/4-2][i%4]); } if(verbose) printf("Done reading\n"); mean_dt=mean_dt*(doingEvent-1)/doingEvent+(float)data_turf.interval/doingEvent; printf("Trig no: %hu, trig time: %lu, 1PPS: %lu, dt: %lu\n",data_turf.rawtrig, data_turf.time,data_turf.pps1,data_turf.interval); printf("mean dt: %f\n",mean_dt); // Clear boards for(i=0;i<numDevices-1;++i) if (cntl_set_SURF(PlxHandle[i], ClrEvt) != ApiSuccess) printf(" failed to send clear event pulse on SURF %d.\n",i) ; } /* closing master while loop. */ // Clean up for(i=0;i<numDevices;++i) PlxPciDeviceClose(PlxHandle[i] ); return 1 ; }
static void free_device(struct usb_device *dev) { clear_device(dev); libusb_unref_device(dev->dev); free(dev); }