Changeset 625

Timestamp:

Jan 3, 2021, 7:20:20 AM (5 years ago)

Author:

Paul Smedley

Message:

Code cleanups to simplify future maintenance, update regmap/regcache/rbtree to linux 4.19.163 level

Location:

GPL/branches/uniaud32-next

Files:

• alsa-kernel/core/hwdep.c (modified) (1 diff)
• alsa-kernel/core/info.c (modified) (6 diffs)
• alsa-kernel/core/init.c (modified) (10 diffs)
• alsa-kernel/core/memalloc.c (modified) (1 diff)
• alsa-kernel/core/misc.c (modified) (1 diff)
• alsa-kernel/core/oss/pcm_oss.c (modified) (1 diff)
• alsa-kernel/core/pcm.c (modified) (1 diff)
• alsa-kernel/core/pcm_lib.c (modified) (1 diff)
• alsa-kernel/core/pcm_native.c (modified) (3 diffs)
• alsa-kernel/core/seq/oss/seq_oss_event.c (modified) (2 diffs)
• alsa-kernel/core/seq/oss/seq_oss_midi.c (modified) (1 diff)
• alsa-kernel/core/seq/oss/seq_oss_synth.c (modified) (1 diff)
• alsa-kernel/drivers/mpu401/mpu401.c (modified) (1 diff)
• alsa-kernel/drivers/opl3/opl3_synth.c (modified) (1 diff)
• alsa-kernel/hda/array.c (modified) (1 diff)
• alsa-kernel/hda/hdac_bus.c (modified) (2 diffs)
• alsa-kernel/hda/hdac_stream.c (modified) (3 diffs)
• alsa-kernel/include/sound/control.h (modified) (3 diffs)
• alsa-kernel/include/sound/hda_codec.h (modified) (1 diff)
• alsa-kernel/include/sound/hdaudio.h (modified) (3 diffs)
• alsa-kernel/include/sound/initval.h (modified) (1 diff)
• alsa-kernel/pci/emu10k1/emu10k1_main.c (modified) (2 diffs)
• alsa-kernel/pci/emu10k1/emufx.c (modified) (1 diff)
• alsa-kernel/pci/emu10k1/p16v.c (modified) (1 diff)
• alsa-kernel/pci/hda/hda_controller.c (modified) (2 diffs)
• alsa-kernel/pci/hda/hda_generic.c (modified) (3 diffs)
• alsa-kernel/pci/hda/hda_hwdep.c (modified) (1 diff)
• alsa-kernel/pci/hda/hda_intel.c (modified) (6 diffs)
• alsa-kernel/pci/hda/hda_priv.h (modified) (1 diff)
• alsa-kernel/pci/hda/hda_proc.c (modified) (2 diffs)
• alsa-kernel/pci/hda/hda_sysfs.c (modified) (2 diffs)
• alsa-kernel/pci/hda/patch_conexant.c (modified) (2 diffs)
• alsa-kernel/pci/hda/patch_sigmatel.c (modified) (3 diffs)
• alsa-kernel/pci/hda/patch_via.c (modified) (1 diff)
• alsa-kernel/pci/intel8x0.c (modified) (3 diffs)
• alsa-kernel/pci/maestro3.c (modified) (4 diffs)
• alsa-kernel/pci/trident/trident_main.c (modified) (1 diff)
• include/asm/atomic.h (modified) (1 diff)
• include/asm/unaligned.h (modified) (1 diff)
• include/linux/clocksource.h (modified) (1 diff)
• include/linux/completion.h (modified) (1 diff)
• include/linux/device.h (modified) (2 diffs)
• include/linux/fs.h (modified) (4 diffs)
• include/linux/genalloc.h (modified) (1 diff)
• include/linux/init.h (modified) (1 diff)
• include/linux/major.h (modified) (1 diff)
• include/linux/mm.h (modified) (1 diff)
• include/linux/module.h (modified) (1 diff)
• include/linux/moduleparam.h (modified) (1 diff)
• include/linux/mutex.h (modified) (1 diff)
• include/linux/overflow.h (added)
• include/linux/pci.h (modified) (1 diff)
• include/linux/pm_runtime.h (modified) (1 diff)
• include/linux/proc_fs.h (modified) (1 diff)
• include/linux/rbtree.h (modified) (3 diffs)
• include/linux/rbtree_augmented.h (modified) (14 diffs)
• include/linux/regmap.h (modified) (23 diffs)
• include/linux/slab.h (modified) (1 diff)
• include/linux/time.h (modified) (1 diff)
• include/linux/time64.h (modified) (1 diff)
• include/linux/timecounter.h (modified) (1 diff)
• include/linux/unaligned (added)
• include/linux/unaligned/be_byteshift.h (added)
• include/linux/unaligned/le_byteshift.h (added)
• include/linux/vga_switcheroo.h (modified) (1 diff)
• include/linux/vgaarb.h (modified) (1 diff)
• include/linux/vmalloc.h (modified) (1 diff)
• include/linux/wait.h (modified) (1 diff)
• lib32/drivers_base.c (modified) (2 diffs)
• lib32/internal.h (modified) (6 diffs)
• lib32/ioctl.c (modified) (1 diff)
• lib32/misc.c (modified) (1 diff)
• lib32/rbtree.c (modified) (6 diffs)
• lib32/regcache-flat.c (modified) (4 diffs)
• lib32/regcache-rbtree.c (modified) (25 diffs)
• lib32/regcache.c (modified) (1 diff)
• lib32/regmap.c (modified) (74 diffs)
• lib32/waitqueue.c (modified) (2 diffs)

GPL/branches/uniaud32-next/alsa-kernel/core/hwdep.c

@@ -5 +5 @@
  */
 
-#ifdef TARGET_OS2
-#include <sound/core.h>
-#endif
 #include <linux/major.h>
 #include <linux/init.h>

GPL/branches/uniaud32-next/alsa-kernel/core/info.c

@@ -232 +232 @@
 static int snd_info_entry_mmap(struct file *file, struct vm_area_struct *vma)
 {
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 20)
         struct inode *inode = file_inode(file);
-#else
-        struct inode *inode = file->f_dentry->d_inode;
-#endif
         struct snd_info_private_data *data;
         struct snd_info_entry *entry;
@@ -479 +475 @@
                 return -ENOMEM;
         snd_proc_root->mode = S_IFDIR | 0555;
-#ifndef TARGET_OS2
         snd_proc_root->p = proc_mkdir("asound", NULL);
-#else
-        snd_proc_root->p = create_proc_entry("asound", S_IFDIR | S_IRUGO | S_IXUGO, NULL);
-#endif
         if (!snd_proc_root->p)
                 goto error;
@@ -491 +483 @@
                 goto error;
 #endif
-#if IS_ENABLED(CONFIG_SND_SEQUENCER) 
+#if IS_ENABLED(CONFIG_SND_SEQUENCER)
         snd_seq_root = create_subdir(THIS_MODULE, "seq");
         if (!snd_seq_root)
@@ -551 +543 @@
 int snd_info_card_register(struct snd_card *card)
 {
-#ifndef TARGET_OS2
         struct proc_dir_entry *p;
-#endif
         int err;
 
@@ -568 +558 @@
         if (card->proc_root_link)
                 return 0;
-#ifndef TARGET_OS2
         p = proc_symlink(card->id, snd_proc_root->p, card->proc_root->name);
         if (!p)
                 return -ENOMEM;
         card->proc_root_link = p;
-#endif
         return 0;
 }
@@ -587 +575 @@
                 card->proc_root_link = NULL;
         }
-#ifndef TARGET_OS2
         if (strcmp(card->id, card->proc_root->name))
                 card->proc_root_link = proc_symlink(card->id,
                                                     snd_proc_root->p,
                                                     card->proc_root->name);
-#endif
         mutex_unlock(&info_mutex);
 }

GPL/branches/uniaud32-next/alsa-kernel/core/init.c

@@ -5 +5 @@
  */
 
-#ifdef TARGET_OS2
-#include <sound/core.h>
-#include <sound/initval.h>
-#include <linux/sysfs.h>
-struct class *sound_class;
-#endif
 #include <linux/init.h>
 #include <linux/sched.h>
@@ -26 +20 @@
 #include <sound/info.h>
 
+#ifdef TARGET_OS2
+struct class *sound_class;
+#endif
+
 /* monitor files for graceful shutdown (hotplug) */
 struct snd_monitor_file {
@@ -55 +53 @@
 {
         int match = 1;
-#ifndef TARGET_OS2
 #ifdef MODULE
         const char *s1, *s2;
@@ -84 +81 @@
         }
 #endif /* MODULE */
-#endif
         return match;
 }
@@ -229 +225 @@
         card->card_dev.class = sound_class;
         card->card_dev.release = release_card_device;
-#ifndef TARGET_OS2
         card->card_dev.groups = card->dev_groups;
         card->dev_groups[0] = &card_dev_attr_group;
@@ -235 +230 @@
         if (err < 0)
                 goto __error;
+
         snprintf(card->irq_descr, sizeof(card->irq_descr), "%s:%s",
                  dev_driver_string(card->dev), dev_name(&card->card_dev));
-#endif
+
         /* the control interface cannot be accessed from the user space until */
         /* snd_cards_bitmask and snd_cards are set with snd_card_register */
@@ -478 +474 @@
 
         spin_lock_irq(&card->files_lock);
-#ifndef TARGET_OS2
         wait_event_lock_irq(card->remove_sleep,
                             list_empty(&card->files_list),
                             card->files_lock);
-#endif
         spin_unlock_irq(&card->files_lock);
 }
@@ -548 +542 @@
         if (ret)
                 return ret;
-#ifndef TARGET_OS2
         /* wait, until all devices are ready for the free operation */
         wait_for_completion(&released);
-#endif
         return 0;
 }
@@ -709 +701 @@
         return count;
 }
-#endif
-
-#ifdef NOT_USED
+
 static DEVICE_ATTR(id, 0644, card_id_show_attr, card_id_store_attr);
 
@@ -1000 +990 @@
                 }
         }
-#ifndef TARGET_OS2
         if (list_empty(&card->files_list))
                 wake_up_all(&card->remove_sleep);
-#endif
         spin_unlock(&card->files_lock);
         if (!found) {

GPL/branches/uniaud32-next/alsa-kernel/core/memalloc.c

@@ -8 +8 @@
 
 #ifdef TARGET_OS2
-#include <sound/core.h>
+#include <sound/config.h> //for CONFIG_HAS_DMA
 #endif
 #include <linux/slab.h>

GPL/branches/uniaud32-next/alsa-kernel/core/misc.c

@@ -31 +31 @@
         if (res) {
                 release_resource(res);
-                kfree_nocheck(res);
+                kfree(res);
         }
 }

GPL/branches/uniaud32-next/alsa-kernel/core/oss/pcm_oss.c

@@ -1456 +1456 @@
                         if (substream->oss.setup.partialfrag ||
                             runtime->oss.buffer_used == runtime->oss.period_bytes) {
-                                tmp = snd_pcm_oss_write2(substream, runtime->oss.buffer + runtime->oss.period_ptr,
+                                tmp = snd_pcm_oss_write2(substream, runtime->oss.buffer + runtime->oss.period_ptr, 
                                                          runtime->oss.buffer_used - runtime->oss.period_ptr, 1);
                                 if (tmp <= 0)

GPL/branches/uniaud32-next/alsa-kernel/core/pcm.c

@@ -1030 +1030 @@
         return snprintf(buf, PAGE_SIZE, "%s\n", str);
 }
-#endif
-
-#ifndef TARGET_OS2
+
 static DEVICE_ATTR(pcm_class, 0444, show_pcm_class, NULL);
 static struct attribute *pcm_dev_attrs[] = {

GPL/branches/uniaud32-next/alsa-kernel/core/pcm_lib.c

@@ -1408 +1408 @@
         if ((snd_interval_value(i) == width) ||
             (width == 0 && snd_interval_value(i) > msbits))
-#ifdef TARGET_OS2 //fixme
+#ifdef TARGET_OS2 //fixme min_not_zero uses typeof()
                 params->msbits = msbits;
 #else

GPL/branches/uniaud32-next/alsa-kernel/core/pcm_native.c

@@ -1972 +1972 @@
 
 
-#ifndef TARGET_OS2
 static bool is_pcm_file(struct file *file)
 {
@@ -1990 +1989 @@
         return true;
 }
-#endif
 
 /*
@@ -2011 +2009 @@
         if (!f.file)
                 return -EBADFD;
-#ifndef TARGET_OS2
         if (!is_pcm_file(f.file)) {
                 res = -EBADFD;
                 goto _badf;
         }
-#endif
         pcm_file = f.file->private_data;
         substream1 = pcm_file->substream;

GPL/branches/uniaud32-next/alsa-kernel/core/seq/oss/seq_oss_event.c

@@ -287 +287 @@
                 }
 
-#ifndef TARGET_OS2
                 ch = array_index_nospec(ch, info->nr_voices);
-#endif
                 if (note == 255 && info->ch[ch].note >= 0) {
                         /* volume control */
@@ -350 +348 @@
                 }
 
-#ifndef TARGET_OS2
                 ch = array_index_nospec(ch, info->nr_voices);
-#endif
                 if (info->ch[ch].note >= 0) {
                         note = info->ch[ch].note;

GPL/branches/uniaud32-next/alsa-kernel/core/seq/oss/seq_oss_midi.c

@@ -304 +304 @@
         if (dev < 0 || dev >= dp->max_mididev)
                 return NULL;
-#ifndef TARGET_OS2
         dev = array_index_nospec(dev, dp->max_mididev);
-#endif
         return get_mdev(dev);
 }

GPL/branches/uniaud32-next/alsa-kernel/core/seq/oss/seq_oss_synth.c

@@ -333 +333 @@
         if (dev < 0 || dev >= dp->max_synthdev)
                 return NULL;
-#ifndef TARGET_OS2
         dev = array_index_nospec(dev, SNDRV_SEQ_OSS_MAX_SYNTH_DEVS);
-#endif
         return &dp->synths[dev];
 }

GPL/branches/uniaud32-next/alsa-kernel/drivers/mpu401/mpu401.c

@@ -6 +6 @@
  */
 
-#ifdef TARGET_OS2
-#include <sound/config.h>
-#endif
 #include <linux/init.h>
 #include <linux/pnp.h>

GPL/branches/uniaud32-next/alsa-kernel/drivers/opl3/opl3_synth.c

@@ -465 +465 @@
         }
         /* Get register offset of operator */
-#ifndef TARGET_OS2
         voice_offset = array_index_nospec(voice_offset, MAX_OPL2_VOICES);
         voice_op = array_index_nospec(voice->op, 4);
-#endif
         op_offset = snd_opl3_regmap[voice_offset][voice_op];
 

GPL/branches/uniaud32-next/alsa-kernel/hda/array.c

@@ -35 +35 @@
                 array->alloced = num;
         }
-
         return snd_array_elem(array, array->used++);
 }

GPL/branches/uniaud32-next/alsa-kernel/hda/hdac_bus.c

