touchscreen.c

gpm-1.20.0.tar.gz

  return ret ? ret : bytes_read;
}

/**
* Zmiana dla j眃ra 2.2.x z <code>select</code> na <code>poll</code>
*/
static unsigned int poll_touchscreen(struct file *file, struct poll_table_struct *_wait)
{
  struct usb_device *dev;
  struct tscrn_usb_data *tscrn;
  struct inode *inode;
  struct dentry *dentry;

  kdev_t minor;

  dentry = file->f_dentry;
  inode  = dentry->d_inode;
  minor = USB_TSCRN_MINOR(inode);
  

  dbg("poll_touchscreen(%d): entered", minor);

  if (!p_tscrn_table[minor])
  {
    err("poll_touchscreen(%d): invalid minor", minor);
    return 0;
    //return -ENODEV;
  };

  tscrn = p_tscrn_table[minor];
  dev   = tscrn->dev;

  //if(_selType != SEL_IN)
  //  return -EPERM;

  if((tscrn->pToWrite == tscrn->pToRead) || (tscrn->pToRead == NULL))
  {
    poll_wait(file, &tscrn->wait, _wait);
    return 0;
  };

  return 1;
};

static int ioctl_touchscreen(struct inode *inode, struct file *file,
    unsigned int cmd, unsigned long arg)
{
  struct usb_device *dev;
  struct tscrn_usb_data *tscrn;

  int nRet;

  kdev_t minor;

#ifdef __TEST_NO_DEVICE__
  return -ENODEV;
#endif 
  minor = USB_TSCRN_MINOR(inode);

  dbg("ioctl_touchscreen(%d): entered cmd=%d", minor,cmd);

  if (!p_tscrn_table[minor])
  {
    err("ioctl_touchscreen(%d): invalid minor", minor);
    return -ENODEV;
  }

  tscrn = p_tscrn_table[minor];
  dev   = tscrn->dev;

  switch (cmd)
  {
    case TSCRN_USER_REQUEST:
      {
        /* sends reset command */
        struct
        {
          __u8  data;
          __u8  request;
          __u16 value;
          __u16 index;
        } args;

        if (copy_from_user(&args, (void *)arg, sizeof(args)))
          return -EFAULT;

        // for the present a soft reset
        tscrn->setup_packet->requesttype = args.data;
        tscrn->setup_packet->request = args.request;
        tscrn->setup_packet->value = args.value;
        tscrn->setup_packet->index = args.index;
        tscrn->setup_packet->length = 0;
        FILL_CONTROL_URB(&tscrn->ctrlout, dev, 
            usb_sndctrlpipe(dev, 0), (unsigned char *)tscrn->setup_packet,
            NULL, 0, ctrl_touchscreen, tscrn);

        if ((nRet=usb_submit_urb(&tscrn->ctrlout)))
        {
          err("ioctl_touchscreen(%d): errror=%d status=%d.", minor, nRet, tscrn->ctrlout.status);
          return nRet;
        }
        dbg("ioctl_touchscreen(%d): cmd status=%d nRet=%d",minor,tscrn->ctrlout.status,nRet);
        interruptible_sleep_on(&tscrn->wait);
        dbg("ioctl_touchscreen(%d): cmd status=%d", minor, tscrn->ctrlout.status);
        return tscrn->ctrlout.status;
      };
    case TSCRN_CLEAR_HALT:
      {
        // when end_point is STALLED always returned -1 at first 
        // and OK on second exec, then end_point returns to normal state
        return usb_clear_halt(dev,0x00);//0x80
      };
    case TSCRN_HARD_RESET:
      {
        tscrn->setup_packet->requesttype = USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE;
        tscrn->setup_packet->request = TSCRN_USB_REQUEST_RESET;
        tscrn->setup_packet->value = TSCRN_USB_PARAM_HARD_RESET;
        tscrn->setup_packet->index = 0;
        tscrn->setup_packet->length = 0;
        FILL_CONTROL_URB(&tscrn->ctrlout, dev, 
            usb_sndctrlpipe(dev, 0), (unsigned char *)tscrn->setup_packet,
            NULL, 0, ctrl_touchscreen, tscrn);

        if ((nRet=usb_submit_urb(&tscrn->ctrlout)))
        {
          err("ioctl_touchscreen(%d): errror=%d status=%d.", minor, nRet, tscrn->ctrlout.status);
          return nRet;
        }
        dbg("ioctl_touchscreen(%d): status=%d nRet=%d",minor,tscrn->ctrlout.status,nRet);
        interruptible_sleep_on(&tscrn->wait);
        dbg("ioctl_touchscreen(%d): status=%d", minor, tscrn->ctrlout.status);

        return tscrn->ctrlout.status;
      };
    case TSCRN_SOFT_RESET:
      {
        tscrn->setup_packet->requesttype = USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE;
        tscrn->setup_packet->request = TSCRN_USB_REQUEST_RESET;
        tscrn->setup_packet->value = TSCRN_USB_PARAM_SOFT_RESET;
        tscrn->setup_packet->index = 0;
        tscrn->setup_packet->length = 0;
        FILL_CONTROL_URB(&tscrn->ctrlout, dev, 
            usb_sndctrlpipe(dev, 0), (unsigned char *)tscrn->setup_packet,
            NULL, 0, ctrl_touchscreen, tscrn);

        if ((nRet=usb_submit_urb(&tscrn->ctrlout)))
        {
          err("ioctl_touchscreen(%d): errror=%d status=%d.", minor, nRet, tscrn->ctrlout.status);
          return nRet;
        }
        dbg("ioctl_touchscreen(%d): status=%d nRet=%d",minor,tscrn->ctrlout.status,nRet);
        interruptible_sleep_on(&tscrn->wait);
        dbg("ioctl_touchscreen(%d): status=%d", minor, tscrn->ctrlout.status);

        return tscrn->ctrlout.status;
      };
    case TSCRN_CONTROLLER_STATUS:
      {
        tscrn->setup_packet->requesttype = USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE;
        tscrn->setup_packet->request = TSCRN_USB_REQUEST_STATUS;
        tscrn->setup_packet->value = 0;
        tscrn->setup_packet->index = 0;
        tscrn->setup_packet->length = TSCRN_USB_RAPORT_SIZE_STATUS;
        memset(tscrn->ibuf,0x0, IBUF_SIZE);
        FILL_CONTROL_URB(&tscrn->ctrlin, dev, 
            usb_rcvctrlpipe(dev, 0x80), (unsigned char *)tscrn->setup_packet,
            tscrn->ibuf, TSCRN_USB_RAPORT_SIZE_STATUS, ctrl_touchscreen, tscrn);

        if ((nRet=usb_submit_urb(&tscrn->ctrlin)))
        {
          err("ioctl_touchscreen(%d): errror=%d status=%d.", minor, nRet, tscrn->ctrlin.status);
          return nRet;
        }
        dbg("ioctl_touchscreen(%d): status=%d", minor, tscrn->ctrlin.status);
        interruptible_sleep_on(&tscrn->wait);
        dbg("ioctl_touchscreen(%d): gets 0x%x,0x%x,0x%x,0x%x,0x%x,0x%x,0x%x,0x%x status=%d nRet=%d", minor,(int)tscrn->ibuf[0],(int)tscrn->ibuf[1],(int)tscrn->ibuf[2],(int)tscrn->ibuf[3],(int)tscrn->ibuf[4],(int)tscrn->ibuf[5],(int)tscrn->ibuf[6],(int)tscrn->ibuf[7], tscrn->ctrlin.status, nRet);

        if(tscrn->ctrlin.status == 0)
          if (copy_to_user((void *)arg, tscrn->ibuf, TSCRN_USB_RAPORT_SIZE_STATUS))
            return -EFAULT;

        return tscrn->ctrlin.status;
      };
    case TSCRN_CONTROLLER_ID:
      {
        tscrn->setup_packet->requesttype = USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE;
        tscrn->setup_packet->request = TSCRN_USB_REQUEST_CONTROLLER_ID;
        tscrn->setup_packet->value = 0;
        tscrn->setup_packet->index = 0;
        tscrn->setup_packet->length = TSCRN_USB_RAPORT_SIZE_ID;
        memset(tscrn->ibuf,0x0, IBUF_SIZE);
        FILL_CONTROL_URB(&tscrn->ctrlin, dev, 
            usb_rcvctrlpipe(dev, 0x80), (unsigned char *)tscrn->setup_packet,
            tscrn->ibuf, TSCRN_USB_RAPORT_SIZE_ID, ctrl_touchscreen, tscrn);

        if ((nRet=usb_submit_urb(&tscrn->ctrlin)))
        {
          err("ioctl_touchscreen(%d): errror=%d status=%d.", minor, nRet, tscrn->ctrlin.status);
          return nRet;
        }
        dbg("ioctl_touchscreen(%d): status=%d", minor, tscrn->ctrlin.status);
        interruptible_sleep_on(&tscrn->wait);
        dbg("ioctl_touchscreen(%d): gets 0x%x,0x%x,0x%x,0x%x,0x%x,0x%x,0x%x,0x%x status=%d nRet=%d", minor,(int)tscrn->ibuf[0],(int)tscrn->ibuf[1],(int)tscrn->ibuf[2],(int)tscrn->ibuf[3],(int)tscrn->ibuf[4],(int)tscrn->ibuf[5],(int)tscrn->ibuf[6],(int)tscrn->ibuf[7], tscrn->ctrlin.status, nRet);

        if(tscrn->ctrlin.status == 0)
          if (copy_to_user((void *)arg, tscrn->ibuf, TSCRN_USB_RAPORT_SIZE_ID))
            return -EFAULT;

        return tscrn->ctrlin.status;
      };
    case TSCRN_CALIBRATION:
      {
        __u16  type;

        if (copy_from_user(&type, (void *)arg, sizeof(type)))
        {
          err("ioctl_touchscreen(%d): copy from user error arg=%d.", minor, *((int *)arg));
          return -EFAULT;
        };

        switch(type)
        {
          case TSCRN_EXTENDED_CALIBRATION_TYPE:
          case TSCRN_CORNER_CALIBRATION_TYPE:
            break;
          default:
            err("ioctl_touchscreen(%d): unknown calibration type %d.", minor, type);
            return -EFAULT;

        };
        tscrn->setup_packet->requesttype = USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE;
        tscrn->setup_packet->request = TSCRN_USB_REQUEST_CALIBRATION;
        tscrn->setup_packet->value = type;
        tscrn->setup_packet->index = 0;
        tscrn->setup_packet->length = 0;
        FILL_CONTROL_URB(&tscrn->ctrlout, dev, 
            usb_sndctrlpipe(dev, 0x0), (unsigned char *)tscrn->setup_packet,
            NULL, 0, ctrl_touchscreen, tscrn);

        if ((nRet=usb_submit_urb(&tscrn->ctrlout)))
        {
          err("ioctl_touchscreen(%d): errror=%d status=%d.", minor, nRet, tscrn->ctrlout.status);
          return nRet;
        }
        dbg("ioctl_touchscreen(%d): status=%d nRet=%d", minor, tscrn->ctrlout.status, nRet);
        interruptible_sleep_on(&tscrn->wait);
        dbg("ioctl_touchscreen(%d): status=%d", minor, tscrn->ctrlout.status);

        return tscrn->ctrlout.status;
      };
    case TSCRN_RESTORE_DEFAULTS:
      {
        tscrn->setup_packet->requesttype = USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE;
        tscrn->setup_packet->request = TSCRN_USB_REQUEST_RESTORE_DEFAULTS;
        tscrn->setup_packet->value = 0;
        tscrn->setup_packet->index = 0;
        tscrn->setup_packet->length = 0;
        FILL_CONTROL_URB(&tscrn->ctrlout, dev, 
            usb_sndctrlpipe(dev, 0x0), (unsigned char *)tscrn->setup_packet,
            NULL, 0, ctrl_touchscreen, tscrn);

        if ((nRet=usb_submit_urb(&tscrn->ctrlout)))
        {
          err("ioctl_touchscreen(%d): errror=%d status=%d.", minor, nRet, tscrn->ctrlout.status);
          return nRet;
        }
        dbg("ioctl_touchscreen(%d): status=%d nRet=%d", minor, tscrn->ctrlout.status, nRet);
        interruptible_sleep_on(&tscrn->wait);
        dbg("ioctl_touchscreen(%d): status=%d", minor, tscrn->ctrlout.status);

        return tscrn->ctrlout.status;
      };
    default:
      return -ENOIOCTLCMD;
  }
  return 0;
}

