@mytechtoday/augment-extensions 1.4.0 → 1.5.0

package/augment-extensions/coding-standards/c/templates/prompts/drivers.txt

@@ -0,0 +1,191 @@
+You are assisting with Linux device driver development in C.
+
+## Context
+- Category: {category}
+- C Standard: {c_standard}
+- Target: Linux kernel device drivers
+
+## Key Rules for Device Drivers
+
+### 1. ioctl Interface Design
+- Define ioctl commands using _IO, _IOR, _IOW, _IOWR macros
+- Validate all user input in ioctl handlers
+- Use copy_from_user() and copy_to_user() for data transfer
+- Return appropriate error codes (-EINVAL, -EFAULT, -ENOTTY)
+
+### 2. DMA (Direct Memory Access)
+- Use dma_alloc_coherent() for DMA buffers
+- Check dma_map_single() return with dma_mapping_error()
+- Always unmap DMA buffers with dma_unmap_single()
+- Use proper DMA direction flags (DMA_TO_DEVICE, DMA_FROM_DEVICE)
+- Ensure cache coherency
+
+### 3. Memory-Mapped I/O
+- Use ioremap() to map device registers, never direct pointers
+- Use readl()/writel() for 32-bit register access
+- Use readb()/writeb() for 8-bit register access
+- Always iounmap() in cleanup
+- Use memory barriers (mb, rmb, wmb) when needed
+
+### 4. Interrupt Handling
+- Request IRQ with request_irq() or devm_request_irq()
+- Return IRQ_HANDLED or IRQ_NONE appropriately
+- Use threaded IRQs for complex handling
+- Free IRQ in cleanup with free_irq()
+- Minimize work in hard IRQ context
+
+### 5. Resource Management
+- Use devm_* functions for automatic cleanup
+- Request resources (I/O ports, memory regions) before use
+- Release ALL resources in remove/exit functions
+- Handle probe() failures with proper cleanup
+- Use reference counting for shared resources
+
+{#if rules}
+## Active Rules
+{#each rules}
+- {id}: {description}
+{/each}
+{/if}
+
+## Example Pattern: Platform Driver
+
+```c
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/io.h>
+#include <linux/interrupt.h>
+
+struct example_device {
+    void __iomem *regs;
+    int irq;
+    struct device *dev;
+};
+
+static irqreturn_t example_irq_handler(int irq, void *dev_id) {
+    struct example_device *edev = dev_id;
+    u32 status;
+    
+    status = readl(edev->regs + STATUS_REG);
+    if (!(status & IRQ_FLAG))
+        return IRQ_NONE;
+    
+    // Clear interrupt
+    writel(IRQ_FLAG, edev->regs + STATUS_REG);
+    
+    // Handle interrupt
+    dev_dbg(edev->dev, "Interrupt handled: 0x%x\n", status);
+    
+    return IRQ_HANDLED;
+}
+
+static int example_probe(struct platform_device *pdev) {
+    struct example_device *edev;
+    struct resource *res;
+    int ret;
+    
+    edev = devm_kzalloc(&pdev->dev, sizeof(*edev), GFP_KERNEL);
+    if (!edev)
+        return -ENOMEM;
+    
+    edev->dev = &pdev->dev;
+    
+    // Map device registers
+    res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+    edev->regs = devm_ioremap_resource(&pdev->dev, res);
+    if (IS_ERR(edev->regs))
+        return PTR_ERR(edev->regs);
+    
+    // Get and request IRQ
+    edev->irq = platform_get_irq(pdev, 0);
+    if (edev->irq < 0)
+        return edev->irq;
+    
+    ret = devm_request_irq(&pdev->dev, edev->irq, example_irq_handler,
+                          0, dev_name(&pdev->dev), edev);
+    if (ret) {
+        dev_err(&pdev->dev, "Failed to request IRQ\n");
+        return ret;
+    }
+    
+    platform_set_drvdata(pdev, edev);
+    dev_info(&pdev->dev, "Driver probed successfully\n");
+    
+    return 0;
+}
+
+static int example_remove(struct platform_device *pdev) {
+    dev_info(&pdev->dev, "Driver removed\n");
+    return 0;
+}
+
+static const struct of_device_id example_of_match[] = {
+    { .compatible = "vendor,example-device" },
+    { }
+};
+MODULE_DEVICE_TABLE(of, example_of_match);
+
+static struct platform_driver example_driver = {
+    .probe = example_probe,
+    .remove = example_remove,
+    .driver = {
+        .name = "example-driver",
+        .of_match_table = example_of_match,
+    },
+};
+
+module_platform_driver(example_driver);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Your Name");
+MODULE_DESCRIPTION("Example platform driver");
+```
+
+## Example Pattern: DMA Usage
+
+```c
+#include <linux/dma-mapping.h>
+
+int setup_dma_transfer(struct device *dev, void *buffer, size_t size) {
+    dma_addr_t dma_handle;
+    int ret;
+    
+    // Map buffer for DMA
+    dma_handle = dma_map_single(dev, buffer, size, DMA_TO_DEVICE);
+    if (dma_mapping_error(dev, dma_handle)) {
+        dev_err(dev, "DMA mapping failed\n");
+        return -ENOMEM;
+    }
+    
+    // Program DMA controller with dma_handle
+    // ...
+    
+    // After transfer completes
+    dma_unmap_single(dev, dma_handle, size, DMA_TO_DEVICE);
+    
+    return 0;
+}
+```
+
+{#if examples}
+## Additional Examples
+{#each examples}
+
+### {title}
+```c
+{code}
+```
+{/each}
+{/if}
+
+## Common Pitfalls to Avoid
+- Direct pointer access to device memory (use ioremap)
+- Not checking dma_mapping_error()
+- Forgetting to unmap DMA buffers
+- Not validating ioctl user input
+- Memory leaks in probe error paths
+- Not freeing IRQs in remove function
+- Using wrong register access functions
+
+Generate device driver code following these standards.
+

package/augment-extensions/coding-standards/c/templates/prompts/embedded.txt

@@ -0,0 +1,164 @@
+You are assisting with C embedded systems programming.
+
+## Context
+- Category: {category}
+- C Standard: {c_standard}
+- Target: Resource-constrained embedded systems
+
+## Key Rules for Embedded Systems
+
+### 1. Volatile Usage
+**CRITICAL**: Use volatile for hardware registers and interrupt-shared variables
+- Memory-mapped I/O registers MUST be volatile
+- Variables modified by ISRs MUST be volatile
+- Prevents compiler optimization that breaks hardware interaction
+
+### 2. ISR (Interrupt Service Routine) Constraints
+- Keep ISRs SHORT and FAST
+- No blocking operations (no delays, no waiting)
+- No dynamic memory allocation (malloc/free)
+- Use atomic operations or disable interrupts for shared data
+- Set flags for main loop to process
+
+### 3. No Dynamic Allocation
+- Avoid malloc(), free(), realloc() in embedded systems
+- Use static allocation or stack allocation
+- Pre-allocate all buffers at compile time
+- Use fixed-size circular buffers for data streams
+
+### 4. Fixed-Size Buffers
+- Define buffer sizes at compile time
+- Use circular/ring buffers for streaming data
+- Implement overflow protection
+- Document buffer sizes and constraints
+
+### 5. Hardware Register Access
+- Use memory-mapped I/O with proper volatile pointers
+- Follow datasheet specifications exactly
+- Use bit manipulation macros for clarity
+- Document register addresses and bit fields
+
+{#if rules}
+## Active Rules
+{#each rules}
+- {id}: {description}
+{/each}
+{/if}
+
+## Example Pattern: Hardware Register Access
+
+```c
+#include <stdint.h>
+
+// Hardware register definitions
+#define GPIO_BASE       0x40020000
+#define GPIO_MODER      (*(volatile uint32_t*)(GPIO_BASE + 0x00))
+#define GPIO_ODR        (*(volatile uint32_t*)(GPIO_BASE + 0x14))
+#define GPIO_IDR        (*(volatile uint32_t*)(GPIO_BASE + 0x10))
+
+// Bit manipulation macros
+#define BIT_SET(reg, bit)    ((reg) |= (1U << (bit)))
+#define BIT_CLEAR(reg, bit)  ((reg) &= ~(1U << (bit)))
+#define BIT_READ(reg, bit)   (((reg) >> (bit)) & 1U)
+
+void gpio_init(void) {
+    // Set pin 5 as output
+    GPIO_MODER &= ~(3U << (5 * 2));  // Clear mode bits
+    GPIO_MODER |= (1U << (5 * 2));   // Set as output
+}
+
+void gpio_set_pin(uint8_t pin) {
+    BIT_SET(GPIO_ODR, pin);
+}
+```
+
+## Example Pattern: Interrupt Service Routine
+
+```c
+#include <stdint.h>
+#include <stdbool.h>
+
+// Shared with ISR - MUST be volatile
+volatile bool data_ready = false;
+volatile uint8_t received_byte = 0;
+
+// ISR: Keep SHORT and FAST
+void UART_IRQHandler(void) {
+    if (UART_STATUS & UART_RX_FLAG) {
+        received_byte = UART_DATA;  // Read data
+        data_ready = true;          // Set flag
+        UART_STATUS = UART_RX_FLAG; // Clear flag
+    }
+}
+
+// Main loop processes data
+void main_loop(void) {
+    while (1) {
+        if (data_ready) {
+            data_ready = false;
+            process_byte(received_byte);
+        }
+    }
+}
+```
+
+## Example Pattern: Circular Buffer (No Dynamic Allocation)
+
+```c
+#include <stdint.h>
+#include <stdbool.h>
+
+#define BUFFER_SIZE 64
+
+typedef struct {
+    uint8_t data[BUFFER_SIZE];
+    volatile uint16_t head;
+    volatile uint16_t tail;
+} circular_buffer_t;
+
+static circular_buffer_t rx_buffer = {0};
+
+bool buffer_put(circular_buffer_t *buf, uint8_t byte) {
+    uint16_t next_head = (buf->head + 1) % BUFFER_SIZE;
+    
+    if (next_head == buf->tail) {
+        return false;  // Buffer full
+    }
+    
+    buf->data[buf->head] = byte;
+    buf->head = next_head;
+    return true;
+}
+
+bool buffer_get(circular_buffer_t *buf, uint8_t *byte) {
+    if (buf->head == buf->tail) {
+        return false;  // Buffer empty
+    }
+    
+    *byte = buf->data[buf->tail];
+    buf->tail = (buf->tail + 1) % BUFFER_SIZE;
+    return true;
+}
+```
+
+{#if examples}
+## Additional Examples
+{#each examples}
+
+### {title}
+```c
+{code}
+```
+{/each}
+{/if}
+
+## Common Pitfalls to Avoid
+- Forgetting volatile on hardware registers
+- Using malloc/free in embedded code
+- Long-running ISRs blocking other interrupts
+- Not protecting shared data between ISR and main
+- Unbounded buffers causing memory overflow
+- Non-atomic operations on multi-byte shared variables
+
+Generate embedded C code following these constraints.
+

package/augment-extensions/coding-standards/c/templates/prompts/kernel.txt

@@ -0,0 +1,175 @@
+You are assisting with Linux kernel module development in C.
+
+## Context
+- Category: {category}
+- C Standard: {c_standard}
+- Target: Linux kernel space programming
+
+## Key Rules for Kernel Development
+
+### 1. Kernel API Usage
+- Use kernel-provided functions (kmalloc, kfree, printk)
+- NO standard library functions (printf, malloc, strcpy)
+- Follow kernel coding style (Documentation/process/coding-style.rst)
+- Use kernel types (u8, u16, u32, u64, __be32, etc.)
+
+### 2. Memory Management
+- Use kmalloc() with appropriate GFP flags (GFP_KERNEL, GFP_ATOMIC)
+- ALWAYS check kmalloc() return value for NULL
+- Free memory with kfree() - no memory leaks
+- Use GFP_ATOMIC in interrupt context, GFP_KERNEL otherwise
+- Consider using slab allocators for frequent allocations
+
+### 3. Locking and Synchronization
+- Protect shared data with spinlocks or mutexes
+- Use spinlocks for short critical sections
+- Use mutexes for longer critical sections (can sleep)
+- NEVER sleep while holding a spinlock
+- Avoid deadlocks: acquire locks in consistent order
+
+### 4. Error Handling
+- Return negative error codes (e.g., -ENOMEM, -EINVAL, -EIO)
+- Use ERR_PTR() and IS_ERR() for pointer returns
+- Clean up resources on error paths (goto error handling)
+- Log errors with pr_err() or dev_err()
+
+### 5. Module Lifecycle
+- Implement module_init() and module_exit()
+- Clean up ALL resources in exit function
+- Use reference counting for shared resources
+- Handle module unload gracefully
+
+{#if rules}
+## Active Rules
+{#each rules}
+- {id}: {description}
+{/each}
+{/if}
+
+## Example Pattern: Basic Kernel Module
+
+```c
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Your Name");
+MODULE_DESCRIPTION("Example kernel module");
+MODULE_VERSION("1.0");
+
+static int __init example_init(void) {
+    pr_info("Example module loaded\n");
+    return 0;
+}
+
+static void __exit example_exit(void) {
+    pr_info("Example module unloaded\n");
+}
+
+module_init(example_init);
+module_exit(example_exit);
+```
+
+## Example Pattern: Character Device Driver
+
+```c
+#include <linux/module.h>
+#include <linux/fs.h>
+#include <linux/cdev.h>
+#include <linux/uaccess.h>
+
+#define DEVICE_NAME "example"
+#define BUFFER_SIZE 1024
+
+static dev_t dev_num;
+static struct cdev example_cdev;
+static char device_buffer[BUFFER_SIZE];
+
+static ssize_t example_read(struct file *filp, char __user *buf,
+                           size_t count, loff_t *f_pos) {
+    size_t to_read = min(count, (size_t)(BUFFER_SIZE - *f_pos));
+    
+    if (*f_pos >= BUFFER_SIZE)
+        return 0;
+    
+    if (copy_to_user(buf, device_buffer + *f_pos, to_read))
+        return -EFAULT;
+    
+    *f_pos += to_read;
+    return to_read;
+}
+
+static ssize_t example_write(struct file *filp, const char __user *buf,
+                            size_t count, loff_t *f_pos) {
+    size_t to_write = min(count, (size_t)(BUFFER_SIZE - *f_pos));
+    
+    if (*f_pos >= BUFFER_SIZE)
+        return -ENOSPC;
+    
+    if (copy_from_user(device_buffer + *f_pos, buf, to_write))
+        return -EFAULT;
+    
+    *f_pos += to_write;
+    return to_write;
+}
+
+static struct file_operations fops = {
+    .owner = THIS_MODULE,
+    .read = example_read,
+    .write = example_write,
+};
+
+static int __init example_init(void) {
+    int ret;
+    
+    ret = alloc_chrdev_region(&dev_num, 0, 1, DEVICE_NAME);
+    if (ret < 0) {
+        pr_err("Failed to allocate device number\n");
+        return ret;
+    }
+    
+    cdev_init(&example_cdev, &fops);
+    ret = cdev_add(&example_cdev, dev_num, 1);
+    if (ret < 0) {
+        unregister_chrdev_region(dev_num, 1);
+        return ret;
+    }
+    
+    pr_info("Character device registered: %d:%d\n",
+            MAJOR(dev_num), MINOR(dev_num));
+    return 0;
+}
+
+static void __exit example_exit(void) {
+    cdev_del(&example_cdev);
+    unregister_chrdev_region(dev_num, 1);
+    pr_info("Character device unregistered\n");
+}
+
+module_init(example_init);
+module_exit(example_exit);
+```
+
+{#if examples}
+## Additional Examples
+{#each examples}
+
+### {title}
+```c
+{code}
+```
+{/each}
+{/if}
+
+## Common Pitfalls to Avoid
+- Using standard library functions (use kernel equivalents)
+- Not checking kmalloc() return values
+- Sleeping while holding spinlocks
+- Memory leaks in error paths
+- Not cleaning up resources in module_exit()
+- Using floating point (not available in kernel)
+- Incorrect GFP flags for memory allocation
+
+Generate kernel module code following these standards.
+