@@ -158 +158 @@
 EXPORT_SYMBOL_GPL(snd_hdac_bus_queue_event);
 
-#ifdef TARGET_OS2 //was ifndef 2020-11-26
 /*
  * process queued unsolicited events
@@ -189 +188 @@
         spin_unlock_irq(&bus->reg_lock);
 }
-#endif
 
 /**

GPL/branches/uniaud32-next/alsa-kernel/hda/hdac_stream.c

@@ -4 +4 @@
  */
 
-#ifdef TARGET_OS2
-#include <linux/types.h>
-#endif
 #include <linux/kernel.h>
 #include <linux/delay.h>
@@ -303 +300 @@
                 if (azx_dev->opened)
                         continue;
-#ifndef TARGET_OS2
                 if (azx_dev->assigned_key == key) {
-#else
-                if (azx_dev->device == substream->pcm->device) {
-#endif
                         res = azx_dev;
                         break;
@@ -318 +311 @@
                 res->opened = 1;
                 res->running = 0;
-#ifndef TARGET_OS2
                 res->assigned_key = key;
-#else
-                res->device == substream->pcm->device;
-#endif
                 res->substream = substream;
                 spin_unlock_irq(&bus->reg_lock);

GPL/branches/uniaud32-next/alsa-kernel/include/sound/control.h

@@ -64 +64 @@
         } tlv;
         unsigned long private_value;
-#ifdef TARGET_OS2
-        void *private_ptr;
-#endif
         void *private_data;
         void (*private_free)(struct snd_kcontrol *kcontrol);
@@ -143 +140 @@
 {
         unsigned int ioff = id->numid - kctl->id.numid;
-#ifndef TARGET_OS2
         return array_index_nospec(ioff, kctl->count);
-#else
-        return ioff;
-#endif
 }
 
@@ -153 +146 @@
 {
         unsigned int ioff = id->index - kctl->id.index;
-#ifndef TARGET_OS2
         return array_index_nospec(ioff, kctl->count);
-#else
-        return ioff;
-#endif
 }
 

GPL/branches/uniaud32-next/alsa-kernel/include/sound/hda_codec.h

@@ -206 +206 @@
         struct list_head conn_list;     /* linked-list of connection-list */
 
-#ifndef TARGET_OS2
         struct mutex spdif_mutex;
-#else
-        struct semaphore spdif_mutex;
-#endif
         struct mutex control_mutex;
         struct snd_array spdif_out;

GPL/branches/uniaud32-next/alsa-kernel/include/sound/hdaudio.h

@@ -17 +17 @@
 #include <sound/hda_verbs.h>
 #include <drm/i915_component.h>
-#ifdef TARGET_OS2
-#include <linux/clocksource.h>
-#endif
+
 /* codec node id */
 typedef u16 hda_nid_t;
@@ -361 +359 @@
         /* locks */
         spinlock_t reg_lock;
-#ifndef TARGET_OS2
         struct mutex cmd_mutex;
-#else
-        struct semaphore cmd_mutex;
-#endif
         struct mutex lock;
 
@@ -538 +532 @@
         unsigned char stream_tag;       /* assigned stream */
         unsigned char index;            /* stream index */
-#ifndef TARGET_OS2
         int assigned_key;               /* last device# key assigned to */
-#else
-        int device;                     /* last device number assigned to */
-#endif
         bool opened:1;
         bool running:1;

GPL/branches/uniaud32-next/alsa-kernel/include/sound/initval.h

@@ -22 +22 @@
 #define MODULE_DEVICES(val) 
 #define MODULE_PARM_SYNTAX(id, val) 
-#define module_param_array(name, type, nump, perm)
-#define module_param(name, type, perm)
 #else
 #define MODULE_CLASSES(val) MODULE_GENERIC_STRING(info_classes, val)

GPL/branches/uniaud32-next/alsa-kernel/pci/emu10k1/emu10k1_main.c

@@ -1926 +1926 @@
                 (unsigned long)(emu->ptb_pages.addr + emu->ptb_pages.bytes));
 
-#ifndef TARGET_OS2
+#ifdef TARGET_OS2
         emu->page_ptr_table = vmalloc(array_size(sizeof(void *),
                                                  emu->max_cache_pages));
@@ -2091 +2091 @@
         if (emu->audigy)
                 size += ARRAY_SIZE(saved_regs_audigy);
-#ifndef TARGET_OS2
+#ifdef TARGET_OS2
         emu->saved_ptr = vmalloc(array3_size(4, NUM_G, size));
 #else

GPL/branches/uniaud32-next/alsa-kernel/pci/emu10k1/emufx.c

@@ -2685 +2685 @@
                 return -ENOMEM;
         len = emu->audigy ? 2 * 1024 : 2 * 512;
-#ifndef TARGET_OS2
+#ifdef TARGET_OS2
         emu->saved_icode = vmalloc(array_size(len, 4));
 #else

GPL/branches/uniaud32-next/alsa-kernel/pci/emu10k1/p16v.c

@@ -858 +858 @@
 int snd_p16v_alloc_pm_buffer(struct snd_emu10k1 *emu)
 {
-#ifndef TARGET_OS2
+#ifdef TARGET_OS2
         emu->p16v_saved = vmalloc(array_size(NUM_CHS * 4, 0x80));
 #else

GPL/branches/uniaud32-next/alsa-kernel/pci/hda/hda_controller.c

@@ -9 +9 @@
  *                     PeiSen Hou <pshou@realtek.com.tw>
  */
-
-#ifdef TARGET_OS2
-#include <linux/delay.h>
-#include <linux/interrupt.h>
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/dma-mapping.h>
-#include <linux/moduleparam.h>
-#include <linux/init.h>
-#include <linux/slab.h>
-#include <linux/pci.h>
-#include <linux/mutex.h>
-#include <linux/reboot.h>
-#include <linux/io.h>
-#include <linux/pm_runtime.h>
-#include <linux/clocksource.h>
-#include <linux/time.h>
-#include <linux/completion.h>
-#include <linux/math64.h>
-#endif
 
 #include <linux/clocksource.h>
@@ -1396 +1376 @@
                 snd_hda_codec_configure(codec);
         }
+
         if (!azx_bus(chip)->num_codecs)
                 return -ENODEV;

GPL/branches/uniaud32-next/alsa-kernel/pci/hda/hda_generic.c

@@ -27 +27 @@
 #include "hda_beep.h"
 #include "hda_generic.h"
+
 #ifdef TARGET_OS2
 #define KBUILD_MODNAME "hda_generic"
@@ -5273 +5274 @@
 
         free_kctls(spec); /* no longer needed */
+
         err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
         if (err < 0)
@@ -5854 +5856 @@
                               aamix_default(codec->spec));
         set_pin_eapd(codec, pin, path->active);
-
 }
 

GPL/branches/uniaud32-next/alsa-kernel/pci/hda/hda_hwdep.c

@@ -47 +47 @@
         } else {
                 verb -= codec->core.start_nid;
-#ifndef TARGET_OS2
                 verb = array_index_nospec(verb, codec->core.num_nodes);
-#endif
                 res = codec->wcaps[verb];
         }

GPL/branches/uniaud32-next/alsa-kernel/pci/hda/hda_intel.c

@@ -37 +37 @@
 #include <linux/completion.h>
 #ifdef TARGET_OS2
-#include <linux/math64.h>
-
 #define KBUILD_MODNAME "hda_intel"
 #endif
@@ -53 +51 @@
 #include <sound/hda_i915.h>
 #include <sound/intel-nhlt.h>
-#ifndef TARGET_OS2
 #include <linux/vgaarb.h>
 #include <linux/vga_switcheroo.h>
-#endif
 #include <linux/firmware.h>
 #include <sound/hda_codec.h>
@@ -811 +807 @@
                         "unable to grab IRQ %d, disabling device\n",
                         chip->pci->irq);
-#ifndef TARGET_OS2
                 if (do_disconnect)
                         snd_card_disconnect(chip->card);
-#endif
                 return -1;
         }
@@ -1401 +1395 @@
 
         hda->init_failed = 1; /* to be sure */
-#ifndef TARGET_OS2
         complete_all(&hda->probe_wait);
-#endif
 
 #ifdef CONFIG_VGA_SWITCHEROO
@@ -2210 +2202 @@
 
         dev++;
-#ifndef TARGET_OS2
         if (chip->disabled)
                 complete_all(&hda->probe_wait);
-#endif
         return 0;
 
@@ -2391 +2381 @@
         if (!hda->need_i915_power)
                 display_power(chip, false);
-#ifndef TARGET_OS2
         complete_all(&hda->probe_wait);
-#endif
         to_hda_bus(bus)->bus_probing = 0;
         return 0;

GPL/branches/uniaud32-next/alsa-kernel/pci/hda/hda_priv.h

@@ -216 +216 @@
         unsigned char stream_tag;       /* assigned stream */
         unsigned char index;            /* stream index */
-#ifndef TARGET_OS2
         int assigned_key;               /* last device# key assigned to */
-#else
-        int device;                     /* last device number assigned to */
-#endif
 
         unsigned int opened:1;

GPL/branches/uniaud32-next/alsa-kernel/pci/hda/hda_proc.c

@@ -903 +903 @@
 }
 
-#ifdef CONFIG_PROC_FS
 /*
  * create a proc read
@@ -914 +913 @@
         return snd_card_ro_proc_new(codec->card, name, codec, print_codec_info);
 }
-#endif

GPL/branches/uniaud32-next/alsa-kernel/pci/hda/hda_sysfs.c

@@ -8 +8 @@
  */
 
-#ifdef TARGET_OS2
-#include <linux/sysfs.h>
-#endif
 #include <linux/init.h>
 #include <linux/slab.h>
@@ -718 +715 @@
 int snd_hda_load_patch(struct hda_bus *bus, size_t fw_size, const void *fw_buf)
 {
-dprintf(("snd_hda_load_patch"));
         char buf[128];
         struct hda_codec *codec;

GPL/branches/uniaud32-next/alsa-kernel/pci/hda/patch_conexant.c

@@ -709 +709 @@
 
 #ifdef TARGET_OS2
-static const struct hda_pintbl CXT_PINCFG_COMPAQ_CQ60_PINS[] = {
-                        /* 0x17 was falsely set up as a mic, it should 0x1d */
-                        { 0x17, 0x400001f0 },
-                        { 0x1d, 0x97a70120 },
-                        {0}
-                };
-
 static const struct hda_pintbl CXT_FIXUP_HEADPHONE_MIC_PIN_PINS[] = {
                         { 0x18, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
@@ -737 +730 @@
 static const struct hda_pintbl CXT_FIXUP_HP_530_PINS[] = {
                         { 0x12, 0x90a60160 }, /* int mic */
-                        {0}
-};
-
-static const struct hda_pintbl CXT_FIXUP_HP_SPECTRE_PINS[] = {
-                        /* enable NID 0x1d for the speaker on top */
-                        { 0x1d, 0x91170111 },
-                        {0}
-};
-
-static const struct hda_pintbl CXT_FIXUP_HP_MIC_NO_PRESENCE_PINS[] = {
-                        { 0x1a, 0x02a1113c },
                         {0}
 };

GPL/branches/uniaud32-next/alsa-kernel/pci/hda/patch_sigmatel.c

@@ -29 +29 @@
 #ifdef TARGET_OS2
 #define KBUILD_MODNAME "patch_sigmatel"
-// 2020-11-17 SHL
-#include <../../../lib32/internal.h>
 #endif
 
@@ -1945 +1943 @@
                 .v.pins = stac92hd89xx_hp_z1_g2_right_mic_jack_pin_configs,
         },
-#ifdef TARGET_OS2xxx
         [STAC_92HD73XX_ASUS_MOBO] = {
                 .type = HDA_FIXUP_PINS,
+#ifndef TARGET_OS2
                 .v.pins = (const struct hda_pintbl[]) {
                         /* enable 5.1 and SPDIF out */
@@ -1956 +1954 @@
                         {0}
                 }
-        },
+#else
+                .v.pins = STAC_92HD73XX_ASUS_MOBO_PINS,
 #endif
+        },
 };
 

GPL/branches/uniaud32-next/alsa-kernel/pci/hda/patch_via.c

@@ -193 +193 @@
                 snd_hda_codec_write(codec, 0x1, 0, 0xf81, 1);
                 codec->jackpoll_interval = 0;
-                //NOT_USED cancel_delayed_work_sync(&codec->jackpoll_work);
+                cancel_delayed_work_sync(&codec->jackpoll_work);
                 spec->hp_work_active = false;
         }

GPL/branches/uniaud32-next/alsa-kernel/pci/intel8x0.c

@@ -9 +9 @@
  *   for SiS735, so the code is not fully functional.
  *
-
  */      
 
 #ifdef TARGET_OS2
 #define KBUILD_MODNAME "intel8x0"
-#include <linux/ktime.h>
-extern ktime_t ktime_get(void);
 #endif
 
@@ -3182 +3179 @@
 static int check_default_spdif_aclink(struct pci_dev *pci)
 {
-#ifndef TARGET_OS2
         const struct snd_pci_quirk *w;
 
@@ -3197 +3193 @@
                 return w->value;
         }
-#endif
         return 0;
 }

GPL/branches/uniaud32-next/alsa-kernel/pci/maestro3.c

@@ -2582 +2582 @@
                 quirk = snd_pci_quirk_lookup(pci, m3_amp_quirk_list);
                 if (quirk) {
-#ifndef TARGET_OS2
                         dev_info(card->dev, "set amp-gpio for '%s'\n",
                                  snd_pci_quirk_name(quirk));
-#endif
                         chip->amp_gpio = quirk->value;
                 } else if (chip->allegro_flag)
@@ -2595 +2593 @@
         quirk = snd_pci_quirk_lookup(pci, m3_irda_quirk_list);
         if (quirk) {
-#ifndef TARGET_OS2
                 dev_info(card->dev, "enabled irda workaround for '%s'\n",
                          snd_pci_quirk_name(quirk));
-#endif
                 chip->irda_workaround = 1;
         }
@@ -2653 +2649 @@
 
 #ifdef CONFIG_PM_SLEEP
-#ifndef TARGET_OS2
         chip->suspend_mem =
                 vmalloc(array_size(sizeof(u16),
                                    REV_B_CODE_MEMORY_LENGTH +
                                         REV_B_DATA_MEMORY_LENGTH));
-#else
-        chip->suspend_mem = vmalloc(sizeof(u16) * (REV_B_CODE_MEMORY_LENGTH + REV_B_DATA_MEMORY_LENGTH));
-#endif
         if (chip->suspend_mem == NULL)
                 dev_warn(card->dev, "can't allocate apm buffer\n");
@@ -2713 +2705 @@
         int err;
 
-#ifndef TARGET_OS2
         /* don't pick up modems */
         if (((pci->class >> 8) & 0xffff) != PCI_CLASS_MULTIMEDIA_AUDIO)
                 return -ENODEV;
-#endif
+
         if (dev >= SNDRV_CARDS)
                 return -ENODEV;

GPL/branches/uniaud32-next/alsa-kernel/pci/trident/trident_main.c

