Linaro-mm-sig

linaro-mm-sig@lists.linaro.org

16 participants
7969 discussions

Re: [PATCH v2] dma-buf/udmabuf: Disable the size limit by default

by Kasireddy, Vivek

> Subject: Re: [PATCH v2] dma-buf/udmabuf: Disable the size limit by > default > > On 28.07.26 22:20, Kasireddy, Vivek wrote: > > Hi Robert, > > > >> Subject: [PATCH v2] dma-buf/udmabuf: Disable the size limit by > default > >> > >> As udmabuf increasingly enjoys popularity - being used in projects > like > >> libcamera, Gstreamer, Mesa, KWin and Weston - users more > frequently > >> encounter cases where the current default size limit of 64MB is too > low. > >> Examples include allocating video buffers at a 8K resolution - and > even > >> 4K > >> is affected when using non-subsampled video formats and high bit > >> depths. > >> > >> In its current form the size limit for individual buffers does not seem > to > >> provide any additional level of protection - such as limiting the > amount > >> of > >> memory a process can pin - as the later can just allocate multiple > >> buffers. > >> If additional guardrails are desired, they would likely require some > kind > >> accounting not limited to individual buffers. > >> > >> Therefor let's disable the size limit by default by setting it to the > >> maximal possible value, INT_MAX. > >> > >> Signed-off-by: Robert Mader <robert.mader(a)collabora.com> > >> > >> --- > >> > >> Changes in V2: > >> - Use INT_MAX instead of 0 in order to not change behavior > otherwise. > >> > >> See > >> https://lore.kernel.org/dri-devel/20260711144814.8205-1- > >> robert.mader(a)collabora.com/ > >> for a previous attempt to make the value configurable via kconfig - > and > >> in particular > >> https://lore.kernel.org/dri-devel/6764ca6f-b4d8-4baa-9d27- > >> 2ca867ac2d41(a)amd.com/ > >> for the suggestion and discussion to remove the default limit. > >> --- > >> drivers/dma-buf/udmabuf.c | 4 ++-- > >> 1 file changed, 2 insertions(+), 2 deletions(-) > >> > >> diff --git a/drivers/dma-buf/udmabuf.c b/drivers/dma-buf/udmabuf.c > >> index bced421c0d65..639e93704924 100644 > >> --- a/drivers/dma-buf/udmabuf.c > >> +++ b/drivers/dma-buf/udmabuf.c > >> @@ -20,9 +20,9 @@ static int list_limit = 1024; > >> module_param(list_limit, int, 0644); > >> MODULE_PARM_DESC(list_limit, "udmabuf_create_list->count limit. > >> Default is 1024."); > >> > >> -static int size_limit_mb = 64; > >> +static int size_limit_mb = INT_MAX; > >> module_param(size_limit_mb, int, 0644); > >> -MODULE_PARM_DESC(size_limit_mb, "Max size of a dmabuf, in > >> megabytes. Default is 64."); > >> +MODULE_PARM_DESC(size_limit_mb, "Max size of a dmabuf, in > >> megabytes. Default is INT_MAX."); > > Acked-by: Vivek Kasireddy <vivek.kasireddy(a)intel.com> > > > > If there are no further concerns/questions from anyone, I'll push it to > > drm-misc-next soon. > > FTR., we already have a first duplicate :P > > https://lore.kernel.org/dri-devel/20260803144120.11524-1- > xaver.hugl(a)kde.org/ Yeah, looks like this change seems to be desirable in many use-cases. I have pushed it to drm-misc-next today. Thanks, Vivek > > > > > Thanks, > > Vivek > >> struct udmabuf { > >> pgoff_t pagecount; > >> -- > >> 2.55.0 > > -- > Robert Mader > Consultant Software Developer > > Collabora Ltd. > Platinum Building, St John's Innovation Park, Cambridge CB4 0DS, UK > Registered in England & Wales, no. 5513718

11 minutes

Among Us - Experience Fun Social Deduction and Team Strategy

by grannygame.org＠gmail.com

Get ready for an exciting multiplayer experience with Among Us, where teamwork, strategy, and deception create unforgettable matches with friends and other players. Among Us Online brings players into a world of teamwork and mystery, where Crewmates complete tasks while trying to identify the hidden Impostors before it is too late. Discover what makes Among Us special: - Fun social deduction gameplay that challenges your observation and communication skills. - Exciting matches where every decision can change the outcome. - Team-based tasks that encourage cooperation and smart strategies. - Different roles and situations that keep every round fresh and unpredictable. - A simple gameplay style that is easy to enjoy for both new and experienced players. Experience the thrill of solving mysteries, working with your team, and finding the Impostor in every match. Learn more about Among Us here: https://amongusonline.io Join the adventure today and enjoy a fun multiplayer game filled with strategy, teamwork, and unexpected moments!

4 hours, 3 minutes

Drift Hunters: Your Fast Pass to the Ultimate Drifting Fantasy!

by physical.wolf.nais＠hidepost.net

