docs: def _windows_platform_data():
      '''
      Use the platform module for as much as we can.
      '''
      # Provides:
      #    kernelrelease
      #    kernelversion
      #    osversion
      #    osrelease
      #    osservicepack
      #    osmanufacturer
      #    manufacturer
      #    productname
      #    biosversion
      #    serialnumber
      #    osfullname
      #    timezone
      #    windowsdomain
      #    windowsdomaintype
      #    motherboard.productname
      #    motherboard.serialnumber
      #    virtual
  
      if not HAS_WMI:
          return {}
  
      with salt.utils.winapi.Com():
          wmi_c = wmi.WMI()
          # http://msdn.microsoft.com/en-us/library/windows/desktop/aa394102%28v=vs.85%29.aspx
          systeminfo = wmi_c.Win32_ComputerSystem()[0]
          # https://msdn.microsoft.com/en-us/library/aa394239(v=vs.85).aspx
          osinfo = wmi_c.Win32_OperatingSystem()[0]
          # http://msdn.microsoft.com/en-us/library/windows/desktop/aa394077(v=vs.85).aspx
          biosinfo = wmi_c.Win32_BIOS()[0]
          # http://msdn.microsoft.com/en-us/library/windows/desktop/aa394498(v=vs.85).aspx
          timeinfo = wmi_c.Win32_TimeZone()[0]
  
          # http://msdn.microsoft.com/en-us/library/windows/desktop/aa394072(v=vs.85).aspx
          motherboard = {'product': None,
                         'serial': None}
          try:
              motherboardinfo = wmi_c.Win32_BaseBoard()[0]
              motherboard['product'] = motherboardinfo.Product
              motherboard['serial'] = motherboardinfo.SerialNumber
          except IndexError:
              log.debug('Motherboard info not available on this system')
  
          os_release = platform.release()
          kernel_version = platform.version()
          info = salt.utils.win_osinfo.get_os_version_info()
          net_info = salt.utils.win_osinfo.get_join_info()
  
          service_pack = None
          if info['ServicePackMajor'] > 0:
              service_pack = ''.join(['SP', six.text_type(info['ServicePackMajor'])])
  
          # This creates the osrelease grain based on the Windows Operating
          # System Product Name. As long as Microsoft maintains a similar format
          # this should be future proof
          version = 'Unknown'
          release = ''
          if 'Server' in osinfo.Caption:
              for item in osinfo.Caption.split(' '):
                  # If it's all digits, then it's version
                  if re.match(r'\d+', item):
                      version = item
                  # If it starts with R and then numbers, it's the release
                  # ie: R2
                  if re.match(r'^R\d+$', item):
                      release = item
              os_release = '{0}Server{1}'.format(version, release)
          else:
              for item in osinfo.Caption.split(' '):
                  # If it's a number, decimal number, Thin or Vista, then it's the
                  # version
                  if re.match(r'^(\d+(\.\d+)?)|Thin|Vista$', item):
                      version = item
              os_release = version
  
          grains = {
              'kernelrelease': _clean_value('kernelrelease', osinfo.Version),
              'kernelversion': _clean_value('kernelversion', kernel_version),
              'osversion': _clean_value('osversion', osinfo.Version),
              'osrelease': _clean_value('osrelease', os_release),
              'osservicepack': _clean_value('osservicepack', service_pack),
              'osmanufacturer': _clean_value('osmanufacturer', osinfo.Manufacturer),
              'manufacturer': _clean_value('manufacturer', systeminfo.Manufacturer),
              'productname': _clean_value('productname', systeminfo.Model),
              # bios name had a bunch of whitespace appended to it in my testing
              # 'PhoenixBIOS 4.0 Release 6.0     '
              'biosversion': _clean_value('biosversion', biosinfo.Name.strip()),
              'serialnumber': _clean_value('serialnumber', biosinfo.SerialNumber),
              'osfullname': _clean_value('osfullname', osinfo.Caption),
              'timezone': _clean_value('timezone', timeinfo.Description),
              'windowsdomain': _clean_value('windowsdomain', net_info['Domain']),
              'windowsdomaintype': _clean_value('windowsdomaintype', net_info['DomainType']),
              'motherboard': {
                  'productname': _clean_value('motherboard.productname', motherboard['product']),
                  'serialnumber': _clean_value('motherboard.serialnumber', motherboard['serial']),
              }
          }
  
          # test for virtualized environments
          # I only had VMware available so the rest are unvalidated
          if 'VRTUAL' in biosinfo.Version:  # (not a typo)
              grains['virtual'] = 'HyperV'
          elif 'A M I' in biosinfo.Version:
              grains['virtual'] = 'VirtualPC'
          elif 'VMware' in systeminfo.Model:
              grains['virtual'] = 'VMware'
          elif 'VirtualBox' in systeminfo.Model:
              grains['virtual'] = 'VirtualBox'
          elif 'Xen' in biosinfo.Version:
              grains['virtual'] = 'Xen'
              if 'HVM domU' in systeminfo.Model:
                  grains['virtual_subtype'] = 'HVM domU'
          elif 'OpenStack' in systeminfo.Model:
              grains['virtual'] = 'OpenStack'
  
      return grains