@@ -3351 +3351 @@
         trident->tlb.entries_dmaaddr = ALIGN(trident->tlb.buffer.addr, SNDRV_TRIDENT_MAX_PAGES * 4);
         /* allocate shadow TLB page table (virtual addresses) */
-#ifndef TARGET_OS2
         trident->tlb.shadow_entries =
                 vmalloc(array_size(SNDRV_TRIDENT_MAX_PAGES,
                                    sizeof(unsigned long)));
-#else
-        trident->tlb.shadow_entries = vmalloc(SNDRV_TRIDENT_MAX_PAGES*sizeof(unsigned long));
-#endif
         if (!trident->tlb.shadow_entries)
                 return -ENOMEM;

GPL/branches/uniaud32-next/include/asm/atomic.h

@@ -92 +92 @@
 #define atomic_inc_return(v)            atomic_add_return(1, (v))
 
+typedef struct {
+        long long counter;
+} atomic64_t;
 
+typedef atomic64_t atomic_long_t;
 #endif

GPL/branches/uniaud32-next/include/asm/unaligned.h

@@ -1 +1 @@
 #ifndef _ASM_UNALIGNED_H
 #define _ASM_UNALIGNED_H
-
+#  include <linux/unaligned/le_byteshift.h>
+#  include <linux/unaligned/be_byteshift.h>
 #endif

GPL/branches/uniaud32-next/include/linux/clocksource.h

@@ -1 +1 @@
 #ifndef _LINUX_CLOCKSOURCE_H
 #define _LINUX_CLOCKSOURCE_H
+
+#include <linux/types.h>
+
 /* clocksource cycle base type */
 typedef u64 cycle_t;

GPL/branches/uniaud32-next/include/linux/completion.h

@@ -35 +35 @@
 
 extern void complete(struct completion *);
-
+extern void complete_all(struct completion *);
+extern void wait_for_completion(struct completion *x);
+extern bool try_wait_for_completion(struct completion *x);
 #endif /* _LINUX_COMPLETION_H */

GPL/branches/uniaud32-next/include/linux/device.h

@@ -6 +6 @@
 #include <linux/sysfs.h>
 #include <linux/lockdep.h>
+#include <linux/overflow.h>
 
 struct device;
@@ -291 +292 @@
 extern void *devres_find(struct device *dev, dr_release_t release,
                          dr_match_t match, void *match_data);
+
+/* debugging and troubleshooting/diagnostic helpers. */
+extern const char *dev_driver_string(const struct device *dev);
+
 #endif /* _LINUX_DEVICE_H */
 

GPL/branches/uniaud32-next/include/linux/fs.h

@@ -165 +165 @@
         struct dentry           *f_dentry;
         const struct file_operations    *f_op;
+        struct inode            *f_inode;       /* cached value */
         spinlock_t              f_lock;
         atomic_t                f_count;
@@ -182 +183 @@
 
 struct inode {
-#ifdef TARGET_OS2
-        kdev_t                  i_rdev;
-        struct semaphore        i_sem;
-        union {
-                void            *generic_ip;
-        } u;
-
-#else
          void * i_hash;
          void * i_list;
@@ -225 +218 @@
                 void                            *generic_ip;
         } u;
-#endif
 };
 
@@ -335 +327 @@
 #define FMODE_STREAM            (( fmode_t)0x200000)
 
+static inline struct inode *file_inode(const struct file *f)
+{
+        return f->f_inode;
+}
+
 #endif /* _LINUX_FS_H */

GPL/branches/uniaud32-next/include/linux/genalloc.h

@@ -1 +1 @@
 #ifndef _LINUX_GENALLOC_H
 #define _LINUX_GENALLOC_H
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/printk.h>
 
 #endif /* _LINUX_GENALLOC_H */

GPL/branches/uniaud32-next/include/linux/init.h

@@ -1 +1 @@
 #ifndef _LINUX_INIT_H
 #define _LINUX_INIT_H
+
+#include <asm/errno.h>
+
 
 /* These macros are used to mark some functions or 

GPL/branches/uniaud32-next/include/linux/major.h

@@ -1 +1 @@
 #ifndef _LINUX_MAJOR_H
 #define _LINUX_MAJOR_H
+
+#include <linux/types.h>
 
 /*

GPL/branches/uniaud32-next/include/linux/mm.h

@@ -7 +7 @@
 #include <asm/page.h>
 #include <asm/atomic.h>
+#include <linux/overflow.h>
 
 /*

GPL/branches/uniaud32-next/include/linux/module.h

@@ -7 +7 @@
 #ifndef _LINUX_MODULE_H
 #define _LINUX_MODULE_H
+
 #include <linux/moduleparam.h>
+
 /* Poke the use count of a module.  */
 

GPL/branches/uniaud32-next/include/linux/moduleparam.h

@@ -138 +138 @@
                           &__param_arr_##name, perm)
 
-#ifndef TARGET_OS2
-#define module_param_array(name, type, nump, perm)              \
-        module_param_array_named(name, name, type, nump, perm)
-#endif
+#define module_param_array(name, type, nump, perm)
+#define module_param(name, type, perm)
 extern int param_array_set(const char *val, struct kernel_param *kp);
 extern int param_array_get(char *buffer, struct kernel_param *kp);

GPL/branches/uniaud32-next/include/linux/mutex.h

@@ -3 +3 @@
 
 #include <asm/semaphore.h>
+#include <linux/list.h>
+
+struct mutex {
+        atomic_long_t           owner;
+        spinlock_t              wait_lock;
+#ifdef CONFIG_MUTEX_SPIN_ON_OWNER
+        struct optimistic_spin_queue osq; /* Spinner MCS lock */
+#endif
+        struct list_head        wait_list;
+#ifdef CONFIG_DEBUG_MUTEXES
+        void                    *magic;
+#endif
+#ifdef CONFIG_DEBUG_LOCK_ALLOC
+        struct lockdep_map      dep_map;
+#endif
+};
 
 #define mutex semaphore

GPL/branches/uniaud32-next/include/linux/pci.h

@@ -338 +338 @@
   unsigned short  subsystem_vendor;
   unsigned short  subsystem_device;
-  unsigned int  _class;   /* 3 bytes: (base,sub,prog-if) */
   u8    hdr_type; /* PCI header type (`multi' flag masked out) */
   u8    rom_base_reg; /* Which config register controls the ROM */

GPL/branches/uniaud32-next/include/linux/pm_runtime.h

@@ -3 +3 @@
 
 #include <asm/errno.h>
+#include <linux/pm.h>
+
 /* Runtime PM flag argument bits */
 #define RPM_ASYNC               0x01    /* Request is asynchronous */

GPL/branches/uniaud32-next/include/linux/proc_fs.h

@@ -241 +241 @@
 }
 static inline void *PDE_DATA(const struct inode *inode) {return NULL;}
+
+extern struct proc_dir_entry *proc_symlink(const char *,
+                struct proc_dir_entry *, const char *);
+extern struct proc_dir_entry *proc_mkdir(const char *, struct proc_dir_entry *);
 #endif /* _LINUX_PROC_FS_H */

GPL/branches/uniaud32-next/include/linux/rbtree.h

@@ -26 +26 @@
   See Documentation/rbtree.txt for documentation and samples.
 */
-/* from 4.14.202 */
+/* from 4.19.163 */
 
 #ifndef _LINUX_RBTREE_H
@@ -35 +35 @@
 //#include <linux/rcupdate.h>
 
-#ifdef TARGET_OS2
-#pragma pack(4)
-#endif
 struct rb_node {
         unsigned long  __rb_parent_color;
         struct rb_node *rb_right;
         struct rb_node *rb_left;
-#ifndef TARGET_OS2
-} __attribute__((aligned(sizeof(long))));
-#else
-};
-#pragma pack()
-#endif
+} /*__attribute__((aligned(sizeof(long))))*/;
     /* The alignment might seem pointless, but allegedly CRIS needs it */
 
@@ -109 +101 @@
 extern void rb_replace_node_rcu(struct rb_node *victim, struct rb_node *new,
                                 struct rb_root *root);
+extern void rb_replace_node_cached(struct rb_node *victim, struct rb_node *new,
+                                   struct rb_root_cached *root);
 
 static inline void rb_link_node(struct rb_node *node, struct rb_node *parent,

GPL/branches/uniaud32-next/include/linux/rbtree_augmented.h

@@ -21 +21 @@
   linux/include/linux/rbtree_augmented.h
 */
-/* from 4.14.202 */
+/* from 4.19.163 */
+
 #ifndef _LINUX_RBTREE_AUGMENTED_H
 #define _LINUX_RBTREE_AUGMENTED_H
@@ -27 +28 @@
 #include <linux/compiler.h>
 #include <linux/rbtree.h>
+//#include <linux/rcupdate.h>
 
 /*
@@ -56 +58 @@
  * affected subtrees.
  */
-static inline void
+/*static inline*/ void
 rb_insert_augmented(struct rb_node *node, struct rb_root *root,
                     const struct rb_augment_callbacks *augment)
@@ -63 +65 @@
 }
 
-static inline void
+/*static inline*/ void
 rb_insert_augmented_cached(struct rb_node *node,
                            struct rb_root_cached *root, bool newleft,
@@ -72 +74 @@
 }
 
-#define RB_DECLARE_CALLBACKS(rbstatic, rbname, rbstruct, rbfield,       \
+#define RB_DECLARE_CALLBACKS(rb/*static*/, rbname, rbstruct, rbfield,   \
                              rbtype, rbaugmented, rbcompute)            \
-static inline void                                                      \
+/*static inline*/ void                                                  \
 rbname ## _propagate(struct rb_node *rb, struct rb_node *stop)          \
 {                                                                       \
@@ -86 +88 @@
         }                                                               \
 }                                                                       \
-static inline void                                                      \
+/*static inline*/ void                                                  \
 rbname ## _copy(struct rb_node *rb_old, struct rb_node *rb_new)         \
 {                                                                       \
@@ -93 +95 @@
         new->rbaugmented = old->rbaugmented;                            \
 }                                                                       \
-static void                                                             \
+/*static*/ void                                                         \
 rbname ## _rotate(struct rb_node *rb_old, struct rb_node *rb_new)       \
 {                                                                       \
@@ -101 +103 @@
         old->rbaugmented = rbcompute(old);                              \
 }                                                                       \