///////////////////////////////////////////////////////////////////////////
static void * probe_touchscreen(struct usb_device *dev, unsigned int ifnum)
{
  struct tscrn_usb_data *tscrn;
  struct usb_interface_descriptor *interface;
  struct usb_endpoint_descriptor *endpoint;

#ifdef DEBUG
  int nRet,nCounter;
#endif
  //devrequest *setup_packet;

  int ep_cnt;

  kdev_t minor;

  char valid_device = 0;
  char have_intr;

  if (vendor != -1 && product != -1) 
  {
    info("probe_touchscreen: User specified USB touchscreen -- Vendor:Product - %x:%x", vendor, product);
  }

  /*
   * 1. Check Vendor/Product
   * 2. Determine/Assign Bulk Endpoints
   * 3. Determine/Assign Intr Endpoint
   */

  /* 
   *
   * NOTE: Just because a product is supported here does not mean that
   * applications exist that support the product.  It's in the hopes
   * that this will allow developers a means to produce applications
   * that will support USB products.
   *
   * Until we detect a device which is pleasing, we silently punt.
   */

  if(	dev->descriptor.idVendor == MICROTOUCH_VENDOR_ID
      && dev->descriptor.idProduct == MICROTOUCH_PRODUCT_ID
    )
    valid_device = 1;
  // no user specification devices !!!
  // --   else
  // --   /* User specified */
  // --   if (dev->descriptor.idVendor == vendor
  // --       &&  dev->descriptor.idProduct == product)
  // --       valid_device = 1;

  if (!valid_device)	
    return NULL;	/* We didn't find anything pleasing */