Subversion Repositories Kolibri OS

Rev

Rev 5271 | Rev 5367 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. #include <drm/drmP.h>
  2. #include <drm/drm_crtc_helper.h>
  3. #include <drm/radeon_drm.h>
  4. #include "radeon_reg.h"
  5. #include "radeon.h"
  6. #include "bitmap.h"
  7.  
  8. void __init dmi_scan_machine(void);
  9.  
  10. #define KMS_DEV_CLOSE 0
  11. #define KMS_DEV_INIT  1
  12. #define KMS_DEV_READY 2
  13.  
  14. struct pci_device {
  15.     uint16_t    domain;
  16.     uint8_t     bus;
  17.     uint8_t     dev;
  18.     uint8_t     func;
  19.     uint16_t    vendor_id;
  20.     uint16_t    device_id;
  21.     uint16_t    subvendor_id;
  22.     uint16_t    subdevice_id;
  23.     uint32_t    device_class;
  24.     uint8_t     revision;
  25. };
  26.  
  27. struct drm_device *main_device;
  28. struct drm_file   *drm_file_handlers[256];
  29.  
  30. videomode_t usermode;
  31.  
  32. void cpu_detect1();
  33.  
  34. int _stdcall display_handler(ioctl_t *io);
  35. static char  log[256];
  36.  
  37. unsigned long volatile jiffies;
  38. u64 jiffies_64;
  39.  
  40. struct workqueue_struct *system_wq;
  41. int driver_wq_state;
  42.  
  43. int x86_clflush_size;
  44.  
  45. void ati_driver_thread()
  46. {
  47.     struct radeon_device *rdev = NULL;
  48.     struct workqueue_struct *cwq = NULL;
  49. //    static int dpms = 1;
  50. //   static int dpms_lock = 0;
  51. //    oskey_t   key;
  52.     unsigned long irqflags;
  53.     int tmp;
  54.  
  55.     printf("%s\n",__FUNCTION__);
  56.  
  57.     while(driver_wq_state == KMS_DEV_INIT)
  58.     {
  59.         jiffies = GetTimerTicks();
  60.         jiffies_64 = jiffies;
  61.         delay(1);
  62.     };
  63.  
  64.     rdev = main_device->dev_private;
  65. //    cwq = rdev->wq;
  66.  
  67.     asm volatile("int $0x40":"=a"(tmp):"a"(66),"b"(1),"c"(1));
  68.     asm volatile("int $0x40":"=a"(tmp):"a"(66),"b"(4),"c"(0x46),"d"(0x330));
  69.     asm volatile("int $0x40":"=a"(tmp):"a"(66),"b"(4),"c"(0xC6),"d"(0x330));
  70.  
  71.     while(driver_wq_state != KMS_DEV_CLOSE)
  72.     {
  73.         jiffies = GetTimerTicks();
  74. #if 0
  75.         key = get_key();
  76.  
  77.         if( (key.val != 1) && (key.state == 0x02))
  78.         {
  79.             if(key.code == 0x46 && dpms_lock == 0)
  80.             {
  81.                 dpms_lock = 1;
  82.                 if(dpms == 1)
  83.                 {
  84.                     i915_dpms(main_device, DRM_MODE_DPMS_OFF);
  85.                     printf("dpms off\n");
  86.                 }
  87.                 else
  88.                 {
  89.                     i915_dpms(main_device, DRM_MODE_DPMS_ON);
  90.                     printf("dpms on\n");
  91.                 };
  92.                 dpms ^= 1;
  93.                 }
  94.             else if(key.code == 0xC6)
  95.                 dpms_lock = 0;
  96.         };
  97.         spin_lock_irqsave(&cwq->lock, irqflags);
  98.  
  99.         while (!list_empty(&cwq->worklist))
  100.         {
  101.             struct work_struct *work = list_entry(cwq->worklist.next,
  102.                                         struct work_struct, entry);
  103.             work_func_t f = work->func;
  104.             list_del_init(cwq->worklist.next);
  105.  
  106.             spin_unlock_irqrestore(&cwq->lock, irqflags);
  107.             f(work);
  108.             spin_lock_irqsave(&cwq->lock, irqflags);
  109.         }
  110.  
  111.         spin_unlock_irqrestore(&cwq->lock, irqflags);
  112. #endif
  113.  
  114.         delay(1);
  115.     };
  116.  
  117.     asm volatile ("int $0x40"::"a"(-1));
  118. }
  119.  
  120. u32  __attribute__((externally_visible)) drvEntry(int action, char *cmdline)
  121. {
  122.     struct radeon_device *rdev = NULL;
  123.  
  124.     const struct pci_device_id  *ent;
  125.  
  126.     int err = 0;
  127.  
  128.     if(action != 1)
  129.     {
  130.         driver_wq_state = KMS_DEV_CLOSE;
  131.         return 0;
  132.     };
  133.  
  134.     if( GetService("DISPLAY") != 0 )
  135.         return 0;
  136.  
  137.     printf("Radeon v3.19-rc2 cmdline %s\n", cmdline);
  138.  
  139.     if( cmdline && *cmdline )
  140.         parse_cmdline(cmdline, &usermode, log, &radeon_modeset);
  141.  
  142.     if( *log && !dbg_open(log))
  143.     {
  144.         printf("Can't open %s\nExit\n", log);
  145.         return 0;
  146.     }
  147.  
  148.     cpu_detect1();
  149.  
  150.     err = enum_pci_devices();
  151.     if( unlikely(err != 0) )
  152.     {
  153.         dbgprintf("Device enumeration failed\n");
  154.         return 0;
  155.     }
  156.  
  157.     driver_wq_state = KMS_DEV_INIT;
  158.     CreateKernelThread(ati_driver_thread);
  159.  
  160.     err = ati_init();
  161.     if(unlikely(err!= 0))
  162.     {
  163.         driver_wq_state = KMS_DEV_CLOSE;
  164.         dbgprintf("Epic Fail :(\n");
  165.         return 0;
  166.     };
  167.  
  168.     driver_wq_state = KMS_DEV_READY;
  169.  
  170.     rdev = main_device->dev_private;
  171.     printf("current engine clock: %u0 kHz\n", radeon_get_engine_clock(rdev));
  172.     printf("current memory clock: %u0 kHz\n", radeon_get_memory_clock(rdev));
  173.  
  174.     err = RegService("DISPLAY", display_handler);
  175.  
  176.     if( err != 0)
  177.         dbgprintf("DISPLAY service installed\n");
  178.  
  179.  
  180.     return err;
  181. };
  182.  
  183.  
  184.  
  185. #define CURRENT_API     0x0200      /*      2.00     */
  186. #define COMPATIBLE_API  0x0100      /*      1.00     */
  187.  
  188. #define API_VERSION     (COMPATIBLE_API << 16) | CURRENT_API
  189.  
  190. #define SRV_GETVERSION          0
  191. #define SRV_ENUM_MODES          1
  192. #define SRV_SET_MODE            2
  193. #define SRV_GET_CAPS            3
  194.  
  195. #define SRV_CREATE_SURFACE      10
  196. #define SRV_DESTROY_SURFACE     11
  197. #define SRV_LOCK_SURFACE        12
  198. #define SRV_UNLOCK_SURFACE      13
  199. #define SRV_RESIZE_SURFACE      14
  200. #define SRV_BLIT_BITMAP         15
  201. #define SRV_BLIT_TEXTURE        16
  202. #define SRV_BLIT_VIDEO          17
  203.  
  204.  
  205.  
  206. int r600_video_blit(uint64_t src_offset, int  x, int y,
  207.                     int w, int h, int pitch);
  208.  
  209. #define check_input(size) \
  210.     if( unlikely((inp==NULL)||(io->inp_size != (size))) )   \
  211.         break;
  212.  
  213. #define check_output(size) \
  214.     if( unlikely((outp==NULL)||(io->out_size != (size))) )   \
  215.         break;
  216.  
  217. int _stdcall display_handler(ioctl_t *io)
  218. {
  219.     int    retval = -1;
  220.     u32 *inp;
  221.     u32 *outp;
  222.  
  223.     inp = io->input;
  224.     outp = io->output;
  225.  
  226.     switch(io->io_code)
  227.     {
  228.         case SRV_GETVERSION:
  229.             check_output(4);
  230.             *outp  = API_VERSION;
  231.             retval = 0;
  232.             break;
  233.  
  234.         case SRV_ENUM_MODES:
  235. //            dbgprintf("SRV_ENUM_MODES inp %x inp_size %x out_size %x\n",
  236. //                       inp, io->inp_size, io->out_size );
  237.             check_output(4);
  238.             if( radeon_modeset)
  239.                 retval = get_videomodes((videomode_t*)inp, outp);
  240.             break;
  241.  
  242.         case SRV_SET_MODE:
  243. //            dbgprintf("SRV_SET_MODE inp %x inp_size %x\n",
  244. //                       inp, io->inp_size);
  245.             check_input(sizeof(videomode_t));
  246.             if( radeon_modeset )
  247.                 retval = set_user_mode((videomode_t*)inp);
  248.             break;
  249. /*
  250.         case SRV_GET_CAPS:
  251.             retval = get_driver_caps((hwcaps_t*)inp);
  252.             break;
  253.  
  254.         case SRV_CREATE_SURFACE:
  255. //            check_input(8);
  256.             retval = create_surface(main_drm_device, (struct io_call_10*)inp);
  257.             break;
  258.  
  259.         case SRV_LOCK_SURFACE:
  260.             retval = lock_surface((struct io_call_12*)inp);
  261.             break;
  262.  
  263.         case SRV_BLIT_BITMAP:
  264.             srv_blit_bitmap( inp[0], inp[1], inp[2],
  265.                         inp[3], inp[4], inp[5], inp[6]);
  266. */
  267.     };
  268.  
  269.     return retval;
  270. }
  271.  
  272.  
  273. #define PCI_CLASS_REVISION      0x08
  274. #define PCI_CLASS_DISPLAY_VGA   0x0300
  275.  
  276. int pci_scan_filter(u32 id, u32 busnr, u32 devfn)
  277. {
  278.     u16 vendor, device;
  279.     u32 class;
  280.     int   ret = 0;
  281.  
  282.     vendor   = id & 0xffff;
  283.     device   = (id >> 16) & 0xffff;
  284.  
  285.     if(vendor == 0x1002)
  286.     {
  287.         class = PciRead32(busnr, devfn, PCI_CLASS_REVISION);
  288.         class >>= 16;
  289.  
  290.         if( class == PCI_CLASS_DISPLAY_VGA)
  291.             ret = 1;
  292.     }
  293.     return ret;
  294. }
  295.  
  296.  
  297. int seq_printf(struct seq_file *m, const char *f, ...)
  298. {
  299. //        int ret;
  300. //        va_list args;
  301.  
  302. //        va_start(args, f);
  303. //        ret = seq_vprintf(m, f, args);
  304. //        va_end(args);
  305.  
  306. //        return ret;
  307.     return 0;
  308. }
  309.  
  310. s64 div64_s64(s64 dividend, s64 divisor)
  311. {
  312.         s64 quot, t;
  313.  
  314.         quot = div64_u64(abs64(dividend), abs64(divisor));
  315.         t = (dividend ^ divisor) >> 63;
  316.  
  317.         return (quot ^ t) - t;
  318. }
  319.  
  320.