-rbstatic const struct rb_augment_callbacks rbname = {                   \
+rb/*static*/ const struct rb_augment_callbacks rbname = {                       \
         .propagate = rbname ## _propagate,                              \
         .copy = rbname ## _copy,                                        \
@@ -120 +122 @@
 #define rb_is_black(rb)    __rb_is_black((rb)->__rb_parent_color)
 
-static inline void rb_set_parent(struct rb_node *rb, struct rb_node *p)
+/*static inline*/ void rb_set_parent(struct rb_node *rb, struct rb_node *p)
 {
         rb->__rb_parent_color = rb_color(rb) | (unsigned long)p;
 }
 
-static inline void rb_set_parent_color(struct rb_node *rb,
+/*static inline*/ void rb_set_parent_color(struct rb_node *rb,
                                        struct rb_node *p, int color)
 {
@@ -131 +133 @@
 }
 
-static inline void
+/*static inline*/ void
 __rb_change_child(struct rb_node *old, struct rb_node *new,
                   struct rb_node *parent, struct rb_root *root)
@@ -145 +147 @@
 
 #ifndef TARGET_OS2
-static inline void
+/*static inline*/ void
 __rb_change_child_rcu(struct rb_node *old, struct rb_node *new,
                       struct rb_node *parent, struct rb_root *root)
@@ -162 +164 @@
         void (*augment_rotate)(struct rb_node *old, struct rb_node *new));
 
-static inline struct rb_node *
+/*static inline*/ struct rb_node *
 __rb_erase_augmented(struct rb_node *node, struct rb_root *root,
                      struct rb_node **leftmost,
@@ -270 +272 @@
 }
 
-static inline void
+/*static inline*/ void
 rb_erase_augmented(struct rb_node *node, struct rb_root *root,
                    const struct rb_augment_callbacks *augment)
@@ -280 +282 @@
 }
 
-static inline void
+/*static inline*/ void
 rb_erase_augmented_cached(struct rb_node *node, struct rb_root_cached *root,
                           const struct rb_augment_callbacks *augment)

GPL/branches/uniaud32-next/include/linux/regmap.h

@@ -13 +13 @@
  * published by the Free Software Foundation.
  */
-/* from 4.14.202 */
+/* from 4.19.163 */
 
 #include <linux/list.h>
 #include <linux/rbtree.h>
+#include <linux/ktime.h>
 #include <linux/delay.h>
 #include <linux/err.h>
@@ -22 +23 @@
 #include <linux/lockdep.h>
 
-#define CONFIG_REGMAP
-
 struct module;
+struct clk;
 struct device;
 struct i2c_client;
 struct irq_domain;
+struct slim_device;
 struct spi_device;
 struct spmi_device;
@@ -34 +35 @@
 struct regmap_field;
 struct snd_ac97;
+struct sdw_slave;
 
 /* An enum of all the supported cache types */
@@ -124 +126 @@
 #define regmap_read_poll_timeout(map, addr, val, cond, sleep_us, timeout_us) \
 ({ \
-        ktime_t timeout = ktime_add_us(ktime_get(), timeout_us); \
+        u64 __timeout_us = (timeout_us); \
+        unsigned long __sleep_us = (sleep_us); \
+        ktime_t __timeout = ktime_add_us(ktime_get(), __timeout_us); \
+        int __ret; \
+        might_sleep_if(__sleep_us); \
+        for (;;) { \
+                __ret = regmap_read((map), (addr), &(val)); \
+                if (__ret) \
+                        break; \
+                if (cond) \
+                        break; \
+                if ((__timeout_us) && \
+                    ktime_compare(ktime_get(), __timeout) > 0) { \
+                        __ret = regmap_read((map), (addr), &(val)); \
+                        break; \
+                } \
+                if (__sleep_us) \
+                        usleep_range((__sleep_us >> 2) + 1, __sleep_us); \
+        } \
+        __ret ?: ((cond) ? 0 : -ETIMEDOUT); \
+})
+
+/**
+ * regmap_field_read_poll_timeout - Poll until a condition is met or timeout
+ *
+ * @field: Regmap field to read from
+ * @val: Unsigned integer variable to read the value into
+ * @cond: Break condition (usually involving @val)
+ * @sleep_us: Maximum time to sleep between reads in us (0
+ *            tight-loops).  Should be less than ~20ms since usleep_range
+ *            is used (see Documentation/timers/timers-howto.txt).
+ * @timeout_us: Timeout in us, 0 means never timeout
+ *
+ * Returns 0 on success and -ETIMEDOUT upon a timeout or the regmap_field_read
+ * error return value in case of a error read. In the two former cases,
+ * the last read value at @addr is stored in @val. Must not be called
+ * from atomic context if sleep_us or timeout_us are used.
+ *
+ * This is modelled after the readx_poll_timeout macros in linux/iopoll.h.
+ */
+#define regmap_field_read_poll_timeout(field, val, cond, sleep_us, timeout_us) \
+({ \
+        u64 __timeout_us = (timeout_us); \
+        unsigned long __sleep_us = (sleep_us); \
+        ktime_t timeout = ktime_add_us(ktime_get(), __timeout_us); \
         int pollret; \
-        might_sleep_if(sleep_us); \
+        might_sleep_if(__sleep_us); \
         for (;;) { \
-                pollret = regmap_read((map), (addr), &(val)); \
+                pollret = regmap_field_read((field), &(val)); \
                 if (pollret) \
                         break; \
                 if (cond) \
                         break; \
-                if (timeout_us && ktime_compare(ktime_get(), timeout) > 0) { \
-                        pollret = regmap_read((map), (addr), &(val)); \
+                if (__timeout_us && ktime_compare(ktime_get(), timeout) > 0) { \
+                        pollret = regmap_field_read((field), &(val)); \
                         break; \
                 } \
-                if (sleep_us) \
-                        usleep_range((sleep_us >> 2) + 1, sleep_us); \
+                if (__sleep_us) \
+                        usleep_range((__sleep_us >> 2) + 1, __sleep_us); \
         } \
         pollret ?: ((cond) ? 0 : -ETIMEDOUT); \
 })
 
+#define CONFIG_REGMAP
 #ifdef CONFIG_REGMAP
 
@@ -224 +271 @@
  *                check is performed on such table (a register is precious if
  *                it belongs to one of the ranges specified by precious_table).
+ * @readable_noinc_reg: Optional callback returning true if the register
+ *                      supports multiple read operations without incrementing
+ *                      the register number. If this field is NULL but
+ *                      rd_noinc_table (see below) is not, the check is
+ *                      performed on such table (a register is no increment
+ *                      readable if it belongs to one of the ranges specified
+ *                      by rd_noinc_table).
+ * @disable_locking: This regmap is either protected by external means or
+ *                   is guaranteed not be be accessed from multiple threads.
+ *                   Don't use any locking mechanisms.
  * @lock:         Optional lock callback (overrides regmap's default lock
  *                function, based on spinlock or mutex).
@@ -248 +305 @@
  * @volatile_table: As above, for volatile registers.
  * @precious_table: As above, for precious registers.
+ * @rd_noinc_table: As above, for no increment readable registers.
  * @reg_defaults: Power on reset values for registers (for use with
  *                register cache support).
@@ -256 +314 @@
  * @write_flag_mask: Mask to be set in the top bytes of the register when doing
  *                   a write. If both read_flag_mask and write_flag_mask are
- *                   empty the regmap_bus default masks are used.
+ *                   empty and zero_flag_mask is not set the regmap_bus default
+ *                   masks are used.
+ * @zero_flag_mask: If set, read_flag_mask and write_flag_mask are used even
+ *                   if they are both empty.
  * @use_single_rw: If set, converts the bulk read and write operations into
  *                  a series of single read and write operations. This is useful
@@ -277 +338 @@
  * @ranges: Array of configuration entries for virtual address ranges.
  * @num_ranges: Number of range configuration entries.
+ * @use_hwlock: Indicate if a hardware spinlock should be used.
+ * @hwlock_id: Specify the hardware spinlock id.
+ * @hwlock_mode: The hardware spinlock mode, should be HWLOCK_IRQSTATE,
+ *               HWLOCK_IRQ or 0.
  */
 struct regmap_config {
@@ -290 +355 @@
         bool (*volatile_reg)(struct device *dev, unsigned int reg);
         bool (*precious_reg)(struct device *dev, unsigned int reg);
+        bool (*readable_noinc_reg)(struct device *dev, unsigned int reg);
+
+        bool disable_locking;
         regmap_lock lock;
         regmap_unlock unlock;
@@ -304 +372 @@
         const struct regmap_access_table *volatile_table;
         const struct regmap_access_table *precious_table;
+        const struct regmap_access_table *rd_noinc_table;
         const struct reg_default *reg_defaults;
         unsigned int num_reg_defaults;
@@ -312 +381 @@
         unsigned long read_flag_mask;
         unsigned long write_flag_mask;
+        bool zero_flag_mask;
 
         bool use_single_read;
@@ -322 +392 @@
         const struct regmap_range_cfg *ranges;
         unsigned int num_ranges;
+
+        bool use_hwlock;
+        unsigned int hwlock_id;
+        unsigned int hwlock_mode;
 };
 
@@ -454 +528 @@
                                  struct lock_class_key *lock_key,
                                  const char *lock_name);
+struct regmap *__regmap_init_sccb(struct i2c_client *i2c,
+                                  const struct regmap_config *config,
+                                  struct lock_class_key *lock_key,
+                                  const char *lock_name);
+struct regmap *__regmap_init_slimbus(struct slim_device *slimbus,
+                                 const struct regmap_config *config,
+                                 struct lock_class_key *lock_key,
+                                 const char *lock_name);
 struct regmap *__regmap_init_spi(struct spi_device *dev,
                                  const struct regmap_config *config,
@@ -479 +561 @@
                                   struct lock_class_key *lock_key,
                                   const char *lock_name);
+struct regmap *__regmap_init_sdw(struct sdw_slave *sdw,
+                                 const struct regmap_config *config,
+                                 struct lock_class_key *lock_key,
+                                 const char *lock_name);
 
 struct regmap *__devm_regmap_init(struct device *dev,
@@ -490 +576 @@
                                       struct lock_class_key *lock_key,
                                       const char *lock_name);
+struct regmap *__devm_regmap_init_sccb(struct i2c_client *i2c,
+                                       const struct regmap_config *config,
+                                       struct lock_class_key *lock_key,
+                                       const char *lock_name);
 struct regmap *__devm_regmap_init_spi(struct spi_device *dev,
                                       const struct regmap_config *config,
@@ -516 +606 @@
                                        struct lock_class_key *lock_key,
                                        const char *lock_name);
-
+struct regmap *__devm_regmap_init_sdw(struct sdw_slave *sdw,
+                                 const struct regmap_config *config,
+                                 struct lock_class_key *lock_key,
+                                 const char *lock_name);
+struct regmap *__devm_regmap_init_slimbus(struct slim_device *slimbus,
+                                 const struct regmap_config *config,
+                                 struct lock_class_key *lock_key,
+                                 const char *lock_name);
 /*
  * Wrapper for regmap_init macros to include a unique lockdep key and name
@@ -571 +668 @@
 
 /**
+ * regmap_init_sccb() - Initialise register map
+ *
+ * @i2c: Device that will be interacted with
+ * @config: Configuration for register map
+ *
+ * The return value will be an ERR_PTR() on error or a valid pointer to
+ * a struct regmap.
+ */
+#define regmap_init_sccb(i2c, config)                                   \
+        __regmap_lockdep_wrapper(__regmap_init_sccb, #config,           \
+                                i2c, config)
+
+/**
+ * regmap_init_slimbus() - Initialise register map
+ *
+ * @slimbus: Device that will be interacted with
+ * @config: Configuration for register map
+ *
+ * The return value will be an ERR_PTR() on error or a valid pointer to
+ * a struct regmap.
+ */
+#define regmap_init_slimbus(slimbus, config)                            \
+        __regmap_lockdep_wrapper(__regmap_init_slimbus, #config,        \
+                                slimbus, config)
+
+/**
  * regmap_init_spi() - Initialise register map
  *
@@ -665 +788 @@
 
 /**
+ * regmap_init_sdw() - Initialise register map
+ *
+ * @sdw: Device that will be interacted with
+ * @config: Configuration for register map
+ *
+ * The return value will be an ERR_PTR() on error or a valid pointer to
+ * a struct regmap.
+ */
+#define regmap_init_sdw(sdw, config)                                    \
+        __regmap_lockdep_wrapper(__regmap_init_sdw, #config,            \
+                                sdw, config)
+
+
+/**
  * devm_regmap_init() - Initialise managed register map
  *
@@ -696 +833 @@
 
 /**
+ * devm_regmap_init_sccb() - Initialise managed register map
+ *
+ * @i2c: Device that will be interacted with
+ * @config: Configuration for register map
+ *
+ * The return value will be an ERR_PTR() on error or a valid pointer
+ * to a struct regmap.  The regmap will be automatically freed by the
+ * device management code.
+ */
+#define devm_regmap_init_sccb(i2c, config)                              \
+        __regmap_lockdep_wrapper(__devm_regmap_init_sccb, #config,      \
+                                i2c, config)
+
+/**
  * devm_regmap_init_spi() - Initialise register map
  *
@@ -794 +945 @@
                                 ac97, config)
 
+/**
+ * devm_regmap_init_sdw() - Initialise managed register map
+ *
+ * @sdw: Device that will be interacted with
+ * @config: Configuration for register map
+ *
+ * The return value will be an ERR_PTR() on error or a valid pointer
+ * to a struct regmap. The regmap will be automatically freed by the
+ * device management code.
+ */
+#define devm_regmap_init_sdw(sdw, config)                               \
+        __regmap_lockdep_wrapper(__devm_regmap_init_sdw, #config,       \
+                                sdw, config)
+
+/**
+ * devm_regmap_init_slimbus() - Initialise managed register map
+ *
+ * @slimbus: Device that will be interacted with
+ * @config: Configuration for register map
+ *
+ * The return value will be an ERR_PTR() on error or a valid pointer
+ * to a struct regmap. The regmap will be automatically freed by the
+ * device management code.
+ */
+#define devm_regmap_init_slimbus(slimbus, config)                       \
+        __regmap_lockdep_wrapper(__devm_regmap_init_slimbus, #config,   \
+                                slimbus, config)
+int regmap_mmio_attach_clk(struct regmap *map, struct clk *clk);
+void regmap_mmio_detach_clk(struct regmap *map);
 void regmap_exit(struct regmap *map);
 int regmap_reinit_cache(struct regmap *map,
@@ -815 +995 @@
 int regmap_raw_read(struct regmap *map, unsigned int reg,
                     void *val, size_t val_len);
+int regmap_noinc_read(struct regmap *map, unsigned int reg,
+                      void *val, size_t val_len);
 int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
                      size_t val_count);
@@ -1019 +1201 @@
                                unsigned int val)
 {
-        WARN_ONCE(1, "regmap API is disabled");
+//      WARN_ONCE(1, "regmap API is disabled");
         return -EINVAL;
 }
@@ -1060 +1242 @@
 static inline int regmap_raw_read(struct regmap *map, unsigned int reg,
                                   void *val, size_t val_len)
+{
+        WARN_ONCE(1, "regmap API is disabled");
+        return -EINVAL;
+}
+
+static inline int regmap_noinc_read(struct regmap *map, unsigned int reg,
+                                    void *val, size_t val_len)
 {
         WARN_ONCE(1, "regmap API is disabled");

GPL/branches/uniaud32-next/include/linux/slab.h

@@ -7 +7 @@
 #include <linux/types.h>
 #include <linux/list.h>
+#include <linux/overflow.h>
 
 #if     !defined(_LINUX_SLAB_H)

GPL/branches/uniaud32-next/include/linux/time.h

@@ -6 +6 @@
 #include <linux/ktime.h>
 #include <linux/time64.h>
+#include <linux/math64.h>
 
 #define NSEC_PER_SEC    1000000000L

GPL/branches/uniaud32-next/include/linux/time64.h

@@ -1 +1 @@
 #ifndef _LINUX_TIME64_H
 #define _LINUX_TIME64_H
+
+#include <linux/math64.h>
 
 typedef __s64 time64_t;

GPL/branches/uniaud32-next/include/linux/timecounter.h

@@ -1 +1 @@
 #ifndef _LINUX_TIMECOUNTER_H
 #define _LINUX_TIMECOUNTER_H
-
+#include <linux/clocksource.h>
 #endif /* _LINUX_TIMECOUNTER_H */

GPL/branches/uniaud32-next/include/linux/vga_switcheroo.h

@@ -1 @@
-#ifndef _LINUX_EXPORT_H
-#define _LINUX_EXPORT_H
+#ifndef _LINUX_VGA_SWITCHEROO_H
+#define _LINUX_VGA_SWITCHEROO_H
 
-#endif /* _LINUX_EXPORT_H */
+#endif /* _LINUX_VGA_SWITCHEROO_H */

GPL/branches/uniaud32-next/include/linux/vgaarb.h

@@ -1 @@
-#ifndef _LINUX_EXPORT_H
-#define _LINUX_EXPORT_H
+#ifndef _LINUX_VGAARB_H
+#define _LINUX_VGAARB_H
 
-#endif /* _LINUX_EXPORT_H */
+#endif /* _LINUX_VGAARB_H */

GPL/branches/uniaud32-next/include/linux/vmalloc.h

@@ -4 +4 @@
 //#include <linux/sched.h>
 //#include <linux/mm.h>
+#include <linux/overflow.h>
 
 #include <asm/page.h>

GPL/branches/uniaud32-next/include/linux/wait.h

@@ -130 +130 @@
 void __wake_up_locked(wait_queue_head_t *q, unsigned int mode, int nr);
 #endif /* __KERNEL__ */
-
+#define wait_event_lock_irq(wq_head, condition, lock)
+#define wake_up_all(x)                  
 #endif

GPL/branches/uniaud32-next/lib32/drivers_base.c

@@ -13 +13 @@
 #include <linux/device.h>
 #include <linux/err.h>
+#include <linux/pci.h>
 #include <linux/init.h>
 #include <linux/module.h>
@@ -154 +155 @@
 EXPORT_SYMBOL_GPL(put_device);
 
+/**
+ * dev_driver_string - Return a device's driver name, if at all possible
+ * @dev: struct device to get the name of
+ *
+ * Will return the device's driver's name if it is bound to a device.  If
+ * the device is not bound to a driver, it will return the name of the bus
+ * it is attached to.  If it is not attached to a bus either, an empty
+ * string will be returned.
+ */
+const char *dev_driver_string(const struct device *dev)
+{
+        struct device_driver *drv;
+
+        /* dev->driver can change to NULL underneath us because of unbinding,
+         * so be careful about accessing it.  dev->bus and dev->class should
+         * never change once they are set, so they don't need special care.
+         */
+        drv = dev->driver;
+        return drv ? drv->name :
+                        (dev->bus ? dev->bus->name :
+                        (dev->class ? dev->class->name : ""));
+}

GPL/branches/uniaud32-next/lib32/internal.h

@@ -10 +10 @@
  * published by the Free Software Foundation.
  */
-/* from 4.14.202 */
+/* from 4.19.163 */
 
 #ifndef _REGMAP_INTERNAL_H
@@ -82 +82 @@
 
 #ifdef CONFIG_DEBUG_FS
+        bool debugfs_disable;
         struct dentry *debugfs;
         const char *debugfs_name;
@@ -98 +99 @@
         bool (*volatile_reg)(struct device *dev, unsigned int reg);
         bool (*precious_reg)(struct device *dev, unsigned int reg);
+        bool (*readable_noinc_reg)(struct device *dev, unsigned int reg);
         const struct regmap_access_table *wr_table;
         const struct regmap_access_table *rd_table;
         const struct regmap_access_table *volatile_table;
         const struct regmap_access_table *precious_table;
+        const struct regmap_access_table *rd_noinc_table;
 
         int (*reg_read)(void *context, unsigned int reg, unsigned int *val);
@@ -162 +165 @@
         struct rb_root range_tree;
         void *selector_work_buf;        /* Scratch buffer used for selector */
+
+        struct hwspinlock *hwlock;
 };
 