Hey there, fellow speed demons and virtual asphalt aficionados! Ever felt that primal urge to kick out the tail of a finely-tuned machine, leaving a smoky ballet of rubber and exhilaration in your wake? That craving for the perfect slide, the harmonious symphony of engine roar and squealing tyres, the pure, unadulterated joy of mastering a corner sideways? If you're nodding enthusiastically enough to rattle your screen, then buckle up, because today we're diving headfirst into a game that promises to deliver all that and a whole lot more: Drift Hunters! Imagine a game that understands your passion for drifting, a game that doesn't just tolerate sideways movement but actively encourages and celebrates it. That's Drift Hunters in a nutshell. It's a digital playground built for those who find beauty in controlled chaos, for the artists who paint the track with tyre marks. So, whether you're a seasoned drift king or a curious newcomer eager to learn the ropes, get ready to discover your next obsession. Visit: https://drifthunters3d.io/ 1. What in the World is Drift Hunters? Drift Hunters is a high-octane, browser-based 3D drifting game that throws you into the driver's seat of an impressive roster of customizable vehicles, all designed for one purpose: to drift. Developed by the talented team at Ilya Kaminetsky, this gem first hit the virtual streets, captivating players with its intuitive mechanics and satisfying gameplay. While an exact initial release date for the very first iteration can be a little elusive given its evolution across various platforms, its presence has been felt and celebrated for several years now, consistently delivering that pure drifting rush. At its core, Drift Hunters is all about skill, precision, and a healthy dose of showmanship. It's not about being the fastest around the track in a conventional race; it's about chaining together epic drifts, earning points, and ultimately, mastering the art of controlled mayhem. Think of it as a dance, where your car is your partner, and the track is your stage. The more gracefully and powerfully you slide, the higher your score, and the bigger your bragging rights. 2. How to Play Drift Hunters The basic controls are refreshingly straightforward, designed to get you drifting in no time: Acceleration: Typically the W key or the Up arrow key. This is your lifeblood, your power source. Brake/Reverse: Usually the S key or the Down arrow key. Essential for scrubbing speed, initiating drifts, and recovering from oversteer. Steering: A and D keys or Left and Right arrow keys. Your primary tools for guiding your car through turns and maintaining your drift angle. Handbrake: The Spacebar. This is your secret weapon for initiating aggressive drifts, particularly in tighter corners. It's your drift-starter button! Shift Up/Down (Manual Transmission): Left Shift and Left Control. For those who crave ultimate control and a more immersive experience, manual transmission adds another layer of skill. Camera Views: C key. Switch between various perspectives to find what suits your drifting style best. Pause: P key. Need a breather? Hit P to pause the action. The goal of each session is simple: earn as many drift points as possible. You do this by holding long, sustained drifts, chaining them together, and maximizing your drift angle without spinning out or hitting obstacles. The longer and more aggressive your drift, the higher the multiplier, and the more points you rack up. It's a delicate balance of speed, steering, and throttle control. 3. Useful Tips for Success Start Simple: Don't jump straight into the fastest car on the most complex track. Begin with the starter car on a more forgiving track like "Test Drive" or "Parking." Get a feel for the controls and the physics before pushing the limits. Practice Makes Perfect: Drifting is a skill that requires practice. Don't get discouraged if you spin out repeatedly at first. Every spin-out is a learning opportunity. Feather the Throttle: This is perhaps the most important tip. Instead of mashing the accelerator, learn to gently "feather" it. This means rapidly tapping and releasing the gas to maintain your drift angle and prevent spinning. Look Ahead: Always be looking several turns ahead. Anticipating the next corner allows you to set up your entry perfectly and maximize your drift chain. Experiment with Cars: Each car handles differently. Don't be afraid to try out different vehicles once you unlock them. You might find that a particular car just "clicks" with your drifting style. Tune Your Ride: Don't neglect the tuning options! Adjusting your suspension, gear ratios, and even tire pressure can significantly impact how your car drifts. Spend some time in the garage tweaking your settings to find your ideal setup. Use the Handbrake Wisely: The handbrake is a powerful tool, but use it sparingly and with precision. It's excellent for initiating sharp drifts or correcting an angle, but overusing it can lead to instability. Watch and Learn: There are countless videos of skilled Drift Hunters players on platforms like YouTube. Watch how they approach corners, their throttle control, and their counter-steering techniques. You'll pick up valuable insights. Don't Be Afraid to Fail: Seriously, failure is part of the learning process. The best drifts often come after numerous failed attempts. Embrace the spins, learn from them, and keep pushing your limits. Have Fun!: Ultimately, video games are about enjoyment. Don't get too caught up in chasing high scores if it stops being fun. Experiment, customize, and simply enjoy the thrill of sliding sideways! 4. Ready to Leave Your Mark on the Asphalt? So, there you have it, folks. Drift Hunters isn't just a game; it's an invitation to a world where the laws of physics are bent to your will, where every turn is an opportunity for a masterpiece, and where the roar of an engine is your personal soundtrack. It’s a place where you can refine your skills, unleash your creativity through customization, and challenge yourself to become the ultimate drift master. Are you ready to feel the thrill? Are you prepared to transform your ordinary driving into an extraordinary ballet of controlled slides? Then don't just sit there reading about it! Head over to Drift Hunters right now! Your perfectly tuned, tire-shredding machine is waiting for you. Get ready to experience the pure, unadulterated joy of drifting. I'll see you on the track, leaving smoky trails of glory! Let the drifting commence! Visit: https://drifthunters3d.io/