@@ -183 +188 @@
 bool regmap_volatile(struct regmap *map, unsigned int reg);
 bool regmap_precious(struct regmap *map, unsigned int reg);
+bool regmap_readable_noinc(struct regmap *map, unsigned int reg);
 
 int _regmap_write(struct regmap *map, unsigned int reg,
@@ -218 +224 @@
 extern void regmap_debugfs_init(struct regmap *map, const char *name);
 extern void regmap_debugfs_exit(struct regmap *map);
+
+static inline void regmap_debugfs_disable(struct regmap *map)
+{
+        map->debugfs_disable = true;
+}
+
 #else
 static inline void regmap_debugfs_initcall(void) { }
 static inline void regmap_debugfs_init(struct regmap *map, const char *name) { }
 static inline void regmap_debugfs_exit(struct regmap *map) { }
+static inline void regmap_debugfs_disable(struct regmap *map) { }
 #endif
 

GPL/branches/uniaud32-next/lib32/ioctl.c

@@ -276 +276 @@
 
         pcms = pcm_instances(deviceid);
-dprintf(("PSDebug: pcms= %d",pcms));
+
         if (!pcaps || !pcms) return -1;
 

GPL/branches/uniaud32-next/lib32/misc.c

@@ -246 +246 @@
 {
     return 0;
+}
+//******************************************************************************
+//******************************************************************************
+struct proc_dir_entry *proc_mkdir_mode(const char *name, umode_t mode,
+        struct proc_dir_entry *parent){
+    struct proc_dir_entry *proc;
+    proc = (struct proc_dir_entry *)kmalloc(sizeof(struct proc_dir_entry), 0);
+    memset(proc, 0, sizeof(struct proc_dir_entry));
+
+    proc->name   = name;
+    proc->parent = parent;
+
+    return proc;
+}
+//******************************************************************************
+//******************************************************************************
+struct proc_dir_entry *proc_mkdir(const char *name, struct proc_dir_entry *parent)
+{
+    return proc_mkdir_mode(name, S_IRUGO | S_IXUGO, parent);
+}
+//******************************************************************************
+//******************************************************************************
+struct proc_dir_entry *proc_symlink(const char *name, struct proc_dir_entry *parent, const char *dest)
+{
+    struct proc_dir_entry *proc;
+    proc = (struct proc_dir_entry *)kmalloc(sizeof(struct proc_dir_entry), 0);
+    memset(proc, 0, sizeof(struct proc_dir_entry));
+
+    proc->name   = name;
+    proc->parent = parent;
+    proc->data = dest;
+
+    return proc;
 }
 //******************************************************************************

GPL/branches/uniaud32-next/lib32/rbtree.c

@@ -21 +21 @@
   linux/lib/rbtree.c
 */
-/* from 4.14.202 */
+/* from 4.19.163 */
 
 #include <linux/rbtree_augmented.h>
@@ -97 +97 @@
 }
 
-/*static*/ inline void
+/*static inline*/ void
 __rb_insert(struct rb_node *node, struct rb_root *root,
             bool newleft, struct rb_node **leftmost,
@@ -243 +243 @@
  * and eliminate the dummy_rotate callback there
  */
-/*static*/ inline void
+/*static inline*/ void
 ____rb_erase_color(struct rb_node *parent, struct rb_root *root,
         void (*augment_rotate)(struct rb_node *old, struct rb_node *new))
@@ -445 +445 @@
 /*static inline*/ void dummy_rotate(struct rb_node *old, struct rb_node *new) {}
 
-/*static*/ const struct rb_augment_callbacks dummy_callbacks = {
+static const struct rb_augment_callbacks dummy_callbacks = {
         .propagate = dummy_propagate,
         .copy = dummy_copy,
@@ -607 +607 @@
 EXPORT_SYMBOL(rb_replace_node);
 
+void rb_replace_node_cached(struct rb_node *victim, struct rb_node *new,
+                            struct rb_root_cached *root)
+{
+        rb_replace_node(victim, new, &root->rb_root);
+
+        if (root->rb_leftmost == victim)
+                root->rb_leftmost = new;
+}
+EXPORT_SYMBOL(rb_replace_node_cached);
+
 #ifndef TARGET_OS2
 void rb_replace_node_rcu(struct rb_node *victim, struct rb_node *new,
@@ -631 +641 @@
 #endif
 
-/*static*/ struct rb_node *rb_left_deepest_node(const struct rb_node *node)
+static struct rb_node *rb_left_deepest_node(const struct rb_node *node)
 {
         for (;;) {

GPL/branches/uniaud32-next/lib32/regcache-flat.c

@@ -10 +10 @@
  * published by the Free Software Foundation.
  */
-/* from 4.14.202 */
+/* from 4.19.163 */
 
 #include <linux/device.h>
 #include <linux/seq_file.h>
 #include <linux/slab.h>
-#include <linux/module.h>
-#include <linux/workqueue.h>
-#include <linux/byteorder/little_endian.h>
-#include <linux/printk.h>
 
 #include "internal.h"
@@ -43 +39 @@
         cache = map->cache;
 
-        for (i = 0; i < map->num_reg_defaults; i++)
-                cache[regcache_flat_get_index(map, map->reg_defaults[i].reg)] =
-                                map->reg_defaults[i].def;
+        for (i = 0; i < map->num_reg_defaults; i++) {
+                unsigned int reg = map->reg_defaults[i].reg;
+                unsigned int index = regcache_flat_get_index(map, reg);
+
+                cache[index] = map->reg_defaults[i].def;
+        }
 
         return 0;
@@ -62 +61 @@
 {
         unsigned int *cache = map->cache;
+        unsigned int index = regcache_flat_get_index(map, reg);
 
-        *value = cache[regcache_flat_get_index(map, reg)];
+        *value = cache[index];
 
         return 0;
@@ -72 +72 @@
 {
         unsigned int *cache = map->cache;
+        unsigned int index = regcache_flat_get_index(map, reg);
 
-        cache[regcache_flat_get_index(map, reg)] = value;
+        cache[index] = value;
 
         return 0;

GPL/branches/uniaud32-next/lib32/regcache-rbtree.c

@@ -10 +10 @@
  * published by the Free Software Foundation.
  */
-/* from 4.14.202 */
+/* from 4.19.163 */
 
 //#include <linux/debugfs.h>
@@ -24 +24 @@
 #include "internal.h"
 
-/*static*/ int regcache_rbtree_write(struct regmap *map, unsigned int reg,
-                                 unsigned int value);
-/*static*/ int regcache_rbtree_exit(struct regmap *map);
-
 #ifdef TARGET_OS2
 #define UINT_MAX        (~0U)
-#pragma pack(1)
 #endif
+
+/*static inline*/ int regcache_rbtree_write(struct regmap *map, unsigned int reg,
+                                 unsigned int value);
+/*static inline*/ int regcache_rbtree_exit(struct regmap *map);
+
 struct regcache_rbtree_node {
         /* block of adjacent registers */
         void *block;
         /* Which registers are present */
-        unsigned long *cache_present;
+        long *cache_present;
         /* base register handled by this block */
         unsigned int base_reg;
@@ -43 +43 @@
         /* the actual rbtree node holding this block */
         struct rb_node node;
-#ifndef TARGET_OS2
-} __attribute__ ((packed));
-#else
-};
-#pragma pack()
-#endif
+} /*__attribute__ ((packed))*/;
 
 struct regcache_rbtree_ctx {
@@ -55 +50 @@
 };
 
-/*static inline*/ void regcache_rbtree_get_base_top_reg(
+/*static inline*/ inline void regcache_rbtree_get_base_top_reg(
         struct regmap *map,
         struct regcache_rbtree_node *rbnode,
@@ -64 +59 @@
 }
 
-/*static*/ unsigned int regcache_rbtree_get_register(struct regmap *map,
+/*static inline*/ unsigned int regcache_rbtree_get_register(struct regmap *map,
         struct regcache_rbtree_node *rbnode, unsigned int idx)
 {
@@ -70 +65 @@
 }
 
-/*static*/ void regcache_rbtree_set_register(struct regmap *map,
+/*static inline*/ void regcache_rbtree_set_register(struct regmap *map,
                                          struct regcache_rbtree_node *rbnode,
                                          unsigned int idx, unsigned int val)
@@ -78 +73 @@
 }
 
-/*static*/ struct regcache_rbtree_node *regcache_rbtree_lookup(struct regmap *map,
+/*static inline*/ struct regcache_rbtree_node *regcache_rbtree_lookup(struct regmap *map,
                                                            unsigned int reg)
 {
@@ -108 +103 @@
                 }
         }
+
         return NULL;
 }
 
-/*static*/ int regcache_rbtree_insert(struct regmap *map, struct rb_root *root,
+/*static inline*/ int regcache_rbtree_insert(struct regmap *map, struct rb_root *root,
                                   struct regcache_rbtree_node *rbnode)
 {
@@ -121 +117 @@
         parent = NULL;
         new = &root->rb_node;
-
         while (*new) {
                 rbnode_tmp = rb_entry(*new, struct regcache_rbtree_node, node);
@@ -148 +143 @@
 
 #ifdef CONFIG_DEBUG_FS
-/*static*/ int rbtree_show(struct seq_file *s, void *ignored)
+/*static inline*/ int rbtree_show(struct seq_file *s, void *ignored)
 {
         struct regmap *map = s->private;
@@ -192 +187 @@
 }
 
-/*static*/ int rbtree_open(struct inode *inode, struct file *file)
+/*static inline*/ int rbtree_open(struct inode *inode, struct file *file)
 {
         return single_open(file, rbtree_show, inode->i_private);
 }
 
-/*static*/ const struct file_operations rbtree_fops = {
+/*static inline*/ const struct file_operations rbtree_fops = {
         .open           = rbtree_open,
         .read           = seq_read,
@@ -204 +199 @@
 };
 
-/*static*/ void rbtree_debugfs_init(struct regmap *map)
+/*static inline*/ void rbtree_debugfs_init(struct regmap *map)
 {
         debugfs_create_file("rbtree", 0400, map->debugfs, map, &rbtree_fops);
@@ -210 +205 @@
 #endif
 
-/*static*/ int regcache_rbtree_init(struct regmap *map)
+/*static inline*/ int regcache_rbtree_init(struct regmap *map)
 {
         struct regcache_rbtree_ctx *rbtree_ctx;
@@ -233 +228 @@
 #endif
         rbtree_ctx->cached_rbnode = NULL;
+
         for (i = 0; i < map->num_reg_defaults; i++) {
                 ret = regcache_rbtree_write(map,
@@ -248 +244 @@
 }
 
-/*static*/ int regcache_rbtree_exit(struct regmap *map)
+/*static inline*/ int regcache_rbtree_exit(struct regmap *map)
 {
         struct rb_node *next;
@@ -277 +273 @@
 }
 
-/*static*/ int regcache_rbtree_read(struct regmap *map,
+/*static inline*/ int regcache_rbtree_read(struct regmap *map,
                                 unsigned int reg, unsigned int *value)
 {
@@ -292 +288 @@
                 return -ENOENT;
         }
-        return 0;
-}
-
-
-/*static*/ int regcache_rbtree_insert_to_block(struct regmap *map,
+
+        return 0;
+}
+
+
+/*static inline*/ int regcache_rbtree_insert_to_block(struct regmap *map,
                                            struct regcache_rbtree_node *rbnode,
                                            unsigned int base_reg,
@@ -351 +348 @@
 }
 
-/*static*/ struct regcache_rbtree_node *
+/*static inline*/ struct regcache_rbtree_node *
 regcache_rbtree_node_alloc(struct regmap *map, unsigned int reg)
 {
@@ -369 +366 @@
                                 break;
                 }
+
                 if (i != map->rd_table->n_yes_ranges) {
                         range = &map->rd_table->yes_ranges[i];
@@ -376 +374 @@
                 }
         }
+
         if (!rbnode->blklen) {
                 rbnode->blklen = 1;
@@ -401 +400 @@
 }
 
-/*static*/ int regcache_rbtree_write(struct regmap *map, unsigned int reg,
+/*static inline*/ int regcache_rbtree_write(struct regmap *map, unsigned int reg,
                                  unsigned int value)
 {
@@ -476 +475 @@
                                                               new_top_reg, reg,
                                                               value);
-                        if (ret){
-                                return ret;}
+                        if (ret)
+                                return ret;
                         rbtree_ctx->cached_rbnode = rbnode;
                         return 0;
@@ -486 +485 @@
                  */
                 rbnode = regcache_rbtree_node_alloc(map, reg);
-                if (!rbnode){
-                        return -ENOMEM;}
+                if (!rbnode)
+                        return -ENOMEM;
                 regcache_rbtree_set_register(map, rbnode,
                                              reg - rbnode->base_reg, value);
@@ -493 +492 @@
                 rbtree_ctx->cached_rbnode = rbnode;
         }
-        return 0;
-}
-
-/*static*/ int regcache_rbtree_sync(struct regmap *map, unsigned int min,
+
+        return 0;
+}
+
+/*static inline*/ int regcache_rbtree_sync(struct regmap *map, unsigned int min,
                                 unsigned int max)
 {
@@ -537 +537 @@
 }
 
-/*static*/ int regcache_rbtree_drop(struct regmap *map, unsigned int min,
+/*static inline*/ int regcache_rbtree_drop(struct regmap *map, unsigned int min,
                                 unsigned int max)
 {

GPL/branches/uniaud32-next/lib32/regcache.c

@@ -10 +10 @@
  * published by the Free Software Foundation.
  */
-/* from 4.14.202 */
+/* from 4.19.163 */
 
 //#include <linux/bsearch.h>

GPL/branches/uniaud32-next/lib32/regmap.c

@@ -10 +10 @@
  * published by the Free Software Foundation.
  */
-/* from 4.14.202 */
+/* from 4.19.163 */
 
 #include <linux/device.h>
@@ -22 +22 @@
 #include <linux/delay.h>
 #include <linux/log2.h>
+//#include <linux/hwspinlock.h>
+#include <asm/unaligned.h>
 #include <linux/module.h>
 #include <linux/workqueue.h>
 #include <linux/byteorder/little_endian.h>
 #include <linux/printk.h>
+
+/* hwspinlock mode argument */
+#define HWLOCK_IRQSTATE 0x01    /* Disable interrupts, save state */
+#define HWLOCK_IRQ      0x02    /* Disable interrupts, don't save state */
+#define HWLOCK_RAW      0x03
 
 #define CREATE_TRACE_POINTS
@@ -40 +47 @@
 #undef LOG_DEVICE
 
-static int _regmap_update_bits(struct regmap *map, unsigned int reg,
+/*static inline*/ int _regmap_update_bits(struct regmap *map, unsigned int reg,
                                unsigned int mask, unsigned int val,
                                bool *change, bool force_write);
 
-static int _regmap_bus_reg_read(void *context, unsigned int reg,
+/*static inline*/ int _regmap_bus_reg_read(void *context, unsigned int reg,
                                 unsigned int *val);
-static int _regmap_bus_read(void *context, unsigned int reg,
+/*static inline*/ int _regmap_bus_read(void *context, unsigned int reg,
                             unsigned int *val);
-static int _regmap_bus_formatted_write(void *context, unsigned int reg,
+/*static inline*/ int _regmap_bus_formatted_write(void *context, unsigned int reg,
                                        unsigned int val);
-static int _regmap_bus_reg_write(void *context, unsigned int reg,
+/*static inline*/ int _regmap_bus_reg_write(void *context, unsigned int reg,
                                  unsigned int val);
-static int _regmap_bus_raw_write(void *context, unsigned int reg,
+/*static inline*/ int _regmap_bus_raw_write(void *context, unsigned int reg,
                                  unsigned int val);
 
@@ -173 +180 @@
 }
 
-static bool regmap_volatile_range(struct regmap *map, unsigned int reg,
+bool regmap_readable_noinc(struct regmap *map, unsigned int reg)
+{
+        if (map->readable_noinc_reg)
+                return map->readable_noinc_reg(map->dev, reg);
+
+        if (map->rd_noinc_table)
+                return regmap_check_range_table(map, reg, map->rd_noinc_table);
+
+        return true;
+}
+
+/*static inline*/ bool regmap_volatile_range(struct regmap *map, unsigned int reg,
         size_t num)
 {
@@ -179 +197 @@
 
         for (i = 0; i < num; i++)
-                if (!regmap_volatile(map, reg + i))
+                if (!regmap_volatile(map, reg + regmap_get_offset(map, i)))
                         return false;
 
@@ -185 +203 @@
 }
 
-static void regmap_format_2_6_write(struct regmap *map,
+/*static inline*/ void regmap_format_2_6_write(struct regmap *map,
                                      unsigned int reg, unsigned int val)
 {
@@ -193 +211 @@
 }
 
-static void regmap_format_4_12_write(struct regmap *map,
+/*static inline*/ void regmap_format_4_12_write(struct regmap *map,
                                      unsigned int reg, unsigned int val)
 {
@@ -200 +218 @@
 }
 
-static void regmap_format_7_9_write(struct regmap *map,
+/*static inline*/ void regmap_format_7_9_write(struct regmap *map,
                                     unsigned int reg, unsigned int val)
 {
@@ -207 +225 @@
 }
 
-static void regmap_format_10_14_write(struct regmap *map,
+/*static inline*/ void regmap_format_10_14_write(struct regmap *map,
                                     unsigned int reg, unsigned int val)
 {
@@ -217 +235 @@
 }
 
-static void regmap_format_8(void *buf, unsigned int val, unsigned int shift)
+/*static inline*/ void regmap_format_8(void *buf, unsigned int val, unsigned int shift)
 {
         u8 *b = buf;
@@ -224 +242 @@
 }
 
-static void regmap_format_16_be(void *buf, unsigned int val, unsigned int shift)
-{
-        __be16 *b = buf;
-
-        b[0] = cpu_to_be16(val << shift);
-}
-
-static void regmap_format_16_le(void *buf, unsigned int val, unsigned int shift)
-{
-        __le16 *b = buf;
-
-        b[0] = cpu_to_le16(val << shift);
-}
-
-static void regmap_format_16_native(void *buf, unsigned int val,
+/*static inline*/ void regmap_format_16_be(void *buf, unsigned int val, unsigned int shift)
+{
+        put_unaligned_be16(val << shift, buf);
+}
+
+/*static inline*/ void regmap_format_16_le(void *buf, unsigned int val, unsigned int shift)
+{
+        put_unaligned_le16(val << shift, buf);
+}
+
+/*static inline*/ void regmap_format_16_native(void *buf, unsigned int val,
                                     unsigned int shift)
 {
-        *(u16 *)buf = val << shift;
-}
-
-static void regmap_format_24(void *buf, unsigned int val, unsigned int shift)
+        u16 v = val << shift;
+
+        memcpy(buf, &v, sizeof(v));
+}
+
+/*static inline*/ void regmap_format_24(void *buf, unsigned int val, unsigned int shift)
 {
         u8 *b = buf;
@@ -255 +271 @@
 }
 
-static void regmap_format_32_be(void *buf, unsigned int val, unsigned int shift)
-{
-        __be32 *b = buf;
-
-        b[0] = cpu_to_be32(val << shift);
-}
-
-static void regmap_format_32_le(void *buf, unsigned int val, unsigned int shift)
-{
-        __le32 *b = buf;
-
-        b[0] = cpu_to_le32(val << shift);
-}
-
-static void regmap_format_32_native(void *buf, unsigned int val,
+/*static inline*/ void regmap_format_32_be(void *buf, unsigned int val, unsigned int shift)
+{
+        put_unaligned_be32(val << shift, buf);
+}
+
+/*static inline*/ void regmap_format_32_le(void *buf, unsigned int val, unsigned int shift)
+{
+        put_unaligned_le32(val << shift, buf);
+}
+
+/*static inline*/ void regmap_format_32_native(void *buf, unsigned int val,
                                     unsigned int shift)
 {
-        *(u32 *)buf = val << shift;
+        u32 v = val << shift;
+
+        memcpy(buf, &v, sizeof(v));
 }
 
 #ifdef CONFIG_64BIT
-static void regmap_format_64_be(void *buf, unsigned int val, unsigned int shift)
-{
-        __be64 *b = buf;
-
-        b[0] = cpu_to_be64((u64)val << shift);
-}
-
-static void regmap_format_64_le(void *buf, unsigned int val, unsigned int shift)
-{
-        __le64 *b = buf;
-
-        b[0] = cpu_to_le64((u64)val << shift);
-}
-
-static void regmap_format_64_native(void *buf, unsigned int val,
+/*static inline*/ void regmap_format_64_be(void *buf, unsigned int val, unsigned int shift)
+{
+        put_unaligned_be64((u64) val << shift, buf);
+}
+
+/*static inline*/ void regmap_format_64_le(void *buf, unsigned int val, unsigned int shift)
+{
+        put_unaligned_le64((u64) val << shift, buf);
+}
+
+/*static inline*/ void regmap_format_64_native(void *buf, unsigned int val,
                                     unsigned int shift)
 {
-        *(u64 *)buf = (u64)val << shift;
+        u64 v = (u64) val << shift;
+
+        memcpy(buf, &v, sizeof(v));
 }
 #endif
 
-static void regmap_parse_inplace_noop(void *buf)
-{
-}
-
-static unsigned int regmap_parse_8(const void *buf)
+/*static inline*/ void regmap_parse_inplace_noop(void *buf)
+{
+}
+
+/*static inline*/ unsigned int regmap_parse_8(const void *buf)
 {
         const u8 *b = buf;
@@ -308 +320 @@
 }
 
-static unsigned int regmap_parse_16_be(const void *buf)
-{
-        const __be16 *b = buf;
-
-        return be16_to_cpu(b[0]);
-}
-
-static unsigned int regmap_parse_16_le(const void *buf)
-{
-        const __le16 *b = buf;
-
-        return le16_to_cpu(b[0]);
-}
-
-static void regmap_parse_16_be_inplace(void *buf)
-{
-        __be16 *b = buf;
-
-        b[0] = be16_to_cpu(b[0]);
-}
-
-static void regmap_parse_16_le_inplace(void *buf)
-{
-        __le16 *b = buf;
-
-        b[0] = le16_to_cpu(b[0]);
-}
-
-static unsigned int regmap_parse_16_native(const void *buf)
-{
-        return *(u16 *)buf;
-}
-
-static unsigned int regmap_parse_24(const void *buf)
+/*static inline*/ unsigned int regmap_parse_16_be(const void *buf)
+{
+        return get_unaligned_be16(buf);
+}
+
+/*static inline*/ unsigned int regmap_parse_16_le(const void *buf)
+{
+        return get_unaligned_le16(buf);
+}
+
+/*static inline*/ void regmap_parse_16_be_inplace(void *buf)
+{
+        u16 v = get_unaligned_be16(buf);
+
+        memcpy(buf, &v, sizeof(v));
+}
+
+/*static inline*/ void regmap_parse_16_le_inplace(void *buf)
+{
+        u16 v = get_unaligned_le16(buf);
+
+        memcpy(buf, &v, sizeof(v));
+}
+
+/*static inline*/ unsigned int regmap_parse_16_native(const void *buf)
+{
+        u16 v;
+
+        memcpy(&v, buf, sizeof(v));
+        return v;
+}
+
+/*static inline*/ unsigned int regmap_parse_24(const void *buf)
 {
         const u8 *b = buf;
@@ -351 +362 @@
 }
 
-static unsigned int regmap_parse_32_be(const void *buf)
-{
-        const __be32 *b = buf;
-
-        return be32_to_cpu(b[0]);
-}
-
-static unsigned int regmap_parse_32_le(const void *buf)
-{
-        const __le32 *b = buf;
-
-        return le32_to_cpu(b[0]);
-}
-
-static void regmap_parse_32_be_inplace(void *buf)
-{
-        __be32 *b = buf;
-
-        b[0] = be32_to_cpu(b[0]);
-}
-
-static void regmap_parse_32_le_inplace(void *buf)
-{
-        __le32 *b = buf;
-
-        b[0] = le32_to_cpu(b[0]);
-}
-
-static unsigned int regmap_parse_32_native(const void *buf)
-{
-        return *(u32 *)buf;
+/*static inline*/ unsigned int regmap_parse_32_be(const void *buf)
+{
+        return get_unaligned_be32(buf);
+}
+
+/*static inline*/ unsigned int regmap_parse_32_le(const void *buf)
+{
+        return get_unaligned_le32(buf);
+}
+
+/*static inline*/ void regmap_parse_32_be_inplace(void *buf)
+{
+        u32 v = get_unaligned_be32(buf);
+
+        memcpy(buf, &v, sizeof(v));
+}
+
+/*static inline*/ void regmap_parse_32_le_inplace(void *buf)
+{
+        u32 v = get_unaligned_le32(buf);
+
+        memcpy(buf, &v, sizeof(v));
+}
+
+/*static inline*/ unsigned int regmap_parse_32_native(const void *buf)
+{
+        u32 v;
+
+        memcpy(&v, buf, sizeof(v));
+        return v;
 }
 
 #ifdef CONFIG_64BIT
-static unsigned int regmap_parse_64_be(const void *buf)
-{
-        const __be64 *b = buf;
-
-        return be64_to_cpu(b[0]);
-}
-
-static unsigned int regmap_parse_64_le(const void *buf)
-{
-        const __le64 *b = buf;
-
-        return le64_to_cpu(b[0]);
-}
-
-static void regmap_parse_64_be_inplace(void *buf)
-{
-        __be64 *b = buf;
-
-        b[0] = be64_to_cpu(b[0]);
-}
-
-static void regmap_parse_64_le_inplace(void *buf)
-{
-        __le64 *b = buf;
-
-        b[0] = le64_to_cpu(b[0]);
-}
-
-static unsigned int regmap_parse_64_native(const void *buf)
-{
-        return *(u64 *)buf;
+/*static inline*/ unsigned int regmap_parse_64_be(const void *buf)
+{
+        return get_unaligned_be64(buf);
+}
+
+/*static inline*/ unsigned int regmap_parse_64_le(const void *buf)
+{
+        return get_unaligned_le64(buf);
+}
+
+/*static inline*/ void regmap_parse_64_be_inplace(void *buf)
+{
+        u64 v =  get_unaligned_be64(buf);
+
+        memcpy(buf, &v, sizeof(v));
+}
+
+/*static inline*/ void regmap_parse_64_le_inplace(void *buf)
+{
+        u64 v = get_unaligned_le64(buf);
+
+        memcpy(buf, &v, sizeof(v));
+}
+
+/*static inline*/ unsigned int regmap_parse_64_native(const void *buf)
+{
+        u64 v;
+
+        memcpy(&v, buf, sizeof(v));
+        return v;
 }
 #endif
 
-static void regmap_lock_mutex(void *__map)
+/*static inline*/ void regmap_lock_hwlock(void *__map)
+{
+        struct regmap *map = __map;
+
+//      hwspin_lock_timeout(map->hwlock, UINT_MAX);
+}
+
+/*static inline*/ void regmap_lock_hwlock_irq(void *__map)
+{
+        struct regmap *map = __map;
+
+//      hwspin_lock_timeout_irq(map->hwlock, UINT_MAX);
+}
+
+/*static inline*/ void regmap_lock_hwlock_irqsave(void *__map)
+{
+        struct regmap *map = __map;
+
+//      hwspin_lock_timeout_irqsave(map->hwlock, UINT_MAX,
+//                                  &map->spinlock_flags);
+}
+
+/*static inline*/ void regmap_unlock_hwlock(void *__map)
+{
+        struct regmap *map = __map;
+
+//      hwspin_unlock(map->hwlock);
+}
+
+/*static inline*/ void regmap_unlock_hwlock_irq(void *__map)
+{
+        struct regmap *map = __map;
+
+//      hwspin_unlock_irq(map->hwlock);
+}
+
+/*static inline*/ void regmap_unlock_hwlock_irqrestore(void *__map)
+{
+        struct regmap *map = __map;
+
+//      hwspin_unlock_irqrestore(map->hwlock, &map->spinlock_flags);
+}
+
+/*static inline*/ void regmap_lock_unlock_none(void *__map)
+{
+
+}
+
+/*static inline*/ void regmap_lock_mutex(void *__map)
 {
         struct regmap *map = __map;
@@ -425 +482 @@
 }
 
-static void regmap_unlock_mutex(void *__map)
+/*static inline*/ void regmap_unlock_mutex(void *__map)
 {
         struct regmap *map = __map;
@@ -431 +488 @@
 }
 
-static void regmap_lock_spinlock(void *__map)
+/*static inline*/ void regmap_lock_spinlock(void *__map)
 __acquires(&map->spinlock)
 {
@@ -441 +498 @@
 }
 
-static void regmap_unlock_spinlock(void *__map)
+/*static inline*/ void regmap_unlock_spinlock(void *__map)
 __releases(&map->spinlock)
 {
@@ -448 +505 @@
 }
 
-static void dev_get_regmap_release(struct device *dev, void *res)
+/*static inline*/ void dev_get_regmap_release(struct device *dev, void *res)
 {
         /*
@@ -457 +514 @@
 }
 
-static bool _regmap_range_add(struct regmap *map,
+/*static inline*/ bool _regmap_range_add(struct regmap *map,
                               struct regmap_range_node *data)
 {
@@ -482 +539 @@
 }
 
-static struct regmap_range_node *_regmap_range_lookup(struct regmap *map,
+/*static inline*/ struct regmap_range_node *_regmap_range_lookup(struct regmap *map,
                                                       unsigned int reg)
 {
@@ -502 +559 @@
 }
 
-static void regmap_range_exit(struct regmap *map)
+/*static inline*/ void regmap_range_exit(struct regmap *map)
 {
         struct rb_node *next;
@@ -540 +597 @@
 EXPORT_SYMBOL_GPL(regmap_attach_dev);
 
-static enum regmap_endian regmap_get_reg_endian(const struct regmap_bus *bus,
+/*static inline*/ enum regmap_endian regmap_get_reg_endian(const struct regmap_bus *bus,
                                         const struct regmap_config *config)
 {
@@ -633 +690 @@
         }
 
-        if (config->lock && config->unlock) {
+        if (config->name) {
+#ifndef TARGET_OS2
+                map->name = kstrdup_const(config->name, GFP_KERNEL);
+#else
+                map->name = config->name;
+#endif
+                if (!map->name) {
+                        ret = -ENOMEM;
+                        goto err_map;
+                }
+        }
+
+        if (config->disable_locking) {
+                map->lock = map->unlock = regmap_lock_unlock_none;
+                regmap_debugfs_disable(map);
+        } else if (config->lock && config->unlock) {
                 map->lock = config->lock;
                 map->unlock = config->unlock;
                 map->lock_arg = config->lock_arg;
+        } else if (config->use_hwlock) {
+//              map->hwlock = hwspin_lock_request_specific(config->hwlock_id);
+//              if (!map->hwlock) {
+//                      ret = -ENXIO;
+//                      goto err_name;
+//              }
+
+                switch (config->hwlock_mode) {
+                case HWLOCK_IRQSTATE:
+                        map->lock = regmap_lock_hwlock_irqsave;
+                        map->unlock = regmap_unlock_hwlock_irqrestore;
+                        break;
+                case HWLOCK_IRQ:
+                        map->lock = regmap_lock_hwlock_irq;
+                        map->unlock = regmap_unlock_hwlock_irq;
+                        break;
+                default:
+                        map->lock = regmap_lock_hwlock;
+                        map->unlock = regmap_unlock_hwlock;
+                        break;
+                }
+
+                map->lock_arg = map;
         } else {
                 if ((bus && bus->fast_io) ||
@@ -693 +788 @@
         map->volatile_table = config->volatile_table;
         map->precious_table = config->precious_table;
+        map->rd_noinc_table = config->rd_noinc_table;
         map->writeable_reg = config->writeable_reg;
         map->readable_reg = config->readable_reg;
         map->volatile_reg = config->volatile_reg;
         map->precious_reg = config->precious_reg;
+        map->readable_noinc_reg = config->readable_noinc_reg;
         map->cache_type = config->cache_type;
-        map->name = config->name;
 
         spin_lock_init(&map->async_lock);
@@ -705 +801 @@
         init_waitqueue_head(&map->async_waitq);
 
-        if (config->read_flag_mask || config->write_flag_mask) {
+        if (config->read_flag_mask ||
+            config->write_flag_mask ||
+            config->zero_flag_mask) {
                 map->read_flag_mask = config->read_flag_mask;
                 map->write_flag_mask = config->write_flag_mask;
@@ -739 +837 @@
                         break;
                 default:
-                        goto err_map;
+                        goto err_hwlock;
                 }
                 break;
@@ -749 +847 @@
                         break;
                 default:
-                        goto err_map;
+                        goto err_hwlock;
                 }
                 break;
@@ -759 +857 @@
                         break;
                 default:
-                        goto err_map;
+                        goto err_hwlock;
                 }
                 break;
@@ -769 +867 @@
                         break;
                 default:
-                        goto err_map;
+                        goto err_hwlock;
                 }
                 break;
@@ -789 +887 @@
                         break;
                 default:
-                        goto err_map;
+                        goto err_hwlock;
                 }
                 break;
@@ -795 +893 @@
         case 24:
                 if (reg_endian != REGMAP_ENDIAN_BIG)
-                        goto err_map;
+                        goto err_hwlock;
                 map->format.format_reg = regmap_format_24;
                 break;
@@ -811 +909 @@
                         break;
                 default:
-                        goto err_map;
+                        goto err_hwlock;
                 }
                 break;
@@ -828 +926 @@
                         break;
                 default:
-                        goto err_map;
+                        goto err_hwlock;
                 }
                 break;
@@ -834 +932 @@
 
         default:
-                goto err_map;
+                goto err_hwlock;
         }
 
@@ -863 +961 @@
                         break;
                 default:
-                        goto err_map;
+                        goto err_hwlock;
                 }
                 break;
         case 24:
                 if (val_endian != REGMAP_ENDIAN_BIG)
-                        goto err_map;
+                        goto err_hwlock;
                 map->format.format_val = regmap_format_24;
                 map->format.parse_val = regmap_parse_24;
@@ -889 +987 @@
                         break;
                 default:
-                        goto err_map;
+                        goto err_hwlock;
                 }
                 break;
@@ -910 +1008 @@
                         break;
                 default:
-                        goto err_map;
+                        goto err_hwlock;
                 }
                 break;
@@ -919 +1017 @@
                 if ((reg_endian != REGMAP_ENDIAN_BIG) ||
                     (val_endian != REGMAP_ENDIAN_BIG))
-                        goto err_map;
+                        goto err_hwlock;
                 map->use_single_write = true;
         }
@@ -925 +1023 @@
         if (!map->format.format_write &&
             !(map->format.format_reg && map->format.format_val))
-                goto err_map;
+                goto err_hwlock;
 
         map->work_buf = kzalloc(map->format.buf_size, GFP_KERNEL);
         if (map->work_buf == NULL) {
                 ret = -ENOMEM;
-                goto err_map;
+                goto err_hwlock;
         }
 
@@ -1047 +1145 @@
         if (dev) {
                 ret = regmap_attach_dev(dev, map, config);
-
                 if (ret != 0)
                         goto err_regcache;
+        } else {
+                regmap_debugfs_init(map, config->name);
         }
 
@@ -1059 +1158 @@
         regmap_range_exit(map);
         kfree(map->work_buf);
+err_hwlock:
+//      if (map->hwlock)
+//              hwspin_lock_free(map->hwlock);
+err_name:
+//      kfree_const(map->name);
 err_map:
         kfree(map);
@@ -1067 +1171 @@
 
 #ifndef TARGET_OS2
-static void devm_regmap_release(struct device *dev, void *res)
+/*static inline*/ void devm_regmap_release(struct device *dev, void *res)
 {
         regmap_exit(*(struct regmap **)res);
@@ -1099 +1203 @@
 #endif
 
-static void regmap_field_init(struct regmap_field *rm_field,
+/*static inline*/ void regmap_field_init(struct regmap_field *rm_field,
         struct regmap *regmap, struct reg_field reg_field)
 {
@@ -1216 +1320 @@
         map->volatile_reg = config->volatile_reg;
         map->precious_reg = config->precious_reg;
+        map->readable_noinc_reg = config->readable_noinc_reg;
         map->cache_type = config->cache_type;
 
@@ -1250 +1355 @@
                 kfree(async);
         }
+//      if (map->hwlock)
+//              hwspin_lock_free(map->hwlock);
+//      kfree_const(map->name);
+        kfree(map->patch);
         kfree(map);
 }
 EXPORT_SYMBOL_GPL(regmap_exit);
 
-static int dev_get_regmap_match(struct device *dev, void *res, void *data)
+/*static inline*/ int dev_get_regmap_match(struct device *dev, void *res, void *data)
 {
         struct regmap **r = res;
@@ -1305 +1414 @@
 EXPORT_SYMBOL_GPL(regmap_get_device);
 
-static int _regmap_select_page(struct regmap *map, unsigned int *reg,
+/*static inline*/ int _regmap_select_page(struct regmap *map, unsigned int *reg,
                                struct regmap_range_node *range,
                                unsigned int val_num)
@@ -1353 +1462 @@
 }
 
-static void regmap_set_work_buf_flag_mask(struct regmap *map, int max_bytes,
+/*static inline*/ void regmap_set_work_buf_flag_mask(struct regmap *map, int max_bytes,
                                           unsigned long mask)
 {
@@ -1368 +1477 @@
 }
 
-int _regmap_raw_write(struct regmap *map, unsigned int reg,
-                      const void *val, size_t val_len)
+/*static inline*/ int _regmap_raw_write_impl(struct regmap *map, unsigned int reg,
+                                  const void *val, size_t val_len)
 {
         struct regmap_range_node *range;
@@ -1420 +1529 @@
                         dev_dbg(map->dev, "Writing window %d/%zu\n",
                                 win_residue, val_len / map->format.val_bytes);
-                        ret = _regmap_raw_write(map, reg, val, win_residue *
-                                                map->format.val_bytes);
+                        ret = _regmap_raw_write_impl(map, reg, val,
+                                                     win_residue *
+                                                     map->format.val_bytes);
                         if (ret != 0)
                                 return ret;
@@ -1588 +1698 @@
 EXPORT_SYMBOL_GPL(regmap_get_raw_write_max);
 
-static int _regmap_bus_formatted_write(void *context, unsigned int reg,
+/*static inline*/ int _regmap_bus_formatted_write(void *context, unsigned int reg,
                                        unsigned int val)
 {
@@ -1612 +1722 @@
 }
 
-static int _regmap_bus_reg_write(void *context, unsigned int reg,
+/*static inline*/ int _regmap_bus_reg_write(void *context, unsigned int reg,
                                  unsigned int val)
 {
@@ -1620 +1730 @@
 }
 
-static int _regmap_bus_raw_write(void *context, unsigned int reg,
+/*static inline*/ int _regmap_bus_raw_write(void *context, unsigned int reg,
                                  unsigned int val)
 {
@@ -1629 +1739 @@
         map->format.format_val(map->work_buf + map->format.reg_bytes
                                + map->format.pad_bytes, val, 0);
-        return _regmap_raw_write(map, reg,
-                                 map->work_buf +
-                                 map->format.reg_bytes +
-                                 map->format.pad_bytes,
-                                 map->format.val_bytes);
-}
-
-static inline void *_regmap_map_get_context(struct regmap *map)
+        return _regmap_raw_write_impl(map, reg,
+                                      map->work_buf +
+                                      map->format.reg_bytes +
+                                      map->format.pad_bytes,
+                                      map->format.val_bytes);
+}
+
+/*static inline*/ inline void *_regmap_map_get_context(struct regmap *map)
 {
         return (map->bus) ? map : map->bus_context;
@@ -1728 +1838 @@
 EXPORT_SYMBOL_GPL(regmap_write_async);
 
+int _regmap_raw_write(struct regmap *map, unsigned int reg,
+                      const void *val, size_t val_len)
+{
+        size_t val_bytes = map->format.val_bytes;
+        size_t val_count = val_len / val_bytes;
+        size_t chunk_count, chunk_bytes;
+        size_t chunk_regs = val_count;
+        int ret, i;
+
+        if (!val_count)
+                return -EINVAL;
+
+        if (map->use_single_write)
+                chunk_regs = 1;
+        else if (map->max_raw_write && val_len > map->max_raw_write)
+                chunk_regs = map->max_raw_write / val_bytes;
+
+        chunk_count = val_count / chunk_regs;
+        chunk_bytes = chunk_regs * val_bytes;
+
+        /* Write as many bytes as possible with chunk_size */
+        for (i = 0; i < chunk_count; i++) {
+                ret = _regmap_raw_write_impl(map, reg, val, chunk_bytes);
+                if (ret)
+                        return ret;
+
+                reg += regmap_get_offset(map, chunk_regs);
+                val += chunk_bytes;
+                val_len -= chunk_bytes;
+        }
+
+        /* Write remaining bytes */
+        if (val_len)
+                ret = _regmap_raw_write_impl(map, reg, val, val_len);
+
+        return ret;
+}
+
 /**
  * regmap_raw_write() - Write raw values to one or more registers
@@ -1753 +1901 @@
         if (val_len % map->format.val_bytes)
                 return -EINVAL;
-        if (map->max_raw_write && map->max_raw_write < val_len)
-                return -E2BIG;
 
         map->lock(map->lock_arg);
@@ -1845 +1991 @@
         int ret = 0, i;
         size_t val_bytes = map->format.val_bytes;
-        size_t total_size = val_bytes * val_count;
 
         if (!IS_ALIGNED(reg, map->reg_stride))
@@ -1851 +1996 @@
 
         /*
-         * Some devices don't support bulk write, for
-         * them we have a series of single write operations in the first two if
-         * blocks.
-         *
-         * The first if block is used for memory mapped io. It does not allow
-         * val_bytes of 3 for example.
-         * The second one is for busses that do not provide raw I/O.
-         * The third one is used for busses which do not have these limitations
-         * and can write arbitrary value lengths.
+         * Some devices don't support bulk write, for them we have a series of
+         * single write operations.
          */
-        if (!map->bus) {
+        if (!map->bus || !map->format.parse_inplace) {
                 map->lock(map->lock_arg);
                 for (i = 0; i < val_count; i++) {
@@ -1894 +2032 @@
 out:
                 map->unlock(map->lock_arg);
-        } else if (map->bus && !map->format.parse_inplace) {
-                const u8 *u8 = val;
-                const u16 *u16 = val;
-                const u32 *u32 = val;
-                unsigned int ival;
-
-                for (i = 0; i < val_count; i++) {
-                        switch (map->format.val_bytes) {
-                        case 4:
-                                ival = u32[i];
-                                break;
-                        case 2:
-                                ival = u16[i];
-                                break;
-                        case 1:
-                                ival = u8[i];
-                                break;
-                        default:
-                                return -EINVAL;
-                        }
-
-                        ret = regmap_write(map, reg + (i * map->reg_stride),
-                                           ival);
-                        if (ret)
-                                return ret;
-                }
-        } else if (map->use_single_write ||
-                   (map->max_raw_write && map->max_raw_write < total_size)) {
-                int chunk_stride = map->reg_stride;
-                size_t chunk_size = val_bytes;
-                size_t chunk_count = val_count;
-
-                if (!map->use_single_write) {
-                        chunk_size = map->max_raw_write;
-                        if (chunk_size % val_bytes)
-                                chunk_size -= chunk_size % val_bytes;
-                        chunk_count = total_size / chunk_size;
-                        chunk_stride *= chunk_size / val_bytes;
-                }
-
-                map->lock(map->lock_arg);
-                /* Write as many bytes as possible with chunk_size */
-                for (i = 0; i < chunk_count; i++) {
-                        ret = _regmap_raw_write(map,
-                                                reg + (i * chunk_stride),
-                                                val + (i * chunk_size),
-                                                chunk_size);
-                        if (ret)
-                                break;
-                }
-
-                /* Write remaining bytes */
-                if (!ret && chunk_size * i < total_size) {
-                        ret = _regmap_raw_write(map, reg + (i * chunk_stride),
-                                                val + (i * chunk_size),
-                                                total_size - i * chunk_size);
-                }
-                map->unlock(map->lock_arg);
         } else {
                 void *wval;
 
-                if (!val_count)
-                        return -EINVAL;
-
                 wval = kmemdup(val, val_count * val_bytes, map->alloc_flags);
-                if (!wval) {
-                        dev_err(map->dev, "Error in memory allocation\n");
+                if (!wval)
                         return -ENOMEM;
-                }
+
                 for (i = 0; i < val_count * val_bytes; i += val_bytes)
                         map->format.parse_inplace(wval + i);
 
-                map->lock(map->lock_arg);
-                ret = _regmap_raw_write(map, reg, wval, val_bytes * val_count);
-                map->unlock(map->lock_arg);
+                ret = regmap_raw_write(map, reg, wval, val_bytes * val_count);
 
                 kfree(wval);
@@ -1983 +2057 @@
  * relative. The page register has been written if that was necessary.
  */
-static int _regmap_raw_multi_reg_write(struct regmap *map,
+/*static inline*/ int _regmap_raw_multi_reg_write(struct regmap *map,
                                        const struct reg_sequence *regs,
                                        size_t num_regs)
@@ -2029 +2103 @@
 }
 
-static unsigned int _regmap_register_page(struct regmap *map,
+/*static inline*/ unsigned int _regmap_register_page(struct regmap *map,
                                           unsigned int reg,
                                           struct regmap_range_node *range)
@@ -2038 +2112 @@
 }
 
-static int _regmap_range_multi_paged_reg_write(struct regmap *map,
+/*static inline*/ int _regmap_range_multi_paged_reg_write(struct regmap *map,
                                                struct reg_sequence *regs,
                                                size_t num_regs)
@@ -2115 +2189 @@
 }
 
-static int _regmap_multi_reg_write(struct regmap *map,
+/*static inline*/ int _regmap_multi_reg_write(struct regmap *map,
                                    const struct reg_sequence *regs,
                                    size_t num_regs)
@@ -2310 +2384 @@
 EXPORT_SYMBOL_GPL(regmap_raw_write_async);
 
-static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
-                            unsigned int val_len)
+/*static inline*/ int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
+                            unsigned int val_len, bool noinc)
 {
         struct regmap_range_node *range;
@@ -2324 +2398 @@
         if (range) {
                 ret = _regmap_select_page(map, &reg, range,
-                                          val_len / map->format.val_bytes);
+                                          noinc ? 1 : val_len / map->format.val_bytes);
                 if (ret != 0)
                         return ret;
@@ -2340 +2414 @@
 }
 
-static int _regmap_bus_reg_read(void *context, unsigned int reg,
+/*static inline*/ int _regmap_bus_reg_read(void *context, unsigned int reg,
                                 unsigned int *val)
 {
@@ -2348 +2422 @@
 }
 
-static int _regmap_bus_read(void *context, unsigned int reg,
+/*static inline*/ int _regmap_bus_read(void *context, unsigned int reg,
                             unsigned int *val)
 {
         int ret;
         struct regmap *map = context;
+        void *work_val = map->work_buf + map->format.reg_bytes +
+                map->format.pad_bytes;
 
         if (!map->format.parse_val)
                 return -EINVAL;
 
-        ret = _regmap_raw_read(map, reg, map->work_buf, map->format.val_bytes);
+        ret = _regmap_raw_read(map, reg, work_val, map->format.val_bytes, false);
         if (ret == 0)
-                *val = map->format.parse_val(map->work_buf);
+                *val = map->format.parse_val(work_val);
 
         return ret;
 }
 
-static int _regmap_read(struct regmap *map, unsigned int reg,
+/*static inline*/ int _regmap_read(struct regmap *map, unsigned int reg,
                         unsigned int *val)
 {
@@ -2455 +2531 @@
         if (regmap_volatile_range(map, reg, val_count) || map->cache_bypass ||
             map->cache_type == REGCACHE_NONE) {
+                size_t chunk_count, chunk_bytes;
+                size_t chunk_regs = val_count;
+
                 if (!map->bus->read) {
                         ret = -ENOTSUPP;
                         goto out;
                 }
-                if (map->max_raw_read && map->max_raw_read < val_len) {
-                        ret = -E2BIG;
-                        goto out;
-                }
-
-                /* Physical block read if there's no cache involved */
-                ret = _regmap_raw_read(map, reg, val, val_len);
-
+
+                if (map->use_single_read)
+                        chunk_regs = 1;
+                else if (map->max_raw_read && val_len > map->max_raw_read)
+                        chunk_regs = map->max_raw_read / val_bytes;
+
+                chunk_count = val_count / chunk_regs;
+                chunk_bytes = chunk_regs * val_bytes;
+
+                /* Read bytes that fit into whole chunks */
+                for (i = 0; i < chunk_count; i++) {
+                        ret = _regmap_raw_read(map, reg, val, chunk_bytes, false);
+                        if (ret != 0)
+                                goto out;
+
+                        reg += regmap_get_offset(map, chunk_regs);
+                        val += chunk_bytes;
+                        val_len -= chunk_bytes;
+                }
+
+                /* Read remaining bytes */
+                if (val_len) {
+                        ret = _regmap_raw_read(map, reg, val, val_len, false);
+                        if (ret != 0)
+                                goto out;
+                }
         } else {
                 /* Otherwise go word by word for the cache; should be low
@@ -2489 +2586 @@
 
 /**
- * regmap_field_read() - Read a value to a single register field
+ * regmap_noinc_read(): Read data from a register without incrementing the
+ *                      register number
+ *
+ * @map: Register map to read from
+ * @reg: Register to read from
+ * @val: Pointer to data buffer
+ * @val_len: Length of output buffer in bytes.
+ *
+ * The regmap API usually assumes that bulk bus read operations will read a
+ * range of registers. Some devices have certain registers for which a read
+ * operation read will read from an internal FIFO.
+ *
+ * The target register must be volatile but registers after it can be
+ * completely unrelated cacheable registers.
+ *
+ * This will attempt multiple reads as required to read val_len bytes.
+ *
+ * A value of zero will be returned on success, a negative errno will be
+ * returned in error cases.
+ */
+int regmap_noinc_read(struct regmap *map, unsigned int reg,
+                      void *val, size_t val_len)
+{
+        size_t read_len;
+        int ret;
+
+        if (!map->bus)
+                return -EINVAL;
+        if (!map->bus->read)
+                return -ENOTSUPP;
+        if (val_len % map->format.val_bytes)
+                return -EINVAL;
+        if (!IS_ALIGNED(reg, map->reg_stride))
+                return -EINVAL;
+        if (val_len == 0)
+                return -EINVAL;
+
+        map->lock(map->lock_arg);
+
+        if (!regmap_volatile(map, reg) || !regmap_readable_noinc(map, reg)) {
+                ret = -EINVAL;
+                goto out_unlock;
+        }
+
+        while (val_len) {
+                if (map->max_raw_read && map->max_raw_read < val_len)
+                        read_len = map->max_raw_read;
+                else
+                        read_len = val_len;
+                ret = _regmap_raw_read(map, reg, val, read_len, true);
+                if (ret)
+                        goto out_unlock;
+                val = ((u8 *)val) + read_len;
+                val_len -= read_len;
+        }
+
+out_unlock:
+        map->unlock(map->lock_arg);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(regmap_noinc_read);
+
+/**
+ * regmap_field_read(): Read a value to a single register field
  *
  * @field: Register field to read from
@@ -2566 +2726 @@
         if (!IS_ALIGNED(reg, map->reg_stride))
                 return -EINVAL;
+        if (val_count == 0)
+                return -EINVAL;
 
         if (map->bus && map->format.parse_inplace && (vol || map->cache_type == REGCACHE_NONE)) {
-                /*
-                 * Some devices does not support bulk read, for
-                 * them we have a series of single read operations.
-                 */
-                size_t total_size = val_bytes * val_count;
-
-                if (!map->use_single_read &&
-                    (!map->max_raw_read || map->max_raw_read > total_size)) {
-                        ret = regmap_raw_read(map, reg, val,
-                                              val_bytes * val_count);
-                        if (ret != 0)
-                                return ret;
-                } else {
-                        /*
-                         * Some devices do not support bulk read or do not
-                         * support large bulk reads, for them we have a series
-                         * of read operations.
-                         */
-                        int chunk_stride = map->reg_stride;
-                        size_t chunk_size = val_bytes;
-                        size_t chunk_count = val_count;
-
-                        if (!map->use_single_read) {
-                                chunk_size = map->max_raw_read;
-                                if (chunk_size % val_bytes)
-                                        chunk_size -= chunk_size % val_bytes;
-                                chunk_count = total_size / chunk_size;
-                                chunk_stride *= chunk_size / val_bytes;
-                        }
-
-                        /* Read bytes that fit into a multiple of chunk_size */
-                        for (i = 0; i < chunk_count; i++) {
-                                ret = regmap_raw_read(map,
-                                                      reg + (i * chunk_stride),
-                                                      val + (i * chunk_size),
-                                                      chunk_size);
-                                if (ret != 0)
-                                        return ret;
-                        }
-
-                        /* Read remaining bytes */
-                        if (chunk_size * i < total_size) {
-                                ret = regmap_raw_read(map,
-                                                      reg + (i * chunk_stride),
-                                                      val + (i * chunk_size),
-                                                      total_size - i * chunk_size);
-                                if (ret != 0)
-                                        return ret;
-                        }
-                }
+                ret = regmap_raw_read(map, reg, val, val_bytes * val_count);
+                if (ret != 0)
+                        return ret;
 
                 for (i = 0; i < val_count * val_bytes; i += val_bytes)
                         map->format.parse_inplace(val + i);
         } else {
+#ifdef CONFIG_64BIT
+                u64 *u64 = val;
+#endif
+                u32 *u32 = val;
+                u16 *u16 = val;
+                u8 *u8 = val;
+
+                map->lock(map->lock_arg);
+
                 for (i = 0; i < val_count; i++) {
                         unsigned int ival;
-                        ret = regmap_read(map, reg + regmap_get_offset(map, i),
-                                          &ival);
+
+                        ret = _regmap_read(map, reg + regmap_get_offset(map, i),
+                                           &ival);
                         if (ret != 0)
-                                return ret;
-
-                        if (map->format.format_val) {
-                                map->format.format_val(val + (i * val_bytes), ival, 0);
-                        } else {
-                                /* Devices providing read and write
-                                 * operations can use the bulk I/O
-                                 * functions if they define a val_bytes,
-                                 * we assume that the values are native
-                                 * endian.
-                                 */
+                                goto out;
+
+                        switch (map->format.val_bytes) {
 #ifdef CONFIG_64BIT
-                                u64 *u64 = val;
+                        case 8:
+                                u64[i] = ival;
+                                break;
 #endif
-                                u32 *u32 = val;
-                                u16 *u16 = val;
-                                u8 *u8 = val;
-
-                                switch (map->format.val_bytes) {
-#ifdef CONFIG_64BIT
-                                case 8:
-                                        u64[i] = ival;
-                                        break;
-#endif
-                                case 4:
-                                        u32[i] = ival;
-                                        break;
-                                case 2:
-                                        u16[i] = ival;
-                                        break;
-                                case 1:
-                                        u8[i] = ival;
-                                        break;
-                                default:
-                                        return -EINVAL;
-                                }
+                        case 4:
+                                u32[i] = ival;
+                                break;
+                        case 2:
+                                u16[i] = ival;
+                                break;
+                        case 1:
+                                u8[i] = ival;
+                                break;
+                        default:
+                                ret = -EINVAL;
+                                goto out;
                         }
                 }
-        }
-
-        return 0;
+
+out:
+                map->unlock(map->lock_arg);
+        }
+
+        return ret;
 }
 EXPORT_SYMBOL_GPL(regmap_bulk_read);
 
-static int _regmap_update_bits(struct regmap *map, unsigned int reg,
+/*static inline*/ int _regmap_update_bits(struct regmap *map, unsigned int reg,
                                unsigned int mask, unsigned int val,
                                bool *change, bool force_write)
@@ -2764 +2876 @@
 EXPORT_SYMBOL_GPL(regmap_async_complete_cb);
 
-#ifndef TARGET_OS2
-static int regmap_async_is_done(struct regmap *map)
+/*static inline*/ int regmap_async_is_done(struct regmap *map)
 {
         unsigned long flags;
@@ -2776 +2887 @@
         return ret;
 }
-#endif
 
 /**
@@ -2795 +2905 @@
                 return 0;
 
-//FIXME wait_event(map->async_waitq, regmap_async_is_done(map));
+//      wait_event(map->async_waitq, regmap_async_is_done(map));
 
         spin_lock_irqsave(&map->async_lock, flags);
@@ -2835 +2945 @@
                 return 0;
 #endif
-
         p = krealloc(map->patch,
                      sizeof(struct reg_sequence) * (map->patch_regs + num_regs),
@@ -2924 +3033 @@
 EXPORT_SYMBOL_GPL(regmap_parse_val);
 
-static int __init regmap_initcall(void)
+/*static inline*/ int __init regmap_initcall(void)
 {
         regmap_debugfs_initcall();

GPL/branches/uniaud32-next/lib32/waitqueue.c

@@ -109 +109 @@
         spin_unlock_irqrestore(&x->wait.lock, flags);
 }
+/**
+ * complete_all: - signals all threads waiting on this completion
+ * @x:  holds the state of this particular completion
+ *
+ * This will wake up all threads waiting on this particular completion event.
+ *
+ * If this function wakes up a task, it executes a full memory barrier before
+ * accessing the task state.
+ *
+ * Since complete_all() sets the completion of @x permanently to done
+ * to allow multiple waiters to finish, a call to reinit_completion()
+ * must be used on @x if @x is to be used again. The code must make
+ * sure that all waiters have woken and finished before reinitializing
+ * @x. Also note that the function completion_done() can not be used
+ * to know if there are still waiters after complete_all() has been called.
+ */
+void complete_all(struct completion *x)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&x->wait.lock, flags);
+        __wake_up_locked(&x->wait, TASK_NORMAL, 1);
+        spin_unlock_irqrestore(&x->wait.lock, flags);
+}
 //******************************************************************************
 //******************************************************************************
@@ -115 +139 @@
     dprintf3(("WARNING: __wake_up_locked STUB"));
 }
+//******************************************************************************
+//******************************************************************************
+/**
+ * wait_for_completion: - waits for completion of a task
+ * @x:  holds the state of this particular completion
+ *
+ * This waits to be signaled for completion of a specific task. It is NOT
+ * interruptible and there is no timeout.
+ *
+ * See also similar routines (i.e. wait_for_completion_timeout()) with timeout
+ * and interrupt capability. Also see complete().
+ */
+void wait_for_completion(struct completion *x)
+{
+    dprintf3(("WARNING: wait_for_completion STUB"));
+}
+
+
+/**
+ * wait_for_completion_timeout: - waits for completion of a task (w/timeout)
+ * @x:  holds the state of this particular completion
+ * @timeout:  timeout value in jiffies
+ *
+ * This waits for either a completion of a specific task to be signaled or for a
+ * specified timeout to expire. The timeout is in jiffies. It is not
+ * interruptible.
+ *
+ * Return: 0 if timed out, and positive (at least 1, or number of jiffies left
+ * till timeout) if completed.
+ */
+unsigned long wait_for_completion_timeout(struct completion *x, unsigned long timeout)
+{
+    dprintf3(("WARNING: wait_for_completion_timeout STUB"));
+    return 1;
+}