4 hours, 33 minutes

Usdc Coin Scam Recovery From Online Trading Investment Scam Contact Primatz Guard

by alexandermonroe63＠gmail.com

Primatz Guard has emerged as a prominent figure in the realm of cryptocurrency recovery, gaining a reputation for their exceptional ability to retrieve lost Bitcoin (BTC) and other cryptocurrencies. Their expertise and track record have made them a beacon of hope for individuals facing the distressing situation of lost or inaccessible crypto assets. Homepage : Primatz Guard

11 hours, 24 minutes

Re: [PATCH v5 3/9] vfio/pci: Add a helper to look up PFNs for DMABUFs

by Matt Evans

Hi Praan, On 30/07/2026 23:55, Pranjal Shrivastava wrote: > On Wed, Jul 15, 2026 at 06:47:26PM +0100, Matt Evans wrote: >> Add vfio_pci_dma_buf_find_pfn(), which a VMA fault handler can use to >> find a PFN. >> >> This supports multi-range DMABUFs, which typically would be used to >> represent scattered spans but might even represent overlapping or >> aliasing spans of PFNs. >> >> Because this is intended to be used in vfio_pci_core.c, we also need >> to expose the struct vfio_pci_dma_buf in the vfio_pci_priv.h header. >> >> Signed-off-by: Matt Evans <matt(a)ozlabs.org> >> --- >> drivers/vfio/pci/vfio_pci_dmabuf.c | 153 ++++++++++++++++++++++++++--- >> drivers/vfio/pci/vfio_pci_priv.h | 20 ++++ >> 2 files changed, 160 insertions(+), 13 deletions(-) >> >> diff --git a/drivers/vfio/pci/vfio_pci_dmabuf.c b/drivers/vfio/pci/vfio_pci_dmabuf.c >> index c16f460c01d6..7c047400dfd1 100644 >> --- a/drivers/vfio/pci/vfio_pci_dmabuf.c >> +++ b/drivers/vfio/pci/vfio_pci_dmabuf.c >> @@ -9,19 +9,6 @@ >> >> MODULE_IMPORT_NS("DMA_BUF"); >> >> -struct vfio_pci_dma_buf { >> - struct dma_buf *dmabuf; >> - struct vfio_pci_core_device *vdev; >> - struct list_head dmabufs_elm; >> - size_t size; >> - struct phys_vec *phys_vec; >> - struct p2pdma_provider *provider; >> - u32 nr_ranges; >> - struct kref kref; >> - struct completion comp; >> - u8 revoked : 1; >> -}; >> - >> static int vfio_pci_dma_buf_attach(struct dma_buf *dmabuf, >> struct dma_buf_attachment *attachment) >> { >> @@ -106,6 +93,146 @@ static const struct dma_buf_ops vfio_pci_dmabuf_ops = { >> .release = vfio_pci_dma_buf_release, >> }; >> >> +int vfio_pci_dma_buf_find_pfn(struct vfio_pci_dma_buf *priv, >> + struct vm_area_struct *vma, >> + unsigned long fault_addr, >> + unsigned int order, >> + unsigned long *out_pfn) >> +{ >> + /* >> + * Given a VMA (start, end, pgoffs) and a fault address, >> + * search the corresponding DMABUF's phys_vec[] to find the >> + * range representing the address's offset into the VMA, and >> + * its PFN. >> + * >> + * The phys_vec[] ranges represent contiguous spans of VAs >> + * upwards from the buffer offset 0; the actual PFNs might be >> + * in any order, overlap/alias, etc. Calculate an offset of >> + * the desired page given VMA start/pgoff and address, then >> + * search upwards from 0 to find which span contains it. >> + * >> + * On success, a valid PFN for a page sized by 'order' is >> + * returned into out_pfn. >> + * >> + * Failure occurs if: >> + * - A hugepage would cross the edge of the VMA, >> + * - A hugepage isn't entirely contained within a range >> + * (including where it straddles the boundary between >> + * ranges), >> + * - We find a range, but the final PFN isn't aligned to the >> + * requested order. >> + * >> + * Upon failure, -EAGAIN is returned and the caller is >> + * expected to try again with a smaller order, which will >> + * eventually succeed (order=0 will always work). >> + * >> + * It's suboptimal if DMABUFs are created with neighbouring >> + * ranges that are physically contiguous, since hugepages >> + * can't straddle range boundaries. (The construction of the >> + * ranges should merge them in this case.) >> + * >> + * Finally, vma_pgoff_adjust is used with a DMABUF created for >> + * a VFIO BAR mmap: a BAR mapped with vm_pgoff > 0 creates a >> + * DMABUF such that byte 0 of the VMA corresponds to byte 0 of >> + * the DMABUF and byte 'vm_pgoff << PAGE_SHIFT' into the BAR. >> + * To avoid double-offsetting in this scenario, subtracting >> + * vma_pgoff_adjust from this (non-zero) vm_pgoff generates >> + * the effective offset. >> + */ >> + >> + const unsigned long pagesize = PAGE_SIZE << order; >> + unsigned long vma_off = ((vma->vm_pgoff - priv->vma_pgoff_adjust) << >> + PAGE_SHIFT) & VFIO_PCI_OFFSET_MASK; > > Maybe I'm getting ahead of myself here.. but it seems like this > restricts us to only mapping DMABUFs at offsets < 1TB due to the > VFIO_PCI_OFFSET_MASK (since we have HBMs on PCI devices now, hitting 1TB > may not be a very distant future). This is a really good question, thanks for raisiing it. It is not too forward-thinking at all. > While I understand this mask is needed to drop the BAR encoding in the > high bits. > > My worry is, if in the future a user were to export a massive > contiguous DMABUF (e.g., >1TB of aggregated HBM) and tried to mmap deep > into it (passing an offset >= 1TB), this bitwise AND would silently drop > the high bits, leading to silent data corruption. One of the big advantages of DMABUF export was that the range could be huge and unencumbered by the VFIO_PCI_OFFSET_SHIFT of the traditional mmap() interface. It's a way to mmap huge BARs without having to change the user-visible shift). So definitely this is a relevant concern. > I think we should explicitly reject such an mmap with -EINVAL like: > > +const unsigned long pagesize = PAGE_SIZE << order; > +unsigned long vma_off = (vma->vm_pgoff - priv->vma_pgoff_adjust) << PAGE_SHIFT; > > +/* > + * Prevent silent wrap-around if the user mmaps a DMABUF at an > + * offset greater than the VFIO index mask allows. > + */ > +if (unlikely(vma_off > VFIO_PCI_OFFSET_MASK)) > + return -EINVAL; > > +vma_off &= VFIO_PCI_OFFSET_MASK; Agreed, for now this absolutely should not silently wrap if the offset is > 1TB, and we live with the restriction that a DMABUF sized >1TB can't be mapped with such an offset. (We can still, say, map all of a 16TB DMABUF with offset=0, which is good.). I'll add a check, thanks for pointing this out. I suggest as something to revisit later, we flag for a DMABUF (maybe an evolution of vma_pgoff_adjust) to differentiate whether this masking needs to be applied (traditional mmap() path) or not (DMABUF mmap()), and then offsets can be arbitrarily large. Cheers, Matt >> + unsigned long rounded_page_addr = ALIGN_DOWN(fault_addr, pagesize); >> + unsigned long rounded_page_end = rounded_page_addr + pagesize; >> + unsigned long fault_offset; >> + unsigned long fault_offset_end; >> + unsigned long range_start_offset = 0; >> + unsigned int i; >> + int ret; >> + > > > Thanks, > Praan

12 hours, 11 minutes

[PATCH v3 0/2] drm/drm_crtc: dma_fence_ops fixes

by André Draszik

Hi, These patches fix two issues in the drm/drm_crtc driver. Initially I was hitting the BUG_ON() in a scenario as explained in the commit message of what is now the second patch in this series. After posting, sashiko.dev noticed another issue, that was previously masked by the now-removed BUG_ON(). Since we can't have a loud BUG() be replaced with silent data corruption or worse, I've also added a patch to address this issue highlighted by sashiko.dev. I believe its observation and analysis to be correct. Cheers, Andre' Signed-off-by: André Draszik <andre.draszik(a)linaro.org> --- Changes in v3: - Philipp: - patch 1: update kerneldoc, add Fixes: - patch 2: shorten commit message - explicitly Cc: stable - collect tag - Link to v2: https://lore.kernel.org/r/20260708-linux-drm_crtc_fix2-v2-0-cf72be75d75a@li… Changes in v2: - add new patch 1 to address sashiko observation - original patch 1 becomes patch 2 - patch 2: - don't turn fence_to_crtc() into macro (Jani, Philipp) - update commit message to include reference to deprecated use of BUG - Link to v1: https://lore.kernel.org/r/20260618-linux-drm_crtc_fix2-v1-1-c03e77b36f34@li… --- André Draszik (2): drm/drm_crtc: ensure dma_fence_ops remain valid during device unbind drm/drm_crtc: fix race with dma_fence_signal() in ::get_driver_name() drivers/gpu/drm/drm_crtc.c | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) --- base-commit: 0718283ab28bc3907e10b61a6b4be6fefa1cbb2f change-id: 20260618-linux-drm_crtc_fix2-23a7c354a412 Best regards, -- André Draszik <andre.draszik(a)linaro.org>

18 hours, 7 minutes

Prepare to Rage Quit (and Maybe Love It): Diving into Level Devil

by graceful.earthworm.hsos＠hidingmail.com

So, you're looking for a new game to sink your teeth into? Something challenging, maybe a little bit infuriating, and definitely memorable? Look no further than Level Devil. This deceptively simple platformer is a masterclass in trickery, constantly changing the rules and keeping you on your toes. But don't be intimidated! With a little patience (and maybe a stress ball), you can conquer its devilish design. https://leveldevilfull.com Gameplay: Expect the Unexpected At its core, Level Devil is a 2D platformer. You control a little pixelated character tasked with reaching the exit door in each level. Sounds easy, right? Wrong. The beauty (and the frustration) lies in the unpredictable nature of the environment. Platforms crumble beneath your feet, spikes appear out of nowhere, and the ground itself can vanish unexpectedly. Each level introduces new challenges, forcing you to adapt your strategy on the fly. You'll encounter moving platforms, disappearing blocks, and even gravity-defying puzzles. The real kicker? The layout of the levels often changes on each attempt, meaning memorization alone won't cut it. You need to be quick-witted and reactive. The charm of Level Devil is its lack of hand-holding. There are no tutorials, no hints, and no mercy. You're thrown straight into the deep end, forced to learn from your mistakes (and trust me, there will be plenty). That feeling of finally overcoming a particularly difficult section is incredibly rewarding. It's a game that demands your full attention and rewards persistence. Tips for Taming the Devil While Level Devil thrives on its unpredictability, here are a few tips to help you navigate its treacherous landscape: • Patience is Key: This game is designed to test your limits. Don't get discouraged by frequent deaths. Treat each attempt as a learning experience. • Observe Carefully: Before making a move, take a moment to scan the environment. Look for subtle cues that might indicate impending danger. • Embrace Failure: You will die. A lot. Embrace it as part of the learning process. Each death provides valuable insight into the level's design. • Don't Overthink It: Sometimes, the solution is simpler than you think. Avoid overcomplicating your approach. • Take Breaks: If you find yourself getting too frustrated, step away from the game for a while. Come back with a fresh perspective. • Listen to the Sound: The game’s audio cues often hint at upcoming dangers. Pay close attention! Level Devil utilizes sound design to enhance the experience (and sometimes, to cleverly mislead you!). Conclusion: A Test of Skill and Sanity Level Devil isn't for the faint of heart. It's a challenging and often frustrating experience. However, it's also incredibly rewarding. The constant surprises, the need for quick thinking, and the sheer satisfaction of overcoming its devilish design make it a truly unique and memorable game. If you're looking for a platformer that will push you to your limits and leave you feeling accomplished, then Level Devil is definitely worth a try. Just be prepared to rage quit... and then come back for more.

21 hours, 20 minutes

[PATCH V5] i2c: qcom-geni: Add dynamic transfer timeout based on transfer length and frequency

by Aniket Randive

The driver uses a static XFER_TIMEOUT of HZ (1 second) for all transfers regardless of message length or bus frequency, causing unnecessary delays on error paths. Compute the timeout dynamically from message length and bus frequency with a 10x safety margin over the theoretical wire time. Add a 300 ms floor to account for I2C clock stretching and other situations where a slave may keep SCL asserted for an extended period, including faulty devices holding the bus. This replaces the fixed 1-second timeout with a transfer-specific timeout while preserving sufficient margin for software overheads and bus-level delays. For GPI multi-descriptor transfers, use the maximum message length across all queued messages as the per-completion timeout. Signed-off-by: Aniket Randive <aniket.randive(a)oss.qualcomm.com> --- Changes in V5: - Updated the commit message as per the review comments. Changes in V4: - As per konrad suggestion used mult_frac() for bit_usec to avoid intermediate overflow on 32-bit targets. - Updated the commit message and added a driver comment explaining the rationale for the 0.3-second minimum timeout floor value. drivers/i2c/busses/i2c-qcom-geni.c | 47 +++++++++++++++++++++++------- 1 file changed, 37 insertions(+), 10 deletions(-) diff --git a/drivers/i2c/busses/i2c-qcom-geni.c b/drivers/i2c/busses/i2c-qcom-geni.c index 96dbf04138be..f011d2564cd2 100644 --- a/drivers/i2c/busses/i2c-qcom-geni.c +++ b/drivers/i2c/busses/i2c-qcom-geni.c @@ -74,9 +74,14 @@ enum geni_i2c_err_code { #define PACKING_BYTES_PW 4 #define ABORT_TIMEOUT HZ -#define XFER_TIMEOUT HZ #define RST_TIMEOUT HZ +/* 9 bits per byte (8 data + 1 ACK), 10x safety margin */ +#define I2C_TIMEOUT_SAFETY_COEFFICIENT 10 + +/* 300ms floor: budget for clock stretching; slave may hold SCL low indefinitely */ +#define I2C_TIMEOUT_MIN_USEC 300000 + struct geni_i2c_desc { bool no_dma_support; unsigned int tx_fifo_depth; @@ -204,6 +209,16 @@ static int geni_i2c_clk_map_idx(struct geni_i2c_dev *gi2c) return -EINVAL; } +static unsigned long geni_i2c_xfer_timeout(struct geni_i2c_dev *gi2c, size_t len) +{ + size_t bit_cnt = len * 9; + size_t bit_usec = mult_frac(bit_cnt, USEC_PER_SEC, gi2c->clk_freq_out); + size_t xfer_max_usec = (bit_usec * I2C_TIMEOUT_SAFETY_COEFFICIENT) + + I2C_TIMEOUT_MIN_USEC; + + return usecs_to_jiffies(xfer_max_usec); +} + static int qcom_geni_i2c_conf(struct geni_se *se, unsigned long freq) { struct geni_i2c_dev *gi2c = dev_get_drvdata(se->dev); @@ -445,7 +460,7 @@ static int geni_i2c_rx_one_msg(struct geni_i2c_dev *gi2c, struct i2c_msg *msg, u32 m_param) { dma_addr_t rx_dma = 0; - unsigned long time_left; + unsigned long time_left, timeout; void *dma_buf; struct geni_se *se = &gi2c->se; size_t len = msg->len; @@ -470,8 +485,9 @@ static int geni_i2c_rx_one_msg(struct geni_i2c_dev *gi2c, struct i2c_msg *msg, gi2c->dma_buf = dma_buf; } + timeout = geni_i2c_xfer_timeout(gi2c, len); cur = gi2c->cur; - time_left = wait_for_completion_timeout(&gi2c->done, XFER_TIMEOUT); + time_left = wait_for_completion_timeout(&gi2c->done, timeout); if (!time_left) geni_i2c_abort_xfer(gi2c); @@ -484,7 +500,7 @@ static int geni_i2c_tx_one_msg(struct geni_i2c_dev *gi2c, struct i2c_msg *msg, u32 m_param) { dma_addr_t tx_dma = 0; - unsigned long time_left; + unsigned long time_left, timeout; void *dma_buf; struct geni_se *se = &gi2c->se; size_t len = msg->len; @@ -512,8 +528,9 @@ static int geni_i2c_tx_one_msg(struct geni_i2c_dev *gi2c, struct i2c_msg *msg, if (!dma_buf) /* Get FIFO IRQ */ writel_relaxed(1, se->base + SE_GENI_TX_WATERMARK_REG); + timeout = geni_i2c_xfer_timeout(gi2c, len); cur = gi2c->cur; - time_left = wait_for_completion_timeout(&gi2c->done, XFER_TIMEOUT); + time_left = wait_for_completion_timeout(&gi2c->done, timeout); if (!time_left) geni_i2c_abort_xfer(gi2c); @@ -591,7 +608,7 @@ static void geni_i2c_gpi_multi_desc_unmap(struct geni_i2c_dev *gi2c, struct i2c_ * geni_i2c_gpi_multi_xfer_timeout_handler() - Handles multi message transfer timeout * @dev: Pointer to the corresponding dev node * @multi_xfer: Pointer to the geni_i2c_gpi_multi_desc_xfer - * @transfer_timeout_msecs: Timeout value in milliseconds + * @transfer_timeout_msecs: Per-message completion timeout in jiffies * @transfer_comp: Completion object of the transfer * * This function waits for the completion of each processed transfer messages @@ -601,7 +618,7 @@ static void geni_i2c_gpi_multi_desc_unmap(struct geni_i2c_dev *gi2c, struct i2c_ */ static int geni_i2c_gpi_multi_xfer_timeout_handler(struct device *dev, struct geni_i2c_gpi_multi_desc_xfer *multi_xfer, - u32 transfer_timeout_msecs, + unsigned long timeout_jiffies, struct completion *transfer_comp) { int i; @@ -612,7 +629,7 @@ static int geni_i2c_gpi_multi_xfer_timeout_handler(struct device *dev, if (multi_xfer->msg_idx_cnt != multi_xfer->irq_cnt) { time_left = wait_for_completion_timeout(transfer_comp, - transfer_timeout_msecs); + timeout_jiffies); if (!time_left) { dev_err(dev, "%s: Transfer timeout\n", __func__); return -ETIMEDOUT; @@ -736,8 +753,16 @@ static int geni_i2c_gpi(struct geni_i2c_dev *gi2c, struct i2c_msg msgs[], dma_async_issue_pending(gi2c->tx_c); if ((msg_idx == (gi2c->num_msgs - 1)) || flags & DMA_PREP_INTERRUPT) { + unsigned long timeout; + size_t max_len = 0; + int j; + + for (j = 0; j < gi2c->num_msgs; j++) + max_len = max_t(size_t, max_len, msgs[j].len); + + timeout = geni_i2c_xfer_timeout(gi2c, max_len); ret = geni_i2c_gpi_multi_xfer_timeout_handler(gi2c->se.dev, gi2c_gpi_xfer, - XFER_TIMEOUT, &gi2c->done); + timeout, &gi2c->done); if (ret) { dev_err(gi2c->se.dev, "I2C multi write msg transfer timeout: %d\n", @@ -851,8 +876,10 @@ static int geni_i2c_gpi_xfer(struct geni_i2c_dev *gi2c, struct i2c_msg msgs[], i } if (!gi2c->is_tx_multi_desc_xfer) { + unsigned long timeout = geni_i2c_xfer_timeout(gi2c, msgs[i].len); + dma_async_issue_pending(gi2c->tx_c); - time_left = wait_for_completion_timeout(&gi2c->done, XFER_TIMEOUT); + time_left = wait_for_completion_timeout(&gi2c->done, timeout); if (!time_left) { dev_err(gi2c->se.dev, "%s:I2C timeout\n", __func__); gi2c->err = -ETIMEDOUT; -- 2.34.1

22 hours, 5 minutes

Get Ready to Roll: Unveiling the Addictive World of Slope Unblocked!

by awkward.guppy.nqjz＠hidepost.net

Hey there, fellow gamers and adrenaline junkies! Are you ready to dive into a world where precision, speed, and gravity are your best friends (and sometimes your worst enemies)? Do you crave a game that’s easy to pick up, impossible to put down, and delivers an instant shot of pure, unadulterated fun? Then buckle up, because today we’re talking about a phenomenon that’s been silently captivating players across the globe: Slope Unblocked! Forget your everyday, run-of-the-mill mobile games or those lengthy, story-driven adventures that demand hours of your time. Slope Unblocked is a different beast entirely. It’s a masterclass in elegant simplicity, a high-octane thrill ride that distills the essence of gaming down to its purest, most exhilarating form. And the best part? Thanks to its unblocked nature, it's often readily available at your fingertips, waiting to transform your mundane moments into mini-adventures. So, what exactly is this captivating game, and why should you be paying attention? Let’s roll into it! Visit: https://slopefree.org/ 1. What on Earth Is Slope Unblocked? Imagine a perpetually descending slope, a futuristic, neon-lit landscape stretching into infinity. Now, picture yourself controlling a small, vibrant green ball, your only goal being to navigate this treacherous terrain without plummeting into the abyss. That, my friends, is the core of Slope Unblocked. It’s an infinite runner, but with a unique twist. Instead of simply running forward, you’re constantly battling gravity, steering your ball left and right to avoid a myriad of obstacles: gaping holes, towering walls, and sudden changes in the terrain that demand lightning-fast reflexes. The speed intensifies as you progress, the stakes get higher, and the thrill becomes absolutely intoxicating. Why "Unblocked," you ask? In many school, college, or even workplace networks, popular gaming websites are often blocked to prevent distractions. "Unblocked" versions of games like Slope are typically hosted on alternative domains or proxy servers, allowing players to bypass these restrictions and enjoy their favorite games when they have a spare moment. This accessibility is a huge part of Slope's widespread appeal, turning a quick break into an opportunity for some high-score chasing. 2. How to Play: Simple Controls, Deep Challenge This is where Slope Unblocked truly shines: its elegant simplicity. You won't find complicated control schemes or convoluted tutorials here. The beauty lies in its minimalist approach, making it instantly accessible to players of all ages and skill levels. The controls are incredibly straightforward: Left Arrow Key (or 'A'): Steer your ball to the left. Right Arrow Key (or 'D'): Steer your ball to the right. That’s it! No jumping, no power-ups, no special abilities. Your entire success hinges on your ability to master these two simple movements, anticipating the upcoming terrain and making split-second decisions. Your objective is equally clear: go as far as you can, score as high as possible, and don’t fall off the edge. As you descend, the score counter relentlessly ticks upwards, providing a constant motivation to push your limits. The game features a variety of level designs that are procedurally generated, meaning each run is unique, keeping the gameplay fresh and unpredictable. You'll encounter flat stretches that lull you into a false sense of security, sudden drops that demand immediate corrective action, and narrow passages that test the absolute limits of your precision. 3. Tips and Tricks for Dominating the Slope Think you’re ready to conquer the slope? While the game is easy to pick up, mastering it requires a bit of practice and some strategic thinking. Here are some invaluable tips to help you ascend to the top of the leaderboards: Look Ahead, Always: This is arguably the most crucial tip. Your eyes should constantly be scanning the terrain ahead, not just the immediate vicinity of your ball. Anticipating upcoming obstacles gives you precious milliseconds to react and adjust your trajectory. Think of it like driving – you don’t just stare at your hood! Gentle Nudges are Key: Don't oversteer! Rapid, jerky movements are often the quickest way to end your run. Instead, aim for small, precise nudges with your arrow keys. A light tap can often be enough to correct your course and guide your ball safely. Over-correcting is a common beginner mistake. Master the Momentum: Your ball carries momentum. Use it to your advantage! Sometimes, a slightly wider turn executed smoothly is better than a sharp, sudden correction that could send you spiraling off course. Learn to feel the flow of the game. Practice Makes Perfect: There's no secret shortcut to becoming a Slope master. The more you play, the better your reflexes will become, and the more attuned you'll be to the game's physics. Each failed run is a learning opportunity! Analyze what went wrong and try to avoid repeating the same mistake. Find Your Rhythm: Slope Unblocked has a mesmerizing, almost hypnotic quality to it. As you play, you'll start to develop a rhythm, a flow state where your movements become intuitive. Don't fight this feeling; embrace it! When you're in the zone, your scores will soar. Embrace Failure: You will fall. A lot. Don't get discouraged! Every fall is a chance to learn the nuances of the terrain and refine your approach. The best players aren't those who never fall, but those who learn from their falls and come back stronger. Don't Hog the Middle: While the middle seems safest, hugging it too closely can sometimes limit your reaction time, especially when large obstacles appear on either side. Don't be afraid to utilize the full width of the slope, provided it's clear! Take Breaks: Believe it or not, stepping away for a few minutes can actually improve your performance. Sometimes, a fresh pair of eyes and a reset mind can help you see patterns you missed before. 4. Ready to Take the Plunge? So, what are you waiting for? Your personal best awaits! If you’re looking for a game that will test your reflexes, sharpen your focus, and provide an instant rush of adrenaline, then look no further than Slope Unblocked. Head over to Slope Unblocked and give it a try. I guarantee you'll find yourself saying "just one more run" more times than you care to admit. Will you conquer the slope and etch your name into the high score hall of fame? There's only one way to find out! Go on, give it a whirl. Let me know in the comments below what your highest score is, and what tips you've discovered to dominate the treacherous terrain! Happy rolling! Visit: https://slopefree.org/

23 hours, 30 minutes

New Years Eve 2027 in ZSL London Zoo, UK - Celebrate in Style with These Tips

by klyianfriyasnia＠gmail.com

# What I Thought vs. What I Know Now: NYE 2027 in ZSL London Zoo, UK There's a version of me, about a year ago, who thought planning New Year's Eve in ZSL London Zoo, UK would be roughly as simple as planning any other trip. Book a hotel, show up, enjoy the fireworks. That version of me was wrong about almost every part of it — not dramatically, just consistently, in ways that only became obvious in hindsight. Here's what changed between then and now. ## What I Thought: "I'll book the hotel whenever, there's plenty of time" **What I know now:** there really isn't. I remember assuming that because NYE was months away, hotel availability would still be wide open closer to the date. It wasn't a reckless assumption — it's just how booking works for basically every other trip I'd taken. NYE in ZSL London Zoo, UK doesn't follow that pattern. The properties within a reasonable distance of the actual countdown activity get reserved on a timeline that's meaningfully faster than normal travel booking, and by the time I went looking with real urgency, my options had already narrowed more than I expected. The lesson wasn't complicated, just something I hadn't internalized yet: for this specific night, "plenty of time" arrives and disappears earlier than it feels like it should. ## What I Thought: "The free viewing spot is obviously the smart choice" **What I know now:** it's a choice, not automatically the smart one. Back then, "free" felt like a complete answer on its own — why would I pay for something I could get for nothing? What I hadn't accounted for was the actual cost of that free option: showing up hours early, standing in a dense crowd for an extended stretch, having limited ability to move or leave once committed to that spot. I don't think free spots are wrong, exactly. I think I made that decision without actually comparing it to the alternative, which is a different mistake than the decision itself. Now I'd at least look at what a ticketed event or a rooftop reservation costs before defaulting to free out of habit. ## What I Thought: "We'll figure out dinner when we're hungry" **What I know now:** that sentence doesn't really apply to NYE in ZSL London Zoo, UK. On any regular night, sure, wandering around and picking somewhere works fine. That year, it didn't — every place with any real reputation was already fully booked, weeks or months out, and "figuring it out" turned into eating something unmemorable much later than planned. What surprised me most in hindsight wasn't that restaurants got booked out — that part makes sense. It was how early it happened, well before I'd even locked in other logistics. I know now that dinner deserves the same urgency as the hotel, not a decision to leave for later. ## What I Thought: "Getting home will be fine, it's the same city I've been in all week" **What I know now:** the city functions completely differently right after midnight than it does at any other point during the trip. This was the assumption that caused the most friction in hindsight, mostly because it never occurred to me to question it. Roads that had been open all week closed. Transit that had been manageable became overwhelmed. Rideshare pricing jumped to something that felt almost absurd in the moment. The lesson here wasn't about a specific mistake so much as a blind spot: I'd planned the arrival to the viewing spot in detail and genuinely never thought about the departure as a separate logistics problem. It is one, and now I plan for it as one. ## What I Thought: "The countdown and fireworks are basically the whole night" **What I know now:** there's usually a lot more going on. At the time, my entire mental model of NYE in ZSL London Zoo, UK began and ended with the countdown moment itself. It wasn't until afterward, hearing what other people had done that same night, that I realized there were concerts, smaller parties, and local events running in parallel that never showed up in the content I'd been reading beforehand. I wouldn't say I missed out, exactly — the night I had was fine. But I know now that "fine" and "the version that actually matched what I was looking for" aren't necessarily the same thing, and a bit more research into the broader event landscape would have closed that gap. ## Where This Ended Up Looking back, none of these were single dramatic errors. They were a version of me applying normal trip-planning logic to a night that doesn't operate on normal trip-planning logic — and only realizing the difference after the fact, one piece at a time. That hindsight is basically what became **[ https://nye2027insider.com/new-years-eve-2027-in-zsl-london-zoo-uk/ ]** — a full NYE 2027 planning resource for ZSL London Zoo, UK and several other major destinations, built around exactly the gaps outlined above: - **Hotel recommendations that reflect the real booking timeline**, not generic "few months ahead" advice - **A genuine comparison of ticketed versus free viewing options**, including the time cost that "free" doesn't advertise - **Restaurant guidance with realistic reservation windows**, so dinner isn't left for later - **Transport planning that treats the return trip as its own logistics problem** - **A fuller view of what's happening beyond the main countdown**, for travelers who want more than just the fireworks - **Official ticketed and skip-the-line options**, for anyone who'd rather not default to the free option out of habit If ZSL London Zoo, UK is on your list for NYE 2027, the version of this planning process that took me a full trip to figure out is laid out here: **[ https://nye2027insider.com/new-years-eve-2027-in-zsl-london-zoo-uk/ ]** ## The Actual Takeaway The gap between what I thought going in and what I know now isn't really about ZSL London Zoo, UK specifically — it's about how differently this one night operates compared to ordinary travel planning. Booking earlier, comparing free against paid rather than defaulting to either, locking in dinner ahead of everything else, and treating the trip home as seriously as the trip there: none of it is complicated in hindsight. It just wasn't obvious going in. The complete resource, covering all of it in more depth, is available at **[ https://nye2027insider.com/new-years-eve-2027-in-zsl-london-zoo-uk/ ]**.

1 day, 4 hours

Jump to page:

2026

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

Linaro-mm-sig